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