| /************************************************************** |
| * |
| * 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 |