xalan-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From dbert...@apache.org
Subject cvs commit: xml-xalan/c/src/PlatformSupport ArenaBlock.hpp AttributeListImpl.cpp AttributesImpl.cpp DOMStringHelper.cpp DOMStringHelper.hpp DOMStringPrintWriter.cpp DOMStringPrintWriter.hpp DoubleSupport.cpp FormatterListener.hpp NullPrintWriter.cpp NullPrintWriter.hpp PrintWriter.hpp ReusableArenaBlock.hpp StringTokenizer.cpp StringTokenizer.hpp URISupport.cpp Writer.hpp XalanBitmap.cpp XalanBitmap.hpp XalanDOMStringHashTable.cpp XalanDOMStringHashTable.hpp XalanDOMStringPool.cpp XalanDOMStringPool.hpp XalanDecimalFormat.cpp XalanNumberFormat.cpp XalanOutputStream.cpp XalanOutputStream.hpp XalanOutputStreamPrintWriter.cpp XalanOutputStreamPrintWriter.hpp XalanToXercesTranscoderWrapper.cpp XalanToXercesTranscoderWrapper.hpp XalanTranscodingServices.hpp XalanUTF16Transcoder.cpp XalanUTF16Transcoder.hpp
Date Tue, 25 Sep 2001 21:12:52 GMT
dbertoni    01/09/25 14:12:52

  Modified:    c/src/PlatformSupport ArenaBlock.hpp AttributeListImpl.cpp
                        AttributesImpl.cpp DOMStringHelper.cpp
                        DOMStringHelper.hpp DOMStringPrintWriter.cpp
                        DOMStringPrintWriter.hpp DoubleSupport.cpp
                        FormatterListener.hpp NullPrintWriter.cpp
                        NullPrintWriter.hpp PrintWriter.hpp
                        ReusableArenaBlock.hpp StringTokenizer.cpp
                        StringTokenizer.hpp URISupport.cpp Writer.hpp
                        XalanBitmap.cpp XalanBitmap.hpp
                        XalanDOMStringHashTable.cpp
                        XalanDOMStringHashTable.hpp XalanDOMStringPool.cpp
                        XalanDOMStringPool.hpp XalanDecimalFormat.cpp
                        XalanNumberFormat.cpp XalanOutputStream.cpp
                        XalanOutputStream.hpp
                        XalanOutputStreamPrintWriter.cpp
                        XalanOutputStreamPrintWriter.hpp
                        XalanToXercesTranscoderWrapper.cpp
                        XalanToXercesTranscoderWrapper.hpp
                        XalanTranscodingServices.hpp
                        XalanUTF16Transcoder.cpp XalanUTF16Transcoder.hpp
  Log:
  32/64-bit fixes.
  
  Revision  Changes    Path
  1.11      +1 -1      xml-xalan/c/src/PlatformSupport/ArenaBlock.hpp
  
  Index: ArenaBlock.hpp
  ===================================================================
  RCS file: /home/cvs/xml-xalan/c/src/PlatformSupport/ArenaBlock.hpp,v
  retrieving revision 1.10
  retrieving revision 1.11
  diff -u -r1.10 -r1.11
  --- ArenaBlock.hpp	2001/01/16 02:43:35	1.10
  +++ ArenaBlock.hpp	2001/09/25 21:12:51	1.11
  @@ -195,7 +195,7 @@
   			// If no memory has yet been allocated, then allocate it...
   			if (m_objectBlock == 0)
   			{
  -				m_objectBlock = m_allocator.allocate(m_blockSize, 0);
  +				m_objectBlock = m_allocator.allocate(m_blockSize);
   			}
   			assert(m_objectBlock != 0);
   
  
  
  
  1.20      +4 -1      xml-xalan/c/src/PlatformSupport/AttributeListImpl.cpp
  
  Index: AttributeListImpl.cpp
  ===================================================================
  RCS file: /home/cvs/xml-xalan/c/src/PlatformSupport/AttributeListImpl.cpp,v
  retrieving revision 1.19
  retrieving revision 1.20
  diff -u -r1.19 -r1.20
  --- AttributeListImpl.cpp	2001/04/30 18:07:01	1.19
  +++ AttributeListImpl.cpp	2001/09/25 21:12:51	1.20
  @@ -227,7 +227,10 @@
   unsigned int
   AttributeListImpl::getLength() const
   {
  -	return m_AttributeVector.size();
  +	// Make sure the mismatch between Xerces and vector<> doesn't cause a problem...
  +	assert(m_AttributeVector.size() == unsigned(m_AttributeVector.size()));
  +
  +	return unsigned(m_AttributeVector.size());
   }
   
   
  
  
  
  1.4       +5 -5      xml-xalan/c/src/PlatformSupport/AttributesImpl.cpp
  
  Index: AttributesImpl.cpp
  ===================================================================
  RCS file: /home/cvs/xml-xalan/c/src/PlatformSupport/AttributesImpl.cpp,v
  retrieving revision 1.3
  retrieving revision 1.4
  diff -u -r1.3 -r1.4
  --- AttributesImpl.cpp	2001/04/30 18:07:02	1.3
  +++ AttributesImpl.cpp	2001/09/25 21:12:51	1.4
  @@ -231,7 +231,7 @@
   unsigned int
   AttributesImpl::getLength() const
   {
  -	return m_attributesVector.size();
  +	return unsigned(m_attributesVector.size());
   }
   
   
  @@ -341,7 +341,7 @@
   	}
   	else
   	{
  -		return getType(AttributesVectorType::size_type(theIndex));
  +		return getType(theIndex);
   	}
   }
   
  @@ -358,7 +358,7 @@
   	}
   	else
   	{
  -		return getValue(AttributesVectorType::size_type(theIndex));
  +		return getValue(theIndex);
   	}
   }
   
  @@ -377,7 +377,7 @@
   	}
   	else
   	{
  -		return getType(AttributesVectorType::size_type(theIndex));
  +		return getType(theIndex);
   	}
   }
   
  @@ -396,7 +396,7 @@
   	}
   	else
   	{
  -		return getValue(AttributesVectorType::size_type(theIndex));
  +		return getValue(theIndex);
   	}
   }
   
  
  
  
  1.62      +58 -55    xml-xalan/c/src/PlatformSupport/DOMStringHelper.cpp
  
  Index: DOMStringHelper.cpp
  ===================================================================
  RCS file: /home/cvs/xml-xalan/c/src/PlatformSupport/DOMStringHelper.cpp,v
  retrieving revision 1.61
  retrieving revision 1.62
  diff -u -r1.61 -r1.62
  --- DOMStringHelper.cpp	2001/09/04 16:48:47	1.61
  +++ DOMStringHelper.cpp	2001/09/25 21:12:51	1.62
  @@ -179,8 +179,8 @@
   	assert(theString != 0);
   	assert(theSubstring != 0);
   
  -	const unsigned int	theStringLength = length(theString);
  -	const unsigned int	theSubstringLength = length(theSubstring);
  +	const XalanDOMString::size_type		theStringLength = length(theString);
  +	const XalanDOMString::size_type		theSubstringLength = length(theSubstring);
   
   	// If the substring is longer than the string, then
   	// it's not a substring.
  @@ -203,13 +203,13 @@
   			  theStringLength - theStringIndex >= theSubstringLength)
   		{
   			// We always start over from the beginning of the second string.
  -			unsigned int	theSubstringIndex = 0;
  +			XalanDOMString::size_type	theSubstringIndex = 0;
   
   			// This variable will be incremented to index into the first
   			// string.  That way, we preserve the first string index for
   			// when we have to restart the following loop with the next
   			// position in the first string.
  -			unsigned int	theOffset = 0;
  +			XalanDOMString::size_type	theOffset = 0;
   
   			// Compare the characters in the two strings, at the
   			// current indices, until the characters don't match.
  @@ -266,7 +266,7 @@
   			const XalanDOMChar*		theString,
   			XalanDOMChar			theChar)
   {
  -	const unsigned int	theLength = length(theString);
  +	const XalanDOMString::size_type		theLength = length(theString);
   
   	if (theLength == 0)
   	{
  @@ -274,15 +274,14 @@
   	}
   	else
   	{
  -		unsigned int	theIndex = theLength - 1;
  +		XalanDOMString::size_type	theIndex = theLength;
   
  -		// Rely on wrap-around...
  -		while(theIndex < theLength && theString[theIndex] != theChar)
  +		while(theIndex > 0 && theString[theIndex - 1] != theChar)
   		{
   			theIndex--;
   		}
   
  -		return theIndex > theLength ? theLength : theIndex;
  +		return theIndex == 0 ? theLength : theIndex - 1;
   	}
   }
   
  @@ -295,9 +294,9 @@
   {
   	bool		fResult = false;
   
  -	const unsigned int	theStringLength = length(theString);
  +	const XalanDOMString::size_type		theStringLength = length(theString);
   
  -	const unsigned int	theSubstringLength = length(theSubstring);
  +	const XalanDOMString::size_type		theSubstringLength = length(theSubstring);
   
   	if (theSubstringLength == 0)
   	{
  @@ -306,7 +305,7 @@
   	}
   	else if (theStringLength >= theSubstringLength)
   	{
  -		unsigned int	i = 0;
  +		XalanDOMString::size_type	i = 0;
   
   		// Compare each character...
   		for (;
  @@ -383,22 +382,25 @@
   			const XalanDOMChar*		theString,
   			const XalanDOMChar*		theSubstring)
   {
  +	assert(theString != 0);
  +	assert(theSubstring != 0);
  +
   	bool				fResult = false;
   
  -	const unsigned int	theStringLength = length(theString);
  +	const XalanDOMString::size_type		theStringLength = length(theString);
   
  -	const unsigned int	theSubStringLength = length(theSubstring);
  +	const XalanDOMString::size_type		theSubstringLength = length(theSubstring);
   
   	// If the substring is longer, there's no point in continuing.
  -	if (theStringLength >= theSubStringLength)
  +	if (theSubstringLength >  0 && theStringLength >= theSubstringLength)
   	{
  -		int		i = theStringLength - 1;
  -		int		j = theSubStringLength - 1;
  +		XalanDOMString::size_type	i = theStringLength;
  +		XalanDOMString::size_type	j = theSubstringLength;
   
   		// Compare each character...
   		for (;
  -				j >= 0 &&
  -						theString[i] == theSubstring[j];
  +				j > 0 &&
  +						theString[i - 1] == theSubstring[j - 1];
   					--j, --i)
   		{
   			;
  @@ -406,7 +408,7 @@
   
   		// If we've gotten to the beginning of the substring, then
   		// return true.
  -		if (j == -1)
  +		if (j == 0)
   		{
   			fResult = true;
   		}
  @@ -474,13 +476,13 @@
   
   XALAN_PLATFORMSUPPORT_EXPORT_FUNCTION(XalanDOMString)
   substring(
  -			const XalanDOMChar*		theString,
  -			unsigned int			theStartIndex,
  -			unsigned int			theEndIndex)
  +			const XalanDOMChar*			theString,
  +			XalanDOMString::size_type	theStartIndex,
  +			XalanDOMString::size_type	theEndIndex)
   {
   	assert(theString != 0);
   
  -	const unsigned int	theStringLength = length(theString);
  +	const XalanDOMString::size_type		theStringLength = length(theString);
   
   	// $$$ ToDo: In Java-land, any failing of this
   	// assertion would result in an exception being thrown.
  @@ -493,7 +495,7 @@
   	}
   	else
   	{
  -		const unsigned int	theLength = theEndIndex == UINT_MAX ? theStringLength - theStartIndex :
  +		const XalanDOMString::size_type		theLength = theEndIndex == XalanDOMString::npos ? theStringLength - theStartIndex :
   													theEndIndex - theStartIndex;
   		assert(theStartIndex + theLength <= theStringLength);
   
  @@ -505,14 +507,14 @@
   
   XALAN_PLATFORMSUPPORT_EXPORT_FUNCTION(XalanDOMString)&
   substring(
  -			const XalanDOMChar*		theString,
  -			XalanDOMString&			theSubstring,
  -			unsigned int			theStartIndex,
  -			unsigned int			theEndIndex)
  +			const XalanDOMChar*			theString,
  +			XalanDOMString&				theSubstring,
  +			XalanDOMString::size_type	theStartIndex,
  +			XalanDOMString::size_type	theEndIndex)
   {
   	assert(theString != 0);
   
  -	const unsigned int	theStringLength = length(theString);
  +	const XalanDOMString::size_type		theStringLength = length(theString);
   
   	// $$$ ToDo: In Java-land, any failing of this
   	// assertion would result in an exception being thrown.
  @@ -525,7 +527,7 @@
   	}
   	else
   	{
  -		const unsigned int	theLength = theEndIndex == UINT_MAX ? theStringLength - theStartIndex :
  +		const XalanDOMString::size_type		theLength = theEndIndex == XalanDOMString::npos ? theStringLength - theStartIndex :
   													theEndIndex - theStartIndex;
   		assert(theStartIndex + theLength <= theStringLength);
   
  @@ -539,12 +541,12 @@
   
   XALAN_PLATFORMSUPPORT_EXPORT_FUNCTION(void)
   substring(
  -			const XalanDOMString&	theString,
  -			XalanDOMString&			theSubstring,
  -			unsigned int			theStartIndex,
  -			unsigned int			theEndIndex)
  +			const XalanDOMString&		theString,
  +			XalanDOMString&				theSubstring,
  +			XalanDOMString::size_type	theStartIndex,
  +			XalanDOMString::size_type	theEndIndex)
   {
  -	const unsigned int	theStringLength = length(theString);
  +	const XalanDOMString::size_type		theStringLength = length(theString);
   
   	// $$$ ToDo: In Java-land, any failing of this
   	// assertion would result in an exception being thrown.
  @@ -557,7 +559,7 @@
   	}
   	else
   	{
  -		const unsigned int	theLength = theEndIndex == UINT_MAX ? theStringLength - theStartIndex :
  +		const XalanDOMString::size_type		theLength = theEndIndex == XalanDOMString::npos ? theStringLength - theStartIndex :
   													theEndIndex - theStartIndex;
   
   		if (theLength == 0)
  @@ -577,11 +579,11 @@
   
   XALAN_PLATFORMSUPPORT_EXPORT_FUNCTION(XalanDOMString)
   substring(
  -			const XalanDOMString&	theString,
  -			unsigned int			theStartIndex,
  -			unsigned int			theEndIndex)
  +			const XalanDOMString&		theString,
  +			XalanDOMString::size_type	theStartIndex,
  +			XalanDOMString::size_type	theEndIndex)
   {
  -	const unsigned int	theStringLength = length(theString);
  +	const XalanDOMString::size_type		theStringLength = length(theString);
   
   	// $$$ ToDo: In Java-land, any failing of this
   	// assertion would result in an exception being thrown.
  @@ -594,7 +596,7 @@
   	}
   	else
   	{
  -		const unsigned int	theLength = theEndIndex == UINT_MAX ? theStringLength - theStartIndex :
  +		const XalanDOMString::size_type		theLength = theEndIndex == XalanDOMString::npos ? theStringLength - theStartIndex :
   													theEndIndex - theStartIndex;
   
   		if (theLength == 0)
  @@ -704,7 +706,7 @@
   			const XalanDOMString&	theInputString,
   			FunctionType			theFunction)
   {
  -	const unsigned int	theStringLength = length(theInputString);
  +	const XalanDOMString::size_type		theStringLength = length(theInputString);
   
   	if (theStringLength == 0)
   	{
  @@ -1091,7 +1093,7 @@
   	else
   	{
   		// Include the terminating null byte...
  -		const unsigned int	theLength = strlen(data) + 1;
  +		const size_t	theLength = strlen(data) + 1;
   
   		theResult.reserve(theLength);
   
  @@ -1118,7 +1120,7 @@
   {
   	assert(data != 0);
   
  -	unsigned int	theLength = length(data);
  +	const XalanDOMString::size_type		theLength = length(data);
   
   	// Create a vector which includes the terminating 0.
   	return XalanDOMCharVectorType(data, data + theLength + 1);
  @@ -1131,13 +1133,13 @@
   			const XalanDOMChar*		theString,
   			CharVectorType&			theVector)
   {
  -	const unsigned int	theLength = length(theString);
  +	const XalanDOMString::size_type		theLength = length(theString);
   
   	if (theLength != 0)
   	{
   		theVector.reserve(theVector.size() + theLength + 1);
   
  -		for(unsigned int i = 0; i < theLength; i++)
  +		for(XalanDOMString::size_type i = 0; i < theLength; i++)
   		{
   			// Assert that the truncation will not affect the resulting character.
   			assert(theString[i] == char(theString[i]));
  @@ -1258,24 +1260,25 @@
   {
   	if (isEmpty(theString))
   		return theString;
  +
  +	const XalanDOMString::size_type		strLen = length(theString);
  +	assert(strLen > 0);
   
  -	const int	strLen = length(theString);
  -	
   	// index of first non-whitespace character
  -	int			leadingSpace = 0;
  +	XalanDOMString::size_type	leadingSpace = 0;
   
   	for (; leadingSpace < strLen; ++leadingSpace)
   		if (!isXMLWhitespace(charAt(theString, leadingSpace)))
   			break;
   
   	// index of last non-whitespace character
  -	int trailingSpace = strLen - 1;
  +	XalanDOMString::size_type	trailingSpace = strLen - 1;
   
  -	for (; trailingSpace>=0; --trailingSpace)
  -		if (!isXMLWhitespace(charAt(theString, trailingSpace)))
  +	for (; trailingSpace > 0; --trailingSpace)
  +		if (!isXMLWhitespace(charAt(theString, trailingSpace - 1)))
   			break;
   
  -	return substring(theString, leadingSpace, trailingSpace + 1);
  +	return substring(theString, leadingSpace, trailingSpace);
   }
   
   
  @@ -1692,7 +1695,7 @@
   XALAN_PLATFORMSUPPORT_EXPORT_FUNCTION(bool)
   isXMLWhitespace(const XalanDOMString&	string)
   {
  -	const unsigned int	theLength = length(string);
  +	const XalanDOMString::size_type		theLength = length(string);
   
   	if (theLength == 0)
   	{
  
  
  
  1.51      +83 -83    xml-xalan/c/src/PlatformSupport/DOMStringHelper.hpp
  
  Index: DOMStringHelper.hpp
  ===================================================================
  RCS file: /home/cvs/xml-xalan/c/src/PlatformSupport/DOMStringHelper.hpp,v
  retrieving revision 1.50
  retrieving revision 1.51
  diff -u -r1.50 -r1.51
  --- DOMStringHelper.hpp	2001/08/15 14:37:51	1.50
  +++ DOMStringHelper.hpp	2001/09/25 21:12:51	1.51
  @@ -272,8 +272,8 @@
    */
   inline void
   reserve(
  -			XalanDOMString&		theString,
  -			unsigned int		theCount)
  +			XalanDOMString&				theString,
  +			XalanDOMString::size_type	theCount)
   {
   	theString.reserve(theCount);
   }
  @@ -286,7 +286,7 @@
    * @param theString target string
    * @return the length of the target string
    */
  -inline unsigned int
  +inline XalanDOMString::size_type
   length(const XalanDOMString&	theString)
   {
   	return theString.length();
  @@ -301,7 +301,7 @@
    * @param theString target string
    * @return the length of the target string
    */
  -inline unsigned int
  +inline XalanDOMString::size_type
   length(const XalanDOMChar*	theString)
   {
   	assert(theString != 0);
  @@ -313,7 +313,7 @@
   		theBufferPointer++;
   	}
   
  -	return unsigned(theBufferPointer - theString);
  +	return XalanDOMString::size_type(theBufferPointer - theString);
   }
   
   
  @@ -324,12 +324,12 @@
    * @param theString target string
    * @return the length of the target string
    */
  -inline unsigned int
  +inline XalanDOMString::size_type
   length(const char*	theString)
   {
   	assert(theString != 0);
   
  -	return unsigned(strlen(theString));
  +	return XalanDOMString::size_type(strlen(theString));
   }
   
   
  @@ -357,7 +357,7 @@
    * or length(theString) if the character is not
    * found.    
    */
  -inline unsigned int
  +inline XalanDOMString::size_type
   indexOf(
   			const XalanDOMChar*		theString,
   			XalanDOMChar			theChar)
  @@ -371,7 +371,7 @@
   		++thePointer;
   	}
   
  -	return unsigned(thePointer - theString);
  +	return XalanDOMString::size_type(thePointer - theString);
   }
   
   
  @@ -386,11 +386,11 @@
    * or length(theString) if the character is not
    * found.    
    */
  -inline unsigned int
  +inline XalanDOMString::size_type
   indexOf(
  -			const XalanDOMChar*		theString,
  -			unsigned int			theStringLength,
  -			XalanDOMChar			theChar)
  +			const XalanDOMChar*			theString,
  +			XalanDOMString::size_type	theStringLength,
  +			XalanDOMChar				theChar)
   {
   	assert(theString != 0);
   
  @@ -402,7 +402,7 @@
   		++thePointer;
   	}
   
  -	return unsigned(thePointer - theString);
  +	return XalanDOMString::size_type(thePointer - theString);
   }
   
   
  @@ -416,7 +416,7 @@
    * or length(theString) if the character is not
    * found.    
    */
  -inline unsigned int
  +inline XalanDOMString::size_type
   indexOf(
   			const XalanDOMString&	theString,
   			XalanDOMChar			theChar)
  @@ -435,7 +435,7 @@
    * or length(theString) if the string is not
    * found.
    */
  -XALAN_PLATFORMSUPPORT_EXPORT_FUNCTION(unsigned int)
  +XALAN_PLATFORMSUPPORT_EXPORT_FUNCTION(XalanDOMString::size_type)
   indexOf(
   			const XalanDOMChar*		theString,
   			const XalanDOMChar*		theSubstring);
  @@ -450,7 +450,7 @@
    * or length(theString) if the string is not
    * found.
    */
  -XALAN_PLATFORMSUPPORT_EXPORT_FUNCTION(unsigned int)
  +XALAN_PLATFORMSUPPORT_EXPORT_FUNCTION(XalanDOMString::size_type)
   indexOf(
   			const XalanDOMString&	theString,
   			const XalanDOMString&	theSubstring);
  @@ -467,7 +467,7 @@
    * found.
    */
   
  -XALAN_PLATFORMSUPPORT_EXPORT_FUNCTION(unsigned int)
  +XALAN_PLATFORMSUPPORT_EXPORT_FUNCTION(XalanDOMString::size_type)
   lastIndexOf(
   			const XalanDOMChar*		theString,
   			XalanDOMChar			theChar);
  @@ -483,7 +483,7 @@
    * or length(theString) if the character is not
    * found.
    */
  -inline unsigned int
  +inline XalanDOMString::size_type
   lastIndexOf(
   			const XalanDOMString&	theString,
   			XalanDOMChar			theChar)
  @@ -1114,8 +1114,8 @@
    */
   inline XalanDOMChar
   charAt(
  -			const XalanDOMString&	theString,
  -			unsigned int			theIndex)
  +			const XalanDOMString&		theString,
  +			XalanDOMString::size_type	theIndex)
   {
   	return theString[theIndex];
   }
  @@ -1178,9 +1178,9 @@
    */
   XALAN_PLATFORMSUPPORT_EXPORT_FUNCTION(XalanDOMString)
   substring(
  -			const XalanDOMChar*		theString,
  -			unsigned int			theStartIndex,
  -			unsigned int			theEndIndex = unsigned(-1));
  +			const XalanDOMChar*			theString,
  +			XalanDOMString::size_type	theStartIndex,
  +			XalanDOMString::size_type	theEndIndex = XalanDOMString::npos);
   
   
   
  @@ -1198,10 +1198,10 @@
    */
   XALAN_PLATFORMSUPPORT_EXPORT_FUNCTION(XalanDOMString)&
   substring(
  -			const XalanDOMChar*		theString,
  -			XalanDOMString&			theSubstring,
  -			unsigned int			theStartIndex,
  -			unsigned int			theEndIndex = unsigned(-1));
  +			const XalanDOMChar*			theString,
  +			XalanDOMString&				theSubstring,
  +			XalanDOMString::size_type	theStartIndex,
  +			XalanDOMString::size_type	theEndIndex = XalanDOMString::npos);
   
   
   
  @@ -1218,10 +1218,10 @@
    */
   XALAN_PLATFORMSUPPORT_EXPORT_FUNCTION(void)
   substring(
  -			const XalanDOMString&	theString,
  -			XalanDOMString&			theSubstring,
  -			unsigned int			theStartIndex,
  -			unsigned int			theEndIndex = unsigned(-1));
  +			const XalanDOMString&		theString,
  +			XalanDOMString&				theSubstring,
  +			XalanDOMString::size_type	theStartIndex,
  +			XalanDOMString::size_type	theEndIndex = XalanDOMString::npos);
   
   
   
  @@ -1238,9 +1238,9 @@
    */
   XALAN_PLATFORMSUPPORT_EXPORT_FUNCTION(XalanDOMString)
   substring(
  -			const XalanDOMString&	theString,
  -			unsigned int			theStartIndex,
  -			unsigned int			theEndIndex = unsigned(-1));
  +			const XalanDOMString&		theString,
  +			XalanDOMString::size_type	theStartIndex,
  +			XalanDOMString::size_type	theEndIndex = XalanDOMString::npos);
   
   
   
  @@ -1376,10 +1376,10 @@
    */
   XALAN_PLATFORMSUPPORT_EXPORT_FUNCTION(int)
   compare(
  -			const XalanDOMChar*		theLHS,
  -			unsigned int			theLHSLength,
  -			const XalanDOMChar*		theRHS,
  -			unsigned int			theRHSLength);
  +			const XalanDOMChar*			theLHS,
  +			XalanDOMString::size_type	theLHSLength,
  +			const XalanDOMChar*			theRHS,
  +			XalanDOMString::size_type	theRHSLength);
   
   
   
  @@ -1480,10 +1480,10 @@
    */
   XALAN_PLATFORMSUPPORT_EXPORT_FUNCTION(int)
   compareIgnoreCaseASCII(
  -			const XalanDOMChar*		theLHS,
  -			unsigned int			theLHSLength,
  -			const XalanDOMChar*		theRHS,
  -			unsigned int			theRHSLength);
  +			const XalanDOMChar*			theLHS,
  +			XalanDOMString::size_type	theLHSLength,
  +			const XalanDOMChar*			theRHS,
  +			XalanDOMString::size_type	theRHSLength);
   
   
   
  @@ -1587,10 +1587,10 @@
    */
   XALAN_PLATFORMSUPPORT_EXPORT_FUNCTION(int)
   collationCompare(
  -			const XalanDOMChar*		theLHS,
  -			unsigned int			theLHSLength,
  -			const XalanDOMChar*		theRHS,
  -			unsigned int			theRHSLength);
  +			const XalanDOMChar*			theLHS,
  +			XalanDOMString::size_type	theLHSLength,
  +			const XalanDOMChar*			theRHS,
  +			XalanDOMString::size_type	theRHSLength);
   
    
    
  @@ -1680,9 +1680,9 @@
    */
   XALAN_PLATFORMSUPPORT_EXPORT_FUNCTION(bool)
   equals(
  -			const XalanDOMChar*		theLHS,
  -			const XalanDOMChar*		theRHS,
  -			unsigned int			theLength);
  +			const XalanDOMChar*			theLHS,
  +			const XalanDOMChar*			theRHS,
  +			XalanDOMString::size_type	theLength);
   
   
   
  @@ -1698,7 +1698,7 @@
   			const XalanDOMChar*		theLHS,
   			const XalanDOMChar*		theRHS)
   {
  -	const unsigned int	theLHSLength = length(theLHS);
  +	const XalanDOMString::size_type		theLHSLength = length(theLHS);
   
   	return theLHSLength != length(theRHS) ? false : equals(theLHS, theRHS, theLHSLength);
   }
  @@ -1771,7 +1771,7 @@
   {
   	assert(theRHS != 0);
   
  -	const unsigned int	theRHSLength = length(theRHS);
  +	const XalanDOMString::size_type		theRHSLength = length(theRHS);
   
   	if (theRHSLength != length(theLHS))
   	{
  @@ -1815,7 +1815,7 @@
   	assert(theLHS != 0);
   	assert(theRHS != 0);
   
  -	const unsigned int	theRHSLength = length(theRHS);
  +	const XalanDOMString::size_type		theRHSLength = length(theRHS);
   
   	if (theRHSLength != length(theLHS))
   	{
  @@ -1855,9 +1855,9 @@
    */
   XALAN_PLATFORMSUPPORT_EXPORT_FUNCTION(bool)
   equalsIgnoreCaseASCII(
  -			const XalanDOMChar*		theLHS,
  -			const XalanDOMChar*		theRHS,
  -			unsigned int			theLength);
  +			const XalanDOMChar*			theLHS,
  +			const XalanDOMChar*			theRHS,
  +			XalanDOMString::size_type	theLength);
   
   
   
  @@ -1874,7 +1874,7 @@
   			const XalanDOMChar*		theLHS,
   			const XalanDOMChar*		theRHS)
   {
  -	const unsigned int	theLength = length(theLHS);
  +	const XalanDOMString::size_type		theLength = length(theLHS);
   
   	return theLength != length(theRHS) ? false :
   		equalsIgnoreCaseASCII(theLHS, theRHS, theLength);
  @@ -1895,7 +1895,7 @@
   			const XalanDOMString&	theLHS,
   			const XalanDOMString&	theRHS)
   {
  -	const unsigned int	theLength = length(theLHS);
  +	const XalanDOMString::size_type		theLength = length(theLHS);
   
   	return theLength != length(theRHS) ? false :
   		equalsIgnoreCaseASCII(toCharArray(theLHS), toCharArray(theRHS), theLength);
  @@ -1916,7 +1916,7 @@
   			const XalanDOMChar*		theLHS,
   			const XalanDOMString&	theRHS)
   {
  -	const unsigned int	theRHSLength = length(theRHS);
  +	const XalanDOMString::size_type		theRHSLength = length(theRHS);
   
   	return theRHSLength != length(theLHS) ? false :
   		equalsIgnoreCaseASCII(theLHS, toCharArray(theRHS), theRHSLength);
  @@ -1985,7 +1985,7 @@
    * 
    * @param theString         target string
    * @param theStringToAppend string to assign
  - * @param theStringToAppendLength length of the string (-1 implies the string is null-terminated)
  + * @param theStringToAppendLength length of the string (XalanDOMString::npos implies the string is null-terminated)
    * @return a reference to the target string
    */
   inline XalanDOMString&
  @@ -2005,16 +2005,16 @@
    * 
    * @param theString         target string
    * @param theStringToAppend string to assign
  - * @param theStringToAppendLength length of the string (-1 implies the string is null-terminated)
  + * @param theStringToAppendLength length of the string (XalanDOMString::npos implies the string is null-terminated)
    * @return a reference to the target string
    */
   inline XalanDOMString&
   assign(
  -			XalanDOMString&			theString,
  -			const XalanDOMChar*		theStringToAssign,
  -			unsigned int			theStringToAssignLength = unsigned(-1))
  +			XalanDOMString&				theString,
  +			const XalanDOMChar*			theStringToAssign,
  +			XalanDOMString::size_type	theStringToAssignLength = XalanDOMString::npos)
   {
  -	if (theStringToAssignLength == unsigned(-1))
  +	if (theStringToAssignLength == XalanDOMString::npos)
   	{
   		theString.assign(theStringToAssign);
   	}
  @@ -2052,18 +2052,18 @@
    * 
    * @param theString         target string
    * @param theStringToAppend string to add to target
  - * @param theStringToAppendLength length of the string (-1 implies the string is null-terminated)
  + * @param theStringToAppendLength length of the string (XalanDOMString::npos implies the string is null-terminated)
    * @return a reference to the target string
    */
   inline XalanDOMString&
   append(
  -			XalanDOMString&			theString,
  -			const XalanDOMChar*		theStringToAppend,
  -			unsigned int			theStringToAppendLength = unsigned(-1))
  +			XalanDOMString&				theString,
  +			const XalanDOMChar*			theStringToAppend,
  +			XalanDOMString::size_type	theStringToAppendLength = XalanDOMString::npos)
   {
   	assert(theStringToAppend != 0);
   
  -	if (theStringToAppendLength == unsigned(-1))
  +	if (theStringToAppendLength == XalanDOMString::npos)
   	{
   		theString.append(theStringToAppend);
   	}
  @@ -2082,14 +2082,14 @@
    * 
    * @param theString         target string
    * @param theStringToAppend string to add to target
  - * @param theStringToAppendLength length of the string (-1 implies the string is null-terminated)
  + * @param theStringToAppendLength length of the string (XalanDOMString::npos implies the string is null-terminated)
    * @return string with contents of 'theStringToAppend' added to target string
    */
   inline XalanDOMString&
   append(
  -			XalanDOMString&		theString,
  -			const char*			theStringToAppend,
  -			unsigned int		theStringToAppendLength = unsigned(-1))
  +			XalanDOMString&				theString,
  +			const char*					theStringToAppend,
  +			XalanDOMString::size_type	theStringToAppendLength = XalanDOMString::npos)
   {
   	theString.append(TranscodeFromLocalCodePage(theStringToAppend, theStringToAppendLength));
   
  @@ -2147,9 +2147,9 @@
    */
   inline XalanDOMString&
   insert(
  -			XalanDOMString&			theString,
  -			unsigned int			thePosition,
  -			const XalanDOMString&	theStringToInsert)
  +			XalanDOMString&				theString,
  +			XalanDOMString::size_type	thePosition,
  +			const XalanDOMString&		theStringToInsert)
   {
   	theString.insert(thePosition, theStringToInsert);
   
  @@ -2168,9 +2168,9 @@
    */
   inline XalanDOMString&
   insert(
  -			XalanDOMString&			theString,
  -			unsigned int			thePosition,
  -			const XalanDOMChar*		theStringToInsert)
  +			XalanDOMString&				theString,
  +			XalanDOMString::size_type	thePosition,
  +			const XalanDOMChar*			theStringToInsert)
   {
   	theString.insert(thePosition, theStringToInsert);
   
  @@ -2548,9 +2548,9 @@
    */
   XALAN_PLATFORMSUPPORT_EXPORT_FUNCTION(bool)
   isXMLWhitespace(
  -			const XalanDOMChar	ch[],
  -			unsigned int		start,
  -			unsigned int		length);
  +			const XalanDOMChar			ch[],
  +			XalanDOMString::size_type	start,
  +			XalanDOMString::size_type	length);
   
   
   
  
  
  
  1.12      +14 -14    xml-xalan/c/src/PlatformSupport/DOMStringPrintWriter.cpp
  
  Index: DOMStringPrintWriter.cpp
  ===================================================================
  RCS file: /home/cvs/xml-xalan/c/src/PlatformSupport/DOMStringPrintWriter.cpp,v
  retrieving revision 1.11
  retrieving revision 1.12
  diff -u -r1.11 -r1.12
  --- DOMStringPrintWriter.cpp	2001/02/07 04:05:05	1.11
  +++ DOMStringPrintWriter.cpp	2001/09/25 21:12:51	1.12
  @@ -105,8 +105,8 @@
   void
   DOMStringPrintWriter::write(
   			const char*		s,
  -			unsigned int	theOffset,
  -			unsigned int	theLength)
  +			size_t			theOffset,
  +			size_t			theLength)
   {
   	write(TranscodeFromLocalCodePage(s), theOffset, theLength);
   }
  @@ -115,9 +115,9 @@
   
   void
   DOMStringPrintWriter::write(
  -			const XalanDOMChar*		s,
  -			unsigned int			theOffset,
  -			unsigned int			theLength)
  +			const XalanDOMChar*			s,
  +			XalanDOMString::size_type	theOffset,
  +			XalanDOMString::size_type	theLength)
   {
   #if !defined(XALAN_NO_NAMESPACES)
   	using std::vector;
  @@ -141,9 +141,9 @@
   
   void
   DOMStringPrintWriter::write(
  -			const XalanDOMString&	s,
  -			unsigned int			theOffset,
  -			unsigned int			theLength)
  +			const XalanDOMString&		s,
  +			XalanDOMString::size_type	theOffset,
  +			XalanDOMString::size_type	theLength)
   {
   	assert(c_wstr(s) != 0);
   	assert(theLength == UINT_MAX || length(s) >= theOffset + theLength);
  @@ -188,7 +188,7 @@
   void
   DOMStringPrintWriter::print(
   			const char*		s,
  -			unsigned int	theLength)
  +			size_t			theLength)
   {
   	write(s,
   		  0,
  @@ -199,8 +199,8 @@
   
   void
   DOMStringPrintWriter::print(
  -			const XalanDOMChar*		s,
  -			unsigned int			theLength)
  +			const XalanDOMChar*			s,
  +			XalanDOMString::size_type	theLength)
   {
   	write(s,
   		  0,
  @@ -274,7 +274,7 @@
   void
   DOMStringPrintWriter::println(
   			const char*		s,
  -			unsigned int	theLength)
  +			size_t			theLength)
   {
   	print(s, theLength);
   
  @@ -285,8 +285,8 @@
   
   void
   DOMStringPrintWriter::println(
  -			const XalanDOMChar*		s,
  -			unsigned int			theLength)
  +			const XalanDOMChar*			s,
  +			XalanDOMString::size_type	theLength)
   {
   	print(s, theLength);
   
  
  
  
  1.9       +30 -30    xml-xalan/c/src/PlatformSupport/DOMStringPrintWriter.hpp
  
  Index: DOMStringPrintWriter.hpp
  ===================================================================
  RCS file: /home/cvs/xml-xalan/c/src/PlatformSupport/DOMStringPrintWriter.hpp,v
  retrieving revision 1.8
  retrieving revision 1.9
  diff -u -r1.8 -r1.9
  --- DOMStringPrintWriter.hpp	2000/11/02 01:45:35	1.8
  +++ DOMStringPrintWriter.hpp	2001/09/25 21:12:51	1.9
  @@ -93,7 +93,6 @@
   
   	// Output functions inherited from PrintWriter...
   
  -	// Flush the stream, then check the error status.
   	virtual bool
       checkError() const;
   
  @@ -103,29 +102,26 @@
   	virtual void
   	flush();
   
  -
  -	// Output functions
  -
  -	// If the length is UINT_MAX, then the array is assumed to be null-terminated.
   	virtual void
  -	write(const char*	s,
  -		  unsigned int	theOffset = 0,
  -		  unsigned int	theLength = UINT_MAX);
  +	write(
  +			const char*		s,
  +			size_t			theOffset = 0,
  +			size_t			theLength = size_t(-1));
   
  -	// If the length is UINT_MAX, then the array is assumed to be null-terminated.
   	virtual void
  -	write(const XalanDOMChar*	s,
  -		  unsigned int			theOffset = 0,
  -		  unsigned int			theLength = UINT_MAX);
  +	write(
  +			const XalanDOMChar*			s,
  +			XalanDOMString::size_type	theOffset = 0,
  +			XalanDOMString::size_type	theLength = XalanDOMString::npos);
   
   	virtual void
  -	write(XalanDOMChar	c);
  +	write(XalanDOMChar		c);
   
  -	// If the length is UINT_MAX, then the entire string is printed.
   	virtual void
  -	write(const XalanDOMString&		s,
  -		  unsigned int				theOffset = 0,
  -		  unsigned int				theLength = UINT_MAX);
  +	write(
  +			const XalanDOMString&		s,
  +			XalanDOMString::size_type	theOffset = 0,
  +			XalanDOMString::size_type	theLength = XalanDOMString::npos);
   
   #if !defined(XALAN_BOOL_AS_INT)
   	virtual void
  @@ -136,12 +132,14 @@
   	print(char	c);
   
   	virtual void
  -	print(const char*	s,
  -		  unsigned int	theLength = UINT_MAX);
  +	print(
  +			const char*		s,
  +			size_t			theLength = size_t(-1));
   
   	virtual void
  -	print(const XalanDOMChar*	s,
  -		  unsigned int			theLength = UINT_MAX);
  +	print(
  +			const XalanDOMChar*			s,
  +			XalanDOMString::size_type	theLength = XalanDOMString::npos);
   
   	virtual void
   	print(double	d);
  @@ -160,28 +158,30 @@
   
   #if !defined(XALAN_BOOL_AS_INT)
   	virtual void
  -	println(bool	b);
  +	println(bool	x);
   #endif
   
   	virtual void
  -	println(char	c);
  +	println(char	x);
   
   	virtual void
  -	println(const char*		s,
  -		    unsigned int	theLength = UINT_MAX);
  +	println(
  +			const char*		s,
  +		    size_t			theLength = size_t(-1));
   
   	virtual void
  -	println(const XalanDOMChar*		s,
  -			unsigned int			theLength = UINT_MAX);
  +	println(
  +			const XalanDOMChar*			s,
  +			XalanDOMString::size_type	theLength = XalanDOMString::npos);
   
   	virtual void
  -	println(double	d);
  +	println(double	x);
   
   	virtual void
  -	println(int		i);
  +	println(int		x);
   
   	virtual void
  -	println(long	l);
  +	println(long	x);
   
   	virtual void
   	println(const XalanDOMString&	s);
  
  
  
  1.28      +3 -3      xml-xalan/c/src/PlatformSupport/DoubleSupport.cpp
  
  Index: DoubleSupport.cpp
  ===================================================================
  RCS file: /home/cvs/xml-xalan/c/src/PlatformSupport/DoubleSupport.cpp,v
  retrieving revision 1.27
  retrieving revision 1.28
  diff -u -r1.27 -r1.28
  --- DoubleSupport.cpp	2001/08/10 17:50:08	1.27
  +++ DoubleSupport.cpp	2001/09/25 21:12:51	1.28
  @@ -605,9 +605,9 @@
   	// string is less than n characters, we'll convert
   	// it as a long and coerce that to a double.  This
   	// is _much_ cheaper...
  -	const unsigned int	theLongHackThreshold = 10;
  +	const XalanDOMString::size_type		theLongHackThreshold = 10;
   
  -	unsigned int	theLength = length(theString);
  +	XalanDOMString::size_type	theLength = length(theString);
   
   	if (fGotDecimalPoint == false && theLength < theLongHackThreshold)
   	{
  @@ -619,7 +619,7 @@
   		consumeWhitespace(theString, theLength);
   
   		// Use a stack-based buffer, when possible...
  -		const unsigned int	theBufferSize = 200u;
  +		const XalanDOMString::size_type		theBufferSize = 200u;
   
   		if (theLength < theBufferSize)
   		{
  
  
  
  1.3       +8 -5      xml-xalan/c/src/PlatformSupport/FormatterListener.hpp
  
  Index: FormatterListener.hpp
  ===================================================================
  RCS file: /home/cvs/xml-xalan/c/src/PlatformSupport/FormatterListener.hpp,v
  retrieving revision 1.2
  retrieving revision 1.3
  diff -u -r1.2 -r1.3
  --- FormatterListener.hpp	2001/06/29 18:41:45	1.2
  +++ FormatterListener.hpp	2001/09/25 21:12:51	1.3
  @@ -58,7 +58,7 @@
   #define FORMATTERLISTENER_HEADER_GUARD_1357924680
   
   /**
  - * $Id: FormatterListener.hpp,v 1.2 2001/06/29 18:41:45 dbertoni Exp $
  + * $Id: FormatterListener.hpp,v 1.3 2001/09/25 21:12:51 dbertoni Exp $
    * 
    * $State: Exp $
    * 
  @@ -92,6 +92,9 @@
   {
   public:
   
  +	// A handy typedef...  Must match DocumentHandler's type for characters(), etc...
  +	typedef unsigned int	size_type;
  +
   	/**
   	 * Perform static initialization.  See class XMLSupportInit.
   	 */
  @@ -161,7 +164,7 @@
   	virtual void
   	charactersRaw(
   			const XMLCh* const	chars,
  -			const unsigned int	length) = 0;
  +			const size_type		length) = 0;
   
   	/**
   	 * Called when a Comment is to be constructed.
  @@ -196,7 +199,7 @@
   	virtual void
   	cdata(
   			const XMLCh* const	ch,
  -			const unsigned int 	length) = 0;
  +			const size_type 	length) = 0;
   
   	/**
   	 * Receive notification of a entityReference.
  @@ -213,7 +216,7 @@
       virtual void
   	characters(
   			const XMLCh* const	chars,
  -			const unsigned int	length) = 0;
  +			const size_type		length) = 0;
   
       virtual void
   	endDocument() = 0;
  @@ -224,7 +227,7 @@
   	virtual void
   	ignorableWhitespace(
   			const XMLCh* const	chars,
  -			const unsigned int	length) = 0;
  +			const size_type		length) = 0;
   
   	virtual void
   	processingInstruction(
  
  
  
  1.5       +14 -14    xml-xalan/c/src/PlatformSupport/NullPrintWriter.cpp
  
  Index: NullPrintWriter.cpp
  ===================================================================
  RCS file: /home/cvs/xml-xalan/c/src/PlatformSupport/NullPrintWriter.cpp,v
  retrieving revision 1.4
  retrieving revision 1.5
  diff -u -r1.4 -r1.5
  --- NullPrintWriter.cpp	2000/08/15 19:41:10	1.4
  +++ NullPrintWriter.cpp	2001/09/25 21:12:51	1.5
  @@ -97,8 +97,8 @@
   void
   NullPrintWriter::write(
   			const char*		/* s */,
  -			unsigned int	/* theOffset */,
  -			unsigned int	/* theLength */)
  +			size_t			/* theOffset */,
  +			size_t			/* theLength */)
   {
   }
   
  @@ -106,9 +106,9 @@
   
   void
   NullPrintWriter::write(
  -			const XalanDOMChar*	/* s */,
  -			unsigned int		/* theOffset */,
  -			unsigned int		/* theLength */)
  +			const XalanDOMChar*			/* s */,
  +			XalanDOMString::size_type	/* theOffset */,
  +			XalanDOMString::size_type	/* theLength */)
   {
   }
   
  @@ -123,9 +123,9 @@
   
   void
   NullPrintWriter::write(
  -			const XalanDOMString&	/* s */,
  -			unsigned int			/* theOffset */,
  -			unsigned int			/* theLength */)
  +			const XalanDOMString&		/* s */,
  +			XalanDOMString::size_type	/* theOffset */,
  +			XalanDOMString::size_type	/* theLength */)
   {
   }
   
  @@ -150,7 +150,7 @@
   void
   NullPrintWriter::print(
   			const char*		/* s */,
  -			unsigned int	/* theLength */)
  +			size_t			/* theLength */)
   {
   }
   
  @@ -158,8 +158,8 @@
   
   void
   NullPrintWriter::print(
  -			const XalanDOMChar*	/* s */,
  -			unsigned int		/* theLength */)
  +			const XalanDOMChar*			/* s */,
  +			XalanDOMString::size_type	/* theLength */)
   {
   }
   
  @@ -219,7 +219,7 @@
   void
   NullPrintWriter::println(
   			const char*		/* s */,
  -			unsigned int	/* theLength */)
  +			size_t			/* theLength */)
   {
   }
   
  @@ -227,8 +227,8 @@
   
   void
   NullPrintWriter::println(
  -			const XalanDOMChar*		/* s */,
  -			unsigned int			/* theLength */)
  +			const XalanDOMChar*			/* s */,
  +			XalanDOMString::size_type	/* theLength */)
   {
   }
   
  
  
  
  1.5       +24 -20    xml-xalan/c/src/PlatformSupport/NullPrintWriter.hpp
  
  Index: NullPrintWriter.hpp
  ===================================================================
  RCS file: /home/cvs/xml-xalan/c/src/PlatformSupport/NullPrintWriter.hpp,v
  retrieving revision 1.4
  retrieving revision 1.5
  diff -u -r1.4 -r1.5
  --- NullPrintWriter.hpp	2000/08/15 19:41:10	1.4
  +++ NullPrintWriter.hpp	2001/09/25 21:12:51	1.5
  @@ -90,26 +90,26 @@
   	virtual void
   	flush();
   
  -	// If the length is UINT_MAX, then the array is assumed to be null-terminated.
   	virtual void
  -	write(const char*	s,
  -		  unsigned int	theOffset = 0,
  -		  unsigned int	theLength = UINT_MAX);
  +	write(
  +			const char*		s,
  +			size_t			theOffset = 0,
  +			size_t			theLength = size_t(-1));
   
  -	// If the length is UINT_MAX, then the array is assumed to be null-terminated.
   	virtual void
  -	write(const XalanDOMChar*	s,
  -		  unsigned int	theOffset = 0,
  -		  unsigned int	theLength = UINT_MAX);
  +	write(
  +			const XalanDOMChar*			s,
  +			XalanDOMString::size_type	theOffset = 0,
  +			XalanDOMString::size_type	theLength = XalanDOMString::npos);
   
   	virtual void
   	write(XalanDOMChar		c);
   
  -	// If the length is UINT_MAX, then the entire string is printed.
   	virtual void
  -	write(const XalanDOMString&		s,
  -		  unsigned int				theOffset = 0,
  -		  unsigned int				theLength = UINT_MAX);
  +	write(
  +			const XalanDOMString&		s,
  +			XalanDOMString::size_type	theOffset = 0,
  +			XalanDOMString::size_type	theLength = XalanDOMString::npos);
   
   #if !defined(XALAN_BOOL_AS_INT)
   	virtual void
  @@ -120,12 +120,14 @@
   	print(char	c);
   
   	virtual void
  -	print(const char*	s,
  -		  unsigned int	theLength = UINT_MAX);
  +	print(
  +			const char*		s,
  +			size_t			theLength = size_t(-1));
   
   	virtual void
  -	print(const XalanDOMChar*	s,
  -		  unsigned int			theLength = UINT_MAX);
  +	print(
  +			const XalanDOMChar*			s,
  +			XalanDOMString::size_type	theLength = XalanDOMString::npos);
   
   	virtual void
   	print(double	d);
  @@ -151,12 +153,14 @@
   	println(char	x);
   
   	virtual void
  -	println(const char*		s,
  -			unsigned int	theLength = UINT_MAX);
  +	println(
  +			const char*		s,
  +		    size_t			theLength = size_t(-1));
   
   	virtual void
  -	println(const XalanDOMChar*		s,
  -			unsigned int			theLength = UINT_MAX);
  +	println(
  +			const XalanDOMChar*			s,
  +			XalanDOMString::size_type	theLength = XalanDOMString::npos);
   
   	virtual void
   	println(double	x);
  
  
  
  1.11      +24 -20    xml-xalan/c/src/PlatformSupport/PrintWriter.hpp
  
  Index: PrintWriter.hpp
  ===================================================================
  RCS file: /home/cvs/xml-xalan/c/src/PlatformSupport/PrintWriter.hpp,v
  retrieving revision 1.10
  retrieving revision 1.11
  diff -u -r1.10 -r1.11
  --- PrintWriter.hpp	2001/02/08 21:39:04	1.10
  +++ PrintWriter.hpp	2001/09/25 21:12:51	1.11
  @@ -102,26 +102,26 @@
   
   	// Output functions inherited from Writer...
   
  -	// If the length is UINT_MAX, then the array is assumed to be null-terminated.
   	virtual void
  -	write(const char*	s,
  -		  unsigned int	theOffset = 0,
  -		  unsigned int	theLength = UINT_MAX) = 0;
  +	write(
  +			const char*		s,
  +			size_t			theOffset = 0,
  +			size_t			theLength = size_t(-1)) = 0;
   
  -	// If the length is UINT_MAX, then the array is assumed to be null-terminated.
   	virtual void
  -	write(const XalanDOMChar*	s,
  -		  unsigned int			theOffset = 0,
  -		  unsigned int			theLength = UINT_MAX) = 0;
  +	write(
  +			const XalanDOMChar*			s,
  +			XalanDOMString::size_type	theOffset = 0,
  +			XalanDOMString::size_type	theLength = XalanDOMString::npos) = 0;
   
   	virtual void
   	write(XalanDOMChar	c) = 0;
   
  -	// If the length is UINT_MAX, then the entire string is printed.
   	virtual void
  -	write(const XalanDOMString&		s,
  -		  unsigned int				theOffset = 0,
  -		  unsigned int				theLength = UINT_MAX) = 0;
  +	write(
  +			const XalanDOMString&		s,
  +			XalanDOMString::size_type	theOffset = 0,
  +			XalanDOMString::size_type	theLength = XalanDOMString::npos) = 0;
   
   	// Output functions which are new...
   
  @@ -134,12 +134,14 @@
   	print(char	c) = 0;
   
   	virtual void
  -	print(const char*	s,
  -		  unsigned int	theLength = UINT_MAX) = 0;
  +	print(
  +			const char*		s,
  +			size_t			theLength = size_t(-1)) = 0;
   
   	virtual void
  -	print(const XalanDOMChar*	s,
  -		  unsigned int			theLength = UINT_MAX) = 0;
  +	print(
  +			const XalanDOMChar*			s,
  +			XalanDOMString::size_type	theLength = XalanDOMString::npos) = 0;
   
   	virtual void
   	print(double	d) = 0;
  @@ -165,12 +167,14 @@
   	println(char	x) = 0;
   
   	virtual void
  -	println(const char*		s,
  -		    unsigned int	theLength = UINT_MAX) = 0;
  +	println(
  +			const char*		s,
  +		    size_t			theLength = size_t(-1)) = 0;
   
   	virtual void
  -	println(const XalanDOMChar*		s,
  -			unsigned int			theLength = UINT_MAX) = 0;
  +	println(
  +			const XalanDOMChar*			s,
  +			XalanDOMString::size_type	theLength = XalanDOMString::npos) = 0;
   
   	virtual void
   	println(double	x) = 0;
  
  
  
  1.8       +3 -3      xml-xalan/c/src/PlatformSupport/ReusableArenaBlock.hpp
  
  Index: ReusableArenaBlock.hpp
  ===================================================================
  RCS file: /home/cvs/xml-xalan/c/src/PlatformSupport/ReusableArenaBlock.hpp,v
  retrieving revision 1.7
  retrieving revision 1.8
  diff -u -r1.7 -r1.8
  --- ReusableArenaBlock.hpp	2000/11/30 19:26:22	1.7
  +++ ReusableArenaBlock.hpp	2001/09/25 21:12:51	1.8
  @@ -292,9 +292,9 @@
   
   		if (m_freeBlockCount > 0)
   		{
  -			const unsigned long	theFreeListSize = m_freeList.getSize();
  +			const size_type		theFreeListSize = m_freeList.getSize();
   
  -			for(unsigned long i = 0; i < theFreeListSize; ++i)
  +			for(size_type i = 0; i < theFreeListSize; ++i)
   			{
   				if (m_freeList.isSet(i) == true)
   				{
  @@ -314,7 +314,7 @@
   	XalanBitmap		m_freeList;
   
   	// The number of blocks on the free list.)
  -	unsigned long	m_freeBlockCount;
  +	size_type		m_freeBlockCount;
   };
   
   
  
  
  
  1.6       +11 -8     xml-xalan/c/src/PlatformSupport/StringTokenizer.cpp
  
  Index: StringTokenizer.cpp
  ===================================================================
  RCS file: /home/cvs/xml-xalan/c/src/PlatformSupport/StringTokenizer.cpp,v
  retrieving revision 1.5
  retrieving revision 1.6
  diff -u -r1.5 -r1.6
  --- StringTokenizer.cpp	2001/06/14 18:27:30	1.5
  +++ StringTokenizer.cpp	2001/09/25 21:12:51	1.6
  @@ -162,7 +162,7 @@
   	XalanDOMString	theToken;
   
   	// Find the index of the next delimiter.
  -	unsigned int	theIndex = FindNextDelimiterIndex(m_CurrentIndex);
  +	XalanDOMString::size_type	theIndex = FindNextDelimiterIndex(m_CurrentIndex);
   
   	if (theIndex == m_CurrentIndex)
   	{
  @@ -208,7 +208,7 @@
   	assert(m_CurrentIndex < m_StringLength);
   
   	// Find the index of the next delimiter.
  -	unsigned int	theIndex = FindNextDelimiterIndex(m_CurrentIndex);
  +	XalanDOMString::size_type	theIndex = FindNextDelimiterIndex(m_CurrentIndex);
   
   	if (theIndex == m_CurrentIndex)
   	{
  @@ -250,17 +250,19 @@
   
   
   
  -unsigned int
  +size_t
   StringTokenizer::countTokens() const
   {
  -	unsigned int	theCount = 0;
  -	unsigned int	theCurrentIndex = m_CurrentIndex;
  +	size_t						theCount = 0;
  +
  +	XalanDOMString::size_type	theCurrentIndex = m_CurrentIndex;
   
   	if (theCurrentIndex < m_StringLength)
   	{
   		while(theCurrentIndex < m_StringLength)
   		{
  -			const unsigned int	theNextIndex = FindNextDelimiterIndex(theCurrentIndex);
  +			const XalanDOMString::size_type		theNextIndex =
  +				FindNextDelimiterIndex(theCurrentIndex);
   
   			if (theNextIndex == theCurrentIndex)
   			{
  @@ -288,8 +290,9 @@
   unsigned int
   StringTokenizer::FindNextDelimiterIndex(unsigned int	theStartIndex) const
   {
  -	bool			fTokenFound = false;
  -	unsigned int	theIndex = theStartIndex;
  +	bool						fTokenFound = false;
  +
  +	XalanDOMString::size_type	theIndex = theStartIndex;
   
   	while(theIndex < m_StringLength &&
   		  fTokenFound == false)
  
  
  
  1.9       +9 -9      xml-xalan/c/src/PlatformSupport/StringTokenizer.hpp
  
  Index: StringTokenizer.hpp
  ===================================================================
  RCS file: /home/cvs/xml-xalan/c/src/PlatformSupport/StringTokenizer.hpp,v
  retrieving revision 1.8
  retrieving revision 1.9
  diff -u -r1.8 -r1.9
  --- StringTokenizer.hpp	2001/06/14 18:27:35	1.8
  +++ StringTokenizer.hpp	2001/09/25 21:12:51	1.9
  @@ -164,27 +164,27 @@
   	 * 
   	 * @return number of remaining tokens
   	 */
  -	virtual unsigned int
  +	virtual size_t
   	countTokens() const;
   
   protected:
   
  -	unsigned int
  -	FindNextDelimiterIndex(unsigned int	theStartIndex) const;
  +	XalanDOMString::size_type
  +	FindNextDelimiterIndex(XalanDOMString::size_type	theStartIndex) const;
   
   private:
   
  -	const XalanDOMString	m_String;
  +	const XalanDOMString				m_String;
   
  -	const XalanDOMString	m_Tokens;
  +	const XalanDOMString				m_Tokens;
   
  -	const bool				m_fReturnTokens;
  +	const bool							m_fReturnTokens;
   
  -	unsigned int			m_CurrentIndex;
  +	XalanDOMString::size_type			m_CurrentIndex;
   
  -	const unsigned int		m_StringLength;
  +	const XalanDOMString::size_type		m_StringLength;
   
  -	const unsigned int		m_tokensLength;
  +	const XalanDOMString::size_type		m_tokensLength;
   };
   
   
  
  
  
  1.14      +8 -8      xml-xalan/c/src/PlatformSupport/URISupport.cpp
  
  Index: URISupport.cpp
  ===================================================================
  RCS file: /home/cvs/xml-xalan/c/src/PlatformSupport/URISupport.cpp,v
  retrieving revision 1.13
  retrieving revision 1.14
  diff -u -r1.13 -r1.14
  --- URISupport.cpp	2001/04/30 18:07:04	1.13
  +++ URISupport.cpp	2001/09/25 21:12:51	1.14
  @@ -140,11 +140,11 @@
   	XalanDOMString	theNormalizedURI(urlString);
   
   	// Let's see what sort of URI we have...
  -	const unsigned int	len = length(theNormalizedURI);
  +	const XalanDOMString::size_type		len = length(theNormalizedURI);
   
   	if (len != 0)
   	{
  -		const unsigned int	index = indexOf(theNormalizedURI, XalanUnicode::charColon);
  +		const XalanDOMString::size_type		index = indexOf(theNormalizedURI, XalanUnicode::charColon);
   
   		bool				protocolPresent = false;
   
  @@ -220,9 +220,9 @@
   
   	NormalizeURIText(context);
   
  -	const unsigned int	theContextLength = length(context);
  +	const XalanDOMString::size_type		theContextLength = length(context);
   
  -	const unsigned int	indexOfSlash = theContextLength == 0 ?
  +	const XalanDOMString::size_type		indexOfSlash = theContextLength == 0 ?
   							0 :
   							lastIndexOf(context, XalanUnicode::charSolidus);
   
  @@ -240,8 +240,8 @@
   	// OK, now let's look at the urlString...
   
   	// Is there a colon, indicating some sort of drive spec, or protocol?
  -	const unsigned int	theURLStringLength = length(urlString);
  -	const unsigned int	theColonIndex = indexOf(urlString, XalanUnicode::charColon);
  +	const XalanDOMString::size_type		theURLStringLength = length(urlString);
  +	const XalanDOMString::size_type		theColonIndex = indexOf(urlString, XalanUnicode::charColon);
   
   	if (theColonIndex == theURLStringLength)
   	{
  @@ -313,8 +313,8 @@
   #endif
   
   	// OK, look for a quick, cheap exit...
  -	const unsigned int	len = length(uriString);
  -	const unsigned int	index = indexOf(uriString, XalanUnicode::charReverseSolidus);
  +	const XalanDOMString::size_type		len = length(uriString);
  +	const XalanDOMString::size_type		index = indexOf(uriString, XalanUnicode::charReverseSolidus);
   
   	if (index != len)
   	{
  
  
  
  1.11      +15 -24    xml-xalan/c/src/PlatformSupport/Writer.hpp
  
  Index: Writer.hpp
  ===================================================================
  RCS file: /home/cvs/xml-xalan/c/src/PlatformSupport/Writer.hpp,v
  retrieving revision 1.10
  retrieving revision 1.11
  diff -u -r1.10 -r1.11
  --- Writer.hpp	2000/09/27 16:24:09	1.10
  +++ Writer.hpp	2001/09/25 21:12:51	1.11
  @@ -64,11 +64,6 @@
   
   
   
  -#include <climits>
  -
  -
  -
  -// $$$ ToDo: Necessary will XalanDOMString is still a typedef.
   #include <XalanDOM/XalanDOMString.hpp>
   
   
  @@ -98,7 +93,6 @@
   	virtual void
   	flush() = 0;
   
  -
   	/**
   	 * Get the stream associated with the writer...
   	 */
  @@ -119,28 +113,26 @@
   	 * 
   	 * @param 	s         string to write
   	 * @param 	theOffset starting offset in string to begin writing, default 0
  -	 * @param 	theLength number of characters to write. If the length is
  -	 *                    UINT_MAX, then the array is assumed to be
  -	 *                    null-terminated.  Default is UINT_MAX.
  +	 * @param 	theLength number of characters to write. If the length is -1, then the array is assumed to be null-terminated.
   	 */
   	virtual void
  -	write(const char*	s,
  -		  unsigned int	theOffset = 0,
  -		  unsigned int	theLength = UINT_MAX) = 0;
  +	write(
  +			const char*		s,
  +			size_t			theOffset = 0,
  +			size_t			theLength = size_t(-1)) = 0;
   
   	/**
   	 * Writes a string
   	 * 
   	 * @param 	s         string to write
   	 * @param 	theOffset starting offset in string to begin writing, default 0
  -	 * @param 	theLength number of characters to write. If the length is
  -	 *                    UINT_MAX, then the array is assumed to be
  -	 *                    null-terminated.  Default is UINT_MAX.
  +	 * @param 	theLength number of characters to write. If the length is XalanDOMString::npos, then the array is assumed to be null-terminated.
   	 */
   	virtual void
  -	write(const XalanDOMChar*	s,
  -		  unsigned int			theOffset = 0,
  -		  unsigned int			theLength = UINT_MAX) = 0;
  +	write(
  +			const XalanDOMChar*			s,
  +			XalanDOMString::size_type	theOffset = 0,
  +			XalanDOMString::size_type	theLength = XalanDOMString::npos) = 0;
   
   	/**
   	 * Writes a character
  @@ -155,14 +147,13 @@
   	 * 
   	 * @param 	s         string to write
   	 * @param 	theOffset starting offset in string to begin writing, default 0
  -	 * @param 	theLength number of characters to write. If the length is
  -	 *                    UINT_MAX,  then the entire string is printed. Default
  -	 *                    is UINT_MAX.
  +	 * @param 	theLength number of characters to write. If the length is XalanDOMString::npos,  then the entire string is printed.
   	 */
   	virtual void
  -	write(const XalanDOMString&		s,
  -		  unsigned int				theOffset = 0,
  -		  unsigned int				theLength = UINT_MAX) = 0;
  +	write(
  +			const XalanDOMString&		s,
  +			XalanDOMString::size_type	theOffset = 0,
  +			XalanDOMString::size_type	theLength = XalanDOMString::npos) = 0;
   
   private:
   
  
  
  
  1.5       +6 -6      xml-xalan/c/src/PlatformSupport/XalanBitmap.cpp
  
  Index: XalanBitmap.cpp
  ===================================================================
  RCS file: /home/cvs/xml-xalan/c/src/PlatformSupport/XalanBitmap.cpp,v
  retrieving revision 1.4
  retrieving revision 1.5
  diff -u -r1.4 -r1.5
  --- XalanBitmap.cpp	2000/11/02 01:45:37	1.4
  +++ XalanBitmap.cpp	2001/09/25 21:12:51	1.5
  @@ -69,9 +69,9 @@
   
   
   
  -XalanBitmap::XalanBitmap(unsigned long	theSize) :
  +XalanBitmap::XalanBitmap(size_type	theSize) :
   	m_size(theSize),
  -	m_bitmap(unsigned((theSize + eBitsPerUnit) / eBitsPerUnit), BitmapVectorType::value_type(0))
  +	m_bitmap(size_type((theSize + eBitsPerUnit) / eBitsPerUnit), BitmapVectorType::value_type(0))
   {
   }
   
  @@ -84,7 +84,7 @@
   
   
   bool
  -XalanBitmap::isSet(unsigned long	theBit) const
  +XalanBitmap::isSet(size_type	theBit) const
   {
   	if (theBit >= m_size)
   	{
  @@ -99,7 +99,7 @@
   
   
   void
  -XalanBitmap::set(unsigned long	theBit)
  +XalanBitmap::set(size_type	theBit)
   {
   	if (theBit < m_size)
   	{
  @@ -110,7 +110,7 @@
   
   
   void
  -XalanBitmap::clear(unsigned long	theBit)
  +XalanBitmap::clear(size_type	theBit)
   {
   	if (theBit < m_size)
   	{
  @@ -121,7 +121,7 @@
   
   
   void
  -XalanBitmap::toggle(unsigned long	theBit)
  +XalanBitmap::toggle(size_type	theBit)
   {
   	if (theBit < m_size)
   	{
  
  
  
  1.3       +12 -9     xml-xalan/c/src/PlatformSupport/XalanBitmap.hpp
  
  Index: XalanBitmap.hpp
  ===================================================================
  RCS file: /home/cvs/xml-xalan/c/src/PlatformSupport/XalanBitmap.hpp,v
  retrieving revision 1.2
  retrieving revision 1.3
  diff -u -r1.2 -r1.3
  --- XalanBitmap.hpp	2000/07/10 22:45:46	1.2
  +++ XalanBitmap.hpp	2001/09/25 21:12:51	1.3
  @@ -73,8 +73,11 @@
   public:
   
   	// The basic storage unit for the bitmaps.
  -	typedef char	UnitType;
  +	typedef char		UnitType;
   
  +	// A handy typedef...
  +	typedef size_t		size_type;
  +
   	// Really all we're assuming is that a char is at least
   	// 8 bits.  If it's more, then we'll just waste some
   	// space.  This may need to be adjusted for various
  @@ -89,7 +92,7 @@
   	 *
   	 * @param  theSize   The number of bits in the map.
   	 */
  -	XalanBitmap(unsigned long	theSize);
  +	XalanBitmap(size_type	theSize);
   
   	~XalanBitmap();
   
  @@ -101,7 +104,7 @@
   	 * @return true if the bit is set, false if not.
   	 */
   	bool
  -	isSet(unsigned long	theBit) const;
  +	isSet(size_type		theBit) const;
   
   	/**
   	 * Set a bit.
  @@ -109,7 +112,7 @@
   	 * @param theBit The number of the bit to set.
   	 */
   	void
  -	set(unsigned long	theBit);
  +	set(size_type	theBit);
   
   	/**
   	 * Clear a bit.
  @@ -117,7 +120,7 @@
   	 * @param theBit The number of the bit to clear.
   	 */
   	void
  -	clear(unsigned long	theBit);
  +	clear(size_type		theBit);
   
   	/**
   	 * Toggle a bit.
  @@ -125,7 +128,7 @@
   	 * @param theBit The number of the bit to toggle.
   	 */
   	void
  -	toggle(unsigned long	theBit);
  +	toggle(size_type	theBit);
   
   	/**
   	 * Clear all of the bits.
  @@ -138,7 +141,7 @@
   	 *
   	 * @return The number of bits in the map.
   	 */
  -	unsigned long
  +	size_type
   	getSize() const
   	{
   		return m_size;
  @@ -152,9 +155,9 @@
   	typedef std::vector<UnitType>	BitmapVectorType;
   #endif
   
  -	const unsigned long		m_size;
  +	const size_type		m_size;
   
  -	BitmapVectorType		m_bitmap;
  +	BitmapVectorType	m_bitmap;
   };
   
   
  
  
  
  1.3       +28 -26    xml-xalan/c/src/PlatformSupport/XalanDOMStringHashTable.cpp
  
  Index: XalanDOMStringHashTable.cpp
  ===================================================================
  RCS file: /home/cvs/xml-xalan/c/src/PlatformSupport/XalanDOMStringHashTable.cpp,v
  retrieving revision 1.2
  retrieving revision 1.3
  diff -u -r1.2 -r1.3
  --- XalanDOMStringHashTable.cpp	2001/05/10 19:15:37	1.2
  +++ XalanDOMStringHashTable.cpp	2001/09/25 21:12:51	1.3
  @@ -69,8 +69,8 @@
   
   
   XalanDOMStringHashTable::XalanDOMStringHashTable(
  -			unsigned int	theBucketCount,
  -			unsigned int	theBucketSize) :
  +			size_t		theBucketCount,
  +			size_t		theBucketSize) :
   
   	m_bucketCount(theBucketCount),
   	m_bucketSize(theBucketSize),
  @@ -85,7 +85,7 @@
   void
   XalanDOMStringHashTable::clear()
   {
  -	for(unsigned int i = 0; i < m_bucketCount; ++i)
  +	for(size_t i = 0; i < m_bucketCount; ++i)
   	{
   		m_buckets[i].clear();
   	}
  @@ -101,9 +101,11 @@
   void
   XalanDOMStringHashTable::getBucketCounts(BucketCountsType&	theVector) const
   {
  -	for(unsigned int i = 0; i < m_bucketCount; ++i)
  +	for(size_t i = 0; i < m_bucketCount; ++i)
   	{
  -		theVector.push_back(m_buckets[i].size());
  +		const bucket_size_type	size = m_buckets[i].size();
  +
  +		theVector.push_back(size);
   	}
   }
   
  @@ -113,8 +115,8 @@
   equalsXalanDOMString
   {
   	equalsXalanDOMString(
  -			const XalanDOMChar*		theString,
  -			unsigned int			theLength) :
  +			const XalanDOMChar*			theString,
  +			XalanDOMString::size_type	theLength) :
   		m_string(theString),
   		m_length(theLength)
   	{
  @@ -135,9 +137,9 @@
   
   private:
   
  -	const XalanDOMChar* const	m_string;
  +	const XalanDOMChar* const			m_string;
   
  -	const unsigned int			m_length;
  +	const XalanDOMString::size_type		m_length;
   };
   
   
  @@ -145,27 +147,27 @@
   const XalanDOMString*
   XalanDOMStringHashTable::find(
   			const XalanDOMString&	theString,
  -			unsigned int*			theBucketIndex) const
  +			size_t*					theBucketIndex) const
   {
   	return find(c_wstr(theString), length(theString), theBucketIndex);
   }
   
   
   
  -inline unsigned int
  +inline size_t
   hashString(
  -			const XalanDOMChar*		theString,
  -			unsigned int			theLength)
  +			const XalanDOMChar*			theString,
  +			XalanDOMString::size_type	theLength)
   {
   	assert(theString != 0);
   
  -    unsigned int				theResult = 0;
  +    size_t				theResult = 0;
   
   	const XalanDOMChar* const	theEnd = theString + theLength;
   
   	while (theString != theEnd)
       {
  -        theResult += (theResult * 37) + (theResult >> 24) + unsigned(*theString);
  +        theResult += (theResult * 37) + (theResult >> 24) + size_t(*theString);
   
           ++theString;
       }
  @@ -177,18 +179,18 @@
   
   const XalanDOMString*
   XalanDOMStringHashTable::find(
  -			const XalanDOMChar*		theString,
  -			unsigned int			theLength,
  -			unsigned int*			theBucketIndex) const
  +			const XalanDOMChar*			theString,
  +			XalanDOMString::size_type	theLength,
  +			size_t*						theBucketIndex) const
   {
   	assert(theString != 0);
   
  -	const unsigned int	theActualLength =
  -		theLength == unsigned(-1) ? length(theString) : theLength;
  +	const XalanDOMString::size_type		theActualLength =
  +		theLength == XalanDOMString::npos ? length(theString) : theLength;
   
  -	const unsigned int	theHash = hashString(theString, theActualLength);
  +	const size_t	theHash = hashString(theString, theActualLength);
   
  -	const unsigned int	theLocalBucketIndex = theHash % m_bucketCount;
  +	const size_t	theLocalBucketIndex = theHash % m_bucketCount;
   
   	assert(theLocalBucketIndex < m_bucketCount);
   
  @@ -224,9 +226,9 @@
   void
   XalanDOMStringHashTable::insert(const XalanDOMString&	theString)
   {
  -	const unsigned int	theHash = hashString(c_wstr(theString), length(theString));
  +	const size_t	theHash = hashString(c_wstr(theString), length(theString));
   
  -	const unsigned int	theBucketIndex = theHash % m_bucketCount;
  +	const size_t	theBucketIndex = theHash % m_bucketCount;
   
   	assert(theBucketIndex < m_bucketCount);
   
  @@ -251,12 +253,12 @@
   void
   XalanDOMStringHashTable::insert(
   			const XalanDOMString&	theString,
  -			unsigned int			theBucketIndex)
  +			size_t					theBucketIndex)
   {
   	assert(theBucketIndex == hashString(c_wstr(theString), length(theString)) % m_bucketCount);
   	assert(theBucketIndex < m_bucketCount);
   
  -	BucketType&	theBucket = m_buckets[theBucketIndex];
  +	BucketType&		theBucket = m_buckets[theBucketIndex];
   
   #if !defined(NDEBUG)
   	if (theBucket.size() > 0)
  
  
  
  1.2       +18 -15    xml-xalan/c/src/PlatformSupport/XalanDOMStringHashTable.hpp
  
  Index: XalanDOMStringHashTable.hpp
  ===================================================================
  RCS file: /home/cvs/xml-xalan/c/src/PlatformSupport/XalanDOMStringHashTable.hpp,v
  retrieving revision 1.1
  retrieving revision 1.2
  diff -u -r1.1 -r1.2
  --- XalanDOMStringHashTable.hpp	2001/05/10 17:47:06	1.1
  +++ XalanDOMStringHashTable.hpp	2001/09/25 21:12:51	1.2
  @@ -82,12 +82,15 @@
   
   #if defined(XALAN_NO_NAMESPACES)
   	typedef vector<const XalanDOMString*>	BucketType;
  -	typedef vector<unsigned int>			BucketCountsType;
  +	typedef BucketType::size_type			bucket_size_type;
  +	typedef vector<bucket_size_type>		BucketCountsType;
   #else
   	typedef std::vector<const XalanDOMString*>	BucketType;
  -	typedef std::vector<unsigned int>			BucketCountsType;
  +	typedef BucketType::size_type				bucket_size_type;
  +	typedef std::vector<bucket_size_type>		BucketCountsType;
   #endif
   
  +
   	enum { eDefaultBucketCount = 101, eDefaultBucketSize = 15 };
   
   
  @@ -99,8 +102,8 @@
   	 */
   	explicit
   	XalanDOMStringHashTable(
  -			unsigned int	theBucketCount = eDefaultBucketCount,
  -			unsigned int	theBucketSize = eDefaultBucketSize);
  +			size_t				theBucketCount = eDefaultBucketCount,
  +			bucket_size_type	theBucketSize = eDefaultBucketSize);
   
   	~XalanDOMStringHashTable() { }
   
  @@ -115,7 +118,7 @@
   	 *
   	 * @return The number of strings in the table
   	 */
  -	unsigned int
  +	size_t
   	size() const
   	{
   		return m_count;
  @@ -126,7 +129,7 @@
   	 *
   	 * @return The number of buckets in the table
   	 */
  -	unsigned int
  +	size_t
   	bucketCount() const
   	{
   		return m_bucketCount;
  @@ -146,7 +149,7 @@
   	 *
   	 * @return The number of collisions.  Valid only for non-release builds.
   	 */
  -	unsigned int
  +	size_t
   	collisions() const
   	{
   		return m_collisions;
  @@ -162,7 +165,7 @@
   	const XalanDOMString*
   	find(
   			const XalanDOMString&	theString,
  -			unsigned int*			theBucketIndex = 0) const;
  +			size_t*					theBucketIndex = 0) const;
   
   	/**
   	 * Find a string.  If the string is not found, return null.
  @@ -178,9 +181,9 @@
   	 */
   	const XalanDOMString*
   	find(
  -			const XalanDOMChar*		theString,
  -			unsigned int			theLength = unsigned(-1),
  -			unsigned int*			theBucketIndex = 0) const;
  +			const XalanDOMChar*			theString,
  +			XalanDOMString::size_type	theLength = XalanDOMString::npos,
  +			size_t*						theBucketIndex = 0) const;
   
   	/**
   	 * Insert a pointer to a string into the table.  If the string
  @@ -215,7 +218,7 @@
   	void
   	insert(
   			const XalanDOMString&	theString,
  -			unsigned int			theBucketIndex);
  +			size_t					theBucketIndex);
   
   private:
   
  @@ -230,13 +233,13 @@
   
   
   	// Data members...
  -	const unsigned int				m_bucketCount;
  +	const size_t					m_bucketCount;
   
  -	const unsigned int				m_bucketSize;
  +	const bucket_size_type			m_bucketSize;
   
   	XalanArrayAutoPtr<BucketType>	m_buckets;
   
  -	unsigned int					m_count;
  +	size_t							m_count;
   
   	unsigned int					m_collisions;		
   };
  
  
  
  1.11      +7 -7      xml-xalan/c/src/PlatformSupport/XalanDOMStringPool.cpp
  
  Index: XalanDOMStringPool.cpp
  ===================================================================
  RCS file: /home/cvs/xml-xalan/c/src/PlatformSupport/XalanDOMStringPool.cpp,v
  retrieving revision 1.10
  retrieving revision 1.11
  diff -u -r1.10 -r1.11
  --- XalanDOMStringPool.cpp	2001/05/10 17:47:48	1.10
  +++ XalanDOMStringPool.cpp	2001/09/25 21:12:51	1.11
  @@ -65,9 +65,9 @@
   
   
   XalanDOMStringPool::XalanDOMStringPool(
  -			unsigned int	theBlockSize,
  -			unsigned int	theBucketCount,
  -			unsigned int	theBucketSize) :
  +			block_size_type		theBlockSize,
  +			bucket_count_type	theBucketCount,
  +			bucket_size_type	theBucketSize) :
   	m_stringAllocator(theBlockSize),
   	m_stringCount(0),
   	m_hashTable(theBucketCount, theBucketSize)
  @@ -114,8 +114,8 @@
   
   const XalanDOMString&
   XalanDOMStringPool::get(
  -			const XalanDOMChar*		theString,
  -			unsigned int			theLength)
  +			const XalanDOMChar*			theString,
  +			XalanDOMString::size_type	theLength)
   {
   	assert(m_stringCount == m_hashTable.size());
   
  @@ -125,9 +125,9 @@
   	}
   	else
   	{
  -		const unsigned int	theActualLength = theLength == unsigned(-1) ? length(theString) : theLength;
  +		const XalanDOMString::size_type		theActualLength = theLength == XalanDOMString::npos ? length(theString) : theLength;
   
  -		unsigned int	theBucketIndex;
  +		size_t	theBucketIndex;
   
   		const XalanDOMString*	theTableString = m_hashTable.find(theString, theActualLength, &theBucketIndex);
   
  
  
  
  1.9       +21 -17    xml-xalan/c/src/PlatformSupport/XalanDOMStringPool.hpp
  
  Index: XalanDOMStringPool.hpp
  ===================================================================
  RCS file: /home/cvs/xml-xalan/c/src/PlatformSupport/XalanDOMStringPool.hpp,v
  retrieving revision 1.8
  retrieving revision 1.9
  diff -u -r1.8 -r1.9
  --- XalanDOMStringPool.hpp	2001/05/10 17:47:49	1.8
  +++ XalanDOMStringPool.hpp	2001/09/25 21:12:51	1.9
  @@ -83,6 +83,19 @@
   		   eDefaultBucketCount = XalanDOMStringHashTable::eDefaultBucketCount,
   		   eDefaultBucketSize = XalanDOMStringHashTable::eDefaultBucketSize };
   
  +#if defined(XALAN_NO_DEFAULT_TEMPLATE_ARGUMENTS)
  +	typedef ArenaBlock<XalanDOMString>		ArenaBlockType;
  +
  +	typedef ArenaAllocator<XalanDOMString,
  +						   ArenaBlockType>	ArenaAllocatorType;
  +#else
  +	typedef ArenaAllocator<XalanDOMString>	ArenaAllocatorType;
  +#endif
  +
  +	typedef ArenaAllocatorType::size_type				block_size_type;
  +	typedef size_t										bucket_count_type;
  +	typedef XalanDOMStringHashTable::bucket_size_type	bucket_size_type;
  +
   	/**
   	 * Create a string pool.
   	 *
  @@ -92,9 +105,9 @@
   	 */
   	explicit
   	XalanDOMStringPool(
  -			unsigned int	theBlockSize = eDefaultBlockSize,
  -			unsigned int	theBucketCount = eDefaultBucketCount,
  -			unsigned int	theBucketSize = eDefaultBucketSize);
  +			block_size_type		theBlockSize = eDefaultBlockSize,
  +			bucket_count_type	theBucketCount = eDefaultBucketCount,
  +			bucket_size_type	theBucketSize = eDefaultBucketSize);
   
   	virtual
   	~XalanDOMStringPool();
  @@ -111,7 +124,7 @@
   	 *
   	 * @return the size of the pool.
   	 */
  -	virtual unsigned int
  +	virtual size_t
   	size() const;
   
   	/**
  @@ -127,13 +140,13 @@
   	 * Get a pooled string.  If the string is not pooled, it is added.
   	 *
   	 * @param theString The string to pool.
  -	 * @param theLength The length of the string.  If -1, the string is assumed to be null-terminated.
  +	 * @param theLength The length of the string.  If XalanDOMString::npos, the string is assumed to be null-terminated.
   	 * @return a const reference to the pooled string.
   	 */
   	virtual const XalanDOMString&
   	get(
  -			const XalanDOMChar*		theString,
  -			unsigned int			theLength = unsigned(-1));
  +			const XalanDOMChar*			theString,
  +			XalanDOMString::size_type	theLength = XalanDOMString::npos);
   
   	/**
   	 * Get a reference to the pool's hash table.  Useful for diagnostic
  @@ -158,19 +171,10 @@
   	bool
   	operator==(const XalanDOMStringPool&) const;
   
  -#if defined(XALAN_NO_DEFAULT_TEMPLATE_ARGUMENTS)
  -	typedef ArenaBlock<XalanDOMString>		ArenaBlockType;
  -
  -	typedef ArenaAllocator<XalanDOMString,
  -						   ArenaBlockType>	ArenaAllocatorType;
  -#else
  -	typedef ArenaAllocator<XalanDOMString>	ArenaAllocatorType;
  -#endif
  -
   	// Data members...
   	ArenaAllocatorType				m_stringAllocator;
   
  -	unsigned int					m_stringCount;
  +	size_t							m_stringCount;
   
   	XalanDOMStringHashTable			m_hashTable;
   
  
  
  
  1.3       +1 -1      xml-xalan/c/src/PlatformSupport/XalanDecimalFormat.cpp
  
  Index: XalanDecimalFormat.cpp
  ===================================================================
  RCS file: /home/cvs/xml-xalan/c/src/PlatformSupport/XalanDecimalFormat.cpp,v
  retrieving revision 1.2
  retrieving revision 1.3
  diff -u -r1.2 -r1.3
  --- XalanDecimalFormat.cpp	2001/06/14 19:04:02	1.2
  +++ XalanDecimalFormat.cpp	2001/09/25 21:12:51	1.3
  @@ -208,7 +208,7 @@
   		m_decimalFormatSymbols->getPatternSeparator();
   
   	// Is the a separator?
  -	const unsigned int	theSeparatorIndex =
  +	const XalanDOMString::size_type		theSeparatorIndex =
   		indexOf(thePattern, thePatternSeparatorChar);
   
   	if (theSeparatorIndex < length(thePattern))
  
  
  
  1.10      +4 -4      xml-xalan/c/src/PlatformSupport/XalanNumberFormat.cpp
  
  Index: XalanNumberFormat.cpp
  ===================================================================
  RCS file: /home/cvs/xml-xalan/c/src/PlatformSupport/XalanNumberFormat.cpp,v
  retrieving revision 1.9
  retrieving revision 1.10
  diff -u -r1.9 -r1.10
  --- XalanNumberFormat.cpp	2001/06/14 19:04:04	1.9
  +++ XalanNumberFormat.cpp	2001/09/25 21:12:51	1.10
  @@ -237,7 +237,7 @@
   	}
   	else
   	{
  -		const unsigned int len = length(value);
  +		const XalanDOMString::size_type		len = length(value);
   
   		if (len == 0)
   		{
  @@ -245,7 +245,7 @@
   		}
   		else
   		{
  -			const unsigned int	bufsize = len + len/m_groupingSize + 1;
  +			const XalanDOMString::size_type		bufsize = len + len/m_groupingSize + 1;
   
   			XalanDOMChar* const		buffer = new XalanDOMChar[bufsize];
   
  @@ -255,14 +255,14 @@
   
   			*p-- = 0;	// null terminate
   
  -			for (unsigned int i = 0, ix = len - 1; i < len; i++, ix--)
  +			for (XalanDOMString::size_type i = 0, ix = len - 1; i < len; i++, ix--)
   			{
   				const XalanDOMChar		c = charAt(value, ix);
   
   				if (i && !(i% m_groupingSize))
   				{
   					// Could be a multiple character separator??
  -					for (int j= m_groupingSeparator.length()-1; j>=0; j--)
  +					for (long j = long(m_groupingSeparator.length() - 1); j>=0; j--)
   						*p-- = charAt(m_groupingSeparator, j);
   				}
   
  
  
  
  1.13      +7 -7      xml-xalan/c/src/PlatformSupport/XalanOutputStream.cpp
  
  Index: XalanOutputStream.cpp
  ===================================================================
  RCS file: /home/cvs/xml-xalan/c/src/PlatformSupport/XalanOutputStream.cpp,v
  retrieving revision 1.12
  retrieving revision 1.13
  diff -u -r1.12 -r1.13
  --- XalanOutputStream.cpp	2001/08/09 20:30:26	1.12
  +++ XalanOutputStream.cpp	2001/09/25 21:12:51	1.13
  @@ -101,7 +101,7 @@
   void
   XalanOutputStream::write(
   			const XalanDOMChar*		theBuffer,
  -			unsigned long			theBufferLength)
  +			size_t					theBufferLength)
   {
   	assert(theBuffer != 0);
   
  @@ -127,7 +127,7 @@
   void
   XalanOutputStream::transcode(
   			const XalanDOMChar*		theBuffer,
  -			unsigned long			theBufferLength,
  +			size_t					theBufferLength,
   			TranscodeVectorType&	theDestination)
   {
   	if (m_transcoder == 0)
  @@ -160,7 +160,7 @@
   		// and amount remaining in the buffer, since we may not be
   		// able to transcode it all at once.
   		const XalanDOMChar*		theBufferPosition = theBuffer;
  -		unsigned int			theRemainingBufferLength = theBufferLength;
  +		size_t					theRemainingBufferLength = theBufferLength;
   
   		// Keep track of the destination size, and the target size, which is
   		// the size of the destination that has not yet been filled with
  @@ -168,8 +168,8 @@
   		// transcoding to a 16-bit encoding.
   		// $$$ ToDo: We need to know the size of an encoding, so we can
   		// do the right thing with the destination size.
  -		unsigned int			theDestinationSize = theBufferLength * 2;
  -		unsigned int			theTargetSize = theDestinationSize;
  +		size_t	theDestinationSize = theBufferLength * 2;
  +		size_t	theTargetSize = theDestinationSize;
   
   		do
   		{
  @@ -285,7 +285,7 @@
   		XalanTranscodingServices::getStreamProlog(theEncoding);
   	assert(theProlog != 0);
   
  -	const unsigned int	theLength = XalanTranscodingServices::length(theProlog);
  +	const size_t	theLength = XalanTranscodingServices::length(theProlog);
   
   	if (theLength > 0)
   	{
  @@ -315,7 +315,7 @@
   void
   XalanOutputStream::doWrite(
   			const XalanDOMChar*		theBuffer,
  -			unsigned long			theBufferLength)
  +			size_t					theBufferLength)
   {
   	assert(theBuffer != 0);
   
  
  
  
  1.7       +6 -6      xml-xalan/c/src/PlatformSupport/XalanOutputStream.hpp
  
  Index: XalanOutputStream.hpp
  ===================================================================
  RCS file: /home/cvs/xml-xalan/c/src/PlatformSupport/XalanOutputStream.hpp,v
  retrieving revision 1.6
  retrieving revision 1.7
  diff -u -r1.6 -r1.7
  --- XalanOutputStream.hpp	2001/08/09 20:30:26	1.6
  +++ XalanOutputStream.hpp	2001/09/25 21:12:51	1.7
  @@ -191,7 +191,7 @@
       void
   	write(
   			const char*		theBuffer,
  -			unsigned long	theBufferLength)
  +			size_t			theBufferLength)
   	{
   		assert(theBuffer != 0);
   
  @@ -211,7 +211,7 @@
       void
   	write(
   			const XalanDOMChar*		theBuffer,
  -			unsigned long			theBufferLength);
  +			size_t					theBufferLength);
   
   	/**
   	 * Get the output encoding for the stream.
  @@ -357,12 +357,12 @@
   	void
   	transcode(
   			const XalanDOMChar*		theBuffer,
  -			unsigned long			theBufferLength,
  +			size_t					theBufferLength,
   			TranscodeVectorType&	theDestination);
   
   	virtual void
  -	writeData(const char*		theBuffer,
  -			  unsigned long		theBufferLength) = 0;
  +	writeData(const char*	theBuffer,
  +			  size_t		theBufferLength) = 0;
   
   	virtual void
   	doFlush() = 0;
  @@ -385,7 +385,7 @@
   	void
   	doWrite(
   			const XalanDOMChar*		theBuffer,
  -			unsigned long			theBufferLength);
  +			size_t					theBufferLength);
   
   
   	const TranscodeVectorType::size_type	m_transcoderBlockSize;
  
  
  
  1.6       +14 -14    xml-xalan/c/src/PlatformSupport/XalanOutputStreamPrintWriter.cpp
  
  Index: XalanOutputStreamPrintWriter.cpp
  ===================================================================
  RCS file: /home/cvs/xml-xalan/c/src/PlatformSupport/XalanOutputStreamPrintWriter.cpp,v
  retrieving revision 1.5
  retrieving revision 1.6
  diff -u -r1.5 -r1.6
  --- XalanOutputStreamPrintWriter.cpp	2001/08/09 20:30:05	1.5
  +++ XalanOutputStreamPrintWriter.cpp	2001/09/25 21:12:51	1.6
  @@ -131,8 +131,8 @@
   void
   XalanOutputStreamPrintWriter::write(
   			const char*		s,
  -			unsigned int	theOffset,
  -			unsigned int	theLength)
  +			size_t			theOffset,
  +			size_t			theLength)
   {
   	assert(s != 0);
   
  @@ -157,9 +157,9 @@
   
   void
   XalanOutputStreamPrintWriter::write(
  -			const XalanDOMChar*		s,
  -			unsigned int			theOffset,
  -			unsigned int			theLength)
  +			const XalanDOMChar*			s,
  +			XalanDOMString::size_type	theOffset,
  +			XalanDOMString::size_type	theLength)
   {
   	assert(s != 0);
   
  @@ -192,9 +192,9 @@
   
   void
   XalanOutputStreamPrintWriter::write(
  -			const XalanDOMString&	s,
  -			unsigned int			theOffset,
  -			unsigned int			theLength)
  +			const XalanDOMString&		s,
  +			XalanDOMString::size_type	theOffset,
  +			XalanDOMString::size_type	theLength)
   {
   	write(c_wstr(s), theOffset, theLength);
   }
  @@ -229,7 +229,7 @@
   void
   XalanOutputStreamPrintWriter::print(
   			const char*		s,
  -			unsigned int	theLength)
  +			size_t			theLength)
   {
   	write(s,
   		  0,
  @@ -240,8 +240,8 @@
   
   void
   XalanOutputStreamPrintWriter::print(
  -			const XalanDOMChar*		s,
  -			unsigned int			theLength)
  +			const XalanDOMChar*			s,
  +			XalanDOMString::size_type	theLength)
   {
   	assert(s != 0);
   	assert(theLength >= 0 || theLength == UINT_MAX);
  @@ -320,7 +320,7 @@
   void
   XalanOutputStreamPrintWriter::println(
   			const char*		s,
  -			unsigned int	theLength)
  +			size_t			theLength)
   {
   	print(s, theLength);
   
  @@ -331,8 +331,8 @@
   
   void
   XalanOutputStreamPrintWriter::println(
  -			const XalanDOMChar*		s,
  -			unsigned int			theLength)
  +			const XalanDOMChar*			s,
  +			XalanDOMString::size_type	theLength)
   {
   	print(s, theLength);
   
  
  
  
  1.2       +29 -25    xml-xalan/c/src/PlatformSupport/XalanOutputStreamPrintWriter.hpp
  
  Index: XalanOutputStreamPrintWriter.hpp
  ===================================================================
  RCS file: /home/cvs/xml-xalan/c/src/PlatformSupport/XalanOutputStreamPrintWriter.hpp,v
  retrieving revision 1.1
  retrieving revision 1.2
  diff -u -r1.1 -r1.2
  --- XalanOutputStreamPrintWriter.hpp	2000/09/27 16:24:12	1.1
  +++ XalanOutputStreamPrintWriter.hpp	2001/09/25 21:12:51	1.2
  @@ -89,7 +89,6 @@
   	virtual
   	~XalanOutputStreamPrintWriter();
   
  -	// These methods are inherited from PrintWriter ...
   
   	virtual bool
       checkError() const;
  @@ -107,25 +106,26 @@
   	getStream() const;
   
   
  -	// Output functions...
  -
   	virtual void
  -	write(const char*	s,
  -		  unsigned int	theOffset = 0,
  -		  unsigned int	theLength = UINT_MAX);
  +	write(
  +			const char*		s,
  +			size_t			theOffset = 0,
  +			size_t			theLength = size_t(-1));
   
   	virtual void
  -	write(const XalanDOMChar*	s,
  -		  unsigned int			theOffset = 0,
  -		  unsigned int			theLength = UINT_MAX);
  +	write(
  +			const XalanDOMChar*			s,
  +			XalanDOMString::size_type	theOffset = 0,
  +			XalanDOMString::size_type	theLength = XalanDOMString::npos);
   
   	virtual void
   	write(XalanDOMChar		c);
   
   	virtual void
  -	write(const XalanDOMString&		s,
  -		  unsigned int				theOffset = 0,
  -		  unsigned int				theLength = UINT_MAX);
  +	write(
  +			const XalanDOMString&		s,
  +			XalanDOMString::size_type	theOffset = 0,
  +			XalanDOMString::size_type	theLength = XalanDOMString::npos);
   
   #if !defined(XALAN_BOOL_AS_INT)
   	virtual void
  @@ -136,12 +136,14 @@
   	print(char	c);
   
   	virtual void
  -	print(const char*	s,
  -		  unsigned int	theLength = UINT_MAX);
  +	print(
  +			const char*		s,
  +			size_t			theLength = size_t(-1));
   
   	virtual void
  -	print(const XalanDOMChar*	s,
  -		  unsigned int			theLength = UINT_MAX);
  +	print(
  +			const XalanDOMChar*			s,
  +			XalanDOMString::size_type	theLength = XalanDOMString::npos);
   
   	virtual void
   	print(double	d);
  @@ -160,28 +162,30 @@
   
   #if !defined(XALAN_BOOL_AS_INT)
   	virtual void
  -	println(bool	b);
  +	println(bool	x);
   #endif
   
   	virtual void
  -	println(char	c);
  +	println(char	x);
   
   	virtual void
  -	println(const char*		s,
  -		    unsigned int	theLength = UINT_MAX);
  +	println(
  +			const char*		s,
  +		    size_t			theLength = size_t(-1));
   
   	virtual void
  -	println(const XalanDOMChar*		s,
  -			unsigned int			theLength = UINT_MAX);
  +	println(
  +			const XalanDOMChar*			s,
  +			XalanDOMString::size_type	theLength = XalanDOMString::npos);
   
   	virtual void
  -	println(double	d);
  +	println(double	x);
   
   	virtual void
  -	println(int		i);
  +	println(int		x);
   
   	virtual void
  -	println(long	l);
  +	println(long	x);
   
   	virtual void
   	println(const XalanDOMString&	s);
  
  
  
  1.4       +27 -14    xml-xalan/c/src/PlatformSupport/XalanToXercesTranscoderWrapper.cpp
  
  Index: XalanToXercesTranscoderWrapper.cpp
  ===================================================================
  RCS file: /home/cvs/xml-xalan/c/src/PlatformSupport/XalanToXercesTranscoderWrapper.cpp,v
  retrieving revision 1.3
  retrieving revision 1.4
  diff -u -r1.3 -r1.4
  --- XalanToXercesTranscoderWrapper.cpp	2001/09/14 20:03:06	1.3
  +++ XalanToXercesTranscoderWrapper.cpp	2001/09/25 21:12:51	1.4
  @@ -85,27 +85,34 @@
   XalanToXercesTranscoderWrapper::eCode
   XalanToXercesTranscoderWrapper::transcode(
   			const XalanDOMChar*		theSourceData,
  -			unsigned int			theSourceCount,
  +			size_t					theSourceCount,
   			XalanXMLByte*			theTarget,
  -			unsigned int			theTargetSize,
  -			unsigned int&			theSourceCharsTranscoded,
  -			unsigned int&			theTargetBytesUsed)
  +			size_t					theTargetSize,
  +			size_t&					theSourceCharsTranscoded,
  +			size_t&					theTargetBytesUsed)
   {
   	eCode	theCode = XalanTranscodingServices::OK;
   
   	try
   	{
  +		XercesSizeType	theXercesSourceCharsTranscoded = 0;
  +
  +		assert(XercesSizeType(theSourceCount) == theSourceCount);
  +		assert(XercesSizeType(theTargetSize) == theTargetSize);
  +
   		theTargetBytesUsed = m_transcoder->transcodeTo(
   			theSourceData,
  -			theSourceCount,
  +			XercesSizeType(theSourceCount),
   			theTarget,
  -			theTargetSize,
  -			theSourceCharsTranscoded,
  +			XercesSizeType(theTargetSize),
  +			theXercesSourceCharsTranscoded,
   			// $$$ ToDo: Eventually, we're going to want to
   			// replace this with UnRep_Throw, and let the
   			// caller try to recover.
   //			XMLTranscoder::UnRep_Throw);
   			XMLTranscoder::UnRep_RepChar);
  +
  +		theSourceCharsTranscoded = theXercesSourceCharsTranscoded;
   	}
   	catch(const XMLException&)
   	{
  @@ -122,24 +129,30 @@
   XalanToXercesTranscoderWrapper::eCode
   XalanToXercesTranscoderWrapper::transcode(
   			const XalanXMLByte*		theSourceData,
  -			unsigned int			theSourceCount,
  +			size_t					theSourceCount,
   			XalanDOMChar*			theTarget,
  -			unsigned int			theTargetSize,
  -			unsigned int&			theSourceCharsTranscoded,
  -			unsigned int&			theTargetBytesUsed,
  +			size_t					theTargetSize,
  +			size_t&					theSourceCharsTranscoded,
  +			size_t&					theTargetBytesUsed,
   			unsigned char*			theCharSizes)
   {
   	eCode	theCode = XalanTranscodingServices::OK;
   
   	try
   	{
  -		theTargetBytesUsed = m_transcoder->transcodeFrom(
  +		assert(XercesSizeType(theSourceCount) == theSourceCount);
  +		assert(XercesSizeType(theTargetSize) == theTargetSize);
  +
  +		const XercesSizeType	theXercesTargetBytesUsed =
  +				m_transcoder->transcodeFrom(
   			theSourceData,
  -			theSourceCount,
  +			XercesSizeType(theSourceCount),
   			theTarget,
  -			theTargetSize,
  +			XercesSizeType(theTargetSize),
   			theSourceCharsTranscoded,
   			theCharSizes);
  +
  +		theTargetBytesUsed = theXercesTargetBytesUsed;
   	}
   	catch(const XMLException&)
   	{
  
  
  
  1.3       +11 -8     xml-xalan/c/src/PlatformSupport/XalanToXercesTranscoderWrapper.hpp
  
  Index: XalanToXercesTranscoderWrapper.hpp
  ===================================================================
  RCS file: /home/cvs/xml-xalan/c/src/PlatformSupport/XalanToXercesTranscoderWrapper.hpp,v
  retrieving revision 1.2
  retrieving revision 1.3
  diff -u -r1.2 -r1.3
  --- XalanToXercesTranscoderWrapper.hpp	2001/09/14 20:03:06	1.2
  +++ XalanToXercesTranscoderWrapper.hpp	2001/09/25 21:12:51	1.3
  @@ -86,20 +86,20 @@
   	virtual eCode
   	transcode(
   			const XalanDOMChar*		theSourceData,
  -			unsigned int			theSourceCount,
  +			size_t					theSourceCount,
   			XalanXMLByte*			theTarget,
  -			unsigned int			theTargetSize,
  -			unsigned int&			theSourceCharsTranscoded,
  -			unsigned int&			theTargetBytesUsed);
  +			size_t					theTargetSize,
  +			size_t&					theSourceCharsTranscoded,
  +			size_t&					theTargetBytesUsed);
   
   	virtual eCode
   	transcode(
   			const XalanXMLByte*		theSourceData,
  -			unsigned int			theSourceCount,
  +			size_t					theSourceCount,
   			XalanDOMChar*			theTarget,
  -			unsigned int			theTargetSize,
  -			unsigned int&			theSourceCharsTranscoded,
  -			unsigned int&			theTargetBytesUsed,
  +			size_t					theTargetSize,
  +			size_t&					theSourceCharsTranscoded,
  +			size_t&					theTargetBytesUsed,
   			unsigned char*			theCharSizes);
   
   private:
  @@ -110,7 +110,10 @@
   	XalanToXercesTranscoderWrapper&
   	operator=(const XalanToXercesTranscoderWrapper&);
   
  +	// A handy typedef...
  +	typedef unsigned int	XercesSizeType;
   
  +	// Data members...
   	XMLTranscoder* const	m_transcoder;
   };
   
  
  
  
  1.6       +10 -10    xml-xalan/c/src/PlatformSupport/XalanTranscodingServices.hpp
  
  Index: XalanTranscodingServices.hpp
  ===================================================================
  RCS file: /home/cvs/xml-xalan/c/src/PlatformSupport/XalanTranscodingServices.hpp,v
  retrieving revision 1.5
  retrieving revision 1.6
  diff -u -r1.5 -r1.6
  --- XalanTranscodingServices.hpp	2001/09/14 20:03:06	1.5
  +++ XalanTranscodingServices.hpp	2001/09/25 21:12:51	1.6
  @@ -100,7 +100,7 @@
   
   	typedef unsigned char	XalanXMLByte;
   
  -	static unsigned int
  +	static size_t
   	length(const XalanXMLByte*	theBytes)
   	{
   		assert(theBytes != 0);
  @@ -146,7 +146,7 @@
   	makeNewTranscoder(
   			const XalanDOMString&	theEncodingName,
   			eCode&					theResult,
  -			unsigned int			theBlockSize);
  +			size_t					theBlockSize);
   
   	/**
   	 * Destroy a transcoder instance.
  @@ -313,11 +313,11 @@
   	virtual eCode
   	transcode(
   			const XalanDOMChar*		theSourceData,
  -			unsigned int			theSourceCount,
  +			size_t					theSourceCount,
   			XalanXMLByte*			theTarget,
  -			unsigned int			theTargetSize,
  -			unsigned int&			theSourceCharsTranscoded,
  -			unsigned int&			theTargetBytesUsed) = 0;
  +			size_t					theTargetSize,
  +			size_t&					theSourceCharsTranscoded,
  +			size_t&					theTargetBytesUsed) = 0;
   
   	/**
   	 * Transcode data from the transcoder's encoding to UTF-16.  If successfull,
  @@ -336,11 +336,11 @@
   	virtual eCode
   	transcode(
   			const XalanXMLByte*		theSourceData,
  -			unsigned int			theSourceCount,
  +			size_t					theSourceCount,
   			XalanDOMChar*			theTarget,
  -			unsigned int			theTargetSize,
  -			unsigned int&			theSourceCharsTranscoded,
  -			unsigned int&			theTargetBytesUsed,
  +			size_t					theTargetSize,
  +			size_t&					theSourceCharsTranscoded,
  +			size_t&					theTargetBytesUsed,
   			unsigned char*			theCharSizes) = 0;
   
   private:
  
  
  
  1.5       +8 -8      xml-xalan/c/src/PlatformSupport/XalanUTF16Transcoder.cpp
  
  Index: XalanUTF16Transcoder.cpp
  ===================================================================
  RCS file: /home/cvs/xml-xalan/c/src/PlatformSupport/XalanUTF16Transcoder.cpp,v
  retrieving revision 1.4
  retrieving revision 1.5
  diff -u -r1.4 -r1.5
  --- XalanUTF16Transcoder.cpp	2001/09/18 14:44:40	1.4
  +++ XalanUTF16Transcoder.cpp	2001/09/25 21:12:51	1.5
  @@ -78,11 +78,11 @@
   XalanUTF16Transcoder::eCode
   XalanUTF16Transcoder::transcode(
   			const XalanDOMChar*		theSourceData,
  -			unsigned int			theSourceCount,
  +			size_t					theSourceCount,
   			XalanXMLByte*			theTarget,
  -			unsigned int			theTargetSize,
  -			unsigned int&			theSourceCharsTranscoded,
  -			unsigned int&			theTargetBytesUsed)
  +			size_t					theTargetSize,
  +			size_t&					theSourceCharsTranscoded,
  +			size_t&					theTargetBytesUsed)
   {
   	unsigned int	theSourceEaten = 0;
   	unsigned int	theTargetPosition = 0;
  @@ -125,11 +125,11 @@
   XalanUTF16Transcoder::eCode
   XalanUTF16Transcoder::transcode(
   			const XalanXMLByte*		theSourceData,
  -			unsigned int			theSourceCount,
  +			size_t					theSourceCount,
   			XalanDOMChar*			theTarget,
  -			unsigned int			theTargetSize,
  -			unsigned int&			theSourceCharsTranscoded,
  -			unsigned int&			theTargetBytesUsed,
  +			size_t					theTargetSize,
  +			size_t&					theSourceCharsTranscoded,
  +			size_t&					theTargetBytesUsed,
   			unsigned char*			theCharSizes)
   {
   	unsigned int	theSourceEaten = 0;
  
  
  
  1.3       +8 -8      xml-xalan/c/src/PlatformSupport/XalanUTF16Transcoder.hpp
  
  Index: XalanUTF16Transcoder.hpp
  ===================================================================
  RCS file: /home/cvs/xml-xalan/c/src/PlatformSupport/XalanUTF16Transcoder.hpp,v
  retrieving revision 1.2
  retrieving revision 1.3
  diff -u -r1.2 -r1.3
  --- XalanUTF16Transcoder.hpp	2001/09/14 20:03:06	1.2
  +++ XalanUTF16Transcoder.hpp	2001/09/25 21:12:51	1.3
  @@ -94,11 +94,11 @@
   	virtual eCode
   	transcode(
   			const XalanDOMChar*		theSourceData,
  -			unsigned int			theSourceCount,
  +			size_t					theSourceCount,
   			XalanXMLByte*			theTarget,
  -			unsigned int			theTargetSize,
  -			unsigned int&			theSourceCharsTranscoded,
  -			unsigned int&			theTargetBytesUsed);
  +			size_t					theTargetSize,
  +			size_t&					theSourceCharsTranscoded,
  +			size_t&					theTargetBytesUsed);
   
   	/**
   	 * Transcode data from UTF-16 to UTF-16.
  @@ -115,11 +115,11 @@
   	virtual eCode
   	transcode(
   			const XalanXMLByte*		theSourceData,
  -			unsigned int			theSourceCount,
  +			size_t					theSourceCount,
   			XalanDOMChar*			theTarget,
  -			unsigned int			theTargetSize,
  -			unsigned int&			theSourceCharsTranscoded,
  -			unsigned int&			theTargetBytesUsed,
  +			size_t					theTargetSize,
  +			size_t&					theSourceCharsTranscoded,
  +			size_t&					theTargetBytesUsed,
   			unsigned char*			theCharSizes);
   
   private:
  
  
  

---------------------------------------------------------------------
To unsubscribe, e-mail: xalan-cvs-unsubscribe@xml.apache.org
For additional commands, e-mail: xalan-cvs-help@xml.apache.org


Mime
View raw message