basic/source/comp/loops.cxx

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2008 by Sun Microsystems, Inc.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * $RCSfile: loops.cxx,v $
  10  * $Revision: 1.13 $
  11  *
  12  * This file is part of OpenOffice.org.
  13  *
  14  * OpenOffice.org is free software: you can redistribute it and/or modify
  15  * it under the terms of the GNU Lesser General Public License version 3
  16  * only, as published by the Free Software Foundation.
  17  *
  18  * OpenOffice.org is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU Lesser General Public License version 3 for more details
  22  * (a copy is included in the LICENSE file that accompanied this code).
  23  *
  24  * You should have received a copy of the GNU Lesser General Public License
  25  * version 3 along with OpenOffice.org.  If not, see
  26  * <http://www.openoffice.org/license.html>
  27  * for a copy of the LGPLv3 License.
  28  *
  29  ************************************************************************/
  30
  31 // MARKER(update_precomp.py): autogen include statement, do not remove
  32 #include "precompiled_basic.hxx"
  33
  34 #include "sbcomp.hxx"
  35
  36 // Single-line IF und Multiline IF
  37
  38 void SbiParser::If()
  39 {
  40     UINT32 nEndLbl;
  41     SbiToken eTok = NIL;
  42     // Ende-Tokens ignorieren:
  43     SbiExpression aCond( this );
  44     aCond.Gen();
  45     TestToken( THEN );
  46     if( IsEoln( Next() ) )
  47     {
  48         // AB 13.5.1996: #27720# Am Ende jeden Blocks muss ein Jump zu ENDIF
  49         // eingefuegt werden, damit bei ELSEIF nicht erneut die Bedingung
  50         // ausgewertet wird. Die Tabelle nimmt alle Absprungstellen auf.
  51 #define JMP_TABLE_SIZE 100
  52         UINT32 pnJmpToEndLbl[JMP_TABLE_SIZE];   // 100 ELSEIFs zulaessig
  53         USHORT iJmp = 0;                                                // aktueller Tabellen-Index
  54
  55         // multiline IF
  56         nEndLbl = aGen.Gen( _JUMPF, 0 );
  57         eTok = Peek();
  58         while( !( eTok == ELSEIF || eTok == ELSE || eTok == ENDIF ) &&
  59                 !bAbort && Parse() )
  60         {
  61             eTok = Peek();
  62             if( IsEof() )
  63             {
  64                 Error( SbERR_BAD_BLOCK, IF ); bAbort = TRUE; return;
  65             }
  66         }
  67         // ELSEIF?
  68         while( eTok == ELSEIF )
  69         {
  70             // #27720# Bei erfolgreichem IF/ELSEIF auf ENDIF springen
  71             if( iJmp >= JMP_TABLE_SIZE )
  72             {
  73                 Error( SbERR_PROG_TOO_LARGE );  bAbort = TRUE;  return;
  74             }
  75             pnJmpToEndLbl[iJmp++] = aGen.Gen( _JUMP, 0 );
  76
  77             Next();
  78             aGen.BackChain( nEndLbl );
  79
  80             aGen.Statement();
  81             SbiExpression* pCond = new SbiExpression( this );
  82             pCond->Gen();
  83             nEndLbl = aGen.Gen( _JUMPF, 0 );
  84             delete pCond;
  85             TestToken( THEN );
  86             eTok = Peek();
  87             while( !( eTok == ELSEIF || eTok == ELSE || eTok == ENDIF ) &&
  88                     !bAbort && Parse() )
  89             {
  90                 eTok = Peek();
  91                 if( IsEof() )
  92                 {
  93                     Error( SbERR_BAD_BLOCK, ELSEIF );  bAbort = TRUE; return;
  94                 }
  95             }
  96         }
  97         if( eTok == ELSE )
  98         {
  99             Next();
 100             UINT32 nElseLbl = nEndLbl;
 101             nEndLbl = aGen.Gen( _JUMP, 0 );
 102             aGen.BackChain( nElseLbl );
 103
 104             aGen.Statement();
 105             StmntBlock( ENDIF );
 106         }
 107         else if( eTok == ENDIF )
 108             Next();
 109
 110         // #27720# Jmp-Tabelle abarbeiten
 111         while( iJmp > 0 )
 112         {
 113             iJmp--;
 114             aGen.BackChain( pnJmpToEndLbl[iJmp] );
 115         }
 116     }
 117     else
 118     {
 119         // single line IF
 120         bSingleLineIf = TRUE;
 121         nEndLbl = aGen.Gen( _JUMPF, 0 );
 122         Push( eCurTok );
 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             UINT32 nElseLbl = nEndLbl;
 134             nEndLbl = aGen.Gen( _JUMP, 0 );
 135             aGen.BackChain( nElseLbl );
 136             while( !bAbort )
 137             {
 138                 if( !Parse() ) break;
 139                 eTok = Peek();
 140                 if( eTok == EOLN )
 141                     break;
 142             }
 143         }
 144         bSingleLineIf = FALSE;
 145     }
 146     aGen.BackChain( nEndLbl );
 147 }
 148
 149 // ELSE/ELSEIF/ENDIF ohne IF
 150
 151 void SbiParser::NoIf()
 152 {
 153     Error( SbERR_NO_IF );
 154     StmntBlock( ENDIF );
 155 }
 156
 157 // DO WHILE...LOOP
 158 // DO ... LOOP WHILE
 159
 160 void SbiParser::DoLoop()
 161 {
 162     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 ? _JUMPF : _JUMPT, nStartLbl );
 175         } else
 176             if (eTok == EOLN || eTok == REM)
 177                 aGen.Gen (_JUMP, nStartLbl);
 178             else
 179                 Error( SbERR_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         UINT32 nEndLbl = aGen.Gen( eTok == UNTIL ? _JUMPT : _JUMPF, 0 );
 190         StmntBlock( LOOP );
 191         TestEoln();
 192         aGen.Gen( _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     UINT32 nStartLbl = aGen.GetPC();
 204     aCond.Gen();
 205     UINT32 nEndLbl = aGen.Gen( _JUMPF, 0 );
 206     StmntBlock( WEND );
 207     aGen.Gen( _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     aLvalue.Gen();              // Variable auf dem Stack
 220
 221     if( bForEach )
 222     {
 223         TestToken( _IN_ );
 224         SbiExpression aCollExpr( this, SbOPERAND );
 225         aCollExpr.Gen();        // Colletion var to for stack
 226         TestEoln();
 227         aGen.Gen( _INITFOREACH );
 228     }
 229     else
 230     {
 231         TestToken( EQ );
 232         SbiExpression aStartExpr( this );
 233         aStartExpr.Gen();       // Startausdruck auf dem Stack
 234         TestToken( TO );
 235         SbiExpression aStopExpr( this );
 236         aStopExpr.Gen();        // Endausdruck auf dem Stack
 237         if( Peek() == STEP )
 238         {
 239             Next();
 240             SbiExpression aStepExpr( this );
 241             aStepExpr.Gen();
 242         }
 243         else
 244         {
 245             SbiExpression aOne( this, 1, SbxINTEGER );
 246             aOne.Gen();
 247         }
 248         TestEoln();
 249         // Der Stack hat jetzt 4 Elemente: Variable, Start, Ende, Inkrement
 250         // Startwert binden
 251         aGen.Gen( _INITFOR );
 252     }
 253
 254     UINT32 nLoop = aGen.GetPC();
 255     // Test durchfuehren, evtl. Stack freigeben
 256     UINT32 nEndTarget = aGen.Gen( _TESTFOR, 0 );
 257     OpenBlock( FOR );
 258     StmntBlock( NEXT );
 259     aGen.Gen( _NEXT );
 260     aGen.Gen( _JUMP, nLoop );
 261     // Kommen Variable nach NEXT?
 262     if( Peek() == SYMBOL )
 263     {
 264         SbiExpression aVar( this, SbOPERAND );
 265         if( aVar.GetRealVar() != aLvalue.GetRealVar() )
 266             Error( SbERR_EXPECTED, aLvalue.GetRealVar()->GetName() );
 267     }
 268     aGen.BackChain( nEndTarget );
 269     CloseBlock();
 270 }
 271
 272 // WITH .. END WITH
 273
 274 void SbiParser::With()
 275 {
 276     SbiExpression aVar( this, SbOPERAND );
 277
 278     // Letzten Knoten in der Objekt-Kette ueberpruefen
 279     SbiExprNode *pNode = aVar.GetExprNode()->GetRealNode();
 280     SbiSymDef* pDef = pNode->GetVar();
 281     // Variant, AB 27.6.1997, #41090: bzw. empty -> muß Object sein
 282     if( pDef->GetType() == SbxVARIANT || pDef->GetType() == SbxEMPTY )
 283         pDef->SetType( SbxOBJECT );
 284     else if( pDef->GetType() != SbxOBJECT )
 285         Error( SbERR_NEEDS_OBJECT );
 286
 287     // Knoten auch auf SbxOBJECT setzen, damit spaeter Gen() klappt
 288     pNode->SetType( SbxOBJECT );
 289
 290     OpenBlock( NIL, aVar.GetExprNode() );
 291     StmntBlock( ENDWITH );
 292     CloseBlock();
 293 }
 294
 295 // LOOP/NEXT/WEND ohne Konstrukt
 296
 297 void SbiParser::BadBlock()
 298 {
 299     if( eEndTok )
 300         Error( SbERR_BAD_BLOCK, eEndTok );
 301     else
 302         Error( SbERR_BAD_BLOCK, "Loop/Next/Wend" );
 303 }
 304
 305 // On expr Goto/Gosub n,n,n...
 306
 307 void SbiParser::OnGoto()
 308 {
 309     SbiExpression aCond( this );
 310     aCond.Gen();
 311     UINT32 nLabelsTarget = aGen.Gen( _ONJUMP, 0 );
 312     SbiToken eTok = Next();
 313     if( eTok != GOTO && eTok != GOSUB )
 314     {
 315         Error( SbERR_EXPECTED, "GoTo/GoSub" );
 316         eTok = GOTO;
 317     }
 318     // Label-Tabelle einlesen:
 319     UINT32 nLbl = 0;
 320     do
 321     {
 322         SbiToken eTok2 = NIL;
 323         eTok2 = Next(); // Label holen
 324         if( MayBeLabel() )
 325         {
 326             UINT32 nOff = pProc->GetLabels().Reference( aSym );
 327             aGen.Gen( _JUMP, nOff );
 328             nLbl++;
 329         }
 330         else Error( SbERR_LABEL_EXPECTED );
 331     }
 332     while( !bAbort && TestComma() );
 333     if( eTok == GOSUB )
 334         nLbl |= 0x8000;
 335     aGen.Patch( nLabelsTarget, nLbl );
 336 }
 337
 338 // GOTO/GOSUB
 339
 340 void SbiParser::Goto()
 341 {
 342     SbiOpcode eOp = eCurTok == GOTO ? _JUMP : _GOSUB;
 343     Next();
 344     if( MayBeLabel() )
 345     {
 346         UINT32 nOff = pProc->GetLabels().Reference( aSym );
 347         aGen.Gen( eOp, nOff );
 348     }
 349     else Error( SbERR_LABEL_EXPECTED );
 350 }
 351
 352 // RETURN [label]
 353
 354 void SbiParser::Return()
 355 {
 356     Next();
 357     if( MayBeLabel() )
 358     {
 359         UINT32 nOff = pProc->GetLabels().Reference( aSym );
 360         aGen.Gen( _RETURN, nOff );
 361     }
 362     else aGen.Gen( _RETURN, 0 );
 363 }
 364
 365 // SELECT CASE
 366
 367 void SbiParser::Select()
 368 {
 369     TestToken( CASE );
 370     SbiExpression aCase( this );
 371     SbiToken eTok = NIL;
 372     aCase.Gen();
 373     aGen.Gen( _CASE );
 374     TestEoln();
 375     UINT32 nNextTarget = 0;
 376     UINT32 nDoneTarget = 0;
 377     BOOL bElse = FALSE;
 378     // Die Cases einlesen:
 379     while( !bAbort )
 380     {
 381         eTok = Next();
 382         if( eTok == CASE )
 383         {
 384             if( nNextTarget )
 385                 aGen.BackChain( nNextTarget ), nNextTarget = 0;
 386             aGen.Statement();
 387             // Jeden Case einlesen
 388             BOOL bDone = FALSE;
 389             UINT32 nTrueTarget = 0;
 390             if( Peek() == ELSE )
 391             {
 392                 // CASE ELSE
 393                 Next();
 394                 bElse = TRUE;
 395             }
 396             else while( !bDone )
 397             {
 398                 if( bElse )
 399                     Error( SbERR_SYNTAX );
 400                 SbiToken eTok2 = Peek();
 401                 if( eTok2 == IS || ( eTok2 >= EQ && eTok2 <= GE ) )
 402                 {       // CASE [IS] operator expr
 403                     if( eTok2 == IS )
 404                         Next();
 405                     eTok2 = Peek();
 406                     if( eTok2 < EQ || eTok2 > GE )
 407                         Error( SbERR_SYNTAX );
 408                     else Next();
 409                     SbiExpression aCompare( this );
 410                     aCompare.Gen();
 411                     nTrueTarget = aGen.Gen(
 412                         _CASEIS, nTrueTarget,
 413                         sal::static_int_cast< UINT16 >(
 414                             SbxEQ + ( eTok2 - EQ ) ) );
 415                 }
 416                 else
 417                 {       // CASE expr | expr TO expr
 418                     SbiExpression aCase1( this );
 419                     aCase1.Gen();
 420                     if( Peek() == TO )
 421                     {
 422                         // CASE a TO b
 423                         Next();
 424                         SbiExpression aCase2( this );
 425                         aCase2.Gen();
 426                         nTrueTarget = aGen.Gen( _CASETO, nTrueTarget );
 427                     }
 428                     else
 429                         // CASE a
 430                         nTrueTarget = aGen.Gen( _CASEIS, nTrueTarget, SbxEQ );
 431
 432                 }
 433                 if( Peek() == COMMA ) Next();
 434                 else TestEoln(), bDone = TRUE;
 435             }
 436             // Alle Cases abgearbeitet
 437             if( !bElse )
 438             {
 439                 nNextTarget = aGen.Gen( _JUMP, nNextTarget );
 440                 aGen.BackChain( nTrueTarget );
 441             }
 442             // den Statement-Rumpf bauen
 443             while( !bAbort )
 444             {
 445                 eTok = Peek();
 446                 if( eTok == CASE || eTok == ENDSELECT )
 447                     break;
 448                 if( !Parse() ) goto done;
 449                 eTok = Peek();
 450                 if( eTok == CASE || eTok == ENDSELECT )
 451                     break;
 452             }
 453             if( !bElse )
 454                 nDoneTarget = aGen.Gen( _JUMP, nDoneTarget );
 455         }
 456         else if( !IsEoln( eTok ) )
 457             break;
 458     }
 459 done:
 460     if( eTok != ENDSELECT )
 461         Error( SbERR_EXPECTED, ENDSELECT );
 462     if( nNextTarget )
 463         aGen.BackChain( nNextTarget );
 464     aGen.BackChain( nDoneTarget );
 465     aGen.Gen( _ENDCASE );
 466 }
 467
 468 // ON Error/Variable
 469
 470 #ifdef _MSC_VER
 471 #pragma optimize("",off)
 472 #endif
 473
 474 void SbiParser::On()
 475 {
 476     SbiToken eTok = Peek();
 477     String aString = SbiTokenizer::Symbol(eTok);
 478     if (aString.EqualsIgnoreCaseAscii("ERROR"))
 479     //if (!aString.ICompare("ERROR"))
 480         eTok = _ERROR_; // Error kommt als SYMBOL
 481     if( eTok != _ERROR_ && eTok != LOCAL ) OnGoto();
 482     else
 483     {
 484         if( eTok == LOCAL ) Next();
 485         Next (); // Kein TestToken mehr, da es sonst einen Fehler gibt
 486
 487         Next(); // Token nach Error holen
 488         if( eCurTok == GOTO )
 489         {
 490             // ON ERROR GOTO label|0
 491             Next();
 492             bool bError_ = false;
 493             if( MayBeLabel() )
 494             {
 495                 if( eCurTok == NUMBER && !nVal )
 496                     aGen.Gen( _STDERROR );
 497                 else
 498                 {
 499                     UINT32 nOff = pProc->GetLabels().Reference( aSym );
 500                     aGen.Gen( _ERRHDL, nOff );
 501                 }
 502             }
 503             else if( eCurTok == MINUS )
 504             {
 505                 Next();
 506                 if( eCurTok == NUMBER && nVal == 1 )
 507                     aGen.Gen( _STDERROR );
 508                 else
 509                     bError_ = true;
 510             }
 511             if( bError_ )
 512                 Error( SbERR_LABEL_EXPECTED );
 513         }
 514         else if( eCurTok == RESUME )
 515         {
 516             TestToken( NEXT );
 517             aGen.Gen( _NOERROR );
 518         }
 519         else Error( SbERR_EXPECTED, "GoTo/Resume" );
 520     }
 521 }
 522
 523 #ifdef _MSC_VER
 524 #pragma optimize("",off)
 525 #endif
 526
 527 // RESUME [0]|NEXT|label
 528
 529 void SbiParser::Resume()
 530 {
 531     UINT32 nLbl;
 532
 533     switch( Next() )
 534     {
 535         case EOS:
 536         case EOLN:
 537             aGen.Gen( _RESUME, 0 );
 538             break;
 539         case NEXT:
 540             aGen.Gen( _RESUME, 1 );
 541             Next();
 542             break;
 543         case NUMBER:
 544             if( !nVal )
 545             {
 546                 aGen.Gen( _RESUME, 0 );
 547                 break;
 548             } // fall thru
 549         case SYMBOL:
 550             if( MayBeLabel() )
 551             {
 552                 nLbl = pProc->GetLabels().Reference( aSym );
 553                 aGen.Gen( _RESUME, nLbl );
 554                 Next();
 555                 break;
 556             } // fall thru
 557         default:
 558             Error( SbERR_LABEL_EXPECTED );
 559     }
 560 }
 561