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