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: */
|
