idl/source/cmptools/lex.cxx

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