LCOV - code coverage report
Current view: top level - rsc/source/parser - rscyacc.y (source / functions) Hit Total Coverage
Test: commit e02a6cb2c3e2b23b203b422e4e0680877f232636 Lines: 0 612 0.0 %
Date: 2014-04-14 Functions: 0 7 0.0 %
Legend: Lines: hit not hit

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

Generated by: LCOV version 1.10