OpenSSL  1.0.1c
 All Classes Files Functions Variables Typedefs Enumerations Enumerator Macros
CPStringUtils.cpp
Go to the documentation of this file.
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  * [email protected].
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  * ([email protected]). This product includes software written by Tim
51  * Hudson ([email protected]).
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 }
Generated on Thu Jan 10 2013 09:53:42 for OpenSSL by   doxygen 1.8.2