| /************************************************************** | |
| * | |
| * 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. | |
| * | |
| *************************************************************/ | |
| // MARKER(update_precomp.py): autogen include statement, do not remove | |
| #include "precompiled_basic.hxx" | |
| #include "sbcomp.hxx" | |
| #include <basic/sbx.hxx> // w.g. ...IMPL_REF(...sbxvariable) | |
| #include "expr.hxx" | |
| /*************************************************************************** | |
| |* | |
| |* SbiExpression | |
| |* | |
| ***************************************************************************/ | |
| SbiExpression::SbiExpression( SbiParser* p, SbiExprType t, | |
| SbiExprMode eMode, const KeywordSymbolInfo* pKeywordSymbolInfo ) | |
| { | |
| pParser = p; | |
| bError = bByVal = bBased = bBracket = sal_False; | |
| nParenLevel = 0; | |
| eCurExpr = t; | |
| m_eMode = eMode; | |
| pNext = NULL; | |
| pExpr = (t != SbSTDEXPR ) ? Term( pKeywordSymbolInfo ) : Boolean(); | |
| if( t != SbSYMBOL ) | |
| pExpr->Optimize(); | |
| if( t == SbLVALUE && !pExpr->IsLvalue() ) | |
| p->Error( SbERR_LVALUE_EXPECTED ); | |
| if( t == SbOPERAND && !IsVariable() ) | |
| p->Error( SbERR_VAR_EXPECTED ); | |
| } | |
| SbiExpression::SbiExpression( SbiParser* p, double n, SbxDataType t ) | |
| { | |
| pParser = p; | |
| eCurExpr = SbOPERAND; | |
| pNext = NULL; | |
| bError = bByVal = bBased = bBracket = sal_False; | |
| pExpr = new SbiExprNode( pParser, n, t ); | |
| pExpr->Optimize(); | |
| } | |
| SbiExpression::SbiExpression( SbiParser* p, const String& r ) | |
| { | |
| pParser = p; | |
| pNext = NULL; | |
| bError = bByVal = bBased = bBracket = sal_False; | |
| eCurExpr = SbOPERAND; | |
| pExpr = new SbiExprNode( pParser, r ); | |
| } | |
| SbiExpression::SbiExpression( SbiParser* p, const SbiSymDef& r, SbiExprList* pPar ) | |
| { | |
| pParser = p; | |
| pNext = NULL; | |
| bError = bByVal = bBased = bBracket = sal_False; | |
| eCurExpr = SbOPERAND; | |
| pExpr = new SbiExprNode( pParser, r, SbxVARIANT, pPar ); | |
| } | |
| SbiExpression::SbiExpression( SbiParser* p, SbiToken t ) | |
| { | |
| pParser = p; | |
| pNext = NULL; | |
| bError = bByVal = bBased = bBracket = sal_False; | |
| eCurExpr = SbOPERAND; | |
| pExpr = new SbiExprNode( pParser, NULL, t, NULL ); | |
| } | |
| SbiExpression::~SbiExpression() | |
| { | |
| delete pExpr; | |
| } | |
| // Einlesen eines kompletten Bezeichners | |
| // Ein Bezeichner hat folgende Form: | |
| // name[(Parameter)][.Name[(parameter)]]... | |
| // Strukturelemente werden ueber das Element pNext verkoppelt, | |
| // damit sie nicht im Baum stehen. | |
| // Folgen Parameter ohne Klammer? Dies kann eine Zahl, ein String, | |
| // ein Symbol oder auch ein Komma sein (wenn der 1. Parameter fehlt) | |
| static sal_Bool DoParametersFollow( SbiParser* p, SbiExprType eCurExpr, SbiToken eTok ) | |
| { | |
| if( eTok == LPAREN ) | |
| return sal_True; | |
| // Aber nur, wenn CALL-aehnlich! | |
| if( !p->WhiteSpace() || eCurExpr != SbSYMBOL ) | |
| return sal_False; | |
| if ( eTok == NUMBER || eTok == MINUS || eTok == FIXSTRING | |
| || eTok == SYMBOL || eTok == COMMA || eTok == DOT || eTok == NOT || eTok == BYVAL ) | |
| { | |
| return sal_True; | |
| } | |
| else // check for default params with reserved names ( e.g. names of tokens ) | |
| { | |
| SbiTokenizer tokens( *(SbiTokenizer*)p ); | |
| // Urk the Next() / Peek() symantics are... weird | |
| tokens.Next(); | |
| if ( tokens.Peek() == ASSIGN ) | |
| return sal_True; | |
| } | |
| return sal_False; | |
| } | |
| // Definition eines neuen Symbols | |
| static SbiSymDef* AddSym | |
| ( SbiToken eTok, SbiSymPool& rPool, SbiExprType eCurExpr, | |
| const String& rName, SbxDataType eType, SbiParameters* pPar ) | |
| { | |
| SbiSymDef* pDef; | |
| // A= ist keine Prozedur | |
| sal_Bool bHasType = sal_Bool( eTok == EQ || eTok == DOT ); | |
| if( ( !bHasType && eCurExpr == SbSYMBOL ) || pPar ) | |
| { | |
| // Dies ist also eine Prozedur | |
| // da suche man doch den richtigen Pool raus, da Procs | |
| // immer in einem Public-Pool landen muessen | |
| SbiSymPool* pPool = &rPool; | |
| if( pPool->GetScope() != SbPUBLIC ) | |
| pPool = &rPool.GetParser()->aPublics; | |
| SbiProcDef* pProc = pPool->AddProc( rName ); | |
| // Sonderbehandlung fuer Colls wie Documents(1) | |
| if( eCurExpr == SbSTDEXPR ) | |
| bHasType = sal_True; | |
| pDef = pProc; | |
| pDef->SetType( bHasType ? eType : SbxEMPTY ); | |
| if( pPar ) | |
| { | |
| // Dummy-Parameter generieren | |
| sal_uInt16 n = 1; | |
| for( short i = 0; i < pPar->GetSize(); i++ ) | |
| { | |
| String aPar = String::CreateFromAscii( "PAR" ); | |
| aPar += ++n; | |
| pProc->GetParams().AddSym( aPar ); | |
| } | |
| } | |
| } | |
| else | |
| { | |
| // oder ein normales Symbol | |
| pDef = rPool.AddSym( rName ); | |
| pDef->SetType( eType ); | |
| } | |
| return pDef; | |
| } | |
| // Zur Zeit sind sogar Keywords zugelassen (wg. gleichnamiger Dflt-Properties) | |
| SbiExprNode* SbiExpression::Term( const KeywordSymbolInfo* pKeywordSymbolInfo ) | |
| { | |
| if( pParser->Peek() == DOT ) | |
| { | |
| // eine WITH-Variable | |
| SbiExprNode* pWithVar = pParser->GetWithVar(); | |
| // #26608: Ans Ende der Node-Kette gehen, um richtiges Objekt zu uebergeben | |
| SbiSymDef* pDef = pWithVar ? pWithVar->GetRealVar() : NULL; | |
| SbiExprNode* pNd = NULL; | |
| if( !pDef ) | |
| { | |
| pParser->Next(); | |
| } | |
| else | |
| { | |
| pNd = ObjTerm( *pDef ); | |
| if( pNd ) | |
| pNd->SetWithParent( pWithVar ); | |
| } | |
| if( !pNd ) | |
| { | |
| pParser->Error( SbERR_UNEXPECTED, DOT ); | |
| pNd = new SbiExprNode( pParser, 1.0, SbxDOUBLE ); | |
| } | |
| return pNd; | |
| } | |
| SbiToken eTok = (pKeywordSymbolInfo == NULL) ? pParser->Next() : pKeywordSymbolInfo->m_eTok; | |
| // Anfang des Parsings merken | |
| pParser->LockColumn(); | |
| String aSym( (pKeywordSymbolInfo == NULL) ? pParser->GetSym() : pKeywordSymbolInfo->m_aKeywordSymbol ); | |
| SbxDataType eType = (pKeywordSymbolInfo == NULL) ? pParser->GetType() : pKeywordSymbolInfo->m_eSbxDataType; | |
| SbiParameters* pPar = NULL; | |
| SbiExprListVector* pvMoreParLcl = NULL; | |
| // Folgen Parameter? | |
| SbiToken eNextTok = pParser->Peek(); | |
| // Ist es ein benannter Parameter? | |
| // Dann einfach eine Stringkonstante erzeugen. Diese wird | |
| // im SbiParameters-ctor erkannt und weiterverarbeitet | |
| if( eNextTok == ASSIGN ) | |
| { | |
| pParser->UnlockColumn(); | |
| return new SbiExprNode( pParser, aSym ); | |
| } | |
| // ab hier sind keine Keywords zugelassen! | |
| if( pParser->IsKwd( eTok ) ) | |
| { | |
| if( pParser->IsCompatible() && eTok == INPUT ) | |
| { | |
| eTok = SYMBOL; | |
| } | |
| else | |
| { | |
| pParser->Error( SbERR_SYNTAX ); | |
| bError = sal_True; | |
| } | |
| } | |
| if( DoParametersFollow( pParser, eCurExpr, eTok = eNextTok ) ) | |
| { | |
| bool bStandaloneExpression = (m_eMode == EXPRMODE_STANDALONE); | |
| pPar = new SbiParameters( pParser, bStandaloneExpression ); | |
| bError |= !pPar->IsValid(); | |
| if( !bError ) | |
| bBracket = pPar->IsBracket(); | |
| eTok = pParser->Peek(); | |
| // i75443 check for additional sets of parameters | |
| while( eTok == LPAREN ) | |
| { | |
| if( pvMoreParLcl == NULL ) | |
| pvMoreParLcl = new SbiExprListVector(); | |
| SbiParameters* pAddPar = new SbiParameters( pParser ); | |
| pvMoreParLcl->push_back( pAddPar ); | |
| bError |= !pPar->IsValid(); | |
| eTok = pParser->Peek(); | |
| } | |
| } | |
| // Es koennte ein Objektteil sein, wenn . oder ! folgt | |
| // Bei . muss aber die Variable bereits definiert sein; wenn pDef | |
| // nach der Suche NULL ist, isses ein Objekt! | |
| sal_Bool bObj = sal_Bool( ( eTok == DOT || eTok == EXCLAM ) | |
| && !pParser->WhiteSpace() ); | |
| if( bObj ) | |
| { | |
| bBracket = sal_False; // Now the bracket for the first term is obsolete | |
| if( eType == SbxVARIANT ) | |
| eType = SbxOBJECT; | |
| else | |
| { | |
| // Name%. geht wirklich nicht! | |
| pParser->Error( SbERR_BAD_DECLARATION, aSym ); | |
| bError = sal_True; | |
| } | |
| } | |
| // Suche: | |
| SbiSymDef* pDef = pParser->pPool->Find( aSym ); | |
| if( !pDef ) | |
| { | |
| // Teil der Runtime-Library? | |
| // AB 31.3.1996: In Parser-Methode ausgelagert | |
| // (wird auch in SbiParser::DefVar() in DIM.CXX benoetigt) | |
| pDef = pParser->CheckRTLForSym( aSym, eType ); | |
| // #i109184: Check if symbol is or later will be defined inside module | |
| SbModule& rMod = pParser->aGen.GetModule(); | |
| SbxArray* pModMethods = rMod.GetMethods(); | |
| if( pModMethods->Find( aSym, SbxCLASS_DONTCARE ) ) | |
| pDef = NULL; | |
| } | |
| if( !pDef ) | |
| { | |
| // Falls ein Punkt angegeben war, isses Teil eines Objekts, | |
| // also muss der Returnwert ein Objekt sein | |
| if( bObj ) | |
| eType = SbxOBJECT; | |
| pDef = AddSym( eTok, *pParser->pPool, eCurExpr, aSym, eType, pPar ); | |
| // Looks like this is a local ( but undefined variable ) | |
| // if it is in a static procedure then make this Symbol | |
| // static | |
| if ( !bObj && pParser->pProc && pParser->pProc->IsStatic() ) | |
| pDef->SetStatic(); | |
| } | |
| else | |
| { | |
| // Symbol ist bereits definiert. | |
| // Ist es eine Konstante? | |
| SbiConstDef* pConst = pDef->GetConstDef(); | |
| if( pConst ) | |
| { | |
| if( pConst->GetType() == SbxSTRING ) | |
| return new SbiExprNode( pParser, pConst->GetString() ); | |
| else | |
| return new SbiExprNode( pParser, pConst->GetValue(), pConst->GetType() ); | |
| } | |
| // Hat es Dimensionen, | |
| // und sind auch Parameter angegeben? | |
| // (Wobei 0 Parameter () entsprechen) | |
| if( pDef->GetDims() ) | |
| { | |
| if( pPar && pPar->GetSize() && pPar->GetSize() != pDef->GetDims() ) | |
| pParser->Error( SbERR_WRONG_DIMS ); | |
| } | |
| if( pDef->IsDefinedAs() ) | |
| { | |
| SbxDataType eDefType = pDef->GetType(); | |
| // #119187 Only error if types conflict | |
| if( eType >= SbxINTEGER && eType <= SbxSTRING && eType != eDefType ) | |
| { | |
| // Wie? Erst mit AS definieren und dann einen Suffix nehmen? | |
| pParser->Error( SbERR_BAD_DECLARATION, aSym ); | |
| bError = sal_True; | |
| } | |
| else if ( eType == SbxVARIANT ) | |
| // Falls nix angegeben, den Typ des Eintrags nehmen | |
| // aber nur, wenn die Var nicht mit AS XXX definiert ist | |
| // damit erwischen wir n% = 5 : print n | |
| eType = eDefType; | |
| } | |
| // Typcheck bei Variablen: | |
| // ist explizit im Scanner etwas anderes angegeben? | |
| // Bei Methoden ist dies OK! | |
| if( eType != SbxVARIANT && // Variant nimmt alles | |
| eType != pDef->GetType() && | |
| !pDef->GetProcDef() ) | |
| { | |
| // Es kann sein, dass pDef ein Objekt beschreibt, das bisher | |
| // nur als SbxVARIANT erkannt wurde, dann Typ von pDef aendern | |
| // AB, 16.12.95 (Vielleicht noch aehnliche Faelle moeglich ?!?) | |
| if( eType == SbxOBJECT && pDef->GetType() == SbxVARIANT ) | |
| { | |
| pDef->SetType( SbxOBJECT ); | |
| } | |
| else | |
| { | |
| pParser->Error( SbERR_BAD_DECLARATION, aSym ); | |
| bError = sal_True; | |
| } | |
| } | |
| } | |
| SbiExprNode* pNd = new SbiExprNode( pParser, *pDef, eType ); | |
| if( !pPar ) | |
| pPar = new SbiParameters( pParser,sal_False,sal_False ); | |
| pNd->aVar.pPar = pPar; | |
| pNd->aVar.pvMorePar = pvMoreParLcl; | |
| if( bObj ) | |
| { | |
| // AB, 8.1.95: Objekt kann auch vom Typ SbxVARIANT sein | |
| if( pDef->GetType() == SbxVARIANT ) | |
| pDef->SetType( SbxOBJECT ); | |
| // Falls wir etwas mit Punkt einscannen, muss der | |
| // Typ SbxOBJECT sein | |
| if( pDef->GetType() != SbxOBJECT && pDef->GetType() != SbxVARIANT ) | |
| { | |
| pParser->Error( SbERR_BAD_DECLARATION, aSym ); | |
| bError = sal_True; | |
| } | |
| if( !bError ) | |
| pNd->aVar.pNext = ObjTerm( *pDef ); | |
| } | |
| // Merken der Spalte 1 wieder freigeben | |
| pParser->UnlockColumn(); | |
| return pNd; | |
| } | |
| // Aufbau eines Objekt-Terms. Ein derartiger Term ist Teil | |
| // eines Ausdrucks, der mit einer Objektvariablen beginnt. | |
| SbiExprNode* SbiExpression::ObjTerm( SbiSymDef& rObj ) | |
| { | |
| pParser->Next(); | |
| SbiToken eTok = pParser->Next(); | |
| if( eTok != SYMBOL && !pParser->IsKwd( eTok ) && !pParser->IsExtra( eTok ) ) | |
| { | |
| // #66745 Einige Operatoren koennen in diesem Kontext auch | |
| // als Identifier zugelassen werden, wichtig fuer StarOne | |
| if( eTok != MOD && eTok != NOT && eTok != AND && eTok != OR && | |
| eTok != XOR && eTok != EQV && eTok != IMP && eTok != IS ) | |
| { | |
| pParser->Error( SbERR_VAR_EXPECTED ); | |
| bError = sal_True; | |
| } | |
| } | |
| /* #118410 Allow type for Class methods and RTL object, e.g. RTL.Chr$(97) | |
| else | |
| { | |
| if( pParser->GetType() != SbxVARIANT ) | |
| pParser->Error( SbERR_SYNTAX ), bError = sal_True; | |
| } | |
| */ | |
| if( bError ) | |
| return NULL; | |
| String aSym( pParser->GetSym() ); | |
| SbxDataType eType = pParser->GetType(); | |
| SbiParameters* pPar = NULL; | |
| SbiExprListVector* pvMoreParLcl = NULL; | |
| eTok = pParser->Peek(); | |
| // Parameter? | |
| if( DoParametersFollow( pParser, eCurExpr, eTok ) ) | |
| { | |
| bool bStandaloneExpression = false; | |
| pPar = new SbiParameters( pParser, bStandaloneExpression ); | |
| bError |= !pPar->IsValid(); | |
| eTok = pParser->Peek(); | |
| // i109624 check for additional sets of parameters | |
| while( eTok == LPAREN ) | |
| { | |
| if( pvMoreParLcl == NULL ) | |
| pvMoreParLcl = new SbiExprListVector(); | |
| SbiParameters* pAddPar = new SbiParameters( pParser ); | |
| pvMoreParLcl->push_back( pAddPar ); | |
| bError |= !pPar->IsValid(); | |
| eTok = pParser->Peek(); | |
| } | |
| } | |
| sal_Bool bObj = sal_Bool( ( eTok == DOT || eTok == EXCLAM ) && !pParser->WhiteSpace() ); | |
| if( bObj ) | |
| { | |
| if( eType == SbxVARIANT ) | |
| eType = SbxOBJECT; | |
| else | |
| { | |
| // Name%. geht wirklich nicht! | |
| pParser->Error( SbERR_BAD_DECLARATION, aSym ); | |
| bError = sal_True; | |
| } | |
| } | |
| // Der Symbol-Pool eines Objekts ist immer PUBLIC | |
| SbiSymPool& rPool = rObj.GetPool(); | |
| rPool.SetScope( SbPUBLIC ); | |
| SbiSymDef* pDef = rPool.Find( aSym ); | |
| if( !pDef ) | |
| { | |
| pDef = AddSym( eTok, rPool, eCurExpr, aSym, eType, pPar ); | |
| pDef->SetType( eType ); | |
| } | |
| SbiExprNode* pNd = new SbiExprNode( pParser, *pDef, eType ); | |
| pNd->aVar.pPar = pPar; | |
| pNd->aVar.pvMorePar = pvMoreParLcl; | |
| if( bObj ) | |
| { | |
| // Falls wir etwas mit Punkt einscannen, muss der | |
| // Typ SbxOBJECT sein | |
| // AB, 3.1.96 | |
| // Es kann sein, dass pDef ein Objekt beschreibt, das bisher | |
| // nur als SbxVARIANT erkannt wurde, dann Typ von pDef aendern | |
| if( pDef->GetType() == SbxVARIANT ) | |
| pDef->SetType( SbxOBJECT ); | |
| if( pDef->GetType() != SbxOBJECT ) | |
| { | |
| pParser->Error( SbERR_BAD_DECLARATION, aSym ); | |
| bError = sal_True; | |
| } | |
| if( !bError ) | |
| { | |
| pNd->aVar.pNext = ObjTerm( *pDef ); | |
| pNd->eType = eType; | |
| } | |
| } | |
| return pNd; | |
| } | |
| // Als Operanden kommen in Betracht: | |
| // Konstante | |
| // skalare Variable | |
| // Strukturelemente | |
| // Array-Elemente | |
| // Funktionen | |
| // geklammerte Ausdruecke | |
| SbiExprNode* SbiExpression::Operand( bool bUsedForTypeOf ) | |
| { | |
| SbiExprNode *pRes; | |
| SbiToken eTok; | |
| // Operand testen: | |
| switch( eTok = pParser->Peek() ) | |
| { | |
| case SYMBOL: | |
| pRes = Term(); | |
| // process something like "IF Not r Is Nothing Then .." | |
| if( !bUsedForTypeOf && pParser->IsVBASupportOn() && pParser->Peek() == IS ) | |
| { | |
| eTok = pParser->Next(); | |
| pRes = new SbiExprNode( pParser, pRes, eTok, Like() ); | |
| } | |
| break; | |
| case DOT: // .with | |
| pRes = Term(); break; | |
| case NUMBER: | |
| pParser->Next(); | |
| pRes = new SbiExprNode( pParser, pParser->GetDbl(), pParser->GetType() ); | |
| break; | |
| case FIXSTRING: | |
| pParser->Next(); | |
| pRes = new SbiExprNode( pParser, pParser->GetSym() ); break; | |
| case LPAREN: | |
| pParser->Next(); | |
| if( nParenLevel == 0 && m_eMode == EXPRMODE_LPAREN_PENDING && pParser->Peek() == RPAREN ) | |
| { | |
| m_eMode = EXPRMODE_EMPTY_PAREN; | |
| pRes = new SbiExprNode(); // Dummy node | |
| pParser->Next(); | |
| break; | |
| } | |
| nParenLevel++; | |
| pRes = Boolean(); | |
| if( pParser->Peek() != RPAREN ) | |
| { | |
| // If there was a LPARAM, it does not belong to the expression | |
| if( nParenLevel == 1 && m_eMode == EXPRMODE_LPAREN_PENDING ) | |
| m_eMode = EXPRMODE_LPAREN_NOT_NEEDED; | |
| else | |
| pParser->Error( SbERR_BAD_BRACKETS ); | |
| } | |
| else | |
| { | |
| pParser->Next(); | |
| if( nParenLevel == 1 && m_eMode == EXPRMODE_LPAREN_PENDING ) | |
| { | |
| SbiToken eTokAfterRParen = pParser->Peek(); | |
| if( eTokAfterRParen == EQ || eTokAfterRParen == LPAREN || eTokAfterRParen == DOT ) | |
| m_eMode = EXPRMODE_ARRAY_OR_OBJECT; | |
| else | |
| m_eMode = EXPRMODE_STANDARD; | |
| } | |
| } | |
| nParenLevel--; | |
| pRes->bComposite = sal_True; | |
| break; | |
| default: | |
| // Zur Zeit sind Keywords hier OK! | |
| if( pParser->IsKwd( eTok ) ) | |
| pRes = Term(); | |
| else | |
| { | |
| pParser->Next(); | |
| pRes = new SbiExprNode( pParser, 1.0, SbxDOUBLE ); // bei Fehlern | |
| pParser->Error( SbERR_UNEXPECTED, eTok ); | |
| } | |
| } | |
| return pRes; | |
| } | |
| SbiExprNode* SbiExpression::Unary() | |
| { | |
| SbiExprNode* pNd; | |
| SbiToken eTok = pParser->Peek(); | |
| switch( eTok ) | |
| { | |
| case MINUS: | |
| eTok = NEG; | |
| pParser->Next(); | |
| pNd = new SbiExprNode( pParser, Unary(), eTok, NULL ); | |
| break; | |
| case NOT: | |
| if( pParser->IsVBASupportOn() ) | |
| { | |
| pNd = Operand(); | |
| } | |
| else | |
| { | |
| pParser->Next(); | |
| pNd = new SbiExprNode( pParser, Unary(), eTok, NULL ); | |
| } | |
| break; | |
| case PLUS: | |
| pParser->Next(); | |
| pNd = Unary(); | |
| break; | |
| case TYPEOF: | |
| { | |
| pParser->Next(); | |
| bool bUsedForTypeOf = true; | |
| SbiExprNode* pObjNode = Operand( bUsedForTypeOf ); | |
| pParser->TestToken( IS ); | |
| String aDummy; | |
| SbiSymDef* pTypeDef = new SbiSymDef( aDummy ); | |
| pParser->TypeDecl( *pTypeDef, sal_True ); | |
| pNd = new SbiExprNode( pParser, pObjNode, pTypeDef->GetTypeId() ); | |
| break; | |
| } | |
| case NEW: | |
| { | |
| pParser->Next(); | |
| String aStr; | |
| SbiSymDef* pTypeDef = new SbiSymDef( aStr ); | |
| pParser->TypeDecl( *pTypeDef, sal_True ); | |
| pNd = new SbiExprNode( pParser, pTypeDef->GetTypeId() ); | |
| break; | |
| } | |
| default: | |
| pNd = Operand(); | |
| } | |
| return pNd; | |
| } | |
| SbiExprNode* SbiExpression::Exp() | |
| { | |
| SbiExprNode* pNd = Unary(); | |
| if( m_eMode != EXPRMODE_EMPTY_PAREN ) | |
| { | |
| while( pParser->Peek() == EXPON ) { | |
| SbiToken eTok = pParser->Next(); | |
| pNd = new SbiExprNode( pParser, pNd, eTok, Unary() ); | |
| } | |
| } | |
| return pNd; | |
| } | |
| SbiExprNode* SbiExpression::MulDiv() | |
| { | |
| SbiExprNode* pNd = Exp(); | |
| if( m_eMode != EXPRMODE_EMPTY_PAREN ) | |
| { | |
| for( ;; ) | |
| { | |
| SbiToken eTok = pParser->Peek(); | |
| if( eTok != MUL && eTok != DIV ) | |
| break; | |
| eTok = pParser->Next(); | |
| pNd = new SbiExprNode( pParser, pNd, eTok, Exp() ); | |
| } | |
| } | |
| return pNd; | |
| } | |
| SbiExprNode* SbiExpression::IntDiv() | |
| { | |
| SbiExprNode* pNd = MulDiv(); | |
| if( m_eMode != EXPRMODE_EMPTY_PAREN ) | |
| { | |
| while( pParser->Peek() == IDIV ) { | |
| SbiToken eTok = pParser->Next(); | |
| pNd = new SbiExprNode( pParser, pNd, eTok, MulDiv() ); | |
| } | |
| } | |
| return pNd; | |
| } | |
| SbiExprNode* SbiExpression::Mod() | |
| { | |
| SbiExprNode* pNd = IntDiv(); | |
| if( m_eMode != EXPRMODE_EMPTY_PAREN ) | |
| { | |
| while( pParser->Peek() == MOD ) { | |
| SbiToken eTok = pParser->Next(); | |
| pNd = new SbiExprNode( pParser, pNd, eTok, IntDiv() ); | |
| } | |
| } | |
| return pNd; | |
| } | |
| SbiExprNode* SbiExpression::AddSub() | |
| { | |
| SbiExprNode* pNd = Mod(); | |
| if( m_eMode != EXPRMODE_EMPTY_PAREN ) | |
| { | |
| for( ;; ) | |
| { | |
| SbiToken eTok = pParser->Peek(); | |
| if( eTok != PLUS && eTok != MINUS ) | |
| break; | |
| eTok = pParser->Next(); | |
| pNd = new SbiExprNode( pParser, pNd, eTok, Mod() ); | |
| } | |
| } | |
| return pNd; | |
| } | |
| SbiExprNode* SbiExpression::Cat() | |
| { | |
| SbiExprNode* pNd = AddSub(); | |
| if( m_eMode != EXPRMODE_EMPTY_PAREN ) | |
| { | |
| for( ;; ) | |
| { | |
| SbiToken eTok = pParser->Peek(); | |
| if( eTok != CAT ) | |
| break; | |
| eTok = pParser->Next(); | |
| pNd = new SbiExprNode( pParser, pNd, eTok, AddSub() ); | |
| } | |
| } | |
| return pNd; | |
| } | |
| SbiExprNode* SbiExpression::Comp() | |
| { | |
| SbiExprNode* pNd = Cat(); | |
| if( m_eMode != EXPRMODE_EMPTY_PAREN ) | |
| { | |
| short nCount = 0; | |
| for( ;; ) | |
| { | |
| SbiToken eTok = pParser->Peek(); | |
| if( m_eMode == EXPRMODE_ARRAY_OR_OBJECT ) | |
| break; | |
| if( eTok != EQ && eTok != NE && eTok != LT | |
| && eTok != GT && eTok != LE && eTok != GE ) | |
| break; | |
| eTok = pParser->Next(); | |
| pNd = new SbiExprNode( pParser, pNd, eTok, Cat() ); | |
| nCount++; | |
| } | |
| } | |
| return pNd; | |
| } | |
| SbiExprNode* SbiExpression::VBA_Not() | |
| { | |
| SbiExprNode* pNd = NULL; | |
| SbiToken eTok = pParser->Peek(); | |
| if( eTok == NOT ) | |
| { | |
| pParser->Next(); | |
| pNd = new SbiExprNode( pParser, VBA_Not(), eTok, NULL ); | |
| } | |
| else | |
| { | |
| pNd = Comp(); | |
| } | |
| return pNd; | |
| } | |
| SbiExprNode* SbiExpression::Like() | |
| { | |
| SbiExprNode* pNd = pParser->IsVBASupportOn() ? VBA_Not() : Comp(); | |
| if( m_eMode != EXPRMODE_EMPTY_PAREN ) | |
| { | |
| short nCount = 0; | |
| while( pParser->Peek() == LIKE ) { | |
| SbiToken eTok = pParser->Next(); | |
| pNd = new SbiExprNode( pParser, pNd, eTok, Comp() ), nCount++; | |
| } | |
| // Mehrere Operatoren hintereinander gehen nicht | |
| if( nCount > 1 ) | |
| { | |
| pParser->Error( SbERR_SYNTAX ); | |
| bError = sal_True; | |
| } | |
| } | |
| return pNd; | |
| } | |
| SbiExprNode* SbiExpression::Boolean() | |
| { | |
| SbiExprNode* pNd = Like(); | |
| if( m_eMode != EXPRMODE_EMPTY_PAREN ) | |
| { | |
| for( ;; ) | |
| { | |
| SbiToken eTok = pParser->Peek(); | |
| if( eTok != AND && eTok != OR && eTok != XOR | |
| && eTok != EQV && eTok != IMP && eTok != IS ) | |
| break; | |
| eTok = pParser->Next(); | |
| pNd = new SbiExprNode( pParser, pNd, eTok, Like() ); | |
| } | |
| } | |
| return pNd; | |
| } | |
| /*************************************************************************** | |
| |* | |
| |* SbiConstExpression | |
| |* | |
| ***************************************************************************/ | |
| // Parsing einer Expression, die sich zu einer numerischen | |
| // Konstanten verarbeiten laesst. | |
| SbiConstExpression::SbiConstExpression( SbiParser* p ) : SbiExpression( p ) | |
| { | |
| if( pExpr->IsConstant() ) | |
| { | |
| eType = pExpr->GetType(); | |
| if( pExpr->IsNumber() ) | |
| { | |
| nVal = pExpr->nVal; | |
| } | |
| else | |
| { | |
| nVal = 0; | |
| aVal = pExpr->aStrVal; | |
| } | |
| } | |
| else | |
| { | |
| // #40204 Spezialbehandlung fuer sal_Bool-Konstanten | |
| sal_Bool bIsBool = sal_False; | |
| if( pExpr->eNodeType == SbxVARVAL ) | |
| { | |
| SbiSymDef* pVarDef = pExpr->GetVar(); | |
| // Ist es eine sal_Bool-Konstante? | |
| sal_Bool bBoolVal = sal_False; | |
| if( pVarDef->GetName().EqualsIgnoreCaseAscii( "true" ) ) | |
| //if( pVarDef->GetName().ICompare( "true" ) == COMPARE_EQUAL ) | |
| { | |
| bIsBool = sal_True; | |
| bBoolVal = sal_True; | |
| } | |
| else if( pVarDef->GetName().EqualsIgnoreCaseAscii( "false" ) ) | |
| //else if( pVarDef->GetName().ICompare( "false" ) == COMPARE_EQUAL ) | |
| { | |
| bIsBool = sal_True; | |
| bBoolVal = sal_False; | |
| } | |
| // Wenn es ein sal_Bool ist, Node austauschen | |
| if( bIsBool ) | |
| { | |
| delete pExpr; | |
| pExpr = new SbiExprNode( pParser, (bBoolVal ? SbxTRUE : SbxFALSE), SbxINTEGER ); | |
| eType = pExpr->GetType(); | |
| nVal = pExpr->nVal; | |
| } | |
| } | |
| if( !bIsBool ) | |
| { | |
| pParser->Error( SbERR_SYNTAX ); | |
| eType = SbxDOUBLE; | |
| nVal = 0; | |
| } | |
| } | |
| } | |
| short SbiConstExpression::GetShortValue() | |
| { | |
| if( eType == SbxSTRING ) | |
| { | |
| SbxVariableRef refConv = new SbxVariable; | |
| refConv->PutString( aVal ); | |
| return refConv->GetInteger(); | |
| } | |
| else | |
| { | |
| double n = nVal; | |
| if( n > 0 ) n += .5; else n -= .5; | |
| if( n > SbxMAXINT ) n = SbxMAXINT, pParser->Error( SbERR_OUT_OF_RANGE ); | |
| else | |
| if( n < SbxMININT ) n = SbxMININT, pParser->Error( SbERR_OUT_OF_RANGE ); | |
| return (short) n; | |
| } | |
| } | |
| /*************************************************************************** | |
| |* | |
| |* SbiExprList | |
| |* | |
| ***************************************************************************/ | |
| SbiExprList::SbiExprList( SbiParser* p ) | |
| { | |
| pParser = p; | |
| pFirst = NULL; | |
| nExpr = | |
| nDim = 0; | |
| bError = | |
| bBracket = sal_False; | |
| } | |
| SbiExprList::~SbiExprList() | |
| { | |
| SbiExpression* p = pFirst; | |
| while( p ) | |
| { | |
| SbiExpression* q = p->pNext; | |
| delete p; | |
| p = q; | |
| } | |
| } | |
| // Parameter anfordern (ab 0) | |
| SbiExpression* SbiExprList::Get( short n ) | |
| { | |
| SbiExpression* p = pFirst; | |
| while( n-- && p ) | |
| p = p->pNext; | |
| return p; | |
| } | |
| void SbiExprList::addExpression( SbiExpression* pExpr ) | |
| { | |
| SbiExpression* p = pFirst; | |
| while( p && p->pNext ) | |
| p = p->pNext; | |
| p->pNext = pExpr; | |
| } | |
| /*************************************************************************** | |
| |* | |
| |* SbiParameters | |
| |* | |
| ***************************************************************************/ | |
| // Parsender Konstruktor: | |
| // Die Parameterliste wird komplett geparst. | |
| // "Prozedurname()" ist OK. | |
| // Dann handelt es sich um eine Funktion ohne Parameter | |
| // respektive um die Angabe eines Arrays als Prozedurparameter. | |
| // #i79918/#i80532: bConst has never been set to true | |
| // -> reused as bStandaloneExpression | |
| //SbiParameters::SbiParameters( SbiParser* p, sal_Bool bConst, sal_Bool bPar) : | |
| SbiParameters::SbiParameters( SbiParser* p, sal_Bool bStandaloneExpression, sal_Bool bPar) : | |
| SbiExprList( p ) | |
| { | |
| if( !bPar ) | |
| return; | |
| SbiExpression *pExpr; | |
| SbiToken eTok = pParser->Peek(); | |
| // evtl. Klammer auf weg: | |
| bool bAssumeExprLParenMode = false; | |
| bool bAssumeArrayMode = false; | |
| if( eTok == LPAREN ) | |
| { | |
| if( bStandaloneExpression ) | |
| { | |
| bAssumeExprLParenMode = true; | |
| } | |
| else | |
| { | |
| bBracket = sal_True; | |
| pParser->Next(); | |
| eTok = pParser->Peek(); | |
| } | |
| } | |
| // Ende-Test | |
| if( ( bBracket && eTok == RPAREN ) || pParser->IsEoln( eTok ) ) | |
| { | |
| if( eTok == RPAREN ) | |
| pParser->Next(); | |
| return; | |
| } | |
| // Parametertabelle einlesen und in richtiger Folge ablegen! | |
| SbiExpression* pLast = NULL; | |
| String aName; | |
| while( !bError ) | |
| { | |
| aName.Erase(); | |
| // Fehlendes Argument | |
| if( eTok == COMMA ) | |
| { | |
| pExpr = new SbiExpression( pParser, 0, SbxEMPTY ); | |
| //if( bConst ) | |
| // pParser->Error( SbERR_SYNTAX ), bError = sal_True; | |
| } | |
| // Benannte Argumente: entweder .name= oder name:= | |
| else | |
| { | |
| bool bByVal = false; | |
| if( eTok == BYVAL ) | |
| { | |
| bByVal = true; | |
| pParser->Next(); | |
| eTok = pParser->Peek(); | |
| } | |
| if( bAssumeExprLParenMode ) | |
| { | |
| pExpr = new SbiExpression( pParser, SbSTDEXPR, EXPRMODE_LPAREN_PENDING ); | |
| bAssumeExprLParenMode = sal_False; | |
| SbiExprMode eModeAfter = pExpr->m_eMode; | |
| if( eModeAfter == EXPRMODE_LPAREN_NOT_NEEDED ) | |
| { | |
| bBracket = sal_True; | |
| } | |
| else if( eModeAfter == EXPRMODE_ARRAY_OR_OBJECT ) | |
| { | |
| // Expression "looks" like an array assignment | |
| // a(...)[(...)] = ? or a(...).b(...) | |
| // RPAREN is already parsed | |
| bBracket = sal_True; | |
| bAssumeArrayMode = true; | |
| eTok = NIL; | |
| } | |
| else if( eModeAfter == EXPRMODE_EMPTY_PAREN ) | |
| { | |
| bBracket = sal_True; | |
| delete pExpr; | |
| if( bByVal ) | |
| pParser->Error( SbERR_LVALUE_EXPECTED ); | |
| return; | |
| } | |
| } | |
| else | |
| pExpr = new SbiExpression( pParser ); | |
| if( bByVal && pExpr->IsLvalue() ) | |
| pExpr->SetByVal(); | |
| //pExpr = bConst ? new SbiConstExpression( pParser ) | |
| // : new SbiExpression( pParser ); | |
| if( !bAssumeArrayMode ) | |
| { | |
| if( pParser->Peek() == ASSIGN ) | |
| { | |
| // VBA mode: name:= | |
| // SbiExpression::Term() hat einen String daraus gemacht | |
| aName = pExpr->GetString(); | |
| delete pExpr; | |
| pParser->Next(); | |
| pExpr = new SbiExpression( pParser ); | |
| //if( bConst ) | |
| // pParser->Error( SbERR_SYNTAX ), bError = sal_True; | |
| } | |
| pExpr->GetName() = aName; | |
| } | |
| } | |
| pExpr->pNext = NULL; | |
| if( !pLast ) | |
| pFirst = pLast = pExpr; | |
| else | |
| pLast->pNext = pExpr, pLast = pExpr; | |
| nExpr++; | |
| bError |= !pExpr->IsValid(); | |
| if( bAssumeArrayMode ) | |
| break; | |
| // Naechstes Element? | |
| eTok = pParser->Peek(); | |
| if( eTok != COMMA ) | |
| { | |
| if( ( bBracket && eTok == RPAREN ) || pParser->IsEoln( eTok ) ) | |
| break; | |
| pParser->Error( bBracket | |
| ? SbERR_BAD_BRACKETS | |
| : SbERR_EXPECTED, COMMA ); | |
| bError = sal_True; | |
| } | |
| else | |
| { | |
| pParser->Next(); | |
| eTok = pParser->Peek(); | |
| if( ( bBracket && eTok == RPAREN ) || pParser->IsEoln( eTok ) ) | |
| break; | |
| } | |
| } | |
| // Schliessende Klammer | |
| if( eTok == RPAREN ) | |
| { | |
| pParser->Next(); | |
| pParser->Peek(); | |
| if( !bBracket ) | |
| { | |
| pParser->Error( SbERR_BAD_BRACKETS ); | |
| bError = sal_True; | |
| } | |
| } | |
| nDim = nExpr; | |
| } | |
| /*************************************************************************** | |
| |* | |
| |* SbiDimList | |
| |* | |
| ***************************************************************************/ | |
| // Parsender Konstruktor: | |
| // Eine Liste von Array-Dimensionen wird geparst. Die Ausdruecke werden | |
| // auf numerisch getestet. Das bCONST-Bit wird gesetzt, wenn alle Ausdruecke | |
| // Integer-Konstanten sind. | |
| SbiDimList::SbiDimList( SbiParser* p ) : SbiExprList( p ) | |
| { | |
| bConst = sal_True; | |
| if( pParser->Next() != LPAREN ) | |
| { | |
| pParser->Error( SbERR_EXPECTED, LPAREN ); | |
| bError = sal_True; return; | |
| } | |
| if( pParser->Peek() != RPAREN ) | |
| { | |
| SbiExpression *pExpr1, *pExpr2, *pLast = NULL; | |
| SbiToken eTok; | |
| for( ;; ) | |
| { | |
| pExpr1 = new SbiExpression( pParser ); | |
| eTok = pParser->Next(); | |
| if( eTok == TO ) | |
| { | |
| pExpr2 = new SbiExpression( pParser ); | |
| eTok = pParser->Next(); | |
| bConst &= pExpr1->IsIntConstant() & pExpr2->IsIntConstant(); | |
| bError |= !pExpr1->IsValid(); | |
| bError |= !pExpr2->IsValid(); | |
| pExpr1->pNext = pExpr2; | |
| if( !pLast ) | |
| pFirst = pExpr1; | |
| else | |
| pLast->pNext = pExpr1; | |
| pLast = pExpr2; | |
| nExpr += 2; | |
| } | |
| else | |
| { | |
| // Nur eine Dim-Angabe | |
| pExpr1->SetBased(); | |
| pExpr1->pNext = NULL; | |
| bConst &= pExpr1->IsIntConstant(); | |
| bError |= !pExpr1->IsValid(); | |
| if( !pLast ) | |
| pFirst = pLast = pExpr1; | |
| else | |
| pLast->pNext = pExpr1, pLast = pExpr1; | |
| nExpr++; | |
| } | |
| nDim++; | |
| if( eTok == RPAREN ) break; | |
| if( eTok != COMMA ) | |
| { | |
| pParser->Error( SbERR_BAD_BRACKETS ); | |
| pParser->Next(); | |
| break; | |
| } | |
| } | |
| } | |
| else pParser->Next(); | |
| } |