rsc/source/parser/rsclex.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  *
   9  * This file incorporates work covered by the following license notice:
  10  *
  11  *   Licensed to the Apache Software Foundation (ASF) under one or more
  12  *   contributor license agreements. See the NOTICE file distributed
  13  *   with this work for additional information regarding copyright
  14  *   ownership. The ASF licenses this file to you under the Apache
  15  *   License, Version 2.0 (the "License"); you may not use this file
  16  *   except in compliance with the License. You may obtain a copy of
  17  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  18  */
  19
  20 #include <stdlib.h>
  21 #include <stdio.h>
  22 #include <string.h>
  23 #include <ctype.h>
  24 #include <limits.h>
  25
  26 #ifdef _RSCERROR_H
  27 #include <rscerror.h>
  28 #endif
  29 #include <rschash.hxx>
  30 #include <rscdb.hxx>
  31 #include <rsctop.hxx>
  32 #include <rsckey.hxx>
  33 #include <rscpar.hxx>
  34 #include <rscdef.hxx>
  35
  36 #include <rsclex.hxx>
  37 #include <rscyacc.hxx>
  38
  39 #include <rtl/textcvt.h>
  40 #include <rtl/textenc.h>
  41
  42
  43 const char* StringContainer::putString( const char* pString )
  44 {
  45     OString aString( static_cast<const sal_Char*>(pString) );
  46     std::pair<
  47         boost::unordered_set< OString, OStringHash >::iterator,
  48         bool > aInsert =
  49         m_aStrings.insert( aString );
  50
  51     return aInsert.first->getStr();
  52 }
  53
  54 int             c;
  55 sal_Bool            bLastInclude;// War letztes Symbol INCLUDE
  56 RscFileInst*    pFI;
  57 RscTypCont*     pTC;
  58 RscExpression * pExp;
  59 struct KeyVal {
  60     int     nKeyWord;
  61     YYSTYPE aYYSType;
  62 } aKeyVal[ 1 ];
  63 sal_Bool bTargetDefined;
  64
  65 StringContainer* pStringContainer = NULL;
  66
  67
  68 sal_uInt32 GetNumber(){
  69     sal_uInt32  l = 0;
  70     sal_uInt32  nLog = 10;
  71
  72     if( '0' == c ){
  73         c = pFI->GetFastChar();
  74         if( 'x' == c ){
  75             nLog = 16;
  76             c = pFI->GetFastChar();
  77         }
  78     };
  79
  80     if( nLog == 16 ){
  81         while( isxdigit( c ) ){
  82             if( isdigit( c ) )
  83                 l = l * nLog + (c - '0');
  84             else
  85                 l = l * nLog + (toupper( c ) - 'A' + 10 );
  86             c = pFI->GetFastChar();
  87         }
  88     }
  89     else{
  90         while( isdigit( c ) || 'x' == c ){
  91             l = l * nLog + (c - '0');
  92             c = pFI->GetFastChar();
  93         }
  94     }
  95
  96     while( c=='U' || c=='u' || c=='l' || c=='L' ) //Wg. Unsigned Longs
  97         c = pFI->GetFastChar();
  98
  99     if( l > 0x7fffffff ) //Oberstes bit gegebenenfalls abschneiden;
 100         l &= 0x7fffffff;
 101
 102     return( l );
 103 }
 104
 105 int MakeToken( YYSTYPE * pTokenVal ){
 106     int             c1;
 107
 108     while( true ){  // Kommentare und Leerzeichen ueberlesen
 109         while( isspace( c ) )
 110             c = pFI->GetFastChar();
 111         if( '/' == c ){
 112             c1 = c;
 113             c = pFI->GetFastChar();
 114             if( '/' == c ){
 115                 while( '\n' != c && !pFI->IsEof() )
 116                     c = pFI->GetFastChar();
 117                 c = pFI->GetFastChar();
 118             }
 119             else if( '*' == c ){
 120                 c = pFI->GetFastChar();
 121                 do {
 122                     while( '*' != c && !pFI->IsEof() )
 123                         c = pFI->GetFastChar();
 124                     c = pFI->GetFastChar();
 125                 } while( '/' != c && !pFI->IsEof() );
 126                 c = pFI->GetFastChar();
 127             }
 128             else
 129                 return( c1 );
 130         }
 131         else
 132             break;
 133     };
 134
 135     if( c == pFI->IsEof() ){
 136         return( 0 );
 137     }
 138
 139     if( bLastInclude ){
 140         bLastInclude = sal_False; //Zuruecksetzten
 141         if( '<' == c ){
 142             OStringBuffer aBuf( 256 );
 143             c = pFI->GetFastChar();
 144             while( '>' != c && !pFI->IsEof() )
 145             {
 146                 aBuf.append( sal_Char(c) );
 147                 c = pFI->GetFastChar();
 148             };
 149             c = pFI->GetFastChar();
 150             pTokenVal->string = const_cast<char*>(pStringContainer->putString( aBuf.getStr() ));
 151             return( INCLUDE_STRING );
 152         };
 153     }
 154
 155     if( c == '"' )
 156     {
 157         OStringBuffer aBuf( 256 );
 158         sal_Bool bDone = sal_False;
 159         while( !bDone && !pFI->IsEof() && c )
 160         {
 161             c = pFI->GetFastChar();
 162             if( c == '"' )
 163             {
 164                 do
 165                 {
 166                     c = pFI->GetFastChar();
 167                 }
 168                 while(  c == ' ' || c == '\t' );
 169                 if( c == '"' )
 170                 {
 171                     // this is a continued string
 172                     // note: multiline string continuations are handled by the parser
 173                     // see rscyacc.y
 174                 }
 175                 else
 176                     bDone = sal_True;
 177             }
 178             else if( c == '\\' )
 179             {
 180                 aBuf.append( '\\' );
 181                 c = pFI->GetFastChar();
 182                 if( c )
 183                     aBuf.append( sal_Char(c) );
 184             }
 185             else
 186                 aBuf.append( sal_Char(c) );
 187         }
 188         pTokenVal->string = const_cast<char*>(pStringContainer->putString( aBuf.getStr() ));
 189         return( STRING );
 190     }
 191     if (isdigit (c)){
 192         pTokenVal->value = GetNumber();
 193         return( NUMBER );
 194     }
 195
 196     if( isalpha (c) || (c == '_') ){
 197         Atom        nHashId;
 198         OStringBuffer aBuf( 256 );
 199
 200         while( isalnum (c) || (c == '_') || (c == '-') )
 201         {
 202             aBuf.append( sal_Char(c) );
 203             c = pFI->GetFastChar();
 204         }
 205
 206         nHashId = pHS->getID( aBuf.getStr(), true );
 207         if( InvalidAtom != nHashId )
 208         {
 209             KEY_STRUCT  aKey;
 210
 211             // Suche nach dem Schluesselwort
 212             if( pTC->aNmTb.Get( nHashId, &aKey ) )
 213             {
 214
 215                 // Schluesselwort gefunden
 216                 switch( aKey.nTyp )
 217                 {
 218                     case CLASSNAME:
 219                         pTokenVal->pClass = (RscTop *)aKey.yylval;
 220                         break;
 221                     case VARNAME:
 222                         pTokenVal->varid = aKey.nName;
 223                         break;
 224                     case CONSTNAME:
 225                         pTokenVal->constname.hashid = aKey.nName;
 226                         pTokenVal->constname.nValue = aKey.yylval;
 227                         break;
 228                     case BOOLEAN:
 229                         pTokenVal->svbool = (sal_Bool)aKey.yylval;
 230                         break;
 231                     case INCLUDE:
 232                         bLastInclude = sal_True;
 233                     default:
 234                         pTokenVal->value = aKey.yylval;
 235                 };
 236
 237                 return( aKey.nTyp );
 238             }
 239             else
 240             {
 241                 pTokenVal->string = const_cast<char*>(pStringContainer->putString( aBuf.getStr() ));
 242                 return( SYMBOL );
 243             }
 244         }
 245         else{       // Symbol
 246             RscDefine  * pDef;
 247
 248             pDef = pTC->aFileTab.FindDef( aBuf.getStr() );
 249             if( pDef ){
 250                 pTokenVal->defineele = pDef;
 251
 252                 return( RSCDEFINE );
 253             }
 254
 255             pTokenVal->string = const_cast<char*>(pStringContainer->putString( aBuf.getStr() ));
 256             return( SYMBOL );
 257         }
 258     }
 259
 260     if( c=='<' )
 261     {
 262         c = pFI->GetFastChar();
 263         if( c=='<' )
 264         {
 265             c = pFI->GetFastChar();
 266             return LEFTSHIFT;
 267         }
 268         else
 269             return '<';
 270     }
 271
 272     if( c=='>' )
 273     {
 274         c = pFI->GetFastChar();
 275         if( c=='>' )
 276         {
 277             c = pFI->GetFastChar();
 278             return RIGHTSHIFT;
 279         }
 280         else
 281             return '>';
 282     }
 283
 284     c1 = c;
 285     c = pFI->GetFastChar();
 286     return( c1 );
 287 }
 288
 289 #if defined( RS6000 )
 290 extern "C" int yylex()
 291 #else
 292 int yylex()
 293 #endif
 294 {
 295     if( bTargetDefined )
 296         bTargetDefined = sal_False;
 297     else
 298         aKeyVal[ 0 ].nKeyWord =
 299                      MakeToken( &aKeyVal[ 0 ].aYYSType );
 300
 301     yylval = aKeyVal[ 0 ].aYYSType;
 302     return( aKeyVal[ 0 ].nKeyWord );
 303 }
 304
 305 #ifdef RS6000
 306 extern "C" void yyerror( char* pMessage )
 307 #elif defined SOLARIS
 308 extern "C" void yyerror( const char* pMessage )
 309 #else
 310 void yyerror( char* pMessage )
 311 #endif
 312 {
 313     pTC->pEH->Error( ERR_YACC, NULL, RscId(), pMessage );
 314 }
 315
 316 void InitParser( RscFileInst * pFileInst )
 317 {
 318     pTC = pFileInst->pTypCont;          // Datenkontainer setzten
 319     pFI = pFileInst;
 320     pStringContainer = new StringContainer();
 321     pExp = NULL;                //fuer MacroParser
 322     bTargetDefined = sal_False;
 323
 324     // Anfangszeichen initialisieren
 325     bLastInclude = sal_False;
 326     c = pFI->GetFastChar();
 327 }
 328
 329 void EndParser(){
 330     // Stack abraeumen
 331     while( ! S.IsEmpty() )
 332         S.Pop();
 333
 334     // free string container
 335     delete pStringContainer;
 336     pStringContainer = NULL;
 337
 338     if( pExp )
 339         delete pExp;
 340     pTC      = NULL;
 341     pFI      = NULL;
 342     pExp     = NULL;
 343
 344 }
 345
 346 void IncludeParser( RscFileInst * pFileInst )
 347 {
 348     int           nToken;   // Wert des Tokens
 349     YYSTYPE       aYYSType; // Daten des Tokens
 350     RscFile     * pFName;   // Filestruktur
 351     sal_uLong         lKey;     // Fileschluessel
 352     RscTypCont  * pTypCon  = pFileInst->pTypCont;
 353
 354     pFName = pTypCon->aFileTab.Get( pFileInst->GetFileIndex() );
 355     InitParser( pFileInst );
 356
 357     nToken = MakeToken( &aYYSType );
 358     while( 0 != nToken && CLASSNAME != nToken ){
 359         if( '#' == nToken ){
 360             if( INCLUDE == (nToken = MakeToken( &aYYSType )) ){
 361                 if( STRING == (nToken = MakeToken( &aYYSType )) ){
 362                     lKey = pTypCon->aFileTab.NewIncFile( aYYSType.string,
 363                                                          aYYSType.string );
 364                     pFName->InsertDependFile( lKey, ULONG_MAX );
 365                 }
 366                 else if( INCLUDE_STRING == nToken ){
 367                     lKey = pTypCon->aFileTab.NewIncFile( aYYSType.string,
 368                                                          OString() );
 369                     pFName->InsertDependFile( lKey, ULONG_MAX );
 370                 };
 371             };
 372         };
 373         nToken = MakeToken( &aYYSType );
 374     };
 375
 376     EndParser();
 377 }
 378
 379 ERRTYPE parser( RscFileInst * pFileInst )
 380 {
 381     ERRTYPE aError;
 382
 383     InitParser( pFileInst );
 384
 385     aError = yyparse();
 386
 387     EndParser();
 388
 389     // yyparser gibt 0 zurueck, wenn erfolgreich
 390     if( 0 == aError )
 391         aError.Clear();
 392     if( pFileInst->pTypCont->pEH->nErrors )
 393         aError = ERR_ERROR;
 394     pFileInst->SetError( aError );
 395     return( aError );
 396 }
 397
 398 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */