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 : #include <sal/log.hxx>
35 :
36 : /* case insensitive compare of two strings up to a given length */
37 118445 : int rsc_strnicmp( const char *string1, const char *string2, size_t count )
38 : {
39 : size_t i;
40 :
41 208869 : for( i = 0; ( i < count ) && string1[ i ] && string2[ i ] ; i++ )
42 : {
43 190268 : if( tolower( string1[ i ] ) < tolower( string2[ i ] ) )
44 63961 : return -1;
45 126307 : else if( tolower( string1[ i ] ) > tolower( string2[ i ] ) )
46 35883 : return 1;
47 : }
48 18601 : if( i == count )
49 18489 : return 0;
50 112 : else if( tolower( string1[ i ] ) < tolower( string2[ i ] ) )
51 112 : return -1;
52 0 : else if( tolower( string1[ i ] ) > tolower( string2[ i ] ) )
53 0 : return 1;
54 0 : return 0;
55 : }
56 :
57 : /* case insensitive compare of two strings */
58 192232 : int rsc_stricmp( const char *string1, const char *string2 ){
59 : int i;
60 :
61 279713 : for( i = 0; string1[ i ] && string2[ i ]; i++ )
62 : {
63 277647 : if( tolower( string1[ i ] ) < tolower( string2[ i ] ) )
64 134221 : return -1;
65 143426 : else if( tolower( string1[ i ] ) > tolower( string2[ i ] ) )
66 55945 : return 1;
67 : }
68 2066 : if( tolower( string1[ i ] ) < tolower( string2[ i ] ) )
69 0 : return -1;
70 2066 : else if( tolower( string1[ i ] ) > tolower( string2[ i ] ) )
71 1537 : return 1;
72 529 : return 0;
73 : }
74 :
75 40793 : char* rsc_strdup( const char* pStr )
76 : {
77 40793 : int nLen = strlen( pStr );
78 40793 : char* pBuffer = static_cast<char*>(rtl_allocateMemory( nLen+1 ));
79 40793 : memcpy( pBuffer, pStr, nLen+1 );
80 40793 : return pBuffer;
81 : }
82 :
83 722 : OString GetTmpFileName()
84 : {
85 1444 : OUString aTmpURL, aTmpFile;
86 722 : osl_createTempFile( NULL, NULL, &aTmpURL.pData );
87 722 : osl_getSystemPathFromFileURL( aTmpURL.pData, &aTmpFile.pData );
88 1444 : return OUStringToOString( aTmpFile, RTL_TEXTENCODING_MS_1252 );
89 : }
90 :
91 0 : bool Append(FILE * fDest, const OString &rTmpFile)
92 : {
93 : #define MAX_BUF 4096
94 0 : FILE *fSource = fopen(rTmpFile.getStr(), "rb");
95 0 : if( !fDest || !fSource )
96 : {
97 0 : if( fSource )
98 0 : fclose( fSource );
99 0 : return false;
100 : }
101 :
102 0 : bool bSuccess = true;
103 : char szBuf[ MAX_BUF ];
104 : size_t nItems;
105 :
106 0 : do //append
107 : {
108 0 : nItems = fread( szBuf, 1, MAX_BUF, fSource );
109 0 : bSuccess = (nItems == fwrite(szBuf, 1, nItems, fDest));
110 : SAL_WARN_IF(!bSuccess, "rsc", "short write");
111 : }
112 0 : while (MAX_BUF == nItems && bSuccess);
113 :
114 0 : fclose( fSource );
115 0 : return bSuccess;
116 : }
117 :
118 0 : bool Append(const OString &rOutputSrs, const OString &rTmpFile)
119 : {
120 0 : FILE * fDest = fopen(rOutputSrs.getStr(), "ab");
121 :
122 0 : bool bRet = Append(fDest, rTmpFile);
123 :
124 0 : if( fDest )
125 0 : fclose( fDest );
126 :
127 0 : return bRet;
128 : }
129 :
130 : /* replaces extension of a file name */
131 834 : OString OutputFile(const OString &rInput, const char * pExt)
132 : {
133 834 : sal_Int32 nSepInd = rInput.lastIndexOf('.');
134 :
135 834 : if( nSepInd != -1 )
136 : {
137 473 : return rInput.copy(0, nSepInd + 1).concat(OString(pExt));
138 : }
139 :
140 361 : return rInput.concat(OString(".")).concat(OString(pExt));
141 : }
142 :
143 834 : char * ResponseFile( RscPtrPtr * ppCmd, char ** ppArgv, sal_uInt32 nArgc )
144 : {
145 : FILE *fFile;
146 : int nItems;
147 : char szBuffer[4096]; // file buffer
148 : sal_uInt32 i;
149 834 : bool bInQuotes = false;
150 :
151 : // program name
152 834 : ppCmd->Append( rsc_strdup( *ppArgv ) );
153 11541 : for( i = 1; i < nArgc; i++ )
154 : {
155 10707 : if( '@' == **(ppArgv +i) ){ // when @, then response file
156 417 : if( NULL == (fFile = fopen( (*(ppArgv +i)) +1, "r" )) )
157 0 : return( (*(ppArgv +i)) );
158 417 : nItems = fread( &szBuffer[ 0 ], 1, sizeof( char ), fFile );
159 11470 : while( nItems )
160 : {
161 10636 : if( !isspace( szBuffer[ 0 ] ) )
162 : {
163 : /*
164 : * #i27914# double ticks '"' now have a duplicate function:
165 : * 1. they define a string ( e.g. -DFOO="baz" )
166 : * 2. a string can contain spaces, so -DFOO="baz zum" defines one
167 : * argument no two !
168 : */
169 9929 : unsigned int n = 0;
170 746886 : while( nItems && (!isspace( szBuffer[ n ] ) || bInQuotes) &&
171 363514 : n +1 < sizeof( szBuffer ) )
172 : {
173 363514 : n++;
174 : nItems = fread( &szBuffer[ n ], 1,
175 363514 : sizeof( char ), fFile );
176 363514 : if( szBuffer[n] == '"' )
177 0 : bInQuotes = !bInQuotes;
178 : }
179 9929 : szBuffer[ n ] = '\0';
180 9929 : ppCmd->Append( rsc_strdup( szBuffer ) );
181 : }
182 10636 : nItems = fread( &szBuffer[ 0 ], 1, sizeof( char ), fFile );
183 : }
184 :
185 417 : fclose( fFile );
186 : }
187 : else
188 10290 : ppCmd->Append( rsc_strdup( *(ppArgv +i) ) );
189 : }
190 834 : ppCmd->Append( static_cast<void *>(nullptr) );
191 834 : return NULL;
192 : }
193 :
194 :
195 1973 : RscPtrPtr :: RscPtrPtr()
196 : {
197 1973 : nCount = 0;
198 1973 : pMem = NULL;
199 1973 : }
200 :
201 1973 : RscPtrPtr :: ~RscPtrPtr()
202 : {
203 1973 : Reset();
204 1973 : }
205 :
206 1973 : void RscPtrPtr :: Reset()
207 : {
208 : sal_uInt32 i;
209 :
210 1973 : if( pMem )
211 : {
212 44322 : for( i = 0; i < nCount; i++ )
213 : {
214 42349 : if( pMem[ i ] )
215 40793 : rtl_freeMemory( pMem[ i ] );
216 : }
217 1973 : rtl_freeMemory( static_cast<void *>(pMem) );
218 : };
219 1973 : nCount = 0;
220 1973 : pMem = NULL;
221 1973 : }
222 :
223 42349 : sal_uInt32 RscPtrPtr :: Append( void * pBuffer )
224 : {
225 42349 : if( !pMem )
226 1973 : pMem = static_cast<void **>(rtl_allocateMemory( (nCount +1) * sizeof( void * ) ));
227 : else
228 : pMem = static_cast<void **>(rtl_reallocateMemory( static_cast<void *>(pMem),
229 40376 : ((nCount +1) * sizeof( void * )
230 40376 : ) ));
231 42349 : pMem[ nCount ] = pBuffer;
232 42349 : return nCount++;
233 : }
234 :
235 185821 : void * RscPtrPtr :: GetEntry( sal_uInt32 nEntry )
236 : {
237 185821 : if( nEntry < nCount )
238 185821 : return pMem[ nEntry ];
239 0 : return NULL;
240 : }
241 :
242 11011 : RscWriteRc::RscWriteRc( RSCBYTEORDER_TYPE nOrder )
243 : {
244 11011 : bSwap = false;
245 11011 : if( nOrder != RSC_SYSTEMENDIAN )
246 : {
247 : RSCBYTEORDER_TYPE nMachineOrder;
248 : #if defined OSL_LITENDIAN
249 9552 : nMachineOrder = RSC_LITTLEENDIAN;
250 : #else
251 : nMachineOrder = RSC_BIGENDIAN;
252 : #endif
253 9552 : bSwap = nOrder != nMachineOrder;
254 : }
255 11011 : nByteOrder = nOrder;
256 11011 : nLen = 0;
257 11011 : pMem = NULL;
258 11011 : }
259 :
260 11011 : RscWriteRc :: ~RscWriteRc()
261 : {
262 11011 : if( pMem )
263 11011 : rtl_freeMemory( pMem );
264 11011 : }
265 :
266 137700 : sal_uInt32 RscWriteRc :: IncSize( sal_uInt32 nSize )
267 : {
268 137700 : sal_uInt32 nOrigPos = nLen;
269 137700 : nLen += nSize;
270 137700 : if( pMem )
271 117097 : pMem = static_cast<char*>(rtl_reallocateMemory( pMem, nLen ));
272 137700 : if( pMem )
273 117097 : memset( pMem + nOrigPos, 0, nSize );
274 137700 : return nOrigPos;
275 : }
276 :
277 354027 : char * RscWriteRc :: GetPointer( sal_uInt32 nSize )
278 : {
279 354027 : if( !pMem )
280 : {
281 11011 : pMem = static_cast<char *>(rtl_allocateMemory( nLen ));
282 11011 : memset( pMem, 0, nLen );
283 : }
284 354027 : return pMem + nSize;
285 : }
286 :
287 :
288 91382 : void RscWriteRc :: Put( sal_uInt16 nVal )
289 : {
290 : sal_uInt32 nOldLen;
291 :
292 91382 : nOldLen = IncSize( sizeof( nVal ) );
293 91382 : PutAt( nOldLen, nVal );
294 91382 : }
295 :
296 25078 : void RscWriteRc :: PutUTF8( char * pStr )
297 : {
298 25078 : sal_uInt32 nStrLen = 0;
299 25078 : if( pStr )
300 25046 : nStrLen = strlen( pStr );
301 :
302 25078 : sal_uInt32 n = nStrLen +1;
303 25078 : if( n % 2 )
304 : // align to 2
305 12516 : n++;
306 :
307 25078 : sal_uInt32 nOldLen = IncSize( n );
308 25078 : char * p = GetPointer( nOldLen );
309 25078 : if (nStrLen != 0)
310 : {
311 25046 : memcpy( p, pStr, nStrLen );
312 : }
313 : // 0 terminated
314 25078 : pMem[ nOldLen + nStrLen ] = '\0';
315 25078 : }
316 :
317 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
