Branch data 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 : : #include <rtl/memory.h>
40 : :
41 : : using ::rtl::OUString;
42 : : using ::rtl::OUStringToOString;
43 : :
44 : : /****************** C o d e **********************************************/
45 : : /*************************************************************************
46 : : |*
47 : : |* rsc_strnicmp()
48 : : |*
49 : : |* Beschreibung Vergleicht zwei Strings Case-Unabhaengig bis zu
50 : : |* einer bestimmten Laenge
51 : : |*
52 : : *************************************************************************/
53 : 661648 : int rsc_strnicmp( const char *string1, const char *string2, size_t count )
54 : : {
55 : : size_t i;
56 : :
57 [ + + ][ + + ]: 1120928 : for( i = 0; ( i < count ) && string1[ i ] && string2[ i ] ; i++ )
[ + - ][ + + ]
58 : : {
59 [ + + ]: 1022248 : if( tolower( string1[ i ] ) < tolower( string2[ i ] ) )
60 : 416880 : return( -1 );
61 [ + + ]: 605368 : else if( tolower( string1[ i ] ) > tolower( string2[ i ] ) )
62 : 146088 : return( 1 );
63 : : }
64 [ + + ]: 98680 : if( i == count )
65 : 98440 : return( 0 );
66 [ + - ]: 240 : else if( tolower( string1[ i ] ) < tolower( string2[ i ] ) )
67 : 240 : return( -1 );
68 [ # # ]: 0 : else if( tolower( string1[ i ] ) > tolower( string2[ i ] ) )
69 : 0 : return( 1 );
70 : 661648 : return( 0 );
71 : : }
72 : :
73 : : /*************************************************************************
74 : : |*
75 : : |* rsc_strnicmp()
76 : : |*
77 : : |* Beschreibung Vergleicht zwei Strings Case-Unabhaengig
78 : : |*
79 : : *************************************************************************/
80 : 1096416 : int rsc_stricmp( const char *string1, const char *string2 ){
81 : : int i;
82 : :
83 [ + + ][ + + ]: 1548216 : for( i = 0; string1[ i ] && string2[ i ]; i++ ){
[ + + ]
84 [ + + ]: 1541376 : if( tolower( string1[ i ] ) < tolower( string2[ i ] ) )
85 : 822440 : return( -1 );
86 [ + + ]: 718936 : else if( tolower( string1[ i ] ) > tolower( string2[ i ] ) )
87 : 267136 : return( 1 );
88 : : }
89 [ + + ]: 6840 : if( tolower( string1[ i ] ) < tolower( string2[ i ] ) )
90 : 1320 : return( -1 );
91 [ + + ]: 5520 : else if( tolower( string1[ i ] ) > tolower( string2[ i ] ) )
92 : 3840 : return( 1 );
93 : 1096416 : return( 0 );
94 : : }
95 : :
96 : 208886 : char* rsc_strdup( const char* pStr )
97 : : {
98 : 208886 : int nLen = strlen( pStr );
99 : 208886 : char* pBuffer = (char*)rtl_allocateMemory( nLen+1 );
100 : 208886 : rtl_copyMemory( pBuffer, pStr, nLen+1 );
101 : 208886 : return pBuffer;
102 : : }
103 : :
104 : : /*************************************************************************
105 : : |*
106 : : |* GetTmpFileName()
107 : : |*
108 : : |* Beschreibung Gibt einen String eines eindeutigen Dateinamens
109 : : |* zurueck. Der Speicher fuer den String wird mit
110 : : |* malloc allokiert
111 : : |*
112 : : *************************************************************************/
113 : 4082 : rtl::OString GetTmpFileName()
114 : : {
115 : 4082 : OUString aTmpURL, aTmpFile;
116 [ + - ]: 4082 : osl_createTempFile( NULL, NULL, &aTmpURL.pData );
117 [ + - ]: 4082 : osl_getSystemPathFromFileURL( aTmpURL.pData, &aTmpFile.pData );
118 [ + - ]: 4082 : return OUStringToOString( aTmpFile, RTL_TEXTENCODING_MS_1252 );
119 : : }
120 : :
121 : : /********************************************************************/
122 : : /* */
123 : : /* Function : Append( ) */
124 : : /* */
125 : : /* Parameters : psw - pointer to a preprocessor switch */
126 : : /* */
127 : : /* Description : appends text files */
128 : : /********************************************************************/
129 : 0 : sal_Bool Append(FILE * fDest, const rtl::OString &rTmpFile)
130 : : {
131 : : #define MAX_BUF 4096
132 [ # # ]: 0 : FILE *fSource = fopen(rTmpFile.getStr(), "rb");
133 [ # # ][ # # ]: 0 : if( !fDest || !fSource )
134 : : {
135 [ # # ]: 0 : if( fSource )
136 [ # # ]: 0 : fclose( fSource );
137 : 0 : return sal_False;
138 : : }
139 : :
140 : 0 : bool bSuccess = true;
141 : : char szBuf[ MAX_BUF ];
142 : : size_t nItems;
143 : :
144 [ # # ][ # # ]: 0 : do //appemd
[ # # ]
145 : : {
146 [ # # ]: 0 : nItems = fread( szBuf, 1, MAX_BUF, fSource );
147 [ # # ]: 0 : bSuccess = (nItems == fwrite(szBuf, 1, nItems, fDest));
148 : : SAL_WARN_IF(!bSuccess, "rsc", "short write");
149 : : } while (MAX_BUF == nItems && bSuccess);
150 : :
151 [ # # ]: 0 : fclose( fSource );
152 : 0 : return bSuccess;
153 : : }
154 : :
155 : 0 : sal_Bool Append(const rtl::OString &rOutputSrs, const rtl::OString &rTmpFile)
156 : : {
157 : 0 : FILE * fDest = fopen(rOutputSrs.getStr(), "ab");
158 : :
159 : 0 : sal_Bool bRet = Append(fDest, rTmpFile);
160 : :
161 [ # # ]: 0 : if( fDest )
162 : 0 : fclose( fDest );
163 : :
164 : 0 : return bRet;
165 : : }
166 : :
167 : : /*************************************************************************
168 : : |*
169 : : |* OutputFile
170 : : |*
171 : : |* Beschreibung Ersetzt Extension durch eine andere
172 : : |* Parameter: input, der Input-Dateiname.
173 : : |* pExt, die Extension des Ausgabenamens
174 : : |*
175 : : *************************************************************************/
176 : 2880 : rtl::OString OutputFile(const rtl::OString &rInput, const char * pExt)
177 : : {
178 [ + - ]: 2880 : rtl::OUString aUniInput(rtl::OStringToOUString(rInput, RTL_TEXTENCODING_ASCII_US));
179 [ + - ][ + - ]: 2880 : DirEntry aFileName(aUniInput);
[ + - ]
180 : :
181 [ + - ]: 2880 : UniString aExt( pExt, RTL_TEXTENCODING_ASCII_US );
182 [ + - ]: 2880 : aFileName.SetExtension( aExt );
183 : :
184 [ + - ][ + - ]: 2880 : return rtl::OUStringToOString(aFileName.GetFull(), RTL_TEXTENCODING_ASCII_US);
[ + - ][ + - ]
[ + - ][ + - ]
185 : : }
186 : :
187 : : /*************************************************************************
188 : : |*
189 : : |* ::ResonseFile()
190 : : |*
191 : : |* Beschreibung Kommandozeile aufbereiten
192 : : |*
193 : : *************************************************************************/
194 : 2880 : char * ResponseFile( RscPtrPtr * ppCmd, char ** ppArgv, sal_uInt32 nArgc )
195 : : {
196 : : FILE *fFile;
197 : : int nItems;
198 : : char szBuffer[4096]; // file buffer
199 : : sal_uInt32 i;
200 : 2880 : bool bInQuotes = false;
201 : :
202 : : // Programmname
203 [ + - ][ + - ]: 2880 : ppCmd->Append( rsc_strdup( *ppArgv ) );
204 [ + + ]: 56602 : for( i = 1; i < nArgc; i++ )
205 : : {
206 [ + + ]: 53722 : if( '@' == **(ppArgv +i) ){ // wenn @, dann Response-Datei
207 [ + - ][ - + ]: 1440 : if( NULL == (fFile = fopen( (*(ppArgv +i)) +1, "r" )) )
208 : 0 : return( (*(ppArgv +i)) );
209 [ + - ]: 1440 : nItems = fread( &szBuffer[ 0 ], 1, sizeof( char ), fFile );
210 [ + + ]: 55000 : while( nItems )
211 : : {
212 [ + + ]: 53560 : if( !isspace( szBuffer[ 0 ] ) )
213 : : {
214 : : /*
215 : : * #i27914# double ticks '"' now have a duplicate function:
216 : : * 1. they define a string ( e.g. -DFOO="baz" )
217 : : * 2. a string can contain spaces, so -DFOO="baz zum" defines one
218 : : * argument no two !
219 : : */
220 : 50962 : unsigned int n = 0;
221 [ + - ][ + + ]: 1662962 : while( nItems && (!isspace( szBuffer[ n ] ) || bInQuotes) &&
[ - + ][ + - ]
[ + + ]
222 : : n +1 < sizeof( szBuffer ) )
223 : : {
224 : 1612000 : n++;
225 : : nItems = fread( &szBuffer[ n ], 1,
226 [ + - ]: 1612000 : sizeof( char ), fFile );
227 [ - + ]: 1612000 : if( szBuffer[n] == '"' )
228 : 0 : bInQuotes = !bInQuotes;
229 : : }
230 : 50962 : szBuffer[ n ] = '\0';
231 [ + - ][ + - ]: 50962 : ppCmd->Append( rsc_strdup( szBuffer ) );
232 : : }
233 [ + - ]: 53560 : nItems = fread( &szBuffer[ 0 ], 1, sizeof( char ), fFile );
234 : : };
235 : :
236 [ + - ]: 1440 : fclose( fFile );
237 : : }
238 : : else
239 [ + - ][ + - ]: 52282 : ppCmd->Append( rsc_strdup( *(ppArgv +i) ) );
240 : : };
241 : 2880 : ppCmd->Append( (void *)0 );
242 : 2880 : return( NULL );
243 : : }
244 : :
245 : :
246 : : /*************** R s c P t r P t r **************************************/
247 : : /*************************************************************************
248 : : |*
249 : : |* RscPtrPtr :: RscPtrPtr()
250 : : |*
251 : : |* Beschreibung Eine Tabelle mit Zeigern
252 : : |*
253 : : *************************************************************************/
254 : 6960 : RscPtrPtr :: RscPtrPtr(){
255 : 6960 : nCount = 0;
256 : 6960 : pMem = NULL;
257 : 6960 : }
258 : :
259 : : /*************************************************************************
260 : : |*
261 : : |* RscPtrPtr :: ~RscPtrPtr()
262 : : |*
263 : : |* Beschreibung Zerst�rt eine Tabelle mit Zeigern, die Zeiger werde
264 : : |* ebenfalls freigegebn
265 : : |*
266 : : *************************************************************************/
267 : 6960 : RscPtrPtr :: ~RscPtrPtr(){
268 : 6960 : Reset();
269 : 6960 : }
270 : :
271 : : /*************************************************************************
272 : : |*
273 : : |* RscPtrPtr :: Reset()
274 : : |*
275 : : *************************************************************************/
276 : 6960 : void RscPtrPtr :: Reset(){
277 : : sal_uInt32 i;
278 : :
279 [ + - ]: 6960 : if( pMem ){
280 [ + + ]: 221366 : for( i = 0; i < nCount; i++ ){
281 [ + + ]: 214406 : if( pMem[ i ] )
282 : 208886 : rtl_freeMemory( pMem[ i ] );
283 : : }
284 : 6960 : rtl_freeMemory( (void *)pMem );
285 : : };
286 : 6960 : nCount = 0;
287 : 6960 : pMem = NULL;
288 : 6960 : }
289 : :
290 : : /*************************************************************************
291 : : |*
292 : : |* RscPtrPtr :: Append()
293 : : |*
294 : : |* Beschreibung Haengt einen Eintrag an.
295 : : |*
296 : : *************************************************************************/
297 : 214406 : sal_uInt32 RscPtrPtr :: Append( void * pBuffer ){
298 [ + + ]: 214406 : if( !pMem )
299 : 6960 : pMem = (void **)rtl_allocateMemory( (nCount +1) * sizeof( void * ) );
300 : : else
301 : : pMem = (void **)rtl_reallocateMemory( (void *)pMem,
302 : : ((nCount +1) * sizeof( void * )
303 : 207446 : ) );
304 : 214406 : pMem[ nCount ] = pBuffer;
305 : 214406 : return( nCount++ );
306 : : }
307 : :
308 : : /*************************************************************************
309 : : |*
310 : : |* RscPtrPtr :: GetEntry()
311 : : |*
312 : : |* Beschreibung Liefert einen Eintrag, NULL wenn nicht vorhanden.
313 : : |*
314 : : *************************************************************************/
315 : 878822 : void * RscPtrPtr :: GetEntry( sal_uInt32 nEntry ){
316 [ + - ]: 878822 : if( nEntry < nCount )
317 : 878822 : return( pMem[ nEntry ] );
318 : 878822 : return( NULL );
319 : : }
320 : :
321 : : /****************** R S C W R I T E R C **********************************/
322 : : /*************************************************************************
323 : : |*
324 : : |* RscWriteRc :: RscWriteRc()
325 : : |*
326 : : *************************************************************************/
327 : 98770 : RscWriteRc::RscWriteRc( RSCBYTEORDER_TYPE nOrder )
328 : : {
329 : 98770 : short nSwapTest = 1;
330 : : RSCBYTEORDER_TYPE nMachineOrder;
331 : :
332 : 98770 : bSwap = sal_False;
333 [ + + ]: 98770 : if( nOrder != RSC_SYSTEMENDIAN )
334 : : {
335 [ + - ]: 18492 : if( (sal_uInt8)*(sal_uInt8 *)&nSwapTest )
336 : 18492 : nMachineOrder = RSC_LITTLEENDIAN;
337 : : else
338 : 0 : nMachineOrder = RSC_BIGENDIAN;
339 : 18492 : bSwap = nOrder != nMachineOrder;
340 : : }
341 : 98770 : nByteOrder = nOrder;
342 : 98770 : nLen = 0;
343 : 98770 : pMem = NULL;
344 : 98770 : }
345 : :
346 : : /*************************************************************************
347 : : |*
348 : : |* RscWriteRc :: ~RscWriteRc()
349 : : |*
350 : : *************************************************************************/
351 : 98770 : RscWriteRc :: ~RscWriteRc()
352 : : {
353 [ + - ]: 98770 : if( pMem )
354 : 98770 : rtl_freeMemory( pMem );
355 : 98770 : }
356 : :
357 : : /*************************************************************************
358 : : |*
359 : : |* RscWriteRc :: IncSize()
360 : : |*
361 : : *************************************************************************/
362 : 1023420 : sal_uInt32 RscWriteRc :: IncSize( sal_uInt32 nSize )
363 : : {
364 : 1023420 : nLen += nSize;
365 [ + + ]: 1023420 : if( pMem )
366 : 906104 : pMem = (char*)rtl_reallocateMemory( pMem, nLen );
367 : 1023420 : return( nLen - nSize );
368 : : }
369 : :
370 : : /*************************************************************************
371 : : |*
372 : : |* RscWriteRc :: GetPointer()
373 : : |*
374 : : *************************************************************************/
375 : 2116400 : char * RscWriteRc :: GetPointer( sal_uInt32 nSize )
376 : : {
377 [ + + ]: 2116400 : if( !pMem )
378 : 98770 : pMem = (char *)rtl_allocateMemory( nLen );
379 : 2116400 : return( pMem + nSize );
380 : : }
381 : :
382 : :
383 : : /*************************************************************************
384 : : |*
385 : : |* RscWriteRc :: Put()
386 : : |*
387 : : *************************************************************************/
388 : 886464 : void RscWriteRc :: Put( sal_uInt16 nVal )
389 : : {
390 : : sal_uInt32 nOldLen;
391 : :
392 : 886464 : nOldLen = IncSize( sizeof( nVal ) );
393 : 886464 : PutAt( nOldLen, nVal );
394 : 886464 : }
395 : :
396 : 74620 : void RscWriteRc :: PutUTF8( char * pStr )
397 : : {
398 : 74620 : sal_uInt32 nStrLen = 0;
399 [ + + ]: 74620 : if( pStr )
400 : 73494 : nStrLen = strlen( pStr );
401 : :
402 : 74620 : sal_uInt32 n = nStrLen +1;
403 [ + + ]: 74620 : if( n % 2 )
404 : : // align to 2
405 : 37750 : n++;
406 : :
407 : 74620 : sal_uInt32 nOldLen = IncSize( n );
408 : 74620 : rtl_copyMemory( GetPointer( nOldLen ), pStr, nStrLen );
409 : : // 0 terminated
410 : 74620 : pMem[ nOldLen + nStrLen ] = '\0';
411 : 74620 : }
412 : :
413 : : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
