Typos.
[openssl.git] / MacOS / GetHTTPS.src / CPStringUtils.cpp
1 /* ====================================================================
2  * Copyright (c) 1998-1999 The OpenSSL Project.  All rights reserved.
3  *
4  * Redistribution and use in source and binary forms, with or without
5  * modification, are permitted provided that the following conditions
6  * are met:
7  *
8  * 1. Redistributions of source code must retain the above copyright
9  *    notice, this list of conditions and the following disclaimer. 
10  *
11  * 2. Redistributions in binary form must reproduce the above copyright
12  *    notice, this list of conditions and the following disclaimer in
13  *    the documentation and/or other materials provided with the
14  *    distribution.
15  *
16  * 3. All advertising materials mentioning features or use of this
17  *    software must display the following acknowledgment:
18  *    "This product includes software developed by the OpenSSL Project
19  *    for use in the OpenSSL Toolkit. (http://www.openssl.org/)"
20  *
21  * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to
22  *    endorse or promote products derived from this software without
23  *    prior written permission. For written permission, please contact
24  *    openssl-core@openssl.org.
25  *
26  * 5. Products derived from this software may not be called "OpenSSL"
27  *    nor may "OpenSSL" appear in their names without prior written
28  *    permission of the OpenSSL Project.
29  *
30  * 6. Redistributions of any form whatsoever must retain the following
31  *    acknowledgment:
32  *    "This product includes software developed by the OpenSSL Project
33  *    for use in the OpenSSL Toolkit (http://www.openssl.org/)"
34  *
35  * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY
36  * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
37  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
38  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE OpenSSL PROJECT OR
39  * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
40  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
41  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
42  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
43  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
44  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
45  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
46  * OF THE POSSIBILITY OF SUCH DAMAGE.
47  * ====================================================================
48  *
49  * This product includes cryptographic software written by Eric Young
50  * (eay@cryptsoft.com).  This product includes software written by Tim
51  * Hudson (tjh@cryptsoft.com).
52  *
53  */
54  
55  
56  
57  #include "CPStringUtils.hpp"
58 #include "ErrorHandling.hpp"
59
60
61
62 #define kNumberFormatString                     "\p########0.00#######;-########0.00#######"
63
64
65
66 //      Useful utility functions which could be optimized a whole lot
67
68
69 void CopyPStrToCStr(const unsigned char *thePStr,char *theCStr,const int maxCStrLength)
70 {
71 int             i,numPChars;
72
73
74         if (thePStr != nil && theCStr != nil && maxCStrLength > 0)
75         {
76                 numPChars = thePStr[0];
77                 
78                 for (i = 0;;i++)
79                 {
80                         if (i >= numPChars || i >= maxCStrLength - 1)
81                         {
82                                 theCStr[i] = 0;
83                                 
84                                 break;
85                         }
86                         
87                         else
88                         {
89                                 theCStr[i] = thePStr[i + 1];
90                         }
91                 }
92         }
93 }
94
95
96 void CopyPStrToPStr(const unsigned char *theSrcPStr,unsigned char *theDstPStr,const int maxDstStrLength)
97 {
98 int             theMaxDstStrLength;
99
100         
101         theMaxDstStrLength = maxDstStrLength;
102         
103         
104         if (theDstPStr != nil && theSrcPStr != nil && theMaxDstStrLength > 0)
105         {
106                 if (theMaxDstStrLength > 255)
107                 {
108                         theMaxDstStrLength = 255;
109                 }
110                 
111                 
112                 if (theMaxDstStrLength - 1 < theSrcPStr[0])
113                 {
114                         BlockMove(theSrcPStr + 1,theDstPStr + 1,theMaxDstStrLength - 1);
115                         
116                         theDstPStr[0] = theMaxDstStrLength - 1;
117                 }
118                 
119                 else
120                 {
121                         BlockMove(theSrcPStr,theDstPStr,theSrcPStr[0] + 1);
122                 }
123         }
124 }
125
126
127 void CopyCStrToCStr(const char *theSrcCStr,char *theDstCStr,const int maxDstStrLength)
128 {
129 int             i;
130
131
132         if (theDstCStr != nil && theSrcCStr != nil && maxDstStrLength > 0)
133         {
134                 for (i = 0;;i++)
135                 {
136                         if (theSrcCStr[i] == 0 || i >= maxDstStrLength - 1)
137                         {
138                                 theDstCStr[i] = 0;
139                                 
140                                 break;
141                         }
142                         
143                         else
144                         {
145                                 theDstCStr[i] = theSrcCStr[i];
146                         }
147                 }
148         }
149 }
150
151
152
153 void CopyCSubstrToCStr(const char *theSrcCStr,const int maxCharsToCopy,char *theDstCStr,const int maxDstStrLength)
154 {
155 int             i;
156
157
158         if (theDstCStr != nil && theSrcCStr != nil && maxDstStrLength > 0)
159         {
160                 for (i = 0;;i++)
161                 {
162                         if (theSrcCStr[i] == 0 || i >= maxDstStrLength - 1 || i >= maxCharsToCopy)
163                         {
164                                 theDstCStr[i] = 0;
165                                 
166                                 break;
167                         }
168                         
169                         else
170                         {
171                                 theDstCStr[i] = theSrcCStr[i];
172                         }
173                 }
174         }
175 }
176
177
178
179 void CopyCSubstrToPStr(const char *theSrcCStr,const int maxCharsToCopy,unsigned char *theDstPStr,const int maxDstStrLength)
180 {
181 int             i;
182 int             theMaxDstStrLength;
183
184         
185         theMaxDstStrLength = maxDstStrLength;
186
187         if (theDstPStr != nil && theSrcCStr != nil && theMaxDstStrLength > 0)
188         {
189                 if (theMaxDstStrLength > 255)
190                 {
191                         theMaxDstStrLength = 255;
192                 }
193                 
194                 
195                 for (i = 0;;i++)
196                 {
197                         if (theSrcCStr[i] == 0 || i >= theMaxDstStrLength - 1 || i >= maxCharsToCopy)
198                         {
199                                 theDstPStr[0] = i;
200                                 
201                                 break;
202                         }
203                         
204                         else
205                         {
206                                 theDstPStr[i + 1] = theSrcCStr[i];
207                         }
208                 }
209         }
210 }
211
212
213
214 void CopyCStrToPStr(const char *theSrcCStr,unsigned char *theDstPStr,const int maxDstStrLength)
215 {
216 int             i;
217 int             theMaxDstStrLength;
218
219         
220         theMaxDstStrLength = maxDstStrLength;
221
222         if (theDstPStr != nil && theSrcCStr != nil && theMaxDstStrLength > 0)
223         {
224                 if (theMaxDstStrLength > 255)
225                 {
226                         theMaxDstStrLength = 255;
227                 }
228                 
229                 
230                 for (i = 0;;i++)
231                 {
232                         if (i >= theMaxDstStrLength - 1 || theSrcCStr[i] == 0)
233                         {
234                                 theDstPStr[0] = i;
235                                 
236                                 break;
237                         }
238                         
239                         else
240                         {
241                                 theDstPStr[i + 1] = theSrcCStr[i];
242                         }
243                 }
244         }
245 }
246
247
248 void ConcatPStrToCStr(const unsigned char *thePStr,char *theCStr,const int maxCStrLength)
249 {
250 int             i,numPChars,cStrLength;
251
252
253         if (thePStr != nil && theCStr != nil && maxCStrLength > 0)
254         {
255                 for (cStrLength = 0;theCStr[cStrLength] != 0;cStrLength++)
256                 {
257                 
258                 }
259                 
260
261                 numPChars = thePStr[0];
262                 
263                 
264                 for (i = 0;;i++)
265                 {
266                         if (i >= numPChars || cStrLength >= maxCStrLength - 1)
267                         {
268                                 theCStr[cStrLength++] = 0;
269                                 
270                                 break;
271                         }
272                         
273                         else
274                         {
275                                 theCStr[cStrLength++] = thePStr[i + 1];
276                         }
277                 }
278         }
279 }
280
281
282
283 void ConcatPStrToPStr(const unsigned char *theSrcPStr,unsigned char *theDstPStr,const int maxDstStrLength)
284 {
285 int             theMaxDstStrLength;
286
287         
288         theMaxDstStrLength = maxDstStrLength;
289         
290         if (theSrcPStr != nil && theDstPStr != nil && theMaxDstStrLength > 0)
291         {
292                 if (theMaxDstStrLength > 255)
293                 {
294                         theMaxDstStrLength = 255;
295                 }
296                 
297                 
298                 if (theMaxDstStrLength - theDstPStr[0] - 1 < theSrcPStr[0])
299                 {
300                         BlockMove(theSrcPStr + 1,theDstPStr + theDstPStr[0] + 1,theMaxDstStrLength - 1 - theDstPStr[0]);
301                         
302                         theDstPStr[0] = theMaxDstStrLength - 1;
303                 }
304                 
305                 else
306                 {
307                         BlockMove(theSrcPStr + 1,theDstPStr + theDstPStr[0] + 1,theSrcPStr[0]);
308                         
309                         theDstPStr[0] += theSrcPStr[0];
310                 }
311         }
312 }
313
314
315
316 void ConcatCStrToPStr(const char *theSrcCStr,unsigned char *theDstPStr,const int maxDstStrLength)
317 {
318 int             i,thePStrLength;
319 int             theMaxDstStrLength;
320
321         
322         theMaxDstStrLength = maxDstStrLength;
323
324         if (theSrcCStr != nil && theDstPStr != nil && theMaxDstStrLength > 0)
325         {
326                 if (theMaxDstStrLength > 255)
327                 {
328                         theMaxDstStrLength = 255;
329                 }
330                 
331                 
332                 thePStrLength = theDstPStr[0];
333                 
334                 for (i = 0;;i++)
335                 {
336                         if (theSrcCStr[i] == 0 || thePStrLength >= theMaxDstStrLength - 1)
337                         {
338                                 theDstPStr[0] = thePStrLength;
339                                 
340                                 break;
341                         }
342                         
343                         else
344                         {
345                                 theDstPStr[thePStrLength + 1] = theSrcCStr[i];
346                                 
347                                 thePStrLength++;
348                         }
349                 }
350         }
351 }
352
353
354
355 void ConcatCStrToCStr(const char *theSrcCStr,char *theDstCStr,const int maxCStrLength)
356 {
357 int             cStrLength;
358
359
360         if (theSrcCStr != nil && theDstCStr != nil && maxCStrLength > 0)
361         {
362                 for (cStrLength = 0;theDstCStr[cStrLength] != 0;cStrLength++)
363                 {
364                 
365                 }
366                 
367
368                 for (;;)
369                 {
370                         if (*theSrcCStr == 0 || cStrLength >= maxCStrLength - 1)
371                         {
372                                 theDstCStr[cStrLength++] = 0;
373                                 
374                                 break;
375                         }
376                         
377                         else
378                         {
379                                 theDstCStr[cStrLength++] = *theSrcCStr++;
380                         }
381                 }
382         }
383 }
384
385
386
387 void ConcatCharToCStr(const char theChar,char *theDstCStr,const int maxCStrLength)
388 {
389 int             cStrLength;
390
391
392         if (theDstCStr != nil && maxCStrLength > 0)
393         {
394                 cStrLength = CStrLength(theDstCStr);
395                 
396                 if (cStrLength < maxCStrLength - 1)
397                 {
398                         theDstCStr[cStrLength++] = theChar;
399                         theDstCStr[cStrLength++] = '\0';
400                 }
401         }
402 }
403
404
405
406 void ConcatCharToPStr(const char theChar,unsigned char *theDstPStr,const int maxPStrLength)
407 {
408 int             pStrLength;
409
410
411         if (theDstPStr != nil && maxPStrLength > 0)
412         {
413                 pStrLength = PStrLength(theDstPStr);
414                 
415                 if (pStrLength < maxPStrLength - 1 && pStrLength < 255)
416                 {
417                         theDstPStr[pStrLength + 1] = theChar;
418                         theDstPStr[0] += 1;
419                 }
420         }
421 }
422
423
424
425
426 int CompareCStrs(const char *theFirstCStr,const char *theSecondCStr,const Boolean ignoreCase)
427 {
428 int             returnValue;
429 char    firstChar,secondChar;
430
431         
432         returnValue = 0;
433         
434         
435         if (theFirstCStr != nil && theSecondCStr != nil)
436         {
437                 for (;;)
438                 {
439                         firstChar = *theFirstCStr;
440                         secondChar = *theSecondCStr;
441                         
442                         if (ignoreCase == true)
443                         {
444                                 if (firstChar >= 'A' && firstChar <= 'Z')
445                                 {
446                                         firstChar = 'a' + (firstChar - 'A');
447                                 }
448                                 
449                                 if (secondChar >= 'A' && secondChar <= 'Z')
450                                 {
451                                         secondChar = 'a' + (secondChar - 'A');
452                                 }
453                         }
454                         
455                         
456                         if (firstChar == 0 && secondChar != 0)
457                         {
458                                 returnValue = -1;
459                                 
460                                 break;
461                         }
462                         
463                         else if (firstChar != 0 && secondChar == 0)
464                         {
465                                 returnValue = 1;
466                                 
467                                 break;
468                         }
469                         
470                         else if (firstChar == 0 && secondChar == 0)
471                         {
472                                 returnValue = 0;
473                                 
474                                 break;
475                         }
476                         
477                         else if (firstChar < secondChar)
478                         {
479                                 returnValue = -1;
480                                 
481                                 break;
482                         }
483                         
484                         else if (firstChar > secondChar)
485                         {
486                                 returnValue = 1;
487                                 
488                                 break;
489                         }
490                         
491                         theFirstCStr++;
492                         theSecondCStr++;
493                 }
494         }
495         
496         
497         return(returnValue);
498 }
499
500
501
502 Boolean CStrsAreEqual(const char *theFirstCStr,const char *theSecondCStr,const Boolean ignoreCase)
503 {
504         if (CompareCStrs(theFirstCStr,theSecondCStr,ignoreCase) == 0)
505         {
506                 return true;
507         }
508         
509         else
510         {
511                 return false;
512         }
513 }
514
515
516 Boolean PStrsAreEqual(const unsigned char *theFirstPStr,const unsigned char *theSecondPStr,const Boolean ignoreCase)
517 {
518         if (ComparePStrs(theFirstPStr,theSecondPStr,ignoreCase) == 0)
519         {
520                 return true;
521         }
522         
523         else
524         {
525                 return false;
526         }
527 }
528
529
530
531 int ComparePStrs(const unsigned char *theFirstPStr,const unsigned char *theSecondPStr,const Boolean ignoreCase)
532 {
533 int             i,returnValue;
534 char    firstChar,secondChar;
535
536         
537         returnValue = 0;
538         
539         
540         if (theFirstPStr != nil && theSecondPStr != nil)
541         {
542                 for (i = 1;;i++)
543                 {
544                         firstChar = theFirstPStr[i];
545                         secondChar = theSecondPStr[i];
546
547                         if (ignoreCase == true)
548                         {
549                                 if (firstChar >= 'A' && firstChar <= 'Z')
550                                 {
551                                         firstChar = 'a' + (firstChar - 'A');
552                                 }
553                                 
554                                 if (secondChar >= 'A' && secondChar <= 'Z')
555                                 {
556                                         secondChar = 'a' + (secondChar - 'A');
557                                 }
558                         }
559
560
561                         if (theFirstPStr[0] < i && theSecondPStr[0] >= i)
562                         {
563                                 returnValue = -1;
564                                 
565                                 break;
566                         }
567                         
568                         else if (theFirstPStr[0] >= i && theSecondPStr[0] < i)
569                         {
570                                 returnValue = 1;
571                                 
572                                 break;
573                         }
574                         
575                         else if (theFirstPStr[0] < i && theSecondPStr[0] < i)
576                         {
577                                 returnValue = 0;
578                                 
579                                 break;
580                         }
581                         
582                         else if (firstChar < secondChar)
583                         {
584                                 returnValue = -1;
585                                 
586                                 break;
587                         }
588                         
589                         else if (firstChar > secondChar)
590                         {
591                                 returnValue = 1;
592                                 
593                                 break;
594                         }
595                 }
596         }
597         
598         
599         return(returnValue);
600 }
601
602
603
604 int CompareCStrToPStr(const char *theCStr,const unsigned char *thePStr,const Boolean ignoreCase)
605 {
606 int             returnValue;
607 char    tempString[256];
608
609         
610         returnValue = 0;
611         
612         if (theCStr != nil && thePStr != nil)
613         {
614                 CopyPStrToCStr(thePStr,tempString,sizeof(tempString));
615                 
616                 returnValue = CompareCStrs(theCStr,tempString,ignoreCase);
617         }
618         
619         
620         return(returnValue);
621 }
622
623
624
625 void ConcatLongIntToCStr(const long theNum,char *theCStr,const int maxCStrLength,const int numDigits)
626 {
627 Str255          theStr255;
628
629
630         NumToString(theNum,theStr255);
631
632
633         if (numDigits > 0)
634         {
635         int     charsToInsert;
636         
637                 
638                 charsToInsert = numDigits - PStrLength(theStr255);
639                 
640                 if (charsToInsert > 0)
641                 {
642                 char    tempString[256];
643                         
644                         CopyCStrToCStr("",tempString,sizeof(tempString));
645                         
646                         for (;charsToInsert > 0;charsToInsert--)
647                         {
648                                 ConcatCStrToCStr("0",tempString,sizeof(tempString));
649                         }
650                         
651                         ConcatPStrToCStr(theStr255,tempString,sizeof(tempString));
652                         
653                         CopyCStrToPStr(tempString,theStr255,sizeof(theStr255));
654                 }
655         }
656
657
658         ConcatPStrToCStr(theStr255,theCStr,maxCStrLength);
659 }
660
661
662
663
664 void ConcatLongIntToPStr(const long theNum,unsigned char *thePStr,const int maxPStrLength,const int numDigits)
665 {
666 Str255          theStr255;
667
668
669         NumToString(theNum,theStr255);
670
671
672         if (numDigits > 0)
673         {
674         int     charsToInsert;
675         
676                 
677                 charsToInsert = numDigits - PStrLength(theStr255);
678                 
679                 if (charsToInsert > 0)
680                 {
681                 char    tempString[256];
682                         
683                         CopyCStrToCStr("",tempString,sizeof(tempString));
684                         
685                         for (;charsToInsert > 0;charsToInsert--)
686                         {
687                                 ConcatCStrToCStr("0",tempString,sizeof(tempString));
688                         }
689                         
690                         ConcatPStrToCStr(theStr255,tempString,sizeof(tempString));
691                         
692                         CopyCStrToPStr(tempString,theStr255,sizeof(theStr255));
693                 }
694         }
695
696
697         ConcatPStrToPStr(theStr255,thePStr,maxPStrLength);
698 }
699
700
701
702 void CopyCStrAndConcatLongIntToCStr(const char *theSrcCStr,const long theNum,char *theDstCStr,const int maxDstStrLength)
703 {
704         CopyCStrToCStr(theSrcCStr,theDstCStr,maxDstStrLength);
705         
706         ConcatLongIntToCStr(theNum,theDstCStr,maxDstStrLength);
707 }
708
709
710
711 void CopyLongIntToCStr(const long theNum,char *theCStr,const int maxCStrLength,const int numDigits)
712 {
713 Str255          theStr255;
714
715
716         NumToString(theNum,theStr255);
717
718
719         if (numDigits > 0)
720         {
721         int     charsToInsert;
722         
723                 
724                 charsToInsert = numDigits - PStrLength(theStr255);
725                 
726                 if (charsToInsert > 0)
727                 {
728                 char    tempString[256];
729                         
730                         CopyCStrToCStr("",tempString,sizeof(tempString));
731                         
732                         for (;charsToInsert > 0;charsToInsert--)
733                         {
734                                 ConcatCStrToCStr("0",tempString,sizeof(tempString));
735                         }
736                         
737                         ConcatPStrToCStr(theStr255,tempString,sizeof(tempString));
738                         
739                         CopyCStrToPStr(tempString,theStr255,sizeof(theStr255));
740                 }
741         }
742
743
744         CopyPStrToCStr(theStr255,theCStr,maxCStrLength);
745 }
746
747
748
749
750
751 void CopyUnsignedLongIntToCStr(const unsigned long theNum,char *theCStr,const int maxCStrLength)
752 {
753 char                    tempString[256];
754 int                             srcCharIndex,dstCharIndex;
755 unsigned long   tempNum,quotient,remainder;
756
757         
758         if (theNum == 0)
759         {
760                 CopyCStrToCStr("0",theCStr,maxCStrLength);
761         }
762         
763         else
764         {
765                 srcCharIndex = 0;
766                 
767                 tempNum = theNum;
768                 
769                 for (;;)
770                 {
771                         if (srcCharIndex >= sizeof(tempString) - 1 || tempNum == 0)
772                         {
773                                 for (dstCharIndex = 0;;)
774                                 {
775                                         if (dstCharIndex >= maxCStrLength - 1 || srcCharIndex <= 0)
776                                         {
777                                                 theCStr[dstCharIndex] = 0;
778                                                 
779                                                 break;
780                                         }
781                                         
782                                         theCStr[dstCharIndex++] = tempString[--srcCharIndex];
783                                 }
784                                 
785                                 break;
786                         }
787                         
788
789                         quotient = tempNum / 10;
790                         
791                         remainder = tempNum - (quotient * 10);
792                         
793                         tempString[srcCharIndex] = '0' + remainder;
794                         
795                         srcCharIndex++;
796                         
797                         tempNum = quotient;
798                 }
799         }
800 }
801
802
803
804
805 void CopyLongIntToPStr(const long theNum,unsigned char *thePStr,const int maxPStrLength,const int numDigits)
806 {
807 char    tempString[256];
808
809
810         CopyLongIntToCStr(theNum,tempString,sizeof(tempString),numDigits);
811         
812         CopyCStrToPStr(tempString,thePStr,maxPStrLength);
813 }
814
815
816
817 OSErr CopyLongIntToNewHandle(const long inTheLongInt,Handle *theHandle)
818 {
819 OSErr           errCode = noErr;
820 char            tempString[32];
821         
822         
823         CopyLongIntToCStr(inTheLongInt,tempString,sizeof(tempString));
824         
825         errCode = CopyCStrToNewHandle(tempString,theHandle);
826
827         return(errCode);
828 }
829
830
831 OSErr CopyLongIntToExistingHandle(const long inTheLongInt,Handle theHandle)
832 {
833 OSErr           errCode = noErr;
834 char            tempString[32];
835         
836         
837         CopyLongIntToCStr(inTheLongInt,tempString,sizeof(tempString));
838         
839         errCode = CopyCStrToExistingHandle(tempString,theHandle);
840
841         return(errCode);
842 }
843
844
845
846
847 OSErr CopyCStrToExistingHandle(const char *theCString,Handle theHandle)
848 {
849 OSErr   errCode = noErr;
850 long    stringLength;
851
852         
853         if (theCString == nil)
854         {
855                 SetErrorMessageAndBail(("CopyCStrToExistingHandle: Bad parameter, theCString == nil"));
856         }
857
858         if (theHandle == nil)
859         {
860                 SetErrorMessageAndBail(("CopyCStrToExistingHandle: Bad parameter, theHandle == nil"));
861         }
862
863         if (*theHandle == nil)
864         {
865                 SetErrorMessageAndBail(("CopyCStrToExistingHandle: Bad parameter, *theHandle == nil"));
866         }
867
868
869
870         stringLength = CStrLength(theCString) + 1;
871         
872         SetHandleSize(theHandle,stringLength);
873         
874         if (GetHandleSize(theHandle) < stringLength)
875         {
876                 SetErrorMessageAndLongIntAndBail("CopyCStrToExistingHandle: Can't set Handle size, MemError() = ",MemError());
877         }
878         
879         
880         ::BlockMove(theCString,*theHandle,stringLength);
881         
882
883 EXITPOINT:
884         
885         return(errCode);
886 }
887
888
889
890
891
892 OSErr CopyCStrToNewHandle(const char *theCString,Handle *theHandle)
893 {
894 OSErr   errCode = noErr;
895 long    stringLength;
896
897         
898         if (theCString == nil)
899         {
900                 SetErrorMessageAndBail(("CopyCStrToNewHandle: Bad parameter, theCString == nil"));
901         }
902
903         if (theHandle == nil)
904         {
905                 SetErrorMessageAndBail(("CopyCStrToNewHandle: Bad parameter, theHandle == nil"));
906         }
907
908
909
910         stringLength = CStrLength(theCString) + 1;
911         
912         *theHandle = NewHandle(stringLength);
913         
914         if (*theHandle == nil)
915         {
916                 SetErrorMessageAndLongIntAndBail("CopyCStrToNewHandle: Can't allocate Handle, MemError() = ",MemError());
917         }
918         
919         
920         ::BlockMove(theCString,**theHandle,stringLength);
921         
922
923 EXITPOINT:
924         
925         return(errCode);
926 }
927
928
929
930 OSErr CopyPStrToNewHandle(const unsigned char *thePString,Handle *theHandle)
931 {
932 OSErr   errCode = noErr;
933 long    stringLength;
934
935         
936         if (thePString == nil)
937         {
938                 SetErrorMessageAndBail(("CopyPStrToNewHandle: Bad parameter, thePString == nil"));
939         }
940
941         if (theHandle == nil)
942         {
943                 SetErrorMessageAndBail(("CopyPStrToNewHandle: Bad parameter, theHandle == nil"));
944         }
945
946
947
948         stringLength = PStrLength(thePString) + 1;
949         
950         *theHandle = NewHandle(stringLength);
951         
952         if (*theHandle == nil)
953         {
954                 SetErrorMessageAndLongIntAndBail("CopyPStrToNewHandle: Can't allocate Handle, MemError() = ",MemError());
955         }
956         
957         
958         if (stringLength > 1)
959         {
960                 BlockMove(thePString + 1,**theHandle,stringLength - 1);
961         }
962         
963         (**theHandle)[stringLength - 1] = 0;
964         
965
966 EXITPOINT:
967         
968         return(errCode);
969 }
970
971
972 OSErr AppendPStrToHandle(const unsigned char *thePString,Handle theHandle,long *currentLength)
973 {
974 OSErr           errCode = noErr;
975 char            tempString[256];
976
977         
978         CopyPStrToCStr(thePString,tempString,sizeof(tempString));
979         
980         errCode = AppendCStrToHandle(tempString,theHandle,currentLength);
981         
982
983 EXITPOINT:
984         
985         return(errCode);
986 }
987
988
989
990 OSErr AppendCStrToHandle(const char *theCString,Handle theHandle,long *currentLength,long *maxLength)
991 {
992 OSErr           errCode = noErr;
993 long            handleMaxLength,handleCurrentLength,stringLength,byteCount;
994
995
996         if (theCString == nil)
997         {
998                 SetErrorMessageAndBail(("AppendCStrToHandle: Bad parameter, theCString == nil"));
999         }
1000
1001         if (theHandle == nil)
1002         {
1003                 SetErrorMessageAndBail(("AppendCStrToHandle: Bad parameter, theHandle == nil"));
1004         }
1005         
1006         
1007         if (maxLength != nil)
1008         {
1009                 handleMaxLength = *maxLength;
1010         }
1011         
1012         else
1013         {
1014                 handleMaxLength = GetHandleSize(theHandle);
1015         }
1016         
1017         
1018         if (currentLength != nil && *currentLength >= 0)
1019         {
1020                 handleCurrentLength = *currentLength;
1021         }
1022         
1023         else
1024         {
1025                 handleCurrentLength = CStrLength(*theHandle);
1026         }
1027         
1028         
1029         stringLength = CStrLength(theCString);
1030         
1031         byteCount = handleCurrentLength + stringLength + 1;
1032         
1033         if (byteCount > handleMaxLength)
1034         {
1035                 SetHandleSize(theHandle,handleCurrentLength + stringLength + 1);
1036                 
1037                 if (maxLength != nil)
1038                 {
1039                         *maxLength = GetHandleSize(theHandle);
1040                         
1041                         handleMaxLength = *maxLength;
1042                 }
1043                 
1044                 else
1045                 {
1046                         handleMaxLength = GetHandleSize(theHandle);
1047                 }
1048
1049                 if (byteCount > handleMaxLength)
1050                 {
1051                         SetErrorMessageAndLongIntAndBail("AppendCStrToHandle: Can't increase Handle allocation, MemError() = ",MemError());
1052                 }
1053         }
1054         
1055         
1056         BlockMove(theCString,*theHandle + handleCurrentLength,stringLength + 1);
1057         
1058         
1059         if (currentLength != nil)
1060         {
1061                 *currentLength += stringLength;
1062         }
1063
1064
1065         errCode = noErr;
1066         
1067         
1068 EXITPOINT:
1069
1070         return(errCode);
1071 }
1072
1073
1074
1075 OSErr AppendCharsToHandle(const char *theChars,const int numChars,Handle theHandle,long *currentLength,long *maxLength)
1076 {
1077 OSErr           errCode = noErr;
1078 long            handleMaxLength,handleCurrentLength,byteCount;
1079
1080
1081         if (theChars == nil)
1082         {
1083                 SetErrorMessageAndBail(("AppendCharsToHandle: Bad parameter, theChars == nil"));
1084         }
1085
1086         if (theHandle == nil)
1087         {
1088                 SetErrorMessageAndBail(("AppendCharsToHandle: Bad parameter, theHandle == nil"));
1089         }
1090         
1091         
1092         if (maxLength != nil)
1093         {
1094                 handleMaxLength = *maxLength;
1095         }
1096         
1097         else
1098         {
1099                 handleMaxLength = GetHandleSize(theHandle);
1100         }
1101         
1102         
1103         if (currentLength != nil && *currentLength >= 0)
1104         {
1105                 handleCurrentLength = *currentLength;
1106         }
1107         
1108         else
1109         {
1110                 handleCurrentLength = CStrLength(*theHandle);
1111         }
1112         
1113         
1114         byteCount = handleCurrentLength + numChars + 1;
1115         
1116         if (byteCount > handleMaxLength)
1117         {
1118                 SetHandleSize(theHandle,handleCurrentLength + numChars + 1);
1119                 
1120                 if (maxLength != nil)
1121                 {
1122                         *maxLength = GetHandleSize(theHandle);
1123                         
1124                         handleMaxLength = *maxLength;
1125                 }
1126                 
1127                 else
1128                 {
1129                         handleMaxLength = GetHandleSize(theHandle);
1130                 }
1131
1132                 if (byteCount > handleMaxLength)
1133                 {
1134                         SetErrorMessageAndLongIntAndBail("AppendCharsToHandle: Can't increase Handle allocation, MemError() = ",MemError());
1135                 }
1136         }
1137         
1138         
1139         BlockMove(theChars,*theHandle + handleCurrentLength,numChars);
1140         
1141         (*theHandle)[handleCurrentLength + numChars] = '\0';
1142         
1143         if (currentLength != nil)
1144         {
1145                 *currentLength += numChars;
1146         }
1147
1148
1149         errCode = noErr;
1150         
1151         
1152 EXITPOINT:
1153
1154         return(errCode);
1155 }
1156
1157
1158
1159 OSErr AppendLongIntToHandle(const long inTheLongInt,Handle theHandle,long *currentLength)
1160 {
1161 OSErr           errCode = noErr;
1162 char            tempString[32];
1163         
1164         
1165         CopyLongIntToCStr(inTheLongInt,tempString,sizeof(tempString));
1166         
1167         errCode = AppendCStrToHandle(tempString,theHandle,currentLength);
1168
1169         return(errCode);
1170 }
1171
1172
1173
1174
1175 long CStrLength(const char *theCString)
1176 {
1177 long    cStrLength = 0;
1178
1179         
1180         if (theCString != nil)
1181         {
1182                 for (cStrLength = 0;theCString[cStrLength] != 0;cStrLength++)
1183                 {
1184                 
1185                 }
1186         }
1187         
1188         
1189         return(cStrLength);
1190 }
1191
1192
1193
1194 long PStrLength(const unsigned char *thePString)
1195 {
1196 long    pStrLength = 0;
1197
1198         
1199         if (thePString != nil)
1200         {
1201                 pStrLength = thePString[0];
1202         }
1203         
1204         
1205         return(pStrLength);
1206 }
1207
1208
1209
1210
1211
1212 void ZeroMem(void *theMemPtr,const unsigned long numBytes)
1213 {
1214 unsigned char   *theBytePtr;
1215 unsigned long   *theLongPtr;
1216 unsigned long   numSingleBytes;
1217 unsigned long   theNumBytes;
1218
1219         
1220         theNumBytes = numBytes;
1221         
1222         if (theMemPtr != nil && theNumBytes > 0)
1223         {
1224                 theBytePtr = (unsigned char     *) theMemPtr;
1225                 
1226                 numSingleBytes = (unsigned long) theBytePtr & 0x0003;
1227                 
1228                 while (numSingleBytes > 0)
1229                 {
1230                         *theBytePtr++ = 0;
1231                         
1232                         theNumBytes--;
1233                         numSingleBytes--;
1234                 }
1235                 
1236
1237                 theLongPtr = (unsigned long     *) theBytePtr;
1238                 
1239                 while (theNumBytes >= 4)
1240                 {
1241                         *theLongPtr++ = 0;
1242                         
1243                         theNumBytes -= 4;
1244                 }
1245                 
1246                 
1247                 theBytePtr = (unsigned char     *) theLongPtr;
1248                 
1249                 while (theNumBytes > 0)
1250                 {
1251                         *theBytePtr++ = 0;
1252                         
1253                         theNumBytes--;
1254                 }
1255         }
1256 }
1257
1258
1259
1260
1261 char *FindCharInCStr(const char theChar,const char *theCString)
1262 {
1263 char    *theStringSearchPtr;
1264
1265         
1266         theStringSearchPtr = (char      *) theCString;
1267         
1268         if (theStringSearchPtr != nil)
1269         {
1270                 while (*theStringSearchPtr != '\0' && *theStringSearchPtr != theChar)
1271                 {
1272                         theStringSearchPtr++;
1273                 }
1274                 
1275                 if (*theStringSearchPtr == '\0')
1276                 {
1277                         theStringSearchPtr = nil;
1278                 }
1279         }
1280         
1281         return(theStringSearchPtr);
1282 }
1283
1284
1285
1286 long FindCharOffsetInCStr(const char theChar,const char *theCString,const Boolean inIgnoreCase)
1287 {
1288 long    theOffset = -1;
1289
1290
1291         if (theCString != nil)
1292         {
1293                 theOffset = 0;
1294                 
1295
1296                 if (inIgnoreCase)
1297                 {
1298                 char    searchChar = theChar;
1299                 
1300                         if (searchChar >= 'a' && searchChar <= 'z')
1301                         {
1302                                 searchChar = searchChar - 'a' + 'A';
1303                         }
1304                         
1305                         
1306                         while (*theCString != 0)
1307                         {
1308                         char    currentChar = *theCString;
1309                         
1310                                 if (currentChar >= 'a' && currentChar <= 'z')
1311                                 {
1312                                         currentChar = currentChar - 'a' + 'A';
1313                                 }
1314                         
1315                                 if (currentChar == searchChar)
1316                                 {
1317                                         break;
1318                                 }
1319                                 
1320                                 theCString++;
1321                                 theOffset++;
1322                         }
1323                 }
1324                 
1325                 else
1326                 {
1327                         while (*theCString != 0 && *theCString != theChar)
1328                         {
1329                                 theCString++;
1330                                 theOffset++;
1331                         }
1332                 }
1333                 
1334                 if (*theCString == 0)
1335                 {
1336                         theOffset = -1;
1337                 }
1338         }
1339         
1340         return(theOffset);
1341 }
1342
1343
1344 long FindCStrOffsetInCStr(const char *theCSubstring,const char *theCString,const Boolean inIgnoreCase)
1345 {
1346 long    theOffset = -1;
1347
1348
1349         if (theCSubstring != nil && theCString != nil)
1350         {
1351                 for (theOffset = 0;;theOffset++)
1352                 {
1353                         if (theCString[theOffset] == 0)
1354                         {
1355                                 theOffset = -1;
1356                                 
1357                                 goto EXITPOINT;
1358                         }
1359                         
1360                         
1361                         for (const char *tempSubstringPtr = theCSubstring,*tempCStringPtr = theCString + theOffset;;tempSubstringPtr++,tempCStringPtr++)
1362                         {
1363                                 if (*tempSubstringPtr == 0)
1364                                 {
1365                                         goto EXITPOINT;
1366                                 }
1367                                 
1368                                 else if (*tempCStringPtr == 0)
1369                                 {
1370                                         break;
1371                                 }
1372                         
1373                         char    searchChar = *tempSubstringPtr;
1374                         char    currentChar = *tempCStringPtr;
1375                         
1376                                 if (inIgnoreCase && searchChar >= 'a' && searchChar <= 'z')
1377                                 {
1378                                         searchChar = searchChar - 'a' + 'A';
1379                                 }
1380                                 
1381                                 if (inIgnoreCase && currentChar >= 'a' && currentChar <= 'z')
1382                                 {
1383                                         currentChar = currentChar - 'a' + 'A';
1384                                 }
1385                                 
1386                                 if (currentChar != searchChar)
1387                                 {
1388                                         break;
1389                                 }
1390                         }
1391                 }
1392                 
1393                 theOffset = -1;
1394         }
1395
1396
1397 EXITPOINT:
1398         
1399         return(theOffset);
1400 }
1401
1402
1403
1404 void InsertCStrIntoCStr(const char *theSrcCStr,const int theInsertionOffset,char *theDstCStr,const int maxDstStrLength)
1405 {
1406 int             currentLength;
1407 int             insertLength;
1408 int             numCharsToInsert;
1409 int             numCharsToShift;
1410
1411         
1412         if (theDstCStr != nil && theSrcCStr != nil && maxDstStrLength > 0 && theInsertionOffset < maxDstStrLength - 1)
1413         {
1414                 currentLength = CStrLength(theDstCStr);
1415                 
1416                 insertLength = CStrLength(theSrcCStr);
1417                 
1418
1419                 if (theInsertionOffset + insertLength < maxDstStrLength - 1)
1420                 {
1421                         numCharsToInsert = insertLength;
1422                 }
1423                 
1424                 else
1425                 {
1426                         numCharsToInsert = maxDstStrLength - 1 - theInsertionOffset;
1427                 }
1428                 
1429
1430                 if (numCharsToInsert + currentLength < maxDstStrLength - 1)
1431                 {
1432                         numCharsToShift = currentLength - theInsertionOffset;
1433                 }
1434                 
1435                 else
1436                 {
1437                         numCharsToShift = maxDstStrLength - 1 - theInsertionOffset - numCharsToInsert;
1438                 }
1439
1440                 
1441                 if (numCharsToShift > 0)
1442                 {
1443                         BlockMove(theDstCStr + theInsertionOffset,theDstCStr + theInsertionOffset + numCharsToInsert,numCharsToShift);
1444                 }
1445                 
1446                 if (numCharsToInsert > 0)
1447                 {
1448                         BlockMove(theSrcCStr,theDstCStr + theInsertionOffset,numCharsToInsert);
1449                 }
1450                 
1451                 theDstCStr[theInsertionOffset + numCharsToInsert + numCharsToShift] = 0;
1452         }
1453 }
1454
1455
1456
1457 void InsertPStrIntoCStr(const unsigned char *theSrcPStr,const int theInsertionOffset,char *theDstCStr,const int maxDstStrLength)
1458 {
1459 int             currentLength;
1460 int             insertLength;
1461 int             numCharsToInsert;
1462 int             numCharsToShift;
1463
1464         
1465         if (theDstCStr != nil && theSrcPStr != nil && maxDstStrLength > 0 && theInsertionOffset < maxDstStrLength - 1)
1466         {
1467                 currentLength = CStrLength(theDstCStr);
1468                 
1469                 insertLength = PStrLength(theSrcPStr);
1470                 
1471
1472                 if (theInsertionOffset + insertLength < maxDstStrLength - 1)
1473                 {
1474                         numCharsToInsert = insertLength;
1475                 }
1476                 
1477                 else
1478                 {
1479                         numCharsToInsert = maxDstStrLength - 1 - theInsertionOffset;
1480                 }
1481                 
1482
1483                 if (numCharsToInsert + currentLength < maxDstStrLength - 1)
1484                 {
1485                         numCharsToShift = currentLength - theInsertionOffset;
1486                 }
1487                 
1488                 else
1489                 {
1490                         numCharsToShift = maxDstStrLength - 1 - theInsertionOffset - numCharsToInsert;
1491                 }
1492
1493                 
1494                 if (numCharsToShift > 0)
1495                 {
1496                         BlockMove(theDstCStr + theInsertionOffset,theDstCStr + theInsertionOffset + numCharsToInsert,numCharsToShift);
1497                 }
1498                 
1499                 if (numCharsToInsert > 0)
1500                 {
1501                         BlockMove(theSrcPStr + 1,theDstCStr + theInsertionOffset,numCharsToInsert);
1502                 }
1503                 
1504                 theDstCStr[theInsertionOffset + numCharsToInsert + numCharsToShift] = 0;
1505         }
1506 }
1507
1508
1509
1510 OSErr InsertCStrIntoHandle(const char *theCString,Handle theHandle,const long inInsertOffset)
1511 {
1512 OSErr   errCode;
1513 int             currentLength;
1514 int             insertLength;
1515
1516         
1517         SetErrorMessageAndBailIfNil(theCString,"InsertCStrIntoHandle: Bad parameter, theCString == nil");
1518
1519         SetErrorMessageAndBailIfNil(theHandle,"InsertCStrIntoHandle: Bad parameter, theHandle == nil");
1520         
1521         currentLength = CStrLength(*theHandle);
1522         
1523         if (currentLength + 1 > ::GetHandleSize(theHandle))
1524         {
1525                 SetErrorMessageAndBail("InsertCStrIntoHandle: Handle has been overflowed");
1526         }
1527         
1528         if (inInsertOffset > currentLength)
1529         {
1530                 SetErrorMessageAndBail("InsertCStrIntoHandle: Insertion offset is greater than string length");
1531         }
1532         
1533         insertLength = CStrLength(theCString);
1534         
1535         ::SetHandleSize(theHandle,currentLength + 1 + insertLength);
1536         
1537         if (::GetHandleSize(theHandle) < currentLength + 1 + insertLength)
1538         {
1539                 SetErrorMessageAndLongIntAndBail("InsertCStrIntoHandle: Can't expand storage for Handle, MemError() = ",MemError());
1540         }
1541         
1542         ::BlockMove(*theHandle + inInsertOffset,*theHandle + inInsertOffset + insertLength,currentLength - inInsertOffset + 1);
1543         
1544         ::BlockMove(theCString,*theHandle + inInsertOffset,insertLength);
1545
1546
1547         errCode = noErr;
1548         
1549         
1550 EXITPOINT:
1551
1552         return(errCode);
1553 }
1554
1555
1556
1557
1558 void CopyCStrAndInsert1LongIntIntoCStr(const char *theSrcCStr,const long theNum,char *theDstCStr,const int maxDstStrLength)
1559 {
1560         CopyCStrAndInsertCStrLongIntIntoCStr(theSrcCStr,nil,theNum,theDstCStr,maxDstStrLength);
1561 }
1562
1563
1564 void CopyCStrAndInsert2LongIntsIntoCStr(const char *theSrcCStr,const long long1,const long long2,char *theDstCStr,const int maxDstStrLength)
1565 {
1566 const long      theLongInts[] = { long1,long2 };
1567
1568         CopyCStrAndInsertCStrsLongIntsIntoCStr(theSrcCStr,nil,theLongInts,theDstCStr,maxDstStrLength);
1569 }
1570
1571
1572 void CopyCStrAndInsert3LongIntsIntoCStr(const char *theSrcCStr,const long long1,const long long2,const long long3,char *theDstCStr,const int maxDstStrLength)
1573 {
1574 const long      theLongInts[] = { long1,long2,long3 };
1575
1576         CopyCStrAndInsertCStrsLongIntsIntoCStr(theSrcCStr,nil,theLongInts,theDstCStr,maxDstStrLength);
1577 }
1578
1579
1580 void CopyCStrAndInsertCStrIntoCStr(const char *theSrcCStr,const char *theInsertCStr,char *theDstCStr,const int maxDstStrLength)
1581 {
1582 const char      *theCStrs[2] = { theInsertCStr,nil };
1583
1584         CopyCStrAndInsertCStrsLongIntsIntoCStr(theSrcCStr,theCStrs,nil,theDstCStr,maxDstStrLength);
1585 }
1586
1587
1588
1589 void CopyCStrAndInsertCStrLongIntIntoCStr(const char *theSrcCStr,const char *theInsertCStr,const long theNum,char *theDstCStr,const int maxDstStrLength)
1590 {
1591 const char      *theCStrs[2] = { theInsertCStr,nil };
1592 const long      theLongInts[1] = { theNum };
1593
1594         CopyCStrAndInsertCStrsLongIntsIntoCStr(theSrcCStr,theCStrs,theLongInts,theDstCStr,maxDstStrLength);
1595 }
1596
1597
1598
1599 void CopyCStrAndInsertCStrsLongIntsIntoCStr(const char *theSrcCStr,const char **theInsertCStrs,const long *theLongInts,char *theDstCStr,const int maxDstStrLength)
1600 {
1601 int                     dstCharIndex,srcCharIndex,theMaxDstStrLength;
1602 int                     theCStrIndex = 0;
1603 int                     theLongIntIndex = 0;
1604
1605         
1606         theMaxDstStrLength = maxDstStrLength;
1607         
1608         if (theDstCStr != nil && theSrcCStr != nil && theMaxDstStrLength > 0)
1609         {
1610                 dstCharIndex = 0;
1611                 
1612                 srcCharIndex = 0;
1613                 
1614                 
1615                 //      Allow room for NULL at end of string
1616                 
1617                 theMaxDstStrLength--;
1618                 
1619                 
1620                 for (;;)
1621                 {
1622                         //      Hit end of buffer?
1623                         
1624                         if (dstCharIndex >= theMaxDstStrLength)
1625                         {
1626                                 theDstCStr[dstCharIndex++] = 0;
1627                                 
1628                                 goto EXITPOINT;
1629                         }
1630                         
1631                         //      End of source string?
1632                         
1633                         else if (theSrcCStr[srcCharIndex] == 0)
1634                         {
1635                                 theDstCStr[dstCharIndex++] = 0;
1636                                 
1637                                 goto EXITPOINT;
1638                         }
1639                         
1640                         //      Did we find a '%s'?
1641                         
1642                         else if (theInsertCStrs != nil && theInsertCStrs[theCStrIndex] != nil && theSrcCStr[srcCharIndex] == '%' && theSrcCStr[srcCharIndex + 1] == 's')
1643                         {
1644                                 //      Skip over the '%s'
1645                                 
1646                                 srcCharIndex += 2;
1647                                 
1648                                 
1649                                 //      Terminate the dest string and then concat the string
1650                                 
1651                                 theDstCStr[dstCharIndex] = 0;
1652                                 
1653                                 ConcatCStrToCStr(theInsertCStrs[theCStrIndex],theDstCStr,theMaxDstStrLength);
1654                                 
1655                                 dstCharIndex = CStrLength(theDstCStr);
1656                                 
1657                                 theCStrIndex++;
1658                         }
1659                         
1660                         //      Did we find a '%ld'?
1661                         
1662                         else if (theLongInts != nil && theSrcCStr[srcCharIndex] == '%' && theSrcCStr[srcCharIndex + 1] == 'l' && theSrcCStr[srcCharIndex + 2] == 'd')
1663                         {
1664                                 //      Skip over the '%ld'
1665                                 
1666                                 srcCharIndex += 3;
1667                                 
1668                                 
1669                                 //      Terminate the dest string and then concat the number
1670                                 
1671                                 theDstCStr[dstCharIndex] = 0;
1672                                 
1673                                 ConcatLongIntToCStr(theLongInts[theLongIntIndex],theDstCStr,theMaxDstStrLength);
1674                                 
1675                                 theLongIntIndex++;
1676                                 
1677                                 dstCharIndex = CStrLength(theDstCStr);
1678                         }
1679                         
1680                         else
1681                         {
1682                                 theDstCStr[dstCharIndex++] = theSrcCStr[srcCharIndex++];
1683                         }
1684                 }
1685         }
1686
1687
1688
1689 EXITPOINT:
1690
1691         return;
1692 }
1693
1694
1695
1696
1697
1698 OSErr CopyCStrAndInsertCStrLongIntIntoHandle(const char *theSrcCStr,const char *theInsertCStr,const long theNum,Handle *theHandle)
1699 {
1700 OSErr   errCode;
1701 long    byteCount;
1702
1703         
1704         if (theHandle != nil)
1705         {
1706                 byteCount = CStrLength(theSrcCStr) + CStrLength(theInsertCStr) + 32;
1707                 
1708                 *theHandle = NewHandle(byteCount);
1709                 
1710                 if (*theHandle == nil)
1711                 {
1712                         SetErrorMessageAndLongIntAndBail("CopyCStrAndInsertCStrLongIntIntoHandle: Can't allocate Handle, MemError() = ",MemError());
1713                 }
1714                 
1715                 
1716                 HLock(*theHandle);
1717                 
1718                 CopyCStrAndInsertCStrLongIntIntoCStr(theSrcCStr,theInsertCStr,theNum,**theHandle,byteCount);
1719                 
1720                 HUnlock(*theHandle);
1721         }
1722         
1723         errCode = noErr;
1724         
1725         
1726 EXITPOINT:
1727
1728         return(errCode);
1729 }
1730
1731
1732
1733
1734
1735 OSErr CopyIndexedWordToCStr(char *theSrcCStr,int whichWord,char *theDstCStr,int maxDstCStrLength)
1736 {
1737 OSErr           errCode;
1738 char            *srcCharPtr,*dstCharPtr;
1739 int                     wordCount;
1740 int                     byteCount;
1741
1742
1743         if (theSrcCStr == nil)
1744         {
1745                 SetErrorMessageAndBail(("CopyIndexedWordToCStr: Bad parameter, theSrcCStr == nil"));
1746         }
1747         
1748         if (theDstCStr == nil)
1749         {
1750                 SetErrorMessageAndBail(("CopyIndexedWordToCStr: Bad parameter, theDstCStr == nil"));
1751         }
1752         
1753         if (whichWord < 0)
1754         {
1755                 SetErrorMessageAndBail(("CopyIndexedWordToCStr: Bad parameter, whichWord < 0"));
1756         }
1757         
1758         if (maxDstCStrLength <= 0)
1759         {
1760                 SetErrorMessageAndBail(("CopyIndexedWordToCStr: Bad parameter, maxDstCStrLength <= 0"));
1761         }
1762
1763         
1764         *theDstCStr = '\0';
1765         
1766         srcCharPtr = theSrcCStr;
1767
1768         while (*srcCharPtr == ' ' || *srcCharPtr == '\t')
1769         {
1770                 srcCharPtr++;
1771         }
1772         
1773
1774         for (wordCount = 0;wordCount < whichWord;wordCount++)
1775         {
1776                 while (*srcCharPtr != ' ' && *srcCharPtr != '\t' && *srcCharPtr != '\r' && *srcCharPtr != '\n' && *srcCharPtr != '\0')
1777                 {
1778                         srcCharPtr++;
1779                 }
1780                 
1781                 if (*srcCharPtr == '\r' || *srcCharPtr == '\n' || *srcCharPtr == '\0')
1782                 {
1783                         errCode = noErr;
1784                         
1785                         goto EXITPOINT;
1786                 }
1787
1788                 while (*srcCharPtr == ' ' || *srcCharPtr == '\t')
1789                 {
1790                         srcCharPtr++;
1791                 }
1792                 
1793                 if (*srcCharPtr == '\r' || *srcCharPtr == '\n' || *srcCharPtr == '\0')
1794                 {
1795                         errCode = noErr;
1796                         
1797                         goto EXITPOINT;
1798                 }
1799         }
1800
1801
1802         dstCharPtr = theDstCStr;
1803         byteCount = 0;
1804         
1805         
1806         for(;;)
1807         {
1808                 if (byteCount >= maxDstCStrLength - 1 || *srcCharPtr == '\0' || *srcCharPtr == ' ' || *srcCharPtr == '\t' || *srcCharPtr == '\r' || *srcCharPtr == '\n')
1809                 {
1810                         *dstCharPtr = '\0';
1811                         break;
1812                 }
1813                 
1814                 *dstCharPtr++ = *srcCharPtr++;
1815                 
1816                 byteCount++;
1817         }
1818
1819
1820         errCode = noErr;
1821
1822
1823 EXITPOINT:
1824
1825         return(errCode);
1826 }
1827
1828
1829
1830
1831
1832 OSErr CopyIndexedWordToNewHandle(char *theSrcCStr,int whichWord,Handle *outTheHandle)
1833 {
1834 OSErr           errCode;
1835 char            *srcCharPtr;
1836 int                     wordCount;
1837 int                     byteCount;
1838
1839
1840         if (theSrcCStr == nil)
1841         {
1842                 SetErrorMessageAndBail(("CopyIndexedWordToNewHandle: Bad parameter, theSrcCStr == nil"));
1843         }
1844         
1845         if (outTheHandle == nil)
1846         {
1847                 SetErrorMessageAndBail(("CopyIndexedWordToNewHandle: Bad parameter, outTheHandle == nil"));
1848         }
1849         
1850         if (whichWord < 0)
1851         {
1852                 SetErrorMessageAndBail(("CopyIndexedWordToNewHandle: Bad parameter, whichWord < 0"));
1853         }
1854
1855         
1856         *outTheHandle = nil;
1857         
1858
1859         srcCharPtr = theSrcCStr;
1860
1861         while (*srcCharPtr == ' ' || *srcCharPtr == '\t')
1862         {
1863                 srcCharPtr++;
1864         }
1865         
1866
1867         for (wordCount = 0;wordCount < whichWord;wordCount++)
1868         {
1869                 while (*srcCharPtr != ' ' && *srcCharPtr != '\t' && *srcCharPtr != '\r' && *srcCharPtr != '\n' && *srcCharPtr != '\0')
1870                 {
1871                         srcCharPtr++;
1872                 }
1873                 
1874                 if (*srcCharPtr == '\r' || *srcCharPtr == '\n' || *srcCharPtr == '\0')
1875                 {
1876                         break;
1877                 }
1878
1879                 while (*srcCharPtr == ' ' || *srcCharPtr == '\t')
1880                 {
1881                         srcCharPtr++;
1882                 }
1883                 
1884                 if (*srcCharPtr == '\r' || *srcCharPtr == '\n' || *srcCharPtr == '\0')
1885                 {
1886                         break;
1887                 }
1888         }
1889
1890
1891         for (byteCount = 0;;byteCount++)
1892         {
1893                 if (srcCharPtr[byteCount] == ' ' || srcCharPtr[byteCount] == '\t' || srcCharPtr[byteCount] == '\r' || srcCharPtr[byteCount] == '\n' || srcCharPtr[byteCount] == '\0')
1894                 {
1895                         break;
1896                 }
1897         }
1898
1899         
1900         *outTheHandle = NewHandle(byteCount + 1);
1901         
1902         if (*outTheHandle == nil)
1903         {
1904                 SetErrorMessageAndLongIntAndBail("CopyIndexedWordToNewHandle: Can't allocate Handle, MemError() = ",MemError());
1905         }
1906         
1907         
1908         ::BlockMove(srcCharPtr,**outTheHandle,byteCount);
1909         
1910         (**outTheHandle)[byteCount] = '\0';
1911
1912         errCode = noErr;
1913
1914
1915 EXITPOINT:
1916
1917         return(errCode);
1918 }
1919
1920
1921
1922 OSErr CopyIndexedLineToCStr(const char *theSrcCStr,int inWhichLine,int *lineEndIndex,Boolean *gotLastLine,char *theDstCStr,const int maxDstCStrLength)
1923 {
1924 OSErr           errCode;
1925 int                     theCurrentLine;
1926 int                     theCurrentLineOffset;
1927 int                     theEOSOffset;
1928
1929
1930         if (theSrcCStr == nil)
1931         {
1932                 SetErrorMessageAndBail(("CopyIndexedLineToCStr: Bad parameter, theSrcCStr == nil"));
1933         }
1934         
1935         if (theDstCStr == nil)
1936         {
1937                 SetErrorMessageAndBail(("CopyIndexedLineToCStr: Bad parameter, theDstCStr == nil"));
1938         }
1939         
1940         if (inWhichLine < 0)
1941         {
1942                 SetErrorMessageAndBail(("CopyIndexedLineToCStr: Bad parameter, inWhichLine < 0"));
1943         }
1944         
1945         if (maxDstCStrLength <= 0)
1946         {
1947                 SetErrorMessageAndBail(("CopyIndexedLineToCStr: Bad parameter, maxDstCStrLength <= 0"));
1948         }
1949         
1950         
1951         if (gotLastLine != nil)
1952         {
1953                 *gotLastLine = false;
1954         }
1955
1956         
1957         *theDstCStr = 0;
1958         
1959         theCurrentLineOffset = 0;
1960         
1961         theCurrentLine = 0;
1962         
1963         
1964         while (theCurrentLine < inWhichLine)
1965         {
1966                 while (theSrcCStr[theCurrentLineOffset] != '\r' && theSrcCStr[theCurrentLineOffset] != 0)
1967                 {
1968                         theCurrentLineOffset++;
1969                 }
1970                 
1971                 if (theSrcCStr[theCurrentLineOffset] == 0)
1972                 {
1973                         break;
1974                 }
1975                 
1976                 theCurrentLineOffset++;
1977                 theCurrentLine++;
1978         }
1979                 
1980         if (theSrcCStr[theCurrentLineOffset] == 0)
1981         {
1982                 SetErrorMessageAndLongIntAndBail("CopyIndexedLineToCStr: Too few lines in source text, can't get line ",inWhichLine);
1983         }
1984
1985
1986         theEOSOffset = FindCharOffsetInCStr('\r',theSrcCStr + theCurrentLineOffset);
1987         
1988         if (theEOSOffset >= 0)
1989         {
1990                 CopyCSubstrToCStr(theSrcCStr + theCurrentLineOffset,theEOSOffset,theDstCStr,maxDstCStrLength);
1991                 
1992                 if (gotLastLine != nil)
1993                 {
1994                         *gotLastLine = false;
1995                 }
1996         
1997                 if (lineEndIndex != nil)
1998                 {
1999                         *lineEndIndex = theEOSOffset;
2000                 }
2001         }
2002         
2003         else
2004         {
2005                 theEOSOffset = CStrLength(theSrcCStr + theCurrentLineOffset);
2006
2007                 CopyCSubstrToCStr(theSrcCStr + theCurrentLineOffset,theEOSOffset,theDstCStr,maxDstCStrLength);
2008                 
2009                 if (gotLastLine != nil)
2010                 {
2011                         *gotLastLine = true;
2012                 }
2013         
2014                 if (lineEndIndex != nil)
2015                 {
2016                         *lineEndIndex = theEOSOffset;
2017                 }
2018         }
2019         
2020
2021         errCode = noErr;
2022
2023
2024 EXITPOINT:
2025
2026         return(errCode);
2027 }
2028
2029
2030
2031 OSErr CopyIndexedLineToNewHandle(const char *theSrcCStr,int inWhichLine,Handle *outNewHandle)
2032 {
2033 OSErr           errCode;
2034 int                     theCurrentLine;
2035 int                     theCurrentLineOffset;
2036 int                     byteCount;
2037
2038
2039         SetErrorMessageAndBailIfNil(theSrcCStr,"CopyIndexedLineToNewHandle: Bad parameter, theSrcCStr == nil");
2040         SetErrorMessageAndBailIfNil(outNewHandle,"CopyIndexedLineToNewHandle: Bad parameter, outNewHandle == nil");
2041         
2042         if (inWhichLine < 0)
2043         {
2044                 SetErrorMessageAndBail(("CopyIndexedLineToNewHandle: Bad parameter, inWhichLine < 0"));
2045         }
2046         
2047
2048         theCurrentLineOffset = 0;
2049         
2050         theCurrentLine = 0;
2051         
2052         
2053         while (theCurrentLine < inWhichLine)
2054         {
2055                 while (theSrcCStr[theCurrentLineOffset] != '\r' && theSrcCStr[theCurrentLineOffset] != '\0')
2056                 {
2057                         theCurrentLineOffset++;
2058                 }
2059                 
2060                 if (theSrcCStr[theCurrentLineOffset] == '\0')
2061                 {
2062                         break;
2063                 }
2064                 
2065                 theCurrentLineOffset++;
2066                 theCurrentLine++;
2067         }
2068                 
2069         if (theSrcCStr[theCurrentLineOffset] == '\0')
2070         {
2071                 SetErrorMessageAndLongIntAndBail("CopyIndexedLineToNewHandle: Too few lines in source text, can't get line #",inWhichLine);
2072         }
2073
2074         
2075         byteCount = 0;
2076         
2077         while (theSrcCStr[theCurrentLineOffset + byteCount] != '\r' && theSrcCStr[theCurrentLineOffset + byteCount] != '\0')
2078         {
2079                 byteCount++;
2080         }
2081                 
2082         
2083         *outNewHandle = NewHandle(byteCount + 1);
2084         
2085         if (*outNewHandle == nil)
2086         {
2087                 SetErrorMessageAndLongIntAndBail("CopyIndexedLineToNewHandle: Can't allocate Handle, MemError() = ",MemError());
2088         }
2089         
2090         ::BlockMove(theSrcCStr + theCurrentLineOffset,**outNewHandle,byteCount);
2091         
2092         (**outNewHandle)[byteCount] = '\0';
2093
2094         errCode = noErr;
2095
2096
2097 EXITPOINT:
2098
2099         return(errCode);
2100 }
2101
2102
2103
2104
2105 OSErr CountDigits(const char *inCStr,int *outNumIntegerDigits,int *outNumFractDigits)
2106 {
2107 OSErr   errCode = noErr;
2108 int             numIntDigits = 0;
2109 int             numFractDigits = 0;
2110 int     digitIndex = 0;
2111
2112         
2113         SetErrorMessageAndBailIfNil(inCStr,"CountDigits: Bad parameter, theSrcCStr == nil");
2114         SetErrorMessageAndBailIfNil(outNumIntegerDigits,"CountDigits: Bad parameter, outNumIntegerDigits == nil");
2115         SetErrorMessageAndBailIfNil(outNumFractDigits,"CountDigits: Bad parameter, outNumFractDigits == nil");
2116         
2117         digitIndex = 0;
2118         
2119         while (inCStr[digitIndex] >= '0' && inCStr[digitIndex] <= '9')
2120         {
2121                 digitIndex++;
2122                 numIntDigits++;
2123         }
2124         
2125         if (inCStr[digitIndex] == '.')
2126         {
2127                 digitIndex++;
2128                 
2129                 while (inCStr[digitIndex] >= '0' && inCStr[digitIndex] <= '9')
2130                 {
2131                         digitIndex++;
2132                         numFractDigits++;
2133                 }
2134         }
2135         
2136         *outNumIntegerDigits = numIntDigits;
2137         
2138         *outNumFractDigits = numFractDigits;
2139         
2140         errCode = noErr;
2141         
2142 EXITPOINT:
2143
2144         return(errCode);
2145 }
2146
2147
2148
2149 OSErr ExtractIntFromCStr(const char *theSrcCStr,int *outInt,Boolean skipLeadingSpaces)
2150 {
2151 OSErr           errCode;
2152 int                     theCharIndex;
2153
2154
2155         if (theSrcCStr == nil)
2156         {
2157                 SetErrorMessageAndBail(("ExtractIntFromCStr: Bad parameter, theSrcCStr == nil"));
2158         }
2159         
2160         if (outInt == nil)
2161         {
2162                 SetErrorMessageAndBail(("ExtractIntFromCStr: Bad parameter, outInt == nil"));
2163         }       
2164
2165         
2166         *outInt = 0;
2167         
2168         theCharIndex = 0;
2169         
2170         if (skipLeadingSpaces == true)
2171         {
2172                 while (theSrcCStr[theCharIndex] == ' ')
2173                 {
2174                         theCharIndex++;
2175                 }
2176         }
2177         
2178         if (theSrcCStr[theCharIndex] < '0' || theSrcCStr[theCharIndex] > '9')
2179         {
2180                 SetErrorMessageAndBail(("ExtractIntFromCStr: Bad parameter, theSrcCStr contains a bogus numeric representation"));
2181         }
2182
2183
2184         while (theSrcCStr[theCharIndex] >= '0' && theSrcCStr[theCharIndex] <= '9')
2185         {
2186                 *outInt = (*outInt * 10) + (theSrcCStr[theCharIndex] - '0');
2187                 
2188                 theCharIndex++;
2189         }
2190         
2191
2192         errCode = noErr;
2193
2194
2195 EXITPOINT:
2196
2197         return(errCode);
2198 }
2199
2200
2201
2202 OSErr ExtractIntFromPStr(const unsigned char *theSrcPStr,int *outInt,Boolean skipLeadingSpaces)
2203 {
2204 OSErr           errCode;
2205 char            theCStr[256];
2206
2207
2208         if (theSrcPStr == nil)
2209         {
2210                 SetErrorMessageAndBail(("ExtractIntFromPStr: Bad parameter, theSrcPStr == nil"));
2211         }
2212         
2213         if (outInt == nil)
2214         {
2215                 SetErrorMessageAndBail(("ExtractIntFromPStr: Bad parameter, outInt == nil"));
2216         }
2217         
2218         
2219         CopyPStrToCStr(theSrcPStr,theCStr,sizeof(theCStr));
2220         
2221         
2222         errCode = ExtractIntFromCStr(theCStr,outInt,skipLeadingSpaces);
2223
2224
2225 EXITPOINT:
2226
2227         return(errCode);
2228 }
2229
2230
2231
2232 int CountOccurencesOfCharInCStr(const char inChar,const char *inSrcCStr)
2233 {
2234 int             theSrcCharIndex;
2235 int             numOccurrences = -1;
2236
2237
2238         if (inSrcCStr != nil && inChar != '\0')
2239         {
2240                 numOccurrences = 0;
2241                 
2242                 for (theSrcCharIndex = 0;inSrcCStr[theSrcCharIndex] != '\0';theSrcCharIndex++)
2243                 {
2244                         if (inSrcCStr[theSrcCharIndex] == inChar)
2245                         {
2246                                 numOccurrences++;
2247                         }
2248                 }
2249         }
2250         
2251         return(numOccurrences);
2252 }
2253
2254
2255 int CountWordsInCStr(const char *inSrcCStr)
2256 {
2257 int             numWords = -1;
2258
2259
2260         if (inSrcCStr != nil)
2261         {
2262                 numWords = 0;
2263                 
2264                 //      Skip lead spaces
2265                 
2266                 while (*inSrcCStr == ' ')
2267                 {
2268                         inSrcCStr++;
2269                 }
2270
2271                 while (*inSrcCStr != '\0')
2272                 {
2273                         numWords++;
2274
2275                         while (*inSrcCStr != ' ' && *inSrcCStr != '\0')
2276                         {
2277                                 inSrcCStr++;
2278                         }
2279                         
2280                         while (*inSrcCStr == ' ')
2281                         {
2282                                 inSrcCStr++;
2283                         }
2284                 }
2285         }
2286         
2287         return(numWords);
2288 }
2289
2290
2291
2292
2293 void ConvertCStrToUpperCase(char *theSrcCStr)
2294 {
2295 char            *theCharPtr;
2296
2297
2298         if (theSrcCStr != nil)
2299         {
2300                 theCharPtr = theSrcCStr;
2301                 
2302                 while (*theCharPtr != 0)
2303                 {
2304                         if (*theCharPtr >= 'a' && *theCharPtr <= 'z')
2305                         {
2306                                 *theCharPtr = *theCharPtr - 'a' + 'A';
2307                         }
2308                         
2309                         theCharPtr++;
2310                 }
2311         }
2312 }
2313
2314
2315
2316
2317
2318
2319
2320 void ExtractCStrItemFromCStr(const char *inSrcCStr,const char inItemDelimiter,const int inItemNumber,Boolean *foundItem,char *outDstCharPtr,const int inDstCharPtrMaxLength,const Boolean inTreatMultipleDelimsAsSingleDelim)
2321 {
2322 int             theItem;
2323 int             theSrcCharIndex;
2324 int             theDstCharIndex;
2325
2326
2327         if (foundItem != nil)
2328         {
2329                 *foundItem = false;
2330         }
2331         
2332         
2333         if (outDstCharPtr != nil && inDstCharPtrMaxLength > 0 && inItemNumber >= 0 && inItemDelimiter != 0)
2334         {
2335                 *outDstCharPtr = 0;
2336                 
2337
2338                 theSrcCharIndex = 0;
2339                 
2340                 for (theItem = 0;theItem < inItemNumber;theItem++)
2341                 {
2342                         while (inSrcCStr[theSrcCharIndex] != inItemDelimiter && inSrcCStr[theSrcCharIndex] != '\0')
2343                         {
2344                                 theSrcCharIndex++;
2345                         }
2346                         
2347                         if (inSrcCStr[theSrcCharIndex] == inItemDelimiter)
2348                         {
2349                                 theSrcCharIndex++;
2350                                 
2351                                 if (inTreatMultipleDelimsAsSingleDelim)
2352                                 {
2353                                         while (inSrcCStr[theSrcCharIndex] == inItemDelimiter)
2354                                         {
2355                                                 theSrcCharIndex++;
2356                                         }
2357                                 }
2358                         }
2359                         
2360                         
2361                         if (inSrcCStr[theSrcCharIndex] == '\0')
2362                         {
2363                                 goto EXITPOINT;
2364                         }
2365                 }
2366                 
2367
2368                 if (foundItem != nil)
2369                 {
2370                         *foundItem = true;
2371                 }
2372                 
2373                 
2374                 theDstCharIndex = 0;
2375                 
2376                 for (;;)
2377                 {
2378                         if (inSrcCStr[theSrcCharIndex] == 0 || inSrcCStr[theSrcCharIndex] == inItemDelimiter || theDstCharIndex >= inDstCharPtrMaxLength - 1)
2379                         {
2380                                 outDstCharPtr[theDstCharIndex] = 0;
2381                                 
2382                                 break;
2383                         }
2384                         
2385                         outDstCharPtr[theDstCharIndex++] = inSrcCStr[theSrcCharIndex++];
2386                 }
2387         }
2388         
2389         
2390 EXITPOINT:
2391
2392         return;
2393 }
2394
2395
2396
2397 OSErr ExtractCStrItemFromCStrIntoNewHandle(const char *inSrcCStr,const char inItemDelimiter,const int inItemNumber,Boolean *foundItem,Handle *outNewHandle,const Boolean inTreatMultipleDelimsAsSingleDelim)
2398 {
2399 OSErr   errCode;
2400 int             theItem;
2401 int             theSrcCharIndex;
2402 int             theItemLength;
2403
2404
2405         if (inSrcCStr == nil)
2406         {
2407                 SetErrorMessage("ExtractCStrItemFromCStrIntoNewHandle: Bad parameter, inSrcCStr == nil");
2408                 errCode = kGenericError;
2409                 goto EXITPOINT;
2410         }
2411         
2412         if (outNewHandle == nil)
2413         {
2414                 SetErrorMessage("ExtractCStrItemFromCStrIntoNewHandle: Bad parameter, outNewHandle == nil");
2415                 errCode = kGenericError;
2416                 goto EXITPOINT;
2417         }
2418         
2419         if (foundItem == nil)
2420         {
2421                 SetErrorMessage("ExtractCStrItemFromCStrIntoNewHandle: Bad parameter, foundItem == nil");
2422                 errCode = kGenericError;
2423                 goto EXITPOINT;
2424         }
2425         
2426         if (inItemNumber < 0)
2427         {
2428                 SetErrorMessage("ExtractCStrItemFromCStrIntoNewHandle: Bad parameter, inItemNumber < 0");
2429                 errCode = kGenericError;
2430                 goto EXITPOINT;
2431         }
2432         
2433         if (inItemDelimiter == 0)
2434         {
2435                 SetErrorMessage("ExtractCStrItemFromCStrIntoNewHandle: Bad parameter, inItemDelimiter == 0");
2436                 errCode = kGenericError;
2437                 goto EXITPOINT;
2438         }
2439
2440
2441         *foundItem = false;
2442         
2443         theSrcCharIndex = 0;
2444         
2445         for (theItem = 0;theItem < inItemNumber;theItem++)
2446         {
2447                 while (inSrcCStr[theSrcCharIndex] != inItemDelimiter && inSrcCStr[theSrcCharIndex] != '\0')
2448                 {
2449                         theSrcCharIndex++;
2450                 }
2451                 
2452                 if (inSrcCStr[theSrcCharIndex] == inItemDelimiter)
2453                 {
2454                         theSrcCharIndex++;
2455                         
2456                         if (inTreatMultipleDelimsAsSingleDelim)
2457                         {
2458                                 while (inSrcCStr[theSrcCharIndex] == inItemDelimiter)
2459                                 {
2460                                         theSrcCharIndex++;
2461                                 }
2462                         }
2463                 }
2464                 
2465                 
2466                 if (inSrcCStr[theSrcCharIndex] == '\0')
2467                 {
2468                         errCode = noErr;
2469                         
2470                         goto EXITPOINT;
2471                 }
2472         }
2473         
2474
2475         *foundItem = true;
2476         
2477         
2478         for (theItemLength = 0;;theItemLength++)
2479         {
2480                 if (inSrcCStr[theSrcCharIndex + theItemLength] == 0 || inSrcCStr[theSrcCharIndex + theItemLength] == inItemDelimiter)
2481                 {
2482                         break;
2483                 }
2484         }
2485         
2486
2487         *outNewHandle = NewHandle(theItemLength + 1);
2488         
2489         if (*outNewHandle == nil)
2490         {
2491                 SetErrorMessageAndLongIntAndBail("ExtractCStrItemFromCStrIntoNewHandle: Can't allocate Handle, MemError() = ",MemError());
2492         }
2493         
2494         
2495         BlockMove(inSrcCStr + theSrcCharIndex,**outNewHandle,theItemLength);
2496         
2497         (**outNewHandle)[theItemLength] = 0;
2498         
2499         errCode = noErr;
2500         
2501         
2502 EXITPOINT:
2503
2504         return(errCode);
2505 }
2506
2507
2508
2509
2510
2511
2512 OSErr ExtractFloatFromCStr(const char *inCString,extended80 *outFloat)
2513 {
2514 OSErr                           errCode;
2515 Str255                          theStr255;
2516 Handle                          theNumberPartsTableHandle = nil;
2517 long                            theNumberPartsOffset,theNumberPartsLength;
2518 FormatResultType        theFormatResultType;
2519 NumberParts                     theNumberPartsTable;
2520 NumFormatStringRec      theNumFormatStringRec;
2521
2522
2523         if (inCString == nil)
2524         {
2525                 SetErrorMessage("ExtractFloatFromCStr: Bad parameter, inCString == nil");
2526                 errCode = kGenericError;
2527                 goto EXITPOINT;
2528         }
2529
2530         if (outFloat == nil)
2531         {
2532                 SetErrorMessage("ExtractFloatFromCStr: Bad parameter, outFloat == nil");
2533                 errCode = kGenericError;
2534                 goto EXITPOINT;
2535         }
2536         
2537         
2538 //      GetIntlResourceTable(smRoman,smNumberPartsTable,&theNumberPartsTableHandle,&theNumberPartsOffset,&theNumberPartsLength);
2539
2540         GetIntlResourceTable(GetScriptManagerVariable(smSysScript),smNumberPartsTable,&theNumberPartsTableHandle,&theNumberPartsOffset,&theNumberPartsLength);  
2541         
2542         if (theNumberPartsTableHandle == nil)
2543         {
2544                 SetErrorMessage("ExtractFloatFromCStr: Can't get number parts table for converting string representations to/from numeric representations");
2545                 errCode = kGenericError;
2546                 goto EXITPOINT;
2547         }
2548         
2549         if (theNumberPartsLength > sizeof(theNumberPartsTable))
2550         {
2551                 SetErrorMessage("ExtractFloatFromCStr: Number parts table has bad length");
2552                 errCode = kGenericError;
2553                 goto EXITPOINT;
2554         }
2555         
2556
2557         BlockMove(*theNumberPartsTableHandle + theNumberPartsOffset,&theNumberPartsTable,theNumberPartsLength);
2558         
2559         
2560         theFormatResultType = (FormatResultType) StringToFormatRec(kNumberFormatString,&theNumberPartsTable,&theNumFormatStringRec);
2561         
2562         if (theFormatResultType != fFormatOK)
2563         {
2564                 SetErrorMessage("ExtractFloatFromCStr: StringToFormatRec() != fFormatOK");
2565                 errCode = kGenericError;
2566                 goto EXITPOINT;
2567         }
2568
2569         
2570         CopyCStrToPStr(inCString,theStr255,sizeof(theStr255));
2571
2572
2573         theFormatResultType = (FormatResultType) StringToExtended(theStr255,&theNumFormatStringRec,&theNumberPartsTable,outFloat);
2574         
2575         if (theFormatResultType != fFormatOK && theFormatResultType != fBestGuess)
2576         {
2577                 SetErrorMessageAndLongIntAndBail("ExtractFloatFromCStr: StringToExtended() = ",theFormatResultType);
2578         }
2579
2580         
2581         errCode = noErr;
2582         
2583
2584 EXITPOINT:
2585         
2586         return(errCode);
2587 }
2588
2589
2590
2591 OSErr CopyFloatToCStr(const extended80 *theFloat,char *theCStr,const int maxCStrLength,const int inMaxNumIntDigits,const int inMaxNumFractDigits)
2592 {
2593 OSErr                           errCode;
2594 Str255                          theStr255;
2595 Handle                          theNumberPartsTableHandle = nil;
2596 long                            theNumberPartsOffset,theNumberPartsLength;
2597 FormatResultType        theFormatResultType;
2598 NumberParts                     theNumberPartsTable;
2599 NumFormatStringRec      theNumFormatStringRec;
2600
2601
2602         if (theCStr == nil)
2603         {
2604                 SetErrorMessage("CopyFloatToCStr: Bad parameter, theCStr == nil");
2605                 errCode = kGenericError;
2606                 goto EXITPOINT;
2607         }
2608
2609         if (theFloat == nil)
2610         {
2611                 SetErrorMessage("CopyFloatToCStr: Bad parameter, theFloat == nil");
2612                 errCode = kGenericError;
2613                 goto EXITPOINT;
2614         }
2615         
2616
2617 //      GetIntlResourceTable(smRoman,smNumberPartsTable,&theNumberPartsTableHandle,&theNumberPartsOffset,&theNumberPartsLength);
2618
2619         GetIntlResourceTable(GetScriptManagerVariable(smSysScript),smNumberPartsTable,&theNumberPartsTableHandle,&theNumberPartsOffset,&theNumberPartsLength);  
2620         
2621         if (theNumberPartsTableHandle == nil)
2622         {
2623                 SetErrorMessage("CopyFloatToCStr: Can't get number parts table for converting string representations to/from numeric representations");
2624                 errCode = kGenericError;
2625                 goto EXITPOINT;
2626         }
2627         
2628         if (theNumberPartsLength > sizeof(theNumberPartsTable))
2629         {
2630                 SetErrorMessage("CopyFloatToCStr: Number parts table has bad length");
2631                 errCode = kGenericError;
2632                 goto EXITPOINT;
2633         }
2634         
2635         
2636         BlockMove(*theNumberPartsTableHandle + theNumberPartsOffset,&theNumberPartsTable,theNumberPartsLength);
2637         
2638         
2639         if (inMaxNumIntDigits >= 0 || inMaxNumFractDigits >= 0)
2640         {
2641         char    numberFormat[64];
2642         int             numberFormatLength = 0;
2643         
2644                 for (int i = 0;i < inMaxNumIntDigits && numberFormatLength < sizeof(numberFormat) - 1;i++)
2645                 {
2646                         numberFormat[numberFormatLength++] = '0';
2647                 }
2648                 
2649                 if (inMaxNumFractDigits > 0 && numberFormatLength < sizeof(numberFormat) - 1)
2650                 {
2651                         numberFormat[numberFormatLength++] = '.';
2652                         
2653                         for (int i = 0;i < inMaxNumFractDigits && numberFormatLength < sizeof(numberFormat) - 1;i++)
2654                         {
2655                                 numberFormat[numberFormatLength++] = '0';
2656                         }
2657                 }
2658
2659                 
2660                 if (numberFormatLength < sizeof(numberFormat) - 1)
2661                 {
2662                         numberFormat[numberFormatLength++] = ';';
2663                 }
2664                 
2665                 if (numberFormatLength < sizeof(numberFormat) - 1)
2666                 {
2667                         numberFormat[numberFormatLength++] = '-';
2668                 }
2669                 
2670
2671                 for (int i = 0;i < inMaxNumIntDigits && numberFormatLength < sizeof(numberFormat) - 1;i++)
2672                 {
2673                         numberFormat[numberFormatLength++] = '0';
2674                 }
2675                 
2676                 if (inMaxNumFractDigits > 0 && numberFormatLength < sizeof(numberFormat) - 1)
2677                 {
2678                         numberFormat[numberFormatLength++] = '.';
2679                         
2680                         for (int i = 0;i < inMaxNumFractDigits && numberFormatLength < sizeof(numberFormat) - 1;i++)
2681                         {
2682                                 numberFormat[numberFormatLength++] = '0';
2683                         }
2684                 }
2685                 
2686                 numberFormat[numberFormatLength] = '\0';
2687
2688
2689         Str255  tempStr255;
2690         
2691                 CopyCStrToPStr(numberFormat,tempStr255,sizeof(tempStr255));
2692                 
2693                 theFormatResultType = (FormatResultType) StringToFormatRec(tempStr255,&theNumberPartsTable,&theNumFormatStringRec);
2694         }
2695         
2696         else
2697         {
2698                 theFormatResultType = (FormatResultType) StringToFormatRec(kNumberFormatString,&theNumberPartsTable,&theNumFormatStringRec);
2699         }
2700         
2701         if (theFormatResultType != fFormatOK)
2702         {
2703                 SetErrorMessage("CopyFloatToCStr: StringToFormatRec() != fFormatOK");
2704                 errCode = kGenericError;
2705                 goto EXITPOINT;
2706         }
2707
2708
2709         theFormatResultType = (FormatResultType) ExtendedToString(theFloat,&theNumFormatStringRec,&theNumberPartsTable,theStr255);
2710         
2711         if (theFormatResultType != fFormatOK)
2712         {
2713                 SetErrorMessage("CopyFloatToCStr: ExtendedToString() != fFormatOK");
2714                 errCode = kGenericError;
2715                 goto EXITPOINT;
2716         }
2717
2718         
2719         CopyPStrToCStr(theStr255,theCStr,maxCStrLength);
2720         
2721         errCode = noErr;
2722         
2723
2724 EXITPOINT:
2725         
2726         return(errCode);
2727 }
2728
2729
2730
2731
2732
2733 void SkipWhiteSpace(char **ioSrcCharPtr,const Boolean inStopAtEOL)
2734 {
2735         if (ioSrcCharPtr != nil && *ioSrcCharPtr != nil)
2736         {
2737                 if (inStopAtEOL)
2738                 {
2739                         while ((**ioSrcCharPtr == ' ' || **ioSrcCharPtr == '\t') && **ioSrcCharPtr != '\r' && **ioSrcCharPtr != '\n')
2740                         {
2741                                 *ioSrcCharPtr++;
2742                         }
2743                 }
2744                 
2745                 else
2746                 {
2747                         while (**ioSrcCharPtr == ' ' || **ioSrcCharPtr == '\t')
2748                         {
2749                                 *ioSrcCharPtr++;
2750                         }
2751                 }
2752         }
2753 }