| /************************************************************** |
| * |
| * Licensed to the Apache Software Foundation (ASF) under one |
| * or more contributor license agreements. See the NOTICE file |
| * distributed with this work for additional information |
| * regarding copyright ownership. The ASF licenses this file |
| * to you under the Apache License, Version 2.0 (the |
| * "License"); you may not use this file except in compliance |
| * with the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, |
| * software distributed under the License is distributed on an |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| * KIND, either express or implied. See the License for the |
| * specific language governing permissions and limitations |
| * under the License. |
| * |
| *************************************************************/ |
| |
| |
| |
| %{ |
| #if defined __GNUC__ |
| #pragma GCC system_header |
| #elif defined __SUNPRO_CC |
| #pragma disable_warn |
| #endif |
| %} |
| |
| /* Compilerstack */ |
| |
| %union { |
| Atom varid; |
| struct { |
| Atom hashid; |
| sal_Int32 nValue; |
| } constname; |
| RscTop * pClass; |
| RSCHEADER header; |
| struct { |
| CLASS_DATA pData; |
| RscTop * pClass; |
| } instance; |
| sal_Int32 value; |
| sal_uInt16 ushort; |
| short exp_short; |
| char * string; |
| sal_Bool svbool; |
| REF_ENUM copyref; |
| RscDefine * defineele; |
| CharSet charset; |
| RscExpType macrostruct; |
| } |
| |
| /* Token */ |
| %token <value> NUMBER |
| %token <string> SYMBOL |
| %token <defineele> RSCDEFINE |
| %token <string> STRING |
| %token <string> INCLUDE_STRING |
| %token <character> CHARACTER |
| %token <svbool> BOOLEAN |
| |
| %token LINE |
| %token AUTO_ID |
| %token NOT |
| %token XSCALE |
| %token YSCALE |
| %token RGB |
| %token GEOMETRY |
| %token POSITION |
| %token DIMENSION |
| %token INZOOMOUTPUTSIZE |
| %token FLOATINGPOS |
| %token DEFINE |
| %token INCLUDE |
| %token MACROTARGET |
| %token DEFAULT |
| |
| |
| %token <pClass> CLASSNAME |
| %token <varid> VARNAME |
| %token <constname> CONSTNAME |
| %token CLASS |
| %token EXTENDABLE |
| %token WRITEIFSET |
| |
| |
| %type <macrostruct> macro_expression |
| %type <macrostruct> id_expression |
| %type <value> long_expression |
| %type <string> string_multiline |
| |
| %type <pClass> type |
| %type <pClass> type_base |
| %type <header> class_header_body |
| %type <header> class_header |
| %type <header> var_header_class |
| %type <copyref> copy_ref |
| %type <ushort> type_flags |
| |
| |
| %left '|' |
| %left '&' |
| %left LEFTSHIFT RIGHTSHIFT |
| %left '+' '-' |
| %left '*' '/' |
| %left UNARYMINUS |
| %left UNARYPLUS |
| %left ',' |
| %left '(' ')' |
| |
| |
| /* Grammatik */ |
| |
| %start resource_definitions |
| |
| %% |
| |
| /********************** D E F I N I T I O N S ****************************/ |
| resource_definitions |
| : |
| | resource_definitions resource_definition |
| | MACROTARGET macro_expression |
| { |
| RscExpType aExpType; |
| sal_Int32 lValue; |
| |
| aExpType.cType = RSCEXP_NOTHING; |
| pExp = new RscExpression( aExpType, '+', $2 ); |
| if( !pExp->Evaluate( &lValue ) ) |
| pTC->pEH->Error( ERR_ZERODIVISION, NULL, RscId() ); |
| } |
| ; |
| |
| resource_definition |
| : line_number |
| | '#' DEFINE SYMBOL macro_expression |
| { |
| sal_Bool bError = sal_False; |
| |
| if( $4.IsNumber() ){ |
| if( !pTC->aFileTab.NewDef( pFI->GetFileIndex(), |
| ByteString( $3 ), |
| $4.GetLong(), LIST_APPEND ) ) |
| bError = sal_True; |
| } |
| else if( $4.IsDefinition() ){ |
| RscExpType aExpType; |
| RscExpression * pExpr; |
| |
| aExpType.cType = RSCEXP_NOTHING; |
| aExpType.SetLong( 0 ); |
| aExpType.cType = RSCEXP_LONG; |
| pExpr = new RscExpression( aExpType, '+', $4 ); |
| |
| if( !pTC->aFileTab.NewDef( pFI->GetFileIndex(), |
| ByteString( $3 ), pExpr, LIST_APPEND ) ) |
| bError = sal_True; |
| } |
| else if( $4.IsExpression() ){ |
| if( !pTC->aFileTab.NewDef( pFI->GetFileIndex(), |
| ByteString( $3 ), $4.aExp.pExp, |
| LIST_APPEND ) ) |
| bError = sal_True; |
| } |
| |
| if( bError ){ |
| pTC->pEH->Error( ERR_DECLAREDEFINE, NULL, RscId(), $3 ); |
| } |
| } |
| | '#' DEFINE RSCDEFINE macro_expression |
| { |
| pTC->pEH->Error( ERR_DOUBLEDEFINE, NULL, RscId(), $3->GetName().GetBuffer() ); |
| } |
| | '#' INCLUDE STRING |
| { |
| } |
| | '#' INCLUDE INCLUDE_STRING |
| { |
| } |
| | class_definition ';' |
| { |
| #ifdef D40 |
| void * pMem; |
| pMem = rtl_allocateMemory( 20000 ); |
| rtl_freeMemory( pMem ); |
| #endif |
| } |
| | new_class_definition_header '{' new_class_definition_body '}' ';' |
| | new_class_definition_header ';' |
| ; |
| |
| new_class_definition_header |
| : CLASS SYMBOL id_expression ':' CLASSNAME |
| { |
| sal_Int32 lType; |
| |
| $3.Evaluate( &lType ); |
| |
| // Klasse anlegen |
| Atom nId = pHS->getID( $2 ); |
| pCurClass = new RscClass( nId, lType, $5 ); |
| nCurMask = 1; |
| pTC->aNmTb.Put( nId, CLASSNAME, pCurClass ); |
| pTC->GetRoot()->Insert( pCurClass ); |
| } |
| | CLASS CLASSNAME id_expression ':' CLASSNAME |
| { |
| pCurClass = $2; |
| nCurMask = 1; |
| } |
| ; |
| |
| new_class_definition_body |
| : |
| | property_definition ';' new_class_definition_body |
| ; |
| |
| property_definition |
| : type_flags type SYMBOL |
| { |
| // Variable anlegen |
| Atom nId = pTC->aNmTb.Put( $3, VARNAME ); |
| pCurClass->SetVariable( nId, $2, NULL, $1, nCurMask ); |
| nCurMask <<= 1; |
| } |
| | type_flags type VARNAME |
| { |
| pCurClass->SetVariable( $3, $2, NULL, $1, nCurMask ); |
| nCurMask <<= 1; |
| } |
| ; |
| |
| type_flags |
| : type_flags EXTENDABLE |
| { |
| $$ = $1 | VAR_EXTENDABLE; |
| } |
| | type_flags WRITEIFSET |
| { |
| $$ = $1 | VAR_SVDYNAMIC; |
| } |
| | |
| { |
| $$ = 0; |
| } |
| ; |
| |
| type |
| : type_base |
| { |
| $$ = $1; |
| } |
| | type_base '[' ']' |
| { |
| if( $1 ) |
| { |
| ByteString aTypeName = pHS->getString( $1->GetId() ); |
| aTypeName += "[]"; |
| $$ = pTC->SearchType( pHS->getID( aTypeName.GetBuffer(), true ) ); |
| if( !$$ ) |
| { |
| RscCont * pCont; |
| pCont = new RscCont( pHS->getID( aTypeName.GetBuffer() ), RSC_NOTYPE ); |
| pCont->SetTypeClass( $1 ); |
| pTC->InsertType( pCont ); |
| $$ = pCont; |
| } |
| } |
| else |
| $$ = NULL; |
| } |
| ; |
| |
| type_base |
| : CLASSNAME |
| { |
| $$ = $1; |
| } |
| | SYMBOL |
| { |
| RscTop * pType = pTC->SearchType( pHS->getID( $1, true ) ); |
| if( !pType ) |
| pTC->pEH->Error( ERR_NOTYPE, pCurClass, RscId() ); |
| $$ = pType; |
| } |
| ; |
| |
| class_definition |
| : class_header class_body |
| { |
| if( TYPE_REF == $1.nTyp ) |
| pTC->pEH->Error( ERR_REFNOTALLOWED, S.Top().pClass, |
| RscId( $1.nName1 ) ); |
| S.Pop(); |
| } |
| | class_header |
| { |
| ERRTYPE aError; |
| RscId aRscId( $1.nName1 ); |
| |
| if( TYPE_NOTHING == $1.nTyp && aRscId.IsId() ) |
| aError = S.Top().pClass->SetRef( S.Top(), aRscId ); |
| else if( TYPE_COPY == $1.nTyp ) |
| aError = ERR_COPYNOTALLOWED; |
| if( aError.IsError() || aError.IsWarning() ) |
| pTC->pEH->Error( aError, S.Top().pClass, aRscId ); |
| S.Pop(); |
| } |
| ; |
| |
| class_header |
| : class_header_body |
| { |
| if( !DoClassHeader( &$1, sal_False ) ) |
| return( ERR_ERROR ); |
| $$ = $1; |
| } |
| ; |
| |
| copy_ref |
| : '<' |
| { |
| $$ = TYPE_COPY; |
| } |
| | ',' |
| { |
| $$ = TYPE_REF; |
| } |
| ; |
| |
| class_header_body |
| : CLASSNAME id_expression copy_ref CLASSNAME id_expression |
| { |
| $$.pClass = $1; |
| $$.nName1 = $2; |
| $$.nTyp = $3; |
| $$.pRefClass = $4; |
| $$.nName2 = $5; |
| } |
| | CLASSNAME id_expression copy_ref id_expression |
| { |
| $$.pClass = $1; |
| $$.nName1 = $2; |
| $$.nTyp = $3; |
| $$.pRefClass = NULL; |
| $$.nName2 = $4; |
| } |
| | CLASSNAME id_expression |
| { |
| $$.pClass = $1; |
| $$.nName1 = $2; |
| $$.nTyp = TYPE_NOTHING; |
| $$.pRefClass = NULL; |
| $$.nName2.cType = RSCEXP_NOTHING; |
| } |
| | CLASSNAME copy_ref id_expression |
| { |
| $$.pClass = $1; |
| $$.nName1.cType = RSCEXP_NOTHING; |
| $$.nTyp = $2; |
| $$.pRefClass = NULL; |
| $$.nName2 = $3; |
| } |
| | CLASSNAME copy_ref CLASSNAME id_expression |
| { |
| $$.pClass = $1; |
| $$.nName1.cType = RSCEXP_NOTHING; |
| $$.nTyp = $2; |
| $$.pRefClass = $3; |
| $$.nName2 = $4; |
| } |
| | CLASSNAME |
| { |
| $$.pClass = $1; |
| $$.nName1.cType = RSCEXP_NOTHING; |
| $$.nTyp = TYPE_NOTHING; |
| $$.nName2.cType = RSCEXP_NOTHING; |
| } |
| ; |
| |
| class_body |
| : '{' var_definitions '}' |
| | '{' '}' |
| | string_multiline |
| { |
| SetString( S.Top(), "TEXT", $1 ); |
| } |
| ; |
| |
| var_definitions |
| : var_definition |
| | var_definitions var_definition |
| ; |
| |
| xy_mapmode |
| : CONSTNAME |
| { |
| SetConst( S.Top(), "_XYMAPMODE", $1.hashid, $1.nValue ); |
| } |
| | |
| ; |
| |
| wh_mapmode |
| : CONSTNAME |
| { |
| SetConst( S.Top(), "_WHMAPMODE", $1.hashid, $1.nValue ); |
| } |
| | |
| ; |
| |
| xywh_mapmode |
| : CONSTNAME |
| { |
| SetConst( S.Top(), "_XYMAPMODE", $1.hashid, $1.nValue ); |
| SetConst( S.Top(), "_WHMAPMODE", $1.hashid, $1.nValue ); |
| } |
| | |
| ; |
| |
| var_definition |
| : line_number |
| | var_header var_body ';' |
| { |
| S.Pop(); |
| } |
| | class_definition ';' |
| | var_header_class class_body ';' |
| { |
| if( TYPE_REF == $1.nTyp ) |
| pTC->pEH->Error( ERR_REFNOTALLOWED, S.Top().pClass, |
| RscId( $1.nName1 ) ); |
| |
| if( S.Top().pClass->GetCount( S.Top() ) ) |
| pTC->pEH->Error( WRN_SUBINMEMBER, S.Top().pClass, |
| RscId( $1.nName1 ) ); |
| |
| S.Pop(); |
| } |
| | var_header_class ';' |
| { |
| ERRTYPE aError; |
| RscId aRscId( $1.nName1 ); |
| |
| if( TYPE_NOTHING == $1.nTyp && aRscId.IsId() ) |
| aError = S.Top().pClass->SetRef( S.Top(), aRscId ); |
| else if( TYPE_COPY == $1.nTyp ) |
| aError = ERR_COPYNOTALLOWED; |
| if( S.Top().pClass->GetCount( S.Top() ) ) |
| aError = WRN_SUBINMEMBER; |
| if( aError.IsError() || aError.IsWarning() ) |
| pTC->pEH->Error( aError, S.Top().pClass, aRscId ); |
| |
| S.Pop(); |
| } |
| | XSCALE '=' '(' long_expression ',' long_expression ')' ';' |
| { |
| SetNumber( S.Top(), "_XNUMERATOR", $4 ); |
| SetNumber( S.Top(), "_XDENOMINATOR", $6 ); |
| } |
| | YSCALE '=' '(' long_expression ',' long_expression ')' ';' |
| { |
| SetNumber( S.Top(), "_YNUMERATOR", $4 ); |
| SetNumber( S.Top(), "_YDENOMINATOR", $6 ); |
| } |
| | RGB '=' '(' long_expression ',' long_expression |
| ',' long_expression ')' ';' |
| { |
| SetNumber( S.Top(), "RED", $4 ); |
| SetNumber( S.Top(), "GREEN", $6 ); |
| SetNumber( S.Top(), "BLUE", $8 ); |
| } |
| | GEOMETRY '=' xywh_mapmode '(' long_expression ',' long_expression ',' |
| long_expression ',' long_expression ')' ';' |
| { |
| SetNumber( S.Top(), "_X", $5 ); |
| SetNumber( S.Top(), "_Y", $7 ); |
| SetNumber( S.Top(), "_WIDTH", $9 ); |
| SetNumber( S.Top(), "_HEIGHT", $11 ); |
| } |
| | POSITION '=' xy_mapmode '(' long_expression ',' long_expression |
| ')' ';' |
| { |
| SetNumber( S.Top(), "_X", $5 ); |
| SetNumber( S.Top(), "_Y", $7 ); |
| } |
| | DIMENSION '=' wh_mapmode '(' long_expression ',' long_expression |
| ')' ';' |
| { |
| SetNumber( S.Top(), "_WIDTH", $5 ); |
| SetNumber( S.Top(), "_HEIGHT", $7 ); |
| } |
| | INZOOMOUTPUTSIZE '=' CONSTNAME '(' long_expression ',' long_expression |
| ')' ';' |
| { |
| SetConst( S.Top(), "_ZOOMINMAPMODE", $3.hashid, $3.nValue ); |
| SetNumber( S.Top(), "_ZOOMINWIDTH", $5 ); |
| SetNumber( S.Top(), "_ZOOMINHEIGHT", $7 ); |
| } |
| | INZOOMOUTPUTSIZE '=' '(' long_expression ',' long_expression ')' ';' |
| { |
| SetNumber( S.Top(), "_ZOOMINWIDTH", $4 ); |
| SetNumber( S.Top(), "_ZOOMINHEIGHT", $6 ); |
| } |
| | FLOATINGPOS '=' CONSTNAME '(' long_expression ',' long_expression |
| ')' ';' |
| { |
| SetConst( S.Top(), "_FLOATINGPOSMAPMODE", $3.hashid, $3.nValue ); |
| SetNumber( S.Top(), "_FLOATINGPOSX", $5 ); |
| SetNumber( S.Top(), "_FLOATINGPOSY", $7 ); |
| } |
| | FLOATINGPOS '=' '(' long_expression ',' long_expression ')' ';' |
| { |
| SetNumber( S.Top(), "_FLOATINGPOSX", $4 ); |
| SetNumber( S.Top(), "_FLOATINGPOSY", $6 ); |
| } |
| ; |
| |
| var_header_class |
| : VARNAME '=' class_header_body |
| { |
| RSCINST aInst; |
| |
| aInst = S.Top().pClass->GetVariable( S.Top(), $1, RSCINST(), sal_False, $3.pClass ); |
| |
| if( aInst.pData ) |
| S.Push( aInst ); |
| else |
| { |
| pTC->pEH->Error( ERR_NOVARIABLENAME, S.Top().pClass, RscId(), |
| pHS->getString( $1 ) ); |
| return( ERR_ERROR ); |
| }; |
| |
| if( !DoClassHeader( &$3, sal_True ) ) |
| return( ERR_ERROR ); |
| $$ = $3; |
| } |
| | VARNAME '[' CONSTNAME ']' '=' class_header_body |
| { |
| RSCINST aInst; |
| |
| aInst = S.Top().pClass->GetVariable( S.Top(), $1, RSCINST() ); |
| |
| if( aInst.pData ) |
| { |
| ERRTYPE aError; |
| RSCINST aIdxInst; |
| |
| aError = aInst.pClass->GetArrayEle( aInst, $3.hashid, NULL, &aIdxInst ); |
| if( aError.IsError() || aError.IsWarning() ) |
| pTC->pEH->Error( aError, S.Top().pClass, RscId() ); |
| if( aError.IsError() ) |
| return( ERR_ERROR ); |
| S.Push( aIdxInst ); |
| } |
| else |
| { |
| pTC->pEH->Error( ERR_NOVARIABLENAME, S.Top().pClass, RscId(), |
| pHS->getString( $1 ) ); |
| return( ERR_ERROR ); |
| }; |
| if( !DoClassHeader( &$6, sal_True ) ) |
| return( ERR_ERROR ); |
| $$ = $6; |
| } |
| | VARNAME '[' SYMBOL ']' '=' class_header_body |
| { |
| RSCINST aInst; |
| |
| aInst = S.Top().pClass->GetVariable( S.Top(), $1, RSCINST() ); |
| |
| if( aInst.pData ) |
| { |
| long nNewLang = pTC->AddLanguage( $3 ); |
| ERRTYPE aError; |
| RSCINST aIdxInst; |
| |
| aError = aInst.pClass->GetArrayEle( aInst, nNewLang, NULL, &aIdxInst ); |
| if( aError.IsError() || aError.IsWarning() ) |
| pTC->pEH->Error( aError, S.Top().pClass, RscId() ); |
| if( aError.IsError() ) |
| return( ERR_ERROR ); |
| S.Push( aIdxInst ); |
| } |
| else |
| { |
| pTC->pEH->Error( ERR_NOVARIABLENAME, S.Top().pClass, RscId(), |
| pHS->getString( $1 ) ); |
| return( ERR_ERROR ); |
| }; |
| if( !DoClassHeader( &$6, sal_True ) ) |
| return( ERR_ERROR ); |
| $$ = $6; |
| } |
| ; |
| |
| var_header |
| : VARNAME '=' |
| { |
| RSCINST aInst; |
| |
| aInst = S.Top().pClass->GetVariable( S.Top(), $1, RSCINST() ); |
| |
| if( aInst.pData ) |
| S.Push( aInst ); |
| else{ |
| pTC->pEH->Error( ERR_NOVARIABLENAME, S.Top().pClass, RscId(), |
| pHS->getString( $1 ) ); |
| return( ERR_ERROR ); |
| }; |
| } |
| | VARNAME '[' CONSTNAME ']' '=' |
| { |
| RSCINST aInst; |
| |
| aInst = S.Top().pClass->GetVariable( S.Top(), $1, RSCINST() ); |
| |
| if( aInst.pData ) |
| { |
| ERRTYPE aError; |
| RSCINST aIdxInst; |
| |
| aError = aInst.pClass->GetArrayEle( aInst, $3.hashid, NULL, &aIdxInst ); |
| if( aError.IsError() || aError.IsWarning() ) |
| pTC->pEH->Error( aError, S.Top().pClass, RscId() ); |
| if( aError.IsError() ) |
| return( ERR_ERROR ); |
| S.Push( aIdxInst ); |
| } |
| else{ |
| pTC->pEH->Error( ERR_NOVARIABLENAME, S.Top().pClass, RscId(), |
| pHS->getString( $1 ) ); |
| return( ERR_ERROR ); |
| }; |
| } |
| | VARNAME '[' SYMBOL ']' '=' |
| { |
| RSCINST aInst; |
| |
| aInst = S.Top().pClass->GetVariable( S.Top(), $1, RSCINST() ); |
| |
| if( aInst.pData ) |
| { |
| long nNewLang = pTC->AddLanguage( $3 ); |
| ERRTYPE aError; |
| RSCINST aIdxInst; |
| |
| aError = aInst.pClass->GetArrayEle( aInst, nNewLang, NULL, &aIdxInst ); |
| if( aError.IsError() || aError.IsWarning() ) |
| pTC->pEH->Error( aError, S.Top().pClass, RscId() ); |
| if( aError.IsError() ) |
| return( ERR_ERROR ); |
| S.Push( aIdxInst ); |
| } |
| else{ |
| pTC->pEH->Error( ERR_NOVARIABLENAME, S.Top().pClass, RscId(), |
| pHS->getString( $1 ) ); |
| return( ERR_ERROR ); |
| }; |
| } |
| ; |
| tupel_header0 |
| : |
| { |
| RSCINST aInst; |
| |
| aInst = S.Top().pClass->GetTupelVar( S.Top(), 0, RSCINST() ); |
| if( aInst.pData ) |
| S.Push( aInst ); |
| else |
| { |
| pTC->pEH->Error( ERR_NOTUPELNAME, S.Top().pClass, RscId() ); |
| return( ERR_ERROR ); |
| }; |
| } |
| ; |
| |
| tupel_header1 |
| : |
| { |
| RSCINST aInst; |
| |
| aInst = S.Top().pClass->GetTupelVar( S.Top(), 1, RSCINST() ); |
| if( aInst.pData ) |
| S.Push( aInst ); |
| else |
| { |
| pTC->pEH->Error( ERR_NOTUPELNAME, S.Top().pClass, RscId() ); |
| return( ERR_ERROR ); |
| }; |
| } |
| ; |
| |
| tupel_header2 |
| : |
| { |
| RSCINST aInst; |
| |
| aInst = S.Top().pClass->GetTupelVar( S.Top(), 2, RSCINST() ); |
| if( aInst.pData ) |
| S.Push( aInst ); |
| else |
| { |
| pTC->pEH->Error( ERR_NOTUPELNAME, S.Top().pClass, RscId() ); |
| return( ERR_ERROR ); |
| }; |
| } |
| ; |
| |
| tupel_header3 |
| : |
| { |
| RSCINST aInst; |
| |
| aInst = S.Top().pClass->GetTupelVar( S.Top(), 3, RSCINST() ); |
| if( !aInst.pData ) |
| { |
| pTC->pEH->Error( ERR_NOTUPELNAME, S.Top().pClass, RscId() ); |
| return( ERR_ERROR ); |
| }; |
| S.Push( aInst ); |
| } |
| ; |
| |
| tupel_body |
| : var_body |
| { |
| S.Pop(); |
| } |
| ; |
| |
| var_list_header |
| : |
| { |
| ERRTYPE aError; |
| RSCINST aInst; |
| |
| aError = S.Top().pClass->GetElement( S.Top(), RscId(), |
| NULL, RSCINST(), &aInst ); |
| if( aError.IsError() || aError.IsWarning() ) |
| pTC->pEH->Error( aError, S.Top().pClass, RscId() ); |
| if( aError.IsError() ) |
| { // unbedingt Instanz auf den Stack bringen |
| aInst = S.Top().pClass->Create( NULL, RSCINST() ); |
| } |
| S.Push( aInst ); |
| } |
| ; |
| |
| list_body |
| : var_bodycomplex |
| { |
| S.Pop(); |
| } |
| ; |
| |
| list_header |
| : |
| { |
| sal_uInt32 nCount = S.Top().pClass->GetCount( S.Top() ); |
| sal_uInt32 i; |
| |
| for( i = nCount; i > 0; i-- ) |
| S.Top().pClass->DeletePos( S.Top(), i -1 ); |
| } |
| ; |
| |
| list |
| : list var_list_header list_body ';' |
| | list var_bodysimple ';' |
| | list class_definition ';' |
| | list line_number |
| | |
| ; |
| |
| var_bodysimple |
| : macro_expression |
| { |
| sal_Int32 l; |
| ERRTYPE aError; |
| |
| if( !$1.Evaluate( &l ) ) |
| pTC->pEH->Error( ERR_ZERODIVISION, NULL, RscId() ); |
| else |
| { |
| aError = S.Top().pClass->SetRef( S.Top(), RscId( $1 ) ); |
| if( aError.IsError() ) |
| { |
| aError.Clear(); |
| aError = S.Top().pClass->SetNumber( S.Top(), l ); |
| } |
| if( aError.IsError() ) |
| { // Aufwaertskompatible, Tupel probieren |
| RSCINST aInst = GetFirstTupelEle( S.Top() ); |
| if( aInst.pData ) |
| { |
| aError.Clear(); // Fehler zuruecksetzen |
| aError = aInst.pClass->SetRef( aInst, RscId( $1 ) ); |
| if( aError.IsError() ) |
| { |
| aError.Clear(); |
| aError = aInst.pClass->SetNumber( aInst, l ); |
| } |
| } |
| } |
| } |
| |
| if( $1.IsExpression() ) |
| delete $1.aExp.pExp; |
| |
| if( aError.IsError() || aError.IsWarning() ) |
| pTC->pEH->Error( aError, S.Top().pClass, RscId() ); |
| } |
| | CONSTNAME |
| { |
| ERRTYPE aError; |
| aError = S.Top().pClass->SetConst( S.Top(), $1.hashid, $1.nValue ); |
| if( aError.IsError() ) |
| { // Aufwaertskompatible, Tupel probieren |
| RSCINST aInst = GetFirstTupelEle( S.Top() ); |
| if( aInst.pData ) |
| { |
| aError.Clear(); // Fehler zuruecksetzen |
| aError = aInst.pClass->SetConst( aInst, $1.hashid, $1.nValue ); |
| } |
| } |
| |
| if( aError.IsError() || aError.IsWarning() ) |
| pTC->pEH->Error( aError, S.Top().pClass, RscId() ); |
| } |
| | NOT CONSTNAME |
| { |
| ERRTYPE aError; |
| aError = S.Top().pClass->SetNotConst( S.Top(), $2.hashid ); |
| if( aError.IsError() ) |
| { // Aufwaertskompatible, Tupel probieren |
| RSCINST aInst = GetFirstTupelEle( S.Top() ); |
| if( aInst.pData ) |
| { |
| aError.Clear(); // Fehler zuruecksetzen |
| aError = aInst.pClass->SetNotConst( aInst, $2.hashid ); |
| } |
| } |
| |
| if( aError.IsError() || aError.IsWarning() ) |
| pTC->pEH->Error( aError, S.Top().pClass, RscId() ); |
| } |
| | BOOLEAN |
| { |
| ERRTYPE aError; |
| aError = S.Top().pClass->SetBool( S.Top(), $1 ); |
| if( aError.IsError() ) |
| { // Aufwaertskompatible, Tupel probieren |
| RSCINST aInst = GetFirstTupelEle( S.Top() ); |
| if( aInst.pData ) |
| { |
| aError.Clear(); // Fehler zuruecksetzen |
| aError = aInst.pClass->SetBool( aInst, $1 ); |
| } |
| } |
| |
| if( aError.IsError() || aError.IsWarning() ) |
| pTC->pEH->Error( aError, S.Top().pClass, RscId() ); |
| } |
| | string_multiline |
| { |
| ERRTYPE aError; |
| aError = S.Top().pClass->SetString( S.Top(), $1 ); |
| if( aError.IsError() ) |
| { // Aufwaertskompatible, Tupel probieren |
| RSCINST aInst = GetFirstTupelEle( S.Top() ); |
| if( aInst.pData ) |
| { |
| aError.Clear(); // Fehler zuruecksetzen |
| aError = aInst.pClass->SetString( aInst, $1 ); |
| } |
| } |
| |
| if( aError.IsError() || aError.IsWarning() ) |
| pTC->pEH->Error( aError, S.Top().pClass, RscId() ); |
| } |
| | DEFAULT |
| ; |
| |
| var_bodycomplex |
| : '{' list_header list '}' |
| | '<' tupel_header0 tupel_body ';' '>' |
| | '<' tupel_header0 tupel_body ';' tupel_header1 tupel_body ';' '>' |
| | '<' tupel_header0 tupel_body ';' tupel_header1 tupel_body ';' |
| tupel_header2 tupel_body ';' '>' |
| | '<' tupel_header0 tupel_body ';' tupel_header1 tupel_body ';' |
| tupel_header2 tupel_body ';' tupel_header3 tupel_body ';' '>' |
| ; |
| |
| var_body |
| : var_bodysimple |
| | var_bodycomplex |
| ; |
| |
| /********************** work on yacc stack *******************************/ |
| string_multiline |
| : STRING |
| { |
| $$ = $1; |
| } |
| | string_multiline STRING |
| { |
| rtl::OStringBuffer aBuf( 256 ); |
| aBuf.append( $1 ); |
| aBuf.append( $2 ); |
| $$ = (char*)pStringContainer->putString( aBuf.getStr() ); |
| } |
| ; |
| |
| long_expression |
| : macro_expression |
| { |
| if( !$1.Evaluate( &$$ ) ) |
| pTC->pEH->Error( ERR_ZERODIVISION, NULL, RscId() ); |
| if( $1.IsExpression() ) |
| delete $1.aExp.pExp; |
| } |
| ; |
| |
| macro_expression |
| : RSCDEFINE |
| { |
| $$.cType = RSCEXP_DEF; |
| $$.aExp.pDef = $1; |
| } |
| | NUMBER |
| { |
| $$.cType = RSCEXP_LONG; |
| $$.SetLong( $1 ); |
| } |
| | '-' macro_expression %prec UNARYMINUS |
| { |
| if( $2.IsNumber() ){ |
| $$.cType = $2.cType; |
| $$.SetLong( - $2.GetLong() ); |
| } |
| else{ |
| RscExpType aLeftExp; |
| |
| aLeftExp.cType = RSCEXP_NOTHING; |
| $$.cType = RSCEXP_EXP; |
| $$.aExp.pExp = new RscExpression( aLeftExp, '-', $2 ); |
| } |
| } |
| | '+' macro_expression %prec UNARYPLUS |
| { |
| $$ = $2; |
| } |
| | macro_expression '+' macro_expression |
| { |
| if( $1.IsNumber() && $3.IsNumber() ){ |
| $$.cType = RSCEXP_LONG; |
| $$.SetLong( $1.GetLong() + $3.GetLong() ); |
| } |
| else{ |
| $$.cType = RSCEXP_EXP; |
| $$.aExp.pExp = new RscExpression( $1, '+', $3 ); |
| } |
| } |
| | macro_expression '-' macro_expression |
| { |
| if( $1.IsNumber() && $3.IsNumber() ){ |
| $$.cType = RSCEXP_LONG; |
| $$.SetLong( $1.GetLong() - $3.GetLong() ); |
| } |
| else{ |
| $$.cType = RSCEXP_EXP; |
| $$.aExp.pExp = new RscExpression( $1, '-', $3 ); |
| } |
| } |
| | macro_expression '*' macro_expression |
| { |
| if( $1.IsNumber() && $3.IsNumber() ){ |
| $$.cType = RSCEXP_LONG; |
| $$.SetLong( $1.GetLong() * $3.GetLong() ); |
| } |
| else{ |
| $$.cType = RSCEXP_EXP; |
| $$.aExp.pExp = new RscExpression( $1, '*', $3 ); |
| } |
| } |
| | macro_expression '/' macro_expression |
| { |
| if( $1.IsNumber() && $3.IsNumber() ){ |
| if( 0 == $3.GetLong() ){ |
| $$.cType = RSCEXP_EXP; |
| $$.aExp.pExp = new RscExpression( $1, '/', $3 ); |
| } |
| else{ |
| $$.cType = RSCEXP_LONG; |
| $$.SetLong( $1.GetLong() / $3.GetLong() ); |
| } |
| } |
| else{ |
| $$.cType = RSCEXP_EXP; |
| $$.aExp.pExp = new RscExpression( $1, '/', $3 ); |
| } |
| } |
| | macro_expression '&' macro_expression |
| { |
| if( $1.IsNumber() && $3.IsNumber() ){ |
| $$.cType = RSCEXP_LONG; |
| $$.SetLong( $1.GetLong() & $3.GetLong() ); |
| } |
| else{ |
| $$.cType = RSCEXP_EXP; |
| $$.aExp.pExp = new RscExpression( $1, '&', $3 ); |
| } |
| } |
| | macro_expression '|' macro_expression |
| { |
| if( $1.IsNumber() && $3.IsNumber() ){ |
| $$.cType = RSCEXP_LONG; |
| $$.SetLong( $1.GetLong() | $3.GetLong() ); |
| } |
| else{ |
| $$.cType = RSCEXP_EXP; |
| $$.aExp.pExp = new RscExpression( $1, '|', $3 ); |
| } |
| } |
| | '(' macro_expression ')' |
| { |
| $$ = $2; |
| } |
| | macro_expression LEFTSHIFT macro_expression |
| { |
| if( $1.IsNumber() && $3.IsNumber() ){ |
| $$.cType = RSCEXP_LONG; |
| $$.SetLong( $1.GetLong() << $3.GetLong() ); |
| } |
| else{ |
| $$.cType = RSCEXP_EXP; |
| $$.aExp.pExp = new RscExpression( $1, 'l', $3 ); |
| } |
| } |
| | macro_expression RIGHTSHIFT macro_expression |
| { |
| if( $1.IsNumber() && $3.IsNumber() ){ |
| $$.cType = RSCEXP_LONG; |
| $$.SetLong( $1.GetLong() >> $3.GetLong() ); |
| } |
| else{ |
| $$.cType = RSCEXP_EXP; |
| $$.aExp.pExp = new RscExpression( $1, 'r', $3 ); |
| } |
| } |
| ; |
| |
| id_expression |
| : id_expression line_number |
| | macro_expression |
| { // pExpession auswerten und loeschen |
| if( RSCEXP_EXP == $1.cType ){ |
| sal_Int32 lValue; |
| |
| if( !$1.Evaluate( &lValue ) ) |
| pTC->pEH->Error( ERR_ZERODIVISION, NULL, RscId() ); |
| delete $1.aExp.pExp; |
| $$.cType = RSCEXP_LONG; |
| $$.SetLong( lValue ); |
| } |
| else |
| $$ = $1; |
| } |
| ; |
| |
| DUMMY_NUMBER |
| : NUMBER |
| { |
| } |
| | |
| { |
| } |
| ; |
| |
| line_number |
| : '#' LINE NUMBER STRING |
| { |
| RscFile * pFName; |
| |
| pFI->SetLineNo( $3 ); |
| pFI->SetFileIndex( pTC->aFileTab.NewCodeFile( ByteString( $4 ) ) ); |
| pFName = pTC->aFileTab.Get( pFI->GetFileIndex() ); |
| pFName->bLoaded = sal_True; |
| pFName->bScanned = sal_True; |
| } |
| | '#' NUMBER STRING DUMMY_NUMBER |
| { |
| RscFile * pFName; |
| |
| pFI->SetLineNo( $2 ); |
| pFI->SetFileIndex( pTC->aFileTab.NewCodeFile( ByteString( $3 ) ) ); |
| pFName = pTC->aFileTab.Get( pFI->GetFileIndex() ); |
| pFName->bLoaded = sal_True; |
| pFName->bScanned = sal_True; |
| } |
| | '#' NUMBER |
| { |
| pFI->SetLineNo( $2 ); |
| } |
| ; |
| |
| |
| |
| |