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 :
21 : #include <stdlib.h>
22 : #include <stdio.h>
23 : #if defined (WNT )
24 : #include <direct.h>
25 : #endif
26 : #include <string.h>
27 : #include <ctype.h>
28 :
29 : #include <rscdef.hxx>
30 : #include <rsctools.hxx>
31 :
32 : #include <osl/file.h>
33 : #include <rtl/alloc.h>
34 :
35 : /* case insensitive compare of two strings up to a given length */
36 122923 : int rsc_strnicmp( const char *string1, const char *string2, size_t count )
37 : {
38 : size_t i;
39 :
40 216395 : for( i = 0; ( i < count ) && string1[ i ] && string2[ i ] ; i++ )
41 : {
42 197050 : if( tolower( string1[ i ] ) < tolower( string2[ i ] ) )
43 67729 : return -1;
44 129321 : else if( tolower( string1[ i ] ) > tolower( string2[ i ] ) )
45 35849 : return 1;
46 : }
47 19345 : if( i == count )
48 19233 : return 0;
49 112 : else if( tolower( string1[ i ] ) < tolower( string2[ i ] ) )
50 112 : return -1;
51 0 : else if( tolower( string1[ i ] ) > tolower( string2[ i ] ) )
52 0 : return 1;
53 0 : return 0;
54 : }
55 :
56 : /* case insensitive compare of two strings */
57 199668 : int rsc_stricmp( const char *string1, const char *string2 ){
58 : int i;
59 :
60 290490 : for( i = 0; string1[ i ] && string2[ i ]; i++ )
61 : {
62 288420 : if( tolower( string1[ i ] ) < tolower( string2[ i ] ) )
63 140167 : return -1;
64 148253 : else if( tolower( string1[ i ] ) > tolower( string2[ i ] ) )
65 57431 : return 1;
66 : }
67 2070 : if( tolower( string1[ i ] ) < tolower( string2[ i ] ) )
68 0 : return -1;
69 2070 : else if( tolower( string1[ i ] ) > tolower( string2[ i ] ) )
70 1539 : return 1;
71 531 : return 0;
72 : }
73 :
74 42295 : char* rsc_strdup( const char* pStr )
75 : {
76 42295 : int nLen = strlen( pStr );
77 42295 : char* pBuffer = (char*)rtl_allocateMemory( nLen+1 );
78 42295 : memcpy( pBuffer, pStr, nLen+1 );
79 42295 : return pBuffer;
80 : }
81 :
82 726 : OString GetTmpFileName()
83 : {
84 1452 : OUString aTmpURL, aTmpFile;
85 726 : osl_createTempFile( NULL, NULL, &aTmpURL.pData );
86 726 : osl_getSystemPathFromFileURL( aTmpURL.pData, &aTmpFile.pData );
87 1452 : return OUStringToOString( aTmpFile, RTL_TEXTENCODING_MS_1252 );
88 : }
89 :
90 0 : bool Append(FILE * fDest, const OString &rTmpFile)
91 : {
92 : #define MAX_BUF 4096
93 0 : FILE *fSource = fopen(rTmpFile.getStr(), "rb");
94 0 : if( !fDest || !fSource )
95 : {
96 0 : if( fSource )
97 0 : fclose( fSource );
98 0 : return false;
99 : }
100 :
101 0 : bool bSuccess = true;
102 : char szBuf[ MAX_BUF ];
103 : size_t nItems;
104 :
105 0 : do //append
106 : {
107 0 : nItems = fread( szBuf, 1, MAX_BUF, fSource );
108 0 : bSuccess = (nItems == fwrite(szBuf, 1, nItems, fDest));
109 : SAL_WARN_IF(!bSuccess, "rsc", "short write");
110 : }
111 0 : while (MAX_BUF == nItems && bSuccess);
112 :
113 0 : fclose( fSource );
114 0 : return bSuccess;
115 : }
116 :
117 0 : bool Append(const OString &rOutputSrs, const OString &rTmpFile)
118 : {
119 0 : FILE * fDest = fopen(rOutputSrs.getStr(), "ab");
120 :
121 0 : bool bRet = Append(fDest, rTmpFile);
122 :
123 0 : if( fDest )
124 0 : fclose( fDest );
125 :
126 0 : return bRet;
127 : }
128 :
129 : /* replaces extension of a file name */
130 838 : OString OutputFile(const OString &rInput, const char * pExt)
131 : {
132 838 : sal_Int32 nSepInd = rInput.lastIndexOf('.');
133 :
134 838 : if( nSepInd != -1 )
135 : {
136 475 : return rInput.copy(0, nSepInd + 1).concat(OString(pExt));
137 : }
138 :
139 363 : return rInput.concat(OString(".")).concat(OString(pExt));
140 : }
141 :
142 838 : char * ResponseFile( RscPtrPtr * ppCmd, char ** ppArgv, sal_uInt32 nArgc )
143 : {
144 : FILE *fFile;
145 : int nItems;
146 : char szBuffer[4096]; // file buffer
147 : sal_uInt32 i;
148 838 : bool bInQuotes = false;
149 :
150 : // program name
151 838 : ppCmd->Append( rsc_strdup( *ppArgv ) );
152 11922 : for( i = 1; i < nArgc; i++ )
153 : {
154 11084 : if( '@' == **(ppArgv +i) ){ // when @, then response file
155 419 : if( NULL == (fFile = fopen( (*(ppArgv +i)) +1, "r" )) )
156 0 : return( (*(ppArgv +i)) );
157 419 : nItems = fread( &szBuffer[ 0 ], 1, sizeof( char ), fFile );
158 11850 : while( nItems )
159 : {
160 11012 : if( !isspace( szBuffer[ 0 ] ) )
161 : {
162 : /*
163 : * #i27914# double ticks '"' now have a duplicate function:
164 : * 1. they define a string ( e.g. -DFOO="baz" )
165 : * 2. a string can contain spaces, so -DFOO="baz zum" defines one
166 : * argument no two !
167 : */
168 10302 : unsigned int n = 0;
169 720028 : while( nItems && (!isspace( szBuffer[ n ] ) || bInQuotes) &&
170 349712 : n +1 < sizeof( szBuffer ) )
171 : {
172 349712 : n++;
173 : nItems = fread( &szBuffer[ n ], 1,
174 349712 : sizeof( char ), fFile );
175 349712 : if( szBuffer[n] == '"' )
176 0 : bInQuotes = !bInQuotes;
177 : }
178 10302 : szBuffer[ n ] = '\0';
179 10302 : ppCmd->Append( rsc_strdup( szBuffer ) );
180 : }
181 11012 : nItems = fread( &szBuffer[ 0 ], 1, sizeof( char ), fFile );
182 : }
183 :
184 419 : fclose( fFile );
185 : }
186 : else
187 10665 : ppCmd->Append( rsc_strdup( *(ppArgv +i) ) );
188 : }
189 838 : ppCmd->Append( (void *)0 );
190 838 : return NULL;
191 : }
192 :
193 :
194 1983 : RscPtrPtr :: RscPtrPtr()
195 : {
196 1983 : nCount = 0;
197 1983 : pMem = NULL;
198 1983 : }
199 :
200 1983 : RscPtrPtr :: ~RscPtrPtr()
201 : {
202 1983 : Reset();
203 1983 : }
204 :
205 1983 : void RscPtrPtr :: Reset()
206 : {
207 : sal_uInt32 i;
208 :
209 1983 : if( pMem )
210 : {
211 45842 : for( i = 0; i < nCount; i++ )
212 : {
213 43859 : if( pMem[ i ] )
214 42295 : rtl_freeMemory( pMem[ i ] );
215 : }
216 1983 : rtl_freeMemory( (void *)pMem );
217 : };
218 1983 : nCount = 0;
219 1983 : pMem = NULL;
220 1983 : }
221 :
222 43859 : sal_uInt32 RscPtrPtr :: Append( void * pBuffer )
223 : {
224 43859 : if( !pMem )
225 1983 : pMem = (void **)rtl_allocateMemory( (nCount +1) * sizeof( void * ) );
226 : else
227 : pMem = (void **)rtl_reallocateMemory( (void *)pMem,
228 41876 : ((nCount +1) * sizeof( void * )
229 41876 : ) );
230 43859 : pMem[ nCount ] = pBuffer;
231 43859 : return nCount++;
232 : }
233 :
234 193291 : void * RscPtrPtr :: GetEntry( sal_uInt32 nEntry )
235 : {
236 193291 : if( nEntry < nCount )
237 193291 : return pMem[ nEntry ];
238 0 : return NULL;
239 : }
240 :
241 11866 : RscWriteRc::RscWriteRc( RSCBYTEORDER_TYPE nOrder )
242 : {
243 11866 : short nSwapTest = 1;
244 : RSCBYTEORDER_TYPE nMachineOrder;
245 :
246 11866 : bSwap = false;
247 11866 : if( nOrder != RSC_SYSTEMENDIAN )
248 : {
249 9589 : if( (sal_uInt8)*(sal_uInt8 *)&nSwapTest )
250 9589 : nMachineOrder = RSC_LITTLEENDIAN;
251 : else
252 0 : nMachineOrder = RSC_BIGENDIAN;
253 9589 : bSwap = nOrder != nMachineOrder;
254 : }
255 11866 : nByteOrder = nOrder;
256 11866 : nLen = 0;
257 11866 : pMem = NULL;
258 11866 : }
259 :
260 11866 : RscWriteRc :: ~RscWriteRc()
261 : {
262 11866 : if( pMem )
263 11866 : rtl_freeMemory( pMem );
264 11866 : }
265 :
266 148797 : sal_uInt32 RscWriteRc :: IncSize( sal_uInt32 nSize )
267 : {
268 148797 : sal_uInt32 nOrigPos = nLen;
269 148797 : nLen += nSize;
270 148797 : if( pMem )
271 127302 : pMem = (char*)rtl_reallocateMemory( pMem, nLen );
272 148797 : if( pMem )
273 127302 : memset( pMem + nOrigPos, 0, nSize );
274 148797 : return nOrigPos;
275 : }
276 :
277 378334 : char * RscWriteRc :: GetPointer( sal_uInt32 nSize )
278 : {
279 378334 : if( !pMem )
280 : {
281 11866 : pMem = (char *)rtl_allocateMemory( nLen );
282 11866 : memset( pMem, 0, nLen );
283 : }
284 378334 : return pMem + nSize;
285 : }
286 :
287 :
288 100887 : void RscWriteRc :: Put( sal_uInt16 nVal )
289 : {
290 : sal_uInt32 nOldLen;
291 :
292 100887 : nOldLen = IncSize( sizeof( nVal ) );
293 100887 : PutAt( nOldLen, nVal );
294 100887 : }
295 :
296 26014 : void RscWriteRc :: PutUTF8( char * pStr )
297 : {
298 26014 : sal_uInt32 nStrLen = 0;
299 26014 : if( pStr )
300 25982 : nStrLen = strlen( pStr );
301 :
302 26014 : sal_uInt32 n = nStrLen +1;
303 26014 : if( n % 2 )
304 : // align to 2
305 13009 : n++;
306 :
307 26014 : sal_uInt32 nOldLen = IncSize( n );
308 26014 : memcpy( GetPointer( nOldLen ), pStr, nStrLen );
309 : // 0 terminated
310 26014 : pMem[ nOldLen + nStrLen ] = '\0';
311 26014 : }
312 :
313 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
