sal/qa/rtl_strings/rtl_String_Utils.cxx

   1 /*************************************************************************
   2 #
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2000, 2010 Oracle and/or its affiliates.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * This file is part of OpenOffice.org.
  10  *
  11  * OpenOffice.org is free software: you can redistribute it and/or modify
  12  * it under the terms of the GNU Lesser General Public License version 3
  13  * only, as published by the Free Software Foundation.
  14  *
  15  * OpenOffice.org is distributed in the hope that it will be useful,
  16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18  * GNU Lesser General Public License version 3 for more details
  19  * (a copy is included in the LICENSE file that accompanied this code).
  20  *
  21  * You should have received a copy of the GNU Lesser General Public License
  22  * version 3 along with OpenOffice.org.  If not, see
  23  * <http://www.openoffice.org/license.html>
  24  * for a copy of the LGPLv3 License.
  25  *
  26 #*************************************************************************/
  27
  28 // MARKER(update_precomp.py): autogen include statement, do not remove
  29 #include "precompiled_sal.hxx"
  30
  31 //------------------------------------------------------------------------
  32 //------------------------------------------------------------------------
  33
  34 #include <math.h>
  35 #include <stdlib.h>
  36
  37 //------------------------------------------------------------------------
  38 //------------------------------------------------------------------------
  39
  40 #ifndef _SAL_TYPES_H_
  41     #include <sal/types.h>
  42 #endif
  43
  44 #ifndef _RTL_USTRING_H_
  45     #include <rtl/ustring.h>
  46 #endif
  47
  48 #ifndef _RTL_STRING_HXX_
  49     #include <rtl/string.hxx>
  50 #endif
  51
  52 //------------------------------------------------------------------------
  53 //------------------------------------------------------------------------
  54
  55 #ifndef _RTL_STRING_UTILS_CONST_H_
  56     #include <rtl_String_Utils_Const.h>
  57 #endif
  58
  59 //------------------------------------------------------------------------
  60 //------------------------------------------------------------------------
  61
  62 using namespace rtl;
  63
  64 sal_uInt32 AStringLen( const sal_Char *pAStr )
  65 {
  66     sal_uInt32  nStrLen = 0;
  67
  68     if ( pAStr != NULL )
  69     {
  70         const sal_Char *pTempStr = pAStr;
  71
  72         while( *pTempStr )
  73         {
  74             pTempStr++;
  75         } // while
  76
  77         nStrLen = (sal_uInt32)( pTempStr - pAStr );
  78     } // if
  79
  80     return nStrLen;
  81 } // AStringLen
  82 sal_Char* cpystr( sal_Char* dst, const sal_Char* src )
  83 {
  84     const sal_Char* psrc = src;
  85     sal_Char* pdst = dst;
  86
  87     while( *pdst++ = *psrc++ );
  88     return ( dst );
  89 }
  90
  91 sal_Char* cpynstr( sal_Char* dst, const sal_Char* src, sal_uInt32 cnt )
  92 {
  93
  94     const sal_Char* psrc = src;
  95     sal_Char* pdst = dst;
  96     sal_uInt32 len = cnt;
  97     sal_uInt32 i;
  98
  99     if ( len >= AStringLen(src) )
 100     {
 101         return( cpystr( dst, src ) );
 102     }
 103
 104     // copy string by char
 105     for( i = 0; i < len; i++ )
 106         *pdst++ = *psrc++;
 107     *pdst = '\0';
 108
 109     return ( dst );
 110 }
 111
 112 //------------------------------------------------------------------------
 113 sal_Bool cmpstr( const sal_Char* str1, const sal_Char* str2, sal_uInt32 len )
 114 {
 115     const sal_Char* pBuf1 = str1;
 116     const sal_Char* pBuf2 = str2;
 117     sal_uInt32 i = 0;
 118
 119     while ( (*pBuf1 == *pBuf2) && i < len )
 120     {
 121         (pBuf1)++;
 122         (pBuf2)++;
 123         i++;
 124     }
 125     return( i == len );
 126 }
 127 //------------------------------------------------------------------------
 128 sal_Bool cmpustr( const sal_Unicode* str1, const sal_Unicode* str2, sal_uInt32 len )
 129 {
 130     const sal_Unicode* pBuf1 = str1;
 131     const sal_Unicode* pBuf2 = str2;
 132     sal_uInt32 i = 0;
 133
 134     while ( (*pBuf1 == *pBuf2) && i < len )
 135     {
 136         (pBuf1)++;
 137         (pBuf2)++;
 138         i++;
 139     }
 140     return( i == len );
 141 }
 142
 143 //-----------------------------------------------------------------------
 144 sal_Bool cmpustr( const sal_Unicode* str1, const sal_Unicode* str2 )
 145 {
 146     const sal_Unicode* pBuf1 = str1;
 147     const sal_Unicode* pBuf2 = str2;
 148     sal_Bool res = sal_True;
 149
 150     while ( (*pBuf1 == *pBuf2) && *pBuf1 !='\0' && *pBuf2 != '\0')
 151     {
 152         (pBuf1)++;
 153         (pBuf2)++;
 154     }
 155     if (*pBuf1 == '\0' && *pBuf2 == '\0')
 156         res = sal_True;
 157     else
 158         res = sal_False;
 159     return (res);
 160 }
 161
 162 sal_Char* createName( sal_Char* dst, const sal_Char* meth, sal_uInt32 cnt )
 163 {
 164     sal_Char* pdst = dst;
 165     sal_Char nstr[16];
 166     sal_Char* pstr = nstr;
 167     rtl_str_valueOfInt32( pstr, cnt, 10 );
 168
 169     cpystr( pdst, meth );
 170     cpystr( pdst+ AStringLen(meth), "_" );
 171
 172     if ( cnt < 100 )
 173     {
 174         cpystr(pdst + AStringLen(pdst), "0" );
 175     }
 176     if ( cnt < 10 )
 177     {
 178         cpystr(pdst + AStringLen(pdst), "0" );
 179     }
 180
 181     cpystr( pdst + AStringLen(pdst), nstr );
 182     return( pdst );
 183 }
 184
 185 //------------------------------------------------------------------------
 186 //  testing the method compareTo( const OString & aStr )
 187 //------------------------------------------------------------------------
 188 void makeComment( char *com, const char *str1, const char *str2,
 189                                                             sal_Int32 sgn )
 190 {
 191     cpystr(com, str1);
 192     int str1Length = AStringLen( str1 );
 193     const char *sign = (sgn == 0) ? " == " : (sgn > 0) ? " > " : " < " ;
 194     cpystr(com + str1Length, sign);
 195     int signLength = AStringLen(sign);
 196     cpystr(com + str1Length + signLength, str2);
 197     com[str1Length + signLength + AStringLen(str2)] = 0;
 198 }
 199
 200
 201 //------------------------------------------------------------------------
 202
 203 sal_Bool AStringToFloatCompare ( const sal_Char  *pStr,
 204                                  const float      nX,
 205                                  const float      nEPS
 206                                 )
 207 {
 208     sal_Bool cmp = sal_False;
 209
 210     if ( pStr != NULL )
 211     {
 212         ::rtl::OString aStr(pStr);
 213
 214         float actNum = 0;
 215         float expNum = nX;
 216         float eps    = nEPS;
 217
 218         actNum = aStr.toFloat();
 219
 220         if ( abs( (int)(actNum - expNum) ) <= eps )
 221         {
 222             cmp = sal_True;
 223         } // if
 224     } // if
 225
 226     return cmp;
 227 } // AStringToFloatCompare
 228
 229 //------------------------------------------------------------------------
 230
 231 sal_Bool AStringToDoubleCompare ( const sal_Char  *pStr,
 232                                   const double     nX,
 233                                   const double     nEPS
 234                                 )
 235 {
 236     sal_Bool cmp = sal_False;
 237
 238     if ( pStr != NULL )
 239     {
 240         ::rtl::OString aStr(pStr);
 241
 242         double actNum = 0;
 243         double expNum = nX;
 244         double eps    = nEPS;
 245
 246         actNum = aStr.toDouble();
 247
 248         if ( abs( (int)(actNum - expNum) ) <= eps )
 249         {
 250             cmp = sal_True;
 251         } // if
 252     } // if
 253
 254     return cmp;
 255 } // AStringToDoubleCompare
 256
 257 //------------------------------------------------------------------------
 258
 259
 260 //------------------------------------------------------------------------
 261
 262 sal_uInt32 UStringLen( const sal_Unicode *pUStr )
 263 {
 264     sal_uInt32 nUStrLen = 0;
 265
 266     if ( pUStr != NULL )
 267     {
 268         const sal_Unicode *pTempUStr = pUStr;
 269
 270         while( *pTempUStr )
 271         {
 272             pTempUStr++;
 273         } // while
 274
 275         nUStrLen = (sal_uInt32)( pTempUStr - pUStr );
 276     } // if
 277
 278     return nUStrLen;
 279 } // UStringLen
 280
 281 //------------------------------------------------------------------------
 282
 283 sal_Bool AStringIsValid( const sal_Char  *pAStr )
 284 {
 285     if ( pAStr != NULL )
 286     {
 287         sal_uInt32 nLen  = AStringLen( pAStr );
 288         sal_uChar  uChar = 0;
 289
 290         while ( ( nLen >= 0 ) && ( *pAStr ) )
 291         {
 292             uChar = (unsigned char)*pAStr;
 293
 294             if ( uChar > 127 )
 295             {
 296                 return sal_False;
 297             } // if
 298
 299             pAStr++;
 300
 301             // Since we are dealing with unsigned integers
 302             // we want to make sure that the last number is
 303             // indeed zero.
 304
 305             if ( nLen > 0 )
 306             {
 307                 nLen--;
 308             } // if
 309             else
 310             {
 311                 break;
 312             } // else
 313         } // while
 314     } // if
 315
 316     return sal_True;
 317 } // AStringIsValid
 318
 319 //------------------------------------------------------------------------
 320
 321 sal_Bool AStringNIsValid( const sal_Char   *pAStr,
 322                           const sal_uInt32  nStrLen
 323                         )
 324 {
 325     sal_uInt32 nLen  = nStrLen;
 326     sal_uChar  uChar = 0;
 327
 328     while ( ( nLen >= 0 ) && ( *pAStr ) )
 329     {
 330         uChar = (unsigned char)*pAStr;
 331
 332         if ( uChar > 127 )
 333         {
 334             return sal_False;
 335         } // if
 336
 337         pAStr++;
 338
 339         // Since we are dealing with unsigned integers
 340         // we want to make sure that the last number is
 341         // indeed zero.
 342
 343         if ( nLen > 0 )
 344         {
 345             nLen--;
 346         } // if
 347         else
 348         {
 349             break;
 350         } // else
 351     } // while
 352
 353     return sal_True;
 354 } // AStringNIsValid
 355
 356 //------------------------------------------------------------------------
 357
 358 static inline sal_Int32 ACharToUCharCompare( const sal_Unicode *pUStr,
 359                                              const sal_Char    *pAStr
 360                                            )
 361 {
 362     sal_Int32  nCmp   = 0;
 363     sal_Int32  nUChar = (sal_Int32)*pUStr;
 364     sal_Int32  nChar  = (sal_Int32)((unsigned char)*pAStr);
 365
 366     nCmp = nUChar - nChar;
 367
 368     return  nCmp;
 369 } // ACharToUCharCompare
 370
 371 //------------------------------------------------------------------------
 372
 373 sal_Int32 AStringToUStringCompare( const sal_Unicode *pUStr,
 374                                    const sal_Char    *pAStr
 375                                  )
 376 {
 377      sal_Int32 nCmp = kErrCompareAStringToUString;
 378
 379     if ( ( pUStr != NULL ) && ( pAStr != NULL ) )
 380     {
 381         nCmp = ACharToUCharCompare( pUStr, pAStr );
 382
 383         while ( ( nCmp == 0 ) && ( *pAStr ) )
 384         {
 385             pUStr++;
 386             pAStr++;
 387
 388             nCmp = ACharToUCharCompare( pUStr, pAStr );
 389         } // while
 390     } // if
 391
 392     return nCmp;
 393 } // AStringToUStringCompare
 394
 395 //------------------------------------------------------------------------
 396
 397 sal_Int32 AStringToUStringNCompare( const sal_Unicode  *pUStr,
 398                                     const sal_Char     *pAStr,
 399                                     const sal_uInt32    nAStrCount
 400                                    )
 401 {
 402     sal_Int32 nCmp = kErrCompareNAStringToUString;
 403
 404     if ( ( pUStr != NULL ) && ( pAStr != NULL ) )
 405     {
 406         sal_uInt32 nCount = nAStrCount;
 407
 408         nCmp = ACharToUCharCompare( pUStr, pAStr );
 409
 410         while ( ( nCmp == 0 ) && ( *pAStr ) && ( nCount ) )
 411         {
 412             pUStr++;
 413             pAStr++;
 414
 415             nCmp = ACharToUCharCompare( pUStr, pAStr );
 416
 417             // Since we are dealing with unsigned integers
 418             // we want to make sure that the last number is
 419             // indeed zero.
 420
 421             if ( nCount > 0 )
 422             {
 423                 nCount--;
 424             } // if
 425             else
 426             {
 427                 break;
 428             } // else
 429         } // while
 430     } // if
 431
 432     return nCmp;
 433 } // AStringToUStringNCompare
 434
 435 //------------------------------------------------------------------------
 436
 437 sal_Int32 AStringToRTLUStringCompare( const rtl_uString  *pRTLUStr,
 438                                       const sal_Char     *pAStr
 439                                     )
 440 {
 441     sal_Int32 nCmp = kErrCompareAStringToRTLUString;
 442
 443     if ( ( pRTLUStr != NULL ) && ( pAStr != NULL ) )
 444     {
 445         rtl_uString *pRTLUStrCopy = NULL;
 446
 447         rtl_uString_newFromString( &pRTLUStrCopy, pRTLUStr );
 448
 449         if ( pRTLUStrCopy != NULL )
 450         {
 451             const sal_Unicode *pUStr = rtl_uString_getStr( pRTLUStrCopy );
 452
 453             if ( pUStr != NULL )
 454             {
 455                 nCmp = AStringToUStringCompare( pUStr, pAStr );
 456             } // if
 457
 458             rtl_uString_release( pRTLUStrCopy );
 459
 460             pRTLUStrCopy = NULL;
 461         } // if
 462     } // if
 463
 464     return nCmp;
 465 } // AStringToRTLUStringCompare
 466
 467 //------------------------------------------------------------------------
 468
 469 sal_Int32 AStringToRTLUStringNCompare( const rtl_uString  *pRTLUStr,
 470                                        const sal_Char     *pAStr,
 471                                        const sal_uInt32    nAStrCount
 472                                      )
 473 {
 474     sal_Int32 nCmp = kErrCompareNAStringToRTLUString;
 475
 476     if ( ( pRTLUStr != NULL ) && ( pAStr != NULL ) )
 477     {
 478         rtl_uString *pRTLUStrCopy = NULL;
 479
 480         rtl_uString_newFromString( &pRTLUStrCopy, pRTLUStr );
 481
 482         if ( pRTLUStrCopy != NULL )
 483         {
 484             const sal_Unicode  *pUStr = rtl_uString_getStr( pRTLUStrCopy );
 485
 486             if ( pUStr != NULL )
 487             {
 488                 nCmp = AStringToUStringNCompare( pUStr, pAStr, nAStrCount );
 489             } // if
 490
 491             rtl_uString_release( pRTLUStrCopy );
 492
 493             pRTLUStrCopy = NULL;
 494         } // if
 495     } // if
 496
 497     return nCmp;
 498 } // AStringToRTLUStringNCompare
 499
 500 //------------------------------------------------------------------------
 501
 502 sal_Bool AStringToUStringCopy( sal_Unicode     *pDest,
 503                                const sal_Char  *pSrc
 504                              )
 505 {
 506     sal_Bool    bCopied = sal_False;
 507     sal_uInt32  nCount  = AStringLen( pSrc );
 508     sal_uInt32  nLen    = nCount;
 509
 510     if (    ( pDest != NULL )
 511          && ( pSrc  != NULL )
 512          && ( AStringNIsValid( pSrc, nLen ) )
 513        )
 514     {
 515         while ( nCount >= 0 )
 516         {
 517             *pDest = (unsigned char)*pSrc;
 518
 519             pDest++;
 520             pSrc++;
 521
 522             // Since we are dealing with unsigned integers
 523             // we want to make sure that the last number is
 524             // indeed zero.
 525
 526             if ( nCount > 0 )
 527             {
 528                 nCount--;
 529             } // if
 530             else
 531             {
 532                 break;
 533             } // else
 534         } // while
 535
 536         if ( nCount == 0 )
 537         {
 538             bCopied = sal_True;
 539         } // if
 540     } // if
 541
 542     return  bCopied;
 543 } // AStringToUStringCopy
 544
 545 //------------------------------------------------------------------------
 546
 547 sal_Bool AStringToUStringNCopy( sal_Unicode       *pDest,
 548                                 const sal_Char    *pSrc,
 549                                 const sal_uInt32   nSrcLen
 550                               )
 551 {
 552     sal_Bool    bCopied = sal_False;
 553     sal_uInt32  nCount  = nSrcLen;
 554     sal_uInt32  nLen    = nSrcLen;
 555
 556     if (    ( pDest != NULL )
 557          && ( pSrc  != NULL )
 558          && ( AStringNIsValid( pSrc, nLen ) )
 559        )
 560     {
 561         while ( nCount >= 0 )
 562         {
 563             *pDest = (unsigned char)*pSrc;
 564
 565             pDest++;
 566             pSrc++;
 567
 568             // Since we are dealing with unsigned integers
 569             // we want to make sure that the last number is
 570             // indeed zero.
 571
 572             if ( nCount > 0 )
 573             {
 574                 nCount--;
 575             } // if
 576             else
 577             {
 578                 break;
 579             } // else
 580         } // while
 581
 582         if ( nCount == 0 )
 583         {
 584             bCopied = sal_True;
 585         } // if
 586     } // if
 587
 588     return  bCopied;
 589 } // AStringToUStringNCopy
 590
 591 //------------------------------------------------------------------------
 592 //------------------------------------------------------------------------
 593