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