Revision 11414f17d93ec04d2d056d5f3a87e964a7412431 authored by Matt Caswell on 23 May 2015, 20:51:21 UTC, committed by Matt Caswell on 25 May 2015, 16:52:27 UTC
If the record received is for a version that we don't support, previously we were sending an alert back. However if the incoming record already looks like an alert then probably we shouldn't do that. So suppress an outgoing alert if it looks like we've got one incoming. Reviewed-by: Kurt Roeckx <kurt@openssl.org>
1 parent 0a59e2d
CPStringUtils.cpp
/* ====================================================================
* 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++;
}
}
}
}
Computing file changes ...
