LCOV - code coverage report
Current view: top level - libreoffice/rsc/source/tools - rsctools.cxx (source / functions) Hit Total Coverage
Test: libreoffice_filtered.info Lines: 122 147 83.0 %
Date: 2012-12-27 Functions: 17 19 89.5 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
       2             : /*
       3             :  * This file is part of the LibreOffice project.
       4             :  *
       5             :  * This Source Code Form is subject to the terms of the Mozilla Public
       6             :  * License, v. 2.0. If a copy of the MPL was not distributed with this
       7             :  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
       8             :  *
       9             :  * This file incorporates work covered by the following license notice:
      10             :  *
      11             :  *   Licensed to the Apache Software Foundation (ASF) under one or more
      12             :  *   contributor license agreements. See the NOTICE file distributed
      13             :  *   with this work for additional information regarding copyright
      14             :  *   ownership. The ASF licenses this file to you under the Apache
      15             :  *   License, Version 2.0 (the "License"); you may not use this file
      16             :  *   except in compliance with the License. You may obtain a copy of
      17             :  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
      18             :  */
      19             : 
      20             : /****************** I N C L U D E S **************************************/
      21             : 
      22             : // C and C++ Includes.
      23             : #include <stdlib.h>
      24             : #include <stdio.h>
      25             : #if defined (WNT )
      26             : #include <direct.h>
      27             : #endif
      28             : #include <string.h>
      29             : #include <ctype.h>
      30             : 
      31             : #include <tools/fsys.hxx>
      32             : 
      33             : // Include
      34             : #include <rscdef.hxx>
      35             : #include <rsctools.hxx>
      36             : 
      37             : #include <osl/file.h>
      38             : #include <rtl/alloc.h>
      39             : 
      40             : using ::rtl::OUString;
      41             : using ::rtl::OUStringToOString;
      42             : 
      43             : /****************** C o d e **********************************************/
      44             : /*************************************************************************
      45             : |*
      46             : |*    rsc_strnicmp()
      47             : |*
      48             : |*    Beschreibung      Vergleicht zwei Strings Case-Unabhaengig bis zu
      49             : |*                      einer bestimmten Laenge
      50             : |*
      51             : *************************************************************************/
      52      280884 : int rsc_strnicmp( const char *string1, const char *string2, size_t count )
      53             : {
      54             :     size_t i;
      55             : 
      56      476066 :     for( i = 0; ( i < count ) && string1[ i ] && string2[ i ] ; i++ )
      57             :     {
      58      434394 :         if( tolower( string1[ i ] ) < tolower( string2[ i ] ) )
      59      170153 :             return( -1 );
      60      264241 :         else if( tolower( string1[ i ] ) > tolower( string2[ i ] ) )
      61       69059 :             return( 1 );
      62             :     }
      63       41672 :     if( i == count )
      64       41550 :         return( 0 );
      65         122 :     else if( tolower( string1[ i ] ) < tolower( string2[ i ] ) )
      66         122 :         return( -1 );
      67           0 :     else if( tolower( string1[ i ] ) > tolower( string2[ i ] ) )
      68           0 :         return( 1 );
      69           0 :     return( 0 );
      70             : }
      71             : 
      72             : /*************************************************************************
      73             : |*
      74             : |*    rsc_strnicmp()
      75             : |*
      76             : |*    Beschreibung      Vergleicht zwei Strings Case-Unabhaengig
      77             : |*
      78             : *************************************************************************/
      79      464115 : int rsc_stricmp( const char *string1, const char *string2 ){
      80             :     int i;
      81             : 
      82      655676 :     for( i = 0; string1[ i ] && string2[ i ]; i++ ){
      83      652322 :         if( tolower( string1[ i ] ) < tolower( string2[ i ] ) )
      84      344250 :             return( -1 );
      85      308072 :         else if( tolower( string1[ i ] ) > tolower( string2[ i ] ) )
      86      116511 :             return( 1 );
      87             :     }
      88        3354 :     if( tolower( string1[ i ] ) < tolower( string2[ i ] ) )
      89         630 :         return( -1 );
      90        2724 :     else if( tolower( string1[ i ] ) > tolower( string2[ i ] ) )
      91        1911 :         return( 1 );
      92         813 :     return( 0 );
      93             : }
      94             : 
      95       88916 : char* rsc_strdup( const char* pStr )
      96             : {
      97       88916 :     int nLen = strlen( pStr );
      98       88916 :     char* pBuffer = (char*)rtl_allocateMemory( nLen+1 );
      99       88916 :     memcpy( pBuffer, pStr, nLen+1 );
     100       88916 :     return pBuffer;
     101             : }
     102             : 
     103             : /*************************************************************************
     104             : |*
     105             : |*    GetTmpFileName()
     106             : |*
     107             : |*    Beschreibung      Gibt einen String eines eindeutigen Dateinamens
     108             : |*                      zurueck. Der Speicher fuer den String wird mit
     109             : |*                      malloc allokiert
     110             : |*
     111             : *************************************************************************/
     112        1952 : rtl::OString GetTmpFileName()
     113             : {
     114        1952 :     OUString aTmpURL, aTmpFile;
     115        1952 :     osl_createTempFile( NULL, NULL, &aTmpURL.pData );
     116        1952 :     osl_getSystemPathFromFileURL( aTmpURL.pData, &aTmpFile.pData );
     117        1952 :     return OUStringToOString( aTmpFile, RTL_TEXTENCODING_MS_1252 );
     118             : }
     119             : 
     120             : /********************************************************************/
     121             : /*                                                                  */
     122             : /*  Function    :   Append( )                                       */
     123             : /*                                                                  */
     124             : /*  Parameters  :   psw     - pointer to a preprocessor switch      */
     125             : /*                                                                  */
     126             : /*  Description :   appends text files                              */
     127             : /********************************************************************/
     128           0 : sal_Bool Append(FILE * fDest, const rtl::OString &rTmpFile)
     129             : {
     130             : #define MAX_BUF 4096
     131           0 :     FILE *fSource = fopen(rTmpFile.getStr(), "rb");
     132           0 :     if( !fDest || !fSource )
     133             :     {
     134           0 :         if( fSource )
     135           0 :             fclose( fSource );
     136           0 :         return sal_False;
     137             :     }
     138             : 
     139           0 :     bool bSuccess = true;
     140             :     char szBuf[ MAX_BUF ];
     141             :     size_t nItems;
     142             : 
     143           0 :     do //appemd
     144             :     {
     145           0 :         nItems = fread( szBuf, 1, MAX_BUF, fSource );
     146           0 :         bSuccess = (nItems == fwrite(szBuf, 1, nItems, fDest));
     147             :         SAL_WARN_IF(!bSuccess, "rsc", "short write");
     148             :     } while (MAX_BUF == nItems && bSuccess);
     149             : 
     150           0 :     fclose( fSource );
     151           0 :     return bSuccess;
     152             : }
     153             : 
     154           0 : sal_Bool Append(const rtl::OString &rOutputSrs, const rtl::OString &rTmpFile)
     155             : {
     156           0 :     FILE * fDest = fopen(rOutputSrs.getStr(), "ab");
     157             : 
     158           0 :     sal_Bool bRet = Append(fDest, rTmpFile);
     159             : 
     160           0 :     if( fDest )
     161           0 :         fclose( fDest );
     162             : 
     163           0 :     return bRet;
     164             : }
     165             : 
     166             : /*************************************************************************
     167             : |*
     168             : |*    OutputFile
     169             : |*
     170             : |*    Beschreibung      Ersetzt Extension durch eine andere
     171             : |*    Parameter:        input, der Input-Dateiname.
     172             : |*                      pExt, die Extension des Ausgabenamens
     173             : |*
     174             : *************************************************************************/
     175        1382 : rtl::OString OutputFile(const rtl::OString &rInput, const char * pExt)
     176             : {
     177        1382 :     rtl::OUString aUniInput(rtl::OStringToOUString(rInput, RTL_TEXTENCODING_ASCII_US));
     178        1382 :     DirEntry aFileName(aUniInput);
     179             : 
     180        1382 :     UniString aExt( pExt, RTL_TEXTENCODING_ASCII_US );
     181        1382 :     aFileName.SetExtension( aExt );
     182             : 
     183        1382 :     return rtl::OUStringToOString(aFileName.GetFull(), RTL_TEXTENCODING_ASCII_US);
     184             : }
     185             : 
     186             : /*************************************************************************
     187             : |*
     188             : |*    ::ResonseFile()
     189             : |*
     190             : |*    Beschreibung      Kommandozeile aufbereiten
     191             : |*
     192             : *************************************************************************/
     193        1382 : char * ResponseFile( RscPtrPtr * ppCmd, char ** ppArgv, sal_uInt32 nArgc )
     194             : {
     195             :     FILE    *fFile;
     196             :     int     nItems;
     197             :     char    szBuffer[4096];       // file buffer
     198             :     sal_uInt32  i;
     199        1382 :     bool bInQuotes = false;
     200             : 
     201             :     // Programmname
     202        1382 :     ppCmd->Append( rsc_strdup( *ppArgv ) );
     203       24343 :     for( i = 1; i < nArgc; i++ )
     204             :     {
     205       22961 :         if( '@' == **(ppArgv +i) ){ // wenn @, dann Response-Datei
     206         691 :             if( NULL == (fFile = fopen( (*(ppArgv +i)) +1, "r" )) )
     207           0 :                 return( (*(ppArgv +i)) );
     208         691 :             nItems = fread( &szBuffer[ 0 ], 1, sizeof( char ), fFile );
     209       24261 :             while( nItems )
     210             :             {
     211       22879 :                 if( !isspace( szBuffer[ 0 ] ) )
     212             :                 {
     213             :                     /*
     214             :                      *  #i27914# double ticks '"' now have a duplicate function:
     215             :                      *  1. they define a string ( e.g. -DFOO="baz" )
     216             :                      *  2. a string can contain spaces, so -DFOO="baz zum" defines one
     217             :                      *  argument no two !
     218             :                      */
     219       21640 :                     unsigned int n = 0;
     220      725100 :                     while( nItems && (!isspace( szBuffer[ n ] ) || bInQuotes) &&
     221             :                            n +1 < sizeof( szBuffer )  )
     222             :                     {
     223      681820 :                         n++;
     224             :                         nItems = fread( &szBuffer[ n ], 1,
     225      681820 :                                         sizeof( char ), fFile );
     226      681820 :                         if( szBuffer[n] == '"' )
     227           0 :                             bInQuotes = !bInQuotes;
     228             :                     }
     229       21640 :                     szBuffer[ n ] = '\0';
     230       21640 :                     ppCmd->Append( rsc_strdup( szBuffer ) );
     231             :                 }
     232       22879 :                 nItems = fread( &szBuffer[ 0 ], 1, sizeof( char ), fFile );
     233             :             };
     234             : 
     235         691 :             fclose( fFile );
     236             :         }
     237             :         else
     238       22270 :             ppCmd->Append( rsc_strdup( *(ppArgv +i) ) );
     239             :     };
     240        1382 :     ppCmd->Append( (void *)0 );
     241        1382 :     return( NULL );
     242             : }
     243             : 
     244             : 
     245             : /*************** R s c P t r P t r **************************************/
     246             : /*************************************************************************
     247             : |*
     248             : |*    RscPtrPtr :: RscPtrPtr()
     249             : |*
     250             : |*    Beschreibung      Eine Tabelle mit Zeigern
     251             : |*
     252             : *************************************************************************/
     253        3333 : RscPtrPtr :: RscPtrPtr(){
     254        3333 :     nCount = 0;
     255        3333 :     pMem = NULL;
     256        3333 : }
     257             : 
     258             : /*************************************************************************
     259             : |*
     260             : |*    RscPtrPtr :: ~RscPtrPtr()
     261             : |*
     262             : |*    Beschreibung      Zerst�rt eine Tabelle mit Zeigern, die Zeiger werde
     263             : |*                      ebenfalls freigegebn
     264             : |*
     265             : *************************************************************************/
     266        3333 : RscPtrPtr :: ~RscPtrPtr(){
     267        3333 :     Reset();
     268        3333 : }
     269             : 
     270             : /*************************************************************************
     271             : |*
     272             : |*    RscPtrPtr :: Reset()
     273             : |*
     274             : *************************************************************************/
     275        3333 : void RscPtrPtr :: Reset(){
     276             :     sal_uInt32 i;
     277             : 
     278        3333 :     if( pMem ){
     279       94891 :         for( i = 0; i < nCount; i++ ){
     280       91558 :             if( pMem[ i ] )
     281       88916 :                rtl_freeMemory( pMem[ i ] );
     282             :         }
     283        3333 :         rtl_freeMemory( (void *)pMem );
     284             :     };
     285        3333 :     nCount = 0;
     286        3333 :     pMem = NULL;
     287        3333 : }
     288             : 
     289             : /*************************************************************************
     290             : |*
     291             : |*    RscPtrPtr :: Append()
     292             : |*
     293             : |*    Beschreibung      Haengt einen Eintrag an.
     294             : |*
     295             : *************************************************************************/
     296       91558 : sal_uInt32 RscPtrPtr :: Append( void * pBuffer ){
     297       91558 :     if( !pMem )
     298        3333 :         pMem = (void **)rtl_allocateMemory( (nCount +1) * sizeof( void * ) );
     299             :     else
     300             :         pMem = (void **)rtl_reallocateMemory( (void *)pMem,
     301             :                          ((nCount +1) * sizeof( void * )
     302       88225 :                        ) );
     303       91558 :     pMem[ nCount ] = pBuffer;
     304       91558 :     return( nCount++ );
     305             : }
     306             : 
     307             : /*************************************************************************
     308             : |*
     309             : |*    RscPtrPtr :: GetEntry()
     310             : |*
     311             : |*    Beschreibung      Liefert einen Eintrag, NULL wenn nicht vorhanden.
     312             : |*
     313             : *************************************************************************/
     314      371001 : void * RscPtrPtr :: GetEntry( sal_uInt32 nEntry ){
     315      371001 :     if( nEntry < nCount )
     316      371001 :         return( pMem[ nEntry ] );
     317           0 :     return( NULL );
     318             : }
     319             : 
     320             : /****************** R S C W R I T E R C **********************************/
     321             : /*************************************************************************
     322             : |*
     323             : |*    RscWriteRc :: RscWriteRc()
     324             : |*
     325             : *************************************************************************/
     326       44684 : RscWriteRc::RscWriteRc( RSCBYTEORDER_TYPE nOrder )
     327             : {
     328       44684 :     short               nSwapTest = 1;
     329             :     RSCBYTEORDER_TYPE   nMachineOrder;
     330             : 
     331       44684 :     bSwap = sal_False;
     332       44684 :     if( nOrder != RSC_SYSTEMENDIAN )
     333             :     {
     334        9489 :         if( (sal_uInt8)*(sal_uInt8 *)&nSwapTest )
     335        9489 :             nMachineOrder = RSC_LITTLEENDIAN;
     336             :         else
     337           0 :             nMachineOrder = RSC_BIGENDIAN;
     338        9489 :         bSwap = nOrder != nMachineOrder;
     339             :     }
     340       44684 :     nByteOrder = nOrder;
     341       44684 :     nLen = 0;
     342       44684 :     pMem = NULL;
     343       44684 : }
     344             : 
     345             : /*************************************************************************
     346             : |*
     347             : |*    RscWriteRc :: ~RscWriteRc()
     348             : |*
     349             : *************************************************************************/
     350       44684 : RscWriteRc :: ~RscWriteRc()
     351             : {
     352       44684 :     if( pMem )
     353       44684 :         rtl_freeMemory( pMem );
     354       44684 : }
     355             : 
     356             : /*************************************************************************
     357             : |*
     358             : |*    RscWriteRc :: IncSize()
     359             : |*
     360             : *************************************************************************/
     361      466579 : sal_uInt32 RscWriteRc :: IncSize( sal_uInt32 nSize )
     362             : {
     363      466579 :     nLen += nSize;
     364      466579 :     if( pMem )
     365      412376 :         pMem = (char*)rtl_reallocateMemory( pMem, nLen );
     366      466579 :     return( nLen - nSize );
     367             : }
     368             : 
     369             : /*************************************************************************
     370             : |*
     371             : |*    RscWriteRc :: GetPointer()
     372             : |*
     373             : *************************************************************************/
     374      974288 : char * RscWriteRc :: GetPointer( sal_uInt32 nSize )
     375             : {
     376      974288 :     if( !pMem )
     377       44684 :         pMem = (char *)rtl_allocateMemory( nLen );
     378      974288 :     return( pMem + nSize );
     379             : }
     380             : 
     381             : 
     382             : /*************************************************************************
     383             : |*
     384             : |*    RscWriteRc :: Put()
     385             : |*
     386             : *************************************************************************/
     387      400074 : void RscWriteRc :: Put( sal_uInt16 nVal )
     388             : {
     389             :     sal_uInt32  nOldLen;
     390             : 
     391      400074 :     nOldLen = IncSize( sizeof( nVal ) );
     392      400074 :     PutAt( nOldLen, nVal );
     393      400074 : }
     394             : 
     395       36366 : void RscWriteRc :: PutUTF8( char * pStr )
     396             : {
     397       36366 :     sal_uInt32 nStrLen = 0;
     398       36366 :     if( pStr )
     399       35811 :         nStrLen = strlen( pStr );
     400             : 
     401       36366 :     sal_uInt32  n = nStrLen +1;
     402       36366 :     if( n % 2 )
     403             :         // align to 2
     404       18401 :         n++;
     405             : 
     406       36366 :     sal_uInt32  nOldLen = IncSize( n );
     407       36366 :     memcpy( GetPointer( nOldLen ), pStr, nStrLen );
     408             :     // 0 terminated
     409       36366 :     pMem[ nOldLen + nStrLen ] = '\0';
     410       36366 : }
     411             : 
     412             : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */

Generated by: LCOV version 1.10