basic/source/comp/exprtree.cxx

   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
  21 #include "sbcomp.hxx"
  22 #include <basic/sbx.hxx>        // because of ...IMPL_REF(...sbxvariable)
  23 #include "expr.hxx"
  24
  25 /***************************************************************************
  26 |*
  27 |*      SbiExpression
  28 |*
  29 ***************************************************************************/
  30
  31 SbiExpression::SbiExpression( SbiParser* p, SbiExprType t,
  32     SbiExprMode eMode, const KeywordSymbolInfo* pKeywordSymbolInfo )
  33 {
  34     pParser = p;
  35     bBased = bError = bByVal = bBracket = false;
  36     nParenLevel = 0;
  37     eCurExpr = t;
  38     m_eMode = eMode;
  39     pNext = NULL;
  40     pExpr = (t != SbSTDEXPR ) ? Term( pKeywordSymbolInfo ) : Boolean();
  41     if( t != SbSYMBOL )
  42     {
  43         pExpr->Optimize();
  44     }
  45     if( t == SbLVALUE && !pExpr->IsLvalue() )
  46     {
  47         p->Error( SbERR_LVALUE_EXPECTED );
  48     }
  49     if( t == SbOPERAND && !IsVariable() )
  50     {
  51         p->Error( SbERR_VAR_EXPECTED );
  52     }
  53 }
  54
  55 SbiExpression::SbiExpression( SbiParser* p, double n, SbxDataType t )
  56 {
  57     pParser = p;
  58     eCurExpr = SbOPERAND;
  59     pNext = NULL;
  60     bBased = bError = bByVal = bBracket = false;
  61     pExpr = new SbiExprNode( pParser, n, t );
  62     pExpr->Optimize();
  63 }
  64
  65 SbiExpression::SbiExpression( SbiParser* p, const SbiSymDef& r, SbiExprList* pPar )
  66 {
  67     pParser = p;
  68     pNext = NULL;
  69     bBased = bError = bByVal = bBracket = false;
  70     eCurExpr = SbOPERAND;
  71     pExpr = new SbiExprNode( pParser, r, SbxVARIANT, pPar );
  72 }
  73
  74 SbiExpression::~SbiExpression()
  75 {
  76     delete pExpr;
  77 }
  78
  79 // reading in a complete identifier
  80 // an identifier has the following form:
  81 // name[(Parameter)][.Name[(parameter)]]...
  82 // structure elements are coupled via the element pNext,
  83 // so that they're not in the tree.
  84
  85 // Are there parameters without brackets following? This may be a number,
  86 // a string, a symbol or also a comma (if the 1st parameter is missing)
  87
  88 static sal_Bool DoParametersFollow( SbiParser* p, SbiExprType eCurExpr, SbiToken eTok )
  89 {
  90     if( eTok == LPAREN )
  91     {
  92         return sal_True;
  93     }
  94     // but only if similar to CALL!
  95     if( !p->WhiteSpace() || eCurExpr != SbSYMBOL )
  96     {
  97         return sal_False;
  98     }
  99     if ( eTok == NUMBER || eTok == MINUS || eTok == FIXSTRING ||
 100          eTok == SYMBOL || eTok == COMMA  || eTok == DOT || eTok == NOT || eTok == BYVAL )
 101     {
 102         return sal_True;
 103     }
 104     else // check for default params with reserved names ( e.g. names of tokens )
 105     {
 106         SbiTokenizer tokens( *(SbiTokenizer*)p );
 107         // Urk the Next() / Peek() symantics are... weird
 108         tokens.Next();
 109         if ( tokens.Peek() == ASSIGN )
 110         {
 111             return sal_True;
 112         }
 113     }
 114     return sal_False;
 115 }
 116
 117 // definition of a new symbol
 118
 119 static SbiSymDef* AddSym ( SbiToken eTok, SbiSymPool& rPool, SbiExprType eCurExpr,
 120                            const OUString& rName, SbxDataType eType, SbiParameters* pPar )
 121 {
 122     SbiSymDef* pDef;
 123     // A= is not a procedure
 124     sal_Bool bHasType = sal_Bool( eTok == EQ || eTok == DOT );
 125     if( ( !bHasType && eCurExpr == SbSYMBOL ) || pPar )
 126     {
 127         // so this is a procedure
 128         // the correct pool should be found out, as
 129         // procs must always get into a public pool
 130         SbiSymPool* pPool = &rPool;
 131         if( pPool->GetScope() != SbPUBLIC )
 132         {
 133             pPool = &rPool.GetParser()->aPublics;
 134         }
 135         SbiProcDef* pProc = pPool->AddProc( rName );
 136
 137         // special treatment for Colls like Documents(1)
 138         if( eCurExpr == SbSTDEXPR )
 139         {
 140             bHasType = sal_True;
 141         }
 142         pDef = pProc;
 143         pDef->SetType( bHasType ? eType : SbxEMPTY );
 144         if( pPar )
 145         {
 146             // generate dummy parameters
 147             sal_Int32 n = 1;
 148             for( short i = 0; i < pPar->GetSize(); i++ )
 149             {
 150                 n += 1;
 151                 OUStringBuffer aPar("PAR");
 152                 aPar.append(n);
 153                 pProc->GetParams().AddSym( aPar.makeStringAndClear() );
 154             }
 155         }
 156     }
 157     else
 158     {
 159         // or a normal symbol
 160         pDef = rPool.AddSym( rName );
 161         pDef->SetType( eType );
 162     }
 163     return pDef;
 164 }
 165
 166 // currently even keywords are allowed (because of Dflt properties of the same name)
 167
 168 SbiExprNode* SbiExpression::Term( const KeywordSymbolInfo* pKeywordSymbolInfo )
 169 {
 170     if( pParser->Peek() == DOT )
 171     {
 172         SbiExprNode* pWithVar = pParser->GetWithVar();
 173         // #26608: get to the node-chain's end to pass the correct object
 174         SbiSymDef* pDef = pWithVar ? pWithVar->GetRealVar() : NULL;
 175         SbiExprNode* pNd = NULL;
 176         if( !pDef )
 177         {
 178             pParser->Next();
 179         }
 180         else
 181         {
 182             pNd = ObjTerm( *pDef );
 183             if( pNd )
 184             {
 185                 pNd->SetWithParent( pWithVar );
 186             }
 187         }
 188         if( !pNd )
 189         {
 190             pParser->Error( SbERR_UNEXPECTED, DOT );
 191             pNd = new SbiExprNode( pParser, 1.0, SbxDOUBLE );
 192         }
 193         return pNd;
 194     }
 195
 196     SbiToken eTok = (pKeywordSymbolInfo == NULL) ? pParser->Next() : pKeywordSymbolInfo->m_eTok;
 197     // memorize the parsing's begin
 198     pParser->LockColumn();
 199     OUString aSym( (pKeywordSymbolInfo == NULL) ? pParser->GetSym() : pKeywordSymbolInfo->m_aKeywordSymbol );
 200     SbxDataType eType = (pKeywordSymbolInfo == NULL) ? pParser->GetType() : pKeywordSymbolInfo->m_eSbxDataType;
 201     SbiParameters* pPar = NULL;
 202     SbiExprListVector* pvMoreParLcl = NULL;
 203     // are there parameters following?
 204     SbiToken eNextTok = pParser->Peek();
 205     // is it a known parameter?
 206     // create a string constant then, which will be recognized
 207     // in the SbiParameters-ctor and is continued to be handled
 208     if( eNextTok == ASSIGN )
 209     {
 210         pParser->UnlockColumn();
 211         return new SbiExprNode( pParser, aSym );
 212     }
 213     // no keywords allowed from here on!
 214     if( pParser->IsKwd( eTok ) )
 215     {
 216         if( pParser->IsCompatible() && eTok == INPUT )
 217         {
 218             eTok = SYMBOL;
 219         }
 220         else
 221         {
 222             pParser->Error( SbERR_SYNTAX );
 223             bError = true;
 224         }
 225     }
 226
 227     if( DoParametersFollow( pParser, eCurExpr, eTok = eNextTok ) )
 228     {
 229         bool bStandaloneExpression = (m_eMode == EXPRMODE_STANDALONE);
 230         pPar = new SbiParameters( pParser, bStandaloneExpression );
 231         bError = bError || !pPar->IsValid();
 232         if( !bError )
 233             bBracket = pPar->IsBracket();
 234         eTok = pParser->Peek();
 235
 236         // i75443 check for additional sets of parameters
 237         while( eTok == LPAREN )
 238         {
 239             if( pvMoreParLcl == NULL )
 240             {
 241                 pvMoreParLcl = new SbiExprListVector();
 242             }
 243             SbiParameters* pAddPar = new SbiParameters( pParser );
 244             pvMoreParLcl->push_back( pAddPar );
 245             bError = bError || !pAddPar->IsValid();
 246             eTok = pParser->Peek();
 247         }
 248     }
 249     // It might be an object part, if . or ! is following.
 250     // In case of . the variable must already be defined;
 251     // it's an object, if pDef is NULL after the search.
 252     sal_Bool bObj = sal_Bool( ( eTok == DOT || eTok == EXCLAM )
 253                     && !pParser->WhiteSpace() );
 254     if( bObj )
 255     {
 256         bBracket = false;   // Now the bracket for the first term is obsolete
 257         if( eType == SbxVARIANT )
 258         {
 259             eType = SbxOBJECT;
 260         }
 261         else
 262         {
 263             // Name%. really does not work!
 264             pParser->Error( SbERR_BAD_DECLARATION, aSym );
 265             bError = true;
 266         }
 267     }
 268     // Search:
 269     SbiSymDef* pDef = pParser->pPool->Find( aSym );
 270     if( !pDef )
 271     {
 272         // Part of the Runtime-Library?
 273         // from 31.3.1996: swapped out to parser-method
 274         // (is also needed in SbiParser::DefVar() in DIM.CXX)
 275         pDef = pParser->CheckRTLForSym( aSym, eType );
 276
 277         // #i109184: Check if symbol is or later will be defined inside module
 278         SbModule& rMod = pParser->aGen.GetModule();
 279         SbxArray* pModMethods = rMod.GetMethods();
 280         if( pModMethods->Find( aSym, SbxCLASS_DONTCARE ) )
 281         {
 282             pDef = NULL;
 283         }
 284     }
 285     if( !pDef )
 286     {
 287         if( bObj )
 288         {
 289             eType = SbxOBJECT;
 290         }
 291         pDef = AddSym( eTok, *pParser->pPool, eCurExpr, aSym, eType, pPar );
 292         // Looks like this is a local ( but undefined variable )
 293         // if it is in a static procedure then make this Symbol
 294         // static
 295         if ( !bObj && pParser->pProc && pParser->pProc->IsStatic() )
 296         {
 297             pDef->SetStatic();
 298         }
 299     }
 300     else
 301     {
 302
 303         SbiConstDef* pConst = pDef->GetConstDef();
 304         if( pConst )
 305         {
 306             delete pPar;
 307             delete pvMoreParLcl;
 308             if( pConst->GetType() == SbxSTRING )
 309             {
 310                 return new SbiExprNode( pParser, pConst->GetString() );
 311             }
 312             else
 313             {
 314                 return new SbiExprNode( pParser, pConst->GetValue(), pConst->GetType() );
 315             }
 316         }
 317
 318         // 0 parameters come up to ()
 319         if( pDef->GetDims() )
 320         {
 321             if( pPar && pPar->GetSize() && pPar->GetSize() != pDef->GetDims() )
 322             {
 323                 pParser->Error( SbERR_WRONG_DIMS );
 324             }
 325         }
 326         if( pDef->IsDefinedAs() )
 327         {
 328             SbxDataType eDefType = pDef->GetType();
 329             // #119187 Only error if types conflict
 330             if( eType >= SbxINTEGER && eType <= SbxSTRING && eType != eDefType )
 331             {
 332                 // How? Define with AS first and take a Suffix then?
 333                 pParser->Error( SbERR_BAD_DECLARATION, aSym );
 334                 bError = true;
 335             }
 336             else if ( eType == SbxVARIANT )
 337             {
 338                 // if there's nothing named, take the type of the entry,
 339                 // but only if the var hasn't been defined with AS XXX
 340                 // so that we catch n% = 5 : print n
 341                 eType = eDefType;
 342             }
 343         }
 344         // checking type of variables:
 345         // is there named anything different in the scanner?
 346         // That's OK for methods!
 347         if( eType != SbxVARIANT &&          // Variant takes everything
 348             eType != pDef->GetType() &&
 349             !pDef->GetProcDef() )
 350         {
 351             // maybe pDef describes an object that so far has only been
 352             // recognized as SbxVARIANT - then change type of pDef
 353             // from 16.12.95 (similar cases possible perhaps?!?)
 354             if( eType == SbxOBJECT && pDef->GetType() == SbxVARIANT )
 355             {
 356                 pDef->SetType( SbxOBJECT );
 357             }
 358             else
 359             {
 360                 pParser->Error( SbERR_BAD_DECLARATION, aSym );
 361                 bError = true;
 362             }
 363         }
 364     }
 365     SbiExprNode* pNd = new SbiExprNode( pParser, *pDef, eType );
 366     if( !pPar )
 367     {
 368         pPar = new SbiParameters( pParser,sal_False,sal_False );
 369     }
 370     pNd->aVar.pPar = pPar;
 371     pNd->aVar.pvMorePar = pvMoreParLcl;
 372     if( bObj )
 373     {
 374         // from 8.1.95: Object may also be of the type SbxVARIANT
 375         if( pDef->GetType() == SbxVARIANT )
 376             pDef->SetType( SbxOBJECT );
 377         // if we scan something with point,
 378         // the type must be SbxOBJECT
 379         if( pDef->GetType() != SbxOBJECT && pDef->GetType() != SbxVARIANT )
 380         {
 381             // defer error until runtime if in vba mode
 382             if ( !pParser->IsVBASupportOn() )
 383             {
 384                 pParser->Error( SbERR_BAD_DECLARATION, aSym );
 385                 bError = true;
 386             }
 387         }
 388         if( !bError )
 389         {
 390             pNd->aVar.pNext = ObjTerm( *pDef );
 391         }
 392     }
 393
 394     pParser->UnlockColumn();
 395     return pNd;
 396 }
 397
 398 // construction of an object term. A term of this kind is part
 399 // of an expression that begins with an object variable.
 400
 401 SbiExprNode* SbiExpression::ObjTerm( SbiSymDef& rObj )
 402 {
 403     pParser->Next();
 404     SbiToken eTok = pParser->Next();
 405     if( eTok != SYMBOL && !pParser->IsKwd( eTok ) && !pParser->IsExtra( eTok ) )
 406     {
 407         // #66745 Some operators can also be allowed
 408         // as identifiers, important for StarOne
 409         if( eTok != MOD && eTok != NOT && eTok != AND && eTok != OR &&
 410             eTok != XOR && eTok != EQV && eTok != IMP && eTok != IS )
 411         {
 412             pParser->Error( SbERR_VAR_EXPECTED );
 413             bError = true;
 414         }
 415     }
 416
 417     if( bError )
 418     {
 419         return NULL;
 420     }
 421     OUString aSym( pParser->GetSym() );
 422     SbxDataType eType = pParser->GetType();
 423     SbiParameters* pPar = NULL;
 424     SbiExprListVector* pvMoreParLcl = NULL;
 425     eTok = pParser->Peek();
 426
 427     if( DoParametersFollow( pParser, eCurExpr, eTok ) )
 428     {
 429         bool bStandaloneExpression = false;
 430         pPar = new SbiParameters( pParser, bStandaloneExpression );
 431         bError = bError || !pPar->IsValid();
 432         eTok = pParser->Peek();
 433
 434         // i109624 check for additional sets of parameters
 435         while( eTok == LPAREN )
 436         {
 437             if( pvMoreParLcl == NULL )
 438             {
 439                 pvMoreParLcl = new SbiExprListVector();
 440             }
 441             SbiParameters* pAddPar = new SbiParameters( pParser );
 442             pvMoreParLcl->push_back( pAddPar );
 443             bError = bError || !pPar->IsValid();
 444             eTok = pParser->Peek();
 445         }
 446     }
 447     sal_Bool bObj = sal_Bool( ( eTok == DOT || eTok == EXCLAM ) && !pParser->WhiteSpace() );
 448     if( bObj )
 449     {
 450         if( eType == SbxVARIANT )
 451         {
 452             eType = SbxOBJECT;
 453         }
 454         else
 455         {
 456             // Name%. does really not work!
 457             pParser->Error( SbERR_BAD_DECLARATION, aSym );
 458             bError = true;
 459         }
 460     }
 461
 462     // an object's symbol pool is always PUBLIC
 463     SbiSymPool& rPool = rObj.GetPool();
 464     rPool.SetScope( SbPUBLIC );
 465     SbiSymDef* pDef = rPool.Find( aSym );
 466     if( !pDef )
 467     {
 468         pDef = AddSym( eTok, rPool, eCurExpr, aSym, eType, pPar );
 469         pDef->SetType( eType );
 470     }
 471
 472     SbiExprNode* pNd = new SbiExprNode( pParser, *pDef, eType );
 473     pNd->aVar.pPar = pPar;
 474     pNd->aVar.pvMorePar = pvMoreParLcl;
 475     if( bObj )
 476     {
 477         if( pDef->GetType() == SbxVARIANT )
 478         {
 479             pDef->SetType( SbxOBJECT );
 480         }
 481         if( pDef->GetType() != SbxOBJECT )
 482         {
 483             pParser->Error( SbERR_BAD_DECLARATION, aSym );
 484             bError = true;
 485         }
 486         if( !bError )
 487         {
 488             pNd->aVar.pNext = ObjTerm( *pDef );
 489             pNd->eType = eType;
 490         }
 491     }
 492     return pNd;
 493 }
 494
 495 // an operand can be:
 496 //      constant
 497 //      scalar variable
 498 //      structure elements
 499 //      array elements
 500 //      functions
 501 //      bracketed expressions
 502
 503 SbiExprNode* SbiExpression::Operand( bool bUsedForTypeOf )
 504 {
 505     SbiExprNode *pRes;
 506     SbiToken eTok;
 507
 508     // test operand:
 509     switch( eTok = pParser->Peek() )
 510     {
 511     case SYMBOL:
 512         pRes = Term();
 513         // process something like "IF Not r Is Nothing Then .."
 514         if( !bUsedForTypeOf && pParser->IsVBASupportOn() && pParser->Peek() == IS )
 515         {
 516             eTok = pParser->Next();
 517             pRes = new SbiExprNode( pParser, pRes, eTok, Like() );
 518         }
 519         break;
 520     case DOT:   // .with
 521         pRes = Term(); break;
 522     case NUMBER:
 523         pParser->Next();
 524         pRes = new SbiExprNode( pParser, pParser->GetDbl(), pParser->GetType() );
 525         break;
 526     case FIXSTRING:
 527         pParser->Next();
 528         pRes = new SbiExprNode( pParser, pParser->GetSym() ); break;
 529     case LPAREN:
 530         pParser->Next();
 531         if( nParenLevel == 0 && m_eMode == EXPRMODE_LPAREN_PENDING && pParser->Peek() == RPAREN )
 532         {
 533             m_eMode = EXPRMODE_EMPTY_PAREN;
 534             pRes = new SbiExprNode();   // Dummy node
 535             pParser->Next();
 536             break;
 537         }
 538         nParenLevel++;
 539         pRes = Boolean();
 540         if( pParser->Peek() != RPAREN )
 541         {
 542             // If there was a LPARAM, it does not belong to the expression
 543             if( nParenLevel == 1 && m_eMode == EXPRMODE_LPAREN_PENDING )
 544             {
 545                 m_eMode = EXPRMODE_LPAREN_NOT_NEEDED;
 546             }
 547             else
 548             {
 549                 pParser->Error( SbERR_BAD_BRACKETS );
 550             }
 551         }
 552         else
 553         {
 554             pParser->Next();
 555             if( nParenLevel == 1 && m_eMode == EXPRMODE_LPAREN_PENDING )
 556             {
 557                 SbiToken eTokAfterRParen = pParser->Peek();
 558                 if( eTokAfterRParen == EQ || eTokAfterRParen == LPAREN || eTokAfterRParen == DOT )
 559                 {
 560                     m_eMode = EXPRMODE_ARRAY_OR_OBJECT;
 561                 }
 562                 else
 563                 {
 564                     m_eMode = EXPRMODE_STANDARD;
 565                 }
 566             }
 567         }
 568         nParenLevel--;
 569         break;
 570     default:
 571         // keywords here are OK at the moment!
 572         if( pParser->IsKwd( eTok ) )
 573         {
 574             pRes = Term();
 575         }
 576         else
 577         {
 578             pParser->Next();
 579             pRes = new SbiExprNode( pParser, 1.0, SbxDOUBLE );
 580             pParser->Error( SbERR_UNEXPECTED, eTok );
 581         }
 582         break;
 583     }
 584     return pRes;
 585 }
 586
 587 SbiExprNode* SbiExpression::Unary()
 588 {
 589     SbiExprNode* pNd;
 590     SbiToken eTok = pParser->Peek();
 591     switch( eTok )
 592     {
 593         case MINUS:
 594             eTok = NEG;
 595             pParser->Next();
 596             pNd = new SbiExprNode( pParser, Unary(), eTok, NULL );
 597             break;
 598         case NOT:
 599             if( pParser->IsVBASupportOn() )
 600             {
 601                 pNd = Operand();
 602             }
 603             else
 604             {
 605                 pParser->Next();
 606                 pNd = new SbiExprNode( pParser, Unary(), eTok, NULL );
 607             }
 608             break;
 609         case PLUS:
 610             pParser->Next();
 611             pNd = Unary();
 612             break;
 613         case TYPEOF:
 614         {
 615             pParser->Next();
 616             bool bUsedForTypeOf = true;
 617             SbiExprNode* pObjNode = Operand( bUsedForTypeOf );
 618             pParser->TestToken( IS );
 619             OUString aDummy;
 620             SbiSymDef* pTypeDef = new SbiSymDef( aDummy );
 621             pParser->TypeDecl( *pTypeDef, sal_True );
 622             pNd = new SbiExprNode( pParser, pObjNode, pTypeDef->GetTypeId() );
 623             break;
 624         }
 625         case NEW:
 626         {
 627             pParser->Next();
 628             OUString aStr;
 629             SbiSymDef* pTypeDef = new SbiSymDef( aStr );
 630             pParser->TypeDecl( *pTypeDef, sal_True );
 631             pNd = new SbiExprNode( pParser, pTypeDef->GetTypeId() );
 632             break;
 633         }
 634         default:
 635             pNd = Operand();
 636     }
 637     return pNd;
 638 }
 639
 640 SbiExprNode* SbiExpression::Exp()
 641 {
 642     SbiExprNode* pNd = Unary();
 643     if( m_eMode != EXPRMODE_EMPTY_PAREN )
 644     {
 645         while( pParser->Peek() == EXPON )
 646         {
 647             SbiToken eTok = pParser->Next();
 648             pNd = new SbiExprNode( pParser, pNd, eTok, Unary() );
 649         }
 650     }
 651     return pNd;
 652 }
 653
 654 SbiExprNode* SbiExpression::MulDiv()
 655 {
 656     SbiExprNode* pNd = Exp();
 657     if( m_eMode != EXPRMODE_EMPTY_PAREN )
 658     {
 659         for( ;; )
 660         {
 661             SbiToken eTok = pParser->Peek();
 662             if( eTok != MUL && eTok != DIV )
 663             {
 664                 break;
 665             }
 666             eTok = pParser->Next();
 667             pNd = new SbiExprNode( pParser, pNd, eTok, Exp() );
 668         }
 669     }
 670     return pNd;
 671 }
 672
 673 SbiExprNode* SbiExpression::IntDiv()
 674 {
 675     SbiExprNode* pNd = MulDiv();
 676     if( m_eMode != EXPRMODE_EMPTY_PAREN )
 677     {
 678         while( pParser->Peek() == IDIV )
 679         {
 680             SbiToken eTok = pParser->Next();
 681             pNd = new SbiExprNode( pParser, pNd, eTok, MulDiv() );
 682         }
 683     }
 684     return pNd;
 685 }
 686
 687 SbiExprNode* SbiExpression::Mod()
 688 {
 689     SbiExprNode* pNd = IntDiv();
 690     if( m_eMode != EXPRMODE_EMPTY_PAREN )
 691     {
 692         while( pParser->Peek() == MOD )
 693         {
 694             SbiToken eTok = pParser->Next();
 695             pNd = new SbiExprNode( pParser, pNd, eTok, IntDiv() );
 696         }
 697     }
 698     return pNd;
 699 }
 700
 701 SbiExprNode* SbiExpression::AddSub()
 702 {
 703     SbiExprNode* pNd = Mod();
 704     if( m_eMode != EXPRMODE_EMPTY_PAREN )
 705     {
 706         for( ;; )
 707         {
 708             SbiToken eTok = pParser->Peek();
 709             if( eTok != PLUS && eTok != MINUS )
 710             {
 711                 break;
 712             }
 713             eTok = pParser->Next();
 714             pNd = new SbiExprNode( pParser, pNd, eTok, Mod() );
 715         }
 716     }
 717     return pNd;
 718 }
 719
 720 SbiExprNode* SbiExpression::Cat()
 721 {
 722     SbiExprNode* pNd = AddSub();
 723     if( m_eMode != EXPRMODE_EMPTY_PAREN )
 724     {
 725         for( ;; )
 726         {
 727             SbiToken eTok = pParser->Peek();
 728             if( eTok != CAT )
 729             {
 730                 break;
 731             }
 732             eTok = pParser->Next();
 733             pNd = new SbiExprNode( pParser, pNd, eTok, AddSub() );
 734         }
 735     }
 736     return pNd;
 737 }
 738
 739 SbiExprNode* SbiExpression::Comp()
 740 {
 741     SbiExprNode* pNd = Cat();
 742     if( m_eMode != EXPRMODE_EMPTY_PAREN )
 743     {
 744         short nCount = 0;
 745         for( ;; )
 746         {
 747             SbiToken eTok = pParser->Peek();
 748             if( m_eMode == EXPRMODE_ARRAY_OR_OBJECT )
 749             {
 750                 break;
 751             }
 752             if( eTok != EQ && eTok != NE && eTok != LT &&
 753                 eTok != GT && eTok != LE && eTok != GE )
 754             {
 755                 break;
 756             }
 757             eTok = pParser->Next();
 758             pNd = new SbiExprNode( pParser, pNd, eTok, Cat() );
 759             nCount++;
 760         }
 761     }
 762     return pNd;
 763 }
 764
 765
 766 SbiExprNode* SbiExpression::VBA_Not()
 767 {
 768     SbiExprNode* pNd = NULL;
 769
 770     SbiToken eTok = pParser->Peek();
 771     if( eTok == NOT )
 772     {
 773         pParser->Next();
 774         pNd = new SbiExprNode( pParser, VBA_Not(), eTok, NULL );
 775     }
 776     else
 777     {
 778         pNd = Comp();
 779     }
 780     return pNd;
 781 }
 782
 783 SbiExprNode* SbiExpression::Like()
 784 {
 785     SbiExprNode* pNd = pParser->IsVBASupportOn() ? VBA_Not() : Comp();
 786     if( m_eMode != EXPRMODE_EMPTY_PAREN )
 787     {
 788         short nCount = 0;
 789         while( pParser->Peek() == LIKE )
 790         {
 791             SbiToken eTok = pParser->Next();
 792             pNd = new SbiExprNode( pParser, pNd, eTok, Comp() ), nCount++;
 793         }
 794         // multiple operands in a row does not work
 795         if( nCount > 1 && !pParser->IsVBASupportOn() )
 796         {
 797             pParser->Error( SbERR_SYNTAX );
 798             bError = true;
 799         }
 800     }
 801     return pNd;
 802 }
 803
 804 SbiExprNode* SbiExpression::Boolean()
 805 {
 806     SbiExprNode* pNd = Like();
 807     if( m_eMode != EXPRMODE_EMPTY_PAREN )
 808     {
 809         for( ;; )
 810         {
 811             SbiToken eTok = pParser->Peek();
 812             if( (eTok != AND) && (eTok != OR) &&
 813                 (eTok != XOR) && (eTok != EQV) &&
 814                 (eTok != IMP) && (eTok != IS) )
 815             {
 816                 break;
 817             }
 818             eTok = pParser->Next();
 819             pNd = new SbiExprNode( pParser, pNd, eTok, Like() );
 820         }
 821     }
 822     return pNd;
 823 }
 824
 825 /***************************************************************************
 826 |*
 827 |*      SbiConstExpression
 828 |*
 829 ***************************************************************************/
 830
 831 SbiConstExpression::SbiConstExpression( SbiParser* p ) : SbiExpression( p )
 832 {
 833     if( pExpr->IsConstant() )
 834     {
 835         eType = pExpr->GetType();
 836         if( pExpr->IsNumber() )
 837         {
 838             nVal = pExpr->nVal;
 839         }
 840         else
 841         {
 842             nVal = 0;
 843             aVal = pExpr->aStrVal;
 844         }
 845     }
 846     else
 847     {
 848         // #40204 special treatment for sal_Bool-constants
 849         sal_Bool bIsBool = sal_False;
 850         if( pExpr->eNodeType == SbxVARVAL )
 851         {
 852             SbiSymDef* pVarDef = pExpr->GetVar();
 853
 854             sal_Bool bBoolVal = sal_False;
 855             if( pVarDef->GetName().equalsIgnoreAsciiCase( "true" ) )
 856             {
 857                 bIsBool = sal_True;
 858                 bBoolVal = sal_True;
 859             }
 860             else if( pVarDef->GetName().equalsIgnoreAsciiCase( "false" ) )
 861             //else if( pVarDef->GetName().ICompare( "false" ) == COMPARE_EQUAL )
 862             {
 863                 bIsBool = sal_True;
 864                 bBoolVal = sal_False;
 865             }
 866
 867             if( bIsBool )
 868             {
 869                 delete pExpr;
 870                 pExpr = new SbiExprNode( pParser, (bBoolVal ? SbxTRUE : SbxFALSE), SbxINTEGER );
 871                 eType = pExpr->GetType();
 872                 nVal = pExpr->nVal;
 873             }
 874         }
 875
 876         if( !bIsBool )
 877         {
 878             pParser->Error( SbERR_SYNTAX );
 879             eType = SbxDOUBLE;
 880             nVal = 0;
 881         }
 882     }
 883 }
 884
 885 short SbiConstExpression::GetShortValue()
 886 {
 887     if( eType == SbxSTRING )
 888     {
 889         SbxVariableRef refConv = new SbxVariable;
 890         refConv->PutString( aVal );
 891         return refConv->GetInteger();
 892     }
 893     else
 894     {
 895         double n = nVal;
 896         if( n > 0 )
 897         {
 898             n += .5;
 899         }
 900         else
 901         {
 902             n -= .5;
 903         }
 904         if( n > SbxMAXINT )
 905         {
 906             n = SbxMAXINT;
 907             pParser->Error( SbERR_OUT_OF_RANGE );
 908         }
 909         else if( n < SbxMININT )
 910         {
 911             n = SbxMININT;
 912             pParser->Error( SbERR_OUT_OF_RANGE );
 913         }
 914
 915         return (short) n;
 916     }
 917 }
 918
 919
 920 /***************************************************************************
 921 |*
 922 |*      SbiExprList
 923 |*
 924 ***************************************************************************/
 925
 926 SbiExprList::SbiExprList( SbiParser* p )
 927 {
 928     pParser = p;
 929     pFirst = NULL;
 930     nExpr  =
 931     nDim   = 0;
 932     bError = false;
 933     bBracket = false;
 934 }
 935
 936 SbiExprList::~SbiExprList()
 937 {
 938     SbiExpression* p = pFirst;
 939     while( p )
 940     {
 941         SbiExpression* q = p->pNext;
 942         delete p;
 943         p = q;
 944     }
 945 }
 946
 947
 948 SbiExpression* SbiExprList::Get( short n )
 949 {
 950     SbiExpression* p = pFirst;
 951     while( n-- && p )
 952     {
 953         p = p->pNext;
 954     }
 955     return p;
 956 }
 957
 958 void SbiExprList::addExpression( SbiExpression* pExpr )
 959 {
 960     if( !pFirst )
 961     {
 962         pFirst = pExpr;
 963         return;
 964     }
 965
 966     SbiExpression* p = pFirst;
 967     while( p->pNext )
 968     {
 969         p = p->pNext;
 970     }
 971     p->pNext = pExpr;
 972 }
 973
 974
 975 /***************************************************************************
 976 |*
 977 |*      SbiParameters
 978 |*
 979 ***************************************************************************/
 980
 981 // parsing constructor:
 982 // the parameter list is completely parsed
 983 // "procedurename()" is OK
 984 // it's a function without parameters then
 985 // i. e. you give an array as procedure parameter
 986
 987 // #i79918/#i80532: bConst has never been set to true
 988 // -> reused as bStandaloneExpression
 989 //SbiParameters::SbiParameters( SbiParser* p, sal_Bool bConst, sal_Bool bPar) :
 990 SbiParameters::SbiParameters( SbiParser* p, bool bStandaloneExpression, bool bPar) :
 991     SbiExprList( p )
 992 {
 993     if( !bPar )
 994     {
 995         return;
 996     }
 997     SbiExpression *pExpr;
 998     SbiToken eTok = pParser->Peek();
 999
1000     bool bAssumeExprLParenMode = false;
1001     bool bAssumeArrayMode = false;
1002     if( eTok == LPAREN )
1003     {
1004         if( bStandaloneExpression )
1005         {
1006             bAssumeExprLParenMode = true;
1007         }
1008         else
1009         {
1010             bBracket = true;
1011             pParser->Next();
1012             eTok = pParser->Peek();
1013         }
1014     }
1015
1016
1017     if( ( bBracket && eTok == RPAREN ) || pParser->IsEoln( eTok ) )
1018     {
1019         if( eTok == RPAREN )
1020         {
1021             pParser->Next();
1022         }
1023         return;
1024     }
1025     // read in parameter table and lay down in correct order!
1026     SbiExpression* pLast = NULL;
1027     OUString aName;
1028     while( !bError )
1029     {
1030         aName = "";
1031         // missing argument
1032         if( eTok == COMMA )
1033         {
1034             pExpr = new SbiExpression( pParser, 0, SbxEMPTY );
1035         }
1036         // named arguments: either .name= or name:=
1037         else
1038         {
1039             bool bByVal = false;
1040             if( eTok == BYVAL )
1041             {
1042                 bByVal = true;
1043                 pParser->Next();
1044                 eTok = pParser->Peek();
1045             }
1046
1047             if( bAssumeExprLParenMode )
1048             {
1049                 pExpr = new SbiExpression( pParser, SbSTDEXPR, EXPRMODE_LPAREN_PENDING );
1050                 bAssumeExprLParenMode = sal_False;
1051
1052                 SbiExprMode eModeAfter = pExpr->m_eMode;
1053                 if( eModeAfter == EXPRMODE_LPAREN_NOT_NEEDED )
1054                 {
1055                     bBracket = true;
1056                 }
1057                 else if( eModeAfter == EXPRMODE_ARRAY_OR_OBJECT )
1058                 {
1059                     // Expression "looks" like an array assignment
1060                     // a(...)[(...)] = ? or a(...).b(...)
1061                     // RPAREN is already parsed
1062                     bBracket = true;
1063                     bAssumeArrayMode = true;
1064                     eTok = NIL;
1065                 }
1066                 else if( eModeAfter == EXPRMODE_EMPTY_PAREN )
1067                 {
1068                     bBracket = true;
1069                     delete pExpr;
1070                     if( bByVal )
1071                     {
1072                         pParser->Error( SbERR_LVALUE_EXPECTED );
1073                     }
1074                     return;
1075                 }
1076             }
1077             else
1078             {
1079                 pExpr = new SbiExpression( pParser );
1080             }
1081             if( bByVal && pExpr->IsLvalue() )
1082             {
1083                 pExpr->SetByVal();
1084             }
1085             if( !bAssumeArrayMode )
1086             {
1087                 if( pParser->Peek() == ASSIGN )
1088                 {
1089                     // VBA mode: name:=
1090                     // SbiExpression::Term() has made as string out of it
1091                     aName = pExpr->GetString();
1092                     delete pExpr;
1093                     pParser->Next();
1094                     pExpr = new SbiExpression( pParser );
1095                 }
1096                 pExpr->GetName() = aName;
1097             }
1098         }
1099         pExpr->pNext = NULL;
1100         if( !pLast )
1101         {
1102             pFirst = pLast = pExpr;
1103         }
1104         else
1105         {
1106             pLast->pNext = pExpr, pLast = pExpr;
1107         }
1108         nExpr++;
1109         bError = bError || !pExpr->IsValid();
1110
1111         if( bAssumeArrayMode )
1112         {
1113             break;
1114         }
1115         // next element?
1116         eTok = pParser->Peek();
1117         if( eTok != COMMA )
1118         {
1119             if( ( bBracket && eTok == RPAREN ) || pParser->IsEoln( eTok ) )
1120             {
1121                 break;
1122             }
1123             pParser->Error( bBracket ? SbERR_BAD_BRACKETS : SbERR_EXPECTED, COMMA );
1124             bError = true;
1125         }
1126         else
1127         {
1128             pParser->Next();
1129             eTok = pParser->Peek();
1130             if( ( bBracket && eTok == RPAREN ) || pParser->IsEoln( eTok ) )
1131             {
1132                 break;
1133             }
1134         }
1135     }
1136     // closing bracket
1137     if( eTok == RPAREN )
1138     {
1139         pParser->Next();
1140         pParser->Peek();
1141         if( !bBracket )
1142         {
1143             pParser->Error( SbERR_BAD_BRACKETS );
1144             bError = true;
1145         }
1146     }
1147     nDim = nExpr;
1148 }
1149
1150 /***************************************************************************
1151 |*
1152 |*      SbiDimList
1153 |*
1154 ***************************************************************************/
1155
1156 // parsing constructor:
1157 // A list of array dimensions is parsed. The expressions are tested for being
1158 // numeric. The bCONST-Bit is reset when all expressions are Integer constants.
1159
1160 SbiDimList::SbiDimList( SbiParser* p ) : SbiExprList( p )
1161 {
1162     bConst = true;
1163
1164     if( pParser->Next() != LPAREN )
1165     {
1166         pParser->Error( SbERR_EXPECTED, LPAREN );
1167         bError = true; return;
1168     }
1169
1170     if( pParser->Peek() != RPAREN )
1171     {
1172         SbiExpression *pExpr1, *pExpr2, *pLast = NULL;
1173         SbiToken eTok;
1174         for( ;; )
1175         {
1176             pExpr1 = new SbiExpression( pParser );
1177             eTok = pParser->Next();
1178             if( eTok == TO )
1179             {
1180                 pExpr2 = new SbiExpression( pParser );
1181                 eTok = pParser->Next();
1182                 bConst = bConst && pExpr1->IsIntConstant() && pExpr2->IsIntConstant();
1183                 bError = bError || !pExpr1->IsValid() || !pExpr2->IsValid();
1184                 pExpr1->pNext = pExpr2;
1185                 if( !pLast )
1186                 {
1187                     pFirst = pExpr1;
1188                 }
1189                 else
1190                 {
1191                     pLast->pNext = pExpr1;
1192                 }
1193                 pLast = pExpr2;
1194                 nExpr += 2;
1195             }
1196             else
1197             {
1198                 pExpr1->SetBased();
1199                 pExpr1->pNext = NULL;
1200                 bConst = bConst && pExpr1->IsIntConstant();
1201                 bError = bError || !pExpr1->IsValid();
1202                 if( !pLast )
1203                 {
1204                     pFirst = pLast = pExpr1;
1205                 }
1206                 else
1207                 {
1208                     pLast->pNext = pExpr1, pLast = pExpr1;
1209                 }
1210                 nExpr++;
1211             }
1212             nDim++;
1213             if( eTok == RPAREN ) break;
1214             if( eTok != COMMA )
1215             {
1216                 pParser->Error( SbERR_BAD_BRACKETS );
1217                 pParser->Next();
1218                 break;
1219             }
1220         }
1221     }
1222     else pParser->Next();
1223 }
1224
1225 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */