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