| /************************************************************** | |
| * | |
| * 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 | |
| /* disable assignment within condition expression */ | |
| #ifdef WNT | |
| #pragma warning( disable : 4706 ) | |
| #endif | |
| 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 cmpstr( const sal_Char* str1, const sal_Char* str2 ) | |
| { | |
| const sal_Char* pBuf1 = str1; | |
| const sal_Char* 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_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 ( *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 ( *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 ) ) | |
| ) | |
| { | |
| for (;;) | |
| { | |
| *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 ) ) | |
| ) | |
| { | |
| for (;;) | |
| { | |
| *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 | |
| //------------------------------------------------------------------------ | |
| //------------------------------------------------------------------------ |