/************************************************************** * * 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 typedef ::std::vector 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 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 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