rsc/source/parser/rscyacc.y

   1 %{
   2 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   3 /*
   4  * This file is part of the LibreOffice project.
   5  *
   6  * This Source Code Form is subject to the terms of the Mozilla Public
   7  * License, v. 2.0. If a copy of the MPL was not distributed with this
   8  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   9  *
  10  * This file incorporates work covered by the following license notice:
  11  *
  12  *   Licensed to the Apache Software Foundation (ASF) under one or more
  13  *   contributor license agreements. See the NOTICE file distributed
  14  *   with this work for additional information regarding copyright
  15  *   ownership. The ASF licenses this file to you under the Apache
  16  *   License, Version 2.0 (the "License"); you may not use this file
  17  *   except in compliance with the License. You may obtain a copy of
  18  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  19  */
  20
  21 #include "sal/config.h"
  22
  23 #include <stdio.h>
  24 #include <ctype.h>
  25 #include <string.h>
  26
  27 #include <rtl/strbuf.hxx>
  28 #include <tools/rc.h>
  29 #include <rscerror.h>
  30 #include <rsctools.hxx>
  31 #include <rscclass.hxx>
  32 #include <rsccont.hxx>
  33 #include <rsctree.hxx>
  34 #include <rscdb.hxx>
  35 #include <rscdef.hxx>
  36 #include <rscpar.hxx>
  37
  38 #include <rsclex.hxx>
  39
  40 ObjectStack                     S;
  41 RscTop *                        pCurClass;
  42 sal_uInt32                      nCurMask;
  43 char                            szErrBuf[ 100 ];
  44
  45 RSCINST GetVarInst( const RSCINST & rInst, const char * pVarName )
  46 {
  47     RSCINST aInst;
  48
  49     aInst = rInst.pClass->GetVariable( rInst, pHS->getID( pVarName ),
  50                                        RSCINST() );
  51
  52     if( !aInst.pData )
  53         pTC->pEH->Error( ERR_NOVARIABLENAME, rInst.pClass, RscId() );
  54
  55     return( aInst );
  56 }
  57
  58 void SetNumber( const RSCINST & rInst, const char * pVarName, sal_Int32 lValue )
  59 {
  60     RSCINST aInst;
  61
  62     aInst = GetVarInst( rInst, pVarName );
  63
  64     if( aInst.pData ){
  65         ERRTYPE aError;
  66         aError = aInst.pClass->SetNumber( aInst, lValue );
  67
  68         if( aError.IsError() )
  69             pTC->pEH->Error( aError, aInst.pClass, RscId() );
  70     }
  71 }
  72
  73 void SetConst( const RSCINST & rInst, const char * pVarName,
  74                Atom nValueId, sal_Int32 nVal )
  75 {
  76     RSCINST aInst;
  77
  78     aInst = GetVarInst( rInst, pVarName );
  79     if( aInst.pData )
  80     {
  81         ERRTYPE aError;
  82         aError = aInst.pClass->SetConst( aInst, nValueId, nVal );
  83
  84         if( aError.IsError() )
  85             pTC->pEH->Error( aError, aInst.pClass, RscId() );
  86     }
  87 }
  88
  89 void SetString( const RSCINST & rInst, const char * pVarName, const char * pStr )
  90 {
  91     RSCINST aInst;
  92
  93     aInst = GetVarInst( rInst, pVarName );
  94     if( aInst.pData ){
  95         ERRTYPE aError;
  96         aError = aInst.pClass->SetString( aInst, pStr );
  97
  98         if( aError.IsError() )
  99             pTC->pEH->Error( aError, aInst.pClass, RscId() );
 100     }
 101 }
 102
 103 RscId MakeRscId( RscExpType aExpType )
 104 {
 105     if( !aExpType.IsNothing() )
 106     {
 107         sal_Int32 lValue(0);
 108
 109         if( !aExpType.Evaluate( &lValue ) )
 110             pTC->pEH->Error( ERR_ZERODIVISION, NULL, RscId() );
 111         if( lValue < 1 || lValue > (sal_Int32)0x7FFF )
 112         {
 113             pTC->pEH->Error( ERR_IDRANGE, NULL, RscId(),
 114                              rtl::OString::valueOf(lValue).getStr() );
 115         }
 116
 117         if( aExpType.IsDefinition() )
 118             return RscId( aExpType.aExp.pDef );
 119         else
 120             return RscId( lValue );
 121     }
 122     return RscId();
 123 }
 124
 125 sal_Bool DoClassHeader( RSCHEADER * pHeader, sal_Bool bMember )
 126 {
 127     RSCINST aCopyInst;
 128     RscId aName1 = MakeRscId( pHeader->nName1 );
 129     RscId aName2 = MakeRscId( pHeader->nName2 );
 130
 131     if( pHeader->pRefClass )
 132         aCopyInst.pClass = pHeader->pRefClass;
 133     else
 134         aCopyInst.pClass = pHeader->pClass;
 135
 136     if( TYPE_COPY == pHeader->nTyp )
 137     {
 138         ObjNode * pCopyObj = aCopyInst.pClass->GetObjNode( aName2 );
 139
 140         if( !pCopyObj )
 141         {
 142             rtl::OStringBuffer aMsg( pHS->getString( aCopyInst.pClass->GetId() ) );
 143             aMsg.append(' ');
 144             aMsg.append(aName2.GetName());
 145             pTC->pEH->Error( ERR_NOCOPYOBJ, pHeader->pClass, aName1,
 146                              aMsg.getStr() );
 147         }
 148         else
 149             aCopyInst.pData = pCopyObj->GetRscObj();
 150     }
 151
 152     if( bMember )
 153     {
 154         // Angabe von Superklassen oder abgeleiteten Klassen ist jetzt erlaubt
 155         if( S.Top().pClass->InHierarchy( pHeader->pClass )
 156           ||  pHeader->pClass->InHierarchy( S.Top().pClass) )
 157         {
 158             if( aCopyInst.IsInst() )
 159             {
 160                 RSCINST aTmpI( S.Top() );
 161                 aTmpI.pClass->Destroy( aTmpI );
 162                 aTmpI.pClass->Create( &aTmpI, aCopyInst );
 163             }
 164         }
 165         else
 166             pTC->pEH->Error( ERR_FALSETYPE, S.Top().pClass, aName1,
 167                              pHS->getString( pHeader->pClass->GetId() ).getStr() );
 168     }
 169     else
 170     {
 171         if( S.IsEmpty() )
 172         {
 173             if( (sal_Int32)aName1 < 256 )
 174                 pTC->pEH->Error( WRN_GLOBALID, pHeader->pClass, aName1 );
 175
 176             if( aCopyInst.IsInst() )
 177                 S.Push( pHeader->pClass->Create( NULL, aCopyInst ) );
 178             else
 179                 S.Push( pHeader->pClass->Create( NULL, RSCINST() ) );
 180
 181             pTC->pEH->StdOut( ".", RscVerbosityVerbose );
 182
 183             if( !aName1.IsId() )
 184                 pTC->pEH->Error( ERR_IDEXPECTED, pHeader->pClass, aName1 );
 185             else
 186             {
 187                 ObjNode * pNode = new ObjNode( aName1, S.Top().pData,
 188                                                pFI->GetFileIndex() );
 189                 if( !pHeader->pClass->PutObjNode( pNode ) )
 190                     pTC->pEH->Error( ERR_DOUBLEID, pHeader->pClass, aName1 );
 191             }
 192         }
 193         else
 194         {
 195             RSCINST aTmpI;
 196             ERRTYPE aError;
 197
 198             if( (sal_Int32)aName1 >= 256 && aName1.IsId() )
 199                 pTC->pEH->Error( WRN_LOCALID, pHeader->pClass, aName1 );
 200             aError = S.Top().pClass->GetElement( S.Top(), aName1,
 201                                                  pHeader->pClass, aCopyInst, &aTmpI );
 202
 203             if( aError.IsWarning() )
 204                 pTC->pEH->Error( aError, pHeader->pClass, aName1 );
 205             else if( aError.IsError() )
 206             {
 207                 if( ERR_CONT_INVALIDTYPE == aError )
 208                     pTC->pEH->Error( aError, S.Top().pClass, aName1,
 209                                      pHS->getString( pHeader->pClass->GetId() ).getStr() );
 210                 else
 211                     pTC->pEH->Error( aError, S.Top().pClass, aName1 );
 212                 S.Top().pClass->GetElement( S.Top(), RscId(),
 213                                             pHeader->pClass, RSCINST(), &aTmpI );
 214
 215                 if( !aTmpI.IsInst() )
 216                     return( sal_False );
 217             }
 218             S.Push( aTmpI );
 219         }
 220     }
 221     if( TYPE_REF == pHeader->nTyp )
 222     {
 223         ERRTYPE aError;
 224
 225         aError = S.Top().pClass->SetRef( S.Top(), aName2 );
 226         pTC->pEH->Error( aError, S.Top().pClass, aName1 );
 227     }
 228
 229     return( sal_True );
 230 }
 231
 232 RSCINST GetFirstTupelEle( const RSCINST & rTop )
 233 { // Aufwaertskompatible, Tupel probieren
 234     RSCINST aInst;
 235     ERRTYPE aErr;
 236
 237     aErr = rTop.pClass->GetElement( rTop, RscId(), NULL, RSCINST(), &aInst );
 238     if( !aErr.IsError() )
 239         aInst = aInst.pClass->GetTupelVar( aInst, 0, RSCINST() );
 240     return aInst;
 241 }
 242
 243 //#define YYDEBUG 1
 244
 245 #ifdef UNX
 246 #define YYMAXDEPTH              2000
 247 #else
 248 #define YYMAXDEPTH              800
 249 #endif
 250
 251 #if defined _MSC_VER
 252 #pragma warning(push, 1)
 253 #pragma warning(disable:4129 4273 4701 4702)
 254 #endif
 255 #if HAVE_GCC_PRAGMA_DIAGNOSTIC_MODIFY
 256 #pragma GCC diagnostic ignored "-Wwrite-strings"
 257 #elif defined __SUNPRO_CC
 258 #pragma disable_warn
 259 #endif
 260 %}
 261
 262 /* Compilerstack */
 263
 264 %union {
 265         Atom                    varid;
 266         struct {
 267                 Atom                    hashid;
 268                 sal_Int32                       nValue;
 269         }                               constname;
 270         RscTop *                pClass;
 271         RSCHEADER               header;
 272         struct {
 273                 CLASS_DATA      pData;
 274                 RscTop *        pClass;
 275         }                               instance;
 276         sal_Int32                       value;
 277         sal_uInt16                      ushort;
 278         short                   exp_short;
 279         char *                  string;
 280         sal_Bool                        svbool;
 281         REF_ENUM                copyref;
 282         RscDefine         * defineele;
 283         CharSet                 charset;
 284         RscExpType              macrostruct;
 285 }
 286
 287 /* Token */
 288 %token <value>                  NUMBER
 289 %token <string>                 SYMBOL
 290 %token <defineele>              RSCDEFINE
 291 %token <string>                 STRING
 292 %token <string>                 INCLUDE_STRING
 293 %token <character>              CHARACTER
 294 %token <svbool>                 BOOLEAN
 295
 296 %token LINE
 297 %token AUTO_ID
 298 %token NOT
 299 %token XSCALE
 300 %token YSCALE
 301 %token RGB
 302 %token GEOMETRY
 303 %token POSITION
 304 %token DIMENSION
 305 %token INZOOMOUTPUTSIZE
 306 %token FLOATINGPOS
 307 %token DEFINE
 308 %token INCLUDE
 309 %token MACROTARGET
 310 %token DEFAULT
 311
 312
 313 %token <pClass>                 CLASSNAME
 314 %token <varid>                  VARNAME
 315 %token <constname>              CONSTNAME
 316 %token CLASS
 317 %token EXTENDABLE
 318 %token WRITEIFSET
 319
 320
 321 %type  <macrostruct>    macro_expression
 322 %type  <macrostruct>    id_expression
 323 %type  <value>                  long_expression
 324 %type  <string>                 string_multiline
 325
 326 %type  <pClass>                 type
 327 %type  <pClass>                 type_base
 328 %type  <header>                 class_header_body
 329 %type  <header>                 class_header
 330 %type  <header>                 var_header_class
 331 %type  <copyref>                copy_ref
 332 %type  <ushort>                 type_flags
 333
 334
 335 %left '|'
 336 %left '&'
 337 %left LEFTSHIFT RIGHTSHIFT
 338 %left '+' '-'
 339 %left '*' '/'
 340 %left UNARYMINUS
 341 %left UNARYPLUS
 342 %left ','
 343 %left '(' ')'
 344
 345
 346 /*      Grammatik  */
 347
 348 %start resource_definitions
 349
 350 %%
 351
 352 resource_definitions
 353   :
 354   | resource_definitions resource_definition
 355   | MACROTARGET macro_expression
 356         {
 357                 RscExpType              aExpType;
 358                 sal_Int32                       lValue;
 359
 360                 aExpType.cType = RSCEXP_NOTHING;
 361                 pExp = new RscExpression( aExpType, '+', $2 );
 362                 if( !pExp->Evaluate( &lValue ) )
 363                         pTC->pEH->Error( ERR_ZERODIVISION, NULL, RscId() );
 364         }
 365   ;
 366
 367 resource_definition
 368   : line_number
 369   | '#' DEFINE SYMBOL macro_expression
 370         {
 371                 sal_Bool                bError = sal_False;
 372
 373                 if( $4.IsNumber() ){
 374                         if( !pTC->aFileTab.NewDef( pFI->GetFileIndex(),
 375                                                                            rtl::OString( $3 ),
 376                                                                            $4.GetLong(), ULONG_MAX ) )
 377                                 bError = sal_True;
 378                 }
 379                 else if( $4.IsDefinition() ){
 380                         RscExpType              aExpType;
 381                         RscExpression * pExpr;
 382
 383                         aExpType.cType = RSCEXP_NOTHING;
 384                         aExpType.SetLong( 0 );
 385                         aExpType.cType = RSCEXP_LONG;
 386                         pExpr = new RscExpression( aExpType, '+', $4 );
 387
 388                         if( !pTC->aFileTab.NewDef( pFI->GetFileIndex(),
 389                                                                            rtl::OString( $3 ), pExpr, ULONG_MAX ) )
 390                                 bError = sal_True;
 391                 }
 392                 else if( $4.IsExpression() ){
 393                         if( !pTC->aFileTab.NewDef( pFI->GetFileIndex(),
 394                                                                            rtl::OString( $3 ), $4.aExp.pExp,
 395                                                                            ULONG_MAX ) )
 396                                 bError = sal_True;
 397                 }
 398
 399                 if( bError ){
 400                         pTC->pEH->Error( ERR_DECLAREDEFINE, NULL, RscId(), $3 );
 401                 }
 402         }
 403   | '#' DEFINE RSCDEFINE macro_expression
 404         {
 405                 pTC->pEH->Error( ERR_DOUBLEDEFINE, NULL, RscId(), $3->GetName().getStr() );
 406         }
 407   | '#' INCLUDE STRING
 408         {
 409         }
 410   | '#' INCLUDE INCLUDE_STRING
 411         {
 412         }
 413   | class_definition ';'
 414         {
 415 #ifdef D40
 416                         void * pMem;
 417                         pMem = rtl_allocateMemory( 20000 );
 418                         rtl_freeMemory( pMem );
 419 #endif
 420         }
 421   | new_class_definition_header '{' new_class_definition_body '}' ';'
 422   | new_class_definition_header ';'
 423   ;
 424
 425 new_class_definition_header
 426   : CLASS SYMBOL id_expression ':' CLASSNAME
 427         {
 428                 sal_Int32       lType;
 429
 430                 $3.Evaluate( &lType );
 431
 432                 // Klasse anlegen
 433                 Atom nId = pHS->getID( $2 );
 434                 pCurClass = new RscClass( nId, lType, $5 );
 435                 nCurMask = 1;
 436                 pTC->aNmTb.Put( nId, CLASSNAME, pCurClass );
 437                 pTC->GetRoot()->Insert( pCurClass );
 438         }
 439   | CLASS CLASSNAME id_expression ':' CLASSNAME
 440         {
 441                 pCurClass = $2;
 442                 nCurMask = 1;
 443         }
 444   ;
 445
 446 new_class_definition_body
 447   :
 448   | property_definition ';' new_class_definition_body
 449   ;
 450
 451 property_definition
 452   : type_flags type SYMBOL
 453   {
 454         // Variable anlegen
 455         Atom nId = pTC->aNmTb.Put( $3, VARNAME );
 456         pCurClass->SetVariable( nId, $2, NULL, $1, nCurMask );
 457         nCurMask <<= 1;
 458   }
 459   | type_flags type VARNAME
 460   {
 461         pCurClass->SetVariable( $3, $2, NULL, $1, nCurMask );
 462         nCurMask <<= 1;
 463   }
 464   ;
 465
 466 type_flags
 467   : type_flags EXTENDABLE
 468   {
 469         $$ = $1 | VAR_EXTENDABLE;
 470   }
 471   | type_flags WRITEIFSET
 472   {
 473         $$ = $1 | VAR_SVDYNAMIC;
 474   }
 475   |
 476   {
 477         $$ = 0;
 478   }
 479   ;
 480
 481 type
 482   : type_base
 483   {
 484         $$ = $1;
 485   }
 486   | type_base '[' ']'
 487   {
 488         if( $1 )
 489         {
 490                 rtl::OString aTypeName = rtl::OStringBuffer(pHS->getString($1->GetId())).
 491                     append("[]").makeStringAndClear();
 492                 $$ = pTC->SearchType( pHS->getID( aTypeName.getStr(), true ) );
 493                 if( !$$ )
 494                 {
 495                         RscCont * pCont;
 496                         pCont = new RscCont( pHS->getID( aTypeName.getStr() ), RSC_NOTYPE );
 497                         pCont->SetTypeClass( $1 );
 498                         pTC->InsertType( pCont );
 499                         $$ = pCont;
 500                 }
 501         }
 502         else
 503                 $$ = NULL;
 504   }
 505   ;
 506
 507 type_base
 508   : CLASSNAME
 509   {
 510         $$ = $1;
 511   }
 512   | SYMBOL
 513   {
 514         RscTop * pType = pTC->SearchType( pHS->getID( $1, true ) );
 515         if( !pType )
 516                 pTC->pEH->Error( ERR_NOTYPE, pCurClass, RscId() );
 517         $$ = pType;
 518   }
 519   ;
 520
 521 class_definition
 522   : class_header class_body
 523   {
 524         if( TYPE_REF == $1.nTyp )
 525                 pTC->pEH->Error( ERR_REFNOTALLOWED, S.Top().pClass,
 526                                                  RscId( $1.nName1 ) );
 527         S.Pop();
 528   }
 529   | class_header
 530   {
 531         ERRTYPE aError;
 532         RscId aRscId( $1.nName1 );
 533
 534         if( TYPE_NOTHING == $1.nTyp && aRscId.IsId() )
 535                 aError = S.Top().pClass->SetRef( S.Top(), aRscId );
 536         else if( TYPE_COPY == $1.nTyp )
 537                 aError = ERR_COPYNOTALLOWED;
 538         if( aError.IsError() || aError.IsWarning() )
 539                 pTC->pEH->Error( aError, S.Top().pClass, aRscId );
 540         S.Pop();
 541   }
 542   ;
 543
 544 class_header
 545   : class_header_body
 546         {
 547                 if( !DoClassHeader( &$1, sal_False ) )
 548                         return( ERR_ERROR );
 549                 $$ = $1;
 550         }
 551   ;
 552
 553 copy_ref
 554   : '<'
 555         {
 556                 $$ = TYPE_COPY;
 557         }
 558   | ','
 559         {
 560                 $$ = TYPE_REF;
 561         }
 562   ;
 563
 564 class_header_body
 565   : CLASSNAME id_expression copy_ref CLASSNAME id_expression
 566         {
 567                 $$.pClass = $1;
 568                 $$.nName1 = $2;
 569                 $$.nTyp = $3;
 570                 $$.pRefClass = $4;
 571                 $$.nName2 = $5;
 572         }
 573   | CLASSNAME id_expression copy_ref id_expression
 574         {
 575                 $$.pClass = $1;
 576                 $$.nName1 = $2;
 577                 $$.nTyp = $3;
 578                 $$.pRefClass = NULL;
 579                 $$.nName2 = $4;
 580         }
 581   | CLASSNAME id_expression
 582         {
 583                 $$.pClass = $1;
 584                 $$.nName1 = $2;
 585                 $$.nTyp = TYPE_NOTHING;
 586                 $$.pRefClass = NULL;
 587                 $$.nName2.cType = RSCEXP_NOTHING;
 588         }
 589   | CLASSNAME copy_ref id_expression
 590         {
 591                 $$.pClass = $1;
 592                 $$.nName1.cType = RSCEXP_NOTHING;
 593                 $$.nTyp = $2;
 594                 $$.pRefClass = NULL;
 595                 $$.nName2 = $3;
 596         }
 597   | CLASSNAME copy_ref CLASSNAME id_expression
 598         {
 599                 $$.pClass = $1;
 600                 $$.nName1.cType = RSCEXP_NOTHING;
 601                 $$.nTyp = $2;
 602                 $$.pRefClass = $3;
 603                 $$.nName2 = $4;
 604         }
 605   | CLASSNAME
 606         {
 607                 $$.pClass = $1;
 608                 $$.nName1.cType = RSCEXP_NOTHING;
 609                 $$.nTyp = TYPE_NOTHING;
 610                 $$.nName2.cType = RSCEXP_NOTHING;
 611         }
 612   ;
 613
 614 class_body
 615   : '{' var_definitions '}'
 616   | '{' '}'
 617   | string_multiline
 618         {
 619                 SetString( S.Top(), "TEXT", $1 );
 620         }
 621   ;
 622
 623 var_definitions
 624   : var_definition
 625   | var_definitions var_definition
 626   ;
 627
 628 xy_mapmode
 629   : CONSTNAME
 630         {
 631                 SetConst( S.Top(), "_XYMAPMODE", $1.hashid, $1.nValue );
 632         }
 633   |
 634   ;
 635
 636 wh_mapmode
 637   : CONSTNAME
 638         {
 639                 SetConst( S.Top(), "_WHMAPMODE", $1.hashid, $1.nValue );
 640         }
 641   |
 642   ;
 643
 644 xywh_mapmode
 645   : CONSTNAME
 646         {
 647                 SetConst( S.Top(), "_XYMAPMODE", $1.hashid, $1.nValue );
 648                 SetConst( S.Top(), "_WHMAPMODE", $1.hashid, $1.nValue );
 649         }
 650   |
 651   ;
 652
 653 var_definition
 654   : line_number
 655   | var_header var_body ';'
 656         {
 657                 S.Pop();
 658         }
 659   | class_definition ';'
 660   | var_header_class class_body ';'
 661         {
 662                 if( TYPE_REF == $1.nTyp )
 663                         pTC->pEH->Error( ERR_REFNOTALLOWED, S.Top().pClass,
 664                                                          RscId( $1.nName1 ) );
 665
 666                 if( S.Top().pClass->GetCount( S.Top() ) )
 667                         pTC->pEH->Error( WRN_SUBINMEMBER, S.Top().pClass,
 668                                                          RscId(  $1.nName1 ) );
 669
 670                 S.Pop();
 671         }
 672   | var_header_class ';'
 673         {
 674                 ERRTYPE aError;
 675                 RscId aRscId( $1.nName1 );
 676
 677                 if( TYPE_NOTHING == $1.nTyp && aRscId.IsId() )
 678                         aError = S.Top().pClass->SetRef( S.Top(), aRscId );
 679                 else if( TYPE_COPY == $1.nTyp )
 680                         aError = ERR_COPYNOTALLOWED;
 681                 if( S.Top().pClass->GetCount( S.Top() ) )
 682                         aError = WRN_SUBINMEMBER;
 683                 if( aError.IsError() || aError.IsWarning() )
 684                         pTC->pEH->Error( aError, S.Top().pClass, aRscId );
 685
 686                 S.Pop();
 687         }
 688   | XSCALE '=' '(' long_expression ',' long_expression ')' ';'
 689         {
 690                 SetNumber( S.Top(), "_XNUMERATOR", $4 );
 691                 SetNumber( S.Top(), "_XDENOMINATOR", $6 );
 692         }
 693   | YSCALE '=' '(' long_expression ',' long_expression ')' ';'
 694         {
 695                 SetNumber( S.Top(), "_YNUMERATOR", $4 );
 696                 SetNumber( S.Top(), "_YDENOMINATOR", $6 );
 697         }
 698   | RGB '=' '(' long_expression ',' long_expression
 699                                 ',' long_expression ')' ';'
 700         {
 701                 SetNumber( S.Top(), "RED", $4 );
 702                 SetNumber( S.Top(), "GREEN", $6 );
 703                 SetNumber( S.Top(), "BLUE", $8 );
 704         }
 705   | GEOMETRY '=' xywh_mapmode '(' long_expression ',' long_expression ','
 706                                                 long_expression ',' long_expression ')' ';'
 707         {
 708                 SetNumber( S.Top(), "_X", $5 );
 709                 SetNumber( S.Top(), "_Y", $7 );
 710                 SetNumber( S.Top(), "_WIDTH", $9 );
 711                 SetNumber( S.Top(), "_HEIGHT", $11 );
 712         }
 713   | POSITION '=' xy_mapmode '(' long_expression ',' long_expression
 714                                                         ')' ';'
 715         {
 716                 SetNumber( S.Top(), "_X", $5 );
 717                 SetNumber( S.Top(), "_Y", $7 );
 718         }
 719   | DIMENSION '=' wh_mapmode '(' long_expression ',' long_expression
 720                                                          ')' ';'
 721         {
 722                 SetNumber( S.Top(), "_WIDTH", $5 );
 723                 SetNumber( S.Top(), "_HEIGHT", $7 );
 724         }
 725   | INZOOMOUTPUTSIZE '=' CONSTNAME '(' long_expression ',' long_expression
 726                                                          ')' ';'
 727         {
 728                 SetConst( S.Top(), "_ZOOMINMAPMODE", $3.hashid, $3.nValue );
 729                 SetNumber( S.Top(), "_ZOOMINWIDTH", $5 );
 730                 SetNumber( S.Top(), "_ZOOMINHEIGHT", $7 );
 731         }
 732   | INZOOMOUTPUTSIZE '=' '(' long_expression ',' long_expression ')' ';'
 733         {
 734                 SetNumber( S.Top(), "_ZOOMINWIDTH", $4 );
 735                 SetNumber( S.Top(), "_ZOOMINHEIGHT", $6 );
 736         }
 737   | FLOATINGPOS '=' CONSTNAME '(' long_expression ',' long_expression
 738                                                          ')' ';'
 739         {
 740                 SetConst( S.Top(),      "_FLOATINGPOSMAPMODE", $3.hashid, $3.nValue );
 741                 SetNumber( S.Top(), "_FLOATINGPOSX", $5 );
 742                 SetNumber( S.Top(), "_FLOATINGPOSY", $7 );
 743         }
 744   | FLOATINGPOS '=' '(' long_expression ',' long_expression ')' ';'
 745         {
 746                 SetNumber( S.Top(), "_FLOATINGPOSX", $4 );
 747                 SetNumber( S.Top(), "_FLOATINGPOSY", $6 );
 748         }
 749   ;
 750
 751 var_header_class
 752   : VARNAME '=' class_header_body
 753         {
 754                 RSCINST aInst;
 755
 756                 aInst = S.Top().pClass->GetVariable( S.Top(), $1, RSCINST(), sal_False, $3.pClass );
 757
 758                 if( aInst.pData )
 759                         S.Push( aInst );
 760                 else
 761                 {
 762                         pTC->pEH->Error( ERR_NOVARIABLENAME, S.Top().pClass, RscId(),
 763                                                          pHS->getString( $1 ).getStr() );
 764                         return( ERR_ERROR );
 765                 }
 766
 767                 if( !DoClassHeader( &$3, sal_True ) )
 768                         return( ERR_ERROR );
 769                 $$ = $3;
 770         }
 771   | VARNAME '[' CONSTNAME ']' '=' class_header_body
 772         {
 773                 RSCINST aInst;
 774
 775                 aInst = S.Top().pClass->GetVariable( S.Top(), $1, RSCINST() );
 776
 777                 if( aInst.pData )
 778                 {
 779                         ERRTYPE aError;
 780                         RSCINST aIdxInst;
 781
 782                         aError = aInst.pClass->GetArrayEle( aInst, $3.hashid, NULL, &aIdxInst );
 783                         if( aError.IsError() || aError.IsWarning() )
 784                                  pTC->pEH->Error( aError, S.Top().pClass, RscId() );
 785                         if( aError.IsError() )
 786                                 return( ERR_ERROR );
 787                         S.Push( aIdxInst );
 788                 }
 789                 else
 790                 {
 791                         pTC->pEH->Error( ERR_NOVARIABLENAME, S.Top().pClass, RscId(),
 792                                                          pHS->getString( $1 ).getStr() );
 793                         return( ERR_ERROR );
 794                 }
 795                 if( !DoClassHeader( &$6, sal_True ) )
 796                         return( ERR_ERROR );
 797                 $$ = $6;
 798         }
 799   | VARNAME '[' SYMBOL ']' '=' class_header_body
 800         {
 801                 RSCINST aInst;
 802
 803                 aInst = S.Top().pClass->GetVariable( S.Top(), $1, RSCINST() );
 804
 805                 if( aInst.pData )
 806                 {
 807             long nNewLang = pTC->AddLanguage( $3 );
 808                         ERRTYPE aError;
 809                         RSCINST aIdxInst;
 810
 811                         aError = aInst.pClass->GetArrayEle( aInst, nNewLang, NULL, &aIdxInst );
 812                         if( aError.IsError() || aError.IsWarning() )
 813                                  pTC->pEH->Error( aError, S.Top().pClass, RscId() );
 814                         if( aError.IsError() )
 815                                 return( ERR_ERROR );
 816                         S.Push( aIdxInst );
 817                 }
 818                 else
 819                 {
 820                         pTC->pEH->Error( ERR_NOVARIABLENAME, S.Top().pClass, RscId(),
 821                                                          pHS->getString( $1 ).getStr() );
 822                         return( ERR_ERROR );
 823                 }
 824                 if( !DoClassHeader( &$6, sal_True ) )
 825                         return( ERR_ERROR );
 826                 $$ = $6;
 827         }
 828   ;
 829
 830 var_header
 831   : VARNAME '='
 832         {
 833                 RSCINST aInst;
 834
 835                 aInst = S.Top().pClass->GetVariable( S.Top(), $1, RSCINST() );
 836
 837                 if( aInst.pData )
 838                         S.Push( aInst );
 839                 else{
 840                         pTC->pEH->Error( ERR_NOVARIABLENAME, S.Top().pClass, RscId(),
 841                                                          pHS->getString( $1 ).getStr() );
 842                         return( ERR_ERROR );
 843                 }
 844         }
 845   | VARNAME '[' CONSTNAME ']' '='
 846         {
 847                 RSCINST aInst;
 848
 849                 aInst = S.Top().pClass->GetVariable( S.Top(), $1, RSCINST() );
 850
 851                 if( aInst.pData )
 852                 {
 853                         ERRTYPE aError;
 854                         RSCINST aIdxInst;
 855
 856                         aError = aInst.pClass->GetArrayEle( aInst, $3.hashid, NULL, &aIdxInst );
 857                         if( aError.IsError() || aError.IsWarning() )
 858                                  pTC->pEH->Error( aError, S.Top().pClass, RscId() );
 859                         if( aError.IsError() )
 860                                 return( ERR_ERROR );
 861                         S.Push( aIdxInst );
 862                 }
 863                 else{
 864                         pTC->pEH->Error( ERR_NOVARIABLENAME, S.Top().pClass, RscId(),
 865                                                          pHS->getString( $1 ).getStr() );
 866                         return( ERR_ERROR );
 867                 }
 868         }
 869   | VARNAME '[' SYMBOL ']' '='
 870         {
 871                 RSCINST aInst;
 872
 873                 aInst = S.Top().pClass->GetVariable( S.Top(), $1, RSCINST() );
 874
 875                 if( aInst.pData )
 876                 {
 877             long nNewLang = pTC->AddLanguage( $3 );
 878                         ERRTYPE aError;
 879                         RSCINST aIdxInst;
 880
 881                         aError = aInst.pClass->GetArrayEle( aInst, nNewLang, NULL, &aIdxInst );
 882                         if( aError.IsError() || aError.IsWarning() )
 883                                  pTC->pEH->Error( aError, S.Top().pClass, RscId() );
 884                         if( aError.IsError() )
 885                                 return( ERR_ERROR );
 886                         S.Push( aIdxInst );
 887                 }
 888                 else{
 889                         pTC->pEH->Error( ERR_NOVARIABLENAME, S.Top().pClass, RscId(),
 890                                                          pHS->getString( $1 ).getStr() );
 891                         return( ERR_ERROR );
 892                 }
 893         }
 894   ;
 895 tupel_header0
 896   :
 897         {
 898                 RSCINST aInst;
 899
 900                 aInst = S.Top().pClass->GetTupelVar( S.Top(), 0, RSCINST() );
 901                 if( aInst.pData )
 902                         S.Push( aInst );
 903                 else
 904                 {
 905                         pTC->pEH->Error( ERR_NOTUPELNAME, S.Top().pClass, RscId() );
 906                         return( ERR_ERROR );
 907                 }
 908         }
 909   ;
 910
 911 tupel_header1
 912   :
 913         {
 914                 RSCINST aInst;
 915
 916                 aInst = S.Top().pClass->GetTupelVar( S.Top(), 1, RSCINST() );
 917                 if( aInst.pData )
 918                         S.Push( aInst );
 919                 else
 920                 {
 921                         pTC->pEH->Error( ERR_NOTUPELNAME, S.Top().pClass, RscId() );
 922                         return( ERR_ERROR );
 923                 }
 924         }
 925   ;
 926
 927 tupel_header2
 928   :
 929         {
 930                 RSCINST aInst;
 931
 932                 aInst = S.Top().pClass->GetTupelVar( S.Top(), 2, RSCINST() );
 933                 if( aInst.pData )
 934                         S.Push( aInst );
 935                 else
 936                 {
 937                         pTC->pEH->Error( ERR_NOTUPELNAME, S.Top().pClass, RscId() );
 938                         return( ERR_ERROR );
 939                 }
 940         }
 941   ;
 942
 943 tupel_header3
 944   :
 945         {
 946                 RSCINST aInst;
 947
 948                 aInst = S.Top().pClass->GetTupelVar( S.Top(), 3, RSCINST() );
 949                 if( !aInst.pData )
 950                 {
 951                         pTC->pEH->Error( ERR_NOTUPELNAME, S.Top().pClass, RscId() );
 952                         return( ERR_ERROR );
 953                 }
 954                 S.Push( aInst );
 955         }
 956   ;
 957
 958 tupel_body
 959   : var_body
 960         {
 961                 S.Pop();
 962         }
 963   ;
 964
 965 var_list_header
 966   :
 967         {
 968                 ERRTYPE aError;
 969                 RSCINST aInst;
 970
 971                 aError = S.Top().pClass->GetElement( S.Top(), RscId(),
 972                                                                                         NULL, RSCINST(), &aInst );
 973                 if( aError.IsError() || aError.IsWarning() )
 974                         pTC->pEH->Error( aError, S.Top().pClass, RscId() );
 975                 if( aError.IsError() )
 976                 { // unbedingt Instanz auf den Stack bringen
 977                         aInst = S.Top().pClass->Create( NULL, RSCINST() );
 978                 }
 979                 S.Push( aInst );
 980         }
 981   ;
 982
 983 list_body
 984   : var_bodycomplex
 985         {
 986                 S.Pop();
 987         }
 988   ;
 989
 990 list_header
 991   :
 992         {
 993                 sal_uInt32 nCount = S.Top().pClass->GetCount( S.Top() );
 994                 sal_uInt32 i;
 995
 996                 for( i = nCount; i > 0; i-- )
 997                         S.Top().pClass->DeletePos( S.Top(), i -1 );
 998         }
 999   ;
