| /* ==================================================================== |
| * Copyright (c) 1998-1999 The OpenSSL Project. All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * 1. Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * |
| * 2. Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in |
| * the documentation and/or other materials provided with the |
| * distribution. |
| * |
| * 3. All advertising materials mentioning features or use of this |
| * software must display the following acknowledgment: |
| * "This product includes software developed by the OpenSSL Project |
| * for use in the OpenSSL Toolkit. (http://www.openssl.org/)" |
| * |
| * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to |
| * endorse or promote products derived from this software without |
| * prior written permission. For written permission, please contact |
| * openssl-core@openssl.org. |
| * |
| * 5. Products derived from this software may not be called "OpenSSL" |
| * nor may "OpenSSL" appear in their names without prior written |
| * permission of the OpenSSL Project. |
| * |
| * 6. Redistributions of any form whatsoever must retain the following |
| * acknowledgment: |
| * "This product includes software developed by the OpenSSL Project |
| * for use in the OpenSSL Toolkit (http://www.openssl.org/)" |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY |
| * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE |
| * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR |
| * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE OpenSSL PROJECT OR |
| * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
| * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; |
| * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) |
| * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, |
| * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) |
| * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED |
| * OF THE POSSIBILITY OF SUCH DAMAGE. |
| * ==================================================================== |
| * |
| * This product includes cryptographic software written by Eric Young |
| * (eay@cryptsoft.com). This product includes software written by Tim |
| * Hudson (tjh@cryptsoft.com). |
| * |
| */ |
| |
| |
| |
| #include "CPStringUtils.hpp" |
| #include "ErrorHandling.hpp" |
| |
| |
| |
| #define kNumberFormatString "\p########0.00#######;-########0.00#######" |
| |
| |
| |
| // Useful utility functions which could be optimized a whole lot |
| |
| |
| void CopyPStrToCStr(const unsigned char *thePStr,char *theCStr,const int maxCStrLength) |
| { |
| int i,numPChars; |
| |
| |
| if (thePStr != nil && theCStr != nil && maxCStrLength > 0) |
| { |
| numPChars = thePStr[0]; |
| |
| for (i = 0;;i++) |
| { |
| if (i >= numPChars || i >= maxCStrLength - 1) |
| { |
| theCStr[i] = 0; |
| |
| break; |
| } |
| |
| else |
| { |
| theCStr[i] = thePStr[i + 1]; |
| } |
| } |
| } |
| } |
| |
| |
| void CopyPStrToPStr(const unsigned char *theSrcPStr,unsigned char *theDstPStr,const int maxDstStrLength) |
| { |
| int theMaxDstStrLength; |
| |
| |
| theMaxDstStrLength = maxDstStrLength; |
| |
| |
| if (theDstPStr != nil && theSrcPStr != nil && theMaxDstStrLength > 0) |
| { |
| if (theMaxDstStrLength > 255) |
| { |
| theMaxDstStrLength = 255; |
| } |
| |
| |
| if (theMaxDstStrLength - 1 < theSrcPStr[0]) |
| { |
| BlockMove(theSrcPStr + 1,theDstPStr + 1,theMaxDstStrLength - 1); |
| |
| theDstPStr[0] = theMaxDstStrLength - 1; |
| } |
| |
| else |
| { |
| BlockMove(theSrcPStr,theDstPStr,theSrcPStr[0] + 1); |
| } |
| } |
| } |
| |
| |
| void CopyCStrToCStr(const char *theSrcCStr,char *theDstCStr,const int maxDstStrLength) |
| { |
| int i; |
| |
| |
| if (theDstCStr != nil && theSrcCStr != nil && maxDstStrLength > 0) |
| { |
| for (i = 0;;i++) |
| { |
| if (theSrcCStr[i] == 0 || i >= maxDstStrLength - 1) |
| { |
| theDstCStr[i] = 0; |
| |
| break; |
| } |
| |
| else |
| { |
| theDstCStr[i] = theSrcCStr[i]; |
| } |
| } |
| } |
| } |
| |
| |
| |
| void CopyCSubstrToCStr(const char *theSrcCStr,const int maxCharsToCopy,char *theDstCStr,const int maxDstStrLength) |
| { |
| int i; |
| |
| |
| if (theDstCStr != nil && theSrcCStr != nil && maxDstStrLength > 0) |
| { |
| for (i = 0;;i++) |
| { |
| if (theSrcCStr[i] == 0 || i >= maxDstStrLength - 1 || i >= maxCharsToCopy) |
| { |
| theDstCStr[i] = 0; |
| |
| break; |
| } |
| |
| else |
| { |
| theDstCStr[i] = theSrcCStr[i]; |
| } |
| } |
| } |
| } |
| |
| |
| |
| void CopyCSubstrToPStr(const char *theSrcCStr,const int maxCharsToCopy,unsigned char *theDstPStr,const int maxDstStrLength) |
| { |
| int i; |
| int theMaxDstStrLength; |
| |
| |
| theMaxDstStrLength = maxDstStrLength; |
| |
| if (theDstPStr != nil && theSrcCStr != nil && theMaxDstStrLength > 0) |
| { |
| if (theMaxDstStrLength > 255) |
| { |
| theMaxDstStrLength = 255; |
| } |
| |
| |
| for (i = 0;;i++) |
| { |
| if (theSrcCStr[i] == 0 || i >= theMaxDstStrLength - 1 || i >= maxCharsToCopy) |
| { |
| theDstPStr[0] = i; |
| |
| break; |
| } |
| |
| else |
| { |
| theDstPStr[i + 1] = theSrcCStr[i]; |
| } |
| } |
| } |
| } |
| |
| |
| |
| void CopyCStrToPStr(const char *theSrcCStr,unsigned char *theDstPStr,const int maxDstStrLength) |
| { |
| int i; |
| int theMaxDstStrLength; |
| |
| |
| theMaxDstStrLength = maxDstStrLength; |
| |
| if (theDstPStr != nil && theSrcCStr != nil && theMaxDstStrLength > 0) |
| { |
| if (theMaxDstStrLength > 255) |
| { |
| theMaxDstStrLength = 255; |
| } |
| |
| |
| for (i = 0;;i++) |
| { |
| if (i >= theMaxDstStrLength - 1 || theSrcCStr[i] == 0) |
| { |
| theDstPStr[0] = i; |
| |
| break; |
| } |
| |
| else |
| { |
| theDstPStr[i + 1] = theSrcCStr[i]; |
| } |
| } |
| } |
| } |
| |
| |
| void ConcatPStrToCStr(const unsigned char *thePStr,char *theCStr,const int maxCStrLength) |
| { |
| int i,numPChars,cStrLength; |
| |
| |
| if (thePStr != nil && theCStr != nil && maxCStrLength > 0) |
| { |
| for (cStrLength = 0;theCStr[cStrLength] != 0;cStrLength++) |
| { |
| |
| } |
| |
| |
| numPChars = thePStr[0]; |
| |
| |
| for (i = 0;;i++) |
| { |
| if (i >= numPChars || cStrLength >= maxCStrLength - 1) |
| { |
| theCStr[cStrLength++] = 0; |
| |
| break; |
| } |
| |
| else |
| { |
| theCStr[cStrLength++] = thePStr[i + 1]; |
| } |
| } |
| } |
| } |
| |
| |
| |
| void ConcatPStrToPStr(const unsigned char *theSrcPStr,unsigned char *theDstPStr,const int maxDstStrLength) |
| { |
| int theMaxDstStrLength; |
| |
| |
| theMaxDstStrLength = maxDstStrLength; |
| |
| if (theSrcPStr != nil && theDstPStr != nil && theMaxDstStrLength > 0) |
| { |
| if (theMaxDstStrLength > 255) |
| { |
| theMaxDstStrLength = 255; |
| } |
| |
| |
| if (theMaxDstStrLength - theDstPStr[0] - 1 < theSrcPStr[0]) |
| { |
| BlockMove(theSrcPStr + 1,theDstPStr + theDstPStr[0] + 1,theMaxDstStrLength - 1 - theDstPStr[0]); |
| |
| theDstPStr[0] = theMaxDstStrLength - 1; |
| } |
| |
| else |
| { |
| BlockMove(theSrcPStr + 1,theDstPStr + theDstPStr[0] + 1,theSrcPStr[0]); |
| |
| theDstPStr[0] += theSrcPStr[0]; |
| } |
| } |
| } |
| |
| |
| |
| void ConcatCStrToPStr(const char *theSrcCStr,unsigned char *theDstPStr,const int maxDstStrLength) |
| { |
| int i,thePStrLength; |
| int theMaxDstStrLength; |
| |
| |
| theMaxDstStrLength = maxDstStrLength; |
| |
| if (theSrcCStr != nil && theDstPStr != nil && theMaxDstStrLength > 0) |
| { |
| if (theMaxDstStrLength > 255) |
| { |
| theMaxDstStrLength = 255; |
| } |
| |
| |
| thePStrLength = theDstPStr[0]; |
| |
| for (i = 0;;i++) |
| { |
| if (theSrcCStr[i] == 0 || thePStrLength >= theMaxDstStrLength - 1) |
| { |
| theDstPStr[0] = thePStrLength; |
| |
| break; |
| } |
| |
| else |
| { |
| theDstPStr[thePStrLength + 1] = theSrcCStr[i]; |
| |
| thePStrLength++; |
| } |
| } |
| } |
| } |
| |
| |
| |
| void ConcatCStrToCStr(const char *theSrcCStr,char *theDstCStr,const int maxCStrLength) |
| { |
| int cStrLength; |
| |
| |
| if (theSrcCStr != nil && theDstCStr != nil && maxCStrLength > 0) |
| { |
| for (cStrLength = 0;theDstCStr[cStrLength] != 0;cStrLength++) |
| { |
| |
| } |
| |
| |
| for (;;) |
| { |
| if (*theSrcCStr == 0 || cStrLength >= maxCStrLength - 1) |
| { |
| theDstCStr[cStrLength++] = 0; |
| |
| break; |
| } |
| |
| else |
| { |
| theDstCStr[cStrLength++] = *theSrcCStr++; |
| } |
| } |
| } |
| } |
| |
| |
| |
| void ConcatCharToCStr(const char theChar,char *theDstCStr,const int maxCStrLength) |
| { |
| int cStrLength; |
| |
| |
| if (theDstCStr != nil && maxCStrLength > 0) |
| { |
| cStrLength = CStrLength(theDstCStr); |
| |
| if (cStrLength < maxCStrLength - 1) |
| { |
| theDstCStr[cStrLength++] = theChar; |
| theDstCStr[cStrLength++] = '\0'; |
| } |
| } |
| } |
| |
| |
| |
| void ConcatCharToPStr(const char theChar,unsigned char *theDstPStr,const int maxPStrLength) |
| { |
| int pStrLength; |
| |
| |
| if (theDstPStr != nil && maxPStrLength > 0) |
| { |
| pStrLength = PStrLength(theDstPStr); |
| |
| if (pStrLength < maxPStrLength - 1 && pStrLength < 255) |
| { |
| theDstPStr[pStrLength + 1] = theChar; |
| theDstPStr[0] += 1; |
| } |
| } |
| } |
| |
| |
| |
| |
| int CompareCStrs(const char *theFirstCStr,const char *theSecondCStr,const Boolean ignoreCase) |
| { |
| int returnValue; |
| char firstChar,secondChar; |
| |
| |
| returnValue = 0; |
| |
| |
| if (theFirstCStr != nil && theSecondCStr != nil) |
| { |
| for (;;) |
| { |
| firstChar = *theFirstCStr; |
| secondChar = *theSecondCStr; |
| |
| if (ignoreCase == true) |
| { |
| if (firstChar >= 'A' && firstChar <= 'Z') |
| { |
| firstChar = 'a' + (firstChar - 'A'); |
| } |
| |
| if (secondChar >= 'A' && secondChar <= 'Z') |
| { |
| secondChar = 'a' + (secondChar - 'A'); |
| } |
| } |
| |
| |
| if (firstChar == 0 && secondChar != 0) |
| { |
| returnValue = -1; |
| |
| break; |
| } |
| |
| else if (firstChar != 0 && secondChar == 0) |
| { |
| returnValue = 1; |
| |
| break; |
| } |
| |
| else if (firstChar == 0 && secondChar == 0) |
| { |
| returnValue = 0; |
| |
| break; |
| } |
| |
| else if (firstChar < secondChar) |
| { |
| returnValue = -1; |
| |
| break; |
| } |
| |
| else if (firstChar > secondChar) |
| { |
| returnValue = 1; |
| |
| break; |
| } |
| |
| theFirstCStr++; |
| theSecondCStr++; |
| } |
| } |
| |
| |
| return(returnValue); |
| } |
| |
| |
| |
| Boolean CStrsAreEqual(const char *theFirstCStr,const char *theSecondCStr,const Boolean ignoreCase) |
| { |
| if (CompareCStrs(theFirstCStr,theSecondCStr,ignoreCase) == 0) |
| { |
| return true; |
| } |
| |
| else |
| { |
| return false; |
| } |
| } |
| |
| |
| Boolean PStrsAreEqual(const unsigned char *theFirstPStr,const unsigned char *theSecondPStr,const Boolean ignoreCase) |
| { |
| if (ComparePStrs(theFirstPStr,theSecondPStr,ignoreCase) == 0) |
| { |
| return true; |
| } |
| |
| else |
| { |
| return false; |
| } |
| } |
| |
| |
| |
| int ComparePStrs(const unsigned char *theFirstPStr,const unsigned char *theSecondPStr,const Boolean ignoreCase) |
| { |
| int i,returnValue; |
| char firstChar,secondChar; |
| |
| |
| returnValue = 0; |
| |
| |
| if (theFirstPStr != nil && theSecondPStr != nil) |
| { |
| for (i = 1;;i++) |
| { |
| firstChar = theFirstPStr[i]; |
| secondChar = theSecondPStr[i]; |
| |
| if (ignoreCase == true) |
| { |
| if (firstChar >= 'A' && firstChar <= 'Z') |
| { |
| firstChar = 'a' + (firstChar - 'A'); |
| } |
| |
| if (secondChar >= 'A' && secondChar <= 'Z') |
| { |
| secondChar = 'a' + (secondChar - 'A'); |
| } |
| } |
| |
| |
| if (theFirstPStr[0] < i && theSecondPStr[0] >= i) |
| { |
| returnValue = -1; |
| |
| break; |
| } |
| |
| else if (theFirstPStr[0] >= i && theSecondPStr[0] < i) |
| { |
| returnValue = 1; |
| |
| break; |
| } |
| |
| else if (theFirstPStr[0] < i && theSecondPStr[0] < i) |
| { |
| returnValue = 0; |
| |
| break; |
| } |
| |
| else if (firstChar < secondChar) |
| { |
| returnValue = -1; |
| |
| break; |
| } |
| |
| else if (firstChar > secondChar) |
| { |
| returnValue = 1; |
| |
| break; |
| } |
| } |
| } |
| |
| |
| return(returnValue); |
| } |
| |
| |
| |
| int CompareCStrToPStr(const char *theCStr,const unsigned char *thePStr,const Boolean ignoreCase) |
| { |
| int returnValue; |
| char tempString[256]; |
| |
| |
| returnValue = 0; |
| |
| if (theCStr != nil && thePStr != nil) |
| { |
| CopyPStrToCStr(thePStr,tempString,sizeof(tempString)); |
| |
| returnValue = CompareCStrs(theCStr,tempString,ignoreCase); |
| } |
| |
| |
| return(returnValue); |
| } |
| |
| |
| |
| void ConcatLongIntToCStr(const long theNum,char *theCStr,const int maxCStrLength,const int numDigits) |
| { |
| Str255 theStr255; |
| |
| |
| NumToString(theNum,theStr255); |
| |
| |
| if (numDigits > 0) |
| { |
| int charsToInsert; |
| |
| |
| charsToInsert = numDigits - PStrLength(theStr255); |
| |
| if (charsToInsert > 0) |
| { |
| char tempString[256]; |
| |
| CopyCStrToCStr("",tempString,sizeof(tempString)); |
| |
| for (;charsToInsert > 0;charsToInsert--) |
| { |
| ConcatCStrToCStr("0",tempString,sizeof(tempString)); |
| } |
| |
| ConcatPStrToCStr(theStr255,tempString,sizeof(tempString)); |
| |
| CopyCStrToPStr(tempString,theStr255,sizeof(theStr255)); |
| } |
| } |
| |
| |
| ConcatPStrToCStr(theStr255,theCStr,maxCStrLength); |
| } |
| |
| |
| |
| |
| void ConcatLongIntToPStr(const long theNum,unsigned char *thePStr,const int maxPStrLength,const int numDigits) |
| { |
| Str255 theStr255; |
| |
| |
| NumToString(theNum,theStr255); |
| |
| |
| if (numDigits > 0) |
| { |
| int charsToInsert; |
| |
| |
| charsToInsert = numDigits - PStrLength(theStr255); |
| |
| if (charsToInsert > 0) |
| { |
| char tempString[256]; |
| |
| CopyCStrToCStr("",tempString,sizeof(tempString)); |
| |
| for (;charsToInsert > 0;charsToInsert--) |
| { |
| ConcatCStrToCStr("0",tempString,sizeof(tempString)); |
| } |
| |
| ConcatPStrToCStr(theStr255,tempString,sizeof(tempString)); |
| |
| CopyCStrToPStr(tempString,theStr255,sizeof(theStr255)); |
| } |
| } |
| |
| |
| ConcatPStrToPStr(theStr255,thePStr,maxPStrLength); |
| } |
| |
| |
| |
| void CopyCStrAndConcatLongIntToCStr(const char *theSrcCStr,const long theNum,char *theDstCStr,const int maxDstStrLength) |
| { |
| CopyCStrToCStr(theSrcCStr,theDstCStr,maxDstStrLength); |
| |
| ConcatLongIntToCStr(theNum,theDstCStr,maxDstStrLength); |
| } |
| |
| |
| |
| void CopyLongIntToCStr(const long theNum,char *theCStr,const int maxCStrLength,const int numDigits) |
| { |
| Str255 theStr255; |
| |
| |
| NumToString(theNum,theStr255); |
| |
| |
| if (numDigits > 0) |
| { |
| int charsToInsert; |
| |
| |
| charsToInsert = numDigits - PStrLength(theStr255); |
| |
| if (charsToInsert > 0) |
| { |
| char tempString[256]; |
| |
| CopyCStrToCStr("",tempString,sizeof(tempString)); |
| |
| for (;charsToInsert > 0;charsToInsert--) |
| { |
| ConcatCStrToCStr("0",tempString,sizeof(tempString)); |
| } |
| |
| ConcatPStrToCStr(theStr255,tempString,sizeof(tempString)); |
| |
| CopyCStrToPStr(tempString,theStr255,sizeof(theStr255)); |
| } |
| } |
| |
| |
| CopyPStrToCStr(theStr255,theCStr,maxCStrLength); |
| } |
| |
| |
| |
| |
| |
| void CopyUnsignedLongIntToCStr(const unsigned long theNum,char *theCStr,const int maxCStrLength) |
| { |
| char tempString[256]; |
| int srcCharIndex,dstCharIndex; |
| unsigned long tempNum,quotient,remainder; |
| |
| |
| if (theNum == 0) |
| { |
| CopyCStrToCStr("0",theCStr,maxCStrLength); |
| } |
| |
| else |
| { |
| srcCharIndex = 0; |
| |
| tempNum = theNum; |
| |
| for (;;) |
| { |
| if (srcCharIndex >= sizeof(tempString) - 1 || tempNum == 0) |
| { |
| for (dstCharIndex = 0;;) |
| { |
| if (dstCharIndex >= maxCStrLength - 1 || srcCharIndex <= 0) |
| { |
| theCStr[dstCharIndex] = 0; |
| |
| break; |
| } |
| |
| theCStr[dstCharIndex++] = tempString[--srcCharIndex]; |
| } |
| |
| break; |
| } |
| |
| |
| quotient = tempNum / 10; |
| |
| remainder = tempNum - (quotient * 10); |
| |
| tempString[srcCharIndex] = '0' + remainder; |
| |
| srcCharIndex++; |
| |
| tempNum = quotient; |
| } |
| } |
| } |
| |
| |
| |
| |
| void CopyLongIntToPStr(const long theNum,unsigned char *thePStr,const int maxPStrLength,const int numDigits) |
| { |
| char tempString[256]; |
| |
| |
| CopyLongIntToCStr(theNum,tempString,sizeof(tempString),numDigits); |
| |
| CopyCStrToPStr(tempString,thePStr,maxPStrLength); |
| } |
| |
| |
| |
| OSErr CopyLongIntToNewHandle(const long inTheLongInt,Handle *theHandle) |
| { |
| OSErr errCode = noErr; |
| char tempString[32]; |
| |
| |
| CopyLongIntToCStr(inTheLongInt,tempString,sizeof(tempString)); |
| |
| errCode = CopyCStrToNewHandle(tempString,theHandle); |
| |
| return(errCode); |
| } |
| |
| |
| OSErr CopyLongIntToExistingHandle(const long inTheLongInt,Handle theHandle) |
| { |
| OSErr errCode = noErr; |
| char tempString[32]; |
| |
| |
| CopyLongIntToCStr(inTheLongInt,tempString,sizeof(tempString)); |
| |
| errCode = CopyCStrToExistingHandle(tempString,theHandle); |
| |
| return(errCode); |
| } |
| |
| |
| |
| |
| OSErr CopyCStrToExistingHandle(const char *theCString,Handle theHandle) |
| { |
| OSErr errCode = noErr; |
| long stringLength; |
| |
| |
| if (theCString == nil) |
| { |
| SetErrorMessageAndBail(("CopyCStrToExistingHandle: Bad parameter, theCString == nil")); |
| } |
| |
| if (theHandle == nil) |
| { |
| SetErrorMessageAndBail(("CopyCStrToExistingHandle: Bad parameter, theHandle == nil")); |
| } |
| |
| if (*theHandle == nil) |
| { |
| SetErrorMessageAndBail(("CopyCStrToExistingHandle: Bad parameter, *theHandle == nil")); |
| } |
| |
| |
| |
| stringLength = CStrLength(theCString) + 1; |
| |
| SetHandleSize(theHandle,stringLength); |
| |
| if (GetHandleSize(theHandle) < stringLength) |
| { |
| SetErrorMessageAndLongIntAndBail("CopyCStrToExistingHandle: Can't set Handle size, MemError() = ",MemError()); |
| } |
| |
| |
| ::BlockMove(theCString,*theHandle,stringLength); |
| |
| |
| EXITPOINT: |
| |
| return(errCode); |
| } |
| |
| |
| |
| |
| |
| OSErr CopyCStrToNewHandle(const char *theCString,Handle *theHandle) |
| { |
| OSErr errCode = noErr; |
| long stringLength; |
| |
| |
| if (theCString == nil) |
| { |
| SetErrorMessageAndBail(("CopyCStrToNewHandle: Bad parameter, theCString == nil")); |
| } |
| |
| if (theHandle == nil) |
| { |
| SetErrorMessageAndBail(("CopyCStrToNewHandle: Bad parameter, theHandle == nil")); |
| } |
| |
| |
| |
| stringLength = CStrLength(theCString) + 1; |
| |
| *theHandle = NewHandle(stringLength); |
| |
| if (*theHandle == nil) |
| { |
| SetErrorMessageAndLongIntAndBail("CopyCStrToNewHandle: Can't allocate Handle, MemError() = ",MemError()); |
| } |
| |
| |
| ::BlockMove(theCString,**theHandle,stringLength); |
| |
| |
| EXITPOINT: |
| |
| return(errCode); |
| } |
| |
| |
| |
| OSErr CopyPStrToNewHandle(const unsigned char *thePString,Handle *theHandle) |
| { |
| OSErr errCode = noErr; |
| long stringLength; |
| |
| |
| if (thePString == nil) |
| { |
| SetErrorMessageAndBail(("CopyPStrToNewHandle: Bad parameter, thePString == nil")); |
| } |
| |
| if (theHandle == nil) |
| { |
| SetErrorMessageAndBail(("CopyPStrToNewHandle: Bad parameter, theHandle == nil")); |
| } |
| |
| |
| |
| stringLength = PStrLength(thePString) + 1; |
| |
| *theHandle = NewHandle(stringLength); |
| |
| if (*theHandle == nil) |
| { |
| SetErrorMessageAndLongIntAndBail("CopyPStrToNewHandle: Can't allocate Handle, MemError() = ",MemError()); |
| } |
| |
| |
| if (stringLength > 1) |
| { |
| BlockMove(thePString + 1,**theHandle,stringLength - 1); |
| } |
| |
| (**theHandle)[stringLength - 1] = 0; |
| |
| |
| EXITPOINT: |
| |
| return(errCode); |
| } |
| |
| |
| OSErr AppendPStrToHandle(const unsigned char *thePString,Handle theHandle,long *currentLength) |
| { |
| OSErr errCode = noErr; |
| char tempString[256]; |
| |
| |
| CopyPStrToCStr(thePString,tempString,sizeof(tempString)); |
| |
| errCode = AppendCStrToHandle(tempString,theHandle,currentLength); |
| |
| |
| EXITPOINT: |
| |
| return(errCode); |
| } |
| |
| |
| |
| OSErr AppendCStrToHandle(const char *theCString,Handle theHandle,long *currentLength,long *maxLength) |
| { |
| OSErr errCode = noErr; |
| long handleMaxLength,handleCurrentLength,stringLength,byteCount; |
| |
| |
| if (theCString == nil) |
| { |
| SetErrorMessageAndBail(("AppendCStrToHandle: Bad parameter, theCString == nil")); |
| } |
| |
| if (theHandle == nil) |
| { |
| SetErrorMessageAndBail(("AppendCStrToHandle: Bad parameter, theHandle == nil")); |
| } |
| |
| |
| if (maxLength != nil) |
| { |
| handleMaxLength = *maxLength; |
| } |
| |
| else |
| { |
| handleMaxLength = GetHandleSize(theHandle); |
| } |
| |
| |
| if (currentLength != nil && *currentLength >= 0) |
| { |
| handleCurrentLength = *currentLength; |
| } |
| |
| else |
| { |
| handleCurrentLength = CStrLength(*theHandle); |
| } |
| |
| |
| stringLength = CStrLength(theCString); |
| |
| byteCount = handleCurrentLength + stringLength + 1; |
| |
| if (byteCount > handleMaxLength) |
| { |
| SetHandleSize(theHandle,handleCurrentLength + stringLength + 1); |
| |
| if (maxLength != nil) |
| { |
| *maxLength = GetHandleSize(theHandle); |
| |
| handleMaxLength = *maxLength; |
| } |
| |
| else |
| { |
| handleMaxLength = GetHandleSize(theHandle); |
| } |
| |
| if (byteCount > handleMaxLength) |
| { |
| SetErrorMessageAndLongIntAndBail("AppendCStrToHandle: Can't increase Handle allocation, MemError() = ",MemError()); |
| } |
| } |
| |
| |
| BlockMove(theCString,*theHandle + handleCurrentLength,stringLength + 1); |
| |
| |
| if (currentLength != nil) |
| { |
| *currentLength += stringLength; |
| } |
| |
| |
| errCode = noErr; |
| |
| |
| EXITPOINT: |
| |
| return(errCode); |
| } |
| |
| |
| |
| OSErr AppendCharsToHandle(const char *theChars,const int numChars,Handle theHandle,long *currentLength,long *maxLength) |
| { |
| OSErr errCode = noErr; |
| long handleMaxLength,handleCurrentLength,byteCount; |
| |
| |
| if (theChars == nil) |
| { |
| SetErrorMessageAndBail(("AppendCharsToHandle: Bad parameter, theChars == nil")); |
| } |
| |
| if (theHandle == nil) |
| { |
| SetErrorMessageAndBail(("AppendCharsToHandle: Bad parameter, theHandle == nil")); |
| } |
| |
| |
| if (maxLength != nil) |
| { |
| handleMaxLength = *maxLength; |
| } |
| |
| else |
| { |
| handleMaxLength = GetHandleSize(theHandle); |
| } |
| |
| |
| if (currentLength != nil && *currentLength >= 0) |
| { |
| handleCurrentLength = *currentLength; |
| } |
| |
| else |
| { |
| handleCurrentLength = CStrLength(*theHandle); |
| } |
| |
| |
| byteCount = handleCurrentLength + numChars + 1; |
| |
| if (byteCount > handleMaxLength) |
| { |
| SetHandleSize(theHandle,handleCurrentLength + numChars + 1); |
| |
| if (maxLength != nil) |
| { |
| *maxLength = GetHandleSize(theHandle); |
| |
| handleMaxLength = *maxLength; |
| } |
| |
| else |
| { |
| handleMaxLength = GetHandleSize(theHandle); |
| } |
| |
| if (byteCount > handleMaxLength) |
| { |
| SetErrorMessageAndLongIntAndBail("AppendCharsToHandle: Can't increase Handle allocation, MemError() = ",MemError()); |
| } |
| } |
| |
| |
| BlockMove(theChars,*theHandle + handleCurrentLength,numChars); |
| |
| (*theHandle)[handleCurrentLength + numChars] = '\0'; |
| |
| if (currentLength != nil) |
| { |
| *currentLength += numChars; |
| } |
| |
| |
| errCode = noErr; |
| |
| |
| EXITPOINT: |
| |
| return(errCode); |
| } |
| |
| |
| |
| OSErr AppendLongIntToHandle(const long inTheLongInt,Handle theHandle,long *currentLength) |
| { |
| OSErr errCode = noErr; |
| char tempString[32]; |
| |
| |
| CopyLongIntToCStr(inTheLongInt,tempString,sizeof(tempString)); |
| |
| errCode = AppendCStrToHandle(tempString,theHandle,currentLength); |
| |
| return(errCode); |
| } |
| |
| |
| |
| |
| long CStrLength(const char *theCString) |
| { |
| long cStrLength = 0; |
| |
| |
| if (theCString != nil) |
| { |
| for (cStrLength = 0;theCString[cStrLength] != 0;cStrLength++) |
| { |
| |
| } |
| } |
| |
| |
| return(cStrLength); |
| } |
| |
| |
| |
| long PStrLength(const unsigned char *thePString) |
| { |
| long pStrLength = 0; |
| |
| |
| if (thePString != nil) |
| { |
| pStrLength = thePString[0]; |
| } |
| |
| |
| return(pStrLength); |
| } |
| |
| |
| |
| |
| |
| void ZeroMem(void *theMemPtr,const unsigned long numBytes) |
| { |
| unsigned char *theBytePtr; |
| unsigned long *theLongPtr; |
| unsigned long numSingleBytes; |
| unsigned long theNumBytes; |
| |
| |
| theNumBytes = numBytes; |
| |
| if (theMemPtr != nil && theNumBytes > 0) |
| { |
| theBytePtr = (unsigned char *) theMemPtr; |
| |
| numSingleBytes = (unsigned long) theBytePtr & 0x0003; |
| |
| while (numSingleBytes > 0) |
| { |
| *theBytePtr++ = 0; |
| |
| theNumBytes--; |
| numSingleBytes--; |
| } |
| |
| |
| theLongPtr = (unsigned long *) theBytePtr; |
| |
| while (theNumBytes >= 4) |
| { |
| *theLongPtr++ = 0; |
| |
| theNumBytes -= 4; |
| } |
| |
| |
| theBytePtr = (unsigned char *) theLongPtr; |
| |
| while (theNumBytes > 0) |
| { |
| *theBytePtr++ = 0; |
| |
| theNumBytes--; |
| } |
| } |
| } |
| |
| |
| |
| |
| char *FindCharInCStr(const char theChar,const char *theCString) |
| { |
| char *theStringSearchPtr; |
| |
| |
| theStringSearchPtr = (char *) theCString; |
| |
| if (theStringSearchPtr != nil) |
| { |
| while (*theStringSearchPtr != '\0' && *theStringSearchPtr != theChar) |
| { |
| theStringSearchPtr++; |
| } |
| |
| if (*theStringSearchPtr == '\0') |
| { |
| theStringSearchPtr = nil; |
| } |
| } |
| |
| return(theStringSearchPtr); |
| } |
| |
| |
| |
| long FindCharOffsetInCStr(const char theChar,const char *theCString,const Boolean inIgnoreCase) |
| { |
| long theOffset = -1; |
| |
| |
| if (theCString != nil) |
| { |
| theOffset = 0; |
| |
| |
| if (inIgnoreCase) |
| { |
| char searchChar = theChar; |
| |
| if (searchChar >= 'a' && searchChar <= 'z') |
| { |
| searchChar = searchChar - 'a' + 'A'; |
| } |
| |
| |
| while (*theCString != 0) |
| { |
| char currentChar = *theCString; |
| |
| if (currentChar >= 'a' && currentChar <= 'z') |
| { |
| currentChar = currentChar - 'a' + 'A'; |
| } |
| |
| if (currentChar == searchChar) |
| { |
| break; |
| } |
| |
| theCString++; |
| theOffset++; |
| } |
| } |
| |
| else |
| { |
| while (*theCString != 0 && *theCString != theChar) |
| { |
| theCString++; |
| theOffset++; |
| } |
| } |
| |
| if (*theCString == 0) |
| { |
| theOffset = -1; |
| } |
| } |
| |
| return(theOffset); |
| } |
| |
| |
| long FindCStrOffsetInCStr(const char *theCSubstring,const char *theCString,const Boolean inIgnoreCase) |
| { |
| long theOffset = -1; |
| |
| |
| if (theCSubstring != nil && theCString != nil) |
| { |
| for (theOffset = 0;;theOffset++) |
| { |
| if (theCString[theOffset] == 0) |
| { |
| theOffset = -1; |
| |
| goto EXITPOINT; |
| } |
| |
| |
| for (const char *tempSubstringPtr = theCSubstring,*tempCStringPtr = theCString + theOffset;;tempSubstringPtr++,tempCStringPtr++) |
| { |
| if (*tempSubstringPtr == 0) |
| { |
| goto EXITPOINT; |
| } |
| |
| else if (*tempCStringPtr == 0) |
| { |
| break; |
| } |
| |
| char searchChar = *tempSubstringPtr; |
| char currentChar = *tempCStringPtr; |
| |
| if (inIgnoreCase && searchChar >= 'a' && searchChar <= 'z') |
| { |
| searchChar = searchChar - 'a' + 'A'; |
| } |
| |
| if (inIgnoreCase && currentChar >= 'a' && currentChar <= 'z') |
| { |
| currentChar = currentChar - 'a' + 'A'; |
| } |
| |
| if (currentChar != searchChar) |
| { |
| break; |
| } |
| } |
| } |
| |
| theOffset = -1; |
| } |
| |
| |
| EXITPOINT: |
| |
| return(theOffset); |
| } |
| |
| |
| |
| void InsertCStrIntoCStr(const char *theSrcCStr,const int theInsertionOffset,char *theDstCStr,const int maxDstStrLength) |
| { |
| int currentLength; |
| int insertLength; |
| int numCharsToInsert; |
| int numCharsToShift; |
| |
| |
| if (theDstCStr != nil && theSrcCStr != nil && maxDstStrLength > 0 && theInsertionOffset < maxDstStrLength - 1) |
| { |
| currentLength = CStrLength(theDstCStr); |
| |
| insertLength = CStrLength(theSrcCStr); |
| |
| |
| if (theInsertionOffset + insertLength < maxDstStrLength - 1) |
| { |
| numCharsToInsert = insertLength; |
| } |
| |
| else |
| { |
| numCharsToInsert = maxDstStrLength - 1 - theInsertionOffset; |
| } |
| |
| |
| if (numCharsToInsert + currentLength < maxDstStrLength - 1) |
| { |
| numCharsToShift = currentLength - theInsertionOffset; |
| } |
| |
| else |
| { |
| numCharsToShift = maxDstStrLength - 1 - theInsertionOffset - numCharsToInsert; |
| } |
| |
| |
| if (numCharsToShift > 0) |
| { |
| BlockMove(theDstCStr + theInsertionOffset,theDstCStr + theInsertionOffset + numCharsToInsert,numCharsToShift); |
| } |
| |
| if (numCharsToInsert > 0) |
| { |
| BlockMove(theSrcCStr,theDstCStr + theInsertionOffset,numCharsToInsert); |
| } |
| |
| theDstCStr[theInsertionOffset + numCharsToInsert + numCharsToShift] = 0; |
| } |
| } |
| |
| |
| |
| void InsertPStrIntoCStr(const unsigned char *theSrcPStr,const int theInsertionOffset,char *theDstCStr,const int maxDstStrLength) |
| { |
| int currentLength; |
| int insertLength; |
| int numCharsToInsert; |
| int numCharsToShift; |
| |
| |
| if (theDstCStr != nil && theSrcPStr != nil && maxDstStrLength > 0 && theInsertionOffset < maxDstStrLength - 1) |
| { |
| currentLength = CStrLength(theDstCStr); |
| |
| insertLength = PStrLength(theSrcPStr); |
| |
| |
| if (theInsertionOffset + insertLength < maxDstStrLength - 1) |
| { |
| numCharsToInsert = insertLength; |
| } |
| |
| else |
| { |
| numCharsToInsert = maxDstStrLength - 1 - theInsertionOffset; |
| } |
| |
| |
| if (numCharsToInsert + currentLength < maxDstStrLength - 1) |
| { |
| numCharsToShift = currentLength - theInsertionOffset; |
| } |
| |
| else |
| { |
| numCharsToShift = maxDstStrLength - 1 - theInsertionOffset - numCharsToInsert; |
| } |
| |
| |
| if (numCharsToShift > 0) |
| { |
| BlockMove(theDstCStr + theInsertionOffset,theDstCStr + theInsertionOffset + numCharsToInsert,numCharsToShift); |
| } |
| |
| if (numCharsToInsert > 0) |
| { |
| BlockMove(theSrcPStr + 1,theDstCStr + theInsertionOffset,numCharsToInsert); |
| } |
| |
| theDstCStr[theInsertionOffset + numCharsToInsert + numCharsToShift] = 0; |
| } |
| } |
| |
| |
| |
| OSErr InsertCStrIntoHandle(const char *theCString,Handle theHandle,const long inInsertOffset) |
| { |
| OSErr errCode; |
| int currentLength; |
| int insertLength; |
| |
| |
| SetErrorMessageAndBailIfNil(theCString,"InsertCStrIntoHandle: Bad parameter, theCString == nil"); |
| |
| SetErrorMessageAndBailIfNil(theHandle,"InsertCStrIntoHandle: Bad parameter, theHandle == nil"); |
| |
| currentLength = CStrLength(*theHandle); |
| |
| if (currentLength + 1 > ::GetHandleSize(theHandle)) |
| { |
| SetErrorMessageAndBail("InsertCStrIntoHandle: Handle has been overflowed"); |
| } |
| |
| if (inInsertOffset > currentLength) |
| { |
| SetErrorMessageAndBail("InsertCStrIntoHandle: Insertion offset is greater than string length"); |
| } |
| |
| insertLength = CStrLength(theCString); |
| |
| ::SetHandleSize(theHandle,currentLength + 1 + insertLength); |
| |
| if (::GetHandleSize(theHandle) < currentLength + 1 + insertLength) |
| { |
| SetErrorMessageAndLongIntAndBail("InsertCStrIntoHandle: Can't expand storage for Handle, MemError() = ",MemError()); |
| } |
| |
| ::BlockMove(*theHandle + inInsertOffset,*theHandle + inInsertOffset + insertLength,currentLength - inInsertOffset + 1); |
| |
| ::BlockMove(theCString,*theHandle + inInsertOffset,insertLength); |
| |
| |
| errCode = noErr; |
| |
| |
| EXITPOINT: |
| |
| return(errCode); |
| } |
| |
| |
| |
| |
| void CopyCStrAndInsert1LongIntIntoCStr(const char *theSrcCStr,const long theNum,char *theDstCStr,const int maxDstStrLength) |
| { |
| CopyCStrAndInsertCStrLongIntIntoCStr(theSrcCStr,nil,theNum,theDstCStr,maxDstStrLength); |
| } |
| |
| |
| void CopyCStrAndInsert2LongIntsIntoCStr(const char *theSrcCStr,const long long1,const long long2,char *theDstCStr,const int maxDstStrLength) |
| { |
| const long theLongInts[] = { long1,long2 }; |
| |
| CopyCStrAndInsertCStrsLongIntsIntoCStr(theSrcCStr,nil,theLongInts,theDstCStr,maxDstStrLength); |
| } |
| |
| |
| void CopyCStrAndInsert3LongIntsIntoCStr(const char *theSrcCStr,const long long1,const long long2,const long long3,char *theDstCStr,const int maxDstStrLength) |
| { |
| const long theLongInts[] = { long1,long2,long3 }; |
| |
| CopyCStrAndInsertCStrsLongIntsIntoCStr(theSrcCStr,nil,theLongInts,theDstCStr,maxDstStrLength); |
| } |
| |
| |
| void CopyCStrAndInsertCStrIntoCStr(const char *theSrcCStr,const char *theInsertCStr,char *theDstCStr,const int maxDstStrLength) |
| { |
| const char *theCStrs[2] = { theInsertCStr,nil }; |
| |
| CopyCStrAndInsertCStrsLongIntsIntoCStr(theSrcCStr,theCStrs,nil,theDstCStr,maxDstStrLength); |
| } |
| |
| |
| |
| void CopyCStrAndInsertCStrLongIntIntoCStr(const char *theSrcCStr,const char *theInsertCStr,const long theNum,char *theDstCStr,const int maxDstStrLength) |
| { |
| const char *theCStrs[2] = { theInsertCStr,nil }; |
| const long theLongInts[1] = { theNum }; |
| |
| CopyCStrAndInsertCStrsLongIntsIntoCStr(theSrcCStr,theCStrs,theLongInts,theDstCStr,maxDstStrLength); |
| } |
| |
| |
| |
| void CopyCStrAndInsertCStrsLongIntsIntoCStr(const char *theSrcCStr,const char **theInsertCStrs,const long *theLongInts,char *theDstCStr,const int maxDstStrLength) |
| { |
| int dstCharIndex,srcCharIndex,theMaxDstStrLength; |
| int theCStrIndex = 0; |
| int theLongIntIndex = 0; |
| |
| |
| theMaxDstStrLength = maxDstStrLength; |
| |
| if (theDstCStr != nil && theSrcCStr != nil && theMaxDstStrLength > 0) |
| { |
| dstCharIndex = 0; |
| |
| srcCharIndex = 0; |
| |
| |
| // Allow room for NULL at end of string |
| |
| theMaxDstStrLength--; |
| |
| |
| for (;;) |
| { |
| // Hit end of buffer? |
| |
| if (dstCharIndex >= theMaxDstStrLength) |
| { |
| theDstCStr[dstCharIndex++] = 0; |
| |
| goto EXITPOINT; |
| } |
| |
| // End of source string? |
| |
| else if (theSrcCStr[srcCharIndex] == 0) |
| { |
| theDstCStr[dstCharIndex++] = 0; |
| |
| goto EXITPOINT; |
| } |
| |
| // Did we find a '%s'? |
| |
| else if (theInsertCStrs != nil && theInsertCStrs[theCStrIndex] != nil && theSrcCStr[srcCharIndex] == '%' && theSrcCStr[srcCharIndex + 1] == 's') |
| { |
| // Skip over the '%s' |
| |
| srcCharIndex += 2; |
| |
| |
| // Terminate the dest string and then concat the string |
| |
| theDstCStr[dstCharIndex] = 0; |
| |
| ConcatCStrToCStr(theInsertCStrs[theCStrIndex],theDstCStr,theMaxDstStrLength); |
| |
| dstCharIndex = CStrLength(theDstCStr); |
| |
| theCStrIndex++; |
| } |
| |
| // Did we find a '%ld'? |
| |
| else if (theLongInts != nil && theSrcCStr[srcCharIndex] == '%' && theSrcCStr[srcCharIndex + 1] == 'l' && theSrcCStr[srcCharIndex + 2] == 'd') |
| { |
| // Skip over the '%ld' |
| |
| srcCharIndex += 3; |
| |
| |
| // Terminate the dest string and then concat the number |
| |
| theDstCStr[dstCharIndex] = 0; |
| |
| ConcatLongIntToCStr(theLongInts[theLongIntIndex],theDstCStr,theMaxDstStrLength); |
| |
| theLongIntIndex++; |
| |
| dstCharIndex = CStrLength(theDstCStr); |
| } |
| |
| else |
| { |
| theDstCStr[dstCharIndex++] = theSrcCStr[srcCharIndex++]; |
| } |
| } |
| } |
| |
| |
| |
| EXITPOINT: |
| |
| return; |
| } |
| |
| |
| |
| |
| |
| OSErr CopyCStrAndInsertCStrLongIntIntoHandle(const char *theSrcCStr,const char *theInsertCStr,const long theNum,Handle *theHandle) |
| { |
| OSErr errCode; |
| long byteCount; |
| |
| |
| if (theHandle != nil) |
| { |
| byteCount = CStrLength(theSrcCStr) + CStrLength(theInsertCStr) + 32; |
| |
| *theHandle = NewHandle(byteCount); |
| |
| if (*theHandle == nil) |
| { |
| SetErrorMessageAndLongIntAndBail("CopyCStrAndInsertCStrLongIntIntoHandle: Can't allocate Handle, MemError() = ",MemError()); |
| } |
| |
| |
| HLock(*theHandle); |
| |
| CopyCStrAndInsertCStrLongIntIntoCStr(theSrcCStr,theInsertCStr,theNum,**theHandle,byteCount); |
| |
| HUnlock(*theHandle); |
| } |
| |
| errCode = noErr; |
| |
| |
| EXITPOINT: |
| |
| return(errCode); |
| } |
| |
| |
| |
| |
| |
| OSErr CopyIndexedWordToCStr(char *theSrcCStr,int whichWord,char *theDstCStr,int maxDstCStrLength) |
| { |
| OSErr errCode; |
| char *srcCharPtr,*dstCharPtr; |
| int wordCount; |
| int byteCount; |
| |
| |
| if (theSrcCStr == nil) |
| { |
| SetErrorMessageAndBail(("CopyIndexedWordToCStr: Bad parameter, theSrcCStr == nil")); |
| } |
| |
| if (theDstCStr == nil) |
| { |
| SetErrorMessageAndBail(("CopyIndexedWordToCStr: Bad parameter, theDstCStr == nil")); |
| } |
| |
| if (whichWord < 0) |
| { |
| SetErrorMessageAndBail(("CopyIndexedWordToCStr: Bad parameter, whichWord < 0")); |
| } |
| |
| if (maxDstCStrLength <= 0) |
| { |
| SetErrorMessageAndBail(("CopyIndexedWordToCStr: Bad parameter, maxDstCStrLength <= 0")); |
| } |
| |
| |
| *theDstCStr = '\0'; |
| |
| srcCharPtr = theSrcCStr; |
| |
| while (*srcCharPtr == ' ' || *srcCharPtr == '\t') |
| { |
| srcCharPtr++; |
| } |
| |
| |
| for (wordCount = 0;wordCount < whichWord;wordCount++) |
| { |
| while (*srcCharPtr != ' ' && *srcCharPtr != '\t' && *srcCharPtr != '\r' && *srcCharPtr != '\n' && *srcCharPtr != '\0') |
| { |
| srcCharPtr++; |
| } |
| |
| if (*srcCharPtr == '\r' || *srcCharPtr == '\n' || *srcCharPtr == '\0') |
| { |
| errCode = noErr; |
| |
| goto EXITPOINT; |
| } |
| |
| while (*srcCharPtr == ' ' || *srcCharPtr == '\t') |
| { |
| srcCharPtr++; |
| } |
| |
| if (*srcCharPtr == '\r' || *srcCharPtr == '\n' || *srcCharPtr == '\0') |
| { |
| errCode = noErr; |
| |
| goto EXITPOINT; |
| } |
| } |
| |
| |
| dstCharPtr = theDstCStr; |
| byteCount = 0; |
| |
| |
| for(;;) |
| { |
| if (byteCount >= maxDstCStrLength - 1 || *srcCharPtr == '\0' || *srcCharPtr == ' ' || *srcCharPtr == '\t' || *srcCharPtr == '\r' || *srcCharPtr == '\n') |
| { |
| *dstCharPtr = '\0'; |
| break; |
| } |
| |
| *dstCharPtr++ = *srcCharPtr++; |
| |
| byteCount++; |
| } |
| |
| |
| errCode = noErr; |
| |
| |
| EXITPOINT: |
| |
| return(errCode); |
| } |
| |
| |
| |
| |
| |
| OSErr CopyIndexedWordToNewHandle(char *theSrcCStr,int whichWord,Handle *outTheHandle) |
| { |
| OSErr errCode; |
| char *srcCharPtr; |
| int wordCount; |
| int byteCount; |
| |
| |
| if (theSrcCStr == nil) |
| { |
| SetErrorMessageAndBail(("CopyIndexedWordToNewHandle: Bad parameter, theSrcCStr == nil")); |
| } |
| |
| if (outTheHandle == nil) |
| { |
| SetErrorMessageAndBail(("CopyIndexedWordToNewHandle: Bad parameter, outTheHandle == nil")); |
| } |
| |
| if (whichWord < 0) |
| { |
| SetErrorMessageAndBail(("CopyIndexedWordToNewHandle: Bad parameter, whichWord < 0")); |
| } |
| |
| |
| *outTheHandle = nil; |
| |
| |
| srcCharPtr = theSrcCStr; |
| |
| while (*srcCharPtr == ' ' || *srcCharPtr == '\t') |
| { |
| srcCharPtr++; |
| } |
| |
| |
| for (wordCount = 0;wordCount < whichWord;wordCount++) |
| { |
| while (*srcCharPtr != ' ' && *srcCharPtr != '\t' && *srcCharPtr != '\r' && *srcCharPtr != '\n' && *srcCharPtr != '\0') |
| { |
| srcCharPtr++; |
| } |
| |
| if (*srcCharPtr == '\r' || *srcCharPtr == '\n' || *srcCharPtr == '\0') |
| { |
| break; |
| } |
| |
| while (*srcCharPtr == ' ' || *srcCharPtr == '\t') |
| { |
| srcCharPtr++; |
| } |
| |
| if (*srcCharPtr == '\r' || *srcCharPtr == '\n' || *srcCharPtr == '\0') |
| { |
| break; |
| } |
| } |
| |
| |
| for (byteCount = 0;;byteCount++) |
| { |
| if (srcCharPtr[byteCount] == ' ' || srcCharPtr[byteCount] == '\t' || srcCharPtr[byteCount] == '\r' || srcCharPtr[byteCount] == '\n' || srcCharPtr[byteCount] == '\0') |
| { |
| break; |
| } |
| } |
| |
| |
| *outTheHandle = NewHandle(byteCount + 1); |
| |
| if (*outTheHandle == nil) |
| { |
| SetErrorMessageAndLongIntAndBail("CopyIndexedWordToNewHandle: Can't allocate Handle, MemError() = ",MemError()); |
| } |
| |
| |
| ::BlockMove(srcCharPtr,**outTheHandle,byteCount); |
| |
| (**outTheHandle)[byteCount] = '\0'; |
| |
| errCode = noErr; |
| |
| |
| EXITPOINT: |
| |
| return(errCode); |
| } |
| |
| |
| |
| OSErr CopyIndexedLineToCStr(const char *theSrcCStr,int inWhichLine,int *lineEndIndex,Boolean *gotLastLine,char *theDstCStr,const int maxDstCStrLength) |
| { |
| OSErr errCode; |
| int theCurrentLine; |
| int theCurrentLineOffset; |
| int theEOSOffset; |
| |
| |
| if (theSrcCStr == nil) |
| { |
| SetErrorMessageAndBail(("CopyIndexedLineToCStr: Bad parameter, theSrcCStr == nil")); |
| } |
| |
| if (theDstCStr == nil) |
| { |
| SetErrorMessageAndBail(("CopyIndexedLineToCStr: Bad parameter, theDstCStr == nil")); |
| } |
| |
| if (inWhichLine < 0) |
| { |
| SetErrorMessageAndBail(("CopyIndexedLineToCStr: Bad parameter, inWhichLine < 0")); |
| } |
| |
| if (maxDstCStrLength <= 0) |
| { |
| SetErrorMessageAndBail(("CopyIndexedLineToCStr: Bad parameter, maxDstCStrLength <= 0")); |
| } |
| |
| |
| if (gotLastLine != nil) |
| { |
| *gotLastLine = false; |
| } |
| |
| |
| *theDstCStr = 0; |
| |
| theCurrentLineOffset = 0; |
| |
| theCurrentLine = 0; |
| |
| |
| while (theCurrentLine < inWhichLine) |
| { |
| while (theSrcCStr[theCurrentLineOffset] != '\r' && theSrcCStr[theCurrentLineOffset] != 0) |
| { |
| theCurrentLineOffset++; |
| } |
| |
| if (theSrcCStr[theCurrentLineOffset] == 0) |
| { |
| break; |
| } |
| |
| theCurrentLineOffset++; |
| theCurrentLine++; |
| } |
| |
| if (theSrcCStr[theCurrentLineOffset] == 0) |
| { |
| SetErrorMessageAndLongIntAndBail("CopyIndexedLineToCStr: Too few lines in source text, can't get line ",inWhichLine); |
| } |
| |
| |
| theEOSOffset = FindCharOffsetInCStr('\r',theSrcCStr + theCurrentLineOffset); |
| |
| if (theEOSOffset >= 0) |
| { |
| CopyCSubstrToCStr(theSrcCStr + theCurrentLineOffset,theEOSOffset,theDstCStr,maxDstCStrLength); |
| |
| if (gotLastLine != nil) |
| { |
| *gotLastLine = false; |
| } |
| |
| if (lineEndIndex != nil) |
| { |
| *lineEndIndex = theEOSOffset; |
| } |
| } |
| |
| else |
| { |
| theEOSOffset = CStrLength(theSrcCStr + theCurrentLineOffset); |
| |
| CopyCSubstrToCStr(theSrcCStr + theCurrentLineOffset,theEOSOffset,theDstCStr,maxDstCStrLength); |
| |
| if (gotLastLine != nil) |
| { |
| *gotLastLine = true; |
| } |
| |
| if (lineEndIndex != nil) |
| { |
| *lineEndIndex = theEOSOffset; |
| } |
| } |
| |
| |
| errCode = noErr; |
| |
| |
| EXITPOINT: |
| |
| return(errCode); |
| } |
| |
| |
| |
| OSErr CopyIndexedLineToNewHandle(const char *theSrcCStr,int inWhichLine,Handle *outNewHandle) |
| { |
| OSErr errCode; |
| int theCurrentLine; |
| int theCurrentLineOffset; |
| int byteCount; |
| |
| |
| SetErrorMessageAndBailIfNil(theSrcCStr,"CopyIndexedLineToNewHandle: Bad parameter, theSrcCStr == nil"); |
| SetErrorMessageAndBailIfNil(outNewHandle,"CopyIndexedLineToNewHandle: Bad parameter, outNewHandle == nil"); |
| |
| if (inWhichLine < 0) |
| { |
| SetErrorMessageAndBail(("CopyIndexedLineToNewHandle: Bad parameter, inWhichLine < 0")); |
| } |
| |
| |
| theCurrentLineOffset = 0; |
| |
| theCurrentLine = 0; |
| |
| |
| while (theCurrentLine < inWhichLine) |
| { |
| while (theSrcCStr[theCurrentLineOffset] != '\r' && theSrcCStr[theCurrentLineOffset] != '\0') |
| { |
| theCurrentLineOffset++; |
| } |
| |
| if (theSrcCStr[theCurrentLineOffset] == '\0') |
| { |
| break; |
| } |
| |
| theCurrentLineOffset++; |
| theCurrentLine++; |
| } |
| |
| if (theSrcCStr[theCurrentLineOffset] == '\0') |
| { |
| SetErrorMessageAndLongIntAndBail("CopyIndexedLineToNewHandle: Too few lines in source text, can't get line #",inWhichLine); |
| } |
| |
| |
| byteCount = 0; |
| |
| while (theSrcCStr[theCurrentLineOffset + byteCount] != '\r' && theSrcCStr[theCurrentLineOffset + byteCount] != '\0') |
| { |
| byteCount++; |
| } |
| |
| |
| *outNewHandle = NewHandle(byteCount + 1); |
| |
| if (*outNewHandle == nil) |
| { |
| SetErrorMessageAndLongIntAndBail("CopyIndexedLineToNewHandle: Can't allocate Handle, MemError() = ",MemError()); |
| } |
| |
| ::BlockMove(theSrcCStr + theCurrentLineOffset,**outNewHandle,byteCount); |
| |
| (**outNewHandle)[byteCount] = '\0'; |
| |
| errCode = noErr; |
| |
| |
| EXITPOINT: |
| |
| return(errCode); |
| } |
| |
| |
| |
| |
| OSErr CountDigits(const char *inCStr,int *outNumIntegerDigits,int *outNumFractDigits) |
| { |
| OSErr errCode = noErr; |
| int numIntDigits = 0; |
| int numFractDigits = 0; |
| int digitIndex = 0; |
| |
| |
| SetErrorMessageAndBailIfNil(inCStr,"CountDigits: Bad parameter, theSrcCStr == nil"); |
| SetErrorMessageAndBailIfNil(outNumIntegerDigits,"CountDigits: Bad parameter, outNumIntegerDigits == nil"); |
| SetErrorMessageAndBailIfNil(outNumFractDigits,"CountDigits: Bad parameter, outNumFractDigits == nil"); |
| |
| digitIndex = 0; |
| |
| while (inCStr[digitIndex] >= '0' && inCStr[digitIndex] <= '9') |
| { |
| digitIndex++; |
| numIntDigits++; |
| } |
| |
| if (inCStr[digitIndex] == '.') |
| { |
| digitIndex++; |
| |
| while (inCStr[digitIndex] >= '0' && inCStr[digitIndex] <= '9') |
| { |
| digitIndex++; |
| numFractDigits++; |
| } |
| } |
| |
| *outNumIntegerDigits = numIntDigits; |
| |
| *outNumFractDigits = numFractDigits; |
| |
| errCode = noErr; |
| |
| EXITPOINT: |
| |
| return(errCode); |
| } |
| |
| |
| |
| OSErr ExtractIntFromCStr(const char *theSrcCStr,int *outInt,Boolean skipLeadingSpaces) |
| { |
| OSErr errCode; |
| int theCharIndex; |
| |
| |
| if (theSrcCStr == nil) |
| { |
| SetErrorMessageAndBail(("ExtractIntFromCStr: Bad parameter, theSrcCStr == nil")); |
| } |
| |
| if (outInt == nil) |
| { |
| SetErrorMessageAndBail(("ExtractIntFromCStr: Bad parameter, outInt == nil")); |
| } |
| |
| |
| *outInt = 0; |
| |
| theCharIndex = 0; |
| |
| if (skipLeadingSpaces == true) |
| { |
| while (theSrcCStr[theCharIndex] == ' ') |
| { |
| theCharIndex++; |
| } |
| } |
| |
| if (theSrcCStr[theCharIndex] < '0' || theSrcCStr[theCharIndex] > '9') |
| { |
| SetErrorMessageAndBail(("ExtractIntFromCStr: Bad parameter, theSrcCStr contains a bogus numeric representation")); |
| } |
| |
| |
| while (theSrcCStr[theCharIndex] >= '0' && theSrcCStr[theCharIndex] <= '9') |
| { |
| *outInt = (*outInt * 10) + (theSrcCStr[theCharIndex] - '0'); |
| |
| theCharIndex++; |
| } |
| |
| |
| errCode = noErr; |
| |
| |
| EXITPOINT: |
| |
| return(errCode); |
| } |
| |
| |
| |
| OSErr ExtractIntFromPStr(const unsigned char *theSrcPStr,int *outInt,Boolean skipLeadingSpaces) |
| { |
| OSErr errCode; |
| char theCStr[256]; |
| |
| |
| if (theSrcPStr == nil) |
| { |
| SetErrorMessageAndBail(("ExtractIntFromPStr: Bad parameter, theSrcPStr == nil")); |
| } |
| |
| if (outInt == nil) |
| { |
| SetErrorMessageAndBail(("ExtractIntFromPStr: Bad parameter, outInt == nil")); |
| } |
| |
| |
| CopyPStrToCStr(theSrcPStr,theCStr,sizeof(theCStr)); |
| |
| |
| errCode = ExtractIntFromCStr(theCStr,outInt,skipLeadingSpaces); |
| |
| |
| EXITPOINT: |
| |
| return(errCode); |
| } |
| |
| |
| |
| int CountOccurencesOfCharInCStr(const char inChar,const char *inSrcCStr) |
| { |
| int theSrcCharIndex; |
| int numOccurrences = -1; |
| |
| |
| if (inSrcCStr != nil && inChar != '\0') |
| { |
| numOccurrences = 0; |
| |
| for (theSrcCharIndex = 0;inSrcCStr[theSrcCharIndex] != '\0';theSrcCharIndex++) |
| { |
| if (inSrcCStr[theSrcCharIndex] == inChar) |
| { |
| numOccurrences++; |
| } |
| } |
| } |
| |
| return(numOccurrences); |
| } |
| |
| |
| int CountWordsInCStr(const char *inSrcCStr) |
| { |
| int numWords = -1; |
| |
| |
| if (inSrcCStr != nil) |
| { |
| numWords = 0; |
| |
| // Skip lead spaces |
| |
| while (*inSrcCStr == ' ') |
| { |
| inSrcCStr++; |
| } |
| |
| while (*inSrcCStr != '\0') |
| { |
| numWords++; |
| |
| while (*inSrcCStr != ' ' && *inSrcCStr != '\0') |
| { |
| inSrcCStr++; |
| } |
| |
| while (*inSrcCStr == ' ') |
| { |
| inSrcCStr++; |
| } |
| } |
| } |
| |
| return(numWords); |
| } |
| |
| |
| |
| |
| void ConvertCStrToUpperCase(char *theSrcCStr) |
| { |
| char *theCharPtr; |
| |
| |
| if (theSrcCStr != nil) |
| { |
| theCharPtr = theSrcCStr; |
| |
| while (*theCharPtr != 0) |
| { |
| if (*theCharPtr >= 'a' && *theCharPtr <= 'z') |
| { |
| *theCharPtr = *theCharPtr - 'a' + 'A'; |
| } |
| |
| theCharPtr++; |
| } |
| } |
| } |
| |
| |
| |
| |
| |
| |
| |
| void ExtractCStrItemFromCStr(const char *inSrcCStr,const char inItemDelimiter,const int inItemNumber,Boolean *foundItem,char *outDstCharPtr,const int inDstCharPtrMaxLength,const Boolean inTreatMultipleDelimsAsSingleDelim) |
| { |
| int theItem; |
| int theSrcCharIndex; |
| int theDstCharIndex; |
| |
| |
| if (foundItem != nil) |
| { |
| *foundItem = false; |
| } |
| |
| |
| if (outDstCharPtr != nil && inDstCharPtrMaxLength > 0 && inItemNumber >= 0 && inItemDelimiter != 0) |
| { |
| *outDstCharPtr = 0; |
| |
| |
| theSrcCharIndex = 0; |
| |
| for (theItem = 0;theItem < inItemNumber;theItem++) |
| { |
| while (inSrcCStr[theSrcCharIndex] != inItemDelimiter && inSrcCStr[theSrcCharIndex] != '\0') |
| { |
| theSrcCharIndex++; |
| } |
| |
| if (inSrcCStr[theSrcCharIndex] == inItemDelimiter) |
| { |
| theSrcCharIndex++; |
| |
| if (inTreatMultipleDelimsAsSingleDelim) |
| { |
| while (inSrcCStr[theSrcCharIndex] == inItemDelimiter) |
| { |
| theSrcCharIndex++; |
| } |
| } |
| } |
| |
| |
| if (inSrcCStr[theSrcCharIndex] == '\0') |
| { |
| goto EXITPOINT; |
| } |
| } |
| |
| |
| if (foundItem != nil) |
| { |
| *foundItem = true; |
| } |
| |
| |
| theDstCharIndex = 0; |
| |
| for (;;) |
| { |
| if (inSrcCStr[theSrcCharIndex] == 0 || inSrcCStr[theSrcCharIndex] == inItemDelimiter || theDstCharIndex >= inDstCharPtrMaxLength - 1) |
| { |
| outDstCharPtr[theDstCharIndex] = 0; |
| |
| break; |
| } |
| |
| outDstCharPtr[theDstCharIndex++] = inSrcCStr[theSrcCharIndex++]; |
| } |
| } |
| |
| |
| EXITPOINT: |
| |
| return; |
| } |
| |
| |
| |
| OSErr ExtractCStrItemFromCStrIntoNewHandle(const char *inSrcCStr,const char inItemDelimiter,const int inItemNumber,Boolean *foundItem,Handle *outNewHandle,const Boolean inTreatMultipleDelimsAsSingleDelim) |
| { |
| OSErr errCode; |
| int theItem; |
| int theSrcCharIndex; |
| int theItemLength; |
| |
| |
| if (inSrcCStr == nil) |
| { |
| SetErrorMessage("ExtractCStrItemFromCStrIntoNewHandle: Bad parameter, inSrcCStr == nil"); |
| errCode = kGenericError; |
| goto EXITPOINT; |
| } |
| |
| if (outNewHandle == nil) |
| { |
| SetErrorMessage("ExtractCStrItemFromCStrIntoNewHandle: Bad parameter, outNewHandle == nil"); |
| errCode = kGenericError; |
| goto EXITPOINT; |
| } |
| |
| if (foundItem == nil) |
| { |
| SetErrorMessage("ExtractCStrItemFromCStrIntoNewHandle: Bad parameter, foundItem == nil"); |
| errCode = kGenericError; |
| goto EXITPOINT; |
| } |
| |
| if (inItemNumber < 0) |
| { |
| SetErrorMessage("ExtractCStrItemFromCStrIntoNewHandle: Bad parameter, inItemNumber < 0"); |
| errCode = kGenericError; |
| goto EXITPOINT; |
| } |
| |
| if (inItemDelimiter == 0) |
| { |
| SetErrorMessage("ExtractCStrItemFromCStrIntoNewHandle: Bad parameter, inItemDelimiter == 0"); |
| errCode = kGenericError; |
| goto EXITPOINT; |
| } |
| |
| |
| *foundItem = false; |
| |
| theSrcCharIndex = 0; |
| |
| for (theItem = 0;theItem < inItemNumber;theItem++) |
| { |
| while (inSrcCStr[theSrcCharIndex] != inItemDelimiter && inSrcCStr[theSrcCharIndex] != '\0') |
| { |
| theSrcCharIndex++; |
| } |
| |
| if (inSrcCStr[theSrcCharIndex] == inItemDelimiter) |
| { |
| theSrcCharIndex++; |
| |
| if (inTreatMultipleDelimsAsSingleDelim) |
| { |
| while (inSrcCStr[theSrcCharIndex] == inItemDelimiter) |
| { |
| theSrcCharIndex++; |
| } |
| } |
| } |
| |
| |
| if (inSrcCStr[theSrcCharIndex] == '\0') |
| { |
| errCode = noErr; |
| |
| goto EXITPOINT; |
| } |
| } |
| |
| |
| *foundItem = true; |
| |
| |
| for (theItemLength = 0;;theItemLength++) |
| { |
| if (inSrcCStr[theSrcCharIndex + theItemLength] == 0 || inSrcCStr[theSrcCharIndex + theItemLength] == inItemDelimiter) |
| { |
| break; |
| } |
| } |
| |
| |
| *outNewHandle = NewHandle(theItemLength + 1); |
| |
| if (*outNewHandle == nil) |
| { |
| SetErrorMessageAndLongIntAndBail("ExtractCStrItemFromCStrIntoNewHandle: Can't allocate Handle, MemError() = ",MemError()); |
| } |
| |
| |
| BlockMove(inSrcCStr + theSrcCharIndex,**outNewHandle,theItemLength); |
| |
| (**outNewHandle)[theItemLength] = 0; |
| |
| errCode = noErr; |
| |
| |
| EXITPOINT: |
| |
| return(errCode); |
| } |
| |
| |
| |
| |
| |
| |
| OSErr ExtractFloatFromCStr(const char *inCString,extended80 *outFloat) |
| { |
| OSErr errCode; |
| Str255 theStr255; |
| Handle theNumberPartsTableHandle = nil; |
| long theNumberPartsOffset,theNumberPartsLength; |
| FormatResultType theFormatResultType; |
| NumberParts theNumberPartsTable; |
| NumFormatStringRec theNumFormatStringRec; |
| |
| |
| if (inCString == nil) |
| { |
| SetErrorMessage("ExtractFloatFromCStr: Bad parameter, inCString == nil"); |
| errCode = kGenericError; |
| goto EXITPOINT; |
| } |
| |
| if (outFloat == nil) |
| { |
| SetErrorMessage("ExtractFloatFromCStr: Bad parameter, outFloat == nil"); |
| errCode = kGenericError; |
| goto EXITPOINT; |
| } |
| |
| |
| // GetIntlResourceTable(smRoman,smNumberPartsTable,&theNumberPartsTableHandle,&theNumberPartsOffset,&theNumberPartsLength); |
| |
| GetIntlResourceTable(GetScriptManagerVariable(smSysScript),smNumberPartsTable,&theNumberPartsTableHandle,&theNumberPartsOffset,&theNumberPartsLength); |
| |
| if (theNumberPartsTableHandle == nil) |
| { |
| SetErrorMessage("ExtractFloatFromCStr: Can't get number parts table for converting string representations to/from numeric representations"); |
| errCode = kGenericError; |
| goto EXITPOINT; |
| } |
| |
| if (theNumberPartsLength > sizeof(theNumberPartsTable)) |
| { |
| SetErrorMessage("ExtractFloatFromCStr: Number parts table has bad length"); |
| errCode = kGenericError; |
| goto EXITPOINT; |
| } |
| |
| |
| BlockMove(*theNumberPartsTableHandle + theNumberPartsOffset,&theNumberPartsTable,theNumberPartsLength); |
| |
| |
| theFormatResultType = (FormatResultType) StringToFormatRec(kNumberFormatString,&theNumberPartsTable,&theNumFormatStringRec); |
| |
| if (theFormatResultType != fFormatOK) |
| { |
| SetErrorMessage("ExtractFloatFromCStr: StringToFormatRec() != fFormatOK"); |
| errCode = kGenericError; |
| goto EXITPOINT; |
| } |
| |
| |
| CopyCStrToPStr(inCString,theStr255,sizeof(theStr255)); |
| |
| |
| theFormatResultType = (FormatResultType) StringToExtended(theStr255,&theNumFormatStringRec,&theNumberPartsTable,outFloat); |
| |
| if (theFormatResultType != fFormatOK && theFormatResultType != fBestGuess) |
| { |
| SetErrorMessageAndLongIntAndBail("ExtractFloatFromCStr: StringToExtended() = ",theFormatResultType); |
| } |
| |
| |
| errCode = noErr; |
| |
| |
| EXITPOINT: |
| |
| return(errCode); |
| } |
| |
| |
| |
| OSErr CopyFloatToCStr(const extended80 *theFloat,char *theCStr,const int maxCStrLength,const int inMaxNumIntDigits,const int inMaxNumFractDigits) |
| { |
| OSErr errCode; |
| Str255 theStr255; |
| Handle theNumberPartsTableHandle = nil; |
| long theNumberPartsOffset,theNumberPartsLength; |
| FormatResultType theFormatResultType; |
| NumberParts theNumberPartsTable; |
| NumFormatStringRec theNumFormatStringRec; |
| |
| |
| if (theCStr == nil) |
| { |
| SetErrorMessage("CopyFloatToCStr: Bad parameter, theCStr == nil"); |
| errCode = kGenericError; |
| goto EXITPOINT; |
| } |
| |
| if (theFloat == nil) |
| { |
| SetErrorMessage("CopyFloatToCStr: Bad parameter, theFloat == nil"); |
| errCode = kGenericError; |
| goto EXITPOINT; |
| } |
| |
| |
| // GetIntlResourceTable(smRoman,smNumberPartsTable,&theNumberPartsTableHandle,&theNumberPartsOffset,&theNumberPartsLength); |
| |
| GetIntlResourceTable(GetScriptManagerVariable(smSysScript),smNumberPartsTable,&theNumberPartsTableHandle,&theNumberPartsOffset,&theNumberPartsLength); |
| |
| if (theNumberPartsTableHandle == nil) |
| { |
| SetErrorMessage("CopyFloatToCStr: Can't get number parts table for converting string representations to/from numeric representations"); |
| errCode = kGenericError; |
| goto EXITPOINT; |
| } |
| |
| if (theNumberPartsLength > sizeof(theNumberPartsTable)) |
| { |
| SetErrorMessage("CopyFloatToCStr: Number parts table has bad length"); |
| errCode = kGenericError; |
| goto EXITPOINT; |
| } |
| |
| |
| BlockMove(*theNumberPartsTableHandle + theNumberPartsOffset,&theNumberPartsTable,theNumberPartsLength); |
| |
| |
| if (inMaxNumIntDigits >= 0 || inMaxNumFractDigits >= 0) |
| { |
| char numberFormat[64]; |
| int numberFormatLength = 0; |
| |
| for (int i = 0;i < inMaxNumIntDigits && numberFormatLength < sizeof(numberFormat) - 1;i++) |
| { |
| numberFormat[numberFormatLength++] = '0'; |
| } |
| |
| if (inMaxNumFractDigits > 0 && numberFormatLength < sizeof(numberFormat) - 1) |
| { |
| numberFormat[numberFormatLength++] = '.'; |
| |
| for (int i = 0;i < inMaxNumFractDigits && numberFormatLength < sizeof(numberFormat) - 1;i++) |
| { |
| numberFormat[numberFormatLength++] = '0'; |
| } |
| } |
| |
| |
| if (numberFormatLength < sizeof(numberFormat) - 1) |
| { |
| numberFormat[numberFormatLength++] = ';'; |
| } |
| |
| if (numberFormatLength < sizeof(numberFormat) - 1) |
| { |
| numberFormat[numberFormatLength++] = '-'; |
| } |
| |
| |
| for (int i = 0;i < inMaxNumIntDigits && numberFormatLength < sizeof(numberFormat) - 1;i++) |
| { |
| numberFormat[numberFormatLength++] = '0'; |
| } |
| |
| if (inMaxNumFractDigits > 0 && numberFormatLength < sizeof(numberFormat) - 1) |
| { |
| numberFormat[numberFormatLength++] = '.'; |
| |
| for (int i = 0;i < inMaxNumFractDigits && numberFormatLength < sizeof(numberFormat) - 1;i++) |
| { |
| numberFormat[numberFormatLength++] = '0'; |
| } |
| } |
| |
| numberFormat[numberFormatLength] = '\0'; |
| |
| |
| Str255 tempStr255; |
| |
| CopyCStrToPStr(numberFormat,tempStr255,sizeof(tempStr255)); |
| |
| theFormatResultType = (FormatResultType) StringToFormatRec(tempStr255,&theNumberPartsTable,&theNumFormatStringRec); |
| } |
| |
| else |
| { |
| theFormatResultType = (FormatResultType) StringToFormatRec(kNumberFormatString,&theNumberPartsTable,&theNumFormatStringRec); |
| } |
| |
| if (theFormatResultType != fFormatOK) |
| { |
| SetErrorMessage("CopyFloatToCStr: StringToFormatRec() != fFormatOK"); |
| errCode = kGenericError; |
| goto EXITPOINT; |
| } |
| |
| |
| theFormatResultType = (FormatResultType) ExtendedToString(theFloat,&theNumFormatStringRec,&theNumberPartsTable,theStr255); |
| |
| if (theFormatResultType != fFormatOK) |
| { |
| SetErrorMessage("CopyFloatToCStr: ExtendedToString() != fFormatOK"); |
| errCode = kGenericError; |
| goto EXITPOINT; |
| } |
| |
| |
| CopyPStrToCStr(theStr255,theCStr,maxCStrLength); |
| |
| errCode = noErr; |
| |
| |
| EXITPOINT: |
| |
| return(errCode); |
| } |
| |
| |
| |
| |
| |
| void SkipWhiteSpace(char **ioSrcCharPtr,const Boolean inStopAtEOL) |
| { |
| if (ioSrcCharPtr != nil && *ioSrcCharPtr != nil) |
| { |
| if (inStopAtEOL) |
| { |
| while ((**ioSrcCharPtr == ' ' || **ioSrcCharPtr == '\t') && **ioSrcCharPtr != '\r' && **ioSrcCharPtr != '\n') |
| { |
| *ioSrcCharPtr++; |
| } |
| } |
| |
| else |
| { |
| while (**ioSrcCharPtr == ' ' || **ioSrcCharPtr == '\t') |
| { |
| *ioSrcCharPtr++; |
| } |
| } |
| } |
| } |