| /************************************************************** | |
| * | |
| * 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. | |
| * | |
| *************************************************************/ | |
| #ifndef _EXPR_HXX | |
| #define _EXPR_HXX | |
| #include "opcodes.hxx" | |
| #include "token.hxx" | |
| class SbiExprNode; | |
| class SbiExpression; | |
| class SbiExprList; | |
| class SbiDimList; | |
| class SbiParameters; | |
| class SbiParser; | |
| class SbiCodeGen; | |
| class SbiSymDef; | |
| class SbiProcDef; | |
| #include <vector> | |
| typedef ::std::vector<SbiExprList*> SbiExprListVector; | |
| struct SbVar { // Variablen-Element: | |
| SbiExprNode* pNext; // Weiteres Element (bei Strukturen) | |
| SbiSymDef* pDef; // Symboldefinition | |
| SbiExprList* pPar; // optionale Parameter (wird geloescht) | |
| SbiExprListVector* pvMorePar; // Array of arrays foo(pPar)(avMorePar[0])(avMorePar[1])... | |
| }; | |
| struct KeywordSymbolInfo | |
| { | |
| String m_aKeywordSymbol; | |
| SbxDataType m_eSbxDataType; | |
| SbiToken m_eTok; | |
| }; | |
| enum SbiExprType { // Expression-Typen: | |
| SbSTDEXPR, // normaler Ausdruck | |
| SbLVALUE, // beliebiger lValue | |
| SbSYMBOL, // beliebiges zusammengesetztes Symbol | |
| SbOPERAND // Variable/Funktion | |
| }; | |
| enum SbiExprMode { // Expression context: | |
| EXPRMODE_STANDARD, // default | |
| EXPRMODE_STANDALONE, // a param1, param2 OR a( param1, param2 ) = 42 | |
| EXPRMODE_LPAREN_PENDING, // start of parameter list with bracket, special handling | |
| EXPRMODE_LPAREN_NOT_NEEDED, // pending LPAREN has not been used | |
| EXPRMODE_ARRAY_OR_OBJECT, // '=' or '(' or '.' found after ')' on ParenLevel 0, stopping | |
| // expression, assuming array syntax a(...)[(...)] = ? | |
| // or a(...).b(...) | |
| EXPRMODE_EMPTY_PAREN // It turned out that the paren don't contain anything: a() | |
| }; | |
| enum SbiNodeType { | |
| SbxNUMVAL, // nVal = Wert | |
| SbxSTRVAL, // aStrVal = Wert, before #i59791/#i45570: nStringId = Wert | |
| SbxVARVAL, // aVar = Wert | |
| SbxTYPEOF, // TypeOf ObjExpr Is Type | |
| SbxNODE, // Node | |
| SbxNEW, // new <type> expression | |
| SbxDUMMY | |
| }; | |
| enum RecursiveMode | |
| { | |
| UNDEFINED, | |
| FORCE_CALL, | |
| PREVENT_CALL | |
| }; | |
| class SbiExprNode { // Operatoren (und Operanden) | |
| friend class SbiExpression; | |
| friend class SbiConstExpression; | |
| union { | |
| sal_uInt16 nTypeStrId; // gepoolter String-ID, #i59791/#i45570 Now only for TypeOf | |
| double nVal; // numerischer Wert | |
| SbVar aVar; // oder Variable | |
| }; | |
| String aStrVal; // #i59791/#i45570 Store string directly | |
| SbiExprNode* pLeft; // linker Zweig | |
| SbiExprNode* pRight; // rechter Zweig (NULL bei unaeren Ops) | |
| SbiExprNode* pWithParent; // Knoten, dessen Member this per with ist | |
| SbiCodeGen* pGen; // Code-Generator | |
| SbiNodeType eNodeType; // Art des Nodes | |
| SbxDataType eType; // aktueller Datentyp | |
| SbiToken eTok; // Token des Operators | |
| sal_Bool bComposite; // sal_True: Zusammengesetzter Ausdruck | |
| sal_Bool bError; // sal_True: Fehlerhaft | |
| void FoldConstants(); // Constant Folding durchfuehren | |
| void CollectBits(); // Umwandeln von Zahlen in Strings | |
| sal_Bool IsOperand() // sal_True, wenn Operand | |
| { return sal_Bool( eNodeType != SbxNODE && eNodeType != SbxTYPEOF && eNodeType != SbxNEW ); } | |
| sal_Bool IsTypeOf() | |
| { return sal_Bool( eNodeType == SbxTYPEOF ); } | |
| sal_Bool IsNew() | |
| { return sal_Bool( eNodeType == SbxNEW ); } | |
| sal_Bool IsNumber(); // sal_True bei Zahlen | |
| sal_Bool IsString(); // sal_True bei Strings | |
| sal_Bool IsLvalue(); // sal_True, falls als Lvalue verwendbar | |
| void GenElement( SbiOpcode ); // Element | |
| void BaseInit( SbiParser* p ); // Hilfsfunktion fuer Ctor, AB 17.12.95 | |
| public: | |
| SbiExprNode( void ); | |
| SbiExprNode( SbiParser*, double, SbxDataType ); | |
| SbiExprNode( SbiParser*, const String& ); | |
| SbiExprNode( SbiParser*, const SbiSymDef&, SbxDataType, SbiExprList* = NULL ); | |
| SbiExprNode( SbiParser*, SbiExprNode*, SbiToken, SbiExprNode* ); | |
| SbiExprNode( SbiParser*, SbiExprNode*, sal_uInt16 ); // #120061 TypeOf | |
| SbiExprNode( SbiParser*, sal_uInt16 ); // new <type> | |
| virtual ~SbiExprNode(); | |
| sal_Bool IsValid() { return sal_Bool( !bError ); } | |
| sal_Bool IsConstant() // sal_True bei konstantem Operanden | |
| { return sal_Bool( eNodeType == SbxSTRVAL || eNodeType == SbxNUMVAL ); } | |
| sal_Bool IsIntConst(); // sal_True bei Integer-Konstanten | |
| sal_Bool IsVariable(); // sal_True, wenn Variable | |
| SbiExprNode* GetWithParent() { return pWithParent; } | |
| void SetWithParent( SbiExprNode* p ) { pWithParent = p; } | |
| SbxDataType GetType() { return eType; } | |
| void SetType( SbxDataType eTp ) { eType = eTp; } | |
| SbiNodeType GetNodeType() { return eNodeType; } | |
| SbiSymDef* GetVar(); // Variable (falls vorhanden) | |
| SbiSymDef* GetRealVar(); // letzte Variable in x.y.z | |
| SbiExprNode* GetRealNode(); // letzter Knoten in x.y.z | |
| short GetDepth(); // Tiefe eines Baumes berechnen | |
| const String& GetString() { return aStrVal; } | |
| short GetNumber() { return (short)nVal; } | |
| SbiExprList* GetParameters() { return aVar.pPar; } | |
| SbiExprListVector* GetMoreParameters() { return aVar.pvMorePar; } | |
| void Optimize(); // Baumabgleich | |
| void Gen( RecursiveMode eRecMode = UNDEFINED ); // Ausgabe eines Nodes | |
| }; | |
| class SbiExpression { // der Ausdruck: | |
| friend class SbiExprList; | |
| friend class SbiParameters; | |
| friend class SbiDimList; | |
| protected: | |
| String aArgName; // Name fuer bananntes Argument | |
| SbiParser* pParser; // fuer Fehlermeldungen, Parsing | |
| SbiExpression* pNext; // Link bei Parameterlisten | |
| SbiExprNode* pExpr; // Der Expression-Baum | |
| SbiExprType eCurExpr; // Art des Ausdrucks | |
| SbiExprMode m_eMode; // Expression context | |
| sal_Bool bBased; // sal_True: einfacher DIM-Teil (+BASE) | |
| sal_Bool bError; // sal_True: Fehler | |
| sal_Bool bByVal; // sal_True: ByVal-Parameter | |
| sal_Bool bBracket; // sal_True: Parameter list with brackets | |
| sal_uInt16 nParenLevel; | |
| SbiExprNode* Term( const KeywordSymbolInfo* pKeywordSymbolInfo = NULL ); | |
| SbiExprNode* ObjTerm( SbiSymDef& ); | |
| SbiExprNode* Operand( bool bUsedForTypeOf = false ); | |
| SbiExprNode* Unary(); | |
| SbiExprNode* Exp(); | |
| SbiExprNode* MulDiv(); | |
| SbiExprNode* IntDiv(); | |
| SbiExprNode* Mod(); | |
| SbiExprNode* AddSub(); | |
| SbiExprNode* Cat(); | |
| SbiExprNode* Like(); | |
| SbiExprNode* VBA_Not(); | |
| SbiExprNode* Comp(); | |
| SbiExprNode* Boolean(); | |
| public: | |
| SbiExpression( SbiParser*, SbiExprType = SbSTDEXPR, | |
| SbiExprMode eMode = EXPRMODE_STANDARD, const KeywordSymbolInfo* pKeywordSymbolInfo = NULL ); // Parsender Ctor | |
| SbiExpression( SbiParser*, const String& ); | |
| SbiExpression( SbiParser*, double, SbxDataType = SbxDOUBLE ); | |
| SbiExpression( SbiParser*, const SbiSymDef&, SbiExprList* = NULL ); | |
| SbiExpression( SbiParser*, SbiToken ); // Spezial-Expr mit Spezial-Tokens | |
| ~SbiExpression(); | |
| String& GetName() { return aArgName; } | |
| void SetBased() { bBased = sal_True; } | |
| sal_Bool IsBased() { return bBased; } | |
| void SetByVal() { bByVal = sal_True; } | |
| sal_Bool IsByVal() { return bByVal; } | |
| sal_Bool IsBracket() { return bBracket; } | |
| sal_Bool IsValid() { return pExpr->IsValid(); } | |
| sal_Bool IsConstant() { return pExpr->IsConstant(); } | |
| sal_Bool IsVariable() { return pExpr->IsVariable(); } | |
| sal_Bool IsLvalue() { return pExpr->IsLvalue(); } | |
| sal_Bool IsIntConstant() { return pExpr->IsIntConst(); } | |
| const String& GetString() { return pExpr->GetString(); } | |
| SbiSymDef* GetVar() { return pExpr->GetVar(); } | |
| SbiSymDef* GetRealVar() { return pExpr->GetRealVar(); } | |
| SbiExprNode* GetExprNode() { return pExpr; } | |
| SbxDataType GetType() { return pExpr->GetType(); } | |
| void SetType( SbxDataType eType){ pExpr->eType = eType; } | |
| void Gen( RecursiveMode eRecMode = UNDEFINED ); // Ausgabe eines Nodes | |
| }; | |
| class SbiConstExpression : public SbiExpression { | |
| double nVal; | |
| String aVal; | |
| SbxDataType eType; | |
| public: // numerische Konstante | |
| SbiConstExpression( SbiParser* ); | |
| SbxDataType GetType() { return eType; } | |
| const String& GetString() { return aVal; } | |
| double GetValue() { return nVal; } | |
| short GetShortValue(); | |
| }; | |
| class SbiExprList { // Basisklasse fuer Parameter und Dims | |
| protected: | |
| SbiParser* pParser; // Parser | |
| SbiExpression* pFirst; // Expressions | |
| short nExpr; // Anzahl Expressions | |
| short nDim; // Anzahl Dimensionen | |
| sal_Bool bError; // sal_True: Fehler | |
| sal_Bool bBracket; // sal_True: Klammern | |
| public: | |
| SbiExprList( SbiParser* ); | |
| virtual ~SbiExprList(); | |
| sal_Bool IsBracket() { return bBracket; } | |
| sal_Bool IsValid() { return sal_Bool( !bError ); } | |
| short GetSize() { return nExpr; } | |
| short GetDims() { return nDim; } | |
| SbiExpression* Get( short ); | |
| sal_Bool Test( const SbiProcDef& ); // Parameter-Checks | |
| void Gen(); // Code-Erzeugung | |
| void addExpression( SbiExpression* pExpr ); | |
| }; | |
| class SbiParameters : public SbiExprList { | |
| public: | |
| SbiParameters( SbiParser*, sal_Bool bConst = sal_False, sal_Bool bPar = sal_True);// parsender Ctor | |
| }; | |
| class SbiDimList : public SbiExprList { | |
| sal_Bool bConst; // sal_True: Alles sind Integer-Konstanten | |
| public: | |
| SbiDimList( SbiParser* ); // Parsender Ctor | |
| sal_Bool IsConstant() { return bConst; } | |
| }; | |
| #endif |