Branch data Line data Source code
1 : : /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
2 : : /*
3 : : * This file is part of the LibreOffice project.
4 : : *
5 : : * This Source Code Form is subject to the terms of the Mozilla Public
6 : : * License, v. 2.0. If a copy of the MPL was not distributed with this
7 : : * file, You can obtain one at http://mozilla.org/MPL/2.0/.
8 : : *
9 : : * This file incorporates work covered by the following license notice:
10 : : *
11 : : * Licensed to the Apache Software Foundation (ASF) under one or more
12 : : * contributor license agreements. See the NOTICE file distributed
13 : : * with this work for additional information regarding copyright
14 : : * ownership. The ASF licenses this file to you under the Apache
15 : : * License, Version 2.0 (the "License"); you may not use this file
16 : : * except in compliance with the License. You may obtain a copy of
17 : : * the License at http://www.apache.org/licenses/LICENSE-2.0 .
18 : : */
19 : :
20 : : #ifndef _EXPR_HXX
21 : : #define _EXPR_HXX
22 : :
23 : : #include "opcodes.hxx"
24 : : #include "token.hxx"
25 : :
26 : : class SbiExprNode;
27 : : class SbiExpression;
28 : : class SbiExprList;
29 : : class SbiDimList;
30 : : class SbiParameters;
31 : : class SbiParser;
32 : : class SbiCodeGen;
33 : : class SbiSymDef;
34 : : class SbiProcDef;
35 : :
36 : :
37 : : #include <vector>
38 : : typedef ::std::vector<SbiExprList*> SbiExprListVector;
39 : :
40 : : struct SbVar {
41 : : SbiExprNode* pNext; // next element (for structures)
42 : : SbiSymDef* pDef; // symbol definition
43 : : SbiExprList* pPar; // optional parameters (is deleted)
44 : : SbiExprListVector* pvMorePar; // Array of arrays foo(pPar)(avMorePar[0])(avMorePar[1])...
45 : : };
46 : :
47 : 0 : struct KeywordSymbolInfo
48 : : {
49 : : ::rtl::OUString m_aKeywordSymbol;
50 : : SbxDataType m_eSbxDataType;
51 : : SbiToken m_eTok;
52 : : };
53 : :
54 : : enum SbiExprType { // expression types:
55 : : SbSTDEXPR, // normal expression
56 : : SbLVALUE, // any lValue
57 : : SbSYMBOL, // any composite symbol
58 : : SbOPERAND // variable/function
59 : : };
60 : :
61 : : enum SbiExprMode { // Expression context:
62 : : EXPRMODE_STANDARD, // default
63 : : EXPRMODE_STANDALONE, // a param1, param2 OR a( param1, param2 ) = 42
64 : : EXPRMODE_LPAREN_PENDING, // start of parameter list with bracket, special handling
65 : : EXPRMODE_LPAREN_NOT_NEEDED, // pending LPAREN has not been used
66 : : EXPRMODE_ARRAY_OR_OBJECT, // '=' or '(' or '.' found after ')' on ParenLevel 0, stopping
67 : : // expression, assuming array syntax a(...)[(...)] = ?
68 : : // or a(...).b(...)
69 : : EXPRMODE_EMPTY_PAREN // It turned out that the paren don't contain anything: a()
70 : : };
71 : :
72 : : enum SbiNodeType {
73 : : SbxNUMVAL, // nVal = value
74 : : SbxSTRVAL, // aStrVal = value, before #i59791/#i45570: nStringId = value
75 : : SbxVARVAL, // aVar = value
76 : : SbxTYPEOF, // TypeOf ObjExpr Is Type
77 : : SbxNODE, // Node
78 : : SbxNEW, // new <type> expression
79 : : SbxDUMMY
80 : : };
81 : :
82 : : enum RecursiveMode
83 : : {
84 : : UNDEFINED,
85 : : FORCE_CALL,
86 : : PREVENT_CALL
87 : : };
88 : :
89 : : class SbiExprNode { // operators (and operands)
90 : : friend class SbiExpression;
91 : : friend class SbiConstExpression;
92 : : union {
93 : : sal_uInt16 nTypeStrId; // pooled String-ID, #i59791/#i45570 Now only for TypeOf
94 : : double nVal; // numeric value
95 : : SbVar aVar; // or variable
96 : : };
97 : : String aStrVal; // #i59791/#i45570 Store string directly
98 : : SbiExprNode* pLeft; // right branch
99 : : SbiExprNode* pRight; // right branch (NULL for unary ops)
100 : : SbiExprNode* pWithParent; // node, whose member is "this per with"
101 : : SbiCodeGen* pGen; // code-generator
102 : : SbiNodeType eNodeType;
103 : : SbxDataType eType;
104 : : SbiToken eTok;
105 : : bool bError; // true: error
106 : : void FoldConstants();
107 : : void CollectBits(); // converting numbers to strings
108 : 11956 : bool IsOperand()
109 [ + + ][ + - ]: 11956 : { return eNodeType != SbxNODE && eNodeType != SbxTYPEOF && eNodeType != SbxNEW; }
[ + - ]
110 : 893 : bool IsTypeOf()
111 : 893 : { return eNodeType == SbxTYPEOF; }
112 : 893 : bool IsNew()
113 : 893 : { return eNodeType == SbxNEW; }
114 : : bool IsNumber();
115 : : bool IsLvalue(); // true, if usable as Lvalue
116 : : void GenElement( SbiOpcode );
117 : : void BaseInit( SbiParser* p ); // help function for Ctor, from 17.12.95
118 : : public:
119 : : SbiExprNode( void );
120 : : SbiExprNode( SbiParser*, double, SbxDataType );
121 : : SbiExprNode( SbiParser*, const String& );
122 : : SbiExprNode( SbiParser*, const SbiSymDef&, SbxDataType, SbiExprList* = NULL );
123 : : SbiExprNode( SbiParser*, SbiExprNode*, SbiToken, SbiExprNode* );
124 : : SbiExprNode( SbiParser*, SbiExprNode*, sal_uInt16 ); // #120061 TypeOf
125 : : SbiExprNode( SbiParser*, sal_uInt16 ); // new <type>
126 : : virtual ~SbiExprNode();
127 : :
128 : 2458 : bool IsValid() { return !bError; }
129 : 9065 : bool IsConstant() // true: constant operand
130 [ + + ][ + + ]: 9065 : { return eNodeType == SbxSTRVAL || eNodeType == SbxNUMVAL; }
131 : : bool IsIntConst();
132 : : bool IsVariable();
133 : :
134 : 4438 : SbiExprNode* GetWithParent() { return pWithParent; }
135 : 0 : void SetWithParent( SbiExprNode* p ) { pWithParent = p; }
136 : :
137 : 8042 : SbxDataType GetType() { return eType; }
138 : 0 : void SetType( SbxDataType eTp ) { eType = eTp; }
139 : 0 : SbiNodeType GetNodeType() { return eNodeType; }
140 : : SbiSymDef* GetVar();
141 : : SbiSymDef* GetRealVar(); // last variable in x.y.z
142 : : SbiExprNode* GetRealNode(); // last node in x.y.z
143 : : short GetDepth(); // compute a tree's depth
144 : 172 : const String& GetString() { return aStrVal; }
145 : 0 : short GetNumber() { return (short)nVal; }
146 : 0 : SbiExprList* GetParameters() { return aVar.pPar; }
147 : : SbiExprListVector* GetMoreParameters() { return aVar.pvMorePar; }
148 : :
149 : : void Optimize(); // tree matching
150 : :
151 : : void Gen( RecursiveMode eRecMode = UNDEFINED ); // giving out a node
152 : : };
153 : :
154 : : class SbiExpression {
155 : : friend class SbiExprList;
156 : : friend class SbiParameters;
157 : : friend class SbiDimList;
158 : : protected:
159 : : String aArgName;
160 : : SbiParser* pParser;
161 : : SbiExpression* pNext; // link at parameter lists
162 : : SbiExprNode* pExpr; // expression tree
163 : : SbiExprType eCurExpr; // type of expression
164 : : SbiExprMode m_eMode; // expression context
165 : : bool bBased; // true: easy DIM-part (+BASE)
166 : : bool bError;
167 : : bool bByVal; // true: ByVal-Parameter
168 : : bool bBracket; // true: Parameter list with brackets
169 : : sal_uInt16 nParenLevel;
170 : : SbiExprNode* Term( const KeywordSymbolInfo* pKeywordSymbolInfo = NULL );
171 : : SbiExprNode* ObjTerm( SbiSymDef& );
172 : : SbiExprNode* Operand( bool bUsedForTypeOf = false );
173 : : SbiExprNode* Unary();
174 : : SbiExprNode* Exp();
175 : : SbiExprNode* MulDiv();
176 : : SbiExprNode* IntDiv();
177 : : SbiExprNode* Mod();
178 : : SbiExprNode* AddSub();
179 : : SbiExprNode* Cat();
180 : : SbiExprNode* Like();
181 : : SbiExprNode* VBA_Not();
182 : : SbiExprNode* Comp();
183 : : SbiExprNode* Boolean();
184 : : public:
185 : : SbiExpression( SbiParser*, SbiExprType = SbSTDEXPR,
186 : : SbiExprMode eMode = EXPRMODE_STANDARD, const KeywordSymbolInfo* pKeywordSymbolInfo = NULL ); // parsing Ctor
187 : : SbiExpression( SbiParser*, double, SbxDataType = SbxDOUBLE );
188 : : SbiExpression( SbiParser*, const SbiSymDef&, SbiExprList* = NULL );
189 : : ~SbiExpression();
190 : 4402 : String& GetName() { return aArgName; }
191 : 42 : void SetBased() { bBased = true; }
192 : 0 : bool IsBased() { return bBased; }
193 : 0 : void SetByVal() { bByVal = true; }
194 : : bool IsByVal() { return bByVal; }
195 : 21 : bool IsBracket() { return bBracket; }
196 : 2458 : bool IsValid() { return pExpr->IsValid(); }
197 : : bool IsConstant() { return pExpr->IsConstant(); }
198 : 66 : bool IsVariable() { return pExpr->IsVariable(); }
199 : 1197 : bool IsLvalue() { return pExpr->IsLvalue(); }
200 : 42 : bool IsIntConstant() { return pExpr->IsIntConst(); }
201 : 52 : const String& GetString() { return pExpr->GetString(); }
202 : : SbiSymDef* GetVar() { return pExpr->GetVar(); }
203 : 1668 : SbiSymDef* GetRealVar() { return pExpr->GetRealVar(); }
204 : 0 : SbiExprNode* GetExprNode() { return pExpr; }
205 : 4 : SbxDataType GetType() { return pExpr->GetType(); }
206 : : void SetType( SbxDataType eType){ pExpr->eType = eType; }
207 : : void Gen( RecursiveMode eRecMode = UNDEFINED );
208 : : };
209 : :
210 [ + - ]: 258 : class SbiConstExpression : public SbiExpression {
211 : : double nVal;
212 : : String aVal;
213 : : SbxDataType eType;
214 : : public: // numeric constant
215 : : SbiConstExpression( SbiParser* );
216 : 384 : SbxDataType GetType() { return eType; }
217 : 132 : const String& GetString() { return aVal; }
218 : 126 : double GetValue() { return nVal; }
219 : : short GetShortValue();
220 : : };
221 : :
222 : : class SbiExprList { // base class for parameters and dims
223 : : protected:
224 : : SbiParser* pParser;
225 : : SbiExpression* pFirst;
226 : : short nExpr;
227 : : short nDim;
228 : : bool bError;
229 : : bool bBracket;
230 : : public:
231 : : SbiExprList( SbiParser* );
232 : : virtual ~SbiExprList();
233 : 1117 : bool IsBracket() { return bBracket; }
234 : 1547 : bool IsValid() { return !bError; }
235 : 6282 : short GetSize() { return nExpr; }
236 : 144 : short GetDims() { return nDim; }
237 : : SbiExpression* Get( short );
238 : : void Gen(); // code generation
239 : : void addExpression( SbiExpression* pExpr );
240 : : };
241 : :
242 [ - + ]: 10120 : class SbiParameters : public SbiExprList {
243 : : public:
244 : : SbiParameters( SbiParser*, bool bStandaloneExpression = false, bool bPar = true);// parsing Ctor
245 : : };
246 : :
247 [ - + ]: 96 : class SbiDimList : public SbiExprList {
248 : : bool bConst; // true: everything integer constants
249 : : public:
250 : : SbiDimList( SbiParser* ); // parsing Ctor
251 : : bool IsConstant() { return bConst; }
252 : : };
253 : :
254 : : #endif
255 : :
256 : : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
