1*9f62ea84SAndrew Rist /**************************************************************
2cdf0e10cSrcweir *
3*9f62ea84SAndrew Rist * Licensed to the Apache Software Foundation (ASF) under one
4*9f62ea84SAndrew Rist * or more contributor license agreements. See the NOTICE file
5*9f62ea84SAndrew Rist * distributed with this work for additional information
6*9f62ea84SAndrew Rist * regarding copyright ownership. The ASF licenses this file
7*9f62ea84SAndrew Rist * to you under the Apache License, Version 2.0 (the
8*9f62ea84SAndrew Rist * "License"); you may not use this file except in compliance
9*9f62ea84SAndrew Rist * with the License. You may obtain a copy of the License at
10*9f62ea84SAndrew Rist *
11*9f62ea84SAndrew Rist * http://www.apache.org/licenses/LICENSE-2.0
12*9f62ea84SAndrew Rist *
13*9f62ea84SAndrew Rist * Unless required by applicable law or agreed to in writing,
14*9f62ea84SAndrew Rist * software distributed under the License is distributed on an
15*9f62ea84SAndrew Rist * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
16*9f62ea84SAndrew Rist * KIND, either express or implied. See the License for the
17*9f62ea84SAndrew Rist * specific language governing permissions and limitations
18*9f62ea84SAndrew Rist * under the License.
19*9f62ea84SAndrew Rist *
20*9f62ea84SAndrew Rist *************************************************************/
21*9f62ea84SAndrew Rist
22*9f62ea84SAndrew Rist
23cdf0e10cSrcweir
24cdf0e10cSrcweir // MARKER(update_precomp.py): autogen include statement, do not remove
25cdf0e10cSrcweir #include "precompiled_vcl.hxx"
26cdf0e10cSrcweir
27cdf0e10cSrcweir #include "vcl/strhelper.hxx"
28cdf0e10cSrcweir #include "sal/alloca.h"
29cdf0e10cSrcweir
30cdf0e10cSrcweir namespace psp {
31cdf0e10cSrcweir
isSpace(char cChar)32cdf0e10cSrcweir inline int isSpace( char cChar )
33cdf0e10cSrcweir {
34cdf0e10cSrcweir return
35cdf0e10cSrcweir cChar == ' ' || cChar == '\t' ||
36cdf0e10cSrcweir cChar == '\r' || cChar == '\n' ||
37cdf0e10cSrcweir cChar == 0x0c || cChar == 0x0b;
38cdf0e10cSrcweir }
39cdf0e10cSrcweir
isSpace(sal_Unicode cChar)40cdf0e10cSrcweir inline int isSpace( sal_Unicode cChar )
41cdf0e10cSrcweir {
42cdf0e10cSrcweir return
43cdf0e10cSrcweir cChar == ' ' || cChar == '\t' ||
44cdf0e10cSrcweir cChar == '\r' || cChar == '\n' ||
45cdf0e10cSrcweir cChar == 0x0c || cChar == 0x0b;
46cdf0e10cSrcweir }
47cdf0e10cSrcweir
isProtect(char cChar)48cdf0e10cSrcweir inline int isProtect( char cChar )
49cdf0e10cSrcweir {
50cdf0e10cSrcweir return cChar == '`' || cChar == '\'' || cChar == '"';
51cdf0e10cSrcweir }
52cdf0e10cSrcweir
isProtect(sal_Unicode cChar)53cdf0e10cSrcweir inline int isProtect( sal_Unicode cChar )
54cdf0e10cSrcweir {
55cdf0e10cSrcweir return cChar == '`' || cChar == '\'' || cChar == '"';
56cdf0e10cSrcweir }
57cdf0e10cSrcweir
CopyUntil(char * & pTo,const char * & pFrom,char cUntil,int bIncludeUntil=0)58cdf0e10cSrcweir inline void CopyUntil( char*& pTo, const char*& pFrom, char cUntil, int bIncludeUntil = 0 )
59cdf0e10cSrcweir {
60cdf0e10cSrcweir do
61cdf0e10cSrcweir {
62cdf0e10cSrcweir if( *pFrom == '\\' )
63cdf0e10cSrcweir {
64cdf0e10cSrcweir pFrom++;
65cdf0e10cSrcweir if( *pFrom )
66cdf0e10cSrcweir {
67cdf0e10cSrcweir *pTo = *pFrom;
68cdf0e10cSrcweir pTo++;
69cdf0e10cSrcweir }
70cdf0e10cSrcweir }
71cdf0e10cSrcweir else if( bIncludeUntil || ! isProtect( *pFrom ) )
72cdf0e10cSrcweir {
73cdf0e10cSrcweir *pTo = *pFrom;
74cdf0e10cSrcweir pTo++;
75cdf0e10cSrcweir }
76cdf0e10cSrcweir pFrom++;
77cdf0e10cSrcweir } while( *pFrom && *pFrom != cUntil );
78cdf0e10cSrcweir // copy the terminating character unless zero or protector
79cdf0e10cSrcweir if( ! isProtect( *pFrom ) || bIncludeUntil )
80cdf0e10cSrcweir {
81cdf0e10cSrcweir *pTo = *pFrom;
82cdf0e10cSrcweir if( *pTo )
83cdf0e10cSrcweir pTo++;
84cdf0e10cSrcweir }
85cdf0e10cSrcweir if( *pFrom )
86cdf0e10cSrcweir pFrom++;
87cdf0e10cSrcweir }
88cdf0e10cSrcweir
CopyUntil(sal_Unicode * & pTo,const sal_Unicode * & pFrom,sal_Unicode cUntil,int bIncludeUntil=0)89cdf0e10cSrcweir inline void CopyUntil( sal_Unicode*& pTo, const sal_Unicode*& pFrom, sal_Unicode cUntil, int bIncludeUntil = 0 )
90cdf0e10cSrcweir {
91cdf0e10cSrcweir do
92cdf0e10cSrcweir {
93cdf0e10cSrcweir if( *pFrom == '\\' )
94cdf0e10cSrcweir {
95cdf0e10cSrcweir pFrom++;
96cdf0e10cSrcweir if( *pFrom )
97cdf0e10cSrcweir {
98cdf0e10cSrcweir *pTo = *pFrom;
99cdf0e10cSrcweir pTo++;
100cdf0e10cSrcweir }
101cdf0e10cSrcweir }
102cdf0e10cSrcweir else if( bIncludeUntil || ! isProtect( *pFrom ) )
103cdf0e10cSrcweir {
104cdf0e10cSrcweir *pTo = *pFrom;
105cdf0e10cSrcweir pTo++;
106cdf0e10cSrcweir }
107cdf0e10cSrcweir pFrom++;
108cdf0e10cSrcweir } while( *pFrom && *pFrom != cUntil );
109cdf0e10cSrcweir // copy the terminating character unless zero or protector
110cdf0e10cSrcweir if( ! isProtect( *pFrom ) || bIncludeUntil )
111cdf0e10cSrcweir {
112cdf0e10cSrcweir *pTo = *pFrom;
113cdf0e10cSrcweir if( *pTo )
114cdf0e10cSrcweir pTo++;
115cdf0e10cSrcweir }
116cdf0e10cSrcweir if( *pFrom )
117cdf0e10cSrcweir pFrom++;
118cdf0e10cSrcweir }
119cdf0e10cSrcweir
GetCommandLineToken(int nToken,const String & rLine)120cdf0e10cSrcweir String GetCommandLineToken( int nToken, const String& rLine )
121cdf0e10cSrcweir {
122cdf0e10cSrcweir int nLen = rLine.Len();
123cdf0e10cSrcweir if( ! nLen )
124cdf0e10cSrcweir return String();
125cdf0e10cSrcweir
126cdf0e10cSrcweir int nActualToken = 0;
127cdf0e10cSrcweir sal_Unicode* pBuffer = (sal_Unicode*)alloca( sizeof(sal_Unicode)*( nLen + 1 ) );
128cdf0e10cSrcweir const sal_Unicode* pRun = rLine.GetBuffer();
129cdf0e10cSrcweir sal_Unicode* pLeap = NULL;
130cdf0e10cSrcweir
131cdf0e10cSrcweir while( *pRun && nActualToken <= nToken )
132cdf0e10cSrcweir {
133cdf0e10cSrcweir while( *pRun && isSpace( *pRun ) )
134cdf0e10cSrcweir pRun++;
135cdf0e10cSrcweir pLeap = pBuffer;
136cdf0e10cSrcweir while( *pRun && ! isSpace( *pRun ) )
137cdf0e10cSrcweir {
138cdf0e10cSrcweir if( *pRun == '\\' )
139cdf0e10cSrcweir {
140cdf0e10cSrcweir // escapement
141cdf0e10cSrcweir pRun++;
142cdf0e10cSrcweir *pLeap = *pRun;
143cdf0e10cSrcweir pLeap++;
144cdf0e10cSrcweir if( *pRun )
145cdf0e10cSrcweir pRun++;
146cdf0e10cSrcweir }
147cdf0e10cSrcweir else if( *pRun == '`' )
148cdf0e10cSrcweir CopyUntil( pLeap, pRun, '`' );
149cdf0e10cSrcweir else if( *pRun == '\'' )
150cdf0e10cSrcweir CopyUntil( pLeap, pRun, '\'' );
151cdf0e10cSrcweir else if( *pRun == '"' )
152cdf0e10cSrcweir CopyUntil( pLeap, pRun, '"' );
153cdf0e10cSrcweir else
154cdf0e10cSrcweir {
155cdf0e10cSrcweir *pLeap = *pRun;
156cdf0e10cSrcweir pLeap++;
157cdf0e10cSrcweir pRun++;
158cdf0e10cSrcweir }
159cdf0e10cSrcweir }
160cdf0e10cSrcweir if( nActualToken != nToken )
161cdf0e10cSrcweir pBuffer[0] = 0;
162cdf0e10cSrcweir nActualToken++;
163cdf0e10cSrcweir }
164cdf0e10cSrcweir
165cdf0e10cSrcweir *pLeap = 0;
166cdf0e10cSrcweir
167cdf0e10cSrcweir String aRet( pBuffer );
168cdf0e10cSrcweir return aRet;
169cdf0e10cSrcweir }
170cdf0e10cSrcweir
GetCommandLineToken(int nToken,const ByteString & rLine)171cdf0e10cSrcweir ByteString GetCommandLineToken( int nToken, const ByteString& rLine )
172cdf0e10cSrcweir {
173cdf0e10cSrcweir int nLen = rLine.Len();
174cdf0e10cSrcweir if( ! nLen )
175cdf0e10cSrcweir return ByteString();
176cdf0e10cSrcweir
177cdf0e10cSrcweir int nActualToken = 0;
178cdf0e10cSrcweir char* pBuffer = (char*)alloca( nLen + 1 );
179cdf0e10cSrcweir const char* pRun = rLine.GetBuffer();
180cdf0e10cSrcweir char* pLeap = NULL;
181cdf0e10cSrcweir
182cdf0e10cSrcweir while( *pRun && nActualToken <= nToken )
183cdf0e10cSrcweir {
184cdf0e10cSrcweir while( *pRun && isSpace( *pRun ) )
185cdf0e10cSrcweir pRun++;
186cdf0e10cSrcweir pLeap = pBuffer;
187cdf0e10cSrcweir while( *pRun && ! isSpace( *pRun ) )
188cdf0e10cSrcweir {
189cdf0e10cSrcweir if( *pRun == '\\' )
190cdf0e10cSrcweir {
191cdf0e10cSrcweir // escapement
192cdf0e10cSrcweir pRun++;
193cdf0e10cSrcweir *pLeap = *pRun;
194cdf0e10cSrcweir pLeap++;
195cdf0e10cSrcweir if( *pRun )
196cdf0e10cSrcweir pRun++;
197cdf0e10cSrcweir }
198cdf0e10cSrcweir else if( *pRun == '`' )
199cdf0e10cSrcweir CopyUntil( pLeap, pRun, '`' );
200cdf0e10cSrcweir else if( *pRun == '\'' )
201cdf0e10cSrcweir CopyUntil( pLeap, pRun, '\'' );
202cdf0e10cSrcweir else if( *pRun == '"' )
203cdf0e10cSrcweir CopyUntil( pLeap, pRun, '"' );
204cdf0e10cSrcweir else
205cdf0e10cSrcweir {
206cdf0e10cSrcweir *pLeap = *pRun;
207cdf0e10cSrcweir pLeap++;
208cdf0e10cSrcweir pRun++;
209cdf0e10cSrcweir }
210cdf0e10cSrcweir }
211cdf0e10cSrcweir if( nActualToken != nToken )
212cdf0e10cSrcweir pBuffer[0] = 0;
213cdf0e10cSrcweir nActualToken++;
214cdf0e10cSrcweir }
215cdf0e10cSrcweir
216cdf0e10cSrcweir *pLeap = 0;
217cdf0e10cSrcweir
218cdf0e10cSrcweir ByteString aRet( pBuffer );
219cdf0e10cSrcweir return aRet;
220cdf0e10cSrcweir }
221cdf0e10cSrcweir
GetCommandLineTokenCount(const String & rLine)222cdf0e10cSrcweir int GetCommandLineTokenCount( const String& rLine )
223cdf0e10cSrcweir {
224cdf0e10cSrcweir if( ! rLine.Len() )
225cdf0e10cSrcweir return 0;
226cdf0e10cSrcweir
227cdf0e10cSrcweir int nTokenCount = 0;
228cdf0e10cSrcweir const sal_Unicode *pRun = rLine.GetBuffer();
229cdf0e10cSrcweir
230cdf0e10cSrcweir
231cdf0e10cSrcweir while( *pRun )
232cdf0e10cSrcweir {
233cdf0e10cSrcweir while( *pRun && isSpace( *pRun ) )
234cdf0e10cSrcweir pRun++;
235cdf0e10cSrcweir if( ! *pRun )
236cdf0e10cSrcweir break;
237cdf0e10cSrcweir while( *pRun && ! isSpace( *pRun ) )
238cdf0e10cSrcweir {
239cdf0e10cSrcweir if( *pRun == '\\' )
240cdf0e10cSrcweir {
241cdf0e10cSrcweir // escapement
242cdf0e10cSrcweir pRun++;
243cdf0e10cSrcweir if( *pRun )
244cdf0e10cSrcweir pRun++;
245cdf0e10cSrcweir }
246cdf0e10cSrcweir else if( *pRun == '`' )
247cdf0e10cSrcweir {
248cdf0e10cSrcweir do pRun++; while( *pRun && *pRun != '`' );
249cdf0e10cSrcweir if( *pRun )
250cdf0e10cSrcweir pRun++;
251cdf0e10cSrcweir }
252cdf0e10cSrcweir else if( *pRun == '\'' )
253cdf0e10cSrcweir {
254cdf0e10cSrcweir do pRun++; while( *pRun && *pRun != '\'' );
255cdf0e10cSrcweir if( *pRun )
256cdf0e10cSrcweir pRun++;
257cdf0e10cSrcweir }
258cdf0e10cSrcweir else if( *pRun == '"' )
259cdf0e10cSrcweir {
260cdf0e10cSrcweir do pRun++; while( *pRun && *pRun != '"' );
261cdf0e10cSrcweir if( *pRun )
262cdf0e10cSrcweir pRun++;
263cdf0e10cSrcweir }
264cdf0e10cSrcweir else
265cdf0e10cSrcweir pRun++;
266cdf0e10cSrcweir }
267cdf0e10cSrcweir nTokenCount++;
268cdf0e10cSrcweir }
269cdf0e10cSrcweir
270cdf0e10cSrcweir return nTokenCount;
271cdf0e10cSrcweir }
272cdf0e10cSrcweir
GetCommandLineTokenCount(const ByteString & rLine)273cdf0e10cSrcweir int GetCommandLineTokenCount( const ByteString& rLine )
274cdf0e10cSrcweir {
275cdf0e10cSrcweir if( ! rLine.Len() )
276cdf0e10cSrcweir return 0;
277cdf0e10cSrcweir
278cdf0e10cSrcweir int nTokenCount = 0;
279cdf0e10cSrcweir const char *pRun = rLine.GetBuffer();
280cdf0e10cSrcweir
281cdf0e10cSrcweir
282cdf0e10cSrcweir while( *pRun )
283cdf0e10cSrcweir {
284cdf0e10cSrcweir while( *pRun && isSpace( *pRun ) )
285cdf0e10cSrcweir pRun++;
286cdf0e10cSrcweir if( ! *pRun )
287cdf0e10cSrcweir break;
288cdf0e10cSrcweir while( *pRun && ! isSpace( *pRun ) )
289cdf0e10cSrcweir {
290cdf0e10cSrcweir if( *pRun == '\\' )
291cdf0e10cSrcweir {
292cdf0e10cSrcweir // escapement
293cdf0e10cSrcweir pRun++;
294cdf0e10cSrcweir if( *pRun )
295cdf0e10cSrcweir pRun++;
296cdf0e10cSrcweir }
297cdf0e10cSrcweir else if( *pRun == '`' )
298cdf0e10cSrcweir {
299cdf0e10cSrcweir do pRun++; while( *pRun && *pRun != '`' );
300cdf0e10cSrcweir if( *pRun )
301cdf0e10cSrcweir pRun++;
302cdf0e10cSrcweir }
303cdf0e10cSrcweir else if( *pRun == '\'' )
304cdf0e10cSrcweir {
305cdf0e10cSrcweir do pRun++; while( *pRun && *pRun != '\'' );
306cdf0e10cSrcweir if( *pRun )
307cdf0e10cSrcweir pRun++;
308cdf0e10cSrcweir }
309cdf0e10cSrcweir else if( *pRun == '"' )
310cdf0e10cSrcweir {
311cdf0e10cSrcweir do pRun++; while( *pRun && *pRun != '"' );
312cdf0e10cSrcweir if( *pRun )
313cdf0e10cSrcweir pRun++;
314cdf0e10cSrcweir }
315cdf0e10cSrcweir else
316cdf0e10cSrcweir pRun++;
317cdf0e10cSrcweir }
318cdf0e10cSrcweir nTokenCount++;
319cdf0e10cSrcweir }
320cdf0e10cSrcweir
321cdf0e10cSrcweir return nTokenCount;
322cdf0e10cSrcweir }
323cdf0e10cSrcweir
WhitespaceToSpace(const String & rLine,sal_Bool bProtect)324cdf0e10cSrcweir String WhitespaceToSpace( const String& rLine, sal_Bool bProtect )
325cdf0e10cSrcweir {
326cdf0e10cSrcweir int nLen = rLine.Len();
327cdf0e10cSrcweir if( ! nLen )
328cdf0e10cSrcweir return String();
329cdf0e10cSrcweir
330cdf0e10cSrcweir sal_Unicode *pBuffer = (sal_Unicode*)alloca( sizeof(sal_Unicode)*(nLen + 1) );
331cdf0e10cSrcweir const sal_Unicode *pRun = rLine.GetBuffer();
332cdf0e10cSrcweir sal_Unicode *pLeap = pBuffer;
333cdf0e10cSrcweir
334cdf0e10cSrcweir while( *pRun )
335cdf0e10cSrcweir {
336cdf0e10cSrcweir if( *pRun && isSpace( *pRun ) )
337cdf0e10cSrcweir {
338cdf0e10cSrcweir *pLeap = ' ';
339cdf0e10cSrcweir pLeap++;
340cdf0e10cSrcweir pRun++;
341cdf0e10cSrcweir }
342cdf0e10cSrcweir while( *pRun && isSpace( *pRun ) )
343cdf0e10cSrcweir pRun++;
344cdf0e10cSrcweir while( *pRun && ! isSpace( *pRun ) )
345cdf0e10cSrcweir {
346cdf0e10cSrcweir if( *pRun == '\\' )
347cdf0e10cSrcweir {
348cdf0e10cSrcweir // escapement
349cdf0e10cSrcweir pRun++;
350cdf0e10cSrcweir *pLeap = *pRun;
351cdf0e10cSrcweir pLeap++;
352cdf0e10cSrcweir if( *pRun )
353cdf0e10cSrcweir pRun++;
354cdf0e10cSrcweir }
355cdf0e10cSrcweir else if( bProtect && *pRun == '`' )
356cdf0e10cSrcweir CopyUntil( pLeap, pRun, '`', sal_True );
357cdf0e10cSrcweir else if( bProtect && *pRun == '\'' )
358cdf0e10cSrcweir CopyUntil( pLeap, pRun, '\'', sal_True );
359cdf0e10cSrcweir else if( bProtect && *pRun == '"' )
360cdf0e10cSrcweir CopyUntil( pLeap, pRun, '"', sal_True );
361cdf0e10cSrcweir else
362cdf0e10cSrcweir {
363cdf0e10cSrcweir *pLeap = *pRun;
364cdf0e10cSrcweir ++pLeap;
365cdf0e10cSrcweir ++pRun;
366cdf0e10cSrcweir }
367cdf0e10cSrcweir }
368cdf0e10cSrcweir }
369cdf0e10cSrcweir
370cdf0e10cSrcweir *pLeap = 0;
371cdf0e10cSrcweir
372cdf0e10cSrcweir // there might be a space at beginning or end
373cdf0e10cSrcweir pLeap--;
374cdf0e10cSrcweir if( *pLeap == ' ' )
375cdf0e10cSrcweir *pLeap = 0;
376cdf0e10cSrcweir
377cdf0e10cSrcweir String aRet( *pBuffer == ' ' ? pBuffer+1 : pBuffer );
378cdf0e10cSrcweir return aRet;
379cdf0e10cSrcweir }
380cdf0e10cSrcweir
WhitespaceToSpace(const ByteString & rLine,sal_Bool bProtect)381cdf0e10cSrcweir ByteString WhitespaceToSpace( const ByteString& rLine, sal_Bool bProtect )
382cdf0e10cSrcweir {
383cdf0e10cSrcweir int nLen = rLine.Len();
384cdf0e10cSrcweir if( ! nLen )
385cdf0e10cSrcweir return ByteString();
386cdf0e10cSrcweir
387cdf0e10cSrcweir char *pBuffer = (char*)alloca( nLen + 1 );
388cdf0e10cSrcweir const char *pRun = rLine.GetBuffer();
389cdf0e10cSrcweir char *pLeap = pBuffer;
390cdf0e10cSrcweir
391cdf0e10cSrcweir while( *pRun )
392cdf0e10cSrcweir {
393cdf0e10cSrcweir if( *pRun && isSpace( *pRun ) )
394cdf0e10cSrcweir {
395cdf0e10cSrcweir *pLeap = ' ';
396cdf0e10cSrcweir pLeap++;
397cdf0e10cSrcweir pRun++;
398cdf0e10cSrcweir }
399cdf0e10cSrcweir while( *pRun && isSpace( *pRun ) )
400cdf0e10cSrcweir pRun++;
401cdf0e10cSrcweir while( *pRun && ! isSpace( *pRun ) )
402cdf0e10cSrcweir {
403cdf0e10cSrcweir if( *pRun == '\\' )
404cdf0e10cSrcweir {
405cdf0e10cSrcweir // escapement
406cdf0e10cSrcweir pRun++;
407cdf0e10cSrcweir *pLeap = *pRun;
408cdf0e10cSrcweir pLeap++;
409cdf0e10cSrcweir if( *pRun )
410cdf0e10cSrcweir pRun++;
411cdf0e10cSrcweir }
412cdf0e10cSrcweir else if( bProtect && *pRun == '`' )
413cdf0e10cSrcweir CopyUntil( pLeap, pRun, '`', sal_True );
414cdf0e10cSrcweir else if( bProtect && *pRun == '\'' )
415cdf0e10cSrcweir CopyUntil( pLeap, pRun, '\'', sal_True );
416cdf0e10cSrcweir else if( bProtect && *pRun == '"' )
417cdf0e10cSrcweir CopyUntil( pLeap, pRun, '"', sal_True );
418cdf0e10cSrcweir else
419cdf0e10cSrcweir {
420cdf0e10cSrcweir *pLeap = *pRun;
421cdf0e10cSrcweir ++pLeap;
422cdf0e10cSrcweir ++pRun;
423cdf0e10cSrcweir }
424cdf0e10cSrcweir }
425cdf0e10cSrcweir }
426cdf0e10cSrcweir
427cdf0e10cSrcweir *pLeap = 0;
428cdf0e10cSrcweir
429cdf0e10cSrcweir // there might be a space at beginning or end
430cdf0e10cSrcweir pLeap--;
431cdf0e10cSrcweir if( *pLeap == ' ' )
432cdf0e10cSrcweir *pLeap = 0;
433cdf0e10cSrcweir
434cdf0e10cSrcweir ByteString aRet( *pBuffer == ' ' ? pBuffer+1 : pBuffer );
435cdf0e10cSrcweir return aRet;
436cdf0e10cSrcweir }
437cdf0e10cSrcweir
438cdf0e10cSrcweir } // namespace
439