AOO410/main/sal/qa/rtl_strings/rtl_String_Utils.cxx - openoffice - Git at Google

 /**************************************************************
  *
  * Licensed to the Apache Software Foundation (ASF) under one
  * or more contributor license agreements.  See the NOTICE file
  * distributed with this work for additional information
  * regarding copyright ownership.  The ASF licenses this file
  * to you under the Apache License, Version 2.0 (the
  * "License"); you may not use this file except in compliance
  * with the License.  You may obtain a copy of the License at
  *
  *   http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing,
  * software distributed under the License is distributed on an
  * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
  * KIND, either express or implied.  See the License for the
  * specific language governing permissions and limitations
  * under the License.
  *
  *************************************************************/


 // MARKER(update_precomp.py): autogen include statement, do not remove
 #include "precompiled_sal.hxx"

 //------------------------------------------------------------------------
 //------------------------------------------------------------------------

 #include <math.h>
 #include <stdlib.h>

 //------------------------------------------------------------------------
 //------------------------------------------------------------------------

 #ifndef _SAL_TYPES_H_
 	#include <sal/types.h>
 #endif

 #ifndef _RTL_USTRING_H_
 	#include <rtl/ustring.h>
 #endif

 #ifndef _RTL_STRING_HXX_
 	#include <rtl/string.hxx>
 #endif

 //------------------------------------------------------------------------
 //------------------------------------------------------------------------

 #ifndef _RTL_STRING_UTILS_CONST_H_
 	#include <rtl_String_Utils_Const.h>
 #endif

 //------------------------------------------------------------------------
 //------------------------------------------------------------------------

 using namespace rtl;

 sal_uInt32 AStringLen( const sal_Char *pAStr )
 {
 	sal_uInt32  nStrLen = 0;

 	if ( pAStr != NULL )
 	{
 		const sal_Char *pTempStr = pAStr;

 		while( *pTempStr )
 		{
 			pTempStr++;
 		} // while

 		nStrLen = (sal_uInt32)( pTempStr - pAStr );
 	} // if

 	return nStrLen;
 } // AStringLen
 sal_Char* cpystr( sal_Char* dst, const sal_Char* src )
 {
     const sal_Char* psrc = src;
     sal_Char* pdst = dst;

     while( *pdst++ = *psrc++ );
     return ( dst );
 }

 sal_Char* cpynstr( sal_Char* dst, const sal_Char* src, sal_uInt32 cnt )
 {

     const sal_Char* psrc = src;
     sal_Char* pdst = dst;
     sal_uInt32 len = cnt;
     sal_uInt32 i;

     if ( len >= AStringLen(src) )
     {
         return( cpystr( dst, src ) );
     }

     // copy string by char
     for( i = 0; i < len; i++ )
         *pdst++ = *psrc++;
     *pdst = '\0';

     return ( dst );
 }

 //------------------------------------------------------------------------
 sal_Bool cmpstr( const sal_Char* str1, const sal_Char* str2, sal_uInt32 len )
 {
     const sal_Char* pBuf1 = str1;
     const sal_Char* pBuf2 = str2;
     sal_uInt32 i = 0;

     while ( (*pBuf1 == *pBuf2) && i < len )
     {
         (pBuf1)++;
         (pBuf2)++;
         i++;
     }
     return( i == len );
 }
 //------------------------------------------------------------------------
 sal_Bool cmpustr( const sal_Unicode* str1, const sal_Unicode* str2, sal_uInt32 len )
 {
     const sal_Unicode* pBuf1 = str1;
     const sal_Unicode* pBuf2 = str2;
     sal_uInt32 i = 0;

     while ( (*pBuf1 == *pBuf2) && i < len )
     {
         (pBuf1)++;
         (pBuf2)++;
         i++;
     }
     return( i == len );
 }

 //-----------------------------------------------------------------------
 sal_Bool cmpustr( const sal_Unicode* str1, const sal_Unicode* str2 )
 {
     const sal_Unicode* pBuf1 = str1;
     const sal_Unicode* pBuf2 = str2;
     sal_Bool res = sal_True;

     while ( (*pBuf1 == *pBuf2) && *pBuf1 !='\0' && *pBuf2 != '\0')
     {
         (pBuf1)++;
         (pBuf2)++;
     }
     if (*pBuf1 == '\0' && *pBuf2 == '\0')
         res = sal_True;
     else
         res = sal_False;
     return (res);
 }

 sal_Char* createName( sal_Char* dst, const sal_Char* meth, sal_uInt32 cnt )
 {
     sal_Char* pdst = dst;
     sal_Char nstr[16];
     sal_Char* pstr = nstr;
     rtl_str_valueOfInt32( pstr, cnt, 10 );

     cpystr( pdst, meth );
     cpystr( pdst+ AStringLen(meth), "_" );

     if ( cnt < 100 )
     {
         cpystr(pdst + AStringLen(pdst), "0" );
     }
     if ( cnt < 10 )
     {
         cpystr(pdst + AStringLen(pdst), "0" );
     }

     cpystr( pdst + AStringLen(pdst), nstr );
     return( pdst );
 }

 //------------------------------------------------------------------------
 //  testing the method compareTo( const OString & aStr )
 //------------------------------------------------------------------------
 void makeComment( char *com, const char *str1, const char *str2,
                                                             sal_Int32 sgn )
 {
     cpystr(com, str1);
     int str1Length = AStringLen( str1 );
     const char *sign = (sgn == 0) ? " == " : (sgn > 0) ? " > " : " < " ;
     cpystr(com + str1Length, sign);
     int signLength = AStringLen(sign);
     cpystr(com + str1Length + signLength, str2);
     com[str1Length + signLength + AStringLen(str2)] = 0;
 }


 //------------------------------------------------------------------------

 sal_Bool AStringToFloatCompare ( const sal_Char  *pStr,
                                  const float      nX,
                                  const float      nEPS
                                 )
 {
 	sal_Bool cmp = sal_False;

 	if ( pStr != NULL )
 	{
 		::rtl::OString aStr(pStr);

 		float actNum = 0;
 		float expNum = nX;
 		float eps    = nEPS;

 		actNum = aStr.toFloat();

         if ( abs( (int)(actNum - expNum) ) <= eps )
 		{
 			cmp = sal_True;
 		} // if
 	} // if

 	return cmp;
 } // AStringToFloatCompare

 //------------------------------------------------------------------------

 sal_Bool AStringToDoubleCompare ( const sal_Char  *pStr,
                                   const double     nX,
                                   const double     nEPS
                                 )
 {
 	sal_Bool cmp = sal_False;

 	if ( pStr != NULL )
 	{
 		::rtl::OString aStr(pStr);

 		double actNum = 0;
 		double expNum = nX;
 		double eps    = nEPS;

 		actNum = aStr.toDouble();

         if ( abs( (int)(actNum - expNum) ) <= eps )
 		{
 			cmp = sal_True;
 		} // if
 	} // if

 	return cmp;
 } // AStringToDoubleCompare

 //------------------------------------------------------------------------


 //------------------------------------------------------------------------

 sal_uInt32 UStringLen( const sal_Unicode *pUStr )
 {
 	sal_uInt32 nUStrLen = 0;

 	if ( pUStr != NULL )
 	{
 		const sal_Unicode *pTempUStr = pUStr;

 		while( *pTempUStr )
 		{
 			pTempUStr++;
 		} // while

 		nUStrLen = (sal_uInt32)( pTempUStr - pUStr );
 	} // if

 	return nUStrLen;
 } // UStringLen

 //------------------------------------------------------------------------

 sal_Bool AStringIsValid( const sal_Char  *pAStr )
 {
 	if ( pAStr != NULL )
 	{
 		sal_uInt32 nLen  = AStringLen( pAStr );
 		sal_uChar  uChar = 0;

 		while ( ( nLen >= 0 ) && ( *pAStr ) )
 		{
 			uChar = (unsigned char)*pAStr;

 			if ( uChar > 127 )
 			{
 				return sal_False;
 			} // if

 			pAStr++;

 			// Since we are dealing with unsigned integers
 			// we want to make sure that the last number is
 			// indeed zero.

 			if ( nLen > 0 )
 			{
 				nLen--;
 			} // if
 			else
 			{
 				break;
 			} // else
 		} // while
 	} // if

 	return sal_True;
 } // AStringIsValid

 //------------------------------------------------------------------------

 sal_Bool AStringNIsValid( const sal_Char   *pAStr,
                           const sal_uInt32  nStrLen
                         )
 {
 	sal_uInt32 nLen  = nStrLen;
 	sal_uChar  uChar = 0;

 	while ( ( nLen >= 0 ) && ( *pAStr ) )
 	{
 		uChar = (unsigned char)*pAStr;

 		if ( uChar > 127 )
 		{
 			return sal_False;
 		} // if

 		pAStr++;

 		// Since we are dealing with unsigned integers
 		// we want to make sure that the last number is
 		// indeed zero.

 		if ( nLen > 0 )
 		{
 			nLen--;
 		} // if
 		else
 		{
 			break;
 		} // else
 	} // while

 	return sal_True;
 } // AStringNIsValid

 //------------------------------------------------------------------------

 static inline sal_Int32 ACharToUCharCompare( const sal_Unicode *pUStr,
                                              const sal_Char    *pAStr
                                            )
 {
 	sal_Int32  nCmp   = 0;
 	sal_Int32  nUChar = (sal_Int32)*pUStr;
 	sal_Int32  nChar  = (sal_Int32)((unsigned char)*pAStr);

 	nCmp = nUChar - nChar;

 	return  nCmp;
 } // ACharToUCharCompare

 //------------------------------------------------------------------------

 sal_Int32 AStringToUStringCompare( const sal_Unicode *pUStr,
                                    const sal_Char    *pAStr
                                  )
 {
  	sal_Int32 nCmp = kErrCompareAStringToUString;

 	if ( ( pUStr != NULL ) && ( pAStr != NULL ) )
 	{
 		nCmp = ACharToUCharCompare( pUStr, pAStr );

 		while ( ( nCmp == 0 ) && ( *pAStr ) )
 		{
 			pUStr++;
 			pAStr++;

 			nCmp = ACharToUCharCompare( pUStr, pAStr );
 		} // while
 	} // if

 	return nCmp;
 } // AStringToUStringCompare

 //------------------------------------------------------------------------

 sal_Int32 AStringToUStringNCompare( const sal_Unicode  *pUStr,
                                     const sal_Char     *pAStr,
                                     const sal_uInt32    nAStrCount
                                    )
 {
 	sal_Int32 nCmp = kErrCompareNAStringToUString;

 	if ( ( pUStr != NULL ) && ( pAStr != NULL ) )
 	{
 		sal_uInt32 nCount = nAStrCount;

 		nCmp = ACharToUCharCompare( pUStr, pAStr );

 		while ( ( nCmp == 0 ) && ( *pAStr ) && ( nCount ) )
 		{
 			pUStr++;
 			pAStr++;

 			nCmp = ACharToUCharCompare( pUStr, pAStr );

 			// Since we are dealing with unsigned integers
 			// we want to make sure that the last number is
 			// indeed zero.

 			if ( nCount > 0 )
 			{
 				nCount--;
 			} // if
 			else
 			{
 				break;
 			} // else
 		} // while
 	} // if

 	return nCmp;
 } // AStringToUStringNCompare

 //------------------------------------------------------------------------

 sal_Int32 AStringToRTLUStringCompare( const rtl_uString  *pRTLUStr,
                                       const sal_Char     *pAStr
                                     )
 {
 	sal_Int32 nCmp = kErrCompareAStringToRTLUString;

 	if ( ( pRTLUStr != NULL ) && ( pAStr != NULL ) )
 	{
 		rtl_uString *pRTLUStrCopy = NULL;

 		rtl_uString_newFromString( &pRTLUStrCopy, pRTLUStr );

 		if ( pRTLUStrCopy != NULL )
 		{
 			const sal_Unicode *pUStr = rtl_uString_getStr( pRTLUStrCopy );

 			if ( pUStr != NULL )
 			{
 				nCmp = AStringToUStringCompare( pUStr, pAStr );
 			} // if

 			rtl_uString_release( pRTLUStrCopy );

 			pRTLUStrCopy = NULL;
 		} // if
 	} // if

 	return nCmp;
 } // AStringToRTLUStringCompare

 //------------------------------------------------------------------------

 sal_Int32 AStringToRTLUStringNCompare( const rtl_uString  *pRTLUStr,
                                        const sal_Char     *pAStr,
                                        const sal_uInt32    nAStrCount
                                      )
 {
 	sal_Int32 nCmp = kErrCompareNAStringToRTLUString;

 	if ( ( pRTLUStr != NULL ) && ( pAStr != NULL ) )
 	{
 		rtl_uString *pRTLUStrCopy = NULL;

 		rtl_uString_newFromString( &pRTLUStrCopy, pRTLUStr );

 		if ( pRTLUStrCopy != NULL )
 		{
 			const sal_Unicode  *pUStr = rtl_uString_getStr( pRTLUStrCopy );

 			if ( pUStr != NULL )
 			{
 				nCmp = AStringToUStringNCompare( pUStr, pAStr, nAStrCount );
 			} // if

 			rtl_uString_release( pRTLUStrCopy );

 			pRTLUStrCopy = NULL;
 		} // if
 	} // if

 	return nCmp;
 } // AStringToRTLUStringNCompare

 //------------------------------------------------------------------------

 sal_Bool AStringToUStringCopy( sal_Unicode     *pDest,
                                const sal_Char  *pSrc
                              )
 {
 	sal_Bool    bCopied = sal_False;
 	sal_uInt32  nCount  = AStringLen( pSrc );
 	sal_uInt32  nLen    = nCount;

 	if (    ( pDest != NULL )
 	     && ( pSrc  != NULL )
 	     && ( AStringNIsValid( pSrc, nLen ) )
 	   )
 	{
 		while ( nCount >= 0 )
 		{
 			*pDest = (unsigned char)*pSrc;

 			pDest++;
 			pSrc++;

 			// Since we are dealing with unsigned integers
 			// we want to make sure that the last number is
 			// indeed zero.

 			if ( nCount > 0 )
 			{
 				nCount--;
 			} // if
 			else
 			{
 				break;
 			} // else
 		} // while

 		if ( nCount == 0 )
 		{
 			bCopied = sal_True;
 		} // if
 	} // if

 	return  bCopied;
 } // AStringToUStringCopy

 //------------------------------------------------------------------------

 sal_Bool AStringToUStringNCopy( sal_Unicode       *pDest,
                                 const sal_Char    *pSrc,
                                 const sal_uInt32   nSrcLen
                               )
 {
 	sal_Bool    bCopied = sal_False;
 	sal_uInt32  nCount  = nSrcLen;
 	sal_uInt32  nLen    = nSrcLen;

 	if (    ( pDest != NULL )
 	     && ( pSrc  != NULL )
 	     && ( AStringNIsValid( pSrc, nLen ) )
 	   )
 	{
 		while ( nCount >= 0 )
 		{
 			*pDest = (unsigned char)*pSrc;

 			pDest++;
 			pSrc++;

 			// Since we are dealing with unsigned integers
 			// we want to make sure that the last number is
 			// indeed zero.

 			if ( nCount > 0 )
 			{
 				nCount--;
 			} // if
 			else
 			{
 				break;
 			} // else
 		} // while

 		if ( nCount == 0 )
 		{
 			bCopied = sal_True;
 		} // if
 	} // if

 	return  bCopied;
 } // AStringToUStringNCopy

 //------------------------------------------------------------------------
 //------------------------------------------------------------------------
	/**************************************************************
	*
	* Licensed to the Apache Software Foundation (ASF) under one
	* or more contributor license agreements. See the NOTICE file
	* distributed with this work for additional information
	* regarding copyright ownership. The ASF licenses this file
	* to you under the Apache License, Version 2.0 (the
	* "License"); you may not use this file except in compliance
	* with the License. You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing,
	* software distributed under the License is distributed on an
	* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
	* KIND, either express or implied. See the License for the
	* specific language governing permissions and limitations
	* under the License.
	*
	*************************************************************/



	// MARKER(update_precomp.py): autogen include statement, do not remove
	#include "precompiled_sal.hxx"

	//------------------------------------------------------------------------
	//------------------------------------------------------------------------

	#include <math.h>
	#include <stdlib.h>

	//------------------------------------------------------------------------
	//------------------------------------------------------------------------

	#ifndef _SAL_TYPES_H_
	#include <sal/types.h>
	#endif

	#ifndef _RTL_USTRING_H_
	#include <rtl/ustring.h>
	#endif

	#ifndef _RTL_STRING_HXX_
	#include <rtl/string.hxx>
	#endif

	//------------------------------------------------------------------------
	//------------------------------------------------------------------------

	#ifndef _RTL_STRING_UTILS_CONST_H_
	#include <rtl_String_Utils_Const.h>
	#endif

	//------------------------------------------------------------------------
	//------------------------------------------------------------------------

	using namespace rtl;

	sal_uInt32 AStringLen( const sal_Char *pAStr )
	{
	sal_uInt32 nStrLen = 0;

	if ( pAStr != NULL )
	{
	const sal_Char *pTempStr = pAStr;

	while( *pTempStr )
	{
	pTempStr++;
	} // while

	nStrLen = (sal_uInt32)( pTempStr - pAStr );
	} // if

	return nStrLen;
	} // AStringLen
	sal_Char* cpystr( sal_Char* dst, const sal_Char* src )
	{
	const sal_Char* psrc = src;
	sal_Char* pdst = dst;

	while( pdst++ = psrc++ );
	return ( dst );
	}

	sal_Char* cpynstr( sal_Char* dst, const sal_Char* src, sal_uInt32 cnt )
	{

	const sal_Char* psrc = src;
	sal_Char* pdst = dst;
	sal_uInt32 len = cnt;
	sal_uInt32 i;

	if ( len >= AStringLen(src) )
	{
	return( cpystr( dst, src ) );
	}

	// copy string by char
	for( i = 0; i < len; i++ )
	pdst++ = psrc++;
	*pdst = '\0';

	return ( dst );
	}

	//------------------------------------------------------------------------
	sal_Bool cmpstr( const sal_Char* str1, const sal_Char* str2, sal_uInt32 len )
	{
	const sal_Char* pBuf1 = str1;
	const sal_Char* pBuf2 = str2;
	sal_uInt32 i = 0;

	while ( (pBuf1 == pBuf2) && i < len )
	{
	(pBuf1)++;
	(pBuf2)++;
	i++;
	}
	return( i == len );
	}
	//------------------------------------------------------------------------
	sal_Bool cmpustr( const sal_Unicode* str1, const sal_Unicode* str2, sal_uInt32 len )
	{
	const sal_Unicode* pBuf1 = str1;
	const sal_Unicode* pBuf2 = str2;
	sal_uInt32 i = 0;

	while ( (pBuf1 == pBuf2) && i < len )
	{
	(pBuf1)++;
	(pBuf2)++;
	i++;
	}
	return( i == len );
	}

	//-----------------------------------------------------------------------
	sal_Bool cmpustr( const sal_Unicode* str1, const sal_Unicode* str2 )
	{
	const sal_Unicode* pBuf1 = str1;
	const sal_Unicode* pBuf2 = str2;
	sal_Bool res = sal_True;

	while ( (pBuf1 == pBuf2) && pBuf1 !='\0' && pBuf2 != '\0')
	{
	(pBuf1)++;
	(pBuf2)++;
	}
	if (pBuf1 == '\0' && pBuf2 == '\0')
	res = sal_True;
	else
	res = sal_False;
	return (res);
	}

	sal_Char* createName( sal_Char* dst, const sal_Char* meth, sal_uInt32 cnt )
	{
	sal_Char* pdst = dst;
	sal_Char nstr[16];
	sal_Char* pstr = nstr;
	rtl_str_valueOfInt32( pstr, cnt, 10 );

	cpystr( pdst, meth );
	cpystr( pdst+ AStringLen(meth), "_" );

	if ( cnt < 100 )
	{
	cpystr(pdst + AStringLen(pdst), "0" );
	}
	if ( cnt < 10 )
	{
	cpystr(pdst + AStringLen(pdst), "0" );
	}

	cpystr( pdst + AStringLen(pdst), nstr );
	return( pdst );
	}

	//------------------------------------------------------------------------
	// testing the method compareTo( const OString & aStr )
	//------------------------------------------------------------------------
	void makeComment( char com, const char str1, const char *str2,
	sal_Int32 sgn )
	{
	cpystr(com, str1);
	int str1Length = AStringLen( str1 );
	const char *sign = (sgn == 0) ? " == " : (sgn > 0) ? " > " : " < " ;
	cpystr(com + str1Length, sign);
	int signLength = AStringLen(sign);
	cpystr(com + str1Length + signLength, str2);
	com[str1Length + signLength + AStringLen(str2)] = 0;
	}


	//------------------------------------------------------------------------

	sal_Bool AStringToFloatCompare ( const sal_Char *pStr,
	const float nX,
	const float nEPS
	)
	{
	sal_Bool cmp = sal_False;

	if ( pStr != NULL )
	{
	::rtl::OString aStr(pStr);

	float actNum = 0;
	float expNum = nX;
	float eps = nEPS;

	actNum = aStr.toFloat();

	if ( abs( (int)(actNum - expNum) ) <= eps )
	{
	cmp = sal_True;
	} // if
	} // if

	return cmp;
	} // AStringToFloatCompare

	//------------------------------------------------------------------------

	sal_Bool AStringToDoubleCompare ( const sal_Char *pStr,
	const double nX,
	const double nEPS
	)
	{
	sal_Bool cmp = sal_False;

	if ( pStr != NULL )
	{
	::rtl::OString aStr(pStr);

	double actNum = 0;
	double expNum = nX;
	double eps = nEPS;

	actNum = aStr.toDouble();

	if ( abs( (int)(actNum - expNum) ) <= eps )
	{
	cmp = sal_True;
	} // if
	} // if

	return cmp;
	} // AStringToDoubleCompare

	//------------------------------------------------------------------------


	//------------------------------------------------------------------------

	sal_uInt32 UStringLen( const sal_Unicode *pUStr )
	{
	sal_uInt32 nUStrLen = 0;

	if ( pUStr != NULL )
	{
	const sal_Unicode *pTempUStr = pUStr;

	while( *pTempUStr )
	{
	pTempUStr++;
	} // while

	nUStrLen = (sal_uInt32)( pTempUStr - pUStr );
	} // if

	return nUStrLen;
	} // UStringLen

	//------------------------------------------------------------------------

	sal_Bool AStringIsValid( const sal_Char *pAStr )
	{
	if ( pAStr != NULL )
	{
	sal_uInt32 nLen = AStringLen( pAStr );
	sal_uChar uChar = 0;

	while ( ( nLen >= 0 ) && ( *pAStr ) )
	{
	uChar = (unsigned char)*pAStr;

	if ( uChar > 127 )
	{
	return sal_False;
	} // if

	pAStr++;

	// Since we are dealing with unsigned integers
	// we want to make sure that the last number is
	// indeed zero.

	if ( nLen > 0 )
	{
	nLen--;
	} // if
	else
	{
	break;
	} // else
	} // while
	} // if

	return sal_True;
	} // AStringIsValid

	//------------------------------------------------------------------------

	sal_Bool AStringNIsValid( const sal_Char *pAStr,
	const sal_uInt32 nStrLen
	)
	{
	sal_uInt32 nLen = nStrLen;
	sal_uChar uChar = 0;

	while ( ( nLen >= 0 ) && ( *pAStr ) )
	{
	uChar = (unsigned char)*pAStr;

	if ( uChar > 127 )
	{
	return sal_False;
	} // if

	pAStr++;

	// Since we are dealing with unsigned integers
	// we want to make sure that the last number is
	// indeed zero.

	if ( nLen > 0 )
	{
	nLen--;
	} // if
	else
	{
	break;
	} // else
	} // while

	return sal_True;
	} // AStringNIsValid

	//------------------------------------------------------------------------

	static inline sal_Int32 ACharToUCharCompare( const sal_Unicode *pUStr,
	const sal_Char *pAStr
	)
	{
	sal_Int32 nCmp = 0;
	sal_Int32 nUChar = (sal_Int32)*pUStr;
	sal_Int32 nChar = (sal_Int32)((unsigned char)*pAStr);

	nCmp = nUChar - nChar;

	return nCmp;
	} // ACharToUCharCompare

	//------------------------------------------------------------------------

	sal_Int32 AStringToUStringCompare( const sal_Unicode *pUStr,
	const sal_Char *pAStr
	)
	{
	sal_Int32 nCmp = kErrCompareAStringToUString;

	if ( ( pUStr != NULL ) && ( pAStr != NULL ) )
	{
	nCmp = ACharToUCharCompare( pUStr, pAStr );

	while ( ( nCmp == 0 ) && ( *pAStr ) )
	{
	pUStr++;
	pAStr++;

	nCmp = ACharToUCharCompare( pUStr, pAStr );
	} // while
	} // if

	return nCmp;
	} // AStringToUStringCompare

	//------------------------------------------------------------------------

	sal_Int32 AStringToUStringNCompare( const sal_Unicode *pUStr,
	const sal_Char *pAStr,
	const sal_uInt32 nAStrCount
	)
	{
	sal_Int32 nCmp = kErrCompareNAStringToUString;

	if ( ( pUStr != NULL ) && ( pAStr != NULL ) )
	{
	sal_uInt32 nCount = nAStrCount;

	nCmp = ACharToUCharCompare( pUStr, pAStr );

	while ( ( nCmp == 0 ) && ( *pAStr ) && ( nCount ) )
	{
	pUStr++;
	pAStr++;

	nCmp = ACharToUCharCompare( pUStr, pAStr );

	// Since we are dealing with unsigned integers
	// we want to make sure that the last number is
	// indeed zero.

	if ( nCount > 0 )
	{
	nCount--;
	} // if
	else
	{
	break;
	} // else
	} // while
	} // if

	return nCmp;
	} // AStringToUStringNCompare

	//------------------------------------------------------------------------

	sal_Int32 AStringToRTLUStringCompare( const rtl_uString *pRTLUStr,
	const sal_Char *pAStr
	)
	{
	sal_Int32 nCmp = kErrCompareAStringToRTLUString;

	if ( ( pRTLUStr != NULL ) && ( pAStr != NULL ) )
	{
	rtl_uString *pRTLUStrCopy = NULL;

	rtl_uString_newFromString( &pRTLUStrCopy, pRTLUStr );

	if ( pRTLUStrCopy != NULL )
	{
	const sal_Unicode *pUStr = rtl_uString_getStr( pRTLUStrCopy );

	if ( pUStr != NULL )
	{
	nCmp = AStringToUStringCompare( pUStr, pAStr );
	} // if

	rtl_uString_release( pRTLUStrCopy );

	pRTLUStrCopy = NULL;
	} // if
	} // if

	return nCmp;
	} // AStringToRTLUStringCompare

	//------------------------------------------------------------------------

	sal_Int32 AStringToRTLUStringNCompare( const rtl_uString *pRTLUStr,
	const sal_Char *pAStr,
	const sal_uInt32 nAStrCount
	)
	{
	sal_Int32 nCmp = kErrCompareNAStringToRTLUString;

	if ( ( pRTLUStr != NULL ) && ( pAStr != NULL ) )
	{
	rtl_uString *pRTLUStrCopy = NULL;

	rtl_uString_newFromString( &pRTLUStrCopy, pRTLUStr );

	if ( pRTLUStrCopy != NULL )
	{
	const sal_Unicode *pUStr = rtl_uString_getStr( pRTLUStrCopy );

	if ( pUStr != NULL )
	{
	nCmp = AStringToUStringNCompare( pUStr, pAStr, nAStrCount );
	} // if

	rtl_uString_release( pRTLUStrCopy );

	pRTLUStrCopy = NULL;
	} // if
	} // if

	return nCmp;
	} // AStringToRTLUStringNCompare

	//------------------------------------------------------------------------

	sal_Bool AStringToUStringCopy( sal_Unicode *pDest,
	const sal_Char *pSrc
	)
	{
	sal_Bool bCopied = sal_False;
	sal_uInt32 nCount = AStringLen( pSrc );
	sal_uInt32 nLen = nCount;

	if ( ( pDest != NULL )
	&& ( pSrc != NULL )
	&& ( AStringNIsValid( pSrc, nLen ) )
	)
	{
	while ( nCount >= 0 )
	{
	pDest = (unsigned char)pSrc;

	pDest++;
	pSrc++;

	// Since we are dealing with unsigned integers
	// we want to make sure that the last number is
	// indeed zero.

	if ( nCount > 0 )
	{
	nCount--;
	} // if
	else
	{
	break;
	} // else
	} // while

	if ( nCount == 0 )
	{
	bCopied = sal_True;
	} // if
	} // if

	return bCopied;
	} // AStringToUStringCopy

	//------------------------------------------------------------------------

	sal_Bool AStringToUStringNCopy( sal_Unicode *pDest,
	const sal_Char *pSrc,
	const sal_uInt32 nSrcLen
	)
	{
	sal_Bool bCopied = sal_False;
	sal_uInt32 nCount = nSrcLen;
	sal_uInt32 nLen = nSrcLen;

	if ( ( pDest != NULL )
	&& ( pSrc != NULL )
	&& ( AStringNIsValid( pSrc, nLen ) )
	)
	{
	while ( nCount >= 0 )
	{
	pDest = (unsigned char)pSrc;

	pDest++;
	pSrc++;

	// Since we are dealing with unsigned integers
	// we want to make sure that the last number is
	// indeed zero.

	if ( nCount > 0 )
	{
	nCount--;
	} // if
	else
	{
	break;
	} // else
	} // while

	if ( nCount == 0 )
	{
	bCopied = sal_True;
	} // if
	} // if

	return bCopied;
	} // AStringToUStringNCopy

	//------------------------------------------------------------------------
	//------------------------------------------------------------------------