basic/source/comp/loops.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 <parser.hxx>
  22 #include <memory>
  23
  24 #include <basic/sberrors.hxx>
  25 #include <basic/sbmod.hxx>
  26
  27 #include <rtl/ustrbuf.hxx>
  28
  29 static bool EndsIfBranch(SbiToken eTok)
  30 {
  31     return eTok == ELSEIF || eTok == ELSE || eTok == ENDIF;
  32 }
  33
  34 // Single-line IF and Multiline IF
  35
  36 void SbiParser::If()
  37 {
  38     sal_uInt32 nEndLbl;
  39     SbiToken eTok = NIL;
  40     // ignore end-tokens
  41     SbiExpression aCond( this );
  42     aCond.Gen();
  43     TestToken( THEN );
  44     if( IsEoln( Next() ) )
  45     {
  46         // At the end of each block a jump to ENDIF must be inserted,
  47         // so that the condition is not evaluated again at ELSEIF.
  48         // The table collects all jump points.
  49 #define JMP_TABLE_SIZE 100
  50         sal_uInt32 pnJmpToEndLbl[JMP_TABLE_SIZE];   // 100 ELSEIFs allowed
  51         sal_uInt16 iJmp = 0;                        // current table index
  52
  53         // multiline IF
  54         nEndLbl = aGen.Gen( SbiOpcode::JUMPF_, 0 );
  55         eTok = Peek();
  56         while (!EndsIfBranch(eTok) && !bAbort && Parse())
  57         {
  58             eTok = Peek();
  59             if( IsEof() )
  60             {
  61                 Error( ERRCODE_BASIC_BAD_BLOCK, IF ); bAbort = true; return;
  62             }
  63         }
  64         while( eTok == ELSEIF )
  65         {
  66             // jump to ENDIF in case of a successful IF/ELSEIF
  67             if( iJmp >= JMP_TABLE_SIZE )
  68             {
  69                 Error( ERRCODE_BASIC_PROG_TOO_LARGE );  bAbort = true;  return;
  70             }
  71             pnJmpToEndLbl[iJmp++] = aGen.Gen( SbiOpcode::JUMP_, 0 );
  72
  73             Next();
  74             aGen.BackChain( nEndLbl );
  75
  76             aGen.Statement();
  77             auto pCond = std::make_unique<SbiExpression>( this );
  78             pCond->Gen();
  79             nEndLbl = aGen.Gen( SbiOpcode::JUMPF_, 0 );
  80             pCond.reset();
  81             TestToken( THEN );
  82             eTok = Peek();
  83             while (!EndsIfBranch(eTok) && !bAbort && Parse())
  84             {
  85                 eTok = Peek();
  86                 if( IsEof() )
  87                 {
  88                     Error( ERRCODE_BASIC_BAD_BLOCK, ELSEIF );  bAbort = true; return;
  89                 }
  90             }
  91         }
  92         if( eTok == ELSE )
  93         {
  94             Next();
  95             sal_uInt32 nElseLbl = nEndLbl;
  96             nEndLbl = aGen.Gen( SbiOpcode::JUMP_, 0 );
  97             aGen.BackChain( nElseLbl );
  98
  99             aGen.Statement();
 100             StmntBlock( ENDIF );
 101         }
 102         else if( eTok == ENDIF )
 103             Next();
 104
 105
 106         while( iJmp > 0 )
 107         {
 108             iJmp--;
 109             aGen.BackChain( pnJmpToEndLbl[iJmp] );
 110         }
 111     }
 112     else
 113     {
 114         // single line IF
 115         bSingleLineIf = true;
 116         nEndLbl = aGen.Gen( SbiOpcode::JUMPF_, 0 );
 117         Push( eCurTok );
 118         // tdf#128263: update push positions to correctly restore in Next()
 119         nPLine = nLine;
 120         nPCol1 = nCol1;
 121         nPCol2 = nCol2;
 122
 123         while( !bAbort )
 124         {
 125             if( !Parse() ) break;
 126             eTok = Peek();
 127             if( eTok == ELSE || eTok == EOLN || eTok == REM )
 128                 break;
 129         }
 130         if( eTok == ELSE )
 131         {
 132             Next();
 133             sal_uInt32 nElseLbl = nEndLbl;
 134             nEndLbl = aGen.Gen( SbiOpcode::JUMP_, 0 );
 135             aGen.BackChain( nElseLbl );
 136             while( !bAbort )
 137             {
 138                 if( !Parse() ) break;
 139                 eTok = Peek();
 140                 if( eTok == EOLN || eTok == REM )
 141                     break;
 142             }
 143         }
 144         bSingleLineIf = false;
 145     }
 146     aGen.BackChain( nEndLbl );
 147 }
 148
 149 // ELSE/ELSEIF/ENDIF without IF
 150
 151 void SbiParser::NoIf()
 152 {
 153     Error( ERRCODE_BASIC_NO_IF );
 154     StmntBlock( ENDIF );
 155 }
 156
 157 // DO WHILE...LOOP
 158 // DO ... LOOP WHILE
 159
 160 void SbiParser::DoLoop()
 161 {
 162     sal_uInt32 nStartLbl = aGen.GetPC();
 163     OpenBlock( DO );
 164     SbiToken eTok = Next();
 165     if( IsEoln( eTok ) )
 166     {
 167         // DO ... LOOP [WHILE|UNTIL expr]
 168         StmntBlock( LOOP );
 169         eTok = Next();
 170         if( eTok == UNTIL || eTok == WHILE )
 171         {
 172             SbiExpression aExpr( this );
 173             aExpr.Gen();
 174             aGen.Gen( eTok == UNTIL ? SbiOpcode::JUMPF_ : SbiOpcode::JUMPT_, nStartLbl );
 175         } else
 176             if (eTok == EOLN || eTok == REM)
 177                 aGen.Gen (SbiOpcode::JUMP_, nStartLbl);
 178             else
 179                 Error( ERRCODE_BASIC_EXPECTED, WHILE );
 180     }
 181     else
 182     {
 183         // DO [WHILE|UNTIL expr] ... LOOP
 184         if( eTok == UNTIL || eTok == WHILE )
 185         {
 186             SbiExpression aCond( this );
 187             aCond.Gen();
 188         }
 189         sal_uInt32 nEndLbl = aGen.Gen( eTok == UNTIL ? SbiOpcode::JUMPT_ : SbiOpcode::JUMPF_, 0 );
 190         StmntBlock( LOOP );
 191         TestEoln();
 192         aGen.Gen( SbiOpcode::JUMP_, nStartLbl );
 193         aGen.BackChain( nEndLbl );
 194     }
 195     CloseBlock();
 196 }
 197
 198 // WHILE ... WEND
 199
 200 void SbiParser::While()
 201 {
 202     SbiExpression aCond( this );
 203     sal_uInt32 nStartLbl = aGen.GetPC();
 204     aCond.Gen();
 205     sal_uInt32 nEndLbl = aGen.Gen( SbiOpcode::JUMPF_, 0 );
 206     StmntBlock( WEND );
 207     aGen.Gen( SbiOpcode::JUMP_, nStartLbl );
 208     aGen.BackChain( nEndLbl );
 209 }
 210
 211 // FOR var = expr TO expr STEP
 212
 213 void SbiParser::For()
 214 {
 215     bool bForEach = ( Peek() == EACH );
 216     if( bForEach )
 217         Next();
 218     SbiExpression aLvalue( this, SbOPERAND );
 219     if (!aLvalue.IsVariable())
 220     {
 221         bAbort = true;
 222         return; // the error is already set in SbiExpression ctor
 223     }
 224     aLvalue.Gen();      // variable on the Stack
 225
 226     if( bForEach )
 227     {
 228         TestToken( IN_ );
 229         SbiExpression aCollExpr( this, SbOPERAND );
 230         aCollExpr.Gen();    // Collection var to for stack
 231         TestEoln();
 232         aGen.Gen( SbiOpcode::INITFOREACH_ );
 233     }
 234     else
 235     {
 236         TestToken( EQ );
 237         SbiExpression aStartExpr( this );
 238         aStartExpr.Gen();
 239         TestToken( TO );
 240         SbiExpression aStopExpr( this );
 241         aStopExpr.Gen();
 242         if( Peek() == STEP )
 243         {
 244             Next();
 245             SbiExpression aStepExpr( this );
 246             aStepExpr.Gen();
 247         }
 248         else
 249         {
 250             SbiExpression aOne( this, 1, SbxINTEGER );
 251             aOne.Gen();
 252         }
 253         TestEoln();
 254         // The stack has all 4 elements now: variable, start, end, increment
 255         // bind start value
 256         aGen.Gen( SbiOpcode::INITFOR_ );
 257     }
 258
 259     sal_uInt32 nLoop = aGen.GetPC();
 260     // do tests, maybe free the stack
 261     sal_uInt32 nEndTarget = aGen.Gen( SbiOpcode::TESTFOR_, 0 );
 262     OpenBlock( FOR );
 263     StmntBlock( NEXT );
 264     aGen.Gen( SbiOpcode::NEXT_ );
 265     aGen.Gen( SbiOpcode::JUMP_, nLoop );
 266     // are there variables after NEXT?
 267     if( Peek() == SYMBOL )
 268     {
 269         SbiExpression aVar( this, SbOPERAND );
 270         if( aVar.GetRealVar() != aLvalue.GetRealVar() )
 271             Error( ERRCODE_BASIC_EXPECTED, aLvalue.GetRealVar()->GetName() );
 272     }
 273     aGen.BackChain( nEndTarget );
 274     CloseBlock();
 275 }
 276
 277 // WITH .. END WITH
 278
 279 namespace
 280 {
 281 // Generate a '{_with_library.module_offset} = rVar'
 282 // Use the {_with_library.module_offset} in OpenBlock
 283 // The name of the variable can't be used by user: a name like [{_with_library.module_offset}]
 284 // is valid, but not without the square brackets
 285 struct WithLocalVar
 286 {
 287     WithLocalVar(SbiParser& rParser, SbiExpression& rVar)
 288         : m_rParser(rParser)
 289         , m_aWithParent(createLocalVar(rParser))
 290     {
 291         // Assignment
 292         m_aWithParent.Gen();
 293         rVar.Gen();
 294         m_rParser.aGen.Gen(SbiOpcode::PUTC_);
 295     }
 296
 297     ~WithLocalVar()
 298     {
 299         // {_with_library.module_offset} = Nothing
 300         m_aWithParent.Gen();
 301         m_rParser.aGen.Gen(SbiOpcode::RTL_, m_rParser.aGblStrings.Add(u"Nothing"_ustr), SbxOBJECT);
 302         m_rParser.aGen.Gen(SbiOpcode::PUTC_);
 303     }
 304
 305     static SbiExpression createLocalVar(SbiParser& rParser)
 306     {
 307         // Create the unique name
 308         OUStringBuffer moduleName(rParser.aGen.GetModule().GetName());
 309         for (auto parent = rParser.aGen.GetModule().GetParent(); parent;
 310              parent = parent->GetParent())
 311             moduleName.insert(0, parent->GetName() + ".");
 312
 313         OUString uniqueName
 314             = "{_with_" + moduleName + "_" + OUString::number(rParser.aGen.GetOffset()) + "}";
 315         while (rParser.pPool->Find(uniqueName) != nullptr)
 316         {
 317             static sal_Int64 unique_suffix;
 318             uniqueName = "{_with_" + moduleName + "_" + OUString::number(rParser.aGen.GetOffset())
 319                          + "_" + OUString::number(unique_suffix++) + "}";
 320         }
 321         SbiSymDef* pWithParentDef = new SbiSymDef(uniqueName);
 322         pWithParentDef->SetType(SbxOBJECT);
 323         rParser.pPool->Add(pWithParentDef);
 324
 325         // DIM local variable: work with Option Explicit
 326         rParser.aGen.Gen(SbiOpcode::LOCAL_, pWithParentDef->GetId(), pWithParentDef->GetType());
 327
 328         return SbiExpression(&rParser, *pWithParentDef);
 329     }
 330
 331     SbiParser& m_rParser;
 332     SbiExpression m_aWithParent;
 333 };
 334 }
 335
 336 void SbiParser::With()
 337 {
 338     SbiExpression aVar( this, SbOPERAND );
 339
 340     SbiExprNode *pNode = aVar.GetExprNode()->GetRealNode();
 341     if (!pNode)
 342         return;
 343     SbiSymDef* pDef = pNode->GetVar();
 344     // Variant, from 27.6.1997, #41090: empty -> must be Object
 345     if( pDef->GetType() == SbxVARIANT || pDef->GetType() == SbxEMPTY )
 346         pDef->SetType( SbxOBJECT );
 347     else if( pDef->GetType() != SbxOBJECT )
 348         Error( ERRCODE_BASIC_NEEDS_OBJECT );
 349
 350     pNode->SetType( SbxOBJECT );
 351
 352     std::optional<WithLocalVar> oLocalVar;
 353     if (pDef->GetProcDef())
 354         oLocalVar.emplace(*this, aVar);
 355
 356     OpenBlock(NIL, oLocalVar ? oLocalVar->m_aWithParent.GetExprNode() : aVar.GetExprNode());
 357     StmntBlock( ENDWITH );
 358     CloseBlock();
 359 }
 360
 361 // LOOP/NEXT/WEND without construct
 362
 363 void SbiParser::BadBlock()
 364 {
 365     if( eEndTok )
 366         Error( ERRCODE_BASIC_BAD_BLOCK, eEndTok );
 367     else
 368         Error( ERRCODE_BASIC_BAD_BLOCK, u"Loop/Next/Wend"_ustr );
 369 }
 370
 371 // On expr Goto/Gosub n,n,n...
 372
 373 void SbiParser::OnGoto()
 374 {
 375     SbiExpression aCond( this );
 376     aCond.Gen();
 377     sal_uInt32 nLabelsTarget = aGen.Gen( SbiOpcode::ONJUMP_, 0 );
 378     SbiToken eTok = Next();
 379     if( eTok != GOTO && eTok != GOSUB )
 380     {
 381         Error( ERRCODE_BASIC_EXPECTED, u"GoTo/GoSub"_ustr );
 382         eTok = GOTO;
 383     }
 384
 385     sal_uInt32 nLbl = 0;
 386     do
 387     {
 388         Next(); // get label
 389         if( MayBeLabel() )
 390         {
 391             sal_uInt32 nOff = pProc->GetLabels().Reference( aSym );
 392             aGen.Gen( SbiOpcode::JUMP_, nOff );
 393             nLbl++;
 394         }
 395         else Error( ERRCODE_BASIC_LABEL_EXPECTED );
 396     }
 397     while( !bAbort && TestComma() );
 398     if( eTok == GOSUB )
 399         nLbl |= 0x8000;
 400     aGen.Patch( nLabelsTarget, nLbl );
 401 }
 402
 403 // GOTO/GOSUB
 404
 405 void SbiParser::Goto()
 406 {
 407     SbiOpcode eOp = eCurTok == GOTO ? SbiOpcode::JUMP_ : SbiOpcode::GOSUB_;
 408     Next();
 409     if( MayBeLabel() )
 410     {
 411         sal_uInt32 nOff = pProc->GetLabels().Reference( aSym );
 412         aGen.Gen( eOp, nOff );
 413     }
 414     else Error( ERRCODE_BASIC_LABEL_EXPECTED );
 415 }
 416
 417 // RETURN [label]
 418
 419 void SbiParser::Return()
 420 {
 421     Next();
 422     if( MayBeLabel() )
 423     {
 424         sal_uInt32 nOff = pProc->GetLabels().Reference( aSym );
 425         aGen.Gen( SbiOpcode::RETURN_, nOff );
 426     }
 427     else aGen.Gen( SbiOpcode::RETURN_, 0 );
 428 }
 429
 430 // SELECT CASE
 431
 432 void SbiParser::Select()
 433 {
 434     TestToken( CASE );
 435     SbiExpression aCase( this );
 436     SbiToken eTok = NIL;
 437     aCase.Gen();
 438     aGen.Gen( SbiOpcode::CASE_ );
 439     TestEoln();
 440     sal_uInt32 nNextTarget = 0;
 441     sal_uInt32 nDoneTarget = 0;
 442     bool bElse = false;
 443
 444     while( !bAbort )
 445     {
 446         eTok = Next();
 447         if( eTok == CASE )
 448         {
 449             if( nNextTarget )
 450             {
 451                 aGen.BackChain( nNextTarget );
 452                 nNextTarget = 0;
 453             }
 454             aGen.Statement();
 455
 456             bool bDone = false;
 457             sal_uInt32 nTrueTarget = 0;
 458             if( Peek() == ELSE )
 459             {
 460                 // CASE ELSE
 461                 Next();
 462                 bElse = true;
 463             }
 464             else while( !bDone )
 465             {
 466                 if( bElse )
 467                     Error( ERRCODE_BASIC_SYNTAX );
 468                 SbiToken eTok2 = Peek();
 469                 if( eTok2 == IS || ( eTok2 >= EQ && eTok2 <= GE ) )
 470                 {   // CASE [IS] operator expr
 471                     if( eTok2 == IS )
 472                         Next();
 473                     eTok2 = Peek();
 474                     if( eTok2 < EQ || eTok2 > GE )
 475                         Error( ERRCODE_BASIC_SYNTAX );
 476                     else Next();
 477                     SbiExpression aCompare( this );
 478                     aCompare.Gen();
 479                     nTrueTarget = aGen.Gen(
 480                         SbiOpcode::CASEIS_, nTrueTarget,
 481                         sal::static_int_cast< sal_uInt16 >(
 482                             SbxEQ + ( eTok2 - EQ ) ) );
 483                 }
 484                 else
 485                 {   // CASE expr | expr TO expr
 486                     SbiExpression aCase1( this );
 487                     aCase1.Gen();
 488                     if( Peek() == TO )
 489                     {
 490                         // CASE a TO b
 491                         Next();
 492                         SbiExpression aCase2( this );
 493                         aCase2.Gen();
 494                         nTrueTarget = aGen.Gen( SbiOpcode::CASETO_, nTrueTarget );
 495                     }
 496                     else
 497                         // CASE a
 498                         nTrueTarget = aGen.Gen( SbiOpcode::CASEIS_, nTrueTarget, SbxEQ );
 499
 500                 }
 501                 if( Peek() == COMMA ) Next();
 502                 else
 503                 {
 504                     TestEoln();
 505                     bDone = true;
 506                 }
 507             }
 508
 509             if( !bElse )
 510             {
 511                 nNextTarget = aGen.Gen( SbiOpcode::JUMP_, nNextTarget );
 512                 aGen.BackChain( nTrueTarget );
 513             }
 514             // build the statement body
 515             while( !bAbort )
 516             {
 517                 eTok = Peek();
 518                 if( eTok == CASE || eTok == ENDSELECT )
 519                     break;
 520                 if( !Parse() ) goto done;
 521                 eTok = Peek();
 522                 if( eTok == CASE || eTok == ENDSELECT )
 523                     break;
 524             }
 525             if( !bElse )
 526                 nDoneTarget = aGen.Gen( SbiOpcode::JUMP_, nDoneTarget );
 527         }
 528         else if( !IsEoln( eTok ) )
 529             break;
 530     }
 531 done:
 532     if( eTok != ENDSELECT )
 533         Error( ERRCODE_BASIC_EXPECTED, ENDSELECT );
 534     if( nNextTarget )
 535         aGen.BackChain( nNextTarget );
 536     aGen.BackChain( nDoneTarget );
 537     aGen.Gen( SbiOpcode::ENDCASE_ );
 538 }
 539
 540 // ON Error/Variable
 541
 542 void SbiParser::On()
 543 {
 544     SbiToken eTok = Peek();
 545     OUString aString = SbiTokenizer::Symbol(eTok);
 546     if (aString.equalsIgnoreAsciiCase("ERROR"))
 547     {
 548         eTok = ERROR_; // Error comes as SYMBOL
 549     }
 550     if( eTok != ERROR_ && eTok != LOCAL )
 551     {
 552         OnGoto();
 553     }
 554     else
 555     {
 556         if( eTok == LOCAL )
 557         {
 558             Next();
 559         }
 560         Next (); // no more TestToken, as there'd be an error otherwise
 561
 562         Next(); // get token after error
 563         if( eCurTok == GOTO )
 564         {
 565             // ON ERROR GOTO label|0
 566             Next();
 567             bool bError_ = false;
 568             if( MayBeLabel() )
 569             {
 570                 if( eCurTok == NUMBER && !nVal )
 571                 {
 572                     aGen.Gen( SbiOpcode::STDERROR_ );
 573                 }
 574                 else
 575                 {
 576                     sal_uInt32 nOff = pProc->GetLabels().Reference( aSym );
 577                     aGen.Gen( SbiOpcode::ERRHDL_, nOff );
 578                 }
 579             }
 580             else if( eCurTok == MINUS )
 581             {
 582                 Next();
 583                 if( eCurTok == NUMBER && nVal == 1 )
 584                 {
 585                     aGen.Gen( SbiOpcode::STDERROR_ );
 586                 }
 587                 else
 588                 {
 589                     bError_ = true;
 590                 }
 591             }
 592             if( bError_ )
 593             {
 594                 Error( ERRCODE_BASIC_LABEL_EXPECTED );
 595             }
 596         }
 597         else if( eCurTok == RESUME )
 598         {
 599             TestToken( NEXT );
 600             aGen.Gen( SbiOpcode::NOERROR_ );
 601         }
 602         else Error( ERRCODE_BASIC_EXPECTED, u"GoTo/Resume"_ustr );
 603     }
 604 }
 605
 606 // RESUME [0]|NEXT|label
 607
 608 void SbiParser::Resume()
 609 {
 610     sal_uInt32 nLbl;
 611
 612     switch( Next() )
 613     {
 614         case EOS:
 615         case EOLN:
 616             aGen.Gen( SbiOpcode::RESUME_, 0 );
 617             break;
 618         case NEXT:
 619             aGen.Gen( SbiOpcode::RESUME_, 1 );
 620             Next();
 621             break;
 622         case NUMBER:
 623             if( !nVal )
 624             {
 625                 aGen.Gen( SbiOpcode::RESUME_, 0 );
 626                 break;
 627             }
 628             [[fallthrough]];
 629         case SYMBOL:
 630             if( MayBeLabel() )
 631             {
 632                 nLbl = pProc->GetLabels().Reference( aSym );
 633                 aGen.Gen( SbiOpcode::RESUME_, nLbl );
 634                 Next();
 635                 break;
 636             }
 637             [[fallthrough]];
 638         default:
 639             Error( ERRCODE_BASIC_LABEL_EXPECTED );
 640     }
 641 }
 642
 643 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */