rhodes 1.4.2 → 1.5.0

data/lib/extensions/openssl/ext/openssl/INSTALL.W64

@@ -1,66 +0,0 @@
-
- INSTALLATION ON THE WIN64 PLATFORM
- ----------------------------------
-
- Caveat lector
- -------------
-
- As of moment of this writing Win64 support is classified "initial"
- for the following reasons.
-
- - No assembler modules are engaged upon initial 0.9.8 release.
- - API might change within 0.9.8 life-span, *but* in a manner which
-   doesn't break backward binary compatibility. Or in other words,
-   application programs compiled with initial 0.9.8 headers will
-   be expected to work with future minor release .DLL without need
-   to re-compile, even if future minor release features modified API.
- - Above mentioned API modifications have everything to do with
-   elimination of a number of limitations, which are normally
-   considered inherent to 32-bit platforms. Which in turn is why they
-   are treated as limitations on 64-bit platform such as Win64:-)
-   The current list comprises [but not necessarily limited to]:
-
-   - null-terminated strings may not be longer than 2G-1 bytes,
-     longer strings are treated as zero-length;
-   - dynamically and *internally* allocated chunks can't be larger
-     than 2G-1 bytes;
-   - inability to encrypt/decrypt chunks of data larger than 4GB
-     [it's possibly to *hash* chunks of arbitrary size through];
-
-   Neither of these is actually big deal and hardly encountered
-   in real-life applications.
-
- Compiling procedure
- -------------------
-
- You will need Perl. You can run under Cygwin or you can download
- ActiveState Perl from http://www.activestate.com/ActivePerl.
-
- You will need Microsoft Platform SDK, available for download at
- http://www.microsoft.com/msdownload/platformsdk/sdkupdate/. As per
- April 2005 Platform SDK is equipped with Win64 compilers, as well
- as assemblers, but it might change in the future.
-
- To build for Win64/x64:
-
- > perl Configure VC-WIN64A
- > ms\do_win64a
- > nmake -f ms\ntdll.mak
- > cd out32dll
- > ..\ms\test
-
- To build for Win64/IA64:
-
- > perl Configure VC-WIN64I
- > ms\do_win64i
- > nmake -f ms\ntdll.mak
- > cd out32dll
- > ..\ms\test
-
- Naturally test-suite itself has to be executed on the target platform.
-
- Installation
- ------------
-
- TBD, for now see INSTALL.W32.
-

data/lib/extensions/openssl/ext/openssl/INSTALL.WCE

@@ -1,74 +0,0 @@
- 
- INSTALLATION FOR THE WINDOWS CE PLATFORM
- ----------------------------------------
-
- Building OpenSSL for Windows CE requires the following external tools:
-
-  * Microsoft eMbedded Visual C++ 3.0
-  * wcecompat compatibility library (www.essemer.com.au)
-  * Optionally ceutils for running automated tests (www.essemer.com.au)
-
- You also need Perl for Win32.  You will need ActiveState Perl, available
- from http://www.activestate.com/ActivePerl.
-
- Windows CE support in OpenSSL relies on wcecompat and therefore it's
- appropriate to check http://www.essemer.com.au/windowsce/ for updates in
- case of compilation problems. As for the moment of this writing version
- 1.1 is available and actually required for WCE 4.2 and newer platforms.
- All Windows CE specific issues should be directed to www.essemer.com.au.
-
- The C Runtime Library implementation for Windows CE that is included with
- Microsoft eMbedded Visual C++ 3.0 is incomplete and in some places
- incorrect.  wcecompat plugs the holes and tries to bring the Windows CE
- CRT to a level that is more compatible with ANSI C.  wcecompat goes further
- and provides low-level IO and stream IO support for stdin/stdout/stderr
- (which Windows CE does not provide).  This IO functionality is not needed
- by the OpenSSL library itself but is used for the tests and openssl.exe.
- More information is available at www.essemer.com.au.
-
- Building
- --------
-
- Setup the eMbedded Visual C++ environment.  There are batch files for doing
- this installed with eVC++.  For an ARM processor, for example, execute:
-
- > "C:\Program Files\Microsoft eMbedded Tools\EVC\WCE300\BIN\WCEARM.BAT"
-
- Next indicate where wcecompat is located:
-
- > set WCECOMPAT=C:\wcecompat
-
- Next you should run Configure:
-
- > perl Configure VC-CE
-
- Next you need to build the Makefiles:
-
- > ms\do_ms
-
- If you get errors about things not having numbers assigned then check the
- troubleshooting section in INSTALL.W32: you probably won't be able to compile
- it as it stands.
-
- Then from the VC++ environment at a prompt do:
-
- - to build static libraries:
-
-   > nmake -f ms\ce.mak
-
- - or to build DLLs:
-
-   > nmake -f ms\cedll.mak
-
- If all is well it should compile and you will have some static libraries and
- executables in out32, or some DLLs and executables in out32dll.  If you want
- to try the tests then make sure the ceutils are in the path and do:
- 
- > cd out32
- > ..\ms\testce
-
- This will copy each of the test programs to the Windows CE device and execute
- them, displaying the output of the tests on this computer.  The output should
- look similar to the output produced by running the tests for a regular Windows
- build.
-

data/lib/extensions/openssl/ext/openssl/LICENSE

@@ -1,127 +0,0 @@
-
-  LICENSE ISSUES
-  ==============
-
-  The OpenSSL toolkit stays under a dual license, i.e. both the conditions of
-  the OpenSSL License and the original SSLeay license apply to the toolkit.
-  See below for the actual license texts. Actually both licenses are BSD-style
-  Open Source licenses. In case of any license issues related to OpenSSL
-  please contact openssl-core@openssl.org.
-
-  OpenSSL License
-  ---------------
-
-/* ====================================================================
- * Copyright (c) 1998-2008 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).
- *
- */
-
- Original SSLeay License
- -----------------------
-
-/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
- * All rights reserved.
- *
- * This package is an SSL implementation written
- * by Eric Young (eay@cryptsoft.com).
- * The implementation was written so as to conform with Netscapes SSL.
- * 
- * This library is free for commercial and non-commercial use as long as
- * the following conditions are aheared to.  The following conditions
- * apply to all code found in this distribution, be it the RC4, RSA,
- * lhash, DES, etc., code; not just the SSL code.  The SSL documentation
- * included with this distribution is covered by the same copyright terms
- * except that the holder is Tim Hudson (tjh@cryptsoft.com).
- * 
- * Copyright remains Eric Young's, and as such any Copyright notices in
- * the code are not to be removed.
- * If this package is used in a product, Eric Young should be given attribution
- * as the author of the parts of the library used.
- * This can be in the form of a textual message at program startup or
- * in documentation (online or textual) provided with the package.
- * 
- * 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 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 acknowledgement:
- *    "This product includes cryptographic software written by
- *     Eric Young (eay@cryptsoft.com)"
- *    The word 'cryptographic' can be left out if the rouines from the library
- *    being used are not cryptographic related :-).
- * 4. If you include any Windows specific code (or a derivative thereof) from 
- *    the apps directory (application code) you must include an acknowledgement:
- *    "This product includes software written by Tim Hudson (tjh@cryptsoft.com)"
- * 
- * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND
- * ANY EXPRESS 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 AUTHOR OR 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.
- * 
- * The licence and distribution terms for any publically available version or
- * derivative of this code cannot be changed.  i.e. this code cannot simply be
- * copied and put under another distribution licence
- * [including the GNU Public Licence.]
- */
-

