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 69void CopyPStrToCStr(const unsigned char *thePStr,char *theCStr,const int maxCStrLength) 70{ 71int 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 96void CopyPStrToPStr(const unsigned char *theSrcPStr,unsigned char *theDstPStr,const int maxDstStrLength) 97{ 98int 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 127void CopyCStrToCStr(const char *theSrcCStr,char *theDstCStr,const int maxDstStrLength) 128{ 129int 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 153void CopyCSubstrToCStr(const char *theSrcCStr,const int maxCharsToCopy,char *theDstCStr,const int maxDstStrLength) 154{ 155int 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 179void CopyCSubstrToPStr(const char *theSrcCStr,const int maxCharsToCopy,unsigned char *theDstPStr,const int maxDstStrLength) 180{ 181int i; 182int 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 214void CopyCStrToPStr(const char *theSrcCStr,unsigned char *theDstPStr,const int maxDstStrLength) 215{ 216int i; 217int 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 248void ConcatPStrToCStr(const unsigned char *thePStr,char *theCStr,const int maxCStrLength) 249{ 250int 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 283void ConcatPStrToPStr(const unsigned char *theSrcPStr,unsigned char *theDstPStr,const int maxDstStrLength) 284{ 285int 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 316void ConcatCStrToPStr(const char *theSrcCStr,unsigned char *theDstPStr,const int maxDstStrLength) 317{ 318int i,thePStrLength; 319int 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 355void ConcatCStrToCStr(const char *theSrcCStr,char *theDstCStr,const int maxCStrLength) 356{ 357int 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 387void ConcatCharToCStr(const char theChar,char *theDstCStr,const int maxCStrLength) 388{ 389int 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 406void ConcatCharToPStr(const char theChar,unsigned char *theDstPStr,const int maxPStrLength) 407{ 408int 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 426int CompareCStrs(const char *theFirstCStr,const char *theSecondCStr,const Boolean ignoreCase) 427{ 428int returnValue; 429char 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 502Boolean 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 516Boolean 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 531int ComparePStrs(const unsigned char *theFirstPStr,const unsigned char *theSecondPStr,const Boolean ignoreCase) 532{ 533int i,returnValue; 534char 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 604int CompareCStrToPStr(const char *theCStr,const unsigned char *thePStr,const Boolean ignoreCase) 605{ 606int returnValue; 607char 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 625void ConcatLongIntToCStr(const long theNum,char *theCStr,const int maxCStrLength,const int numDigits) 626{ 627Str255 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 664void ConcatLongIntToPStr(const long theNum,unsigned char *thePStr,const int maxPStrLength,const int numDigits) 665{ 666Str255 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 702void 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 711void CopyLongIntToCStr(const long theNum,char *theCStr,const int maxCStrLength,const int numDigits) 712{ 713Str255 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 751void CopyUnsignedLongIntToCStr(const unsigned long theNum,char *theCStr,const int maxCStrLength) 752{ 753char tempString[256]; 754int srcCharIndex,dstCharIndex; 755unsigned 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 805void CopyLongIntToPStr(const long theNum,unsigned char *thePStr,const int maxPStrLength,const int numDigits) 806{ 807char tempString[256]; 808 809 810 CopyLongIntToCStr(theNum,tempString,sizeof(tempString),numDigits); 811 812 CopyCStrToPStr(tempString,thePStr,maxPStrLength); 813} 814 815 816 817OSErr CopyLongIntToNewHandle(const long inTheLongInt,Handle *theHandle) 818{ 819OSErr errCode = noErr; 820char tempString[32]; 821 822 823 CopyLongIntToCStr(inTheLongInt,tempString,sizeof(tempString)); 824 825 errCode = CopyCStrToNewHandle(tempString,theHandle); 826 827 return(errCode); 828} 829 830 831OSErr CopyLongIntToExistingHandle(const long inTheLongInt,Handle theHandle) 832{ 833OSErr errCode = noErr; 834char 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 847OSErr CopyCStrToExistingHandle(const char *theCString,Handle theHandle) 848{ 849OSErr errCode = noErr; 850long 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 883EXITPOINT: 884 885 return(errCode); 886} 887 888 889 890 891 892OSErr CopyCStrToNewHandle(const char *theCString,Handle *theHandle) 893{ 894OSErr errCode = noErr; 895long 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 923EXITPOINT: 924 925 return(errCode); 926} 927 928 929 930OSErr CopyPStrToNewHandle(const unsigned char *thePString,Handle *theHandle) 931{ 932OSErr errCode = noErr; 933long 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 966EXITPOINT: 967 968 return(errCode); 969} 970 971 972OSErr AppendPStrToHandle(const unsigned char *thePString,Handle theHandle,long *currentLength) 973{ 974OSErr errCode = noErr; 975char tempString[256]; 976 977 978 CopyPStrToCStr(thePString,tempString,sizeof(tempString)); 979 980 errCode = AppendCStrToHandle(tempString,theHandle,currentLength); 981 982 983EXITPOINT: 984 985 return(errCode); 986} 987 988 989 990OSErr AppendCStrToHandle(const char *theCString,Handle theHandle,long *currentLength,long *maxLength) 991{ 992OSErr errCode = noErr; 993long 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 1068EXITPOINT: 1069 1070 return(errCode); 1071} 1072 1073 1074 1075OSErr AppendCharsToHandle(const char *theChars,const int numChars,Handle theHandle,long *currentLength,long *maxLength) 1076{ 1077OSErr errCode = noErr; 1078long 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 1152EXITPOINT: 1153 1154 return(errCode); 1155} 1156 1157 1158 1159OSErr AppendLongIntToHandle(const long inTheLongInt,Handle theHandle,long *currentLength) 1160{ 1161OSErr errCode = noErr; 1162char 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 1175long CStrLength(const char *theCString) 1176{ 1177long 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 1194long PStrLength(const unsigned char *thePString) 1195{ 1196long 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 1212void ZeroMem(void *theMemPtr,const unsigned long numBytes) 1213{ 1214unsigned char *theBytePtr; 1215unsigned long *theLongPtr; 1216unsigned long numSingleBytes; 1217unsigned 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 1261char *FindCharInCStr(const char theChar,const char *theCString) 1262{ 1263char *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 1286long FindCharOffsetInCStr(const char theChar,const char *theCString,const Boolean inIgnoreCase) 1287{ 1288long 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 1344long FindCStrOffsetInCStr(const char *theCSubstring,const char *theCString,const Boolean inIgnoreCase) 1345{ 1346long 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 1397EXITPOINT: 1398 1399 return(theOffset); 1400} 1401 1402 1403 1404void InsertCStrIntoCStr(const char *theSrcCStr,const int theInsertionOffset,char *theDstCStr,const int maxDstStrLength) 1405{ 1406int currentLength; 1407int insertLength; 1408int numCharsToInsert; 1409int 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 1457void InsertPStrIntoCStr(const unsigned char *theSrcPStr,const int theInsertionOffset,char *theDstCStr,const int maxDstStrLength) 1458{ 1459int currentLength; 1460int insertLength; 1461int numCharsToInsert; 1462int 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 1510OSErr InsertCStrIntoHandle(const char *theCString,Handle theHandle,const long inInsertOffset) 1511{ 1512OSErr errCode; 1513int currentLength; 1514int 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 1550EXITPOINT: 1551 1552 return(errCode); 1553} 1554 1555 1556 1557 1558void CopyCStrAndInsert1LongIntIntoCStr(const char *theSrcCStr,const long theNum,char *theDstCStr,const int maxDstStrLength) 1559{ 1560 CopyCStrAndInsertCStrLongIntIntoCStr(theSrcCStr,nil,theNum,theDstCStr,maxDstStrLength); 1561} 1562 1563 1564void CopyCStrAndInsert2LongIntsIntoCStr(const char *theSrcCStr,const long long1,const long long2,char *theDstCStr,const int maxDstStrLength) 1565{ 1566const long theLongInts[] = { long1,long2 }; 1567 1568 CopyCStrAndInsertCStrsLongIntsIntoCStr(theSrcCStr,nil,theLongInts,theDstCStr,maxDstStrLength); 1569} 1570 1571 1572void CopyCStrAndInsert3LongIntsIntoCStr(const char *theSrcCStr,const long long1,const long long2,const long long3,char *theDstCStr,const int maxDstStrLength) 1573{ 1574const long theLongInts[] = { long1,long2,long3 }; 1575 1576 CopyCStrAndInsertCStrsLongIntsIntoCStr(theSrcCStr,nil,theLongInts,theDstCStr,maxDstStrLength); 1577} 1578 1579 1580void CopyCStrAndInsertCStrIntoCStr(const char *theSrcCStr,const char *theInsertCStr,char *theDstCStr,const int maxDstStrLength) 1581{ 1582const char *theCStrs[2] = { theInsertCStr,nil }; 1583 1584 CopyCStrAndInsertCStrsLongIntsIntoCStr(theSrcCStr,theCStrs,nil,theDstCStr,maxDstStrLength); 1585} 1586 1587 1588 1589void CopyCStrAndInsertCStrLongIntIntoCStr(const char *theSrcCStr,const char *theInsertCStr,const long theNum,char *theDstCStr,const int maxDstStrLength) 1590{ 1591const char *theCStrs[2] = { theInsertCStr,nil }; 1592const long theLongInts[1] = { theNum }; 1593 1594 CopyCStrAndInsertCStrsLongIntsIntoCStr(theSrcCStr,theCStrs,theLongInts,theDstCStr,maxDstStrLength); 1595} 1596 1597 1598 1599void CopyCStrAndInsertCStrsLongIntsIntoCStr(const char *theSrcCStr,const char **theInsertCStrs,const long *theLongInts,char *theDstCStr,const int maxDstStrLength) 1600{ 1601int dstCharIndex,srcCharIndex,theMaxDstStrLength; 1602int theCStrIndex = 0; 1603int 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 1689EXITPOINT: 1690 1691 return; 1692} 1693 1694 1695 1696 1697 1698OSErr CopyCStrAndInsertCStrLongIntIntoHandle(const char *theSrcCStr,const char *theInsertCStr,const long theNum,Handle *theHandle) 1699{ 1700OSErr errCode; 1701long 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 1726EXITPOINT: 1727 1728 return(errCode); 1729} 1730 1731 1732 1733 1734 1735OSErr CopyIndexedWordToCStr(char *theSrcCStr,int whichWord,char *theDstCStr,int maxDstCStrLength) 1736{ 1737OSErr errCode; 1738char *srcCharPtr,*dstCharPtr; 1739int wordCount; 1740int 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 1823EXITPOINT: 1824 1825 return(errCode); 1826} 1827 1828 1829 1830 1831 1832OSErr CopyIndexedWordToNewHandle(char *theSrcCStr,int whichWord,Handle *outTheHandle) 1833{ 1834OSErr errCode; 1835char *srcCharPtr; 1836int wordCount; 1837int 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 1915EXITPOINT: 1916 1917 return(errCode); 1918} 1919 1920 1921 1922OSErr CopyIndexedLineToCStr(const char *theSrcCStr,int inWhichLine,int *lineEndIndex,Boolean *gotLastLine,char *theDstCStr,const int maxDstCStrLength) 1923{ 1924OSErr errCode; 1925int theCurrentLine; 1926int theCurrentLineOffset; 1927int 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 2024EXITPOINT: 2025 2026 return(errCode); 2027} 2028 2029 2030 2031OSErr CopyIndexedLineToNewHandle(const char *theSrcCStr,int inWhichLine,Handle *outNewHandle) 2032{ 2033OSErr errCode; 2034int theCurrentLine; 2035int theCurrentLineOffset; 2036int 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 2097EXITPOINT: 2098 2099 return(errCode); 2100} 2101 2102 2103 2104 2105OSErr CountDigits(const char *inCStr,int *outNumIntegerDigits,int *outNumFractDigits) 2106{ 2107OSErr errCode = noErr; 2108int numIntDigits = 0; 2109int numFractDigits = 0; 2110int 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 2142EXITPOINT: 2143 2144 return(errCode); 2145} 2146 2147 2148 2149OSErr ExtractIntFromCStr(const char *theSrcCStr,int *outInt,Boolean skipLeadingSpaces) 2150{ 2151OSErr errCode; 2152int 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 2195EXITPOINT: 2196 2197 return(errCode); 2198} 2199 2200 2201 2202OSErr ExtractIntFromPStr(const unsigned char *theSrcPStr,int *outInt,Boolean skipLeadingSpaces) 2203{ 2204OSErr errCode; 2205char 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 2225EXITPOINT: 2226 2227 return(errCode); 2228} 2229 2230 2231 2232int CountOccurencesOfCharInCStr(const char inChar,const char *inSrcCStr) 2233{ 2234int theSrcCharIndex; 2235int 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 2255int CountWordsInCStr(const char *inSrcCStr) 2256{ 2257int 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 2293void ConvertCStrToUpperCase(char *theSrcCStr) 2294{ 2295char *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 2320void ExtractCStrItemFromCStr(const char *inSrcCStr,const char inItemDelimiter,const int inItemNumber,Boolean *foundItem,char *outDstCharPtr,const int inDstCharPtrMaxLength,const Boolean inTreatMultipleDelimsAsSingleDelim) 2321{ 2322int theItem; 2323int theSrcCharIndex; 2324int 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 2390EXITPOINT: 2391 2392 return; 2393} 2394 2395 2396 2397OSErr ExtractCStrItemFromCStrIntoNewHandle(const char *inSrcCStr,const char inItemDelimiter,const int inItemNumber,Boolean *foundItem,Handle *outNewHandle,const Boolean inTreatMultipleDelimsAsSingleDelim) 2398{ 2399OSErr errCode; 2400int theItem; 2401int theSrcCharIndex; 2402int 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 2502EXITPOINT: 2503 2504 return(errCode); 2505} 2506 2507 2508 2509 2510 2511 2512OSErr ExtractFloatFromCStr(const char *inCString,extended80 *outFloat) 2513{ 2514OSErr errCode; 2515Str255 theStr255; 2516Handle theNumberPartsTableHandle = nil; 2517long theNumberPartsOffset,theNumberPartsLength; 2518FormatResultType theFormatResultType; 2519NumberParts theNumberPartsTable; 2520NumFormatStringRec 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 2584EXITPOINT: 2585 2586 return(errCode); 2587} 2588 2589 2590 2591OSErr CopyFloatToCStr(const extended80 *theFloat,char *theCStr,const int maxCStrLength,const int inMaxNumIntDigits,const int inMaxNumFractDigits) 2592{ 2593OSErr errCode; 2594Str255 theStr255; 2595Handle theNumberPartsTableHandle = nil; 2596long theNumberPartsOffset,theNumberPartsLength; 2597FormatResultType theFormatResultType; 2598NumberParts theNumberPartsTable; 2599NumFormatStringRec 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 2724EXITPOINT: 2725 2726 return(errCode); 2727} 2728 2729 2730 2731 2732 2733void 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} 2754