rsc/source/tools/rsctools.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: rsctools.cxx,v $
  10  * $Revision: 1.17 $
  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_rsc.hxx"
  33 /****************** I N C L U D E S **************************************/
  34
  35 // C and C++ Includes.
  36 #include <stdlib.h>
  37 #include <stdio.h>
  38 #if defined ( DOS ) || defined ( WIN ) || defined (WNT )
  39 #include <direct.h>
  40 #endif
  41 #if defined ( OS2 ) && !defined ( GCC )
  42 #include <direct.h>
  43 #endif
  44 #include <string.h>
  45 #include <ctype.h>
  46
  47 #include <tools/fsys.hxx>
  48
  49 // Include
  50 #include <rscdef.hxx>
  51 #include <rsctools.hxx>
  52
  53 #include <osl/file.h>
  54 #include <rtl/alloc.h>
  55 #include <rtl/memory.h>
  56
  57 #if defined (WIN)
  58 #define ONLY_NEW
  59 #endif
  60
  61 using namespace rtl;
  62
  63 /****************** C o d e **********************************************/
  64 /*************************************************************************
  65 |*
  66 |*        rsc_strnicmp()
  67 |*
  68 |*        Beschreibung          Vergleicht zwei Strings Case-Unabhaengig bis zu
  69 |*                                              einer bestimmten Laenge
  70 |*        Ersterstellung        MM 13.02.91
  71 |*        Letzte Aenderung      MM 13.02.91
  72 |*
  73 *************************************************************************/
  74 int rsc_strnicmp( const char *string1, const char *string2, size_t count )
  75 {
  76     size_t i;
  77
  78     for( i = 0; ( i < count ) && string1[ i ] && string2[ i ] ; i++ )
  79     {
  80         if( tolower( string1[ i ] ) < tolower( string2[ i ] ) )
  81             return( -1 );
  82         else if( tolower( string1[ i ] ) > tolower( string2[ i ] ) )
  83             return( 1 );
  84     }
  85     if( i == count )
  86         return( 0 );
  87     else if( tolower( string1[ i ] ) < tolower( string2[ i ] ) )
  88         return( -1 );
  89     else if( tolower( string1[ i ] ) > tolower( string2[ i ] ) )
  90         return( 1 );
  91     return( 0 );
  92 }
  93
  94 /*************************************************************************
  95 |*
  96 |*        rsc_strnicmp()
  97 |*
  98 |*        Beschreibung          Vergleicht zwei Strings Case-Unabhaengig
  99 |*        Ersterstellung        MM 13.02.91
 100 |*        Letzte Aenderung      MM 13.02.91
 101 |*
 102 *************************************************************************/
 103 int rsc_stricmp( const char *string1, const char *string2 ){
 104     int i;
 105
 106     for( i = 0; string1[ i ] && string2[ i ]; i++ ){
 107         if( tolower( string1[ i ] ) < tolower( string2[ i ] ) )
 108             return( -1 );
 109         else if( tolower( string1[ i ] ) > tolower( string2[ i ] ) )
 110             return( 1 );
 111     }
 112     if( tolower( string1[ i ] ) < tolower( string2[ i ] ) )
 113         return( -1 );
 114     else if( tolower( string1[ i ] ) > tolower( string2[ i ] ) )
 115         return( 1 );
 116     return( 0 );
 117 }
 118
 119 char* rsc_strdup( const char* pStr )
 120 {
 121     int nLen = strlen( pStr );
 122     char* pBuffer = (char*)rtl_allocateMemory( nLen+1 );
 123     rtl_copyMemory( pBuffer, pStr, nLen+1 );
 124     return pBuffer;
 125 }
 126
 127 /*************************************************************************
 128 |*
 129 |*        GetTmpFileName()
 130 |*
 131 |*        Beschreibung          Gibt einen String eines eindeutigen Dateinamens
 132 |*                                              zurueck. Der Speicher fuer den String wird mit
 133 |*                                              malloc allokiert
 134 |*        Ersterstellung        MM 13.02.91
 135 |*        Letzte Aenderung      MH 13.10.97
 136 |*
 137 *************************************************************************/
 138 ByteString GetTmpFileName()
 139 {
 140     OUString aTmpURL, aTmpFile;
 141     osl_createTempFile( NULL, NULL, &aTmpURL.pData );
 142     osl_getSystemPathFromFileURL( aTmpURL.pData, &aTmpFile.pData );
 143     return OUStringToOString( aTmpFile, RTL_TEXTENCODING_MS_1252 );
 144 }
 145
 146 /********************************************************************/
 147 /*                                                                                                                                      */
 148 /*      Function        :       Append( )                                                                               */
 149 /*                                                                                                                                      */
 150 /*      Parameters      :       psw     - pointer to a preprocessor switch              */
 151 /*                                                                                                                                      */
 152 /*      Description :   appends text files                                                              */
 153 /********************************************************************/
 154 BOOL Append( FILE * fDest, ByteString aTmpFile )
 155 {
 156 #define MAX_BUF 4096
 157     char        szBuf[ MAX_BUF ];
 158     int     nItems;
 159     FILE        *fSource;
 160
 161     fSource = fopen( aTmpFile.GetBuffer(), "rb" );
 162     if( !fDest || !fSource ){
 163         if( fSource )
 164             fclose( fSource );
 165         return FALSE;
 166     }
 167     else{
 168         do{ // append
 169             nItems = fread( szBuf, sizeof( char ), MAX_BUF, fSource );
 170             fwrite( szBuf, sizeof( char ), nItems, fDest );
 171         } while( MAX_BUF == nItems );
 172
 173         fclose( fSource );
 174     };
 175     return TRUE;
 176 }
 177
 178 BOOL Append( ByteString aOutputSrs, ByteString aTmpFile )
 179 {
 180     FILE * fDest   = fopen( aOutputSrs.GetBuffer(), "ab" );
 181
 182     BOOL bRet = Append( fDest, aTmpFile );
 183
 184     if( fDest )
 185         fclose( fDest );
 186
 187     return bRet;
 188 }
 189
 190 /*************************************************************************
 191 |*
 192 |*        InputFile
 193 |*
 194 |*        Beschreibung          Haengt Extension an, wenn keine da ist
 195 |*        Parameter:            pInput, der Input-Dateiname.
 196 |*                                              pExt, die Extension des Ausgabenamens
 197 |*        Ersterstellung        MM 13.02.91
 198 |*        Letzte Aenderung      MM 28.06.91
 199 |*
 200 *************************************************************************/
 201 ByteString InputFile ( const char * pInput, const char * pExt )
 202 {
 203     UniString aUniInput( pInput, RTL_TEXTENCODING_ASCII_US );
 204     DirEntry aFileName( aUniInput );
 205
 206     if ( 0 == aFileName.GetExtension().Len() )
 207     {
 208         UniString aExt( pExt, RTL_TEXTENCODING_ASCII_US );
 209         aFileName.SetExtension( aExt );
 210     }
 211
 212     return ByteString( aFileName.GetFull(), RTL_TEXTENCODING_ASCII_US );
 213 }
 214
 215 /*************************************************************************
 216 |*
 217 |*        OutputFile
 218 |*
 219 |*        Beschreibung          Ersetzt Extension durch eine andere
 220 |*        Parameter:            input, der Input-Dateiname.
 221 |*                                              pExt, die Extension des Ausgabenamens
 222 |*        Ersterstellung        MM 13.02.91
 223 |*        Letzte Aenderung      MM 28.06.91
 224 |*
 225 *************************************************************************/
 226 ByteString OutputFile ( ByteString aInput, const char * pExt )
 227 {
 228     UniString   aUniInput( aInput, RTL_TEXTENCODING_ASCII_US );
 229     DirEntry    aFileName( aUniInput );
 230
 231     UniString aExt( pExt, RTL_TEXTENCODING_ASCII_US );
 232     aFileName.SetExtension( aExt );
 233
 234     return ByteString( aFileName.GetFull(), RTL_TEXTENCODING_ASCII_US );
 235 }
 236
 237 /*************************************************************************
 238 |*
 239 |*        ::ResonseFile()
 240 |*
 241 |*        Beschreibung          Kommandozeile aufbereiten
 242 |*        Ersterstellung        MM 05.09.91
 243 |*        Letzte Aenderung      MM 05.09.91
 244 |*
 245 *************************************************************************/
 246 char * ResponseFile( RscPtrPtr * ppCmd, char ** ppArgv, sal_uInt32 nArgc )
 247 {
 248     FILE        *fFile;
 249     int         nItems;
 250     char        szBuffer[4096];           // file buffer
 251     sal_uInt32  i;
 252     bool bInQuotes = false;
 253
 254     // Programmname
 255     ppCmd->Append( rsc_strdup( *ppArgv ) );
 256     for( i = 1; i < nArgc; i++ )
 257     {
 258         if( '@' == **(ppArgv +i) ){ // wenn @, dann Response-Datei
 259             if( NULL == (fFile = fopen( (*(ppArgv +i)) +1, "r" )) )
 260                 return( (*(ppArgv +i)) );
 261             nItems = fread( &szBuffer[ 0 ], 1, sizeof( char ), fFile );
 262             while( nItems )
 263             {
 264                 if( !isspace( szBuffer[ 0 ] ) )
 265                 {
 266                     /*
 267                      *  #i27914# double ticks '"' now have a duplicate function:
 268                      *  1. they define a string ( e.g. -DFOO="baz" )
 269                      *  2. a string can contain spaces, so -DFOO="baz zum" defines one
 270                      *  argument no two !
 271                      */
 272                     unsigned int n = 0;
 273                     while( nItems && (!isspace( szBuffer[ n ] ) || bInQuotes) &&
 274                            n +1 < sizeof( szBuffer )  )
 275                     {
 276                         n++;
 277                         nItems = fread( &szBuffer[ n ], 1,
 278                                         sizeof( char ), fFile );
 279                         if( szBuffer[n] == '"' )
 280                             bInQuotes = !bInQuotes;
 281                     }
 282                     szBuffer[ n ] = '\0';
 283                     ppCmd->Append( rsc_strdup( szBuffer ) );
 284                 }
 285                 nItems = fread( &szBuffer[ 0 ], 1, sizeof( char ), fFile );
 286             };
 287
 288             fclose( fFile );
 289         }
 290         else
 291             ppCmd->Append( rsc_strdup( *(ppArgv +i) ) );
 292     };
 293     ppCmd->Append( (void *)0 );
 294     return( NULL );
 295 }
 296
 297
 298 /*************** R s c P t r P t r **************************************/
 299 /*************************************************************************
 300 |*
 301 |*        RscPtrPtr :: RscPtrPtr()
 302 |*
 303 |*        Beschreibung          Eine Tabelle mit Zeigern
 304 |*        Ersterstellung        MM 13.02.91
 305 |*        Letzte Aenderung      MM 13.02.91
 306 |*
 307 *************************************************************************/
 308 RscPtrPtr :: RscPtrPtr(){
 309     nCount = 0;
 310     pMem = NULL;
 311 }
 312
 313 /*************************************************************************
 314 |*
 315 |*        RscPtrPtr :: ~RscPtrPtr()
 316 |*
 317 |*        Beschreibung          Zerst�rt eine Tabelle mit Zeigern, die Zeiger werde
 318 |*                                              ebenfalls freigegebn
 319 |*        Ersterstellung        MM 13.02.91
 320 |*        Letzte Aenderung      MM 13.02.91
 321 |*
 322 *************************************************************************/
 323 RscPtrPtr :: ~RscPtrPtr(){
 324     Reset();
 325 }
 326
 327 /*************************************************************************
 328 |*
 329 |*        RscPtrPtr :: Reset()
 330 |*
 331 |*        Beschreibung
 332 |*        Ersterstellung        MM 03.05.91
 333 |*        Letzte Aenderung      MM 03.05.91
 334 |*
 335 *************************************************************************/
 336 void RscPtrPtr :: Reset(){
 337     sal_uInt32 i;
 338
 339     if( pMem ){
 340         for( i = 0; i < nCount; i++ ){
 341             if( pMem[ i ] )
 342                rtl_freeMemory( pMem[ i ] );
 343         }
 344         rtl_freeMemory( (void *)pMem );
 345     };
 346     nCount = 0;
 347     pMem = NULL;
 348 }
 349
 350 /*************************************************************************
 351 |*
 352 |*        RscPtrPtr :: Append()
 353 |*
 354 |*        Beschreibung          Haengt einen Eintrag an.
 355 |*        Ersterstellung        MM 13.02.91
 356 |*        Letzte Aenderung      MM 13.02.91
 357 |*
 358 *************************************************************************/
 359 sal_uInt32 RscPtrPtr :: Append( void * pBuffer ){
 360     if( !pMem )
 361         pMem = (void **)rtl_allocateMemory( (nCount +1) * sizeof( void * ) );
 362     else
 363         pMem = (void **)rtl_reallocateMemory( (void *)pMem,
 364                          ((nCount +1) * sizeof( void * )
 365                        ) );
 366     pMem[ nCount ] = pBuffer;
 367     return( nCount++ );
 368 }
 369
 370 /*************************************************************************
 371 |*
 372 |*        RscPtrPtr :: GetEntry()
 373 |*
 374 |*        Beschreibung          Liefert einen Eintrag, NULL wenn nicht vorhanden.
 375 |*        Ersterstellung        MM 13.02.91
 376 |*        Letzte Aenderung      MM 13.02.91
 377 |*
 378 *************************************************************************/
 379 void * RscPtrPtr :: GetEntry( sal_uInt32 nEntry ){
 380     if( nEntry < nCount )
 381         return( pMem[ nEntry ] );
 382     return( NULL );
 383 }
 384
 385 /****************** R S C W R I T E R C **********************************/
 386 /*************************************************************************
 387 |*
 388 |*        RscWriteRc :: RscWriteRc()
 389 |*
 390 |*        Beschreibung
 391 |*        Ersterstellung        MM 15.04.91
 392 |*        Letzte Aenderung      MM 15.04.91
 393 |*
 394 *************************************************************************/
 395 RscWriteRc::RscWriteRc( RSCBYTEORDER_TYPE nOrder )
 396 {
 397     short                               nSwapTest = 1;
 398     RSCBYTEORDER_TYPE   nMachineOrder;
 399
 400     bSwap = FALSE;
 401     if( nOrder != RSC_SYSTEMENDIAN )
 402     {
 403         if( (BYTE)*(BYTE *)&nSwapTest )
 404             nMachineOrder = RSC_LITTLEENDIAN;
 405         else
 406             nMachineOrder = RSC_BIGENDIAN;
 407         bSwap = nOrder != nMachineOrder;
 408     }
 409     nByteOrder = nOrder;
 410     nLen = 0;
 411     pMem = NULL;
 412 }
 413
 414 /*************************************************************************
 415 |*
 416 |*        RscWriteRc :: ~RscWriteRc()
 417 |*
 418 |*        Beschreibung
 419 |*        Ersterstellung        MM 15.04.91
 420 |*        Letzte Aenderung      MM 15.04.91
 421 |*
 422 *************************************************************************/
 423 RscWriteRc :: ~RscWriteRc()
 424 {
 425     if( pMem )
 426         rtl_freeMemory( pMem );
 427 }
 428
 429 /*************************************************************************
 430 |*
 431 |*        RscWriteRc :: IncSize()
 432 |*
 433 |*        Beschreibung
 434 |*        Ersterstellung        MM 15.04.91
 435 |*        Letzte Aenderung      MM 15.04.91
 436 |*
 437 *************************************************************************/
 438 sal_uInt32 RscWriteRc :: IncSize( sal_uInt32 nSize )
 439 {
 440     nLen += nSize;
 441     if( pMem )
 442         pMem = (char*)rtl_reallocateMemory( pMem, nLen );
 443     return( nLen - nSize );
 444 }
 445
 446 /*************************************************************************
 447 |*
 448 |*        RscWriteRc :: GetPointer()
 449 |*
 450 |*        Beschreibung
 451 |*        Ersterstellung        MM 15.04.91
 452 |*        Letzte Aenderung      MM 15.04.91
 453 |*
 454 *************************************************************************/
 455 char * RscWriteRc :: GetPointer( sal_uInt32 nSize )
 456 {
 457     if( !pMem )
 458         pMem = (char *)rtl_allocateMemory( nLen );
 459     return( pMem + nSize );
 460 }
 461
 462
 463 /*************************************************************************
 464 |*
 465 |*        RscWriteRc :: Put()
 466 |*
 467 |*        Beschreibung
 468 |*        Ersterstellung        MM 15.04.91
 469 |*        Letzte Aenderung      MM 15.04.91
 470 |*
 471 *************************************************************************/
 472 void RscWriteRc :: Put( sal_uInt16 nVal )
 473 {
 474     sal_uInt32  nOldLen;
 475
 476     nOldLen = IncSize( sizeof( nVal ) );
 477     PutAt( nOldLen, nVal );
 478 }
 479
 480 void RscWriteRc :: PutUTF8( char * pStr )
 481 {
 482     sal_uInt32 nStrLen = 0;
 483     if( pStr )
 484         nStrLen = strlen( pStr );
 485
 486     sal_uInt32  n = nStrLen +1;
 487     if( n % 2 )
 488         // align to 2
 489         n++;
 490
 491     sal_uInt32  nOldLen = IncSize( n );
 492     rtl_copyMemory( GetPointer( nOldLen ), pStr, nStrLen );
 493     // 0 terminated
 494     pMem[ nOldLen + nStrLen ] = '\0';
 495 }