I 1 : {E E, E E +E, E E E}

Size: px

Start display at page:

Download "I 1 : {E E, E E +E, E E E}"

Erica Johns
5 years ago
Views:

1 Remark on error handling in LR parsing Example E E + E E E (E) a Typically errors are handled by adding actions to the parsing table error routines that print diagnostic messages and recover in some fashion so that, ideally, parsing can continue in a reasonable manner. We noticed that Yacc applies reductions in cases where LALR detects an error. From the point of view of error handling, this is probably the best thing to do: When the top of the stack can be reduced, it seems likely that the error is in what follows not in what you ve already read. So it is generally best, from the point of view of diagnosis, to go ahead and reduce. You will still fail you ll never be able to shift the bad lookahead token. But if you fail after having reduced as far as possible, you can better characterize the error in terms of the kernel items of the current state the input partially matched those kernel items and then failed before the match was complete. action goto STATE a + ( ) $ E 0 s3 s2 1 1 s4 s5 acc 2 s3 s2 6 3 r4 r4 r4 r4 4 s3 s2 7 5 s3 s2 8 6 s4 s5 s9 7 r1 s5 r1 r1 8 r2 r2 r2 r2 9 r3 r3 r3 r3 0 aa$ s3 0a3 a$ r4, instead of error 0E1 a$ error I 1 : {E E, E E +E, E E E At this point, might say missing operator. 1 2

2 E E + E E E (E) a action goto STATE a + ( ) $ E 0 s3 s2 1 1 s4 s5 acc 2 s3 s2 6 3 r4 r4 r4 r4 4 s3 s2 7 5 s3 s2 8 6 s4 s5 s9 7 r1 s5 r1 r1 8 r2 r2 r2 r2 9 r3 r3 r3 r3 0 a+a($ s3 0a3 +a($ r4 0E1 +a($ s4 0E1+4 a($ s3 0E1+4a3 ($ r4, instead of error 0E1+4E7 ($ r1, instead of error 0E1 ($ error Again, missing operator. 3 Debugging Yacc Yacc has a crude debug facility: %{ #define YYDEBUG 1 int yydebug = 1; % %token A B s : s A B ; yylex() { int c; c = getchar(); if (c == a ) return A; if (c == b ) return B; return 0; yyerror(char *s) { printf("%s\n", s); main() { yyparse(); 4

3 yacc -v e1.y gcc -o e1y y.tab.c cat y.output state 0 $accept : _s $end s : _ (2). reduce 2 s goto 1 state 1 $accept : s_$end s : s_a B $end accept A shift 2 state 2 s : s A_B B shift 3 5 state 3 s : s A B_ (1). reduce 1 S Sab ǫ action goto STATE a b $ S 0 r2 r2 r2 1 1 s2 err acc 2 err s3 err 3 r1 r1 r1 0 ab$ r2 0S1 ab$ s2 0S1a2 b$ s3 0S1a2b3 $ r1 0S1 $ acc yacc -v e1.y gcc -o e1y y.tab.c e1y State 0, token -none- Reduce by (2) "s : /* empty */" State 1, token -noneab State 2, token -none- Received token B State 3, token -none- Reduce by (1) "s : s A B" State 1, token -none- 6

4 Error handling in Yacc First, if a state has a unique reduce action, go ahead and reduce even if the lookahead is wrong catch the error on a partially completed rhs. We have already noticed that the Yacc parsing table includes error actions that are taken when no other action is available. 0. An error action puts the parser in error mode. If it wasn t already in error mode, the parser reports. Of course: try to continue parsing after an error... General strategy: Discard tokens from input, and perhaps symbols from stack, until you can synchronize and resume. In Yacc, the token name error is reserved for error handling, and can appear in productions that are used for synchronization (in order to continue the parse). Of course you can also print diagnostic error messages, and perform more elaborate recovery routines. 1. Starting with the state at the top of the stack and working down the stack popping off states as it goes the parser looks for a state in which there is a shift action on lookahead error. Such a state includes an item A error α As long as the lookahead is error, the only normal action that can be performed is shift. Any state in which there is no shift on error will be popped. If all states on the stack are popped in this way, the parser exits. 2. If such a state is found, the parser performs the shift action placing the token error on the stack and entering the state called for in the shift action. 7 8

5 3a. If α = ǫ, so that the applicable error production is simply A error the parser immediately reduces by that production. In the resulting state, the parser discards lookahead tokens until it finds the first one for which it has a non-error action. The parser then continues with normal parsing, except that it remains in error mode until three consecutive tokens are shifted (trying to avoid a cascade of error messages.) 3b. If the error item is A error α with α ǫ, the parser discards lookahead tokens until it finds the first one for which there is a shift action. Intuitively, it is trying to begin reducing input to α, in order to eventually carry out the synchronizing error reduction. After that initial shift, the parser resumes normal operation except for the fact that its goal is still to reduce by A error α. Also, again the parser remains in error mode until three consecutive tokens are shifted (in order to try to avoid a cascade of error messages.) 9 S Sab ǫ action goto STATE a b $ e S 0 r2 r2 r2 exit 1 1 s2 err acc pop 2 err s3 err pop 3 r1 r1 r1 pop 0 b$ r2 0S1 b$ err (e) 0S1 eb$ pop (e) 0 eb$ exit (e) e1y State 0, token -none- Reduce by (2) "s : /* empty */" State 1, token -noneb Received token B Error recovery pops state 0, uncovers state 1 10

6 S Sab ǫ action goto STATE a b $ e S 0 r2 r2 r2 exit 1 1 s2 err acc pop 2 err s3 err pop 3 r1 r1 r1 pop 0 aa$ r2 0S1 aa$ s2 0S1a2 a$ err (e) 0S1a2 ea$ pop (e) 0S1 ea$ pop (e) 0 ea$ exit (e) e1y State 0, token -none- Reduce by (2) "s : /* empty */" State 1, token -noneaa State 2, token -none- Error recovery pops state 2, uncovers state 1 Error recovery pops state 0, uncovers state 1 Let s add an error production... %{ #define YYDEBUG 1 int yydebug = 1; % %token A B s : s A B error ; yylex() { int c; c = getchar(); if (c == a ) return A; if (c == b ) return B; return 0; yyerror(char *s) { printf("%s\n", s); main() { yyparse(); 11 12

7 yacc -v e2.y gcc -o e2y y.tab.c cat y.output state 0 $accept : _s $end s : _ (2) $end reduce 2 error shift 2 A reduce 2 s goto 1 state 1 $accept : s_$end s : s_a B $end accept A shift 3 state 2 s : error_ (3). reduce 3 state 3 s : s A_B B shift 4 state 4 s : s A B_ (1). reduce 1 S Sab ǫ e action goto STATE a b $ e S 0 r2 err r2 s2 1 1 s3 err acc pop 2 r3 r3 r3 pop 3 err s4 err pop 4 r1 r1 r1 pop 0 b$ err (e) 0 eb$ s2 (e) 0e2 b$ r3 (e) 0S1 b$ discard (e) 0S1 $ acc e2y State 0, token -noneb Received token B State 2, token B Reduce by (3) "s : error" State 1, token B Error recovery discards token B 13 14

8 S Sab ǫ e action goto STATE a b $ e S 0 r2 err r2 s2 1 1 s3 err acc pop 2 r3 r3 r3 pop 3 err s4 err pop 4 r1 r1 r1 pop 0 ba$ err (e) 0 eba$ s2 (e) 0e2 ba$ r3 (e) 0S1 ba$ discard (e) 0S1 a$ s3 0S1a3 $ err (e) 0S1a3 e$ pop (e) 0S1 e$ pop (e) 0 e$ s2 (e) 0e2 $ r3 (e) 0S1 $ acc e2y State 0, token -noneba Received token B State 2, token B Reduce by (3) "s : error" State 1, token B Error recovery discards token B State 3, token -none- State 2, token end-of-file Reduce by (3) "s : error" State 1, token end-of-file e2y State 0, token -noneaa Reduce by (2) "s : /* empty */" State 1, token A State 3, token -none- State 2, token A Reduce by (3) "s : error" State 1, token A State 3, token -none- State 2, token end-of-file Reduce by (3) "s : error" State 1, token end-of-file 15 16

9 Let s modify the error production... %{ #define YYDEBUG 1 int yydebug = 1; % %token A B s : s A B error B ; yylex() { int c; c = getchar(); if (c == a ) return A; if (c == b ) return B; return 0; yyerror(char *s) { printf("%s\n", s); main() { yyparse(); yacc -v e3.y gcc -o e3y y.tab.c cat y.output state 0 $accept : _s $end s : _ (2) $end reduce 2 error shift 2 A reduce 2 s goto 1 state 1 $accept : s_$end s : s_a B $end accept A shift 3 state 2 s : error_b B shift 4 state 3 s : s A_B B shift 5 state 4 s : error B_ (3). reduce 3 state 5 s : s A B_ (1). reduce

10 S Sab ǫ eb action goto STATE a b $ e S 0 r2 err r2 s2 1 1 s3 err acc pop 2 err s4 err pop 3 err s5 err pop 4 r3 r3 r3 pop 5 r1 r1 r1 pop 0 b$ err (e) 0 eb$ s2 (e) 0e2 b$ s4 0e2b4 $ r3 0S1 $ acc e3y State 0, token -noneb Received token B State 2, token B State 4, token -none- Reduce by (3) "s : error B" State 1, token -none- 19 S Sab ǫ eb action goto STATE a b $ e S 0 r2 err r2 s2 1 1 s3 err acc pop 2 err s4 err pop 3 err s5 err pop 4 r3 r3 r3 pop 5 r1 r1 r1 pop 0 ba$ err (e) 0 eba$ s2 (e) 0e2 ba$ s4 0e2b4 a$ r3 0S1 a$ s3 0S1a3 $ err (e) 0S1a3 e$ pop (e) 0S1 e$ pop (e) 0 e$ s2 (e) 0e2 $ discard (e) 20

11 e3y State 0, token -noneba Received token B State 2, token B State 4, token -none- Reduce by (3) "s : error B" State 1, token -none- State 3, token -none- State 2, token end-of-file Error recovery discards token end-of-file e3y State 0, token -noneaab Reduce by (2) "s : /* empty */" State 1, token A State 3, token -none- State 2, token A Error recovery discards token A Received token B State 4, token -none- Reduce by (3) "s : error B" State 1, token -none- 21 Let s alter the grammar and make better use of synchronization... %{ #define YYDEBUG 1 int yydebug = 1; % %token NL A B ln : ln s NL error NL ; s : s A B ; yylex() { int c; while ((c=getchar()) == ); if (c == \n ) return NL; if (c == a ) return A; if (c == b ) return B; return c; yyerror(char *s) { printf("%s\n", s); main() { yyparse(); 22

12 yacc -v e4.y gcc -o e4y y.tab.c cat y.output state 0 $accept : _ln $end ln : _ (2) $end reduce 2 error shift 2 NL reduce 2 A reduce 2 ln goto 1 state 1 $accept : ln_$end ln : ln_s NL s : _ (5) $end accept. reduce 5 s goto 3 state 2 ln : error_nl NL shift 4 state 3 ln : ln s_nl s : s_a B NL shift 5 A shift 6 state 4 ln : error NL_ (3). reduce 3 state 5 ln : ln s NL_ (1). reduce 1 state 6 s : s A_B B shift 7 state 7 s : s A B_ (4). reduce 4 L L S nl ǫ e nl S Sab ǫ action goto STATE a b nl $ e L S 0 r2 err r2 r2 s2 1 1 r5 r5 r5 acc pop 3 2 err err s4 err pop 3 s6 err s5 err pop 4 r3 r3 r3 r3 pop 5 r1 r1 r1 r1 pop 6 err s7 err err pop 7 r4 r4 r4 r4 pop 0 anla$ r2 0L1 anla$ r5 0L1S3 anla$ s6 0L1S3a6 nla$ err (e) 0L1S3a6 enla$ pop (e) 0L1S3 enla$ pop (e) 0L1 enla$ pop (e) 0 enla$ s2 (e) 0e2 nla$ s4 0e2nl4 a$ r3 0L1 a$ r5 0L1S3 a$ s6 0L1S3a6 $ err (e) 0L1S3a6 e$ pop (e) 0L1S3 e$ pop (e) 0L1 e$ pop (e) 0 e$ s2 (e) 0e2 $ discard (e) 23 24

13 e4y < tmp e4y < tmp State 0, token -none- Reduce by (2) "ln : /* empty */" State 1, token A Reduce by (5) "s : /* empty */" State 3, token A State 6, token -none- Received token NL Error recovery pops state 6, uncovers state 3 State 2, token NL State 4, token -none- Reduce by (3) "ln : error NL" State 1, token -none- Reduce by (5) "s : /* empty */" State 3, token A State 6, token -none- Error recovery pops state 6, uncovers state 3 State 2, token end-of-file Error recovery discards token end-of-file 25 Recall that once the parser enters error mode, messages are suppressed until three successive tokens are shifted. When we include an error production that reliably synchronizes the parse, we may wish to override this default. For instance, in the previous example, the parser did not emit the message on line 2, although logically, we probably wish to consider the error in line 2 separately from the error in line 1. A call to built-in function yyerrok turns off error mode right away. %{ #define YYDEBUG 1 int yydebug = 1; % %token NL A B ln : ln s NL error NL { yyerrok; ; s : s A B ;... 26

14 yacc -v e5.y gcc -o e5y y.tab.c e5y < tmp State 0, token -none- Reduce by (2) "ln : /* empty */" State 1, token A Reduce by (5) "s : /* empty */" State 3, token A State 6, token -none- Received token NL Error recovery pops state 6, uncovers state 3 State 2, token NL State 4, token -none- Reduce by (3) "ln : error NL" State 1, token -none- Reduce by (5) "s : /* empty */" State 3, token A State 6, token -none- Error recovery pops state 6, uncovers state 3 State 2, token end-of-file Error recovery discards token end-of-file 27 For next time A little on syntax-directed translation. Read 5.1,

CSCI Compiler Design

CSCI Compiler Design Syntactic Analysis Automatic Parser Generators: The UNIX YACC Tool Portions of this lecture were adapted from Prof. Pedro Reis Santos s notes for the 2006 Compilers class lectured at IST/UTL in Lisbon,