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 *************************************************************************/ 45 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 *************************************************************************/ 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 *************************************************************************/ 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 *************************************************************************/ 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 *************************************************************************/ 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 *************************************************************************/ 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 *************************************************************************/ 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 *************************************************************************/ 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 *************************************************************************/ 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 *************************************************************************/ 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 *************************************************************************/ 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 *************************************************************************/ 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