1000
1001 list
1002   : list var_list_header list_body ';'
1003   | list var_bodysimple ';'
1004   | list class_definition ';'
1005   | list line_number
1006   |
1007   ;
1008
1009 var_bodysimple
1010   : macro_expression
1011         {
1012                 sal_Int32       l;
1013                 ERRTYPE aError;
1014
1015                 if( !$1.Evaluate( &l ) )
1016                         pTC->pEH->Error( ERR_ZERODIVISION, NULL, RscId() );
1017                 else
1018                 {
1019                         aError = S.Top().pClass->SetRef( S.Top(), RscId( $1 ) );
1020                         if( aError.IsError() )
1021                         {
1022                                 aError.Clear();
1023                                 aError = S.Top().pClass->SetNumber( S.Top(), l );
1024                         }
1025                         if( aError.IsError() )
1026                         { // Aufwaertskompatible, Tupel probieren
1027                                 RSCINST aInst = GetFirstTupelEle( S.Top() );
1028                                 if( aInst.pData )
1029                                 {
1030                                         aError.Clear(); // Fehler zuruecksetzen
1031                                         aError = aInst.pClass->SetRef( aInst, RscId( $1 ) );
1032                                         if( aError.IsError() )
1033                                         {
1034                                                 aError.Clear();
1035                                                 aError = aInst.pClass->SetNumber( aInst, l );
1036                                         }
1037                                 }
1038                         }
1039                 }
1040
1041                 if( $1.IsExpression() )
1042                         delete $1.aExp.pExp;
1043
1044                 if( aError.IsError() || aError.IsWarning() )
1045                         pTC->pEH->Error( aError, S.Top().pClass, RscId() );
1046         }
1047   | CONSTNAME
1048         {
1049                 ERRTYPE aError;
1050                 aError = S.Top().pClass->SetConst( S.Top(), $1.hashid, $1.nValue );
1051                 if( aError.IsError() )
1052                 { // Aufwaertskompatible, Tupel probieren
1053                         RSCINST aInst = GetFirstTupelEle( S.Top() );
1054                         if( aInst.pData )
1055                         {
1056                                 aError.Clear(); // Fehler zuruecksetzen
1057                                 aError = aInst.pClass->SetConst( aInst, $1.hashid, $1.nValue );
1058                         }
1059                 }
1060
1061                 if( aError.IsError() || aError.IsWarning() )
1062                         pTC->pEH->Error( aError, S.Top().pClass, RscId() );
1063         }
1064   | NOT CONSTNAME
1065         {
1066                 ERRTYPE aError;
1067                 aError = S.Top().pClass->SetNotConst( S.Top(), $2.hashid );
1068                 if( aError.IsError() )
1069                 { // Aufwaertskompatible, Tupel probieren
1070                         RSCINST aInst = GetFirstTupelEle( S.Top() );
1071                         if( aInst.pData )
1072                         {
1073                                 aError.Clear(); // Fehler zuruecksetzen
1074                                 aError = aInst.pClass->SetNotConst( aInst, $2.hashid );
1075                         }
1076                 }
1077
1078                 if( aError.IsError() || aError.IsWarning() )
1079                         pTC->pEH->Error( aError, S.Top().pClass, RscId() );
1080         }
1081   | BOOLEAN
1082         {
1083                 ERRTYPE aError;
1084                 aError = S.Top().pClass->SetBool( S.Top(), $1 );
1085                 if( aError.IsError() )
1086                 { // Aufwaertskompatible, Tupel probieren
1087                         RSCINST aInst = GetFirstTupelEle( S.Top() );
1088                         if( aInst.pData )
1089                         {
1090                                 aError.Clear(); // Fehler zuruecksetzen
1091                                 aError = aInst.pClass->SetBool( aInst, $1 );
1092                         }
1093                 }
1094
1095                 if( aError.IsError() || aError.IsWarning() )
1096                         pTC->pEH->Error( aError, S.Top().pClass, RscId() );
1097         }
1098   | string_multiline
1099         {
1100                 ERRTYPE aError;
1101                 aError = S.Top().pClass->SetString( S.Top(), $1 );
1102                 if( aError.IsError() )
1103                 { // Aufwaertskompatible, Tupel probieren
1104                         RSCINST aInst = GetFirstTupelEle( S.Top() );
1105                         if( aInst.pData )
1106                         {
1107                                 aError.Clear(); // Fehler zuruecksetzen
1108                                 aError = aInst.pClass->SetString( aInst, $1 );
1109                         }
1110                 }
1111
1112                 if( aError.IsError() || aError.IsWarning() )
1113                         pTC->pEH->Error( aError, S.Top().pClass, RscId() );
1114         }
1115   | DEFAULT
1116   ;
1117
1118 var_bodycomplex
1119   : '{' list_header list '}'
1120   | '<' tupel_header0 tupel_body ';' '>'
1121   | '<' tupel_header0 tupel_body ';' tupel_header1 tupel_body ';' '>'
1122   | '<' tupel_header0 tupel_body ';' tupel_header1 tupel_body ';'
1123                 tupel_header2 tupel_body ';' '>'
1124   | '<' tupel_header0 tupel_body ';' tupel_header1 tupel_body ';'
1125                 tupel_header2 tupel_body ';' tupel_header3 tupel_body ';' '>'
1126   ;
1127
1128 var_body
1129   : var_bodysimple
1130   | var_bodycomplex
1131   ;
1132
1133 string_multiline
1134   : STRING
1135         {
1136                 $$ = $1;
1137         }
1138   | string_multiline STRING
1139         {
1140         rtl::OStringBuffer aBuf( 256 );
1141         aBuf.append( $1 );
1142         aBuf.append( $2 );
1143         $$ = (char*)pStringContainer->putString( aBuf.getStr() );
1144         }
1145   ;
1146
1147 long_expression
1148   : macro_expression
1149         {
1150                 if( !$1.Evaluate( &$$ ) )
1151                         pTC->pEH->Error( ERR_ZERODIVISION, NULL, RscId() );
1152                 if( $1.IsExpression() )
1153                         delete $1.aExp.pExp;
1154         }
1155   ;
1156
1157 macro_expression
1158   : RSCDEFINE
1159         {
1160                 $$.cType = RSCEXP_DEF;
1161                 $$.aExp.pDef = $1;
1162         }
1163   | NUMBER
1164         {
1165                 $$.cType = RSCEXP_LONG;
1166                 $$.SetLong( $1 );
1167         }
1168   | '-' macro_expression %prec UNARYMINUS
1169         {
1170                 if( $2.IsNumber() ){
1171                         $$.cType = $2.cType;
1172                         $$.SetLong( - $2.GetLong() );
1173                 }
1174                 else{
1175                         RscExpType aLeftExp;
1176
1177                         aLeftExp.cType = RSCEXP_NOTHING;
1178                         $$.cType = RSCEXP_EXP;
1179                         $$.aExp.pExp = new RscExpression( aLeftExp, '-', $2 );
1180                 }
1181         }
1182   | '+' macro_expression %prec UNARYPLUS
1183         {
1184                 $$ = $2;
1185         }
1186   | macro_expression '+' macro_expression
1187         {
1188                 if( $1.IsNumber() && $3.IsNumber() ){
1189                         $$.cType = RSCEXP_LONG;
1190                         $$.SetLong( $1.GetLong() + $3.GetLong() );
1191                 }
1192                 else{
1193                         $$.cType = RSCEXP_EXP;
1194                         $$.aExp.pExp = new RscExpression( $1, '+', $3 );
1195                 }
1196         }
1197   | macro_expression '-' macro_expression
1198         {
1199                 if( $1.IsNumber() && $3.IsNumber() ){
1200                         $$.cType = RSCEXP_LONG;
1201                         $$.SetLong( $1.GetLong() - $3.GetLong() );
1202                 }
1203                 else{
1204                         $$.cType = RSCEXP_EXP;
1205                         $$.aExp.pExp = new RscExpression( $1, '-', $3 );
1206                 }
1207         }
1208   | macro_expression '*' macro_expression
1209         {
1210                 if( $1.IsNumber() && $3.IsNumber() ){
1211                         $$.cType = RSCEXP_LONG;
1212                         $$.SetLong( $1.GetLong() * $3.GetLong() );
1213                 }
1214                 else{
1215                         $$.cType = RSCEXP_EXP;
1216                         $$.aExp.pExp = new RscExpression( $1, '*', $3 );
1217                 }
1218         }
1219   | macro_expression '/' macro_expression
1220         {
1221                 if( $1.IsNumber() && $3.IsNumber() ){
1222                         if( 0 == $3.GetLong() ){
1223                                 $$.cType = RSCEXP_EXP;
1224                                 $$.aExp.pExp = new RscExpression( $1, '/', $3 );
1225                         }
1226                         else{
1227                                 $$.cType = RSCEXP_LONG;
1228                                 $$.SetLong( $1.GetLong() / $3.GetLong() );
1229                         }
1230                 }
1231                 else{
1232                         $$.cType = RSCEXP_EXP;
1233                         $$.aExp.pExp = new RscExpression( $1, '/', $3 );
1234                 }
1235         }
1236   | macro_expression '&' macro_expression
1237         {
1238                 if( $1.IsNumber() && $3.IsNumber() ){
1239                         $$.cType = RSCEXP_LONG;
1240                         $$.SetLong( $1.GetLong() & $3.GetLong() );
1241                 }
1242                 else{
1243                         $$.cType = RSCEXP_EXP;
1244                         $$.aExp.pExp = new RscExpression( $1, '&', $3 );
1245                 }
1246         }
1247   | macro_expression '|' macro_expression
1248         {
1249                 if( $1.IsNumber() && $3.IsNumber() ){
1250                         $$.cType = RSCEXP_LONG;
1251                         $$.SetLong( $1.GetLong() | $3.GetLong() );
1252                 }
1253                 else{
1254                         $$.cType = RSCEXP_EXP;
1255                         $$.aExp.pExp = new RscExpression( $1, '|', $3 );
1256                 }
1257         }
1258   | '(' macro_expression ')'
1259         {
1260                 $$ = $2;
1261         }
1262   | macro_expression LEFTSHIFT macro_expression
1263         {
1264                 if( $1.IsNumber() && $3.IsNumber() ){
1265                         $$.cType = RSCEXP_LONG;
1266                         $$.SetLong( $1.GetLong() << $3.GetLong() );
1267                 }
1268                 else{
1269                         $$.cType = RSCEXP_EXP;
1270                         $$.aExp.pExp = new RscExpression( $1, 'l', $3 );
1271                 }
1272         }
1273   | macro_expression RIGHTSHIFT macro_expression
1274         {
1275                 if( $1.IsNumber() && $3.IsNumber() ){
1276                         $$.cType = RSCEXP_LONG;
1277                         $$.SetLong( $1.GetLong() >> $3.GetLong() );
1278                 }
1279                 else{
1280                         $$.cType = RSCEXP_EXP;
1281                         $$.aExp.pExp = new RscExpression( $1, 'r', $3 );
1282                 }
1283         }
1284   ;
1285
1286 id_expression
1287   : id_expression line_number
1288   | macro_expression
1289         {  // pExpession auswerten und loeschen
1290                 if( RSCEXP_EXP == $1.cType ){
1291                         sal_Int32       lValue;
1292
1293                         if( !$1.Evaluate( &lValue ) )
1294                                 pTC->pEH->Error( ERR_ZERODIVISION, NULL, RscId() );
1295                         delete $1.aExp.pExp;
1296                         $$.cType = RSCEXP_LONG;
1297                         $$.SetLong( lValue );
1298                 }
1299                 else
1300                         $$ = $1;
1301         }
1302   ;
1303
1304 DUMMY_NUMBER
1305   : NUMBER
1306         {
1307         }
1308   |
1309         {
1310         }
1311   ;
1312
1313 line_number
1314   : '#' LINE NUMBER STRING
1315         {
1316                 RscFile * pFName;
1317
1318                 pFI->SetLineNo( $3 );
1319                 pFI->SetFileIndex( pTC->aFileTab.NewCodeFile( rtl::OString( $4 ) ) );
1320                 pFName = pTC->aFileTab.Get( pFI->GetFileIndex() );
1321                 pFName->bLoaded = sal_True;
1322                 pFName->bScanned = sal_True;
1323         }
1324   | '#' NUMBER STRING DUMMY_NUMBER
1325         {
1326                 RscFile * pFName;
1327
1328                 pFI->SetLineNo( $2 );
1329                 pFI->SetFileIndex( pTC->aFileTab.NewCodeFile( rtl::OString( $3 ) ) );
1330                 pFName = pTC->aFileTab.Get( pFI->GetFileIndex() );
1331                 pFName->bLoaded = sal_True;
1332                 pFName->bScanned = sal_True;
1333         }
1334   | '#' NUMBER
1335         {
1336                 pFI->SetLineNo( $2 );
1337         }
1338   ;
1339
1340 %%
1341 #if defined _MSC_VER
1342 #pragma warning(pop)
1343 #endif
1344
1345 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
1346
1347