/************************************************************** * * 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 #include //------------------------------------------------------------------------ //------------------------------------------------------------------------ #ifndef _SAL_TYPES_H_ #include #endif #ifndef _RTL_USTRING_H_ #include #endif #ifndef _RTL_STRING_HXX_ #include #endif //------------------------------------------------------------------------ //------------------------------------------------------------------------ #ifndef _RTL_STRING_UTILS_CONST_H_ #include #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 //------------------------------------------------------------------------ //------------------------------------------------------------------------