From 099f1b32c8a3334699b6884ba23824a49461d01f Mon Sep 17 00:00:00 2001 From: Andy Polyakov Date: Sun, 19 Dec 1999 16:17:45 +0000 Subject: Initial support for MacOS is now available Submitted by: Roy Woods Reviewed by: Andy Polyakov --- MacOS/GetHTTPS.src/CPStringUtils.cpp | 2753 ++++++++++++++++++ MacOS/GetHTTPS.src/CPStringUtils.hpp | 104 + MacOS/GetHTTPS.src/ErrorHandling.cpp | 170 ++ MacOS/GetHTTPS.src/ErrorHandling.hpp | 147 + MacOS/GetHTTPS.src/GetHTTPS.cpp | 206 ++ MacOS/GetHTTPS.src/MacSocket.cpp | 1607 +++++++++++ MacOS/GetHTTPS.src/MacSocket.h | 103 + MacOS/OpenSSL.mcp.hqx | 5103 ++++++++++++++++++++++++++++++++++ MacOS/TODO | 18 + MacOS/_MWERKS_prefix.h | 5 + MacOS/buildinf.h | 5 + MacOS/mklinks.as.hqx | 820 ++++++ MacOS/opensslconf.h | 118 + 13 files changed, 11159 insertions(+) create mode 100644 MacOS/GetHTTPS.src/CPStringUtils.cpp create mode 100644 MacOS/GetHTTPS.src/CPStringUtils.hpp create mode 100644 MacOS/GetHTTPS.src/ErrorHandling.cpp create mode 100644 MacOS/GetHTTPS.src/ErrorHandling.hpp create mode 100644 MacOS/GetHTTPS.src/GetHTTPS.cpp create mode 100644 MacOS/GetHTTPS.src/MacSocket.cpp create mode 100644 MacOS/GetHTTPS.src/MacSocket.h create mode 100644 MacOS/OpenSSL.mcp.hqx create mode 100644 MacOS/TODO create mode 100644 MacOS/_MWERKS_prefix.h create mode 100644 MacOS/buildinf.h create mode 100644 MacOS/mklinks.as.hqx create mode 100644 MacOS/opensslconf.h (limited to 'MacOS') diff --git a/MacOS/GetHTTPS.src/CPStringUtils.cpp b/MacOS/GetHTTPS.src/CPStringUtils.cpp new file mode 100644 index 0000000000..5f64afe967 --- /dev/null +++ b/MacOS/GetHTTPS.src/CPStringUtils.cpp @@ -0,0 +1,2753 @@ +/* ==================================================================== + * 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++; + } + } + } +} \ No newline at end of file diff --git a/MacOS/GetHTTPS.src/CPStringUtils.hpp b/MacOS/GetHTTPS.src/CPStringUtils.hpp new file mode 100644 index 0000000000..5045c41019 --- /dev/null +++ b/MacOS/GetHTTPS.src/CPStringUtils.hpp @@ -0,0 +1,104 @@ +#pragma once + +#ifdef __cplusplus +extern "C" { +#endif + +void CopyPStrToCStr(const unsigned char *thePStr,char *theCStr,const int maxCStrLength); +void CopyPStrToPStr(const unsigned char *theSrcPStr,unsigned char *theDstPStr,const int maxDstStrLength); +void CopyCStrToCStr(const char *theSrcCStr,char *theDstCStr,const int maxDstStrLength); +void CopyCStrToPStr(const char *theSrcCStr,unsigned char *theDstPStr,const int maxDstStrLength); +void ConcatPStrToCStr(const unsigned char *thePStr,char *theCStr,const int maxCStrLength); +void ConcatPStrToPStr(const unsigned char *theSrcPStr,unsigned char *theDstPStr,const int maxDstStrLength); +void ConcatCStrToPStr(const char *theSrcCStr,unsigned char *theDstPStr,const int maxDstStrLength); +void ConcatCStrToCStr(const char *theSrcCStr,char *theDstCStr,const int maxCStrLength); + +void ConcatCharToCStr(const char theChar,char *theDstCStr,const int maxCStrLength); +void ConcatCharToPStr(const char theChar,unsigned char *theDstPStr,const int maxPStrLength); + +int ComparePStrs(const unsigned char *theFirstPStr,const unsigned char *theSecondPStr,const Boolean ignoreCase = true); +int CompareCStrs(const char *theFirstCStr,const char *theSecondCStr,const Boolean ignoreCase = true); +int CompareCStrToPStr(const char *theCStr,const unsigned char *thePStr,const Boolean ignoreCase = true); + +Boolean CStrsAreEqual(const char *theFirstCStr,const char *theSecondCStr,const Boolean ignoreCase = true); +Boolean PStrsAreEqual(const unsigned char *theFirstCStr,const unsigned char *theSecondCStr,const Boolean ignoreCase = true); + +void CopyLongIntToCStr(const long theNum,char *theCStr,const int maxCStrLength,const int numDigits = -1); +void CopyUnsignedLongIntToCStr(const unsigned long theNum,char *theCStr,const int maxCStrLength); +void ConcatLongIntToCStr(const long theNum,char *theCStr,const int maxCStrLength,const int numDigits = -1); +void CopyCStrAndConcatLongIntToCStr(const char *theSrcCStr,const long theNum,char *theDstCStr,const int maxDstStrLength); + +void CopyLongIntToPStr(const long theNum,unsigned char *thePStr,const int maxPStrLength,const int numDigits = -1); +void ConcatLongIntToPStr(const long theNum,unsigned char *thePStr,const int maxPStrLength,const int numDigits = -1); + +long CStrLength(const char *theCString); +long PStrLength(const unsigned char *thePString); + +OSErr CopyCStrToExistingHandle(const char *theCString,Handle theHandle); +OSErr CopyLongIntToExistingHandle(const long inTheLongInt,Handle theHandle); + +OSErr CopyCStrToNewHandle(const char *theCString,Handle *theHandle); +OSErr CopyPStrToNewHandle(const unsigned char *thePString,Handle *theHandle); +OSErr CopyLongIntToNewHandle(const long inTheLongInt,Handle *theHandle); + +OSErr AppendCStrToHandle(const char *theCString,Handle theHandle,long *currentLength = nil,long *maxLength = nil); +OSErr AppendCharsToHandle(const char *theChars,const int numChars,Handle theHandle,long *currentLength = nil,long *maxLength = nil); +OSErr AppendPStrToHandle(const unsigned char *thePString,Handle theHandle,long *currentLength = nil); +OSErr AppendLongIntToHandle(const long inTheLongInt,Handle theHandle,long *currentLength = nil); + +void ZeroMem(void *theMemPtr,const unsigned long numBytes); + +char *FindCharInCStr(const char theChar,const char *theCString); +long FindCharOffsetInCStr(const char theChar,const char *theCString,const Boolean inIgnoreCase = false); +long FindCStrOffsetInCStr(const char *theCSubstring,const char *theCString,const Boolean inIgnoreCase = false); + +void CopyCSubstrToCStr(const char *theSrcCStr,const int maxCharsToCopy,char *theDstCStr,const int maxDstStrLength); +void CopyCSubstrToPStr(const char *theSrcCStr,const int maxCharsToCopy,unsigned char *theDstPStr,const int maxDstStrLength); + +void InsertCStrIntoCStr(const char *theSrcCStr,const int theInsertionOffset,char *theDstCStr,const int maxDstStrLength); +void InsertPStrIntoCStr(const unsigned char *theSrcPStr,const int theInsertionOffset,char *theDstCStr,const int maxDstStrLength); +OSErr InsertCStrIntoHandle(const char *theCString,Handle theHandle,const long inInsertOffset); + +void CopyCStrAndInsertCStrIntoCStr(const char *theSrcCStr,const char *theInsertCStr,char *theDstCStr,const int maxDstStrLength); + +void CopyCStrAndInsertCStrsLongIntsIntoCStr(const char *theSrcCStr,const char **theInsertCStrs,const long *theLongInts,char *theDstCStr,const int maxDstStrLength); + +void CopyCStrAndInsert1LongIntIntoCStr(const char *theSrcCStr,const long theNum,char *theDstCStr,const int maxDstStrLength); +void CopyCStrAndInsert2LongIntsIntoCStr(const char *theSrcCStr,const long long1,const long long2,char *theDstCStr,const int maxDstStrLength); +void CopyCStrAndInsert3LongIntsIntoCStr(const char *theSrcCStr,const long long1,const long long2,const long long3,char *theDstCStr,const int maxDstStrLength); + +void CopyCStrAndInsertCStrLongIntIntoCStr(const char *theSrcCStr,const char *theInsertCStr,const long theNum,char *theDstCStr,const int maxDstStrLength); +OSErr CopyCStrAndInsertCStrLongIntIntoHandle(const char *theSrcCStr,const char *theInsertCStr,const long theNum,Handle *theHandle); + + +OSErr CopyIndexedWordToCStr(char *theSrcCStr,int whichWord,char *theDstCStr,int maxDstCStrLength); +OSErr CopyIndexedWordToNewHandle(char *theSrcCStr,int whichWord,Handle *outTheHandle); + +OSErr CopyIndexedLineToCStr(const char *theSrcCStr,int inWhichLine,int *lineEndIndex,Boolean *gotLastLine,char *theDstCStr,const int maxDstCStrLength); +OSErr CopyIndexedLineToNewHandle(const char *theSrcCStr,int inWhichLine,Handle *outNewHandle); + +OSErr ExtractIntFromCStr(const char *theSrcCStr,int *outInt,Boolean skipLeadingSpaces = true); +OSErr ExtractIntFromPStr(const unsigned char *theSrcPStr,int *outInt,Boolean skipLeadingSpaces = true); + + +void ConvertCStrToUpperCase(char *theSrcCStr); + + +int CountOccurencesOfCharInCStr(const char inChar,const char *inSrcCStr); +int CountWordsInCStr(const char *inSrcCStr); + +OSErr CountDigits(const char *inCStr,int *outNumIntegerDigits,int *outNumFractDigits); + +void ExtractCStrItemFromCStr(const char *inSrcCStr,const char inItemDelimiter,const int inItemNumber,Boolean *foundItem,char *outDstCharPtr,const int inDstCharPtrMaxLength,const Boolean inTreatMultipleDelimsAsSingleDelim = false); +OSErr ExtractCStrItemFromCStrIntoNewHandle(const char *inSrcCStr,const char inItemDelimiter,const int inItemNumber,Boolean *foundItem,Handle *outNewHandle,const Boolean inTreatMultipleDelimsAsSingleDelim = false); + + +OSErr ExtractFloatFromCStr(const char *inCString,extended80 *outFloat); +OSErr CopyFloatToCStr(const extended80 *theFloat,char *theCStr,const int maxCStrLength,const int inMaxNumIntDigits = -1,const int inMaxNumFractDigits = -1); + +void SkipWhiteSpace(char **ioSrcCharPtr,const Boolean inStopAtEOL = false); + + +#ifdef __cplusplus +} +#endif diff --git a/MacOS/GetHTTPS.src/ErrorHandling.cpp b/MacOS/GetHTTPS.src/ErrorHandling.cpp new file mode 100644 index 0000000000..07a32de59e --- /dev/null +++ b/MacOS/GetHTTPS.src/ErrorHandling.cpp @@ -0,0 +1,170 @@ +/* ==================================================================== + * 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 sourc