| /************************************************************** | |
| * | |
| * 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" | |
| // Single-line IF und Multiline IF | |
| void SbiParser::If() | |
| { | |
| sal_uInt32 nEndLbl; | |
| SbiToken eTok = NIL; | |
| // Ende-Tokens ignorieren: | |
| SbiExpression aCond( this ); | |
| aCond.Gen(); | |
| TestToken( THEN ); | |
| if( IsEoln( Next() ) ) | |
| { | |
| // AB 13.5.1996: #27720# Am Ende jeden Blocks muss ein Jump zu ENDIF | |
| // eingefügt werden, damit bei ELSEIF nicht erneut die Bedingung | |
| // ausgewertet wird. Die Tabelle nimmt alle Absprungstellen auf. | |
| #define JMP_TABLE_SIZE 100 | |
| sal_uInt32 pnJmpToEndLbl[JMP_TABLE_SIZE]; // 100 ELSEIFs zulaessig | |
| sal_uInt16 iJmp = 0; // aktueller Tabellen-Index | |
| // multiline IF | |
| nEndLbl = aGen.Gen( _JUMPF, 0 ); | |
| eTok = Peek(); | |
| while( !( eTok == ELSEIF || eTok == ELSE || eTok == ENDIF ) && | |
| !bAbort && Parse() ) | |
| { | |
| eTok = Peek(); | |
| if( IsEof() ) | |
| { | |
| Error( SbERR_BAD_BLOCK, IF ); bAbort = sal_True; return; | |
| } | |
| } | |
| // ELSEIF? | |
| while( eTok == ELSEIF ) | |
| { | |
| // #27720# Bei erfolgreichem IF/ELSEIF auf ENDIF springen | |
| if( iJmp >= JMP_TABLE_SIZE ) | |
| { | |
| Error( SbERR_PROG_TOO_LARGE ); bAbort = sal_True; return; | |
| } | |
| pnJmpToEndLbl[iJmp++] = aGen.Gen( _JUMP, 0 ); | |
| Next(); | |
| aGen.BackChain( nEndLbl ); | |
| aGen.Statement(); | |
| SbiExpression* pCond = new SbiExpression( this ); | |
| pCond->Gen(); | |
| nEndLbl = aGen.Gen( _JUMPF, 0 ); | |
| delete pCond; | |
| TestToken( THEN ); | |
| eTok = Peek(); | |
| while( !( eTok == ELSEIF || eTok == ELSE || eTok == ENDIF ) && | |
| !bAbort && Parse() ) | |
| { | |
| eTok = Peek(); | |
| if( IsEof() ) | |
| { | |
| Error( SbERR_BAD_BLOCK, ELSEIF ); bAbort = sal_True; return; | |
| } | |
| } | |
| } | |
| if( eTok == ELSE ) | |
| { | |
| Next(); | |
| sal_uInt32 nElseLbl = nEndLbl; | |
| nEndLbl = aGen.Gen( _JUMP, 0 ); | |
| aGen.BackChain( nElseLbl ); | |
| aGen.Statement(); | |
| StmntBlock( ENDIF ); | |
| } | |
| else if( eTok == ENDIF ) | |
| Next(); | |
| // #27720# Jmp-Tabelle abarbeiten | |
| while( iJmp > 0 ) | |
| { | |
| iJmp--; | |
| aGen.BackChain( pnJmpToEndLbl[iJmp] ); | |
| } | |
| } | |
| else | |
| { | |
| // single line IF | |
| bSingleLineIf = sal_True; | |
| nEndLbl = aGen.Gen( _JUMPF, 0 ); | |
| Push( eCurTok ); | |
| while( !bAbort ) | |
| { | |
| if( !Parse() ) break; | |
| eTok = Peek(); | |
| if( eTok == ELSE || eTok == EOLN || eTok == REM ) | |
| break; | |
| } | |
| if( eTok == ELSE ) | |
| { | |
| Next(); | |
| sal_uInt32 nElseLbl = nEndLbl; | |
| nEndLbl = aGen.Gen( _JUMP, 0 ); | |
| aGen.BackChain( nElseLbl ); | |
| while( !bAbort ) | |
| { | |
| if( !Parse() ) break; | |
| eTok = Peek(); | |
| if( eTok == EOLN || eTok == REM ) | |
| break; | |
| } | |
| } | |
| bSingleLineIf = sal_False; | |
| } | |
| aGen.BackChain( nEndLbl ); | |
| } | |
| // ELSE/ELSEIF/ENDIF ohne IF | |
| void SbiParser::NoIf() | |
| { | |
| Error( SbERR_NO_IF ); | |
| StmntBlock( ENDIF ); | |
| } | |
| // DO WHILE...LOOP | |
| // DO ... LOOP WHILE | |
| void SbiParser::DoLoop() | |
| { | |
| sal_uInt32 nStartLbl = aGen.GetPC(); | |
| OpenBlock( DO ); | |
| SbiToken eTok = Next(); | |
| if( IsEoln( eTok ) ) | |
| { | |
| // DO ... LOOP [WHILE|UNTIL expr] | |
| StmntBlock( LOOP ); | |
| eTok = Next(); | |
| if( eTok == UNTIL || eTok == WHILE ) | |
| { | |
| SbiExpression aExpr( this ); | |
| aExpr.Gen(); | |
| aGen.Gen( eTok == UNTIL ? _JUMPF : _JUMPT, nStartLbl ); | |
| } else | |
| if (eTok == EOLN || eTok == REM) | |
| aGen.Gen (_JUMP, nStartLbl); | |
| else | |
| Error( SbERR_EXPECTED, WHILE ); | |
| } | |
| else | |
| { | |
| // DO [WHILE|UNTIL expr] ... LOOP | |
| if( eTok == UNTIL || eTok == WHILE ) | |
| { | |
| SbiExpression aCond( this ); | |
| aCond.Gen(); | |
| } | |
| sal_uInt32 nEndLbl = aGen.Gen( eTok == UNTIL ? _JUMPT : _JUMPF, 0 ); | |
| StmntBlock( LOOP ); | |
| TestEoln(); | |
| aGen.Gen( _JUMP, nStartLbl ); | |
| aGen.BackChain( nEndLbl ); | |
| } | |
| CloseBlock(); | |
| } | |
| // WHILE ... WEND | |
| void SbiParser::While() | |
| { | |
| SbiExpression aCond( this ); | |
| sal_uInt32 nStartLbl = aGen.GetPC(); | |
| aCond.Gen(); | |
| sal_uInt32 nEndLbl = aGen.Gen( _JUMPF, 0 ); | |
| StmntBlock( WEND ); | |
| aGen.Gen( _JUMP, nStartLbl ); | |
| aGen.BackChain( nEndLbl ); | |
| } | |
| // FOR var = expr TO expr STEP | |
| void SbiParser::For() | |
| { | |
| bool bForEach = ( Peek() == EACH ); | |
| if( bForEach ) | |
| Next(); | |
| SbiExpression aLvalue( this, SbOPERAND ); | |
| aLvalue.Gen(); // Variable auf dem Stack | |
| if( bForEach ) | |
| { | |
| TestToken( _IN_ ); | |
| SbiExpression aCollExpr( this, SbOPERAND ); | |
| aCollExpr.Gen(); // Colletion var to for stack | |
| TestEoln(); | |
| aGen.Gen( _INITFOREACH ); | |
| } | |
| else | |
| { | |
| TestToken( EQ ); | |
| SbiExpression aStartExpr( this ); | |
| aStartExpr.Gen(); // Startausdruck auf dem Stack | |
| TestToken( TO ); | |
| SbiExpression aStopExpr( this ); | |
| aStopExpr.Gen(); // Endausdruck auf dem Stack | |
| if( Peek() == STEP ) | |
| { | |
| Next(); | |
| SbiExpression aStepExpr( this ); | |
| aStepExpr.Gen(); | |
| } | |
| else | |
| { | |
| SbiExpression aOne( this, 1, SbxINTEGER ); | |
| aOne.Gen(); | |
| } | |
| TestEoln(); | |
| // Der Stack hat jetzt 4 Elemente: Variable, Start, Ende, Inkrement | |
| // Startwert binden | |
| aGen.Gen( _INITFOR ); | |
| } | |
| sal_uInt32 nLoop = aGen.GetPC(); | |
| // Test durchführen, evtl. Stack freigeben | |
| sal_uInt32 nEndTarget = aGen.Gen( _TESTFOR, 0 ); | |
| OpenBlock( FOR ); | |
| StmntBlock( NEXT ); | |
| aGen.Gen( _NEXT ); | |
| aGen.Gen( _JUMP, nLoop ); | |
| // Kommen Variable nach NEXT? | |
| if( Peek() == SYMBOL ) | |
| { | |
| SbiExpression aVar( this, SbOPERAND ); | |
| if( aVar.GetRealVar() != aLvalue.GetRealVar() ) | |
| Error( SbERR_EXPECTED, aLvalue.GetRealVar()->GetName() ); | |
| } | |
| aGen.BackChain( nEndTarget ); | |
| CloseBlock(); | |
| } | |
| // WITH .. END WITH | |
| void SbiParser::With() | |
| { | |
| SbiExpression aVar( this, SbOPERAND ); | |
| // Letzten Knoten in der Objekt-Kette überprüfen | |
| SbiExprNode *pNode = aVar.GetExprNode()->GetRealNode(); | |
| SbiSymDef* pDef = pNode->GetVar(); | |
| // Variant, AB 27.6.1997, #41090: bzw. empty -> muß Object sein | |
| if( pDef->GetType() == SbxVARIANT || pDef->GetType() == SbxEMPTY ) | |
| pDef->SetType( SbxOBJECT ); | |
| else if( pDef->GetType() != SbxOBJECT ) | |
| Error( SbERR_NEEDS_OBJECT ); | |
| // Knoten auch auf SbxOBJECT setzen, damit später Gen() klappt | |
| pNode->SetType( SbxOBJECT ); | |
| OpenBlock( NIL, aVar.GetExprNode() ); | |
| StmntBlock( ENDWITH ); | |
| CloseBlock(); | |
| } | |
| // LOOP/NEXT/WEND ohne Konstrukt | |
| void SbiParser::BadBlock() | |
| { | |
| if( eEndTok ) | |
| Error( SbERR_BAD_BLOCK, eEndTok ); | |
| else | |
| Error( SbERR_BAD_BLOCK, "Loop/Next/Wend" ); | |
| } | |
| // On expr Goto/Gosub n,n,n... | |
| void SbiParser::OnGoto() | |
| { | |
| SbiExpression aCond( this ); | |
| aCond.Gen(); | |
| sal_uInt32 nLabelsTarget = aGen.Gen( _ONJUMP, 0 ); | |
| SbiToken eTok = Next(); | |
| if( eTok != GOTO && eTok != GOSUB ) | |
| { | |
| Error( SbERR_EXPECTED, "GoTo/GoSub" ); | |
| eTok = GOTO; | |
| } | |
| // Label-Tabelle einlesen: | |
| sal_uInt32 nLbl = 0; | |
| do | |
| { | |
| SbiToken eTok2 = NIL; | |
| eTok2 = Next(); // Label holen | |
| if( MayBeLabel() ) | |
| { | |
| sal_uInt32 nOff = pProc->GetLabels().Reference( aSym ); | |
| aGen.Gen( _JUMP, nOff ); | |
| nLbl++; | |
| } | |
| else Error( SbERR_LABEL_EXPECTED ); | |
| } | |
| while( !bAbort && TestComma() ); | |
| if( eTok == GOSUB ) | |
| nLbl |= 0x8000; | |
| aGen.Patch( nLabelsTarget, nLbl ); | |
| } | |
| // GOTO/GOSUB | |
| void SbiParser::Goto() | |
| { | |
| SbiOpcode eOp = eCurTok == GOTO ? _JUMP : _GOSUB; | |
| Next(); | |
| if( MayBeLabel() ) | |
| { | |
| sal_uInt32 nOff = pProc->GetLabels().Reference( aSym ); | |
| aGen.Gen( eOp, nOff ); | |
| } | |
| else Error( SbERR_LABEL_EXPECTED ); | |
| } | |
| // RETURN [label] | |
| void SbiParser::Return() | |
| { | |
| Next(); | |
| if( MayBeLabel() ) | |
| { | |
| sal_uInt32 nOff = pProc->GetLabels().Reference( aSym ); | |
| aGen.Gen( _RETURN, nOff ); | |
| } | |
| else aGen.Gen( _RETURN, 0 ); | |
| } | |
| // SELECT CASE | |
| void SbiParser::Select() | |
| { | |
| TestToken( CASE ); | |
| SbiExpression aCase( this ); | |
| SbiToken eTok = NIL; | |
| aCase.Gen(); | |
| aGen.Gen( _CASE ); | |
| TestEoln(); | |
| sal_uInt32 nNextTarget = 0; | |
| sal_uInt32 nDoneTarget = 0; | |
| sal_Bool bElse = sal_False; | |
| // Die Cases einlesen: | |
| while( !bAbort ) | |
| { | |
| eTok = Next(); | |
| if( eTok == CASE ) | |
| { | |
| if( nNextTarget ) | |
| aGen.BackChain( nNextTarget ), nNextTarget = 0; | |
| aGen.Statement(); | |
| // Jeden Case einlesen | |
| sal_Bool bDone = sal_False; | |
| sal_uInt32 nTrueTarget = 0; | |
| if( Peek() == ELSE ) | |
| { | |
| // CASE ELSE | |
| Next(); | |
| bElse = sal_True; | |
| } | |
| else while( !bDone ) | |
| { | |
| if( bElse ) | |
| Error( SbERR_SYNTAX ); | |
| SbiToken eTok2 = Peek(); | |
| if( eTok2 == IS || ( eTok2 >= EQ && eTok2 <= GE ) ) | |
| { // CASE [IS] operator expr | |
| if( eTok2 == IS ) | |
| Next(); | |
| eTok2 = Peek(); | |
| if( eTok2 < EQ || eTok2 > GE ) | |
| Error( SbERR_SYNTAX ); | |
| else Next(); | |
| SbiExpression aCompare( this ); | |
| aCompare.Gen(); | |
| nTrueTarget = aGen.Gen( | |
| _CASEIS, nTrueTarget, | |
| sal::static_int_cast< sal_uInt16 >( | |
| SbxEQ + ( eTok2 - EQ ) ) ); | |
| } | |
| else | |
| { // CASE expr | expr TO expr | |
| SbiExpression aCase1( this ); | |
| aCase1.Gen(); | |
| if( Peek() == TO ) | |
| { | |
| // CASE a TO b | |
| Next(); | |
| SbiExpression aCase2( this ); | |
| aCase2.Gen(); | |
| nTrueTarget = aGen.Gen( _CASETO, nTrueTarget ); | |
| } | |
| else | |
| // CASE a | |
| nTrueTarget = aGen.Gen( _CASEIS, nTrueTarget, SbxEQ ); | |
| } | |
| if( Peek() == COMMA ) Next(); | |
| else TestEoln(), bDone = sal_True; | |
| } | |
| // Alle Cases abgearbeitet | |
| if( !bElse ) | |
| { | |
| nNextTarget = aGen.Gen( _JUMP, nNextTarget ); | |
| aGen.BackChain( nTrueTarget ); | |
| } | |
| // den Statement-Rumpf bauen | |
| while( !bAbort ) | |
| { | |
| eTok = Peek(); | |
| if( eTok == CASE || eTok == ENDSELECT ) | |
| break; | |
| if( !Parse() ) goto done; | |
| eTok = Peek(); | |
| if( eTok == CASE || eTok == ENDSELECT ) | |
| break; | |
| } | |
| if( !bElse ) | |
| nDoneTarget = aGen.Gen( _JUMP, nDoneTarget ); | |
| } | |
| else if( !IsEoln( eTok ) ) | |
| break; | |
| } | |
| done: | |
| if( eTok != ENDSELECT ) | |
| Error( SbERR_EXPECTED, ENDSELECT ); | |
| if( nNextTarget ) | |
| aGen.BackChain( nNextTarget ); | |
| aGen.BackChain( nDoneTarget ); | |
| aGen.Gen( _ENDCASE ); | |
| } | |
| // ON Error/Variable | |
| #ifdef _MSC_VER | |
| #pragma optimize("",off) | |
| #endif | |
| void SbiParser::On() | |
| { | |
| SbiToken eTok = Peek(); | |
| String aString = SbiTokenizer::Symbol(eTok); | |
| if (aString.EqualsIgnoreCaseAscii("ERROR")) | |
| //if (!aString.ICompare("ERROR")) | |
| eTok = _ERROR_; // Error kommt als SYMBOL | |
| if( eTok != _ERROR_ && eTok != LOCAL ) OnGoto(); | |
| else | |
| { | |
| if( eTok == LOCAL ) Next(); | |
| Next (); // Kein TestToken mehr, da es sonst einen Fehler gibt | |
| Next(); // Token nach Error holen | |
| if( eCurTok == GOTO ) | |
| { | |
| // ON ERROR GOTO label|0 | |
| Next(); | |
| bool bError_ = false; | |
| if( MayBeLabel() ) | |
| { | |
| if( eCurTok == NUMBER && !nVal ) | |
| aGen.Gen( _STDERROR ); | |
| else | |
| { | |
| sal_uInt32 nOff = pProc->GetLabels().Reference( aSym ); | |
| aGen.Gen( _ERRHDL, nOff ); | |
| } | |
| } | |
| else if( eCurTok == MINUS ) | |
| { | |
| Next(); | |
| if( eCurTok == NUMBER && nVal == 1 ) | |
| aGen.Gen( _STDERROR ); | |
| else | |
| bError_ = true; | |
| } | |
| if( bError_ ) | |
| Error( SbERR_LABEL_EXPECTED ); | |
| } | |
| else if( eCurTok == RESUME ) | |
| { | |
| TestToken( NEXT ); | |
| aGen.Gen( _NOERROR ); | |
| } | |
| else Error( SbERR_EXPECTED, "GoTo/Resume" ); | |
| } | |
| } | |
| #ifdef _MSC_VER | |
| #pragma optimize("",off) | |
| #endif | |
| // RESUME [0]|NEXT|label | |
| void SbiParser::Resume() | |
| { | |
| sal_uInt32 nLbl; | |
| switch( Next() ) | |
| { | |
| case EOS: | |
| case EOLN: | |
| aGen.Gen( _RESUME, 0 ); | |
| break; | |
| case NEXT: | |
| aGen.Gen( _RESUME, 1 ); | |
| Next(); | |
| break; | |
| case NUMBER: | |
| if( !nVal ) | |
| { | |
| aGen.Gen( _RESUME, 0 ); | |
| break; | |
| } // fall through | |
| case SYMBOL: | |
| if( MayBeLabel() ) | |
| { | |
| nLbl = pProc->GetLabels().Reference( aSym ); | |
| aGen.Gen( _RESUME, nLbl ); | |
| Next(); | |
| break; | |
| } // fall through | |
| default: | |
| Error( SbERR_LABEL_EXPECTED ); | |
| } | |
| } | |
| /* vim: set noet sw=4 ts=4: */ |