xref: /AOO41X/main/basic/source/comp/exprtree.cxx (revision e1f63238eb022c8a12b30d46a012444ff20e0951) 
1 /**************************************************************
2  *
3  * Licensed to the Apache Software Foundation (ASF) under one
4  * or more contributor license agreements.  See the NOTICE file
5  * distributed with this work for additional information
6  * regarding copyright ownership.  The ASF licenses this file
7  * to you under the Apache License, Version 2.0 (the
8  * "License"); you may not use this file except in compliance
9  * with the License.  You may obtain a copy of the License at
10  *
11  *   http://www.apache.org/licenses/LICENSE-2.0
12  *
13  * Unless required by applicable law or agreed to in writing,
14  * software distributed under the License is distributed on an
15  * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
16  * KIND, either express or implied.  See the License for the
17  * specific language governing permissions and limitations
18  * under the License.
19  *
20  *************************************************************/
21 
22 
23 
24 // MARKER(update_precomp.py): autogen include statement, do not remove
25 #include "precompiled_basic.hxx"
26 
27 #include "sbcomp.hxx"
28 #include <basic/sbx.hxx>        // w.g. ...IMPL_REF(...sbxvariable)
29 #include "expr.hxx"
30 
31 /***************************************************************************
32 |*
33 |*      SbiExpression
34 |*
35 ***************************************************************************/
36 
SbiExpression(SbiParser * p,SbiExprType t,SbiExprMode eMode,const KeywordSymbolInfo * pKeywordSymbolInfo)37 SbiExpression::SbiExpression( SbiParser* p, SbiExprType t,
38     SbiExprMode eMode, const KeywordSymbolInfo* pKeywordSymbolInfo )
39 {
40     pParser = p;
41     bError = bByVal = bBased = bBracket = sal_False;
42     nParenLevel = 0;
43     eCurExpr = t;
44     m_eMode = eMode;
45     pNext = NULL;
46     pExpr = (t != SbSTDEXPR ) ? Term( pKeywordSymbolInfo ) : Boolean();
47     if( t != SbSYMBOL )
48         pExpr->Optimize();
49     if( t == SbLVALUE && !pExpr->IsLvalue() )
50         p->Error( SbERR_LVALUE_EXPECTED );
51     if( t == SbOPERAND && !IsVariable() )
52         p->Error( SbERR_VAR_EXPECTED );
53 }
54 
SbiExpression(SbiParser * p,double n,SbxDataType t)55 SbiExpression::SbiExpression( SbiParser* p, double n, SbxDataType t )
56 {
57     pParser = p;
58     eCurExpr = SbOPERAND;
59     pNext = NULL;
60     bError = bByVal = bBased = bBracket = sal_False;
61     pExpr = new SbiExprNode( pParser, n, t );
62     pExpr->Optimize();
63 }
64 
SbiExpression(SbiParser * p,const String & r)65 SbiExpression::SbiExpression( SbiParser* p, const String& r )
66 {
67     pParser = p;
68     pNext = NULL;
69     bError = bByVal = bBased = bBracket = sal_False;
70     eCurExpr = SbOPERAND;
71     pExpr = new SbiExprNode( pParser, r );
72 }
73 
SbiExpression(SbiParser * p,const SbiSymDef & r,SbiExprList * pPar)74 SbiExpression::SbiExpression( SbiParser* p, const SbiSymDef& r, SbiExprList* pPar )
75 {
76     pParser = p;
77     pNext = NULL;
78     bError = bByVal = bBased = bBracket = sal_False;
79     eCurExpr = SbOPERAND;
80     pExpr = new SbiExprNode( pParser, r, SbxVARIANT, pPar );
81 }
82 
SbiExpression(SbiParser * p,SbiToken t)83 SbiExpression::SbiExpression( SbiParser* p, SbiToken t )
84 {
85     pParser = p;
86     pNext = NULL;
87     bError = bByVal = bBased = bBracket = sal_False;
88     eCurExpr = SbOPERAND;
89     pExpr = new SbiExprNode( pParser, NULL, t, NULL );
90 }
91 
~SbiExpression()92 SbiExpression::~SbiExpression()
93 {
94     delete pExpr;
95 }
96 
97 // Einlesen eines kompletten Bezeichners
98 // Ein Bezeichner hat folgende Form:
99 // name[(Parameter)][.Name[(parameter)]]...
100 // Strukturelemente werden ueber das Element pNext verkoppelt,
101 // damit sie nicht im Baum stehen.
102 
103 // Folgen Parameter ohne Klammer? Dies kann eine Zahl, ein String,
104 // ein Symbol oder auch ein Komma sein (wenn der 1. Parameter fehlt)
105 
DoParametersFollow(SbiParser * p,SbiExprType eCurExpr,SbiToken eTok)106 static sal_Bool DoParametersFollow( SbiParser* p, SbiExprType eCurExpr, SbiToken eTok )
107 {
108     if( eTok == LPAREN )
109         return sal_True;
110     // Aber nur, wenn CALL-aehnlich!
111     if( !p->WhiteSpace() || eCurExpr != SbSYMBOL )
112         return sal_False;
113     if (   eTok == NUMBER || eTok == MINUS || eTok == FIXSTRING
114         || eTok == SYMBOL || eTok == COMMA  || eTok == DOT || eTok == NOT || eTok == BYVAL )
115     {
116         return sal_True;
117     }
118     else // check for default params with reserved names ( e.g. names of tokens )
119     {
120         SbiTokenizer tokens( *(SbiTokenizer*)p );
121         // Urk the Next() / Peek() symantics are... weird
122         tokens.Next();
123         if ( tokens.Peek() == ASSIGN )
124             return sal_True;
125     }
126     return sal_False;
127 }
128 
129 // Definition eines neuen Symbols
130 
AddSym(SbiToken eTok,SbiSymPool & rPool,SbiExprType eCurExpr,const String & rName,SbxDataType eType,SbiParameters * pPar)131 static SbiSymDef* AddSym
132     ( SbiToken eTok, SbiSymPool& rPool, SbiExprType eCurExpr,
133       const String& rName, SbxDataType eType, SbiParameters* pPar )
134 {
135     SbiSymDef* pDef;
136     // A= ist keine Prozedur
137     sal_Bool bHasType = sal_Bool( eTok == EQ || eTok == DOT );
138     if( ( !bHasType && eCurExpr == SbSYMBOL ) || pPar )
139     {
140         // Dies ist also eine Prozedur
141         // da suche man doch den richtigen Pool raus, da Procs
142         // immer in einem Public-Pool landen muessen
143         SbiSymPool* pPool = &rPool;
144         if( pPool->GetScope() != SbPUBLIC )
145             pPool = &rPool.GetParser()->aPublics;
146         SbiProcDef* pProc = pPool->AddProc( rName );
147 
148         // Sonderbehandlung fuer Colls wie Documents(1)
149         if( eCurExpr == SbSTDEXPR )
150             bHasType = sal_True;
151 
152         pDef = pProc;
153         pDef->SetType( bHasType ? eType : SbxEMPTY );
154         if( pPar )
155         {
156             // Dummy-Parameter generieren
157             sal_uInt16 n = 1;
158             for( short i = 0; i < pPar->GetSize(); i++ )
159             {
160                 String aPar = String::CreateFromAscii( "PAR" );
161                 aPar += ++n;
162                 pProc->GetParams().AddSym( aPar );
163             }
164         }
165     }
166     else
167     {
168         // oder ein normales Symbol
169         pDef = rPool.AddSym( rName );
170         pDef->SetType( eType );
171     }
172     return pDef;
173 }
174 
175 // Zur Zeit sind sogar Keywords zugelassen (wg. gleichnamiger Dflt-Properties)
176 
Term(const KeywordSymbolInfo * pKeywordSymbolInfo)177 SbiExprNode* SbiExpression::Term( const KeywordSymbolInfo* pKeywordSymbolInfo )
178 {
179     if( pParser->Peek() == DOT )
180     {
181         // eine WITH-Variable
182         SbiExprNode* pWithVar = pParser->GetWithVar();
183         // #26608: Ans Ende der Node-Kette gehen, um richtiges Objekt zu uebergeben
184         SbiSymDef* pDef = pWithVar ? pWithVar->GetRealVar() : NULL;
185         SbiExprNode* pNd = NULL;
186         if( !pDef )
187         {
188             pParser->Next();
189         }
190         else
191         {
192             pNd = ObjTerm( *pDef );
193             if( pNd )
194                 pNd->SetWithParent( pWithVar );
195         }
196         if( !pNd )
197         {
198             pParser->Error( SbERR_UNEXPECTED, DOT );
199             pNd = new SbiExprNode( pParser, 1.0, SbxDOUBLE );
200         }
201         return pNd;
202     }
203 
204     SbiToken eTok = (pKeywordSymbolInfo == NULL) ? pParser->Next() : pKeywordSymbolInfo->m_eTok;
205     // Anfang des Parsings merken
206     pParser->LockColumn();
207     String aSym( (pKeywordSymbolInfo == NULL) ? pParser->GetSym() : pKeywordSymbolInfo->m_aKeywordSymbol );
208     SbxDataType eType = (pKeywordSymbolInfo == NULL) ? pParser->GetType() : pKeywordSymbolInfo->m_eSbxDataType;
209     SbiParameters* pPar = NULL;
210     SbiExprListVector* pvMoreParLcl = NULL;
211     // Folgen Parameter?
212     SbiToken eNextTok = pParser->Peek();
213     // Ist es ein benannter Parameter?
214     // Dann einfach eine Stringkonstante erzeugen. Diese wird
215     // im SbiParameters-ctor erkannt und weiterverarbeitet
216     if( eNextTok == ASSIGN )
217     {
218         pParser->UnlockColumn();
219         return new SbiExprNode( pParser, aSym );
220     }
221     // ab hier sind keine Keywords zugelassen!
222     if( pParser->IsKwd( eTok ) )
223     {
224         if( pParser->IsCompatible() && eTok == INPUT )
225         {
226             eTok = SYMBOL;
227         }
228         else
229         {
230             pParser->Error( SbERR_SYNTAX );
231             bError = sal_True;
232         }
233     }
234 
235     if( DoParametersFollow( pParser, eCurExpr, eTok = eNextTok ) )
236     {
237         bool bStandaloneExpression = (m_eMode == EXPRMODE_STANDALONE);
238         pPar = new SbiParameters( pParser, bStandaloneExpression );
239         bError |= !pPar->IsValid();
240         if( !bError )
241             bBracket = pPar->IsBracket();
242         eTok = pParser->Peek();
243 
244         // i75443 check for additional sets of parameters
245         while( eTok == LPAREN )
246         {
247             if( pvMoreParLcl == NULL )
248                 pvMoreParLcl = new SbiExprListVector();
249             SbiParameters* pAddPar = new SbiParameters( pParser );
250             pvMoreParLcl->push_back( pAddPar );
251             bError |= !pPar->IsValid();
252             eTok = pParser->Peek();
253         }
254     }
255     // Es koennte ein Objektteil sein, wenn . oder ! folgt
256     // Bei . muss aber die Variable bereits definiert sein; wenn pDef
257     // nach der Suche NULL ist, isses ein Objekt!
258     sal_Bool bObj = sal_Bool( ( eTok == DOT || eTok == EXCLAM )
259                     && !pParser->WhiteSpace() );
260     if( bObj )
261     {
262         bBracket = sal_False;   // Now the bracket for the first term is obsolete
263         if( eType == SbxVARIANT )
264             eType = SbxOBJECT;
265         else
266         {
267             // Name%. geht wirklich nicht!
268             pParser->Error( SbERR_BAD_DECLARATION, aSym );
269             bError = sal_True;
270         }
271     }
272     // Suche:
273     SbiSymDef* pDef = pParser->pPool->Find( aSym );
274     if( !pDef )
275     {
276         // Teil der Runtime-Library?
277         // AB 31.3.1996: In Parser-Methode ausgelagert
278         // (wird auch in SbiParser::DefVar() in DIM.CXX benoetigt)
279         pDef = pParser->CheckRTLForSym( aSym, eType );
280 
281         // #i109184: Check if symbol is or later will be defined inside module
282         SbModule& rMod = pParser->aGen.GetModule();
283         SbxArray* pModMethods = rMod.GetMethods();
284         if( pModMethods->Find( aSym, SbxCLASS_DONTCARE ) )
285             pDef = NULL;
286     }
287     if( !pDef )
288     {
289         // Falls ein Punkt angegeben war, isses Teil eines Objekts,
290         // also muss der Returnwert ein Objekt sein
291         if( bObj )
292             eType = SbxOBJECT;
293         pDef = AddSym( eTok, *pParser->pPool, eCurExpr, aSym, eType, pPar );
294         // Looks like this is a local ( but undefined variable )
295         // if it is in a static procedure then make this Symbol
296         // static
297         if ( !bObj && pParser->pProc && pParser->pProc->IsStatic() )
298             pDef->SetStatic();
299     }
300     else
301     {
302 
303         // Symbol ist bereits definiert.
304         // Ist es eine Konstante?
305         SbiConstDef* pConst = pDef->GetConstDef();
306         if( pConst )
307         {
308             if( pConst->GetType() == SbxSTRING )
309                 return new SbiExprNode( pParser, pConst->GetString() );
310             else
311                 return new SbiExprNode( pParser, pConst->GetValue(), pConst->GetType() );
312         }
313         // Hat es Dimensionen,
314         // und sind auch Parameter angegeben?
315         // (Wobei 0 Parameter () entsprechen)
316         if( pDef->GetDims() )
317         {
318             if( pPar && pPar->GetSize() && pPar->GetSize() != pDef->GetDims() )
319                 pParser->Error( SbERR_WRONG_DIMS );
320         }
321         if( pDef->IsDefinedAs() )
322         {
323             SbxDataType eDefType = pDef->GetType();
324             // #119187 Only error if types conflict
325             if( eType >= SbxINTEGER && eType <= SbxSTRING && eType != eDefType )
326             {
327                 // Wie? Erst mit AS definieren und dann einen Suffix nehmen?
328                 pParser->Error( SbERR_BAD_DECLARATION, aSym );
329                 bError = sal_True;
330             }
331             else if ( eType == SbxVARIANT )
332                 // Falls nix angegeben, den Typ des Eintrags nehmen
333                 // aber nur, wenn die Var nicht mit AS XXX definiert ist
334                 // damit erwischen wir n% = 5 : print n
335                 eType = eDefType;
336         }
337         // Typcheck bei Variablen:
338         // ist explizit im Scanner etwas anderes angegeben?
339         // Bei Methoden ist dies OK!
340         if( eType != SbxVARIANT &&          // Variant nimmt alles
341             eType != pDef->GetType() &&
342             !pDef->GetProcDef() )
343         {
344             // Es kann sein, dass pDef ein Objekt beschreibt, das bisher
345             // nur als SbxVARIANT erkannt wurde, dann Typ von pDef aendern
346             // AB, 16.12.95 (Vielleicht noch aehnliche Faelle moeglich ?!?)
347             if( eType == SbxOBJECT && pDef->GetType() == SbxVARIANT )
348             {
349                 pDef->SetType( SbxOBJECT );
350             }
351             else
352             {
353                 pParser->Error( SbERR_BAD_DECLARATION, aSym );
354                 bError = sal_True;
355             }
356         }
357     }
358     SbiExprNode* pNd = new SbiExprNode( pParser, *pDef, eType );
359     if( !pPar )
360         pPar = new SbiParameters( pParser,sal_False,sal_False );
361     pNd->aVar.pPar = pPar;
362     pNd->aVar.pvMorePar = pvMoreParLcl;
363     if( bObj )
364     {
365         // AB, 8.1.95: Objekt kann auch vom Typ SbxVARIANT sein
366         if( pDef->GetType() == SbxVARIANT )
367             pDef->SetType( SbxOBJECT );
368         // Falls wir etwas mit Punkt einscannen, muss der
369         // Typ SbxOBJECT sein
370         if( pDef->GetType() != SbxOBJECT && pDef->GetType() != SbxVARIANT )
371         {
372             pParser->Error( SbERR_BAD_DECLARATION, aSym );
373             bError = sal_True;
374         }
375         if( !bError )
376             pNd->aVar.pNext = ObjTerm( *pDef );
377     }
378     // Merken der Spalte 1 wieder freigeben
379     pParser->UnlockColumn();
380     return pNd;
381 }
382 
383 // Aufbau eines Objekt-Terms. Ein derartiger Term ist Teil
384 // eines Ausdrucks, der mit einer Objektvariablen beginnt.
385 
ObjTerm(SbiSymDef & rObj)386 SbiExprNode* SbiExpression::ObjTerm( SbiSymDef& rObj )
387 {
388     pParser->Next();
389     SbiToken eTok = pParser->Next();
390     if( eTok != SYMBOL && !pParser->IsKwd( eTok ) && !pParser->IsExtra( eTok ) )
391     {
392         // #66745 Einige Operatoren koennen in diesem Kontext auch
393         // als Identifier zugelassen werden, wichtig fuer StarOne
394         if( eTok != MOD && eTok != NOT && eTok != AND && eTok != OR &&
395             eTok != XOR && eTok != EQV && eTok != IMP && eTok != IS )
396         {
397             pParser->Error( SbERR_VAR_EXPECTED );
398             bError = sal_True;
399         }
400     }
401     /* #118410 Allow type for Class methods and RTL object, e.g. RTL.Chr$(97)
402     else
403     {
404         if( pParser->GetType() != SbxVARIANT )
405             pParser->Error( SbERR_SYNTAX ), bError = sal_True;
406     }
407     */
408     if( bError )
409         return NULL;
410 
411     String aSym( pParser->GetSym() );
412     SbxDataType eType = pParser->GetType();
413     SbiParameters* pPar = NULL;
414     SbiExprListVector* pvMoreParLcl = NULL;
415     eTok = pParser->Peek();
416     // Parameter?
417     if( DoParametersFollow( pParser, eCurExpr, eTok ) )
418     {
419         bool bStandaloneExpression = false;
420         pPar = new SbiParameters( pParser, bStandaloneExpression );
421         bError |= !pPar->IsValid();
422         eTok = pParser->Peek();
423 
424         // i109624 check for additional sets of parameters
425         while( eTok == LPAREN )
426         {
427             if( pvMoreParLcl == NULL )
428                 pvMoreParLcl = new SbiExprListVector();
429             SbiParameters* pAddPar = new SbiParameters( pParser );
430             pvMoreParLcl->push_back( pAddPar );
431             bError |= !pPar->IsValid();
432             eTok = pParser->Peek();
433         }
434 
435     }
436     sal_Bool bObj = sal_Bool( ( eTok == DOT || eTok == EXCLAM ) && !pParser->WhiteSpace() );
437     if( bObj )
438     {
439         if( eType == SbxVARIANT )
440             eType = SbxOBJECT;
441         else
442         {
443             // Name%. geht wirklich nicht!
444             pParser->Error( SbERR_BAD_DECLARATION, aSym );
445             bError = sal_True;
446         }
447     }
448 
449     // Der Symbol-Pool eines Objekts ist immer PUBLIC
450     SbiSymPool& rPool = rObj.GetPool();
451     rPool.SetScope( SbPUBLIC );
452     SbiSymDef* pDef = rPool.Find( aSym );
453     if( !pDef )
454     {
455         pDef = AddSym( eTok, rPool, eCurExpr, aSym, eType, pPar );
456         pDef->SetType( eType );
457     }
458 
459     SbiExprNode* pNd = new SbiExprNode( pParser, *pDef, eType );
460     pNd->aVar.pPar = pPar;
461     pNd->aVar.pvMorePar = pvMoreParLcl;
462     if( bObj )
463     {
464         // Falls wir etwas mit Punkt einscannen, muss der
465         // Typ SbxOBJECT sein
466 
467         // AB, 3.1.96
468         // Es kann sein, dass pDef ein Objekt beschreibt, das bisher
469         // nur als SbxVARIANT erkannt wurde, dann Typ von pDef aendern
470         if( pDef->GetType() == SbxVARIANT )
471             pDef->SetType( SbxOBJECT );
472 
473         if( pDef->GetType() != SbxOBJECT )
474         {
475             pParser->Error( SbERR_BAD_DECLARATION, aSym );
476             bError = sal_True;
477         }
478         if( !bError )
479         {
480             pNd->aVar.pNext = ObjTerm( *pDef );
481             pNd->eType = eType;
482         }
483     }
484     return pNd;
485 }
486 
487 // Als Operanden kommen in Betracht:
488 //      Konstante
489 //      skalare Variable
490 //      Strukturelemente
491 //      Array-Elemente
492 //      Funktionen
493 //      geklammerte Ausdruecke
494 
Operand(bool bUsedForTypeOf)495 SbiExprNode* SbiExpression::Operand( bool bUsedForTypeOf )
496 {
497     SbiExprNode *pRes;
498     SbiToken eTok;
499 
500     // Operand testen:
501     switch( eTok = pParser->Peek() )
502     {
503         case SYMBOL:
504             pRes = Term();
505             // process something like "IF Not r Is Nothing Then .."
506             if( !bUsedForTypeOf && pParser->IsVBASupportOn() && pParser->Peek() == IS )
507             {
508                 eTok = pParser->Next();
509                 pRes = new SbiExprNode( pParser, pRes, eTok, Like() );
510             }
511             break;
512         case DOT:   // .with
513             pRes = Term(); break;
514         case NUMBER:
515             pParser->Next();
516             pRes = new SbiExprNode( pParser, pParser->GetDbl(), pParser->GetType() );
517             break;
518         case FIXSTRING:
519             pParser->Next();
520             pRes = new SbiExprNode( pParser, pParser->GetSym() ); break;
521         case LPAREN:
522             pParser->Next();
523             if( nParenLevel == 0 && m_eMode == EXPRMODE_LPAREN_PENDING && pParser->Peek() == RPAREN )
524             {
525                 m_eMode = EXPRMODE_EMPTY_PAREN;
526                 pRes = new SbiExprNode();   // Dummy node
527                 pParser->Next();
528                 break;
529             }
530             nParenLevel++;
531             pRes = Boolean();
532             if( pParser->Peek() != RPAREN )
533             {
534                 // If there was a LPARAM, it does not belong to the expression
535                 if( nParenLevel == 1 && m_eMode == EXPRMODE_LPAREN_PENDING )
536                     m_eMode = EXPRMODE_LPAREN_NOT_NEEDED;
537                 else
538                     pParser->Error( SbERR_BAD_BRACKETS );
539             }
540             else
541             {
542                 pParser->Next();
543                 if( nParenLevel == 1 && m_eMode == EXPRMODE_LPAREN_PENDING )
544                 {
545                     SbiToken eTokAfterRParen = pParser->Peek();
546                     if( eTokAfterRParen == EQ || eTokAfterRParen == LPAREN || eTokAfterRParen == DOT )
547                         m_eMode = EXPRMODE_ARRAY_OR_OBJECT;
548                     else
549                         m_eMode = EXPRMODE_STANDARD;
550                 }
551             }
552             nParenLevel--;
553             pRes->bComposite = sal_True;
554             break;
555         default:
556             // Zur Zeit sind Keywords hier OK!
557             if( pParser->IsKwd( eTok ) )
558                 pRes = Term();
559             else
560             {
561                 pParser->Next();
562                 pRes = new SbiExprNode( pParser, 1.0, SbxDOUBLE ); // bei Fehlern
563                 pParser->Error( SbERR_UNEXPECTED, eTok );
564             }
565     }
566     return pRes;
567 }
568 
Unary()569 SbiExprNode* SbiExpression::Unary()
570 {
571     SbiExprNode* pNd;
572     SbiToken eTok = pParser->Peek();
573     switch( eTok )
574     {
575         case MINUS:
576             eTok = NEG;
577             pParser->Next();
578             pNd = new SbiExprNode( pParser, Unary(), eTok, NULL );
579             break;
580         case NOT:
581             if( pParser->IsVBASupportOn() )
582             {
583                 pNd = Operand();
584             }
585             else
586             {
587                 pParser->Next();
588                 pNd = new SbiExprNode( pParser, Unary(), eTok, NULL );
589             }
590             break;
591         case PLUS:
592             pParser->Next();
593             pNd = Unary();
594             break;
595         case TYPEOF:
596         {
597             pParser->Next();
598             bool bUsedForTypeOf = true;
599             SbiExprNode* pObjNode = Operand( bUsedForTypeOf );
600             pParser->TestToken( IS );
601             String aDummy;
602             SbiSymDef* pTypeDef = new SbiSymDef( aDummy );
603             pParser->TypeDecl( *pTypeDef, sal_True );
604             pNd = new SbiExprNode( pParser, pObjNode, pTypeDef->GetTypeId() );
605             break;
606         }
607         case NEW:
608         {
609             pParser->Next();
610             String aStr;
611             SbiSymDef* pTypeDef = new SbiSymDef( aStr );
612             pParser->TypeDecl( *pTypeDef, sal_True );
613             pNd = new SbiExprNode( pParser, pTypeDef->GetTypeId() );
614             break;
615         }
616         default:
617             pNd = Operand();
618     }
619     return pNd;
620 }
621 
Exp()622 SbiExprNode* SbiExpression::Exp()
623 {
624     SbiExprNode* pNd = Unary();
625     if( m_eMode != EXPRMODE_EMPTY_PAREN )
626     {
627         while( pParser->Peek() == EXPON ) {
628             SbiToken eTok = pParser->Next();
629             pNd = new SbiExprNode( pParser, pNd, eTok, Unary() );
630         }
631     }
632     return pNd;
633 }
634 
MulDiv()635 SbiExprNode* SbiExpression::MulDiv()
636 {
637     SbiExprNode* pNd = Exp();
638     if( m_eMode != EXPRMODE_EMPTY_PAREN )
639     {
640         for( ;; )
641         {
642             SbiToken eTok = pParser->Peek();
643             if( eTok != MUL && eTok != DIV )
644                 break;
645             eTok = pParser->Next();
646             pNd = new SbiExprNode( pParser, pNd, eTok, Exp() );
647         }
648     }
649     return pNd;
650 }
651 
IntDiv()652 SbiExprNode* SbiExpression::IntDiv()
653 {
654     SbiExprNode* pNd = MulDiv();
655     if( m_eMode != EXPRMODE_EMPTY_PAREN )
656     {
657         while( pParser->Peek() == IDIV ) {
658             SbiToken eTok = pParser->Next();
659             pNd = new SbiExprNode( pParser, pNd, eTok, MulDiv() );
660         }
661     }
662     return pNd;
663 }
664 
Mod()665 SbiExprNode* SbiExpression::Mod()
666 {
667     SbiExprNode* pNd = IntDiv();
668     if( m_eMode != EXPRMODE_EMPTY_PAREN )
669     {
670         while( pParser->Peek() == MOD ) {
671             SbiToken eTok = pParser->Next();
672             pNd = new SbiExprNode( pParser, pNd, eTok, IntDiv() );
673         }
674     }
675     return pNd;
676 }
677 
AddSub()678 SbiExprNode* SbiExpression::AddSub()
679 {
680     SbiExprNode* pNd = Mod();
681     if( m_eMode != EXPRMODE_EMPTY_PAREN )
682     {
683         for( ;; )
684         {
685             SbiToken eTok = pParser->Peek();
686             if( eTok != PLUS && eTok != MINUS )
687                 break;
688             eTok = pParser->Next();
689             pNd = new SbiExprNode( pParser, pNd, eTok, Mod() );
690         }
691     }
692     return pNd;
693 }
694 
Cat()695 SbiExprNode* SbiExpression::Cat()
696 {
697     SbiExprNode* pNd = AddSub();
698     if( m_eMode != EXPRMODE_EMPTY_PAREN )
699     {
700         for( ;; )
701         {
702             SbiToken eTok = pParser->Peek();
703             if( eTok != CAT )
704                 break;
705             eTok = pParser->Next();
706             pNd = new SbiExprNode( pParser, pNd, eTok, AddSub() );
707         }
708     }
709     return pNd;
710 }
711 
Comp()712 SbiExprNode* SbiExpression::Comp()
713 {
714     SbiExprNode* pNd = Cat();
715     if( m_eMode != EXPRMODE_EMPTY_PAREN )
716     {
717         short nCount = 0;
718         for( ;; )
719         {
720             SbiToken eTok = pParser->Peek();
721             if( m_eMode == EXPRMODE_ARRAY_OR_OBJECT )
722                 break;
723             if( eTok != EQ && eTok != NE && eTok != LT
724              && eTok != GT && eTok != LE && eTok != GE )
725                 break;
726             eTok = pParser->Next();
727             pNd = new SbiExprNode( pParser, pNd, eTok, Cat() );
728             nCount++;
729         }
730     }
731     return pNd;
732 }
733 
VBA_Not()734 SbiExprNode* SbiExpression::VBA_Not()
735 {
736     SbiExprNode* pNd = NULL;
737 
738     SbiToken eTok = pParser->Peek();
739     if( eTok == NOT )
740     {
741         pParser->Next();
742         pNd = new SbiExprNode( pParser, VBA_Not(), eTok, NULL );
743     }
744     else
745     {
746         pNd = Comp();
747     }
748     return pNd;
749 }
750 
Like()751 SbiExprNode* SbiExpression::Like()
752 {
753     SbiExprNode* pNd = pParser->IsVBASupportOn() ? VBA_Not() : Comp();
754     if( m_eMode != EXPRMODE_EMPTY_PAREN )
755     {
756         short nCount = 0;
757         while( pParser->Peek() == LIKE ) {
758             SbiToken eTok = pParser->Next();
759             pNd = new SbiExprNode( pParser, pNd, eTok, Comp() ), nCount++;
760         }
761         // Mehrere Operatoren hintereinander gehen nicht
762         if( nCount > 1 )
763         {
764             pParser->Error( SbERR_SYNTAX );
765             bError = sal_True;
766         }
767     }
768     return pNd;
769 }
770 
Boolean()771 SbiExprNode* SbiExpression::Boolean()
772 {
773     SbiExprNode* pNd = Like();
774     if( m_eMode != EXPRMODE_EMPTY_PAREN )
775     {
776         for( ;; )
777         {
778             SbiToken eTok = pParser->Peek();
779             if( eTok != AND && eTok != OR && eTok != XOR
780              && eTok != EQV && eTok != IMP && eTok != IS )
781                 break;
782             eTok = pParser->Next();
783             pNd = new SbiExprNode( pParser, pNd, eTok, Like() );
784         }
785     }
786     return pNd;
787 }
788 
789 /***************************************************************************
790 |*
791 |*      SbiConstExpression
792 |*
793 ***************************************************************************/
794 
795 // Parsing einer Expression, die sich zu einer numerischen
796 // Konstanten verarbeiten laesst.
797 
SbiConstExpression(SbiParser * p)798 SbiConstExpression::SbiConstExpression( SbiParser* p ) : SbiExpression( p )
799 {
800     if( pExpr->IsConstant() )
801     {
802         eType = pExpr->GetType();
803         if( pExpr->IsNumber() )
804         {
805             nVal = pExpr->nVal;
806         }
807         else
808         {
809             nVal = 0;
810             aVal = pExpr->aStrVal;
811         }
812     }
813     else
814     {
815         // #40204 Spezialbehandlung fuer sal_Bool-Konstanten
816         sal_Bool bIsBool = sal_False;
817         if( pExpr->eNodeType == SbxVARVAL )
818         {
819             SbiSymDef* pVarDef = pExpr->GetVar();
820 
821             // Ist es eine sal_Bool-Konstante?
822             sal_Bool bBoolVal = sal_False;
823             if( pVarDef->GetName().EqualsIgnoreCaseAscii( "true" ) )
824             //if( pVarDef->GetName().ICompare( "true" ) == COMPARE_EQUAL )
825             {
826                 bIsBool = sal_True;
827                 bBoolVal = sal_True;
828             }
829             else if( pVarDef->GetName().EqualsIgnoreCaseAscii( "false" ) )
830             //else if( pVarDef->GetName().ICompare( "false" ) == COMPARE_EQUAL )
831             {
832                 bIsBool = sal_True;
833                 bBoolVal = sal_False;
834             }
835 
836             // Wenn es ein sal_Bool ist, Node austauschen
837             if( bIsBool )
838             {
839                 delete pExpr;
840                 pExpr = new SbiExprNode( pParser, (bBoolVal ? SbxTRUE : SbxFALSE), SbxINTEGER );
841                 eType = pExpr->GetType();
842                 nVal = pExpr->nVal;
843             }
844         }
845 
846         if( !bIsBool )
847         {
848             pParser->Error( SbERR_SYNTAX );
849             eType = SbxDOUBLE;
850             nVal = 0;
851         }
852     }
853 }
854 
GetShortValue()855 short SbiConstExpression::GetShortValue()
856 {
857     if( eType == SbxSTRING )
858     {
859         SbxVariableRef refConv = new SbxVariable;
860         refConv->PutString( aVal );
861         return refConv->GetInteger();
862     }
863     else
864     {
865         double n = nVal;
866         if( n > 0 ) n += .5; else n -= .5;
867         if( n > SbxMAXINT ) n = SbxMAXINT, pParser->Error( SbERR_OUT_OF_RANGE );
868         else
869         if( n < SbxMININT ) n = SbxMININT, pParser->Error( SbERR_OUT_OF_RANGE );
870         return (short) n;
871     }
872 }
873 
874 
875 /***************************************************************************
876 |*
877 |*      SbiExprList
878 |*
879 ***************************************************************************/
880 
SbiExprList(SbiParser * p)881 SbiExprList::SbiExprList( SbiParser* p )
882 {
883     pParser = p;
884     pFirst = NULL;
885     nExpr  =
886     nDim   = 0;
887     bError =
888     bBracket = sal_False;
889 }
890 
~SbiExprList()891 SbiExprList::~SbiExprList()
892 {
893     SbiExpression* p = pFirst;
894     while( p )
895     {
896         SbiExpression* q = p->pNext;
897         delete p;
898         p = q;
899     }
900 }
901 
902 // Parameter anfordern (ab 0)
903 
Get(short n)904 SbiExpression* SbiExprList::Get( short n )
905 {
906     SbiExpression* p = pFirst;
907     while( n-- && p )
908         p = p->pNext;
909     return p;
910 }
911 
addExpression(SbiExpression * pExpr)912 void SbiExprList::addExpression( SbiExpression* pExpr )
913 {
914     SbiExpression* p = pFirst;
915     while( p && p->pNext )
916         p = p->pNext;
917 
918     p->pNext = pExpr;
919 }
920 
921 
922 /***************************************************************************
923 |*
924 |*      SbiParameters
925 |*
926 ***************************************************************************/
927 
928 // Parsender Konstruktor:
929 // Die Parameterliste wird komplett geparst.
930 // "Prozedurname()" ist OK.
931 // Dann handelt es sich um eine Funktion ohne Parameter
932 // respektive um die Angabe eines Arrays als Prozedurparameter.
933 
934 // #i79918/#i80532: bConst has never been set to true
935 // -> reused as bStandaloneExpression
936 //SbiParameters::SbiParameters( SbiParser* p, sal_Bool bConst, sal_Bool bPar) :
SbiParameters(SbiParser * p,sal_Bool bStandaloneExpression,sal_Bool bPar)937 SbiParameters::SbiParameters( SbiParser* p, sal_Bool bStandaloneExpression, sal_Bool bPar) :
938     SbiExprList( p )
939 {
940     if( !bPar )
941         return;
942 
943     SbiExpression *pExpr;
944     SbiToken eTok = pParser->Peek();
945 
946     // evtl. Klammer auf weg:
947     bool bAssumeExprLParenMode = false;
948     bool bAssumeArrayMode = false;
949     if( eTok == LPAREN )
950     {
951         if( bStandaloneExpression )
952         {
953             bAssumeExprLParenMode = true;
954         }
955         else
956         {
957             bBracket = sal_True;
958             pParser->Next();
959             eTok = pParser->Peek();
960         }
961     }
962 
963     // Ende-Test
964     if( ( bBracket && eTok == RPAREN ) || pParser->IsEoln( eTok ) )
965     {
966         if( eTok == RPAREN )
967             pParser->Next();
968         return;
969     }
970     // Parametertabelle einlesen und in richtiger Folge ablegen!
971     SbiExpression* pLast = NULL;
972     String aName;
973     while( !bError )
974     {
975         aName.Erase();
976         // Fehlendes Argument
977         if( eTok == COMMA )
978         {
979             pExpr = new SbiExpression( pParser, 0, SbxEMPTY );
980             //if( bConst )
981             //  pParser->Error( SbERR_SYNTAX ), bError = sal_True;
982         }
983         // Benannte Argumente: entweder .name= oder name:=
984         else
985         {
986             bool bByVal = false;
987             if( eTok == BYVAL )
988             {
989                 bByVal = true;
990                 pParser->Next();
991                 eTok = pParser->Peek();
992             }
993 
994             if( bAssumeExprLParenMode )
995             {
996                 pExpr = new SbiExpression( pParser, SbSTDEXPR, EXPRMODE_LPAREN_PENDING );
997                 bAssumeExprLParenMode = sal_False;
998 
999                 SbiExprMode eModeAfter = pExpr->m_eMode;
1000                 if( eModeAfter == EXPRMODE_LPAREN_NOT_NEEDED )
1001                 {
1002                     bBracket = sal_True;
1003                 }
1004                 else if( eModeAfter == EXPRMODE_ARRAY_OR_OBJECT )
1005                 {
1006                     // Expression "looks" like an array assignment
1007                     // a(...)[(...)] = ? or a(...).b(...)
1008                     // RPAREN is already parsed
1009                     bBracket = sal_True;
1010                     bAssumeArrayMode = true;
1011                     eTok = NIL;
1012                 }
1013                 else if( eModeAfter == EXPRMODE_EMPTY_PAREN )
1014                 {
1015                     bBracket = sal_True;
1016                     delete pExpr;
1017                     if( bByVal )
1018                         pParser->Error( SbERR_LVALUE_EXPECTED );
1019                     return;
1020                 }
1021             }
1022             else
1023                 pExpr = new SbiExpression( pParser );
1024 
1025             if( bByVal && pExpr->IsLvalue() )
1026                 pExpr->SetByVal();
1027 
1028             //pExpr = bConst ? new SbiConstExpression( pParser )
1029             //              : new SbiExpression( pParser );
1030             if( !bAssumeArrayMode )
1031             {
1032                 if( pParser->Peek() == ASSIGN )
1033                 {
1034                     // VBA mode: name:=
1035                     // SbiExpression::Term() hat einen String daraus gemacht
1036                     aName = pExpr->GetString();
1037                     delete pExpr;
1038                     pParser->Next();
1039                     pExpr = new SbiExpression( pParser );
1040                     //if( bConst )
1041                     //  pParser->Error( SbERR_SYNTAX ), bError = sal_True;
1042                 }
1043                 pExpr->GetName() = aName;
1044             }
1045         }
1046         pExpr->pNext = NULL;
1047         if( !pLast )
1048             pFirst = pLast = pExpr;
1049         else
1050             pLast->pNext = pExpr, pLast = pExpr;
1051         nExpr++;
1052         bError |= !pExpr->IsValid();
1053 
1054         if( bAssumeArrayMode )
1055             break;
1056 
1057         // Naechstes Element?
1058         eTok = pParser->Peek();
1059         if( eTok != COMMA )
1060         {
1061             if( ( bBracket && eTok == RPAREN ) || pParser->IsEoln( eTok ) )
1062                 break;
1063             pParser->Error( bBracket
1064                             ? SbERR_BAD_BRACKETS
1065                             : SbERR_EXPECTED, COMMA );
1066             bError = sal_True;
1067         }
1068         else
1069         {
1070             pParser->Next();
1071             eTok = pParser->Peek();
1072             if( ( bBracket && eTok == RPAREN ) || pParser->IsEoln( eTok ) )
1073                 break;
1074         }
1075     }
1076     // Schliessende Klammer
1077     if( eTok == RPAREN )
1078     {
1079         pParser->Next();
1080         pParser->Peek();
1081         if( !bBracket )
1082         {
1083             pParser->Error( SbERR_BAD_BRACKETS );
1084             bError = sal_True;
1085         }
1086     }
1087     nDim = nExpr;
1088 }
1089 
1090 /***************************************************************************
1091 |*
1092 |*      SbiDimList
1093 |*
1094 ***************************************************************************/
1095 
1096 // Parsender Konstruktor:
1097 // Eine Liste von Array-Dimensionen wird geparst. Die Ausdruecke werden
1098 // auf numerisch getestet. Das bCONST-Bit wird gesetzt, wenn alle Ausdruecke
1099 // Integer-Konstanten sind.
1100 
SbiDimList(SbiParser * p)1101 SbiDimList::SbiDimList( SbiParser* p ) : SbiExprList( p )
1102 {
1103     bConst = sal_True;
1104 
1105     if( pParser->Next() != LPAREN )
1106     {
1107         pParser->Error( SbERR_EXPECTED, LPAREN );
1108         bError = sal_True; return;
1109     }
1110 
1111     if( pParser->Peek() != RPAREN )
1112     {
1113         SbiExpression *pExpr1, *pExpr2, *pLast = NULL;
1114         SbiToken eTok;
1115         for( ;; )
1116         {
1117             pExpr1 = new SbiExpression( pParser );
1118             eTok = pParser->Next();
1119             if( eTok == TO )
1120             {
1121                 pExpr2 = new SbiExpression( pParser );
1122                 eTok = pParser->Next();
1123                 bConst &= pExpr1->IsIntConstant() & pExpr2->IsIntConstant();
1124                 bError |= !pExpr1->IsValid();
1125                 bError |= !pExpr2->IsValid();
1126                 pExpr1->pNext = pExpr2;
1127                 if( !pLast )
1128                     pFirst = pExpr1;
1129                 else
1130                     pLast->pNext = pExpr1;
1131                 pLast = pExpr2;
1132                 nExpr += 2;
1133             }
1134             else
1135             {
1136                 // Nur eine Dim-Angabe
1137                 pExpr1->SetBased();
1138                 pExpr1->pNext = NULL;
1139                 bConst &= pExpr1->IsIntConstant();
1140                 bError |= !pExpr1->IsValid();
1141                 if( !pLast )
1142                     pFirst = pLast = pExpr1;
1143                 else
1144                     pLast->pNext = pExpr1, pLast = pExpr1;
1145                 nExpr++;
1146             }
1147             nDim++;
1148             if( eTok == RPAREN ) break;
1149             if( eTok != COMMA )
1150             {
1151                 pParser->Error( SbERR_BAD_BRACKETS );
1152                 pParser->Next();
1153                 break;
1154             }
1155         }
1156     }
1157     else pParser->Next();
1158 }
1159 
1160