xref: /aoo42x/main/idl/source/cmptools/lex.cxx (revision 79aad27f)
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_idl.hxx"
26 
27 
28 #include <ctype.h>
29 #include <stdio.h>
30 
31 #include <char.hxx>
32 #include <hash.hxx>
33 #include <lex.hxx>
34 #include <globals.hxx>
35 #include <tools/bigint.hxx>
36 
37 /****************** SvToken **********************************************/
38 /*************************************************************************
39 |*
40 |*    SvToken::Print()
41 |*
42 |*    Beschreibung
43 |*
44 *************************************************************************/
GetTokenAsString() const45 ByteString SvToken::GetTokenAsString() const
46 {
47     ByteString aStr;
48     switch( nType )
49     {
50         case SVTOKEN_EMPTY:
51             break;
52         case SVTOKEN_COMMENT:
53             aStr = aString;
54             break;
55         case SVTOKEN_INTEGER:
56             aStr = ByteString::CreateFromInt64(nLong);
57             break;
58         case SVTOKEN_STRING:
59             aStr = aString;
60             break;
61         case SVTOKEN_BOOL:
62             aStr = bBool ? "TRUE" : "FALSE";
63             break;
64         case SVTOKEN_IDENTIFIER:
65             aStr = aString;
66             break;
67         case SVTOKEN_CHAR:
68             aStr = cChar;
69             break;
70         case SVTOKEN_RTTIBASE:
71             aStr = "RTTIBASE";//(ULONG)pComplexObj;
72             break;
73         case SVTOKEN_EOF:
74         case SVTOKEN_HASHID:
75             break;
76     }
77 
78     return aStr;
79 }
80 
81 /*************************************************************************
82 |*
83 |*    SvToken::SvToken()
84 |*
85 |*    Beschreibung
86 |*
87 *************************************************************************/
SvToken(const SvToken & rObj)88 SvToken::SvToken( const SvToken & rObj )
89 {
90 	nLine = rObj.nLine;
91 	nColumn = rObj.nColumn;
92 	nType = rObj.nType;
93 	aString = rObj.aString;
94 /*
95     if( SVTOKEN_RTTIBASE = nType )
96 	{
97 	    pComplexObj = rObj.pComplexObj;
98 		pComplexObj->AddRef();
99 	}
100 	else
101 */
102 	    nLong = rObj.nLong;
103 }
104 
105 /*************************************************************************
106 |*
107 |*    SvToken::operator = ()
108 |*
109 |*    Beschreibung
110 |*
111 *************************************************************************/
operator =(const SvToken & rObj)112 SvToken & SvToken::operator = ( const SvToken & rObj )
113 {
114 	if( this != &rObj )
115 	{
116 /*
117         if( SVTOKEN_RTTIBASE = nType )
118 	    	pComplexObj->ReleaseRef();
119 */
120 	    nLine = rObj.nLine;
121 	    nColumn = rObj.nColumn;
122 	    nType = rObj.nType;
123 	    aString = rObj.aString;
124 /*
125         if( SVTOKEN_RTTIBASE = nType )
126 		{
127 	    	pComplexObj = rObj.pComplexObj;
128 			pComplexObj->AddRef();
129 		}
130 		else
131 */
132 		    nLong = rObj.nLong;
133 	}
134     return *this;
135 }
136 
137 /****************** SvTokenStream ****************************************/
138 /*************************************************************************
139 |*    SvTokenStream::InitCtor()
140 |*
141 |*    Beschreibung
142 *************************************************************************/
InitCtor()143 void SvTokenStream::InitCtor()
144 {
145     SetCharSet( gsl_getSystemTextEncoding() );
146 	aStrTrue	= "TRUE";
147 	aStrFalse	= "FALSE";
148     nLine       = nColumn = 0;
149     nBufPos     = 0;
150     nTabSize    = 4;
151 	pCurToken	= NULL;
152 	nMaxPos		= 0;
153     c           = GetNextChar();
154 	FillTokenList();
155 }
156 
157 /*************************************************************************
158 |*    SvTokenStream::SvTokenStream()
159 |*
160 |*    Beschreibung
161 *************************************************************************/
SvTokenStream(const String & rFileName)162 SvTokenStream::SvTokenStream( const String & rFileName )
163     : pInStream( new SvFileStream( rFileName, STREAM_STD_READ | STREAM_NOCREATE ) )
164     , rInStream( *pInStream )
165     , aFileName( rFileName )
166 	, aTokList( 0x8000, 0x8000 )
167 {
168     InitCtor();
169 }
170 
171 /*************************************************************************
172 |*    SvTokenStream::SvTokenStream()
173 |*
174 |*    Beschreibung
175 *************************************************************************/
SvTokenStream(SvStream & rStream,const String & rFileName)176 SvTokenStream::SvTokenStream( SvStream & rStream, const String & rFileName )
177     : pInStream( NULL )
178     , rInStream( rStream )
179     , aFileName( rFileName )
180 	, aTokList( 0x8000, 0x8000 )
181 {
182     InitCtor();
183 }
184 
185 /*************************************************************************
186 |*    SvTokenStream::~SvTokenStream()
187 |*
188 |*    Beschreibung
189 *************************************************************************/
~SvTokenStream()190 SvTokenStream::~SvTokenStream()
191 {
192     delete pInStream;
193     SvToken * pTok = aTokList.Last();
194     while( pTok )
195 	{
196         delete pTok;
197 		pTok = aTokList.Prev();
198 	}
199 }
200 
201 /*************************************************************************
202 |*    SvTokenStream::FillTokenList()
203 |*
204 |*    Beschreibung
205 *************************************************************************/
FillTokenList()206 void SvTokenStream::FillTokenList()
207 {
208 	SvToken * pToken = new SvToken();
209 	aTokList.Insert( pToken, LIST_APPEND );
210 	do
211 	{
212 	    if( !MakeToken( *pToken ) )
213 		{
214 			SvToken * p = aTokList.Prev();
215 	        *pToken = SvToken();
216 			if( p )
217 			{
218 				pToken->SetLine( p->GetLine() );
219 				pToken->SetColumn( p->GetColumn() );
220 			}
221 			break;
222 		}
223 		else if( pToken->IsComment() )
224 			*pToken = SvToken();
225 		else if( pToken->IsEof() )
226 			break;
227 		else
228 		{
229 			pToken = new SvToken();
230 			aTokList.Insert( pToken, LIST_APPEND );
231 		}
232 	}
233 	while( !pToken->IsEof() );
234 	pCurToken = aTokList.First();
235 }
236 
237 /*************************************************************************
238 |*    SvTokenStrem::SetCharSet()
239 |*
240 |*    Beschreibung
241 *************************************************************************/
SetCharSet(CharSet nSet)242 void SvTokenStream::SetCharSet( CharSet nSet )
243 {
244     nCharSet = nSet;
245 
246     pCharTab = SvChar::GetTable( nSet, gsl_getSystemTextEncoding() );
247 }
248 
249 /*************************************************************************
250 |*    SvTokeStream::GetNextChar()
251 |*
252 |*    Beschreibung
253 *************************************************************************/
GetNextChar()254 int SvTokenStream::GetNextChar()
255 {
256     int nChar;
257     if( (int)aBufStr.Len() < nBufPos )
258     {
259         if( rInStream.ReadLine( aBufStr ) )
260         {
261             nLine++;
262             nColumn = 0;
263             nBufPos = 0;
264         }
265         else
266 		{
267 			aBufStr.Erase();
268             nColumn = 0;
269             nBufPos = 0;
270 			return '\0';
271 		}
272     }
273     nChar = aBufStr.GetChar( (sal_uInt16)nBufPos++ );
274     nColumn += nChar == '\t' ? nTabSize : 1;
275     return nChar;
276 }
277 
278 /*************************************************************************
279 |*    SvTokenStrem::GetNumber()
280 |*
281 |*    Beschreibung
282 *************************************************************************/
GetNumber()283 sal_uLong SvTokenStream::GetNumber()
284 {
285     sal_uLong   l = 0;
286     short   nLog = 10;
287 
288     if( '0' == c )
289     {
290         c = GetFastNextChar();
291         if( 'x' == c )
292         {
293             nLog = 16;
294             c = GetFastNextChar();
295         }
296     };
297 
298     if( nLog == 16 )
299     {
300         while( isxdigit( c ) )
301         {
302             if( isdigit( c ) )
303                 l = l * nLog + (c - '0');
304             else
305                 l = l * nLog + (toupper( c ) - 'A' + 10 );
306             c = GetFastNextChar();
307         }
308     }
309     else
310     {
311         while( isdigit( c ) || 'x' == c )
312         {
313             l = l * nLog + (c - '0');
314             c = GetFastNextChar();
315         }
316     }
317 
318     return( l );
319 }
320 
321 /*************************************************************************
322 |*    SvTokenStream::MakeToken()
323 |*
324 |*    Beschreibung
325 *************************************************************************/
MakeToken(SvToken & rToken)326 sal_Bool SvTokenStream::MakeToken( SvToken & rToken )
327 {
328     int             c1;
329     sal_uInt16          i;
330 
331 	do
332 	{
333 		if( 0 == c )
334 	        c = GetNextChar();
335 	    // Leerzeichen ueberlesen
336 	    while( isspace( c ) || 26 == c )
337 		{
338 	        c = GetFastNextChar();
339 		    nColumn += c == '\t' ? nTabSize : 1;
340 		}
341 	}
342 	while( 0 == c && !IsEof() && ( SVSTREAM_OK == rInStream.GetError() ) );
343 
344     sal_uLong nLastLine		= nLine;
345     sal_uLong nLastColumn	= nColumn;
346     // Kommentar
347     if( '/' == c )
348     {
349 		// Zeit Optimierung, keine Kommentare
350         //ByteString aComment( (char)c );
351         c1 = c;
352         c = GetFastNextChar();
353         if( '/' == c )
354         {
355             while( '\0' != c )
356             {
357                 //aComment += (char)c;
358                 c = GetFastNextChar();
359             }
360             c = GetNextChar();
361             rToken.nType 	= SVTOKEN_COMMENT;
362 			//rToken.aString	= aComment;
363         }
364         else if( '*' == c )
365         {
366             //aComment += (char)c;
367             c = GetFastNextChar();
368             do
369 			{
370                 //aComment += (char)c;
371                 while( '*' != c )
372                 {
373 	                if( '\0' == c )
374 					{
375 	                	c = GetNextChar();
376 	                	if( IsEof() )
377 	                    	return sal_False;
378 					}
379 					else
380                     	c = GetFastNextChar();
381                     //aComment += (char)c;
382                 }
383                 c = GetFastNextChar();
384             }
385             while( '/' != c && !IsEof() && ( SVSTREAM_OK == rInStream.GetError() ) );
386             if( IsEof() || ( SVSTREAM_OK != rInStream.GetError() ) )
387                 return sal_False;
388             //aComment += (char)c;
389             c = GetNextChar();
390             rToken.nType = SVTOKEN_COMMENT;
391 			//rToken.aString = aComment;
392 			CalcColumn();
393         }
394         else
395 		{
396 			rToken.nType = SVTOKEN_CHAR;
397             rToken.cChar = (char)c1;
398 		}
399     }
400     else if( c == '"' )
401     {
402         ByteString          aStr;
403         i = 0;
404         sal_Bool bDone = sal_False;
405         while( !bDone && !IsEof() && c )
406         {
407             c = GetFastNextChar();
408 	        if( '\0' == c )
409 			{
410 				// Strings auch "uber das Zeilenende hinauslesen
411 				aStr += '\n';
412 	            c = GetNextChar();
413 	            if( IsEof() )
414 					return sal_False;
415 			}
416             if( c == '"' )
417             {
418                 c = GetFastNextChar();
419                 if( c == '"' )
420                 {
421                     aStr += '"';
422                     aStr += '"';
423                 }
424                 else
425                     bDone = sal_True;
426             }
427             else if( c == '\\' )
428             {
429                 aStr += '\\';
430                 c = GetFastNextChar();
431                 if( c )
432                     aStr += (char)c;
433             }
434             else
435                 aStr += (char)c;
436         }
437         if( IsEof() || ( SVSTREAM_OK != rInStream.GetError() ) )
438             return sal_False;
439         char * pStr = (char *)aStr.GetBuffer();
440         while( *pStr )
441         {
442             *pStr = pCharTab[ (unsigned char)*pStr ];
443             pStr++;
444         };
445         rToken.nType   = SVTOKEN_STRING;
446 		rToken.aString = aStr;
447     }
448     else if( isdigit( c ) )
449     {
450         rToken.nType = SVTOKEN_INTEGER;
451         rToken.nLong = GetNumber();
452 
453     }
454     else if( isalpha (c) || (c == '_') )
455     {
456         ByteString aStr;
457 
458         while( isalnum( c ) || c == '_' )
459         {
460             aStr += (char)c;
461             c = GetFastNextChar();
462         }
463         if( aStr.EqualsIgnoreCaseAscii( aStrTrue ) )
464 		{
465             rToken.nType = SVTOKEN_BOOL;
466 			rToken.bBool = sal_True;
467         }
468         else if( aStr.EqualsIgnoreCaseAscii( aStrFalse ) )
469 		{
470             rToken.nType = SVTOKEN_BOOL;
471 			rToken.bBool = sal_False;
472         }
473         else
474         {
475             sal_uInt32 nHashId;
476             if( IDLAPP->pHashTable->Test( aStr, &nHashId ) )
477                 rToken.SetHash( IDLAPP->pHashTable->Get( nHashId ) );
478 			else
479 			{
480             	rToken.nType   = SVTOKEN_IDENTIFIER;
481 				rToken.aString = aStr;
482 			}
483         }
484     }
485     else if( IsEof() )
486     {
487         rToken.nType = SVTOKEN_EOF;
488     }
489     else
490     {
491         rToken.nType = SVTOKEN_CHAR;
492 		rToken.cChar = (char)c;
493         c = GetFastNextChar();
494     }
495     rToken.SetLine( nLastLine );
496     rToken.SetColumn( nLastColumn );
497 	return rInStream.GetError() == SVSTREAM_OK;
498 }
499 
500