data/lib/extensions/openssl/ext/openssl/MacOS/GUSI_Init.cpp

@@ -1,62 +0,0 @@
-/**************** BEGIN GUSI CONFIGURATION ****************************
- *
- * GUSI Configuration section generated by GUSI Configurator
- * last modified: Wed Jan  5 20:33:51 2000
- *
- * This section will be overwritten by the next run of Configurator.
- */
-
-#define GUSI_SOURCE
-#include <GUSIConfig.h>
-#include <sys/cdefs.h>
-
-/* Declarations of Socket Factories */
-
-__BEGIN_DECLS
-void GUSIwithInetSockets();
-void GUSIwithLocalSockets();
-void GUSIwithMTInetSockets();
-void GUSIwithMTTcpSockets();
-void GUSIwithMTUdpSockets();
-void GUSIwithOTInetSockets();
-void GUSIwithOTTcpSockets();
-void GUSIwithOTUdpSockets();
-void GUSIwithPPCSockets();
-void GUSISetupFactories();
-__END_DECLS
-
-/* Configure Socket Factories */
-
-void GUSISetupFactories()
-{
-#ifdef GUSISetupFactories_BeginHook
-	GUSISetupFactories_BeginHook
-#endif
-	GUSIwithInetSockets();
-#ifdef GUSISetupFactories_EndHook
-	GUSISetupFactories_EndHook
-#endif
-}
-
-/* Declarations of File Devices */
-
-__BEGIN_DECLS
-void GUSIwithDConSockets();
-void GUSIwithNullSockets();
-void GUSISetupDevices();
-__END_DECLS
-
-/* Configure File Devices */
-
-void GUSISetupDevices()
-{
-#ifdef GUSISetupDevices_BeginHook
-	GUSISetupDevices_BeginHook
-#endif
-	GUSIwithNullSockets();
-#ifdef GUSISetupDevices_EndHook
-	GUSISetupDevices_EndHook
-#endif
-}
-
-/**************** END GUSI CONFIGURATION *************************/

data/lib/extensions/openssl/ext/openssl/MacOS/GetHTTPS.src/CPStringUtils.cpp

@@ -1,2753 +0,0 @@
-/* ====================================================================
- * 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++;
-			}
-		}
-	}
-}