From cab516119a24d4fd6d87d9ab06fa37c3c9ff1108 Mon Sep 17 00:00:00 2001 From: unknown Date: Mon, 20 Apr 2020 17:52:33 -0500 Subject: [PATCH] tabla lista --- Reserved.py | 3 + TA.py | 85 +- __pycache__/parsetab.cpython-37.pyc | Bin 9993 -> 10169 bytes parser.out | 2431 +++++++++++++-------------- parsetab.py | 92 +- 5 files changed, 1312 insertions(+), 1299 deletions(-) create mode 100644 Reserved.py diff --git a/Reserved.py b/Reserved.py new file mode 100644 index 0000000..4f83e41 --- /dev/null +++ b/Reserved.py @@ -0,0 +1,3 @@ +reserved = { + +} \ No newline at end of file diff --git a/TA.py b/TA.py index 74d0492..6d1fc89 100644 --- a/TA.py +++ b/TA.py @@ -14,7 +14,6 @@ t_STRING = r'\"[0-9]*[a-zA-Z]+[0-9]*\"' t_ID = r'[0-9]*[a-zA-Z]+[0-9]*' - def t_EQUAL(t): r'\=' t.type = 'EQUAL' @@ -25,7 +24,7 @@ def t_CONSTANT(t): t.type = 'CONSTANT' return t -t_ignore = r' ' +t_ignore = ' \t' def t_READ(t): r'READ' @@ -104,35 +103,57 @@ def t_FLOAT(t): t_COMA = r'\,' +def t_newline(t): + r'\n+' + t.lexer.lineno += len(t.value) + def t_error(t): - print("Caracter no reconocido") + print("Error, invalid character '%s'" % t.value[0]) + t.lexer.skip(1) def p_PROGRAMA(p): ''' PROGRAMA : R START V B FINISH R ''' + p[0] = "DONE" + symbolsTable[p[2]] = 'START' def p_V(p): ''' V : BE VARIABLES SEMICOLON B V | ''' + if len(p) > 1: + symbolsArray.insert(0,p[2]) def p_VARIABLES(p): ''' VARIABLES : FLOAT ID - | INT ID - | VECTOR ID LEFT_PARENTESIS CONSTANT RIGHT_PARENTESIS - | MATRIX ID LEFT_PARENTESIS CONSTANT COMA CONSTANT RIGHT_PARENTESIS - | CUBE ID LEFT_PARENTESIS CONSTANT COMA CONSTANT COMA CONSTANT RIGHT_PARENTESIS + | T ID + | T ID LEFT_PARENTESIS CONSTANT RIGHT_PARENTESIS + | T ID LEFT_PARENTESIS CONSTANT COMA CONSTANT RIGHT_PARENTESIS + | T ID LEFT_PARENTESIS CONSTANT COMA CONSTANT COMA CONSTANT RIGHT_PARENTESIS ''' + +def p_T(p): + ''' + T : INT + | VECTOR + | MATRIX + | CUBE + ''' + typesArray.append(p[1]) + + def p_R(p): ''' R : ROUTINE LEFT_PARENTESIS ID RIGHT_PARENTESIS V B RETURN R | ''' + if(len(p) > 1): + symbolsTable[p[2]] = 'ROUTINE' def p_B(p): ''' @@ -198,20 +219,36 @@ def p_E_AUX(p): ''' def p_error(p): - print("No valido") - - -tokens = Tokens.Tokens -lexer = lex.lex() -parser = yacc.yacc() -nameOfFile = 'test.txt' -archivo = open(nameOfFile,"r") -test = archivo.read() -toParse = '' -for char in test: - if not(char == ' ' or char == '\t' or char == '\n' or char == '\s'): - toParse+=char -archivo.close() - -print(toParse) -parser.parse(toParse) \ No newline at end of file + print("No valido " + str(p.lineno)) + + +try: + typesArray = [] + symbolsArray = [] + symbolsTable = {} + + + tokens = Tokens.Tokens + lexer = lex.lex() + yacc.yacc() + nameOfFile = 'test.txt' + archivo = open(nameOfFile,"r") + test = archivo.read() + archivo.close() + + toParse = '' + + for char in test: + if not(char == ' ' or char == '\t' or char == '\n' or char == '\s'): + toParse+=char + #toParse = test + #print(toParse) + print(yacc.parse(toParse,tracking = True)) + + + + + #print(toParse) + #parser.parse(toParse) +except EOFError as e: + print(e) \ No newline at end of file diff --git a/__pycache__/parsetab.cpython-37.pyc b/__pycache__/parsetab.cpython-37.pyc index 1ef1476b01ce6348db898141e24f895ed116507c..203aaeadbbe177502c694a788b40f2f5e42418c5 100644 GIT binary patch literal 10169 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 R_N@tmuBU7yShKgJ9X3Fm92jxAq%Drf2?EDiaP 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 PO%QY|%4UK!Z*==F{cfv- diff --git a/parser.out b/parser.out index 4dd1e44..3a17260 100644 --- a/parser.out +++ b/parser.out @@ -30,69 +30,73 @@ Rule 1 PROGRAMA -> R START V B FINISH R Rule 2 V -> BE VARIABLES SEMICOLON B V Rule 3 V -> Rule 4 VARIABLES -> FLOAT ID -Rule 5 VARIABLES -> INT ID -Rule 6 VARIABLES -> VECTOR ID LEFT_PARENTESIS CONSTANT RIGHT_PARENTESIS -Rule 7 VARIABLES -> MATRIX ID LEFT_PARENTESIS CONSTANT COMA CONSTANT RIGHT_PARENTESIS -Rule 8 VARIABLES -> CUBE ID LEFT_PARENTESIS CONSTANT COMA CONSTANT COMA CONSTANT RIGHT_PARENTESIS -Rule 9 R -> ROUTINE LEFT_PARENTESIS ID RIGHT_PARENTESIS V B RETURN R -Rule 10 R -> -Rule 11 B -> CALL ID SEMICOLON V B -Rule 12 B -> ID INDICES EQUAL E SEMICOLON V B -Rule 13 B -> READ ID SEMICOLON V B -Rule 14 B -> WRITE STRING WRITE_AUX SEMICOLON V B -Rule 15 B -> WRITE E WRITE_AUX SEMICOLON V B -Rule 16 B -> IF LEFT_PARENTESIS EL RIGHT_PARENTESIS B ELSE_AUX ENDIF V B -Rule 17 B -> WHILE LEFT_PARENTESIS EL RIGHT_PARENTESIS V B ENDWHILE V B -Rule 18 B -> FOR LEFT_PARENTESIS EL COMA B RIGHT_PARENTESIS V B ENDFOR V B -Rule 19 B -> -Rule 20 INDICES -> LEFT_PARENTESIS E RIGHT_PARENTESIS -Rule 21 INDICES -> LEFT_PARENTESIS E COMA E RIGHT_PARENTESIS -Rule 22 INDICES -> LEFT_PARENTESIS E COMA E COMA E RIGHT_PARENTESIS -Rule 23 INDICES -> -Rule 24 ELSE_AUX -> ELSE B -Rule 25 ELSE_AUX -> -Rule 26 WRITE_AUX -> COMA STRING WRITE_AUX -Rule 27 WRITE_AUX -> COMA ID INDICES WRITE_AUX -Rule 28 WRITE_AUX -> -Rule 29 EL -> LEFT_PARENTESIS EL RIGHT_PARENTESIS EL_AUX -Rule 30 EL -> CONSTANT EL_AUX -Rule 31 EL -> ID EL_AUX -Rule 32 EL_AUX -> COMPARISON EL -Rule 33 EL_AUX -> -Rule 34 E -> LEFT_PARENTESIS E RIGHT_PARENTESIS E_AUX -Rule 35 E -> CONSTANT E_AUX -Rule 36 E -> ID INDICES E_AUX -Rule 37 E_AUX -> PLUS E -Rule 38 E_AUX -> STAR E -Rule 39 E_AUX -> SLASH E -Rule 40 E_AUX -> MINUS E -Rule 41 E_AUX -> +Rule 5 VARIABLES -> T ID +Rule 6 VARIABLES -> T ID LEFT_PARENTESIS CONSTANT RIGHT_PARENTESIS +Rule 7 VARIABLES -> T ID LEFT_PARENTESIS CONSTANT COMA CONSTANT RIGHT_PARENTESIS +Rule 8 VARIABLES -> T ID LEFT_PARENTESIS CONSTANT COMA CONSTANT COMA CONSTANT RIGHT_PARENTESIS +Rule 9 T -> INT +Rule 10 T -> VECTOR +Rule 11 T -> MATRIX +Rule 12 T -> CUBE +Rule 13 R -> ROUTINE LEFT_PARENTESIS ID RIGHT_PARENTESIS V B RETURN R +Rule 14 R -> +Rule 15 B -> CALL ID SEMICOLON V B +Rule 16 B -> ID INDICES EQUAL E SEMICOLON V B +Rule 17 B -> READ ID SEMICOLON V B +Rule 18 B -> WRITE STRING WRITE_AUX SEMICOLON V B +Rule 19 B -> WRITE E WRITE_AUX SEMICOLON V B +Rule 20 B -> IF LEFT_PARENTESIS EL RIGHT_PARENTESIS B ELSE_AUX ENDIF V B +Rule 21 B -> WHILE LEFT_PARENTESIS EL RIGHT_PARENTESIS V B ENDWHILE V B +Rule 22 B -> FOR LEFT_PARENTESIS EL COMA B RIGHT_PARENTESIS V B ENDFOR V B +Rule 23 B -> +Rule 24 INDICES -> LEFT_PARENTESIS E RIGHT_PARENTESIS +Rule 25 INDICES -> LEFT_PARENTESIS E COMA E RIGHT_PARENTESIS +Rule 26 INDICES -> LEFT_PARENTESIS E COMA E COMA E RIGHT_PARENTESIS +Rule 27 INDICES -> +Rule 28 ELSE_AUX -> ELSE B +Rule 29 ELSE_AUX -> +Rule 30 WRITE_AUX -> COMA STRING WRITE_AUX +Rule 31 WRITE_AUX -> COMA ID INDICES WRITE_AUX +Rule 32 WRITE_AUX -> +Rule 33 EL -> LEFT_PARENTESIS EL RIGHT_PARENTESIS EL_AUX +Rule 34 EL -> CONSTANT EL_AUX +Rule 35 EL -> ID EL_AUX +Rule 36 EL_AUX -> COMPARISON EL +Rule 37 EL_AUX -> +Rule 38 E -> LEFT_PARENTESIS E RIGHT_PARENTESIS E_AUX +Rule 39 E -> CONSTANT E_AUX +Rule 40 E -> ID INDICES E_AUX +Rule 41 E_AUX -> PLUS E +Rule 42 E_AUX -> STAR E +Rule 43 E_AUX -> SLASH E +Rule 44 E_AUX -> MINUS E +Rule 45 E_AUX -> Terminals, with rules where they appear AND : BE : 2 BOOLEAN_EXPRESSION : -CALL : 11 -COMA : 7 8 8 18 21 22 22 26 27 -COMPARISON : 32 -CONSTANT : 6 7 7 8 8 8 30 35 -CUBE : 8 -ELSE : 24 -ENDFOR : 18 -ENDIF : 16 -ENDWHILE : 17 -EQUAL : 12 +CALL : 15 +COMA : 7 8 8 22 25 26 26 30 31 +COMPARISON : 36 +CONSTANT : 6 7 7 8 8 8 34 39 +CUBE : 12 +ELSE : 28 +ENDFOR : 22 +ENDIF : 20 +ENDWHILE : 21 +EQUAL : 16 EQUAL_EQUAL : FINISH : 1 FLOAT : 4 -FOR : 18 +FOR : 22 GREATER_THAN : GREATER_THAN_EQUAL : -ID : 4 5 6 7 8 9 11 12 13 27 31 36 -IF : 16 -INT : 5 -LEFT_PARENTESIS : 6 7 8 9 16 17 18 20 21 22 29 34 +ID : 4 5 6 7 8 13 15 16 17 31 35 40 +IF : 20 +INT : 9 +LEFT_PARENTESIS : 6 7 8 13 20 21 22 24 25 26 33 38 LENGTH : LENGTH_I : LENGTH_J : @@ -101,44 +105,45 @@ LESS_THAN : LESS_THAN_EQUAL : MATHEMATICAL_CONSTANT : MATHEMATICAL_EXPRESSION : -MATRIX : 7 +MATRIX : 11 MEAN : MEDIAN : -MINUS : 40 +MINUS : 44 MODE : NOT : NOT_EQUAL : OR : -PLUS : 37 -READ : 13 -RETURN : 9 -RIGHT_PARENTESIS : 6 7 8 9 16 17 18 20 21 22 29 34 -ROUTINE : 9 +PLUS : 41 +READ : 17 +RETURN : 13 +RIGHT_PARENTESIS : 6 7 8 13 20 21 22 24 25 26 33 38 +ROUTINE : 13 RREF : -SEMICOLON : 2 11 12 13 14 15 -SLASH : 39 -STAR : 38 +SEMICOLON : 2 15 16 17 18 19 +SLASH : 43 +STAR : 42 START : 1 -STRING : 14 26 -VECTOR : 6 -WHILE : 17 -WRITE : 14 15 +STRING : 18 30 +VECTOR : 10 +WHILE : 21 +WRITE : 18 19 error : Nonterminals, with rules where they appear -B : 1 2 9 11 12 13 14 15 16 16 17 17 18 18 18 24 -E : 12 15 20 21 21 22 22 22 34 37 38 39 40 -EL : 16 17 18 29 32 -ELSE_AUX : 16 -EL_AUX : 29 30 31 -E_AUX : 34 35 36 -INDICES : 12 27 36 +B : 1 2 13 15 16 17 18 19 20 20 21 21 22 22 22 28 +E : 16 19 24 25 25 26 26 26 38 41 42 43 44 +EL : 20 21 22 33 36 +ELSE_AUX : 20 +EL_AUX : 33 34 35 +E_AUX : 38 39 40 +INDICES : 16 31 40 PROGRAMA : 0 -R : 1 1 9 -V : 1 2 9 11 12 13 14 15 16 17 17 18 18 +R : 1 1 13 +T : 5 6 7 8 +V : 1 2 13 15 16 17 18 19 20 21 21 22 22 VARIABLES : 2 -WRITE_AUX : 14 15 26 27 +WRITE_AUX : 18 19 30 31 Parsing method: LALR @@ -146,11 +151,11 @@ state 0 (0) S' -> . PROGRAMA (1) PROGRAMA -> . R START V B FINISH R - (9) R -> . ROUTINE LEFT_PARENTESIS ID RIGHT_PARENTESIS V B RETURN R - (10) R -> . + (13) R -> . ROUTINE LEFT_PARENTESIS ID RIGHT_PARENTESIS V B RETURN R + (14) R -> . ROUTINE shift and go to state 3 - START reduce using rule 10 (R -> .) + START reduce using rule 14 (R -> .) PROGRAMA shift and go to state 1 R shift and go to state 2 @@ -170,7 +175,7 @@ state 2 state 3 - (9) R -> ROUTINE . LEFT_PARENTESIS ID RIGHT_PARENTESIS V B RETURN R + (13) R -> ROUTINE . LEFT_PARENTESIS ID RIGHT_PARENTESIS V B RETURN R LEFT_PARENTESIS shift and go to state 5 @@ -195,7 +200,7 @@ state 4 state 5 - (9) R -> ROUTINE LEFT_PARENTESIS . ID RIGHT_PARENTESIS V B RETURN R + (13) R -> ROUTINE LEFT_PARENTESIS . ID RIGHT_PARENTESIS V B RETURN R ID shift and go to state 8 @@ -203,15 +208,15 @@ state 5 state 6 (1) PROGRAMA -> R START V . B FINISH R - (11) B -> . CALL ID SEMICOLON V B - (12) B -> . ID INDICES EQUAL E SEMICOLON V B - (13) B -> . READ ID SEMICOLON V B - (14) B -> . WRITE STRING WRITE_AUX SEMICOLON V B - (15) B -> . WRITE E WRITE_AUX SEMICOLON V B - (16) B -> . IF LEFT_PARENTESIS EL RIGHT_PARENTESIS B ELSE_AUX ENDIF V B - (17) B -> . WHILE LEFT_PARENTESIS EL RIGHT_PARENTESIS V B ENDWHILE V B - (18) B -> . FOR LEFT_PARENTESIS EL COMA B RIGHT_PARENTESIS V B ENDFOR V B - (19) B -> . + (15) B -> . CALL ID SEMICOLON V B + (16) B -> . ID INDICES EQUAL E SEMICOLON V B + (17) B -> . READ ID SEMICOLON V B + (18) B -> . WRITE STRING WRITE_AUX SEMICOLON V B + (19) B -> . WRITE E WRITE_AUX SEMICOLON V B + (20) B -> . IF LEFT_PARENTESIS EL RIGHT_PARENTESIS B ELSE_AUX ENDIF V B + (21) B -> . WHILE LEFT_PARENTESIS EL RIGHT_PARENTESIS V B ENDWHILE V B + (22) B -> . FOR LEFT_PARENTESIS EL COMA B RIGHT_PARENTESIS V B ENDFOR V B + (23) B -> . CALL shift and go to state 10 ID shift and go to state 11 @@ -220,7 +225,7 @@ state 6 IF shift and go to state 14 WHILE shift and go to state 15 FOR shift and go to state 16 - FINISH reduce using rule 19 (B -> .) + FINISH reduce using rule 23 (B -> .) B shift and go to state 9 @@ -228,141 +233,156 @@ state 7 (2) V -> BE . VARIABLES SEMICOLON B V (4) VARIABLES -> . FLOAT ID - (5) VARIABLES -> . INT ID - (6) VARIABLES -> . VECTOR ID LEFT_PARENTESIS CONSTANT RIGHT_PARENTESIS - (7) VARIABLES -> . MATRIX ID LEFT_PARENTESIS CONSTANT COMA CONSTANT RIGHT_PARENTESIS - (8) VARIABLES -> . CUBE ID LEFT_PARENTESIS CONSTANT COMA CONSTANT COMA CONSTANT RIGHT_PARENTESIS + (5) VARIABLES -> . T ID + (6) VARIABLES -> . T ID LEFT_PARENTESIS CONSTANT RIGHT_PARENTESIS + (7) VARIABLES -> . T ID LEFT_PARENTESIS CONSTANT COMA CONSTANT RIGHT_PARENTESIS + (8) VARIABLES -> . T ID LEFT_PARENTESIS CONSTANT COMA CONSTANT COMA CONSTANT RIGHT_PARENTESIS + (9) T -> . INT + (10) T -> . VECTOR + (11) T -> . MATRIX + (12) T -> . CUBE FLOAT shift and go to state 18 - INT shift and go to state 19 - VECTOR shift and go to state 20 - MATRIX shift and go to state 21 - CUBE shift and go to state 22 + INT shift and go to state 20 + VECTOR shift and go to state 21 + MATRIX shift and go to state 22 + CUBE shift and go to state 23 VARIABLES shift and go to state 17 + T shift and go to state 19 state 8 - (9) R -> ROUTINE LEFT_PARENTESIS ID . RIGHT_PARENTESIS V B RETURN R + (13) R -> ROUTINE LEFT_PARENTESIS ID . RIGHT_PARENTESIS V B RETURN R - RIGHT_PARENTESIS shift and go to state 23 + RIGHT_PARENTESIS shift and go to state 24 state 9 (1) PROGRAMA -> R START V B . FINISH R - FINISH shift and go to state 24 + FINISH shift and go to state 25 state 10 - (11) B -> CALL . ID SEMICOLON V B + (15) B -> CALL . ID SEMICOLON V B - ID shift and go to state 25 + ID shift and go to state 26 state 11 - (12) B -> ID . INDICES EQUAL E SEMICOLON V B - (20) INDICES -> . LEFT_PARENTESIS E RIGHT_PARENTESIS - (21) INDICES -> . LEFT_PARENTESIS E COMA E RIGHT_PARENTESIS - (22) INDICES -> . LEFT_PARENTESIS E COMA E COMA E RIGHT_PARENTESIS - (23) INDICES -> . + (16) B -> ID . INDICES EQUAL E SEMICOLON V B + (24) INDICES -> . LEFT_PARENTESIS E RIGHT_PARENTESIS + (25) INDICES -> . LEFT_PARENTESIS E COMA E RIGHT_PARENTESIS + (26) INDICES -> . LEFT_PARENTESIS E COMA E COMA E RIGHT_PARENTESIS + (27) INDICES -> . - LEFT_PARENTESIS shift and go to state 27 - EQUAL reduce using rule 23 (INDICES -> .) + LEFT_PARENTESIS shift and go to state 28 + EQUAL reduce using rule 27 (INDICES -> .) - INDICES shift and go to state 26 + INDICES shift and go to state 27 state 12 - (13) B -> READ . ID SEMICOLON V B + (17) B -> READ . ID SEMICOLON V B - ID shift and go to state 28 + ID shift and go to state 29 state 13 - (14) B -> WRITE . STRING WRITE_AUX SEMICOLON V B - (15) B -> WRITE . E WRITE_AUX SEMICOLON V B - (34) E -> . LEFT_PARENTESIS E RIGHT_PARENTESIS E_AUX - (35) E -> . CONSTANT E_AUX - (36) E -> . ID INDICES E_AUX + (18) B -> WRITE . STRING WRITE_AUX SEMICOLON V B + (19) B -> WRITE . E WRITE_AUX SEMICOLON V B + (38) E -> . LEFT_PARENTESIS E RIGHT_PARENTESIS E_AUX + (39) E -> . CONSTANT E_AUX + (40) E -> . ID INDICES E_AUX - STRING shift and go to state 29 - LEFT_PARENTESIS shift and go to state 31 - CONSTANT shift and go to state 32 - ID shift and go to state 33 + STRING shift and go to state 30 + LEFT_PARENTESIS shift and go to state 32 + CONSTANT shift and go to state 33 + ID shift and go to state 34 - E shift and go to state 30 + E shift and go to state 31 state 14 - (16) B -> IF . LEFT_PARENTESIS EL RIGHT_PARENTESIS B ELSE_AUX ENDIF V B + (20) B -> IF . LEFT_PARENTESIS EL RIGHT_PARENTESIS B ELSE_AUX ENDIF V B - LEFT_PARENTESIS shift and go to state 34 + LEFT_PARENTESIS shift and go to state 35 state 15 - (17) B -> WHILE . LEFT_PARENTESIS EL RIGHT_PARENTESIS V B ENDWHILE V B + (21) B -> WHILE . LEFT_PARENTESIS EL RIGHT_PARENTESIS V B ENDWHILE V B - LEFT_PARENTESIS shift and go to state 35 + LEFT_PARENTESIS shift and go to state 36 state 16 - (18) B -> FOR . LEFT_PARENTESIS EL COMA B RIGHT_PARENTESIS V B ENDFOR V B + (22) B -> FOR . LEFT_PARENTESIS EL COMA B RIGHT_PARENTESIS V B ENDFOR V B - LEFT_PARENTESIS shift and go to state 36 + LEFT_PARENTESIS shift and go to state 37 state 17 (2) V -> BE VARIABLES . SEMICOLON B V - SEMICOLON shift and go to state 37 + SEMICOLON shift and go to state 38 state 18 (4) VARIABLES -> FLOAT . ID - ID shift and go to state 38 + ID shift and go to state 39 state 19 - (5) VARIABLES -> INT . ID + (5) VARIABLES -> T . ID + (6) VARIABLES -> T . ID LEFT_PARENTESIS CONSTANT RIGHT_PARENTESIS + (7) VARIABLES -> T . ID LEFT_PARENTESIS CONSTANT COMA CONSTANT RIGHT_PARENTESIS + (8) VARIABLES -> T . ID LEFT_PARENTESIS CONSTANT COMA CONSTANT COMA CONSTANT RIGHT_PARENTESIS - ID shift and go to state 39 + ID shift and go to state 40 state 20 - (6) VARIABLES -> VECTOR . ID LEFT_PARENTESIS CONSTANT RIGHT_PARENTESIS + (9) T -> INT . - ID shift and go to state 40 + ID reduce using rule 9 (T -> INT .) state 21 - (7) VARIABLES -> MATRIX . ID LEFT_PARENTESIS CONSTANT COMA CONSTANT RIGHT_PARENTESIS + (10) T -> VECTOR . - ID shift and go to state 41 + ID reduce using rule 10 (T -> VECTOR .) state 22 - (8) VARIABLES -> CUBE . ID LEFT_PARENTESIS CONSTANT COMA CONSTANT COMA CONSTANT RIGHT_PARENTESIS + (11) T -> MATRIX . - ID shift and go to state 42 + ID reduce using rule 11 (T -> MATRIX .) state 23 - (9) R -> ROUTINE LEFT_PARENTESIS ID RIGHT_PARENTESIS . V B RETURN R + (12) T -> CUBE . + + ID reduce using rule 12 (T -> CUBE .) + + +state 24 + + (13) R -> ROUTINE LEFT_PARENTESIS ID RIGHT_PARENTESIS . V B RETURN R (2) V -> . BE VARIABLES SEMICOLON B V (3) V -> . @@ -376,181 +396,181 @@ state 23 FOR reduce using rule 3 (V -> .) RETURN reduce using rule 3 (V -> .) - V shift and go to state 43 + V shift and go to state 41 -state 24 +state 25 (1) PROGRAMA -> R START V B FINISH . R - (9) R -> . ROUTINE LEFT_PARENTESIS ID RIGHT_PARENTESIS V B RETURN R - (10) R -> . + (13) R -> . ROUTINE LEFT_PARENTESIS ID RIGHT_PARENTESIS V B RETURN R + (14) R -> . ROUTINE shift and go to state 3 - $end reduce using rule 10 (R -> .) - - R shift and go to state 44 - -state 25 - - (11) B -> CALL ID . SEMICOLON V B - - SEMICOLON shift and go to state 45 + $end reduce using rule 14 (R -> .) + R shift and go to state 42 state 26 - (12) B -> ID INDICES . EQUAL E SEMICOLON V B + (15) B -> CALL ID . SEMICOLON V B - EQUAL shift and go to state 46 + SEMICOLON shift and go to state 43 state 27 - (20) INDICES -> LEFT_PARENTESIS . E RIGHT_PARENTESIS - (21) INDICES -> LEFT_PARENTESIS . E COMA E RIGHT_PARENTESIS - (22) INDICES -> LEFT_PARENTESIS . E COMA E COMA E RIGHT_PARENTESIS - (34) E -> . LEFT_PARENTESIS E RIGHT_PARENTESIS E_AUX - (35) E -> . CONSTANT E_AUX - (36) E -> . ID INDICES E_AUX + (16) B -> ID INDICES . EQUAL E SEMICOLON V B - LEFT_PARENTESIS shift and go to state 31 - CONSTANT shift and go to state 32 - ID shift and go to state 33 + EQUAL shift and go to state 44 - E shift and go to state 47 state 28 - (13) B -> READ ID . SEMICOLON V B + (24) INDICES -> LEFT_PARENTESIS . E RIGHT_PARENTESIS + (25) INDICES -> LEFT_PARENTESIS . E COMA E RIGHT_PARENTESIS + (26) INDICES -> LEFT_PARENTESIS . E COMA E COMA E RIGHT_PARENTESIS + (38) E -> . LEFT_PARENTESIS E RIGHT_PARENTESIS E_AUX + (39) E -> . CONSTANT E_AUX + (40) E -> . ID INDICES E_AUX - SEMICOLON shift and go to state 48 + LEFT_PARENTESIS shift and go to state 32 + CONSTANT shift and go to state 33 + ID shift and go to state 34 + E shift and go to state 45 state 29 - (14) B -> WRITE STRING . WRITE_AUX SEMICOLON V B - (26) WRITE_AUX -> . COMA STRING WRITE_AUX - (27) WRITE_AUX -> . COMA ID INDICES WRITE_AUX - (28) WRITE_AUX -> . + (17) B -> READ ID . SEMICOLON V B - COMA shift and go to state 50 - SEMICOLON reduce using rule 28 (WRITE_AUX -> .) + SEMICOLON shift and go to state 46 - WRITE_AUX shift and go to state 49 state 30 - (15) B -> WRITE E . WRITE_AUX SEMICOLON V B - (26) WRITE_AUX -> . COMA STRING WRITE_AUX - (27) WRITE_AUX -> . COMA ID INDICES WRITE_AUX - (28) WRITE_AUX -> . + (18) B -> WRITE STRING . WRITE_AUX SEMICOLON V B + (30) WRITE_AUX -> . COMA STRING WRITE_AUX + (31) WRITE_AUX -> . COMA ID INDICES WRITE_AUX + (32) WRITE_AUX -> . - COMA shift and go to state 50 - SEMICOLON reduce using rule 28 (WRITE_AUX -> .) + COMA shift and go to state 48 + SEMICOLON reduce using rule 32 (WRITE_AUX -> .) - WRITE_AUX shift and go to state 51 + WRITE_AUX shift and go to state 47 state 31 - (34) E -> LEFT_PARENTESIS . E RIGHT_PARENTESIS E_AUX - (34) E -> . LEFT_PARENTESIS E RIGHT_PARENTESIS E_AUX - (35) E -> . CONSTANT E_AUX - (36) E -> . ID INDICES E_AUX + (19) B -> WRITE E . WRITE_AUX SEMICOLON V B + (30) WRITE_AUX -> . COMA STRING WRITE_AUX + (31) WRITE_AUX -> . COMA ID INDICES WRITE_AUX + (32) WRITE_AUX -> . - LEFT_PARENTESIS shift and go to state 31 - CONSTANT shift and go to state 32 - ID shift and go to state 33 + COMA shift and go to state 48 + SEMICOLON reduce using rule 32 (WRITE_AUX -> .) - E shift and go to state 52 + WRITE_AUX shift and go to state 49 state 32 - (35) E -> CONSTANT . E_AUX - (37) E_AUX -> . PLUS E - (38) E_AUX -> . STAR E - (39) E_AUX -> . SLASH E - (40) E_AUX -> . MINUS E - (41) E_AUX -> . + (38) E -> LEFT_PARENTESIS . E RIGHT_PARENTESIS E_AUX + (38) E -> . LEFT_PARENTESIS E RIGHT_PARENTESIS E_AUX + (39) E -> . CONSTANT E_AUX + (40) E -> . ID INDICES E_AUX - PLUS shift and go to state 54 - STAR shift and go to state 55 - SLASH shift and go to state 56 - MINUS shift and go to state 57 - COMA reduce using rule 41 (E_AUX -> .) - SEMICOLON reduce using rule 41 (E_AUX -> .) - RIGHT_PARENTESIS reduce using rule 41 (E_AUX -> .) + LEFT_PARENTESIS shift and go to state 32 + CONSTANT shift and go to state 33 + ID shift and go to state 34 - E_AUX shift and go to state 53 + E shift and go to state 50 state 33 - (36) E -> ID . INDICES E_AUX - (20) INDICES -> . LEFT_PARENTESIS E RIGHT_PARENTESIS - (21) INDICES -> . LEFT_PARENTESIS E COMA E RIGHT_PARENTESIS - (22) INDICES -> . LEFT_PARENTESIS E COMA E COMA E RIGHT_PARENTESIS - (23) INDICES -> . + (39) E -> CONSTANT . E_AUX + (41) E_AUX -> . PLUS E + (42) E_AUX -> . STAR E + (43) E_AUX -> . SLASH E + (44) E_AUX -> . MINUS E + (45) E_AUX -> . - LEFT_PARENTESIS shift and go to state 27 - PLUS reduce using rule 23 (INDICES -> .) - STAR reduce using rule 23 (INDICES -> .) - SLASH reduce using rule 23 (INDICES -> .) - MINUS reduce using rule 23 (INDICES -> .) - COMA reduce using rule 23 (INDICES -> .) - SEMICOLON reduce using rule 23 (INDICES -> .) - RIGHT_PARENTESIS reduce using rule 23 (INDICES -> .) + PLUS shift and go to state 52 + STAR shift and go to state 53 + SLASH shift and go to state 54 + MINUS shift and go to state 55 + COMA reduce using rule 45 (E_AUX -> .) + SEMICOLON reduce using rule 45 (E_AUX -> .) + RIGHT_PARENTESIS reduce using rule 45 (E_AUX -> .) - INDICES shift and go to state 58 + E_AUX shift and go to state 51 state 34 - (16) B -> IF LEFT_PARENTESIS . EL RIGHT_PARENTESIS B ELSE_AUX ENDIF V B - (29) EL -> . LEFT_PARENTESIS EL RIGHT_PARENTESIS EL_AUX - (30) EL -> . CONSTANT EL_AUX - (31) EL -> . ID EL_AUX + (40) E -> ID . INDICES E_AUX + (24) INDICES -> . LEFT_PARENTESIS E RIGHT_PARENTESIS + (25) INDICES -> . LEFT_PARENTESIS E COMA E RIGHT_PARENTESIS + (26) INDICES -> . LEFT_PARENTESIS E COMA E COMA E RIGHT_PARENTESIS + (27) INDICES -> . - LEFT_PARENTESIS shift and go to state 59 - CONSTANT shift and go to state 61 - ID shift and go to state 62 + LEFT_PARENTESIS shift and go to state 28 + PLUS reduce using rule 27 (INDICES -> .) + STAR reduce using rule 27 (INDICES -> .) + SLASH reduce using rule 27 (INDICES -> .) + MINUS reduce using rule 27 (INDICES -> .) + COMA reduce using rule 27 (INDICES -> .) + SEMICOLON reduce using rule 27 (INDICES -> .) + RIGHT_PARENTESIS reduce using rule 27 (INDICES -> .) - EL shift and go to state 60 + INDICES shift and go to state 56 state 35 - (17) B -> WHILE LEFT_PARENTESIS . EL RIGHT_PARENTESIS V B ENDWHILE V B - (29) EL -> . LEFT_PARENTESIS EL RIGHT_PARENTESIS EL_AUX - (30) EL -> . CONSTANT EL_AUX - (31) EL -> . ID EL_AUX + (20) B -> IF LEFT_PARENTESIS . EL RIGHT_PARENTESIS B ELSE_AUX ENDIF V B + (33) EL -> . LEFT_PARENTESIS EL RIGHT_PARENTESIS EL_AUX + (34) EL -> . CONSTANT EL_AUX + (35) EL -> . ID EL_AUX - LEFT_PARENTESIS shift and go to state 59 - CONSTANT shift and go to state 61 - ID shift and go to state 62 + LEFT_PARENTESIS shift and go to state 57 + CONSTANT shift and go to state 59 + ID shift and go to state 60 - EL shift and go to state 63 + EL shift and go to state 58 state 36 - (18) B -> FOR LEFT_PARENTESIS . EL COMA B RIGHT_PARENTESIS V B ENDFOR V B - (29) EL -> . LEFT_PARENTESIS EL RIGHT_PARENTESIS EL_AUX - (30) EL -> . CONSTANT EL_AUX - (31) EL -> . ID EL_AUX + (21) B -> WHILE LEFT_PARENTESIS . EL RIGHT_PARENTESIS V B ENDWHILE V B + (33) EL -> . LEFT_PARENTESIS EL RIGHT_PARENTESIS EL_AUX + (34) EL -> . CONSTANT EL_AUX + (35) EL -> . ID EL_AUX - LEFT_PARENTESIS shift and go to state 59 - CONSTANT shift and go to state 61 - ID shift and go to state 62 + LEFT_PARENTESIS shift and go to state 57 + CONSTANT shift and go to state 59 + ID shift and go to state 60 - EL shift and go to state 64 + EL shift and go to state 61 state 37 + (22) B -> FOR LEFT_PARENTESIS . EL COMA B RIGHT_PARENTESIS V B ENDFOR V B + (33) EL -> . LEFT_PARENTESIS EL RIGHT_PARENTESIS EL_AUX + (34) EL -> . CONSTANT EL_AUX + (35) EL -> . ID EL_AUX + + LEFT_PARENTESIS shift and go to state 57 + CONSTANT shift and go to state 59 + ID shift and go to state 60 + + EL shift and go to state 62 + +state 38 + (2) V -> BE VARIABLES SEMICOLON . B V - (11) B -> . CALL ID SEMICOLON V B - (12) B -> . ID INDICES EQUAL E SEMICOLON V B - (13) B -> . READ ID SEMICOLON V B - (14) B -> . WRITE STRING WRITE_AUX SEMICOLON V B - (15) B -> . WRITE E WRITE_AUX SEMICOLON V B - (16) B -> . IF LEFT_PARENTESIS EL RIGHT_PARENTESIS B ELSE_AUX ENDIF V B - (17) B -> . WHILE LEFT_PARENTESIS EL RIGHT_PARENTESIS V B ENDWHILE V B - (18) B -> . FOR LEFT_PARENTESIS EL COMA B RIGHT_PARENTESIS V B ENDFOR V B - (19) B -> . + (15) B -> . CALL ID SEMICOLON V B + (16) B -> . ID INDICES EQUAL E SEMICOLON V B + (17) B -> . READ ID SEMICOLON V B + (18) B -> . WRITE STRING WRITE_AUX SEMICOLON V B + (19) B -> . WRITE E WRITE_AUX SEMICOLON V B + (20) B -> . IF LEFT_PARENTESIS EL RIGHT_PARENTESIS B ELSE_AUX ENDIF V B + (21) B -> . WHILE LEFT_PARENTESIS EL RIGHT_PARENTESIS V B ENDWHILE V B + (22) B -> . FOR LEFT_PARENTESIS EL COMA B RIGHT_PARENTESIS V B ENDFOR V B + (23) B -> . ! shift/reduce conflict for CALL resolved as shift ! shift/reduce conflict for ID resolved as shift @@ -566,72 +586,55 @@ state 37 IF shift and go to state 14 WHILE shift and go to state 15 FOR shift and go to state 16 - BE reduce using rule 19 (B -> .) - FINISH reduce using rule 19 (B -> .) - RETURN reduce using rule 19 (B -> .) - ELSE reduce using rule 19 (B -> .) - ENDIF reduce using rule 19 (B -> .) - RIGHT_PARENTESIS reduce using rule 19 (B -> .) - ENDWHILE reduce using rule 19 (B -> .) - ENDFOR reduce using rule 19 (B -> .) - - ! CALL [ reduce using rule 19 (B -> .) ] - ! ID [ reduce using rule 19 (B -> .) ] - ! READ [ reduce using rule 19 (B -> .) ] - ! WRITE [ reduce using rule 19 (B -> .) ] - ! IF [ reduce using rule 19 (B -> .) ] - ! WHILE [ reduce using rule 19 (B -> .) ] - ! FOR [ reduce using rule 19 (B -> .) ] - - B shift and go to state 65 + BE reduce using rule 23 (B -> .) + FINISH reduce using rule 23 (B -> .) + RETURN reduce using rule 23 (B -> .) + ELSE reduce using rule 23 (B -> .) + ENDIF reduce using rule 23 (B -> .) + RIGHT_PARENTESIS reduce using rule 23 (B -> .) + ENDWHILE reduce using rule 23 (B -> .) + ENDFOR reduce using rule 23 (B -> .) + + ! CALL [ reduce using rule 23 (B -> .) ] + ! ID [ reduce using rule 23 (B -> .) ] + ! READ [ reduce using rule 23 (B -> .) ] + ! WRITE [ reduce using rule 23 (B -> .) ] + ! IF [ reduce using rule 23 (B -> .) ] + ! WHILE [ reduce using rule 23 (B -> .) ] + ! FOR [ reduce using rule 23 (B -> .) ] + + B shift and go to state 63 -state 38 +state 39 (4) VARIABLES -> FLOAT ID . SEMICOLON reduce using rule 4 (VARIABLES -> FLOAT ID .) -state 39 - - (5) VARIABLES -> INT ID . - - SEMICOLON reduce using rule 5 (VARIABLES -> INT ID .) - - state 40 - (6) VARIABLES -> VECTOR ID . LEFT_PARENTESIS CONSTANT RIGHT_PARENTESIS + (5) VARIABLES -> T ID . + (6) VARIABLES -> T ID . LEFT_PARENTESIS CONSTANT RIGHT_PARENTESIS + (7) VARIABLES -> T ID . LEFT_PARENTESIS CONSTANT COMA CONSTANT RIGHT_PARENTESIS + (8) VARIABLES -> T ID . LEFT_PARENTESIS CONSTANT COMA CONSTANT COMA CONSTANT RIGHT_PARENTESIS - LEFT_PARENTESIS shift and go to state 66 + SEMICOLON reduce using rule 5 (VARIABLES -> T ID .) + LEFT_PARENTESIS shift and go to state 64 state 41 - (7) VARIABLES -> MATRIX ID . LEFT_PARENTESIS CONSTANT COMA CONSTANT RIGHT_PARENTESIS - - LEFT_PARENTESIS shift and go to state 67 - - -state 42 - - (8) VARIABLES -> CUBE ID . LEFT_PARENTESIS CONSTANT COMA CONSTANT COMA CONSTANT RIGHT_PARENTESIS - - LEFT_PARENTESIS shift and go to state 68 - - -state 43 - - (9) R -> ROUTINE LEFT_PARENTESIS ID RIGHT_PARENTESIS V . B RETURN R - (11) B -> . CALL ID SEMICOLON V B - (12) B -> . ID INDICES EQUAL E SEMICOLON V B - (13) B -> . READ ID SEMICOLON V B - (14) B -> . WRITE STRING WRITE_AUX SEMICOLON V B - (15) B -> . WRITE E WRITE_AUX SEMICOLON V B - (16) B -> . IF LEFT_PARENTESIS EL RIGHT_PARENTESIS B ELSE_AUX ENDIF V B - (17) B -> . WHILE LEFT_PARENTESIS EL RIGHT_PARENTESIS V B ENDWHILE V B - (18) B -> . FOR LEFT_PARENTESIS EL COMA B RIGHT_PARENTESIS V B ENDFOR V B - (19) B -> . + (13) R -> ROUTINE LEFT_PARENTESIS ID RIGHT_PARENTESIS V . B RETURN R + (15) B -> . CALL ID SEMICOLON V B + (16) B -> . ID INDICES EQUAL E SEMICOLON V B + (17) B -> . READ ID SEMICOLON V B + (18) B -> . WRITE STRING WRITE_AUX SEMICOLON V B + (19) B -> . WRITE E WRITE_AUX SEMICOLON V B + (20) B -> . IF LEFT_PARENTESIS EL RIGHT_PARENTESIS B ELSE_AUX ENDIF V B + (21) B -> . WHILE LEFT_PARENTESIS EL RIGHT_PARENTESIS V B ENDWHILE V B + (22) B -> . FOR LEFT_PARENTESIS EL COMA B RIGHT_PARENTESIS V B ENDFOR V B + (23) B -> . CALL shift and go to state 10 ID shift and go to state 11 @@ -640,20 +643,20 @@ state 43 IF shift and go to state 14 WHILE shift and go to state 15 FOR shift and go to state 16 - RETURN reduce using rule 19 (B -> .) + RETURN reduce using rule 23 (B -> .) - B shift and go to state 69 + B shift and go to state 65 -state 44 +state 42 (1) PROGRAMA -> R START V B FINISH R . $end reduce using rule 1 (PROGRAMA -> R START V B FINISH R .) -state 45 +state 43 - (11) B -> CALL ID SEMICOLON . V B + (15) B -> CALL ID SEMICOLON . V B (2) V -> . BE VARIABLES SEMICOLON B V (3) V -> . @@ -676,34 +679,34 @@ state 45 ! BE [ reduce using rule 3 (V -> .) ] - V shift and go to state 70 + V shift and go to state 66 -state 46 +state 44 - (12) B -> ID INDICES EQUAL . E SEMICOLON V B - (34) E -> . LEFT_PARENTESIS E RIGHT_PARENTESIS E_AUX - (35) E -> . CONSTANT E_AUX - (36) E -> . ID INDICES E_AUX + (16) B -> ID INDICES EQUAL . E SEMICOLON V B + (38) E -> . LEFT_PARENTESIS E RIGHT_PARENTESIS E_AUX + (39) E -> . CONSTANT E_AUX + (40) E -> . ID INDICES E_AUX - LEFT_PARENTESIS shift and go to state 31 - CONSTANT shift and go to state 32 - ID shift and go to state 33 + LEFT_PARENTESIS shift and go to state 32 + CONSTANT shift and go to state 33 + ID shift and go to state 34 - E shift and go to state 71 + E shift and go to state 67 -state 47 +state 45 - (20) INDICES -> LEFT_PARENTESIS E . RIGHT_PARENTESIS - (21) INDICES -> LEFT_PARENTESIS E . COMA E RIGHT_PARENTESIS - (22) INDICES -> LEFT_PARENTESIS E . COMA E COMA E RIGHT_PARENTESIS + (24) INDICES -> LEFT_PARENTESIS E . RIGHT_PARENTESIS + (25) INDICES -> LEFT_PARENTESIS E . COMA E RIGHT_PARENTESIS + (26) INDICES -> LEFT_PARENTESIS E . COMA E COMA E RIGHT_PARENTESIS - RIGHT_PARENTESIS shift and go to state 72 - COMA shift and go to state 73 + RIGHT_PARENTESIS shift and go to state 68 + COMA shift and go to state 69 -state 48 +state 46 - (13) B -> READ ID SEMICOLON . V B + (17) B -> READ ID SEMICOLON . V B (2) V -> . BE VARIABLES SEMICOLON B V (3) V -> . @@ -726,178 +729,178 @@ state 48 ! BE [ reduce using rule 3 (V -> .) ] - V shift and go to state 74 + V shift and go to state 70 + +state 47 + + (18) B -> WRITE STRING WRITE_AUX . SEMICOLON V B + + SEMICOLON shift and go to state 71 + + +state 48 + + (30) WRITE_AUX -> COMA . STRING WRITE_AUX + (31) WRITE_AUX -> COMA . ID INDICES WRITE_AUX + + STRING shift and go to state 72 + ID shift and go to state 73 + state 49 - (14) B -> WRITE STRING WRITE_AUX . SEMICOLON V B + (19) B -> WRITE E WRITE_AUX . SEMICOLON V B - SEMICOLON shift and go to state 75 + SEMICOLON shift and go to state 74 state 50 - (26) WRITE_AUX -> COMA . STRING WRITE_AUX - (27) WRITE_AUX -> COMA . ID INDICES WRITE_AUX + (38) E -> LEFT_PARENTESIS E . RIGHT_PARENTESIS E_AUX - STRING shift and go to state 76 - ID shift and go to state 77 + RIGHT_PARENTESIS shift and go to state 75 state 51 - (15) B -> WRITE E WRITE_AUX . SEMICOLON V B + (39) E -> CONSTANT E_AUX . - SEMICOLON shift and go to state 78 + COMA reduce using rule 39 (E -> CONSTANT E_AUX .) + SEMICOLON reduce using rule 39 (E -> CONSTANT E_AUX .) + RIGHT_PARENTESIS reduce using rule 39 (E -> CONSTANT E_AUX .) state 52 - (34) E -> LEFT_PARENTESIS E . RIGHT_PARENTESIS E_AUX + (41) E_AUX -> PLUS . E + (38) E -> . LEFT_PARENTESIS E RIGHT_PARENTESIS E_AUX + (39) E -> . CONSTANT E_AUX + (40) E -> . ID INDICES E_AUX - RIGHT_PARENTESIS shift and go to state 79 + LEFT_PARENTESIS shift and go to state 32 + CONSTANT shift and go to state 33 + ID shift and go to state 34 + E shift and go to state 76 state 53 - (35) E -> CONSTANT E_AUX . + (42) E_AUX -> STAR . E + (38) E -> . LEFT_PARENTESIS E RIGHT_PARENTESIS E_AUX + (39) E -> . CONSTANT E_AUX + (40) E -> . ID INDICES E_AUX - COMA reduce using rule 35 (E -> CONSTANT E_AUX .) - SEMICOLON reduce using rule 35 (E -> CONSTANT E_AUX .) - RIGHT_PARENTESIS reduce using rule 35 (E -> CONSTANT E_AUX .) + LEFT_PARENTESIS shift and go to state 32 + CONSTANT shift and go to state 33 + ID shift and go to state 34 + E shift and go to state 77 state 54 - (37) E_AUX -> PLUS . E - (34) E -> . LEFT_PARENTESIS E RIGHT_PARENTESIS E_AUX - (35) E -> . CONSTANT E_AUX - (36) E -> . ID INDICES E_AUX + (43) E_AUX -> SLASH . E + (38) E -> . LEFT_PARENTESIS E RIGHT_PARENTESIS E_AUX + (39) E -> . CONSTANT E_AUX + (40) E -> . ID INDICES E_AUX - LEFT_PARENTESIS shift and go to state 31 - CONSTANT shift and go to state 32 - ID shift and go to state 33 + LEFT_PARENTESIS shift and go to state 32 + CONSTANT shift and go to state 33 + ID shift and go to state 34 - E shift and go to state 80 + E shift and go to state 78 state 55 - (38) E_AUX -> STAR . E - (34) E -> . LEFT_PARENTESIS E RIGHT_PARENTESIS E_AUX - (35) E -> . CONSTANT E_AUX - (36) E -> . ID INDICES E_AUX + (44) E_AUX -> MINUS . E + (38) E -> . LEFT_PARENTESIS E RIGHT_PARENTESIS E_AUX + (39) E -> . CONSTANT E_AUX + (40) E -> . ID INDICES E_AUX - LEFT_PARENTESIS shift and go to state 31 - CONSTANT shift and go to state 32 - ID shift and go to state 33 + LEFT_PARENTESIS shift and go to state 32 + CONSTANT shift and go to state 33 + ID shift and go to state 34 - E shift and go to state 81 + E shift and go to state 79 state 56 - (39) E_AUX -> SLASH . E - (34) E -> . LEFT_PARENTESIS E RIGHT_PARENTESIS E_AUX - (35) E -> . CONSTANT E_AUX - (36) E -> . ID INDICES E_AUX + (40) E -> ID INDICES . E_AUX + (41) E_AUX -> . PLUS E + (42) E_AUX -> . STAR E + (43) E_AUX -> . SLASH E + (44) E_AUX -> . MINUS E + (45) E_AUX -> . - LEFT_PARENTESIS shift and go to state 31 - CONSTANT shift and go to state 32 - ID shift and go to state 33 + PLUS shift and go to state 52 + STAR shift and go to state 53 + SLASH shift and go to state 54 + MINUS shift and go to state 55 + COMA reduce using rule 45 (E_AUX -> .) + SEMICOLON reduce using rule 45 (E_AUX -> .) + RIGHT_PARENTESIS reduce using rule 45 (E_AUX -> .) - E shift and go to state 82 + E_AUX shift and go to state 80 state 57 - (40) E_AUX -> MINUS . E - (34) E -> . LEFT_PARENTESIS E RIGHT_PARENTESIS E_AUX - (35) E -> . CONSTANT E_AUX - (36) E -> . ID INDICES E_AUX + (33) EL -> LEFT_PARENTESIS . EL RIGHT_PARENTESIS EL_AUX + (33) EL -> . LEFT_PARENTESIS EL RIGHT_PARENTESIS EL_AUX + (34) EL -> . CONSTANT EL_AUX + (35) EL -> . ID EL_AUX - LEFT_PARENTESIS shift and go to state 31 - CONSTANT shift and go to state 32 - ID shift and go to state 33 + LEFT_PARENTESIS shift and go to state 57 + CONSTANT shift and go to state 59 + ID shift and go to state 60 - E shift and go to state 83 + EL shift and go to state 81 state 58 - (36) E -> ID INDICES . E_AUX - (37) E_AUX -> . PLUS E - (38) E_AUX -> . STAR E - (39) E_AUX -> . SLASH E - (40) E_AUX -> . MINUS E - (41) E_AUX -> . + (20) B -> IF LEFT_PARENTESIS EL . RIGHT_PARENTESIS B ELSE_AUX ENDIF V B - PLUS shift and go to state 54 - STAR shift and go to state 55 - SLASH shift and go to state 56 - MINUS shift and go to state 57 - COMA reduce using rule 41 (E_AUX -> .) - SEMICOLON reduce using rule 41 (E_AUX -> .) - RIGHT_PARENTESIS reduce using rule 41 (E_AUX -> .) + RIGHT_PARENTESIS shift and go to state 82 - E_AUX shift and go to state 84 state 59 - (29) EL -> LEFT_PARENTESIS . EL RIGHT_PARENTESIS EL_AUX - (29) EL -> . LEFT_PARENTESIS EL RIGHT_PARENTESIS EL_AUX - (30) EL -> . CONSTANT EL_AUX - (31) EL -> . ID EL_AUX + (34) EL -> CONSTANT . EL_AUX + (36) EL_AUX -> . COMPARISON EL + (37) EL_AUX -> . - LEFT_PARENTESIS shift and go to state 59 - CONSTANT shift and go to state 61 - ID shift and go to state 62 + COMPARISON shift and go to state 84 + RIGHT_PARENTESIS reduce using rule 37 (EL_AUX -> .) + COMA reduce using rule 37 (EL_AUX -> .) - EL shift and go to state 85 + EL_AUX shift and go to state 83 state 60 - (16) B -> IF LEFT_PARENTESIS EL . RIGHT_PARENTESIS B ELSE_AUX ENDIF V B + (35) EL -> ID . EL_AUX + (36) EL_AUX -> . COMPARISON EL + (37) EL_AUX -> . - RIGHT_PARENTESIS shift and go to state 86 + COMPARISON shift and go to state 84 + RIGHT_PARENTESIS reduce using rule 37 (EL_AUX -> .) + COMA reduce using rule 37 (EL_AUX -> .) + EL_AUX shift and go to state 85 state 61 - (30) EL -> CONSTANT . EL_AUX - (32) EL_AUX -> . COMPARISON EL - (33) EL_AUX -> . + (21) B -> WHILE LEFT_PARENTESIS EL . RIGHT_PARENTESIS V B ENDWHILE V B - COMPARISON shift and go to state 88 - RIGHT_PARENTESIS reduce using rule 33 (EL_AUX -> .) - COMA reduce using rule 33 (EL_AUX -> .) + RIGHT_PARENTESIS shift and go to state 86 - EL_AUX shift and go to state 87 state 62 - (31) EL -> ID . EL_AUX - (32) EL_AUX -> . COMPARISON EL - (33) EL_AUX -> . + (22) B -> FOR LEFT_PARENTESIS EL . COMA B RIGHT_PARENTESIS V B ENDFOR V B - COMPARISON shift and go to state 88 - RIGHT_PARENTESIS reduce using rule 33 (EL_AUX -> .) - COMA reduce using rule 33 (EL_AUX -> .) + COMA shift and go to state 87 - EL_AUX shift and go to state 89 state 63 - (17) B -> WHILE LEFT_PARENTESIS EL . RIGHT_PARENTESIS V B ENDWHILE V B - - RIGHT_PARENTESIS shift and go to state 90 - - -state 64 - - (18) B -> FOR LEFT_PARENTESIS EL . COMA B RIGHT_PARENTESIS V B ENDFOR V B - - COMA shift and go to state 91 - - -state 65 - (2) V -> BE VARIABLES SEMICOLON B . V (2) V -> . BE VARIABLES SEMICOLON B V (3) V -> . @@ -921,48 +924,36 @@ state 65 ! BE [ reduce using rule 3 (V -> .) ] - V shift and go to state 92 - -state 66 - - (6) VARIABLES -> VECTOR ID LEFT_PARENTESIS . CONSTANT RIGHT_PARENTESIS - - CONSTANT shift and go to state 93 + V shift and go to state 88 +state 64 -state 67 - - (7) VARIABLES -> MATRIX ID LEFT_PARENTESIS . CONSTANT COMA CONSTANT RIGHT_PARENTESIS - - CONSTANT shift and go to state 94 - - -state 68 - - (8) VARIABLES -> CUBE ID LEFT_PARENTESIS . CONSTANT COMA CONSTANT COMA CONSTANT RIGHT_PARENTESIS + (6) VARIABLES -> T ID LEFT_PARENTESIS . CONSTANT RIGHT_PARENTESIS + (7) VARIABLES -> T ID LEFT_PARENTESIS . CONSTANT COMA CONSTANT RIGHT_PARENTESIS + (8) VARIABLES -> T ID LEFT_PARENTESIS . CONSTANT COMA CONSTANT COMA CONSTANT RIGHT_PARENTESIS - CONSTANT shift and go to state 95 + CONSTANT shift and go to state 89 -state 69 +state 65 - (9) R -> ROUTINE LEFT_PARENTESIS ID RIGHT_PARENTESIS V B . RETURN R + (13) R -> ROUTINE LEFT_PARENTESIS ID RIGHT_PARENTESIS V B . RETURN R - RETURN shift and go to state 96 + RETURN shift and go to state 90 -state 70 +state 66 - (11) B -> CALL ID SEMICOLON V . B - (11) B -> . CALL ID SEMICOLON V B - (12) B -> . ID INDICES EQUAL E SEMICOLON V B - (13) B -> . READ ID SEMICOLON V B - (14) B -> . WRITE STRING WRITE_AUX SEMICOLON V B - (15) B -> . WRITE E WRITE_AUX SEMICOLON V B - (16) B -> . IF LEFT_PARENTESIS EL RIGHT_PARENTESIS B ELSE_AUX ENDIF V B - (17) B -> . WHILE LEFT_PARENTESIS EL RIGHT_PARENTESIS V B ENDWHILE V B - (18) B -> . FOR LEFT_PARENTESIS EL COMA B RIGHT_PARENTESIS V B ENDFOR V B - (19) B -> . + (15) B -> CALL ID SEMICOLON V . B + (15) B -> . CALL ID SEMICOLON V B + (16) B -> . ID INDICES EQUAL E SEMICOLON V B + (17) B -> . READ ID SEMICOLON V B + (18) B -> . WRITE STRING WRITE_AUX SEMICOLON V B + (19) B -> . WRITE E WRITE_AUX SEMICOLON V B + (20) B -> . IF LEFT_PARENTESIS EL RIGHT_PARENTESIS B ELSE_AUX ENDIF V B + (21) B -> . WHILE LEFT_PARENTESIS EL RIGHT_PARENTESIS V B ENDWHILE V B + (22) B -> . FOR LEFT_PARENTESIS EL COMA B RIGHT_PARENTESIS V B ENDFOR V B + (23) B -> . ! shift/reduce conflict for CALL resolved as shift ! shift/reduce conflict for ID resolved as shift @@ -978,72 +969,72 @@ state 70 IF shift and go to state 14 WHILE shift and go to state 15 FOR shift and go to state 16 - BE reduce using rule 19 (B -> .) - FINISH reduce using rule 19 (B -> .) - RETURN reduce using rule 19 (B -> .) - ELSE reduce using rule 19 (B -> .) - ENDIF reduce using rule 19 (B -> .) - RIGHT_PARENTESIS reduce using rule 19 (B -> .) - ENDWHILE reduce using rule 19 (B -> .) - ENDFOR reduce using rule 19 (B -> .) - - ! CALL [ reduce using rule 19 (B -> .) ] - ! ID [ reduce using rule 19 (B -> .) ] - ! READ [ reduce using rule 19 (B -> .) ] - ! WRITE [ reduce using rule 19 (B -> .) ] - ! IF [ reduce using rule 19 (B -> .) ] - ! WHILE [ reduce using rule 19 (B -> .) ] - ! FOR [ reduce using rule 19 (B -> .) ] - - B shift and go to state 97 + BE reduce using rule 23 (B -> .) + FINISH reduce using rule 23 (B -> .) + RETURN reduce using rule 23 (B -> .) + ELSE reduce using rule 23 (B -> .) + ENDIF reduce using rule 23 (B -> .) + RIGHT_PARENTESIS reduce using rule 23 (B -> .) + ENDWHILE reduce using rule 23 (B -> .) + ENDFOR reduce using rule 23 (B -> .) + + ! CALL [ reduce using rule 23 (B -> .) ] + ! ID [ reduce using rule 23 (B -> .) ] + ! READ [ reduce using rule 23 (B -> .) ] + ! WRITE [ reduce using rule 23 (B -> .) ] + ! IF [ reduce using rule 23 (B -> .) ] + ! WHILE [ reduce using rule 23 (B -> .) ] + ! FOR [ reduce using rule 23 (B -> .) ] + + B shift and go to state 91 -state 71 +state 67 - (12) B -> ID INDICES EQUAL E . SEMICOLON V B + (16) B -> ID INDICES EQUAL E . SEMICOLON V B - SEMICOLON shift and go to state 98 + SEMICOLON shift and go to state 92 -state 72 +state 68 - (20) INDICES -> LEFT_PARENTESIS E RIGHT_PARENTESIS . + (24) INDICES -> LEFT_PARENTESIS E RIGHT_PARENTESIS . - EQUAL reduce using rule 20 (INDICES -> LEFT_PARENTESIS E RIGHT_PARENTESIS .) - PLUS reduce using rule 20 (INDICES -> LEFT_PARENTESIS E RIGHT_PARENTESIS .) - STAR reduce using rule 20 (INDICES -> LEFT_PARENTESIS E RIGHT_PARENTESIS .) - SLASH reduce using rule 20 (INDICES -> LEFT_PARENTESIS E RIGHT_PARENTESIS .) - MINUS reduce using rule 20 (INDICES -> LEFT_PARENTESIS E RIGHT_PARENTESIS .) - COMA reduce using rule 20 (INDICES -> LEFT_PARENTESIS E RIGHT_PARENTESIS .) - SEMICOLON reduce using rule 20 (INDICES -> LEFT_PARENTESIS E RIGHT_PARENTESIS .) - RIGHT_PARENTESIS reduce using rule 20 (INDICES -> LEFT_PARENTESIS E RIGHT_PARENTESIS .) + EQUAL reduce using rule 24 (INDICES -> LEFT_PARENTESIS E RIGHT_PARENTESIS .) + PLUS reduce using rule 24 (INDICES -> LEFT_PARENTESIS E RIGHT_PARENTESIS .) + STAR reduce using rule 24 (INDICES -> LEFT_PARENTESIS E RIGHT_PARENTESIS .) + SLASH reduce using rule 24 (INDICES -> LEFT_PARENTESIS E RIGHT_PARENTESIS .) + MINUS reduce using rule 24 (INDICES -> LEFT_PARENTESIS E RIGHT_PARENTESIS .) + COMA reduce using rule 24 (INDICES -> LEFT_PARENTESIS E RIGHT_PARENTESIS .) + SEMICOLON reduce using rule 24 (INDICES -> LEFT_PARENTESIS E RIGHT_PARENTESIS .) + RIGHT_PARENTESIS reduce using rule 24 (INDICES -> LEFT_PARENTESIS E RIGHT_PARENTESIS .) -state 73 +state 69 - (21) INDICES -> LEFT_PARENTESIS E COMA . E RIGHT_PARENTESIS - (22) INDICES -> LEFT_PARENTESIS E COMA . E COMA E RIGHT_PARENTESIS - (34) E -> . LEFT_PARENTESIS E RIGHT_PARENTESIS E_AUX - (35) E -> . CONSTANT E_AUX - (36) E -> . ID INDICES E_AUX + (25) INDICES -> LEFT_PARENTESIS E COMA . E RIGHT_PARENTESIS + (26) INDICES -> LEFT_PARENTESIS E COMA . E COMA E RIGHT_PARENTESIS + (38) E -> . LEFT_PARENTESIS E RIGHT_PARENTESIS E_AUX + (39) E -> . CONSTANT E_AUX + (40) E -> . ID INDICES E_AUX - LEFT_PARENTESIS shift and go to state 31 - CONSTANT shift and go to state 32 - ID shift and go to state 33 + LEFT_PARENTESIS shift and go to state 32 + CONSTANT shift and go to state 33 + ID shift and go to state 34 - E shift and go to state 99 + E shift and go to state 93 -state 74 +state 70 - (13) B -> READ ID SEMICOLON V . B - (11) B -> . CALL ID SEMICOLON V B - (12) B -> . ID INDICES EQUAL E SEMICOLON V B - (13) B -> . READ ID SEMICOLON V B - (14) B -> . WRITE STRING WRITE_AUX SEMICOLON V B - (15) B -> . WRITE E WRITE_AUX SEMICOLON V B - (16) B -> . IF LEFT_PARENTESIS EL RIGHT_PARENTESIS B ELSE_AUX ENDIF V B - (17) B -> . WHILE LEFT_PARENTESIS EL RIGHT_PARENTESIS V B ENDWHILE V B - (18) B -> . FOR LEFT_PARENTESIS EL COMA B RIGHT_PARENTESIS V B ENDFOR V B - (19) B -> . + (17) B -> READ ID SEMICOLON V . B + (15) B -> . CALL ID SEMICOLON V B + (16) B -> . ID INDICES EQUAL E SEMICOLON V B + (17) B -> . READ ID SEMICOLON V B + (18) B -> . WRITE STRING WRITE_AUX SEMICOLON V B + (19) B -> . WRITE E WRITE_AUX SEMICOLON V B + (20) B -> . IF LEFT_PARENTESIS EL RIGHT_PARENTESIS B ELSE_AUX ENDIF V B + (21) B -> . WHILE LEFT_PARENTESIS EL RIGHT_PARENTESIS V B ENDWHILE V B + (22) B -> . FOR LEFT_PARENTESIS EL COMA B RIGHT_PARENTESIS V B ENDFOR V B + (23) B -> . ! shift/reduce conflict for CALL resolved as shift ! shift/reduce conflict for ID resolved as shift @@ -1059,28 +1050,28 @@ state 74 IF shift and go to state 14 WHILE shift and go to state 15 FOR shift and go to state 16 - BE reduce using rule 19 (B -> .) - FINISH reduce using rule 19 (B -> .) - RETURN reduce using rule 19 (B -> .) - ELSE reduce using rule 19 (B -> .) - ENDIF reduce using rule 19 (B -> .) - RIGHT_PARENTESIS reduce using rule 19 (B -> .) - ENDWHILE reduce using rule 19 (B -> .) - ENDFOR reduce using rule 19 (B -> .) - - ! CALL [ reduce using rule 19 (B -> .) ] - ! ID [ reduce using rule 19 (B -> .) ] - ! READ [ reduce using rule 19 (B -> .) ] - ! WRITE [ reduce using rule 19 (B -> .) ] - ! IF [ reduce using rule 19 (B -> .) ] - ! WHILE [ reduce using rule 19 (B -> .) ] - ! FOR [ reduce using rule 19 (B -> .) ] - - B shift and go to state 100 + BE reduce using rule 23 (B -> .) + FINISH reduce using rule 23 (B -> .) + RETURN reduce using rule 23 (B -> .) + ELSE reduce using rule 23 (B -> .) + ENDIF reduce using rule 23 (B -> .) + RIGHT_PARENTESIS reduce using rule 23 (B -> .) + ENDWHILE reduce using rule 23 (B -> .) + ENDFOR reduce using rule 23 (B -> .) + + ! CALL [ reduce using rule 23 (B -> .) ] + ! ID [ reduce using rule 23 (B -> .) ] + ! READ [ reduce using rule 23 (B -> .) ] + ! WRITE [ reduce using rule 23 (B -> .) ] + ! IF [ reduce using rule 23 (B -> .) ] + ! WHILE [ reduce using rule 23 (B -> .) ] + ! FOR [ reduce using rule 23 (B -> .) ] + + B shift and go to state 94 -state 75 +state 71 - (14) B -> WRITE STRING WRITE_AUX SEMICOLON . V B + (18) B -> WRITE STRING WRITE_AUX SEMICOLON . V B (2) V -> . BE VARIABLES SEMICOLON B V (3) V -> . @@ -1103,37 +1094,37 @@ state 75 ! BE [ reduce using rule 3 (V -> .) ] - V shift and go to state 101 + V shift and go to state 95 -state 76 +state 72 - (26) WRITE_AUX -> COMA STRING . WRITE_AUX - (26) WRITE_AUX -> . COMA STRING WRITE_AUX - (27) WRITE_AUX -> . COMA ID INDICES WRITE_AUX - (28) WRITE_AUX -> . + (30) WRITE_AUX -> COMA STRING . WRITE_AUX + (30) WRITE_AUX -> . COMA STRING WRITE_AUX + (31) WRITE_AUX -> . COMA ID INDICES WRITE_AUX + (32) WRITE_AUX -> . - COMA shift and go to state 50 - SEMICOLON reduce using rule 28 (WRITE_AUX -> .) + COMA shift and go to state 48 + SEMICOLON reduce using rule 32 (WRITE_AUX -> .) - WRITE_AUX shift and go to state 102 + WRITE_AUX shift and go to state 96 -state 77 +state 73 - (27) WRITE_AUX -> COMA ID . INDICES WRITE_AUX - (20) INDICES -> . LEFT_PARENTESIS E RIGHT_PARENTESIS - (21) INDICES -> . LEFT_PARENTESIS E COMA E RIGHT_PARENTESIS - (22) INDICES -> . LEFT_PARENTESIS E COMA E COMA E RIGHT_PARENTESIS - (23) INDICES -> . + (31) WRITE_AUX -> COMA ID . INDICES WRITE_AUX + (24) INDICES -> . LEFT_PARENTESIS E RIGHT_PARENTESIS + (25) INDICES -> . LEFT_PARENTESIS E COMA E RIGHT_PARENTESIS + (26) INDICES -> . LEFT_PARENTESIS E COMA E COMA E RIGHT_PARENTESIS + (27) INDICES -> . - LEFT_PARENTESIS shift and go to state 27 - COMA reduce using rule 23 (INDICES -> .) - SEMICOLON reduce using rule 23 (INDICES -> .) + LEFT_PARENTESIS shift and go to state 28 + COMA reduce using rule 27 (INDICES -> .) + SEMICOLON reduce using rule 27 (INDICES -> .) - INDICES shift and go to state 103 + INDICES shift and go to state 97 -state 78 +state 74 - (15) B -> WRITE E WRITE_AUX SEMICOLON . V B + (19) B -> WRITE E WRITE_AUX SEMICOLON . V B (2) V -> . BE VARIABLES SEMICOLON B V (3) V -> . @@ -1156,91 +1147,91 @@ state 78 ! BE [ reduce using rule 3 (V -> .) ] - V shift and go to state 104 + V shift and go to state 98 -state 79 +state 75 - (34) E -> LEFT_PARENTESIS E RIGHT_PARENTESIS . E_AUX - (37) E_AUX -> . PLUS E - (38) E_AUX -> . STAR E - (39) E_AUX -> . SLASH E - (40) E_AUX -> . MINUS E - (41) E_AUX -> . + (38) E -> LEFT_PARENTESIS E RIGHT_PARENTESIS . E_AUX + (41) E_AUX -> . PLUS E + (42) E_AUX -> . STAR E + (43) E_AUX -> . SLASH E + (44) E_AUX -> . MINUS E + (45) E_AUX -> . - PLUS shift and go to state 54 - STAR shift and go to state 55 - SLASH shift and go to state 56 - MINUS shift and go to state 57 - COMA reduce using rule 41 (E_AUX -> .) - SEMICOLON reduce using rule 41 (E_AUX -> .) - RIGHT_PARENTESIS reduce using rule 41 (E_AUX -> .) + PLUS shift and go to state 52 + STAR shift and go to state 53 + SLASH shift and go to state 54 + MINUS shift and go to state 55 + COMA reduce using rule 45 (E_AUX -> .) + SEMICOLON reduce using rule 45 (E_AUX -> .) + RIGHT_PARENTESIS reduce using rule 45 (E_AUX -> .) - E_AUX shift and go to state 105 + E_AUX shift and go to state 99 -state 80 +state 76 - (37) E_AUX -> PLUS E . + (41) E_AUX -> PLUS E . - COMA reduce using rule 37 (E_AUX -> PLUS E .) - SEMICOLON reduce using rule 37 (E_AUX -> PLUS E .) - RIGHT_PARENTESIS reduce using rule 37 (E_AUX -> PLUS E .) + COMA reduce using rule 41 (E_AUX -> PLUS E .) + SEMICOLON reduce using rule 41 (E_AUX -> PLUS E .) + RIGHT_PARENTESIS reduce using rule 41 (E_AUX -> PLUS E .) -state 81 +state 77 - (38) E_AUX -> STAR E . + (42) E_AUX -> STAR E . - COMA reduce using rule 38 (E_AUX -> STAR E .) - SEMICOLON reduce using rule 38 (E_AUX -> STAR E .) - RIGHT_PARENTESIS reduce using rule 38 (E_AUX -> STAR E .) + COMA reduce using rule 42 (E_AUX -> STAR E .) + SEMICOLON reduce using rule 42 (E_AUX -> STAR E .) + RIGHT_PARENTESIS reduce using rule 42 (E_AUX -> STAR E .) -state 82 +state 78 - (39) E_AUX -> SLASH E . + (43) E_AUX -> SLASH E . - COMA reduce using rule 39 (E_AUX -> SLASH E .) - SEMICOLON reduce using rule 39 (E_AUX -> SLASH E .) - RIGHT_PARENTESIS reduce using rule 39 (E_AUX -> SLASH E .) + COMA reduce using rule 43 (E_AUX -> SLASH E .) + SEMICOLON reduce using rule 43 (E_AUX -> SLASH E .) + RIGHT_PARENTESIS reduce using rule 43 (E_AUX -> SLASH E .) -state 83 +state 79 - (40) E_AUX -> MINUS E . + (44) E_AUX -> MINUS E . - COMA reduce using rule 40 (E_AUX -> MINUS E .) - SEMICOLON reduce using rule 40 (E_AUX -> MINUS E .) - RIGHT_PARENTESIS reduce using rule 40 (E_AUX -> MINUS E .) + COMA reduce using rule 44 (E_AUX -> MINUS E .) + SEMICOLON reduce using rule 44 (E_AUX -> MINUS E .) + RIGHT_PARENTESIS reduce using rule 44 (E_AUX -> MINUS E .) -state 84 +state 80 - (36) E -> ID INDICES E_AUX . + (40) E -> ID INDICES E_AUX . - COMA reduce using rule 36 (E -> ID INDICES E_AUX .) - SEMICOLON reduce using rule 36 (E -> ID INDICES E_AUX .) - RIGHT_PARENTESIS reduce using rule 36 (E -> ID INDICES E_AUX .) + COMA reduce using rule 40 (E -> ID INDICES E_AUX .) + SEMICOLON reduce using rule 40 (E -> ID INDICES E_AUX .) + RIGHT_PARENTESIS reduce using rule 40 (E -> ID INDICES E_AUX .) -state 85 +state 81 - (29) EL -> LEFT_PARENTESIS EL . RIGHT_PARENTESIS EL_AUX + (33) EL -> LEFT_PARENTESIS EL . RIGHT_PARENTESIS EL_AUX - RIGHT_PARENTESIS shift and go to state 106 + RIGHT_PARENTESIS shift and go to state 100 -state 86 +state 82 - (16) B -> IF LEFT_PARENTESIS EL RIGHT_PARENTESIS . B ELSE_AUX ENDIF V B - (11) B -> . CALL ID SEMICOLON V B - (12) B -> . ID INDICES EQUAL E SEMICOLON V B - (13) B -> . READ ID SEMICOLON V B - (14) B -> . WRITE STRING WRITE_AUX SEMICOLON V B - (15) B -> . WRITE E WRITE_AUX SEMICOLON V B - (16) B -> . IF LEFT_PARENTESIS EL RIGHT_PARENTESIS B ELSE_AUX ENDIF V B - (17) B -> . WHILE LEFT_PARENTESIS EL RIGHT_PARENTESIS V B ENDWHILE V B - (18) B -> . FOR LEFT_PARENTESIS EL COMA B RIGHT_PARENTESIS V B ENDFOR V B - (19) B -> . + (20) B -> IF LEFT_PARENTESIS EL RIGHT_PARENTESIS . B ELSE_AUX ENDIF V B + (15) B -> . CALL ID SEMICOLON V B + (16) B -> . ID INDICES EQUAL E SEMICOLON V B + (17) B -> . READ ID SEMICOLON V B + (18) B -> . WRITE STRING WRITE_AUX SEMICOLON V B + (19) B -> . WRITE E WRITE_AUX SEMICOLON V B + (20) B -> . IF LEFT_PARENTESIS EL RIGHT_PARENTESIS B ELSE_AUX ENDIF V B + (21) B -> . WHILE LEFT_PARENTESIS EL RIGHT_PARENTESIS V B ENDWHILE V B + (22) B -> . FOR LEFT_PARENTESIS EL COMA B RIGHT_PARENTESIS V B ENDFOR V B + (23) B -> . CALL shift and go to state 10 ID shift and go to state 11 @@ -1249,43 +1240,43 @@ state 86 IF shift and go to state 14 WHILE shift and go to state 15 FOR shift and go to state 16 - ELSE reduce using rule 19 (B -> .) - ENDIF reduce using rule 19 (B -> .) + ELSE reduce using rule 23 (B -> .) + ENDIF reduce using rule 23 (B -> .) - B shift and go to state 107 + B shift and go to state 101 -state 87 +state 83 - (30) EL -> CONSTANT EL_AUX . + (34) EL -> CONSTANT EL_AUX . - RIGHT_PARENTESIS reduce using rule 30 (EL -> CONSTANT EL_AUX .) - COMA reduce using rule 30 (EL -> CONSTANT EL_AUX .) + RIGHT_PARENTESIS reduce using rule 34 (EL -> CONSTANT EL_AUX .) + COMA reduce using rule 34 (EL -> CONSTANT EL_AUX .) -state 88 +state 84 - (32) EL_AUX -> COMPARISON . EL - (29) EL -> . LEFT_PARENTESIS EL RIGHT_PARENTESIS EL_AUX - (30) EL -> . CONSTANT EL_AUX - (31) EL -> . ID EL_AUX + (36) EL_AUX -> COMPARISON . EL + (33) EL -> . LEFT_PARENTESIS EL RIGHT_PARENTESIS EL_AUX + (34) EL -> . CONSTANT EL_AUX + (35) EL -> . ID EL_AUX - LEFT_PARENTESIS shift and go to state 59 - CONSTANT shift and go to state 61 - ID shift and go to state 62 + LEFT_PARENTESIS shift and go to state 57 + CONSTANT shift and go to state 59 + ID shift and go to state 60 - EL shift and go to state 108 + EL shift and go to state 102 -state 89 +state 85 - (31) EL -> ID EL_AUX . + (35) EL -> ID EL_AUX . - RIGHT_PARENTESIS reduce using rule 31 (EL -> ID EL_AUX .) - COMA reduce using rule 31 (EL -> ID EL_AUX .) + RIGHT_PARENTESIS reduce using rule 35 (EL -> ID EL_AUX .) + COMA reduce using rule 35 (EL -> ID EL_AUX .) -state 90 +state 86 - (17) B -> WHILE LEFT_PARENTESIS EL RIGHT_PARENTESIS . V B ENDWHILE V B + (21) B -> WHILE LEFT_PARENTESIS EL RIGHT_PARENTESIS . V B ENDWHILE V B (2) V -> . BE VARIABLES SEMICOLON B V (3) V -> . @@ -1299,20 +1290,20 @@ state 90 FOR reduce using rule 3 (V -> .) ENDWHILE reduce using rule 3 (V -> .) - V shift and go to state 109 + V shift and go to state 103 -state 91 +state 87 - (18) B -> FOR LEFT_PARENTESIS EL COMA . B RIGHT_PARENTESIS V B ENDFOR V B - (11) B -> . CALL ID SEMICOLON V B - (12) B -> . ID INDICES EQUAL E SEMICOLON V B - (13) B -> . READ ID SEMICOLON V B - (14) B -> . WRITE STRING WRITE_AUX SEMICOLON V B - (15) B -> . WRITE E WRITE_AUX SEMICOLON V B - (16) B -> . IF LEFT_PARENTESIS EL RIGHT_PARENTESIS B ELSE_AUX ENDIF V B - (17) B -> . WHILE LEFT_PARENTESIS EL RIGHT_PARENTESIS V B ENDWHILE V B - (18) B -> . FOR LEFT_PARENTESIS EL COMA B RIGHT_PARENTESIS V B ENDFOR V B - (19) B -> . + (22) B -> FOR LEFT_PARENTESIS EL COMA . B RIGHT_PARENTESIS V B ENDFOR V B + (15) B -> . CALL ID SEMICOLON V B + (16) B -> . ID INDICES EQUAL E SEMICOLON V B + (17) B -> . READ ID SEMICOLON V B + (18) B -> . WRITE STRING WRITE_AUX SEMICOLON V B + (19) B -> . WRITE E WRITE_AUX SEMICOLON V B + (20) B -> . IF LEFT_PARENTESIS EL RIGHT_PARENTESIS B ELSE_AUX ENDIF V B + (21) B -> . WHILE LEFT_PARENTESIS EL RIGHT_PARENTESIS V B ENDWHILE V B + (22) B -> . FOR LEFT_PARENTESIS EL COMA B RIGHT_PARENTESIS V B ENDFOR V B + (23) B -> . CALL shift and go to state 10 ID shift and go to state 11 @@ -1321,11 +1312,11 @@ state 91 IF shift and go to state 14 WHILE shift and go to state 15 FOR shift and go to state 16 - RIGHT_PARENTESIS reduce using rule 19 (B -> .) + RIGHT_PARENTESIS reduce using rule 23 (B -> .) - B shift and go to state 110 + B shift and go to state 104 -state 92 +state 88 (2) V -> BE VARIABLES SEMICOLON B V . @@ -1346,63 +1337,52 @@ state 92 ENDFOR reduce using rule 2 (V -> BE VARIABLES SEMICOLON B V .) -state 93 - - (6) VARIABLES -> VECTOR ID LEFT_PARENTESIS CONSTANT . RIGHT_PARENTESIS - - RIGHT_PARENTESIS shift and go to state 111 - - -state 94 - - (7) VARIABLES -> MATRIX ID LEFT_PARENTESIS CONSTANT . COMA CONSTANT RIGHT_PARENTESIS - - COMA shift and go to state 112 - - -state 95 +state 89 - (8) VARIABLES -> CUBE ID LEFT_PARENTESIS CONSTANT . COMA CONSTANT COMA CONSTANT RIGHT_PARENTESIS + (6) VARIABLES -> T ID LEFT_PARENTESIS CONSTANT . RIGHT_PARENTESIS + (7) VARIABLES -> T ID LEFT_PARENTESIS CONSTANT . COMA CONSTANT RIGHT_PARENTESIS + (8) VARIABLES -> T ID LEFT_PARENTESIS CONSTANT . COMA CONSTANT COMA CONSTANT RIGHT_PARENTESIS - COMA shift and go to state 113 + RIGHT_PARENTESIS shift and go to state 105 + COMA shift and go to state 106 -state 96 +state 90 - (9) R -> ROUTINE LEFT_PARENTESIS ID RIGHT_PARENTESIS V B RETURN . R - (9) R -> . ROUTINE LEFT_PARENTESIS ID RIGHT_PARENTESIS V B RETURN R - (10) R -> . + (13) R -> ROUTINE LEFT_PARENTESIS ID RIGHT_PARENTESIS V B RETURN . R + (13) R -> . ROUTINE LEFT_PARENTESIS ID RIGHT_PARENTESIS V B RETURN R + (14) R -> . ROUTINE shift and go to state 3 - START reduce using rule 10 (R -> .) - $end reduce using rule 10 (R -> .) + START reduce using rule 14 (R -> .) + $end reduce using rule 14 (R -> .) - R shift and go to state 114 + R shift and go to state 107 -state 97 +state 91 - (11) B -> CALL ID SEMICOLON V B . - - FINISH reduce using rule 11 (B -> CALL ID SEMICOLON V B .) - BE reduce using rule 11 (B -> CALL ID SEMICOLON V B .) - CALL reduce using rule 11 (B -> CALL ID SEMICOLON V B .) - ID reduce using rule 11 (B -> CALL ID SEMICOLON V B .) - READ reduce using rule 11 (B -> CALL ID SEMICOLON V B .) - WRITE reduce using rule 11 (B -> CALL ID SEMICOLON V B .) - IF reduce using rule 11 (B -> CALL ID SEMICOLON V B .) - WHILE reduce using rule 11 (B -> CALL ID SEMICOLON V B .) - FOR reduce using rule 11 (B -> CALL ID SEMICOLON V B .) - RETURN reduce using rule 11 (B -> CALL ID SEMICOLON V B .) - ELSE reduce using rule 11 (B -> CALL ID SEMICOLON V B .) - ENDIF reduce using rule 11 (B -> CALL ID SEMICOLON V B .) - RIGHT_PARENTESIS reduce using rule 11 (B -> CALL ID SEMICOLON V B .) - ENDWHILE reduce using rule 11 (B -> CALL ID SEMICOLON V B .) - ENDFOR reduce using rule 11 (B -> CALL ID SEMICOLON V B .) + (15) B -> CALL ID SEMICOLON V B . + + FINISH reduce using rule 15 (B -> CALL ID SEMICOLON V B .) + BE reduce using rule 15 (B -> CALL ID SEMICOLON V B .) + CALL reduce using rule 15 (B -> CALL ID SEMICOLON V B .) + ID reduce using rule 15 (B -> CALL ID SEMICOLON V B .) + READ reduce using rule 15 (B -> CALL ID SEMICOLON V B .) + WRITE reduce using rule 15 (B -> CALL ID SEMICOLON V B .) + IF reduce using rule 15 (B -> CALL ID SEMICOLON V B .) + WHILE reduce using rule 15 (B -> CALL ID SEMICOLON V B .) + FOR reduce using rule 15 (B -> CALL ID SEMICOLON V B .) + RETURN reduce using rule 15 (B -> CALL ID SEMICOLON V B .) + ELSE reduce using rule 15 (B -> CALL ID SEMICOLON V B .) + ENDIF reduce using rule 15 (B -> CALL ID SEMICOLON V B .) + RIGHT_PARENTESIS reduce using rule 15 (B -> CALL ID SEMICOLON V B .) + ENDWHILE reduce using rule 15 (B -> CALL ID SEMICOLON V B .) + ENDFOR reduce using rule 15 (B -> CALL ID SEMICOLON V B .) -state 98 +state 92 - (12) B -> ID INDICES EQUAL E SEMICOLON . V B + (16) B -> ID INDICES EQUAL E SEMICOLON . V B (2) V -> . BE VARIABLES SEMICOLON B V (3) V -> . @@ -1425,50 +1405,50 @@ state 98 ! BE [ reduce using rule 3 (V -> .) ] - V shift and go to state 115 + V shift and go to state 108 -state 99 +state 93 - (21) INDICES -> LEFT_PARENTESIS E COMA E . RIGHT_PARENTESIS - (22) INDICES -> LEFT_PARENTESIS E COMA E . COMA E RIGHT_PARENTESIS + (25) INDICES -> LEFT_PARENTESIS E COMA E . RIGHT_PARENTESIS + (26) INDICES -> LEFT_PARENTESIS E COMA E . COMA E RIGHT_PARENTESIS - RIGHT_PARENTESIS shift and go to state 117 - COMA shift and go to state 116 + RIGHT_PARENTESIS shift and go to state 110 + COMA shift and go to state 109 -state 100 +state 94 - (13) B -> READ ID SEMICOLON V B . - - FINISH reduce using rule 13 (B -> READ ID SEMICOLON V B .) - BE reduce using rule 13 (B -> READ ID SEMICOLON V B .) - CALL reduce using rule 13 (B -> READ ID SEMICOLON V B .) - ID reduce using rule 13 (B -> READ ID SEMICOLON V B .) - READ reduce using rule 13 (B -> READ ID SEMICOLON V B .) - WRITE reduce using rule 13 (B -> READ ID SEMICOLON V B .) - IF reduce using rule 13 (B -> READ ID SEMICOLON V B .) - WHILE reduce using rule 13 (B -> READ ID SEMICOLON V B .) - FOR reduce using rule 13 (B -> READ ID SEMICOLON V B .) - RETURN reduce using rule 13 (B -> READ ID SEMICOLON V B .) - ELSE reduce using rule 13 (B -> READ ID SEMICOLON V B .) - ENDIF reduce using rule 13 (B -> READ ID SEMICOLON V B .) - RIGHT_PARENTESIS reduce using rule 13 (B -> READ ID SEMICOLON V B .) - ENDWHILE reduce using rule 13 (B -> READ ID SEMICOLON V B .) - ENDFOR reduce using rule 13 (B -> READ ID SEMICOLON V B .) + (17) B -> READ ID SEMICOLON V B . + + FINISH reduce using rule 17 (B -> READ ID SEMICOLON V B .) + BE reduce using rule 17 (B -> READ ID SEMICOLON V B .) + CALL reduce using rule 17 (B -> READ ID SEMICOLON V B .) + ID reduce using rule 17 (B -> READ ID SEMICOLON V B .) + READ reduce using rule 17 (B -> READ ID SEMICOLON V B .) + WRITE reduce using rule 17 (B -> READ ID SEMICOLON V B .) + IF reduce using rule 17 (B -> READ ID SEMICOLON V B .) + WHILE reduce using rule 17 (B -> READ ID SEMICOLON V B .) + FOR reduce using rule 17 (B -> READ ID SEMICOLON V B .) + RETURN reduce using rule 17 (B -> READ ID SEMICOLON V B .) + ELSE reduce using rule 17 (B -> READ ID SEMICOLON V B .) + ENDIF reduce using rule 17 (B -> READ ID SEMICOLON V B .) + RIGHT_PARENTESIS reduce using rule 17 (B -> READ ID SEMICOLON V B .) + ENDWHILE reduce using rule 17 (B -> READ ID SEMICOLON V B .) + ENDFOR reduce using rule 17 (B -> READ ID SEMICOLON V B .) -state 101 +state 95 - (14) B -> WRITE STRING WRITE_AUX SEMICOLON V . B - (11) B -> . CALL ID SEMICOLON V B - (12) B -> . ID INDICES EQUAL E SEMICOLON V B - (13) B -> . READ ID SEMICOLON V B - (14) B -> . WRITE STRING WRITE_AUX SEMICOLON V B - (15) B -> . WRITE E WRITE_AUX SEMICOLON V B - (16) B -> . IF LEFT_PARENTESIS EL RIGHT_PARENTESIS B ELSE_AUX ENDIF V B - (17) B -> . WHILE LEFT_PARENTESIS EL RIGHT_PARENTESIS V B ENDWHILE V B - (18) B -> . FOR LEFT_PARENTESIS EL COMA B RIGHT_PARENTESIS V B ENDFOR V B - (19) B -> . + (18) B -> WRITE STRING WRITE_AUX SEMICOLON V . B + (15) B -> . CALL ID SEMICOLON V B + (16) B -> . ID INDICES EQUAL E SEMICOLON V B + (17) B -> . READ ID SEMICOLON V B + (18) B -> . WRITE STRING WRITE_AUX SEMICOLON V B + (19) B -> . WRITE E WRITE_AUX SEMICOLON V B + (20) B -> . IF LEFT_PARENTESIS EL RIGHT_PARENTESIS B ELSE_AUX ENDIF V B + (21) B -> . WHILE LEFT_PARENTESIS EL RIGHT_PARENTESIS V B ENDWHILE V B + (22) B -> . FOR LEFT_PARENTESIS EL COMA B RIGHT_PARENTESIS V B ENDFOR V B + (23) B -> . ! shift/reduce conflict for CALL resolved as shift ! shift/reduce conflict for ID resolved as shift @@ -1484,56 +1464,56 @@ state 101 IF shift and go to state 14 WHILE shift and go to state 15 FOR shift and go to state 16 - BE reduce using rule 19 (B -> .) - FINISH reduce using rule 19 (B -> .) - RETURN reduce using rule 19 (B -> .) - ELSE reduce using rule 19 (B -> .) - ENDIF reduce using rule 19 (B -> .) - RIGHT_PARENTESIS reduce using rule 19 (B -> .) - ENDWHILE reduce using rule 19 (B -> .) - ENDFOR reduce using rule 19 (B -> .) - - ! CALL [ reduce using rule 19 (B -> .) ] - ! ID [ reduce using rule 19 (B -> .) ] - ! READ [ reduce using rule 19 (B -> .) ] - ! WRITE [ reduce using rule 19 (B -> .) ] - ! IF [ reduce using rule 19 (B -> .) ] - ! WHILE [ reduce using rule 19 (B -> .) ] - ! FOR [ reduce using rule 19 (B -> .) ] - - B shift and go to state 118 + BE reduce using rule 23 (B -> .) + FINISH reduce using rule 23 (B -> .) + RETURN reduce using rule 23 (B -> .) + ELSE reduce using rule 23 (B -> .) + ENDIF reduce using rule 23 (B -> .) + RIGHT_PARENTESIS reduce using rule 23 (B -> .) + ENDWHILE reduce using rule 23 (B -> .) + ENDFOR reduce using rule 23 (B -> .) + + ! CALL [ reduce using rule 23 (B -> .) ] + ! ID [ reduce using rule 23 (B -> .) ] + ! READ [ reduce using rule 23 (B -> .) ] + ! WRITE [ reduce using rule 23 (B -> .) ] + ! IF [ reduce using rule 23 (B -> .) ] + ! WHILE [ reduce using rule 23 (B -> .) ] + ! FOR [ reduce using rule 23 (B -> .) ] + + B shift and go to state 111 -state 102 +state 96 - (26) WRITE_AUX -> COMA STRING WRITE_AUX . + (30) WRITE_AUX -> COMA STRING WRITE_AUX . - SEMICOLON reduce using rule 26 (WRITE_AUX -> COMA STRING WRITE_AUX .) + SEMICOLON reduce using rule 30 (WRITE_AUX -> COMA STRING WRITE_AUX .) -state 103 +state 97 - (27) WRITE_AUX -> COMA ID INDICES . WRITE_AUX - (26) WRITE_AUX -> . COMA STRING WRITE_AUX - (27) WRITE_AUX -> . COMA ID INDICES WRITE_AUX - (28) WRITE_AUX -> . + (31) WRITE_AUX -> COMA ID INDICES . WRITE_AUX + (30) WRITE_AUX -> . COMA STRING WRITE_AUX + (31) WRITE_AUX -> . COMA ID INDICES WRITE_AUX + (32) WRITE_AUX -> . - COMA shift and go to state 50 - SEMICOLON reduce using rule 28 (WRITE_AUX -> .) + COMA shift and go to state 48 + SEMICOLON reduce using rule 32 (WRITE_AUX -> .) - WRITE_AUX shift and go to state 119 + WRITE_AUX shift and go to state 112 -state 104 +state 98 - (15) B -> WRITE E WRITE_AUX SEMICOLON V . B - (11) B -> . CALL ID SEMICOLON V B - (12) B -> . ID INDICES EQUAL E SEMICOLON V B - (13) B -> . READ ID SEMICOLON V B - (14) B -> . WRITE STRING WRITE_AUX SEMICOLON V B - (15) B -> . WRITE E WRITE_AUX SEMICOLON V B - (16) B -> . IF LEFT_PARENTESIS EL RIGHT_PARENTESIS B ELSE_AUX ENDIF V B - (17) B -> . WHILE LEFT_PARENTESIS EL RIGHT_PARENTESIS V B ENDWHILE V B - (18) B -> . FOR LEFT_PARENTESIS EL COMA B RIGHT_PARENTESIS V B ENDFOR V B - (19) B -> . + (19) B -> WRITE E WRITE_AUX SEMICOLON V . B + (15) B -> . CALL ID SEMICOLON V B + (16) B -> . ID INDICES EQUAL E SEMICOLON V B + (17) B -> . READ ID SEMICOLON V B + (18) B -> . WRITE STRING WRITE_AUX SEMICOLON V B + (19) B -> . WRITE E WRITE_AUX SEMICOLON V B + (20) B -> . IF LEFT_PARENTESIS EL RIGHT_PARENTESIS B ELSE_AUX ENDIF V B + (21) B -> . WHILE LEFT_PARENTESIS EL RIGHT_PARENTESIS V B ENDWHILE V B + (22) B -> . FOR LEFT_PARENTESIS EL COMA B RIGHT_PARENTESIS V B ENDFOR V B + (23) B -> . ! shift/reduce conflict for CALL resolved as shift ! shift/reduce conflict for ID resolved as shift @@ -1549,77 +1529,77 @@ state 104 IF shift and go to state 14 WHILE shift and go to state 15 FOR shift and go to state 16 - BE reduce using rule 19 (B -> .) - FINISH reduce using rule 19 (B -> .) - RETURN reduce using rule 19 (B -> .) - ELSE reduce using rule 19 (B -> .) - ENDIF reduce using rule 19 (B -> .) - RIGHT_PARENTESIS reduce using rule 19 (B -> .) - ENDWHILE reduce using rule 19 (B -> .) - ENDFOR reduce using rule 19 (B -> .) - - ! CALL [ reduce using rule 19 (B -> .) ] - ! ID [ reduce using rule 19 (B -> .) ] - ! READ [ reduce using rule 19 (B -> .) ] - ! WRITE [ reduce using rule 19 (B -> .) ] - ! IF [ reduce using rule 19 (B -> .) ] - ! WHILE [ reduce using rule 19 (B -> .) ] - ! FOR [ reduce using rule 19 (B -> .) ] + BE reduce using rule 23 (B -> .) + FINISH reduce using rule 23 (B -> .) + RETURN reduce using rule 23 (B -> .) + ELSE reduce using rule 23 (B -> .) + ENDIF reduce using rule 23 (B -> .) + RIGHT_PARENTESIS reduce using rule 23 (B -> .) + ENDWHILE reduce using rule 23 (B -> .) + ENDFOR reduce using rule 23 (B -> .) + + ! CALL [ reduce using rule 23 (B -> .) ] + ! ID [ reduce using rule 23 (B -> .) ] + ! READ [ reduce using rule 23 (B -> .) ] + ! WRITE [ reduce using rule 23 (B -> .) ] + ! IF [ reduce using rule 23 (B -> .) ] + ! WHILE [ reduce using rule 23 (B -> .) ] + ! FOR [ reduce using rule 23 (B -> .) ] + + B shift and go to state 113 - B shift and go to state 120 - -state 105 +state 99 - (34) E -> LEFT_PARENTESIS E RIGHT_PARENTESIS E_AUX . + (38) E -> LEFT_PARENTESIS E RIGHT_PARENTESIS E_AUX . - COMA reduce using rule 34 (E -> LEFT_PARENTESIS E RIGHT_PARENTESIS E_AUX .) - SEMICOLON reduce using rule 34 (E -> LEFT_PARENTESIS E RIGHT_PARENTESIS E_AUX .) - RIGHT_PARENTESIS reduce using rule 34 (E -> LEFT_PARENTESIS E RIGHT_PARENTESIS E_AUX .) + COMA reduce using rule 38 (E -> LEFT_PARENTESIS E RIGHT_PARENTESIS E_AUX .) + SEMICOLON reduce using rule 38 (E -> LEFT_PARENTESIS E RIGHT_PARENTESIS E_AUX .) + RIGHT_PARENTESIS reduce using rule 38 (E -> LEFT_PARENTESIS E RIGHT_PARENTESIS E_AUX .) -state 106 +state 100 - (29) EL -> LEFT_PARENTESIS EL RIGHT_PARENTESIS . EL_AUX - (32) EL_AUX -> . COMPARISON EL - (33) EL_AUX -> . + (33) EL -> LEFT_PARENTESIS EL RIGHT_PARENTESIS . EL_AUX + (36) EL_AUX -> . COMPARISON EL + (37) EL_AUX -> . - COMPARISON shift and go to state 88 - RIGHT_PARENTESIS reduce using rule 33 (EL_AUX -> .) - COMA reduce using rule 33 (EL_AUX -> .) + COMPARISON shift and go to state 84 + RIGHT_PARENTESIS reduce using rule 37 (EL_AUX -> .) + COMA reduce using rule 37 (EL_AUX -> .) - EL_AUX shift and go to state 121 + EL_AUX shift and go to state 114 -state 107 +state 101 - (16) B -> IF LEFT_PARENTESIS EL RIGHT_PARENTESIS B . ELSE_AUX ENDIF V B - (24) ELSE_AUX -> . ELSE B - (25) ELSE_AUX -> . + (20) B -> IF LEFT_PARENTESIS EL RIGHT_PARENTESIS B . ELSE_AUX ENDIF V B + (28) ELSE_AUX -> . ELSE B + (29) ELSE_AUX -> . - ELSE shift and go to state 123 - ENDIF reduce using rule 25 (ELSE_AUX -> .) + ELSE shift and go to state 116 + ENDIF reduce using rule 29 (ELSE_AUX -> .) - ELSE_AUX shift and go to state 122 + ELSE_AUX shift and go to state 115 -state 108 +state 102 - (32) EL_AUX -> COMPARISON EL . + (36) EL_AUX -> COMPARISON EL . - RIGHT_PARENTESIS reduce using rule 32 (EL_AUX -> COMPARISON EL .) - COMA reduce using rule 32 (EL_AUX -> COMPARISON EL .) + RIGHT_PARENTESIS reduce using rule 36 (EL_AUX -> COMPARISON EL .) + COMA reduce using rule 36 (EL_AUX -> COMPARISON EL .) -state 109 +state 103 - (17) B -> WHILE LEFT_PARENTESIS EL RIGHT_PARENTESIS V . B ENDWHILE V B - (11) B -> . CALL ID SEMICOLON V B - (12) B -> . ID INDICES EQUAL E SEMICOLON V B - (13) B -> . READ ID SEMICOLON V B - (14) B -> . WRITE STRING WRITE_AUX SEMICOLON V B - (15) B -> . WRITE E WRITE_AUX SEMICOLON V B - (16) B -> . IF LEFT_PARENTESIS EL RIGHT_PARENTESIS B ELSE_AUX ENDIF V B - (17) B -> . WHILE LEFT_PARENTESIS EL RIGHT_PARENTESIS V B ENDWHILE V B - (18) B -> . FOR LEFT_PARENTESIS EL COMA B RIGHT_PARENTESIS V B ENDFOR V B - (19) B -> . + (21) B -> WHILE LEFT_PARENTESIS EL RIGHT_PARENTESIS V . B ENDWHILE V B + (15) B -> . CALL ID SEMICOLON V B + (16) B -> . ID INDICES EQUAL E SEMICOLON V B + (17) B -> . READ ID SEMICOLON V B + (18) B -> . WRITE STRING WRITE_AUX SEMICOLON V B + (19) B -> . WRITE E WRITE_AUX SEMICOLON V B + (20) B -> . IF LEFT_PARENTESIS EL RIGHT_PARENTESIS B ELSE_AUX ENDIF V B + (21) B -> . WHILE LEFT_PARENTESIS EL RIGHT_PARENTESIS V B ENDWHILE V B + (22) B -> . FOR LEFT_PARENTESIS EL COMA B RIGHT_PARENTESIS V B ENDFOR V B + (23) B -> . CALL shift and go to state 10 ID shift and go to state 11 @@ -1628,58 +1608,52 @@ state 109 IF shift and go to state 14 WHILE shift and go to state 15 FOR shift and go to state 16 - ENDWHILE reduce using rule 19 (B -> .) - - B shift and go to state 124 - -state 110 + ENDWHILE reduce using rule 23 (B -> .) - (18) B -> FOR LEFT_PARENTESIS EL COMA B . RIGHT_PARENTESIS V B ENDFOR V B + B shift and go to state 117 - RIGHT_PARENTESIS shift and go to state 125 - - -state 111 +state 104 - (6) VARIABLES -> VECTOR ID LEFT_PARENTESIS CONSTANT RIGHT_PARENTESIS . + (22) B -> FOR LEFT_PARENTESIS EL COMA B . RIGHT_PARENTESIS V B ENDFOR V B - SEMICOLON reduce using rule 6 (VARIABLES -> VECTOR ID LEFT_PARENTESIS CONSTANT RIGHT_PARENTESIS .) + RIGHT_PARENTESIS shift and go to state 118 -state 112 +state 105 - (7) VARIABLES -> MATRIX ID LEFT_PARENTESIS CONSTANT COMA . CONSTANT RIGHT_PARENTESIS + (6) VARIABLES -> T ID LEFT_PARENTESIS CONSTANT RIGHT_PARENTESIS . - CONSTANT shift and go to state 126 + SEMICOLON reduce using rule 6 (VARIABLES -> T ID LEFT_PARENTESIS CONSTANT RIGHT_PARENTESIS .) -state 113 +state 106 - (8) VARIABLES -> CUBE ID LEFT_PARENTESIS CONSTANT COMA . CONSTANT COMA CONSTANT RIGHT_PARENTESIS + (7) VARIABLES -> T ID LEFT_PARENTESIS CONSTANT COMA . CONSTANT RIGHT_PARENTESIS + (8) VARIABLES -> T ID LEFT_PARENTESIS CONSTANT COMA . CONSTANT COMA CONSTANT RIGHT_PARENTESIS - CONSTANT shift and go to state 127 + CONSTANT shift and go to state 119 -state 114 +state 107 - (9) R -> ROUTINE LEFT_PARENTESIS ID RIGHT_PARENTESIS V B RETURN R . + (13) R -> ROUTINE LEFT_PARENTESIS ID RIGHT_PARENTESIS V B RETURN R . - START reduce using rule 9 (R -> ROUTINE LEFT_PARENTESIS ID RIGHT_PARENTESIS V B RETURN R .) - $end reduce using rule 9 (R -> ROUTINE LEFT_PARENTESIS ID RIGHT_PARENTESIS V B RETURN R .) + START reduce using rule 13 (R -> ROUTINE LEFT_PARENTESIS ID RIGHT_PARENTESIS V B RETURN R .) + $end reduce using rule 13 (R -> ROUTINE LEFT_PARENTESIS ID RIGHT_PARENTESIS V B RETURN R .) -state 115 +state 108 - (12) B -> ID INDICES EQUAL E SEMICOLON V . B - (11) B -> . CALL ID SEMICOLON V B - (12) B -> . ID INDICES EQUAL E SEMICOLON V B - (13) B -> . READ ID SEMICOLON V B - (14) B -> . WRITE STRING WRITE_AUX SEMICOLON V B - (15) B -> . WRITE E WRITE_AUX SEMICOLON V B - (16) B -> . IF LEFT_PARENTESIS EL RIGHT_PARENTESIS B ELSE_AUX ENDIF V B - (17) B -> . WHILE LEFT_PARENTESIS EL RIGHT_PARENTESIS V B ENDWHILE V B - (18) B -> . FOR LEFT_PARENTESIS EL COMA B RIGHT_PARENTESIS V B ENDFOR V B - (19) B -> . + (16) B -> ID INDICES EQUAL E SEMICOLON V . B + (15) B -> . CALL ID SEMICOLON V B + (16) B -> . ID INDICES EQUAL E SEMICOLON V B + (17) B -> . READ ID SEMICOLON V B + (18) B -> . WRITE STRING WRITE_AUX SEMICOLON V B + (19) B -> . WRITE E WRITE_AUX SEMICOLON V B + (20) B -> . IF LEFT_PARENTESIS EL RIGHT_PARENTESIS B ELSE_AUX ENDIF V B + (21) B -> . WHILE LEFT_PARENTESIS EL RIGHT_PARENTESIS V B ENDWHILE V B + (22) B -> . FOR LEFT_PARENTESIS EL COMA B RIGHT_PARENTESIS V B ENDFOR V B + (23) B -> . ! shift/reduce conflict for CALL resolved as shift ! shift/reduce conflict for ID resolved as shift @@ -1695,128 +1669,128 @@ state 115 IF shift and go to state 14 WHILE shift and go to state 15 FOR shift and go to state 16 - BE reduce using rule 19 (B -> .) - FINISH reduce using rule 19 (B -> .) - RETURN reduce using rule 19 (B -> .) - ELSE reduce using rule 19 (B -> .) - ENDIF reduce using rule 19 (B -> .) - RIGHT_PARENTESIS reduce using rule 19 (B -> .) - ENDWHILE reduce using rule 19 (B -> .) - ENDFOR reduce using rule 19 (B -> .) - - ! CALL [ reduce using rule 19 (B -> .) ] - ! ID [ reduce using rule 19 (B -> .) ] - ! READ [ reduce using rule 19 (B -> .) ] - ! WRITE [ reduce using rule 19 (B -> .) ] - ! IF [ reduce using rule 19 (B -> .) ] - ! WHILE [ reduce using rule 19 (B -> .) ] - ! FOR [ reduce using rule 19 (B -> .) ] - - B shift and go to state 128 + BE reduce using rule 23 (B -> .) + FINISH reduce using rule 23 (B -> .) + RETURN reduce using rule 23 (B -> .) + ELSE reduce using rule 23 (B -> .) + ENDIF reduce using rule 23 (B -> .) + RIGHT_PARENTESIS reduce using rule 23 (B -> .) + ENDWHILE reduce using rule 23 (B -> .) + ENDFOR reduce using rule 23 (B -> .) + + ! CALL [ reduce using rule 23 (B -> .) ] + ! ID [ reduce using rule 23 (B -> .) ] + ! READ [ reduce using rule 23 (B -> .) ] + ! WRITE [ reduce using rule 23 (B -> .) ] + ! IF [ reduce using rule 23 (B -> .) ] + ! WHILE [ reduce using rule 23 (B -> .) ] + ! FOR [ reduce using rule 23 (B -> .) ] -state 116 + B shift and go to state 120 - (22) INDICES -> LEFT_PARENTESIS E COMA E COMA . E RIGHT_PARENTESIS - (34) E -> . LEFT_PARENTESIS E RIGHT_PARENTESIS E_AUX - (35) E -> . CONSTANT E_AUX - (36) E -> . ID INDICES E_AUX +state 109 - LEFT_PARENTESIS shift and go to state 31 - CONSTANT shift and go to state 32 - ID shift and go to state 33 + (26) INDICES -> LEFT_PARENTESIS E COMA E COMA . E RIGHT_PARENTESIS + (38) E -> . LEFT_PARENTESIS E RIGHT_PARENTESIS E_AUX + (39) E -> . CONSTANT E_AUX + (40) E -> . ID INDICES E_AUX - E shift and go to state 129 + LEFT_PARENTESIS shift and go to state 32 + CONSTANT shift and go to state 33 + ID shift and go to state 34 -state 117 + E shift and go to state 121 - (21) INDICES -> LEFT_PARENTESIS E COMA E RIGHT_PARENTESIS . +state 110 - EQUAL reduce using rule 21 (INDICES -> LEFT_PARENTESIS E COMA E RIGHT_PARENTESIS .) - PLUS reduce using rule 21 (INDICES -> LEFT_PARENTESIS E COMA E RIGHT_PARENTESIS .) - STAR reduce using rule 21 (INDICES -> LEFT_PARENTESIS E COMA E RIGHT_PARENTESIS .) - SLASH reduce using rule 21 (INDICES -> LEFT_PARENTESIS E COMA E RIGHT_PARENTESIS .) - MINUS reduce using rule 21 (INDICES -> LEFT_PARENTESIS E COMA E RIGHT_PARENTESIS .) - COMA reduce using rule 21 (INDICES -> LEFT_PARENTESIS E COMA E RIGHT_PARENTESIS .) - SEMICOLON reduce using rule 21 (INDICES -> LEFT_PARENTESIS E COMA E RIGHT_PARENTESIS .) - RIGHT_PARENTESIS reduce using rule 21 (INDICES -> LEFT_PARENTESIS E COMA E RIGHT_PARENTESIS .) + (25) INDICES -> LEFT_PARENTESIS E COMA E RIGHT_PARENTESIS . + EQUAL reduce using rule 25 (INDICES -> LEFT_PARENTESIS E COMA E RIGHT_PARENTESIS .) + PLUS reduce using rule 25 (INDICES -> LEFT_PARENTESIS E COMA E RIGHT_PARENTESIS .) + STAR reduce using rule 25 (INDICES -> LEFT_PARENTESIS E COMA E RIGHT_PARENTESIS .) + SLASH reduce using rule 25 (INDICES -> LEFT_PARENTESIS E COMA E RIGHT_PARENTESIS .) + MINUS reduce using rule 25 (INDICES -> LEFT_PARENTESIS E COMA E RIGHT_PARENTESIS .) + COMA reduce using rule 25 (INDICES -> LEFT_PARENTESIS E COMA E RIGHT_PARENTESIS .) + SEMICOLON reduce using rule 25 (INDICES -> LEFT_PARENTESIS E COMA E RIGHT_PARENTESIS .) + RIGHT_PARENTESIS reduce using rule 25 (INDICES -> LEFT_PARENTESIS E COMA E RIGHT_PARENTESIS .) -state 118 - (14) B -> WRITE STRING WRITE_AUX SEMICOLON V B . - - FINISH reduce using rule 14 (B -> WRITE STRING WRITE_AUX SEMICOLON V B .) - BE reduce using rule 14 (B -> WRITE STRING WRITE_AUX SEMICOLON V B .) - CALL reduce using rule 14 (B -> WRITE STRING WRITE_AUX SEMICOLON V B .) - ID reduce using rule 14 (B -> WRITE STRING WRITE_AUX SEMICOLON V B .) - READ reduce using rule 14 (B -> WRITE STRING WRITE_AUX SEMICOLON V B .) - WRITE reduce using rule 14 (B -> WRITE STRING WRITE_AUX SEMICOLON V B .) - IF reduce using rule 14 (B -> WRITE STRING WRITE_AUX SEMICOLON V B .) - WHILE reduce using rule 14 (B -> WRITE STRING WRITE_AUX SEMICOLON V B .) - FOR reduce using rule 14 (B -> WRITE STRING WRITE_AUX SEMICOLON V B .) - RETURN reduce using rule 14 (B -> WRITE STRING WRITE_AUX SEMICOLON V B .) - ELSE reduce using rule 14 (B -> WRITE STRING WRITE_AUX SEMICOLON V B .) - ENDIF reduce using rule 14 (B -> WRITE STRING WRITE_AUX SEMICOLON V B .) - RIGHT_PARENTESIS reduce using rule 14 (B -> WRITE STRING WRITE_AUX SEMICOLON V B .) - ENDWHILE reduce using rule 14 (B -> WRITE STRING WRITE_AUX SEMICOLON V B .) - ENDFOR reduce using rule 14 (B -> WRITE STRING WRITE_AUX SEMICOLON V B .) +state 111 + (18) B -> WRITE STRING WRITE_AUX SEMICOLON V B . + + FINISH reduce using rule 18 (B -> WRITE STRING WRITE_AUX SEMICOLON V B .) + BE reduce using rule 18 (B -> WRITE STRING WRITE_AUX SEMICOLON V B .) + CALL reduce using rule 18 (B -> WRITE STRING WRITE_AUX SEMICOLON V B .) + ID reduce using rule 18 (B -> WRITE STRING WRITE_AUX SEMICOLON V B .) + READ reduce using rule 18 (B -> WRITE STRING WRITE_AUX SEMICOLON V B .) + WRITE reduce using rule 18 (B -> WRITE STRING WRITE_AUX SEMICOLON V B .) + IF reduce using rule 18 (B -> WRITE STRING WRITE_AUX SEMICOLON V B .) + WHILE reduce using rule 18 (B -> WRITE STRING WRITE_AUX SEMICOLON V B .) + FOR reduce using rule 18 (B -> WRITE STRING WRITE_AUX SEMICOLON V B .) + RETURN reduce using rule 18 (B -> WRITE STRING WRITE_AUX SEMICOLON V B .) + ELSE reduce using rule 18 (B -> WRITE STRING WRITE_AUX SEMICOLON V B .) + ENDIF reduce using rule 18 (B -> WRITE STRING WRITE_AUX SEMICOLON V B .) + RIGHT_PARENTESIS reduce using rule 18 (B -> WRITE STRING WRITE_AUX SEMICOLON V B .) + ENDWHILE reduce using rule 18 (B -> WRITE STRING WRITE_AUX SEMICOLON V B .) + ENDFOR reduce using rule 18 (B -> WRITE STRING WRITE_AUX SEMICOLON V B .) -state 119 - (27) WRITE_AUX -> COMA ID INDICES WRITE_AUX . +state 112 - SEMICOLON reduce using rule 27 (WRITE_AUX -> COMA ID INDICES WRITE_AUX .) + (31) WRITE_AUX -> COMA ID INDICES WRITE_AUX . + SEMICOLON reduce using rule 31 (WRITE_AUX -> COMA ID INDICES WRITE_AUX .) -state 120 - (15) B -> WRITE E WRITE_AUX SEMICOLON V B . - - FINISH reduce using rule 15 (B -> WRITE E WRITE_AUX SEMICOLON V B .) - BE reduce using rule 15 (B -> WRITE E WRITE_AUX SEMICOLON V B .) - CALL reduce using rule 15 (B -> WRITE E WRITE_AUX SEMICOLON V B .) - ID reduce using rule 15 (B -> WRITE E WRITE_AUX SEMICOLON V B .) - READ reduce using rule 15 (B -> WRITE E WRITE_AUX SEMICOLON V B .) - WRITE reduce using rule 15 (B -> WRITE E WRITE_AUX SEMICOLON V B .) - IF reduce using rule 15 (B -> WRITE E WRITE_AUX SEMICOLON V B .) - WHILE reduce using rule 15 (B -> WRITE E WRITE_AUX SEMICOLON V B .) - FOR reduce using rule 15 (B -> WRITE E WRITE_AUX SEMICOLON V B .) - RETURN reduce using rule 15 (B -> WRITE E WRITE_AUX SEMICOLON V B .) - ELSE reduce using rule 15 (B -> WRITE E WRITE_AUX SEMICOLON V B .) - ENDIF reduce using rule 15 (B -> WRITE E WRITE_AUX SEMICOLON V B .) - RIGHT_PARENTESIS reduce using rule 15 (B -> WRITE E WRITE_AUX SEMICOLON V B .) - ENDWHILE reduce using rule 15 (B -> WRITE E WRITE_AUX SEMICOLON V B .) - ENDFOR reduce using rule 15 (B -> WRITE E WRITE_AUX SEMICOLON V B .) +state 113 + (19) B -> WRITE E WRITE_AUX SEMICOLON V B . + + FINISH reduce using rule 19 (B -> WRITE E WRITE_AUX SEMICOLON V B .) + BE reduce using rule 19 (B -> WRITE E WRITE_AUX SEMICOLON V B .) + CALL reduce using rule 19 (B -> WRITE E WRITE_AUX SEMICOLON V B .) + ID reduce using rule 19 (B -> WRITE E WRITE_AUX SEMICOLON V B .) + READ reduce using rule 19 (B -> WRITE E WRITE_AUX SEMICOLON V B .) + WRITE reduce using rule 19 (B -> WRITE E WRITE_AUX SEMICOLON V B .) + IF reduce using rule 19 (B -> WRITE E WRITE_AUX SEMICOLON V B .) + WHILE reduce using rule 19 (B -> WRITE E WRITE_AUX SEMICOLON V B .) + FOR reduce using rule 19 (B -> WRITE E WRITE_AUX SEMICOLON V B .) + RETURN reduce using rule 19 (B -> WRITE E WRITE_AUX SEMICOLON V B .) + ELSE reduce using rule 19 (B -> WRITE E WRITE_AUX SEMICOLON V B .) + ENDIF reduce using rule 19 (B -> WRITE E WRITE_AUX SEMICOLON V B .) + RIGHT_PARENTESIS reduce using rule 19 (B -> WRITE E WRITE_AUX SEMICOLON V B .) + ENDWHILE reduce using rule 19 (B -> WRITE E WRITE_AUX SEMICOLON V B .) + ENDFOR reduce using rule 19 (B -> WRITE E WRITE_AUX SEMICOLON V B .) -state 121 - (29) EL -> LEFT_PARENTESIS EL RIGHT_PARENTESIS EL_AUX . +state 114 - RIGHT_PARENTESIS reduce using rule 29 (EL -> LEFT_PARENTESIS EL RIGHT_PARENTESIS EL_AUX .) - COMA reduce using rule 29 (EL -> LEFT_PARENTESIS EL RIGHT_PARENTESIS EL_AUX .) + (33) EL -> LEFT_PARENTESIS EL RIGHT_PARENTESIS EL_AUX . + RIGHT_PARENTESIS reduce using rule 33 (EL -> LEFT_PARENTESIS EL RIGHT_PARENTESIS EL_AUX .) + COMA reduce using rule 33 (EL -> LEFT_PARENTESIS EL RIGHT_PARENTESIS EL_AUX .) -state 122 - (16) B -> IF LEFT_PARENTESIS EL RIGHT_PARENTESIS B ELSE_AUX . ENDIF V B +state 115 + + (20) B -> IF LEFT_PARENTESIS EL RIGHT_PARENTESIS B ELSE_AUX . ENDIF V B - ENDIF shift and go to state 130 + ENDIF shift and go to state 122 -state 123 +state 116 - (24) ELSE_AUX -> ELSE . B - (11) B -> . CALL ID SEMICOLON V B - (12) B -> . ID INDICES EQUAL E SEMICOLON V B - (13) B -> . READ ID SEMICOLON V B - (14) B -> . WRITE STRING WRITE_AUX SEMICOLON V B - (15) B -> . WRITE E WRITE_AUX SEMICOLON V B - (16) B -> . IF LEFT_PARENTESIS EL RIGHT_PARENTESIS B ELSE_AUX ENDIF V B - (17) B -> . WHILE LEFT_PARENTESIS EL RIGHT_PARENTESIS V B ENDWHILE V B - (18) B -> . FOR LEFT_PARENTESIS EL COMA B RIGHT_PARENTESIS V B ENDFOR V B - (19) B -> . + (28) ELSE_AUX -> ELSE . B + (15) B -> . CALL ID SEMICOLON V B + (16) B -> . ID INDICES EQUAL E SEMICOLON V B + (17) B -> . READ ID SEMICOLON V B + (18) B -> . WRITE STRING WRITE_AUX SEMICOLON V B + (19) B -> . WRITE E WRITE_AUX SEMICOLON V B + (20) B -> . IF LEFT_PARENTESIS EL RIGHT_PARENTESIS B ELSE_AUX ENDIF V B + (21) B -> . WHILE LEFT_PARENTESIS EL RIGHT_PARENTESIS V B ENDWHILE V B + (22) B -> . FOR LEFT_PARENTESIS EL COMA B RIGHT_PARENTESIS V B ENDFOR V B + (23) B -> . CALL shift and go to state 10 ID shift and go to state 11 @@ -1825,20 +1799,20 @@ state 123 IF shift and go to state 14 WHILE shift and go to state 15 FOR shift and go to state 16 - ENDIF reduce using rule 19 (B -> .) + ENDIF reduce using rule 23 (B -> .) - B shift and go to state 131 + B shift and go to state 123 -state 124 +state 117 - (17) B -> WHILE LEFT_PARENTESIS EL RIGHT_PARENTESIS V B . ENDWHILE V B + (21) B -> WHILE LEFT_PARENTESIS EL RIGHT_PARENTESIS V B . ENDWHILE V B - ENDWHILE shift and go to state 132 + ENDWHILE shift and go to state 124 -state 125 +state 118 - (18) B -> FOR LEFT_PARENTESIS EL COMA B RIGHT_PARENTESIS . V B ENDFOR V B + (22) B -> FOR LEFT_PARENTESIS EL COMA B RIGHT_PARENTESIS . V B ENDFOR V B (2) V -> . BE VARIABLES SEMICOLON B V (3) V -> . @@ -1852,53 +1826,48 @@ state 125 FOR reduce using rule 3 (V -> .) ENDFOR reduce using rule 3 (V -> .) - V shift and go to state 133 - -state 126 - - (7) VARIABLES -> MATRIX ID LEFT_PARENTESIS CONSTANT COMA CONSTANT . RIGHT_PARENTESIS + V shift and go to state 125 - RIGHT_PARENTESIS shift and go to state 134 - - -state 127 +state 119 - (8) VARIABLES -> CUBE ID LEFT_PARENTESIS CONSTANT COMA CONSTANT . COMA CONSTANT RIGHT_PARENTESIS + (7) VARIABLES -> T ID LEFT_PARENTESIS CONSTANT COMA CONSTANT . RIGHT_PARENTESIS + (8) VARIABLES -> T ID LEFT_PARENTESIS CONSTANT COMA CONSTANT . COMA CONSTANT RIGHT_PARENTESIS - COMA shift and go to state 135 + RIGHT_PARENTESIS shift and go to state 127 + COMA shift and go to state 126 -state 128 +state 120 - (12) B -> ID INDICES EQUAL E SEMICOLON V B . - - FINISH reduce using rule 12 (B -> ID INDICES EQUAL E SEMICOLON V B .) - BE reduce using rule 12 (B -> ID INDICES EQUAL E SEMICOLON V B .) - CALL reduce using rule 12 (B -> ID INDICES EQUAL E SEMICOLON V B .) - ID reduce using rule 12 (B -> ID INDICES EQUAL E SEMICOLON V B .) - READ reduce using rule 12 (B -> ID INDICES EQUAL E SEMICOLON V B .) - WRITE reduce using rule 12 (B -> ID INDICES EQUAL E SEMICOLON V B .) - IF reduce using rule 12 (B -> ID INDICES EQUAL E SEMICOLON V B .) - WHILE reduce using rule 12 (B -> ID INDICES EQUAL E SEMICOLON V B .) - FOR reduce using rule 12 (B -> ID INDICES EQUAL E SEMICOLON V B .) - RETURN reduce using rule 12 (B -> ID INDICES EQUAL E SEMICOLON V B .) - ELSE reduce using rule 12 (B -> ID INDICES EQUAL E SEMICOLON V B .) - ENDIF reduce using rule 12 (B -> ID INDICES EQUAL E SEMICOLON V B .) - RIGHT_PARENTESIS reduce using rule 12 (B -> ID INDICES EQUAL E SEMICOLON V B .) - ENDWHILE reduce using rule 12 (B -> ID INDICES EQUAL E SEMICOLON V B .) - ENDFOR reduce using rule 12 (B -> ID INDICES EQUAL E SEMICOLON V B .) + (16) B -> ID INDICES EQUAL E SEMICOLON V B . + + FINISH reduce using rule 16 (B -> ID INDICES EQUAL E SEMICOLON V B .) + BE reduce using rule 16 (B -> ID INDICES EQUAL E SEMICOLON V B .) + CALL reduce using rule 16 (B -> ID INDICES EQUAL E SEMICOLON V B .) + ID reduce using rule 16 (B -> ID INDICES EQUAL E SEMICOLON V B .) + READ reduce using rule 16 (B -> ID INDICES EQUAL E SEMICOLON V B .) + WRITE reduce using rule 16 (B -> ID INDICES EQUAL E SEMICOLON V B .) + IF reduce using rule 16 (B -> ID INDICES EQUAL E SEMICOLON V B .) + WHILE reduce using rule 16 (B -> ID INDICES EQUAL E SEMICOLON V B .) + FOR reduce using rule 16 (B -> ID INDICES EQUAL E SEMICOLON V B .) + RETURN reduce using rule 16 (B -> ID INDICES EQUAL E SEMICOLON V B .) + ELSE reduce using rule 16 (B -> ID INDICES EQUAL E SEMICOLON V B .) + ENDIF reduce using rule 16 (B -> ID INDICES EQUAL E SEMICOLON V B .) + RIGHT_PARENTESIS reduce using rule 16 (B -> ID INDICES EQUAL E SEMICOLON V B .) + ENDWHILE reduce using rule 16 (B -> ID INDICES EQUAL E SEMICOLON V B .) + ENDFOR reduce using rule 16 (B -> ID INDICES EQUAL E SEMICOLON V B .) -state 129 +state 121 - (22) INDICES -> LEFT_PARENTESIS E COMA E COMA E . RIGHT_PARENTESIS + (26) INDICES -> LEFT_PARENTESIS E COMA E COMA E . RIGHT_PARENTESIS - RIGHT_PARENTESIS shift and go to state 136 + RIGHT_PARENTESIS shift and go to state 128 -state 130 +state 122 - (16) B -> IF LEFT_PARENTESIS EL RIGHT_PARENTESIS B ELSE_AUX ENDIF . V B + (20) B -> IF LEFT_PARENTESIS EL RIGHT_PARENTESIS B ELSE_AUX ENDIF . V B (2) V -> . BE VARIABLES SEMICOLON B V (3) V -> . @@ -1921,18 +1890,18 @@ state 130 ! BE [ reduce using rule 3 (V -> .) ] - V shift and go to state 137 + V shift and go to state 129 -state 131 +state 123 - (24) ELSE_AUX -> ELSE B . + (28) ELSE_AUX -> ELSE B . - ENDIF reduce using rule 24 (ELSE_AUX -> ELSE B .) + ENDIF reduce using rule 28 (ELSE_AUX -> ELSE B .) -state 132 +state 124 - (17) B -> WHILE LEFT_PARENTESIS EL RIGHT_PARENTESIS V B ENDWHILE . V B + (21) B -> WHILE LEFT_PARENTESIS EL RIGHT_PARENTESIS V B ENDWHILE . V B (2) V -> . BE VARIABLES SEMICOLON B V (3) V -> . @@ -1955,20 +1924,20 @@ state 132 ! BE [ reduce using rule 3 (V -> .) ] - V shift and go to state 138 + V shift and go to state 130 -state 133 +state 125 - (18) B -> FOR LEFT_PARENTESIS EL COMA B RIGHT_PARENTESIS V . B ENDFOR V B - (11) B -> . CALL ID SEMICOLON V B - (12) B -> . ID INDICES EQUAL E SEMICOLON V B - (13) B -> . READ ID SEMICOLON V B - (14) B -> . WRITE STRING WRITE_AUX SEMICOLON V B - (15) B -> . WRITE E WRITE_AUX SEMICOLON V B - (16) B -> . IF LEFT_PARENTESIS EL RIGHT_PARENTESIS B ELSE_AUX ENDIF V B - (17) B -> . WHILE LEFT_PARENTESIS EL RIGHT_PARENTESIS V B ENDWHILE V B - (18) B -> . FOR LEFT_PARENTESIS EL COMA B RIGHT_PARENTESIS V B ENDFOR V B - (19) B -> . + (22) B -> FOR LEFT_PARENTESIS EL COMA B RIGHT_PARENTESIS V . B ENDFOR V B + (15) B -> . CALL ID SEMICOLON V B + (16) B -> . ID INDICES EQUAL E SEMICOLON V B + (17) B -> . READ ID SEMICOLON V B + (18) B -> . WRITE STRING WRITE_AUX SEMICOLON V B + (19) B -> . WRITE E WRITE_AUX SEMICOLON V B + (20) B -> . IF LEFT_PARENTESIS EL RIGHT_PARENTESIS B ELSE_AUX ENDIF V B + (21) B -> . WHILE LEFT_PARENTESIS EL RIGHT_PARENTESIS V B ENDWHILE V B + (22) B -> . FOR LEFT_PARENTESIS EL COMA B RIGHT_PARENTESIS V B ENDFOR V B + (23) B -> . CALL shift and go to state 10 ID shift and go to state 11 @@ -1977,50 +1946,50 @@ state 133 IF shift and go to state 14 WHILE shift and go to state 15 FOR shift and go to state 16 - ENDFOR reduce using rule 19 (B -> .) + ENDFOR reduce using rule 23 (B -> .) - B shift and go to state 139 + B shift and go to state 131 -state 134 +state 126 - (7) VARIABLES -> MATRIX ID LEFT_PARENTESIS CONSTANT COMA CONSTANT RIGHT_PARENTESIS . + (8) VARIABLES -> T ID LEFT_PARENTESIS CONSTANT COMA CONSTANT COMA . CONSTANT RIGHT_PARENTESIS - SEMICOLON reduce using rule 7 (VARIABLES -> MATRIX ID LEFT_PARENTESIS CONSTANT COMA CONSTANT RIGHT_PARENTESIS .) + CONSTANT shift and go to state 132 -state 135 +state 127 - (8) VARIABLES -> CUBE ID LEFT_PARENTESIS CONSTANT COMA CONSTANT COMA . CONSTANT RIGHT_PARENTESIS + (7) VARIABLES -> T ID LEFT_PARENTESIS CONSTANT COMA CONSTANT RIGHT_PARENTESIS . - CONSTANT shift and go to state 140 + SEMICOLON reduce using rule 7 (VARIABLES -> T ID LEFT_PARENTESIS CONSTANT COMA CONSTANT RIGHT_PARENTESIS .) -state 136 +state 128 - (22) INDICES -> LEFT_PARENTESIS E COMA E COMA E RIGHT_PARENTESIS . + (26) INDICES -> LEFT_PARENTESIS E COMA E COMA E RIGHT_PARENTESIS . - EQUAL reduce using rule 22 (INDICES -> LEFT_PARENTESIS E COMA E COMA E RIGHT_PARENTESIS .) - PLUS reduce using rule 22 (INDICES -> LEFT_PARENTESIS E COMA E COMA E RIGHT_PARENTESIS .) - STAR reduce using rule 22 (INDICES -> LEFT_PARENTESIS E COMA E COMA E RIGHT_PARENTESIS .) - SLASH reduce using rule 22 (INDICES -> LEFT_PARENTESIS E COMA E COMA E RIGHT_PARENTESIS .) - MINUS reduce using rule 22 (INDICES -> LEFT_PARENTESIS E COMA E COMA E RIGHT_PARENTESIS .) - COMA reduce using rule 22 (INDICES -> LEFT_PARENTESIS E COMA E COMA E RIGHT_PARENTESIS .) - SEMICOLON reduce using rule 22 (INDICES -> LEFT_PARENTESIS E COMA E COMA E RIGHT_PARENTESIS .) - RIGHT_PARENTESIS reduce using rule 22 (INDICES -> LEFT_PARENTESIS E COMA E COMA E RIGHT_PARENTESIS .) + EQUAL reduce using rule 26 (INDICES -> LEFT_PARENTESIS E COMA E COMA E RIGHT_PARENTESIS .) + PLUS reduce using rule 26 (INDICES -> LEFT_PARENTESIS E COMA E COMA E RIGHT_PARENTESIS .) + STAR reduce using rule 26 (INDICES -> LEFT_PARENTESIS E COMA E COMA E RIGHT_PARENTESIS .) + SLASH reduce using rule 26 (INDICES -> LEFT_PARENTESIS E COMA E COMA E RIGHT_PARENTESIS .) + MINUS reduce using rule 26 (INDICES -> LEFT_PARENTESIS E COMA E COMA E RIGHT_PARENTESIS .) + COMA reduce using rule 26 (INDICES -> LEFT_PARENTESIS E COMA E COMA E RIGHT_PARENTESIS .) + SEMICOLON reduce using rule 26 (INDICES -> LEFT_PARENTESIS E COMA E COMA E RIGHT_PARENTESIS .) + RIGHT_PARENTESIS reduce using rule 26 (INDICES -> LEFT_PARENTESIS E COMA E COMA E RIGHT_PARENTESIS .) -state 137 +state 129 - (16) B -> IF LEFT_PARENTESIS EL RIGHT_PARENTESIS B ELSE_AUX ENDIF V . B - (11) B -> . CALL ID SEMICOLON V B - (12) B -> . ID INDICES EQUAL E SEMICOLON V B - (13) B -> . READ ID SEMICOLON V B - (14) B -> . WRITE STRING WRITE_AUX SEMICOLON V B - (15) B -> . WRITE E WRITE_AUX SEMICOLON V B - (16) B -> . IF LEFT_PARENTESIS EL RIGHT_PARENTESIS B ELSE_AUX ENDIF V B - (17) B -> . WHILE LEFT_PARENTESIS EL RIGHT_PARENTESIS V B ENDWHILE V B - (18) B -> . FOR LEFT_PARENTESIS EL COMA B RIGHT_PARENTESIS V B ENDFOR V B - (19) B -> . + (20) B -> IF LEFT_PARENTESIS EL RIGHT_PARENTESIS B ELSE_AUX ENDIF V . B + (15) B -> . CALL ID SEMICOLON V B + (16) B -> . ID INDICES EQUAL E SEMICOLON V B + (17) B -> . READ ID SEMICOLON V B + (18) B -> . WRITE STRING WRITE_AUX SEMICOLON V B + (19) B -> . WRITE E WRITE_AUX SEMICOLON V B + (20) B -> . IF LEFT_PARENTESIS EL RIGHT_PARENTESIS B ELSE_AUX ENDIF V B + (21) B -> . WHILE LEFT_PARENTESIS EL RIGHT_PARENTESIS V B ENDWHILE V B + (22) B -> . FOR LEFT_PARENTESIS EL COMA B RIGHT_PARENTESIS V B ENDFOR V B + (23) B -> . ! shift/reduce conflict for CALL resolved as shift ! shift/reduce conflict for ID resolved as shift @@ -2036,37 +2005,37 @@ state 137 IF shift and go to state 14 WHILE shift and go to state 15 FOR shift and go to state 16 - BE reduce using rule 19 (B -> .) - FINISH reduce using rule 19 (B -> .) - RETURN reduce using rule 19 (B -> .) - ELSE reduce using rule 19 (B -> .) - ENDIF reduce using rule 19 (B -> .) - RIGHT_PARENTESIS reduce using rule 19 (B -> .) - ENDWHILE reduce using rule 19 (B -> .) - ENDFOR reduce using rule 19 (B -> .) - - ! CALL [ reduce using rule 19 (B -> .) ] - ! ID [ reduce using rule 19 (B -> .) ] - ! READ [ reduce using rule 19 (B -> .) ] - ! WRITE [ reduce using rule 19 (B -> .) ] - ! IF [ reduce using rule 19 (B -> .) ] - ! WHILE [ reduce using rule 19 (B -> .) ] - ! FOR [ reduce using rule 19 (B -> .) ] - - B shift and go to state 141 + BE reduce using rule 23 (B -> .) + FINISH reduce using rule 23 (B -> .) + RETURN reduce using rule 23 (B -> .) + ELSE reduce using rule 23 (B -> .) + ENDIF reduce using rule 23 (B -> .) + RIGHT_PARENTESIS reduce using rule 23 (B -> .) + ENDWHILE reduce using rule 23 (B -> .) + ENDFOR reduce using rule 23 (B -> .) + + ! CALL [ reduce using rule 23 (B -> .) ] + ! ID [ reduce using rule 23 (B -> .) ] + ! READ [ reduce using rule 23 (B -> .) ] + ! WRITE [ reduce using rule 23 (B -> .) ] + ! IF [ reduce using rule 23 (B -> .) ] + ! WHILE [ reduce using rule 23 (B -> .) ] + ! FOR [ reduce using rule 23 (B -> .) ] + + B shift and go to state 133 -state 138 +state 130 - (17) B -> WHILE LEFT_PARENTESIS EL RIGHT_PARENTESIS V B ENDWHILE V . B - (11) B -> . CALL ID SEMICOLON V B - (12) B -> . ID INDICES EQUAL E SEMICOLON V B - (13) B -> . READ ID SEMICOLON V B - (14) B -> . WRITE STRING WRITE_AUX SEMICOLON V B - (15) B -> . WRITE E WRITE_AUX SEMICOLON V B - (16) B -> . IF LEFT_PARENTESIS EL RIGHT_PARENTESIS B ELSE_AUX ENDIF V B - (17) B -> . WHILE LEFT_PARENTESIS EL RIGHT_PARENTESIS V B ENDWHILE V B - (18) B -> . FOR LEFT_PARENTESIS EL COMA B RIGHT_PARENTESIS V B ENDFOR V B - (19) B -> . + (21) B -> WHILE LEFT_PARENTESIS EL RIGHT_PARENTESIS V B ENDWHILE V . B + (15) B -> . CALL ID SEMICOLON V B + (16) B -> . ID INDICES EQUAL E SEMICOLON V B + (17) B -> . READ ID SEMICOLON V B + (18) B -> . WRITE STRING WRITE_AUX SEMICOLON V B + (19) B -> . WRITE E WRITE_AUX SEMICOLON V B + (20) B -> . IF LEFT_PARENTESIS EL RIGHT_PARENTESIS B ELSE_AUX ENDIF V B + (21) B -> . WHILE LEFT_PARENTESIS EL RIGHT_PARENTESIS V B ENDWHILE V B + (22) B -> . FOR LEFT_PARENTESIS EL COMA B RIGHT_PARENTESIS V B ENDFOR V B + (23) B -> . ! shift/reduce conflict for CALL resolved as shift ! shift/reduce conflict for ID resolved as shift @@ -2082,84 +2051,84 @@ state 138 IF shift and go to state 14 WHILE shift and go to state 15 FOR shift and go to state 16 - BE reduce using rule 19 (B -> .) - FINISH reduce using rule 19 (B -> .) - RETURN reduce using rule 19 (B -> .) - ELSE reduce using rule 19 (B -> .) - ENDIF reduce using rule 19 (B -> .) - RIGHT_PARENTESIS reduce using rule 19 (B -> .) - ENDWHILE reduce using rule 19 (B -> .) - ENDFOR reduce using rule 19 (B -> .) + BE reduce using rule 23 (B -> .) + FINISH reduce using rule 23 (B -> .) + RETURN reduce using rule 23 (B -> .) + ELSE reduce using rule 23 (B -> .) + ENDIF reduce using rule 23 (B -> .) + RIGHT_PARENTESIS reduce using rule 23 (B -> .) + ENDWHILE reduce using rule 23 (B -> .) + ENDFOR reduce using rule 23 (B -> .) + + ! CALL [ reduce using rule 23 (B -> .) ] + ! ID [ reduce using rule 23 (B -> .) ] + ! READ [ reduce using rule 23 (B -> .) ] + ! WRITE [ reduce using rule 23 (B -> .) ] + ! IF [ reduce using rule 23 (B -> .) ] + ! WHILE [ reduce using rule 23 (B -> .) ] + ! FOR [ reduce using rule 23 (B -> .) ] + + B shift and go to state 134 - ! CALL [ reduce using rule 19 (B -> .) ] - ! ID [ reduce using rule 19 (B -> .) ] - ! READ [ reduce using rule 19 (B -> .) ] - ! WRITE [ reduce using rule 19 (B -> .) ] - ! IF [ reduce using rule 19 (B -> .) ] - ! WHILE [ reduce using rule 19 (B -> .) ] - ! FOR [ reduce using rule 19 (B -> .) ] - - B shift and go to state 142 - -state 139 - - (18) B -> FOR LEFT_PARENTESIS EL COMA B RIGHT_PARENTESIS V B . ENDFOR V B - - ENDFOR shift and go to state 143 +state 131 + (22) B -> FOR LEFT_PARENTESIS EL COMA B RIGHT_PARENTESIS V B . ENDFOR V B -state 140 + ENDFOR shift and go to state 135 - (8) VARIABLES -> CUBE ID LEFT_PARENTESIS CONSTANT COMA CONSTANT COMA CONSTANT . RIGHT_PARENTESIS - RIGHT_PARENTESIS shift and go to state 144 +state 132 + (8) VARIABLES -> T ID LEFT_PARENTESIS CONSTANT COMA CONSTANT COMA CONSTANT . RIGHT_PARENTESIS -state 141 + RIGHT_PARENTESIS shift and go to state 136 - (16) B -> IF LEFT_PARENTESIS EL RIGHT_PARENTESIS B ELSE_AUX ENDIF V B . - FINISH reduce using rule 16 (B -> IF LEFT_PARENTESIS EL RIGHT_PARENTESIS B ELSE_AUX ENDIF V B .) - BE reduce using rule 16 (B -> IF LEFT_PARENTESIS EL RIGHT_PARENTESIS B ELSE_AUX ENDIF V B .) - CALL reduce using rule 16 (B -> IF LEFT_PARENTESIS EL RIGHT_PARENTESIS B ELSE_AUX ENDIF V B .) - ID reduce using rule 16 (B -> IF LEFT_PARENTESIS EL RIGHT_PARENTESIS B ELSE_AUX ENDIF V B .) - READ reduce using rule 16 (B -> IF LEFT_PARENTESIS EL RIGHT_PARENTESIS B ELSE_AUX ENDIF V B .) - WRITE reduce using rule 16 (B -> IF LEFT_PARENTESIS EL RIGHT_PARENTESIS B ELSE_AUX ENDIF V B .) - IF reduce using rule 16 (B -> IF LEFT_PARENTESIS EL RIGHT_PARENTESIS B ELSE_AUX ENDIF V B .) - WHILE reduce using rule 16 (B -> IF LEFT_PARENTESIS EL RIGHT_PARENTESIS B ELSE_AUX ENDIF V B .) - FOR reduce using rule 16 (B -> IF LEFT_PARENTESIS EL RIGHT_PARENTESIS B ELSE_AUX ENDIF V B .) - RETURN reduce using rule 16 (B -> IF LEFT_PARENTESIS EL RIGHT_PARENTESIS B ELSE_AUX ENDIF V B .) - ELSE reduce using rule 16 (B -> IF LEFT_PARENTESIS EL RIGHT_PARENTESIS B ELSE_AUX ENDIF V B .) - ENDIF reduce using rule 16 (B -> IF LEFT_PARENTESIS EL RIGHT_PARENTESIS B ELSE_AUX ENDIF V B .) - RIGHT_PARENTESIS reduce using rule 16 (B -> IF LEFT_PARENTESIS EL RIGHT_PARENTESIS B ELSE_AUX ENDIF V B .) - ENDWHILE reduce using rule 16 (B -> IF LEFT_PARENTESIS EL RIGHT_PARENTESIS B ELSE_AUX ENDIF V B .) - ENDFOR reduce using rule 16 (B -> IF LEFT_PARENTESIS EL RIGHT_PARENTESIS B ELSE_AUX ENDIF V B .) +state 133 + (20) B -> IF LEFT_PARENTESIS EL RIGHT_PARENTESIS B ELSE_AUX ENDIF V B . + + FINISH reduce using rule 20 (B -> IF LEFT_PARENTESIS EL RIGHT_PARENTESIS B ELSE_AUX ENDIF V B .) + BE reduce using rule 20 (B -> IF LEFT_PARENTESIS EL RIGHT_PARENTESIS B ELSE_AUX ENDIF V B .) + CALL reduce using rule 20 (B -> IF LEFT_PARENTESIS EL RIGHT_PARENTESIS B ELSE_AUX ENDIF V B .) + ID reduce using rule 20 (B -> IF LEFT_PARENTESIS EL RIGHT_PARENTESIS B ELSE_AUX ENDIF V B .) + READ reduce using rule 20 (B -> IF LEFT_PARENTESIS EL RIGHT_PARENTESIS B ELSE_AUX ENDIF V B .) + WRITE reduce using rule 20 (B -> IF LEFT_PARENTESIS EL RIGHT_PARENTESIS B ELSE_AUX ENDIF V B .) + IF reduce using rule 20 (B -> IF LEFT_PARENTESIS EL RIGHT_PARENTESIS B ELSE_AUX ENDIF V B .) + WHILE reduce using rule 20 (B -> IF LEFT_PARENTESIS EL RIGHT_PARENTESIS B ELSE_AUX ENDIF V B .) + FOR reduce using rule 20 (B -> IF LEFT_PARENTESIS EL RIGHT_PARENTESIS B ELSE_AUX ENDIF V B .) + RETURN reduce using rule 20 (B -> IF LEFT_PARENTESIS EL RIGHT_PARENTESIS B ELSE_AUX ENDIF V B .) + ELSE reduce using rule 20 (B -> IF LEFT_PARENTESIS EL RIGHT_PARENTESIS B ELSE_AUX ENDIF V B .) + ENDIF reduce using rule 20 (B -> IF LEFT_PARENTESIS EL RIGHT_PARENTESIS B ELSE_AUX ENDIF V B .) + RIGHT_PARENTESIS reduce using rule 20 (B -> IF LEFT_PARENTESIS EL RIGHT_PARENTESIS B ELSE_AUX ENDIF V B .) + ENDWHILE reduce using rule 20 (B -> IF LEFT_PARENTESIS EL RIGHT_PARENTESIS B ELSE_AUX ENDIF V B .) + ENDFOR reduce using rule 20 (B -> IF LEFT_PARENTESIS EL RIGHT_PARENTESIS B ELSE_AUX ENDIF V B .) -state 142 - (17) B -> WHILE LEFT_PARENTESIS EL RIGHT_PARENTESIS V B ENDWHILE V B . +state 134 - FINISH reduce using rule 17 (B -> WHILE LEFT_PARENTESIS EL RIGHT_PARENTESIS V B ENDWHILE V B .) - BE reduce using rule 17 (B -> WHILE LEFT_PARENTESIS EL RIGHT_PARENTESIS V B ENDWHILE V B .) - CALL reduce using rule 17 (B -> WHILE LEFT_PARENTESIS EL RIGHT_PARENTESIS V B ENDWHILE V B .) - ID reduce using rule 17 (B -> WHILE LEFT_PARENTESIS EL RIGHT_PARENTESIS V B ENDWHILE V B .) - READ reduce using rule 17 (B -> WHILE LEFT_PARENTESIS EL RIGHT_PARENTESIS V B ENDWHILE V B .) - WRITE reduce using rule 17 (B -> WHILE LEFT_PARENTESIS EL RIGHT_PARENTESIS V B ENDWHILE V B .) - IF reduce using rule 17 (B -> WHILE LEFT_PARENTESIS EL RIGHT_PARENTESIS V B ENDWHILE V B .) - WHILE reduce using rule 17 (B -> WHILE LEFT_PARENTESIS EL RIGHT_PARENTESIS V B ENDWHILE V B .) - FOR reduce using rule 17 (B -> WHILE LEFT_PARENTESIS EL RIGHT_PARENTESIS V B ENDWHILE V B .) - RETURN reduce using rule 17 (B -> WHILE LEFT_PARENTESIS EL RIGHT_PARENTESIS V B ENDWHILE V B .) - ELSE reduce using rule 17 (B -> WHILE LEFT_PARENTESIS EL RIGHT_PARENTESIS V B ENDWHILE V B .) - ENDIF reduce using rule 17 (B -> WHILE LEFT_PARENTESIS EL RIGHT_PARENTESIS V B ENDWHILE V B .) - RIGHT_PARENTESIS reduce using rule 17 (B -> WHILE LEFT_PARENTESIS EL RIGHT_PARENTESIS V B ENDWHILE V B .) - ENDWHILE reduce using rule 17 (B -> WHILE LEFT_PARENTESIS EL RIGHT_PARENTESIS V B ENDWHILE V B .) - ENDFOR reduce using rule 17 (B -> WHILE LEFT_PARENTESIS EL RIGHT_PARENTESIS V B ENDWHILE V B .) + (21) B -> WHILE LEFT_PARENTESIS EL RIGHT_PARENTESIS V B ENDWHILE V B . + + FINISH reduce using rule 21 (B -> WHILE LEFT_PARENTESIS EL RIGHT_PARENTESIS V B ENDWHILE V B .) + BE reduce using rule 21 (B -> WHILE LEFT_PARENTESIS EL RIGHT_PARENTESIS V B ENDWHILE V B .) + CALL reduce using rule 21 (B -> WHILE LEFT_PARENTESIS EL RIGHT_PARENTESIS V B ENDWHILE V B .) + ID reduce using rule 21 (B -> WHILE LEFT_PARENTESIS EL RIGHT_PARENTESIS V B ENDWHILE V B .) + READ reduce using rule 21 (B -> WHILE LEFT_PARENTESIS EL RIGHT_PARENTESIS V B ENDWHILE V B .) + WRITE reduce using rule 21 (B -> WHILE LEFT_PARENTESIS EL RIGHT_PARENTESIS V B ENDWHILE V B .) + IF reduce using rule 21 (B -> WHILE LEFT_PARENTESIS EL RIGHT_PARENTESIS V B ENDWHILE V B .) + WHILE reduce using rule 21 (B -> WHILE LEFT_PARENTESIS EL RIGHT_PARENTESIS V B ENDWHILE V B .) + FOR reduce using rule 21 (B -> WHILE LEFT_PARENTESIS EL RIGHT_PARENTESIS V B ENDWHILE V B .) + RETURN reduce using rule 21 (B -> WHILE LEFT_PARENTESIS EL RIGHT_PARENTESIS V B ENDWHILE V B .) + ELSE reduce using rule 21 (B -> WHILE LEFT_PARENTESIS EL RIGHT_PARENTESIS V B ENDWHILE V B .) + ENDIF reduce using rule 21 (B -> WHILE LEFT_PARENTESIS EL RIGHT_PARENTESIS V B ENDWHILE V B .) + RIGHT_PARENTESIS reduce using rule 21 (B -> WHILE LEFT_PARENTESIS EL RIGHT_PARENTESIS V B ENDWHILE V B .) + ENDWHILE reduce using rule 21 (B -> WHILE LEFT_PARENTESIS EL RIGHT_PARENTESIS V B ENDWHILE V B .) + ENDFOR reduce using rule 21 (B -> WHILE LEFT_PARENTESIS EL RIGHT_PARENTESIS V B ENDWHILE V B .) -state 143 +state 135 - (18) B -> FOR LEFT_PARENTESIS EL COMA B RIGHT_PARENTESIS V B ENDFOR . V B + (22) B -> FOR LEFT_PARENTESIS EL COMA B RIGHT_PARENTESIS V B ENDFOR . V B (2) V -> . BE VARIABLES SEMICOLON B V (3) V -> . @@ -2182,27 +2151,27 @@ state 143 ! BE [ reduce using rule 3 (V -> .) ] - V shift and go to state 145 + V shift and go to state 137 -state 144 +state 136 - (8) VARIABLES -> CUBE ID LEFT_PARENTESIS CONSTANT COMA CONSTANT COMA CONSTANT RIGHT_PARENTESIS . + (8) VARIABLES -> T ID LEFT_PARENTESIS CONSTANT COMA CONSTANT COMA CONSTANT RIGHT_PARENTESIS . - SEMICOLON reduce using rule 8 (VARIABLES -> CUBE ID LEFT_PARENTESIS CONSTANT COMA CONSTANT COMA CONSTANT RIGHT_PARENTESIS .) + SEMICOLON reduce using rule 8 (VARIABLES -> T ID LEFT_PARENTESIS CONSTANT COMA CONSTANT COMA CONSTANT RIGHT_PARENTESIS .) -state 145 +state 137 - (18) B -> FOR LEFT_PARENTESIS EL COMA B RIGHT_PARENTESIS V B ENDFOR V . B - (11) B -> . CALL ID SEMICOLON V B - (12) B -> . ID INDICES EQUAL E SEMICOLON V B - (13) B -> . READ ID SEMICOLON V B - (14) B -> . WRITE STRING WRITE_AUX SEMICOLON V B - (15) B -> . WRITE E WRITE_AUX SEMICOLON V B - (16) B -> . IF LEFT_PARENTESIS EL RIGHT_PARENTESIS B ELSE_AUX ENDIF V B - (17) B -> . WHILE LEFT_PARENTESIS EL RIGHT_PARENTESIS V B ENDWHILE V B - (18) B -> . FOR LEFT_PARENTESIS EL COMA B RIGHT_PARENTESIS V B ENDFOR V B - (19) B -> . + (22) B -> FOR LEFT_PARENTESIS EL COMA B RIGHT_PARENTESIS V B ENDFOR V . B + (15) B -> . CALL ID SEMICOLON V B + (16) B -> . ID INDICES EQUAL E SEMICOLON V B + (17) B -> . READ ID SEMICOLON V B + (18) B -> . WRITE STRING WRITE_AUX SEMICOLON V B + (19) B -> . WRITE E WRITE_AUX SEMICOLON V B + (20) B -> . IF LEFT_PARENTESIS EL RIGHT_PARENTESIS B ELSE_AUX ENDIF V B + (21) B -> . WHILE LEFT_PARENTESIS EL RIGHT_PARENTESIS V B ENDWHILE V B + (22) B -> . FOR LEFT_PARENTESIS EL COMA B RIGHT_PARENTESIS V B ENDFOR V B + (23) B -> . ! shift/reduce conflict for CALL resolved as shift ! shift/reduce conflict for ID resolved as shift @@ -2218,58 +2187,65 @@ state 145 IF shift and go to state 14 WHILE shift and go to state 15 FOR shift and go to state 16 - BE reduce using rule 19 (B -> .) - FINISH reduce using rule 19 (B -> .) - RETURN reduce using rule 19 (B -> .) - ELSE reduce using rule 19 (B -> .) - ENDIF reduce using rule 19 (B -> .) - RIGHT_PARENTESIS reduce using rule 19 (B -> .) - ENDWHILE reduce using rule 19 (B -> .) - ENDFOR reduce using rule 19 (B -> .) - - ! CALL [ reduce using rule 19 (B -> .) ] - ! ID [ reduce using rule 19 (B -> .) ] - ! READ [ reduce using rule 19 (B -> .) ] - ! WRITE [ reduce using rule 19 (B -> .) ] - ! IF [ reduce using rule 19 (B -> .) ] - ! WHILE [ reduce using rule 19 (B -> .) ] - ! FOR [ reduce using rule 19 (B -> .) ] - - B shift and go to state 146 - -state 146 - - (18) B -> FOR LEFT_PARENTESIS EL COMA B RIGHT_PARENTESIS V B ENDFOR V B . - - FINISH reduce using rule 18 (B -> FOR LEFT_PARENTESIS EL COMA B RIGHT_PARENTESIS V B ENDFOR V B .) - BE reduce using rule 18 (B -> FOR LEFT_PARENTESIS EL COMA B RIGHT_PARENTESIS V B ENDFOR V B .) - CALL reduce using rule 18 (B -> FOR LEFT_PARENTESIS EL COMA B RIGHT_PARENTESIS V B ENDFOR V B .) - ID reduce using rule 18 (B -> FOR LEFT_PARENTESIS EL COMA B RIGHT_PARENTESIS V B ENDFOR V B .) - READ reduce using rule 18 (B -> FOR LEFT_PARENTESIS EL COMA B RIGHT_PARENTESIS V B ENDFOR V B .) - WRITE reduce using rule 18 (B -> FOR LEFT_PARENTESIS EL COMA B RIGHT_PARENTESIS V B ENDFOR V B .) - IF reduce using rule 18 (B -> FOR LEFT_PARENTESIS EL COMA B RIGHT_PARENTESIS V B ENDFOR V B .) - WHILE reduce using rule 18 (B -> FOR LEFT_PARENTESIS EL COMA B RIGHT_PARENTESIS V B ENDFOR V B .) - FOR reduce using rule 18 (B -> FOR LEFT_PARENTESIS EL COMA B RIGHT_PARENTESIS V B ENDFOR V B .) - RETURN reduce using rule 18 (B -> FOR LEFT_PARENTESIS EL COMA B RIGHT_PARENTESIS V B ENDFOR V B .) - ELSE reduce using rule 18 (B -> FOR LEFT_PARENTESIS EL COMA B RIGHT_PARENTESIS V B ENDFOR V B .) - ENDIF reduce using rule 18 (B -> FOR LEFT_PARENTESIS EL COMA B RIGHT_PARENTESIS V B ENDFOR V B .) - RIGHT_PARENTESIS reduce using rule 18 (B -> FOR LEFT_PARENTESIS EL COMA B RIGHT_PARENTESIS V B ENDFOR V B .) - ENDWHILE reduce using rule 18 (B -> FOR LEFT_PARENTESIS EL COMA B RIGHT_PARENTESIS V B ENDFOR V B .) - ENDFOR reduce using rule 18 (B -> FOR LEFT_PARENTESIS EL COMA B RIGHT_PARENTESIS V B ENDFOR V B .) + BE reduce using rule 23 (B -> .) + FINISH reduce using rule 23 (B -> .) + RETURN reduce using rule 23 (B -> .) + ELSE reduce using rule 23 (B -> .) + ENDIF reduce using rule 23 (B -> .) + RIGHT_PARENTESIS reduce using rule 23 (B -> .) + ENDWHILE reduce using rule 23 (B -> .) + ENDFOR reduce using rule 23 (B -> .) + + ! CALL [ reduce using rule 23 (B -> .) ] + ! ID [ reduce using rule 23 (B -> .) ] + ! READ [ reduce using rule 23 (B -> .) ] + ! WRITE [ reduce using rule 23 (B -> .) ] + ! IF [ reduce using rule 23 (B -> .) ] + ! WHILE [ reduce using rule 23 (B -> .) ] + ! FOR [ reduce using rule 23 (B -> .) ] + + B shift and go to state 138 + +state 138 + + (22) B -> FOR LEFT_PARENTESIS EL COMA B RIGHT_PARENTESIS V B ENDFOR V B . + + FINISH reduce using rule 22 (B -> FOR LEFT_PARENTESIS EL COMA B RIGHT_PARENTESIS V B ENDFOR V B .) + BE reduce using rule 22 (B -> FOR LEFT_PARENTESIS EL COMA B RIGHT_PARENTESIS V B ENDFOR V B .) + CALL reduce using rule 22 (B -> FOR LEFT_PARENTESIS EL COMA B RIGHT_PARENTESIS V B ENDFOR V B .) + ID reduce using rule 22 (B -> FOR LEFT_PARENTESIS EL COMA B RIGHT_PARENTESIS V B ENDFOR V B .) + READ reduce using rule 22 (B -> FOR LEFT_PARENTESIS EL COMA B RIGHT_PARENTESIS V B ENDFOR V B .) + WRITE reduce using rule 22 (B -> FOR LEFT_PARENTESIS EL COMA B RIGHT_PARENTESIS V B ENDFOR V B .) + IF reduce using rule 22 (B -> FOR LEFT_PARENTESIS EL COMA B RIGHT_PARENTESIS V B ENDFOR V B .) + WHILE reduce using rule 22 (B -> FOR LEFT_PARENTESIS EL COMA B RIGHT_PARENTESIS V B ENDFOR V B .) + FOR reduce using rule 22 (B -> FOR LEFT_PARENTESIS EL COMA B RIGHT_PARENTESIS V B ENDFOR V B .) + RETURN reduce using rule 22 (B -> FOR LEFT_PARENTESIS EL COMA B RIGHT_PARENTESIS V B ENDFOR V B .) + ELSE reduce using rule 22 (B -> FOR LEFT_PARENTESIS EL COMA B RIGHT_PARENTESIS V B ENDFOR V B .) + ENDIF reduce using rule 22 (B -> FOR LEFT_PARENTESIS EL COMA B RIGHT_PARENTESIS V B ENDFOR V B .) + RIGHT_PARENTESIS reduce using rule 22 (B -> FOR LEFT_PARENTESIS EL COMA B RIGHT_PARENTESIS V B ENDFOR V B .) + ENDWHILE reduce using rule 22 (B -> FOR LEFT_PARENTESIS EL COMA B RIGHT_PARENTESIS V B ENDFOR V B .) + ENDFOR reduce using rule 22 (B -> FOR LEFT_PARENTESIS EL COMA B RIGHT_PARENTESIS V B ENDFOR V B .) WARNING: WARNING: Conflicts: WARNING: -WARNING: shift/reduce conflict for CALL in state 37 resolved as shift -WARNING: shift/reduce conflict for ID in state 37 resolved as shift -WARNING: shift/reduce conflict for READ in state 37 resolved as shift -WARNING: shift/reduce conflict for WRITE in state 37 resolved as shift -WARNING: shift/reduce conflict for IF in state 37 resolved as shift -WARNING: shift/reduce conflict for WHILE in state 37 resolved as shift -WARNING: shift/reduce conflict for FOR in state 37 resolved as shift -WARNING: shift/reduce conflict for BE in state 45 resolved as shift -WARNING: shift/reduce conflict for BE in state 48 resolved as shift -WARNING: shift/reduce conflict for BE in state 65 resolved as shift +WARNING: shift/reduce conflict for CALL in state 38 resolved as shift +WARNING: shift/reduce conflict for ID in state 38 resolved as shift +WARNING: shift/reduce conflict for READ in state 38 resolved as shift +WARNING: shift/reduce conflict for WRITE in state 38 resolved as shift +WARNING: shift/reduce conflict for IF in state 38 resolved as shift +WARNING: shift/reduce conflict for WHILE in state 38 resolved as shift +WARNING: shift/reduce conflict for FOR in state 38 resolved as shift +WARNING: shift/reduce conflict for BE in state 43 resolved as shift +WARNING: shift/reduce conflict for BE in state 46 resolved as shift +WARNING: shift/reduce conflict for BE in state 63 resolved as shift +WARNING: shift/reduce conflict for CALL in state 66 resolved as shift +WARNING: shift/reduce conflict for ID in state 66 resolved as shift +WARNING: shift/reduce conflict for READ in state 66 resolved as shift +WARNING: shift/reduce conflict for WRITE in state 66 resolved as shift +WARNING: shift/reduce conflict for IF in state 66 resolved as shift +WARNING: shift/reduce conflict for WHILE in state 66 resolved as shift +WARNING: shift/reduce conflict for FOR in state 66 resolved as shift WARNING: shift/reduce conflict for CALL in state 70 resolved as shift WARNING: shift/reduce conflict for ID in state 70 resolved as shift WARNING: shift/reduce conflict for READ in state 70 resolved as shift @@ -2277,39 +2253,47 @@ WARNING: shift/reduce conflict for WRITE in state 70 resolved as shift WARNING: shift/reduce conflict for IF in state 70 resolved as shift WARNING: shift/reduce conflict for WHILE in state 70 resolved as shift WARNING: shift/reduce conflict for FOR in state 70 resolved as shift -WARNING: shift/reduce conflict for CALL in state 74 resolved as shift -WARNING: shift/reduce conflict for ID in state 74 resolved as shift -WARNING: shift/reduce conflict for READ in state 74 resolved as shift -WARNING: shift/reduce conflict for WRITE in state 74 resolved as shift -WARNING: shift/reduce conflict for IF in state 74 resolved as shift -WARNING: shift/reduce conflict for WHILE in state 74 resolved as shift -WARNING: shift/reduce conflict for FOR in state 74 resolved as shift -WARNING: shift/reduce conflict for BE in state 75 resolved as shift -WARNING: shift/reduce conflict for BE in state 78 resolved as shift -WARNING: shift/reduce conflict for BE in state 98 resolved as shift -WARNING: shift/reduce conflict for CALL in state 101 resolved as shift -WARNING: shift/reduce conflict for ID in state 101 resolved as shift -WARNING: shift/reduce conflict for READ in state 101 resolved as shift -WARNING: shift/reduce conflict for WRITE in state 101 resolved as shift -WARNING: shift/reduce conflict for IF in state 101 resolved as shift -WARNING: shift/reduce conflict for WHILE in state 101 resolved as shift -WARNING: shift/reduce conflict for FOR in state 101 resolved as shift -WARNING: shift/reduce conflict for CALL in state 104 resolved as shift -WARNING: shift/reduce conflict for ID in state 104 resolved as shift -WARNING: shift/reduce conflict for READ in state 104 resolved as shift -WARNING: shift/reduce conflict for WRITE in state 104 resolved as shift -WARNING: shift/reduce conflict for IF in state 104 resolved as shift -WARNING: shift/reduce conflict for WHILE in state 104 resolved as shift -WARNING: shift/reduce conflict for FOR in state 104 resolved as shift -WARNING: shift/reduce conflict for CALL in state 115 resolved as shift -WARNING: shift/reduce conflict for ID in state 115 resolved as shift -WARNING: shift/reduce conflict for READ in state 115 resolved as shift -WARNING: shift/reduce conflict for WRITE in state 115 resolved as shift -WARNING: shift/reduce conflict for IF in state 115 resolved as shift -WARNING: shift/reduce conflict for WHILE in state 115 resolved as shift -WARNING: shift/reduce conflict for FOR in state 115 resolved as shift -WARNING: shift/reduce conflict for BE in state 130 resolved as shift -WARNING: shift/reduce conflict for BE in state 132 resolved as shift +WARNING: shift/reduce conflict for BE in state 71 resolved as shift +WARNING: shift/reduce conflict for BE in state 74 resolved as shift +WARNING: shift/reduce conflict for BE in state 92 resolved as shift +WARNING: shift/reduce conflict for CALL in state 95 resolved as shift +WARNING: shift/reduce conflict for ID in state 95 resolved as shift +WARNING: shift/reduce conflict for READ in state 95 resolved as shift +WARNING: shift/reduce conflict for WRITE in state 95 resolved as shift +WARNING: shift/reduce conflict for IF in state 95 resolved as shift +WARNING: shift/reduce conflict for WHILE in state 95 resolved as shift +WARNING: shift/reduce conflict for FOR in state 95 resolved as shift +WARNING: shift/reduce conflict for CALL in state 98 resolved as shift +WARNING: shift/reduce conflict for ID in state 98 resolved as shift +WARNING: shift/reduce conflict for READ in state 98 resolved as shift +WARNING: shift/reduce conflict for WRITE in state 98 resolved as shift +WARNING: shift/reduce conflict for IF in state 98 resolved as shift +WARNING: shift/reduce conflict for WHILE in state 98 resolved as shift +WARNING: shift/reduce conflict for FOR in state 98 resolved as shift +WARNING: shift/reduce conflict for CALL in state 108 resolved as shift +WARNING: shift/reduce conflict for ID in state 108 resolved as shift +WARNING: shift/reduce conflict for READ in state 108 resolved as shift +WARNING: shift/reduce conflict for WRITE in state 108 resolved as shift +WARNING: shift/reduce conflict for IF in state 108 resolved as shift +WARNING: shift/reduce conflict for WHILE in state 108 resolved as shift +WARNING: shift/reduce conflict for FOR in state 108 resolved as shift +WARNING: shift/reduce conflict for BE in state 122 resolved as shift +WARNING: shift/reduce conflict for BE in state 124 resolved as shift +WARNING: shift/reduce conflict for CALL in state 129 resolved as shift +WARNING: shift/reduce conflict for ID in state 129 resolved as shift +WARNING: shift/reduce conflict for READ in state 129 resolved as shift +WARNING: shift/reduce conflict for WRITE in state 129 resolved as shift +WARNING: shift/reduce conflict for IF in state 129 resolved as shift +WARNING: shift/reduce conflict for WHILE in state 129 resolved as shift +WARNING: shift/reduce conflict for FOR in state 129 resolved as shift +WARNING: shift/reduce conflict for CALL in state 130 resolved as shift +WARNING: shift/reduce conflict for ID in state 130 resolved as shift +WARNING: shift/reduce conflict for READ in state 130 resolved as shift +WARNING: shift/reduce conflict for WRITE in state 130 resolved as shift +WARNING: shift/reduce conflict for IF in state 130 resolved as shift +WARNING: shift/reduce conflict for WHILE in state 130 resolved as shift +WARNING: shift/reduce conflict for FOR in state 130 resolved as shift +WARNING: shift/reduce conflict for BE in state 135 resolved as shift WARNING: shift/reduce conflict for CALL in state 137 resolved as shift WARNING: shift/reduce conflict for ID in state 137 resolved as shift WARNING: shift/reduce conflict for READ in state 137 resolved as shift @@ -2317,18 +2301,3 @@ WARNING: shift/reduce conflict for WRITE in state 137 resolved as shift WARNING: shift/reduce conflict for IF in state 137 resolved as shift WARNING: shift/reduce conflict for WHILE in state 137 resolved as shift WARNING: shift/reduce conflict for FOR in state 137 resolved as shift -WARNING: shift/reduce conflict for CALL in state 138 resolved as shift -WARNING: shift/reduce conflict for ID in state 138 resolved as shift -WARNING: shift/reduce conflict for READ in state 138 resolved as shift -WARNING: shift/reduce conflict for WRITE in state 138 resolved as shift -WARNING: shift/reduce conflict for IF in state 138 resolved as shift -WARNING: shift/reduce conflict for WHILE in state 138 resolved as shift -WARNING: shift/reduce conflict for FOR in state 138 resolved as shift -WARNING: shift/reduce conflict for BE in state 143 resolved as shift -WARNING: shift/reduce conflict for CALL in state 145 resolved as shift -WARNING: shift/reduce conflict for ID in state 145 resolved as shift -WARNING: shift/reduce conflict for READ in state 145 resolved as shift -WARNING: shift/reduce conflict for WRITE in state 145 resolved as shift -WARNING: shift/reduce conflict for IF in state 145 resolved as shift -WARNING: shift/reduce conflict for WHILE in state 145 resolved as shift -WARNING: shift/reduce conflict for FOR in state 145 resolved as shift diff --git a/parsetab.py b/parsetab.py index 3f9bea1..3a026d8 100644 --- a/parsetab.py +++ b/parsetab.py @@ -6,9 +6,9 @@ _lr_method = 'LALR' -_lr_signature = 'AND BE BOOLEAN_EXPRESSION CALL COMA COMPARISON CONSTANT CUBE ELSE ENDFOR ENDIF ENDWHILE EQUAL EQUAL_EQUAL FINISH FLOAT FOR GREATER_THAN GREATER_THAN_EQUAL ID IF INT LEFT_PARENTESIS LENGTH LENGTH_I LENGTH_J LENGTH_K LESS_THAN LESS_THAN_EQUAL MATHEMATICAL_CONSTANT MATHEMATICAL_EXPRESSION MATRIX MEAN MEDIAN MINUS MODE NOT NOT_EQUAL OR PLUS READ RETURN RIGHT_PARENTESIS ROUTINE RREF SEMICOLON SLASH STAR START STRING VECTOR WHILE WRITE\n PROGRAMA : R START V B FINISH R\n \n V : BE VARIABLES SEMICOLON B V\n |\n \n VARIABLES : FLOAT ID\n | INT ID\n | VECTOR ID LEFT_PARENTESIS CONSTANT RIGHT_PARENTESIS\n | MATRIX ID LEFT_PARENTESIS CONSTANT COMA CONSTANT RIGHT_PARENTESIS\n | CUBE ID LEFT_PARENTESIS CONSTANT COMA CONSTANT COMA CONSTANT RIGHT_PARENTESIS\n \n R : ROUTINE LEFT_PARENTESIS ID RIGHT_PARENTESIS V B RETURN R\n |\n \n B : CALL ID SEMICOLON V B\n | ID INDICES EQUAL E SEMICOLON V B\n | READ ID SEMICOLON V B\n | WRITE STRING WRITE_AUX SEMICOLON V B\n | WRITE E WRITE_AUX SEMICOLON V B\n | IF LEFT_PARENTESIS EL RIGHT_PARENTESIS B ELSE_AUX ENDIF V B\n | WHILE LEFT_PARENTESIS EL RIGHT_PARENTESIS V B ENDWHILE V B\n | FOR LEFT_PARENTESIS EL COMA B RIGHT_PARENTESIS V B ENDFOR V B\n |\n \n INDICES : LEFT_PARENTESIS E RIGHT_PARENTESIS\n | LEFT_PARENTESIS E COMA E RIGHT_PARENTESIS\n | LEFT_PARENTESIS E COMA E COMA E RIGHT_PARENTESIS\n |\n \n ELSE_AUX : ELSE B\n |\n \n WRITE_AUX : COMA STRING WRITE_AUX\n | COMA ID INDICES WRITE_AUX\n |\n \n EL : LEFT_PARENTESIS EL RIGHT_PARENTESIS EL_AUX\n | CONSTANT EL_AUX\n | ID EL_AUX\n \n EL_AUX : COMPARISON EL\n |\n \n E : LEFT_PARENTESIS E RIGHT_PARENTESIS E_AUX\n | CONSTANT E_AUX\n | ID INDICES E_AUX\n \n E_AUX : PLUS E\n | STAR E\n | SLASH E\n | MINUS E\n |\n ' +_lr_signature = 'AND BE BOOLEAN_EXPRESSION CALL COMA COMPARISON CONSTANT CUBE ELSE ENDFOR ENDIF ENDWHILE EQUAL EQUAL_EQUAL FINISH FLOAT FOR GREATER_THAN GREATER_THAN_EQUAL ID IF INT LEFT_PARENTESIS LENGTH LENGTH_I LENGTH_J LENGTH_K LESS_THAN LESS_THAN_EQUAL MATHEMATICAL_CONSTANT MATHEMATICAL_EXPRESSION MATRIX MEAN MEDIAN MINUS MODE NOT NOT_EQUAL OR PLUS READ RETURN RIGHT_PARENTESIS ROUTINE RREF SEMICOLON SLASH STAR START STRING VECTOR WHILE WRITE\n PROGRAMA : R START V B FINISH R\n \n V : BE VARIABLES SEMICOLON B V\n |\n \n VARIABLES : FLOAT ID\n | T ID\n | T ID LEFT_PARENTESIS CONSTANT RIGHT_PARENTESIS\n | T ID LEFT_PARENTESIS CONSTANT COMA CONSTANT RIGHT_PARENTESIS\n | T ID LEFT_PARENTESIS CONSTANT COMA CONSTANT COMA CONSTANT RIGHT_PARENTESIS\n \n T : INT\n | VECTOR\n | MATRIX\n | CUBE\n \n R : ROUTINE LEFT_PARENTESIS ID RIGHT_PARENTESIS V B RETURN R\n |\n \n B : CALL ID SEMICOLON V B\n | ID INDICES EQUAL E SEMICOLON V B\n | READ ID SEMICOLON V B\n | WRITE STRING WRITE_AUX SEMICOLON V B\n | WRITE E WRITE_AUX SEMICOLON V B\n | IF LEFT_PARENTESIS EL RIGHT_PARENTESIS B ELSE_AUX ENDIF V B\n | WHILE LEFT_PARENTESIS EL RIGHT_PARENTESIS V B ENDWHILE V B\n | FOR LEFT_PARENTESIS EL COMA B RIGHT_PARENTESIS V B ENDFOR V B\n |\n \n INDICES : LEFT_PARENTESIS E RIGHT_PARENTESIS\n | LEFT_PARENTESIS E COMA E RIGHT_PARENTESIS\n | LEFT_PARENTESIS E COMA E COMA E RIGHT_PARENTESIS\n |\n \n ELSE_AUX : ELSE B\n |\n \n WRITE_AUX : COMA STRING WRITE_AUX\n | COMA ID INDICES WRITE_AUX\n |\n \n EL : LEFT_PARENTESIS EL RIGHT_PARENTESIS EL_AUX\n | CONSTANT EL_AUX\n | ID EL_AUX\n \n EL_AUX : COMPARISON EL\n |\n \n E : LEFT_PARENTESIS E RIGHT_PARENTESIS E_AUX\n | CONSTANT E_AUX\n | ID INDICES E_AUX\n \n E_AUX : PLUS E\n | STAR E\n | SLASH E\n | MINUS E\n |\n ' -_lr_action_items = {'ROUTINE':([0,24,96,],[3,3,3,]),'START':([0,2,96,114,],[-10,4,-10,-9,]),'$end':([1,24,44,96,114,],[0,-10,-1,-10,-9,]),'LEFT_PARENTESIS':([3,11,13,14,15,16,27,31,33,34,35,36,40,41,42,46,54,55,56,57,59,73,77,88,116,],[5,27,31,34,35,36,31,31,27,59,59,59,66,67,68,31,31,31,31,31,59,31,27,59,31,]),'BE':([4,23,37,45,48,65,70,74,75,78,90,92,97,98,100,101,104,115,118,120,125,128,130,132,137,138,141,142,143,145,146,],[7,7,-19,7,7,7,-19,-19,7,7,7,-2,-11,7,-13,-19,-19,-19,-14,-15,7,-12,7,7,-19,-19,-16,-17,7,-19,-18,]),'CALL':([4,6,23,37,43,45,48,65,70,74,75,78,86,90,91,92,97,98,100,101,104,109,115,118,120,123,125,128,130,132,133,137,138,141,142,143,145,146,],[-3,10,-3,10,10,-3,-3,-3,10,10,-3,-3,10,-3,10,-2,-11,-3,-13,10,10,10,10,-14,-15,10,-3,-12,-3,-3,10,10,10,-16,-17,-3,10,-18,]),'ID':([4,5,6,10,12,13,18,19,20,21,22,23,27,31,34,35,36,37,43,45,46,48,50,54,55,56,57,59,65,70,73,74,75,78,86,88,90,91,92,97,98,100,101,104,109,115,116,118,120,123,125,128,130,132,133,137,138,141,142,143,145,146,],[-3,8,11,25,28,33,38,39,40,41,42,-3,33,33,62,62,62,11,11,-3,33,-3,77,33,33,33,33,62,-3,11,33,11,-3,-3,11,62,-3,11,-2,-11,-3,-13,11,11,11,11,33,-14,-15,11,-3,-12,-3,-3,11,11,11,-16,-17,-3,11,-18,]),'READ':([4,6,23,37,43,45,48,65,70,74,75,78,86,90,91,92,97,98,100,101,104,109,115,118,120,123,125,128,130,132,133,137,138,141,142,143,145,146,],[-3,12,-3,12,12,-3,-3,-3,12,12,-3,-3,12,-3,12,-2,-11,-3,-13,12,12,12,12,-14,-15,12,-3,-12,-3,-3,12,12,12,-16,-17,-3,12,-18,]),'WRITE':([4,6,23,37,43,45,48,65,70,74,75,78,86,90,91,92,97,98,100,101,104,109,115,118,120,123,125,128,130,132,133,137,138,141,142,143,145,146,],[-3,13,-3,13,13,-3,-3,-3,13,13,-3,-3,13,-3,13,-2,-11,-3,-13,13,13,13,13,-14,-15,13,-3,-12,-3,-3,13,13,13,-16,-17,-3,13,-18,]),'IF':([4,6,23,37,43,45,48,65,70,74,75,78,86,90,91,92,97,98,100,101,104,109,115,118,120,123,125,128,130,132,133,137,138,141,142,143,145,146,],[-3,14,-3,14,14,-3,-3,-3,14,14,-3,-3,14,-3,14,-2,-11,-3,-13,14,14,14,14,-14,-15,14,-3,-12,-3,-3,14,14,14,-16,-17,-3,14,-18,]),'WHILE':([4,6,23,37,43,45,48,65,70,74,75,78,86,90,91,92,97,98,100,101,104,109,115,118,120,123,125,128,130,132,133,137,138,141,142,143,145,146,],[-3,15,-3,15,15,-3,-3,-3,15,15,-3,-3,15,-3,15,-2,-11,-3,-13,15,15,15,15,-14,-15,15,-3,-12,-3,-3,15,15,15,-16,-17,-3,15,-18,]),'FOR':([4,6,23,37,43,45,48,65,70,74,75,78,86,90,91,92,97,98,100,101,104,109,115,118,120,123,125,128,130,132,133,137,138,141,142,143,145,146,],[-3,16,-3,16,16,-3,-3,-3,16,16,-3,-3,16,-3,16,-2,-11,-3,-13,16,16,16,16,-14,-15,16,-3,-12,-3,-3,16,16,16,-16,-17,-3,16,-18,]),'FINISH':([4,6,9,37,45,48,65,70,74,75,78,92,97,98,100,101,104,115,118,120,128,130,132,137,138,141,142,143,145,146,],[-3,-19,24,-19,-3,-3,-3,-19,-19,-3,-3,-2,-11,-3,-13,-19,-19,-19,-14,-15,-12,-3,-3,-19,-19,-16,-17,-3,-19,-18,]),'FLOAT':([7,],[18,]),'INT':([7,],[19,]),'VECTOR':([7,],[20,]),'MATRIX':([7,],[21,]),'CUBE':([7,],[22,]),'RIGHT_PARENTESIS':([8,32,33,37,45,47,48,52,53,58,60,61,62,63,65,70,72,74,75,78,79,80,81,82,83,84,85,87,89,91,92,93,97,98,99,100,101,104,105,106,108,110,115,117,118,120,121,126,128,129,130,132,136,137,138,140,141,142,143,145,146,],[23,-41,-23,-19,-3,72,-3,79,-35,-41,86,-33,-33,90,-3,-19,-20,-19,-3,-3,-41,-37,-38,-39,-40,-36,106,-30,-31,-19,-2,111,-11,-3,117,-13,-19,-19,-34,-33,-32,125,-19,-21,-14,-15,-29,134,-12,136,-3,-3,-22,-19,-19,144,-16,-17,-3,-19,-18,]),'EQUAL':([11,26,72,117,136,],[-23,46,-20,-21,-22,]),'STRING':([13,50,],[29,76,]),'CONSTANT':([13,27,31,34,35,36,46,54,55,56,57,59,66,67,68,73,88,112,113,116,135,],[32,32,32,61,61,61,32,32,32,32,32,61,93,94,95,32,61,126,127,32,140,]),'SEMICOLON':([17,25,28,29,30,32,33,38,39,49,51,53,58,71,72,76,77,79,80,81,82,83,84,102,103,105,111,117,119,134,136,144,],[37,45,48,-28,-28,-41,-23,-4,-5,75,78,-35,-41,98,-20,-28,-23,-41,-37,-38,-39,-40,-36,-26,-28,-34,-6,-21,-27,-7,-22,-8,]),'RETURN':([23,37,43,45,48,65,69,70,74,75,78,92,97,98,100,101,104,115,118,120,128,130,132,137,138,141,142,143,145,146,],[-3,-19,-19,-3,-3,-3,96,-19,-19,-3,-3,-2,-11,-3,-13,-19,-19,-19,-14,-15,-12,-3,-3,-19,-19,-16,-17,-3,-19,-18,]),'COMA':([29,30,32,33,47,53,58,61,62,64,72,76,77,79,80,81,82,83,84,87,89,94,95,99,103,105,106,108,117,121,127,136,],[50,50,-41,-23,73,-35,-41,-33,-33,91,-20,50,-23,-41,-37,-38,-39,-40,-36,-30,-31,112,113,116,50,-34,-33,-32,-21,-29,135,-22,]),'PLUS':([32,33,58,72,79,117,136,],[54,-23,54,-20,54,-21,-22,]),'STAR':([32,33,58,72,79,117,136,],[55,-23,55,-20,55,-21,-22,]),'SLASH':([32,33,58,72,79,117,136,],[56,-23,56,-20,56,-21,-22,]),'MINUS':([32,33,58,72,79,117,136,],[57,-23,57,-20,57,-21,-22,]),'ELSE':([37,45,48,65,70,74,75,78,86,92,97,98,100,101,104,107,115,118,120,128,130,132,137,138,141,142,143,145,146,],[-19,-3,-3,-3,-19,-19,-3,-3,-19,-2,-11,-3,-13,-19,-19,123,-19,-14,-15,-12,-3,-3,-19,-19,-16,-17,-3,-19,-18,]),'ENDIF':([37,45,48,65,70,74,75,78,86,92,97,98,100,101,104,107,115,118,120,122,123,128,130,131,132,137,138,141,142,143,145,146,],[-19,-3,-3,-3,-19,-19,-3,-3,-19,-2,-11,-3,-13,-19,-19,-25,-19,-14,-15,130,-19,-12,-3,-24,-3,-19,-19,-16,-17,-3,-19,-18,]),'ENDWHILE':([37,45,48,65,70,74,75,78,90,92,97,98,100,101,104,109,115,118,120,124,128,130,132,137,138,141,142,143,145,146,],[-19,-3,-3,-3,-19,-19,-3,-3,-3,-2,-11,-3,-13,-19,-19,-19,-19,-14,-15,132,-12,-3,-3,-19,-19,-16,-17,-3,-19,-18,]),'ENDFOR':([37,45,48,65,70,74,75,78,92,97,98,100,101,104,115,118,120,125,128,130,132,133,137,138,139,141,142,143,145,146,],[-19,-3,-3,-3,-19,-19,-3,-3,-2,-11,-3,-13,-19,-19,-19,-14,-15,-3,-12,-3,-3,-19,-19,-19,143,-16,-17,-3,-19,-18,]),'COMPARISON':([61,62,106,],[88,88,88,]),} +_lr_action_items = {'ROUTINE':([0,25,90,],[3,3,3,]),'START':([0,2,90,107,],[-14,4,-14,-13,]),'$end':([1,25,42,90,107,],[0,-14,-1,-14,-13,]),'LEFT_PARENTESIS':([3,11,13,14,15,16,28,32,34,35,36,37,40,44,52,53,54,55,57,69,73,84,109,],[5,28,32,35,36,37,32,32,28,57,57,57,64,32,32,32,32,32,57,32,28,57,32,]),'BE':([4,24,38,43,46,63,66,70,71,74,86,88,91,92,94,95,98,108,111,113,118,120,122,124,129,130,133,134,135,137,138,],[7,7,-23,7,7,7,-23,-23,7,7,7,-2,-15,7,-17,-23,-23,-23,-18,-19,7,-16,7,7,-23,-23,-20,-21,7,-23,-22,]),'CALL':([4,6,24,38,41,43,46,63,66,70,71,74,82,86,87,88,91,92,94,95,98,103,108,111,113,116,118,120,122,124,125,129,130,133,134,135,137,138,],[-3,10,-3,10,10,-3,-3,-3,10,10,-3,-3,10,-3,10,-2,-15,-3,-17,10,10,10,10,-18,-19,10,-3,-16,-3,-3,10,10,10,-20,-21,-3,10,-22,]),'ID':([4,5,6,10,12,13,18,19,20,21,22,23,24,28,32,35,36,37,38,41,43,44,46,48,52,53,54,55,57,63,66,69,70,71,74,82,84,86,87,88,91,92,94,95,98,103,108,109,111,113,116,118,120,122,124,125,129,130,133,134,135,137,138,],[-3,8,11,26,29,34,39,40,-9,-10,-11,-12,-3,34,34,60,60,60,11,11,-3,34,-3,73,34,34,34,34,60,-3,11,34,11,-3,-3,11,60,-3,11,-2,-15,-3,-17,11,11,11,11,34,-18,-19,11,-3,-16,-3,-3,11,11,11,-20,-21,-3,11,-22,]),'READ':([4,6,24,38,41,43,46,63,66,70,71,74,82,86,87,88,91,92,94,95,98,103,108,111,113,116,118,120,122,124,125,129,130,133,134,135,137,138,],[-3,12,-3,12,12,-3,-3,-3,12,12,-3,-3,12,-3,12,-2,-15,-3,-17,12,12,12,12,-18,-19,12,-3,-16,-3,-3,12,12,12,-20,-21,-3,12,-22,]),'WRITE':([4,6,24,38,41,43,46,63,66,70,71,74,82,86,87,88,91,92,94,95,98,103,108,111,113,116,118,120,122,124,125,129,130,133,134,135,137,138,],[-3,13,-3,13,13,-3,-3,-3,13,13,-3,-3,13,-3,13,-2,-15,-3,-17,13,13,13,13,-18,-19,13,-3,-16,-3,-3,13,13,13,-20,-21,-3,13,-22,]),'IF':([4,6,24,38,41,43,46,63,66,70,71,74,82,86,87,88,91,92,94,95,98,103,108,111,113,116,118,120,122,124,125,129,130,133,134,135,137,138,],[-3,14,-3,14,14,-3,-3,-3,14,14,-3,-3,14,-3,14,-2,-15,-3,-17,14,14,14,14,-18,-19,14,-3,-16,-3,-3,14,14,14,-20,-21,-3,14,-22,]),'WHILE':([4,6,24,38,41,43,46,63,66,70,71,74,82,86,87,88,91,92,94,95,98,103,108,111,113,116,118,120,122,124,125,129,130,133,134,135,137,138,],[-3,15,-3,15,15,-3,-3,-3,15,15,-3,-3,15,-3,15,-2,-15,-3,-17,15,15,15,15,-18,-19,15,-3,-16,-3,-3,15,15,15,-20,-21,-3,15,-22,]),'FOR':([4,6,24,38,41,43,46,63,66,70,71,74,82,86,87,88,91,92,94,95,98,103,108,111,113,116,118,120,122,124,125,129,130,133,134,135,137,138,],[-3,16,-3,16,16,-3,-3,-3,16,16,-3,-3,16,-3,16,-2,-15,-3,-17,16,16,16,16,-18,-19,16,-3,-16,-3,-3,16,16,16,-20,-21,-3,16,-22,]),'FINISH':([4,6,9,38,43,46,63,66,70,71,74,88,91,92,94,95,98,108,111,113,120,122,124,129,130,133,134,135,137,138,],[-3,-23,25,-23,-3,-3,-3,-23,-23,-3,-3,-2,-15,-3,-17,-23,-23,-23,-18,-19,-16,-3,-3,-23,-23,-20,-21,-3,-23,-22,]),'FLOAT':([7,],[18,]),'INT':([7,],[20,]),'VECTOR':([7,],[21,]),'MATRIX':([7,],[22,]),'CUBE':([7,],[23,]),'RIGHT_PARENTESIS':([8,33,34,38,43,45,46,50,51,56,58,59,60,61,63,66,68,70,71,74,75,76,77,78,79,80,81,83,85,87,88,89,91,92,93,94,95,98,99,100,102,104,108,110,111,113,114,119,120,121,122,124,128,129,130,132,133,134,135,137,138,],[24,-45,-27,-23,-3,68,-3,75,-39,-45,82,-37,-37,86,-3,-23,-24,-23,-3,-3,-45,-41,-42,-43,-44,-40,100,-34,-35,-23,-2,105,-15,-3,110,-17,-23,-23,-38,-37,-36,118,-23,-25,-18,-19,-33,127,-16,128,-3,-3,-26,-23,-23,136,-20,-21,-3,-23,-22,]),'EQUAL':([11,27,68,110,128,],[-27,44,-24,-25,-26,]),'STRING':([13,48,],[30,72,]),'CONSTANT':([13,28,32,35,36,37,44,52,53,54,55,57,64,69,84,106,109,126,],[33,33,33,59,59,59,33,33,33,33,33,59,89,33,59,119,33,132,]),'SEMICOLON':([17,26,29,30,31,33,34,39,40,47,49,51,56,67,68,72,73,75,76,77,78,79,80,96,97,99,105,110,112,127,128,136,],[38,43,46,-32,-32,-45,-27,-4,-5,71,74,-39,-45,92,-24,-32,-27,-45,-41,-42,-43,-44,-40,-30,-32,-38,-6,-25,-31,-7,-26,-8,]),'RETURN':([24,38,41,43,46,63,65,66,70,71,74,88,91,92,94,95,98,108,111,113,120,122,124,129,130,133,134,135,137,138,],[-3,-23,-23,-3,-3,-3,90,-23,-23,-3,-3,-2,-15,-3,-17,-23,-23,-23,-18,-19,-16,-3,-3,-23,-23,-20,-21,-3,-23,-22,]),'COMA':([30,31,33,34,45,51,56,59,60,62,68,72,73,75,76,77,78,79,80,83,85,89,93,97,99,100,102,110,114,119,128,],[48,48,-45,-27,69,-39,-45,-37,-37,87,-24,48,-27,-45,-41,-42,-43,-44,-40,-34,-35,106,109,48,-38,-37,-36,-25,-33,126,-26,]),'PLUS':([33,34,56,68,75,110,128,],[52,-27,52,-24,52,-25,-26,]),'STAR':([33,34,56,68,75,110,128,],[53,-27,53,-24,53,-25,-26,]),'SLASH':([33,34,56,68,75,110,128,],[54,-27,54,-24,54,-25,-26,]),'MINUS':([33,34,56,68,75,110,128,],[55,-27,55,-24,55,-25,-26,]),'ELSE':([38,43,46,63,66,70,71,74,82,88,91,92,94,95,98,101,108,111,113,120,122,124,129,130,133,134,135,137,138,],[-23,-3,-3,-3,-23,-23,-3,-3,-23,-2,-15,-3,-17,-23,-23,116,-23,-18,-19,-16,-3,-3,-23,-23,-20,-21,-3,-23,-22,]),'ENDIF':([38,43,46,63,66,70,71,74,82,88,91,92,94,95,98,101,108,111,113,115,116,120,122,123,124,129,130,133,134,135,137,138,],[-23,-3,-3,-3,-23,-23,-3,-3,-23,-2,-15,-3,-17,-23,-23,-29,-23,-18,-19,122,-23,-16,-3,-28,-3,-23,-23,-20,-21,-3,-23,-22,]),'ENDWHILE':([38,43,46,63,66,70,71,74,86,88,91,92,94,95,98,103,108,111,113,117,120,122,124,129,130,133,134,135,137,138,],[-23,-3,-3,-3,-23,-23,-3,-3,-3,-2,-15,-3,-17,-23,-23,-23,-23,-18,-19,124,-16,-3,-3,-23,-23,-20,-21,-3,-23,-22,]),'ENDFOR':([38,43,46,63,66,70,71,74,88,91,92,94,95,98,108,111,113,118,120,122,124,125,129,130,131,133,134,135,137,138,],[-23,-3,-3,-3,-23,-23,-3,-3,-2,-15,-3,-17,-23,-23,-23,-18,-19,-3,-16,-3,-3,-23,-23,-23,135,-20,-21,-3,-23,-22,]),'COMPARISON':([59,60,100,],[84,84,84,]),} _lr_action = {} for _k, _v in _lr_action_items.items(): @@ -17,7 +17,7 @@ _lr_action[_x][_k] = _y del _lr_action_items -_lr_goto_items = {'PROGRAMA':([0,],[1,]),'R':([0,24,96,],[2,44,114,]),'V':([4,23,45,48,65,75,78,90,98,125,130,132,143,],[6,43,70,74,92,101,104,109,115,133,137,138,145,]),'B':([6,37,43,70,74,86,91,101,104,109,115,123,133,137,138,145,],[9,65,69,97,100,107,110,118,120,124,128,131,139,141,142,146,]),'VARIABLES':([7,],[17,]),'INDICES':([11,33,77,],[26,58,103,]),'E':([13,27,31,46,54,55,56,57,73,116,],[30,47,52,71,80,81,82,83,99,129,]),'WRITE_AUX':([29,30,76,103,],[49,51,102,119,]),'E_AUX':([32,58,79,],[53,84,105,]),'EL':([34,35,36,59,88,],[60,63,64,85,108,]),'EL_AUX':([61,62,106,],[87,89,121,]),'ELSE_AUX':([107,],[122,]),} +_lr_goto_items = {'PROGRAMA':([0,],[1,]),'R':([0,25,90,],[2,42,107,]),'V':([4,24,43,46,63,71,74,86,92,118,122,124,135,],[6,41,66,70,88,95,98,103,108,125,129,130,137,]),'B':([6,38,41,66,70,82,87,95,98,103,108,116,125,129,130,137,],[9,63,65,91,94,101,104,111,113,117,120,123,131,133,134,138,]),'VARIABLES':([7,],[17,]),'T':([7,],[19,]),'INDICES':([11,34,73,],[27,56,97,]),'E':([13,28,32,44,52,53,54,55,69,109,],[31,45,50,67,76,77,78,79,93,121,]),'WRITE_AUX':([30,31,72,97,],[47,49,96,112,]),'E_AUX':([33,56,75,],[51,80,99,]),'EL':([35,36,37,57,84,],[58,61,62,81,102,]),'EL_AUX':([59,60,100,],[83,85,114,]),'ELSE_AUX':([101,],[115,]),} _lr_goto = {} for _k, _v in _lr_goto_items.items(): @@ -27,45 +27,49 @@ del _lr_goto_items _lr_productions = [ ("S' -> PROGRAMA","S'",1,None,None,None), - ('PROGRAMA -> R START V B FINISH R','PROGRAMA',6,'p_PROGRAMA','TA.py',113), - ('V -> BE VARIABLES SEMICOLON B V','V',5,'p_V','TA.py',118), - ('V -> ','V',0,'p_V','TA.py',119), - ('VARIABLES -> FLOAT ID','VARIABLES',2,'p_VARIABLES','TA.py',124), - ('VARIABLES -> INT ID','VARIABLES',2,'p_VARIABLES','TA.py',125), - ('VARIABLES -> VECTOR ID LEFT_PARENTESIS CONSTANT RIGHT_PARENTESIS','VARIABLES',5,'p_VARIABLES','TA.py',126), - ('VARIABLES -> MATRIX ID LEFT_PARENTESIS CONSTANT COMA CONSTANT RIGHT_PARENTESIS','VARIABLES',7,'p_VARIABLES','TA.py',127), - ('VARIABLES -> CUBE ID LEFT_PARENTESIS CONSTANT COMA CONSTANT COMA CONSTANT RIGHT_PARENTESIS','VARIABLES',9,'p_VARIABLES','TA.py',128), - ('R -> ROUTINE LEFT_PARENTESIS ID RIGHT_PARENTESIS V B RETURN R','R',8,'p_R','TA.py',133), - ('R -> ','R',0,'p_R','TA.py',134), - ('B -> CALL ID SEMICOLON V B','B',5,'p_B','TA.py',139), - ('B -> ID INDICES EQUAL E SEMICOLON V B','B',7,'p_B','TA.py',140), - ('B -> READ ID SEMICOLON V B','B',5,'p_B','TA.py',141), - ('B -> WRITE STRING WRITE_AUX SEMICOLON V B','B',6,'p_B','TA.py',142), - ('B -> WRITE E WRITE_AUX SEMICOLON V B','B',6,'p_B','TA.py',143), - ('B -> IF LEFT_PARENTESIS EL RIGHT_PARENTESIS B ELSE_AUX ENDIF V B','B',9,'p_B','TA.py',144), - ('B -> WHILE LEFT_PARENTESIS EL RIGHT_PARENTESIS V B ENDWHILE V B','B',9,'p_B','TA.py',145), - ('B -> FOR LEFT_PARENTESIS EL COMA B RIGHT_PARENTESIS V B ENDFOR V B','B',11,'p_B','TA.py',146), - ('B -> ','B',0,'p_B','TA.py',147), - ('INDICES -> LEFT_PARENTESIS E RIGHT_PARENTESIS','INDICES',3,'p_INDICES','TA.py',152), - ('INDICES -> LEFT_PARENTESIS E COMA E RIGHT_PARENTESIS','INDICES',5,'p_INDICES','TA.py',153), - ('INDICES -> LEFT_PARENTESIS E COMA E COMA E RIGHT_PARENTESIS','INDICES',7,'p_INDICES','TA.py',154), - ('INDICES -> ','INDICES',0,'p_INDICES','TA.py',155), - ('ELSE_AUX -> ELSE B','ELSE_AUX',2,'p_ELSE_AUX','TA.py',160), - ('ELSE_AUX -> ','ELSE_AUX',0,'p_ELSE_AUX','TA.py',161), - ('WRITE_AUX -> COMA STRING WRITE_AUX','WRITE_AUX',3,'p_WRITE_AUX','TA.py',166), - ('WRITE_AUX -> COMA ID INDICES WRITE_AUX','WRITE_AUX',4,'p_WRITE_AUX','TA.py',167), - ('WRITE_AUX -> ','WRITE_AUX',0,'p_WRITE_AUX','TA.py',168), - ('EL -> LEFT_PARENTESIS EL RIGHT_PARENTESIS EL_AUX','EL',4,'p_EL','TA.py',173), - ('EL -> CONSTANT EL_AUX','EL',2,'p_EL','TA.py',174), - ('EL -> ID EL_AUX','EL',2,'p_EL','TA.py',175), - ('EL_AUX -> COMPARISON EL','EL_AUX',2,'p_EL_AUX','TA.py',180), - ('EL_AUX -> ','EL_AUX',0,'p_EL_AUX','TA.py',181), - ('E -> LEFT_PARENTESIS E RIGHT_PARENTESIS E_AUX','E',4,'p_E','TA.py',186), - ('E -> CONSTANT E_AUX','E',2,'p_E','TA.py',187), - ('E -> ID INDICES E_AUX','E',3,'p_E','TA.py',188), - ('E_AUX -> PLUS E','E_AUX',2,'p_E_AUX','TA.py',193), - ('E_AUX -> STAR E','E_AUX',2,'p_E_AUX','TA.py',194), - ('E_AUX -> SLASH E','E_AUX',2,'p_E_AUX','TA.py',195), - ('E_AUX -> MINUS E','E_AUX',2,'p_E_AUX','TA.py',196), - ('E_AUX -> ','E_AUX',0,'p_E_AUX','TA.py',197), + ('PROGRAMA -> R START V B FINISH R','PROGRAMA',6,'p_PROGRAMA','TA.py',118), + ('V -> BE VARIABLES SEMICOLON B V','V',5,'p_V','TA.py',125), + ('V -> ','V',0,'p_V','TA.py',126), + ('VARIABLES -> FLOAT ID','VARIABLES',2,'p_VARIABLES','TA.py',131), + ('VARIABLES -> T ID','VARIABLES',2,'p_VARIABLES','TA.py',132), + ('VARIABLES -> T ID LEFT_PARENTESIS CONSTANT RIGHT_PARENTESIS','VARIABLES',5,'p_VARIABLES','TA.py',133), + ('VARIABLES -> T ID LEFT_PARENTESIS CONSTANT COMA CONSTANT RIGHT_PARENTESIS','VARIABLES',7,'p_VARIABLES','TA.py',134), + ('VARIABLES -> T ID LEFT_PARENTESIS CONSTANT COMA CONSTANT COMA CONSTANT RIGHT_PARENTESIS','VARIABLES',9,'p_VARIABLES','TA.py',135), + ('T -> INT','T',1,'p_T','TA.py',142), + ('T -> VECTOR','T',1,'p_T','TA.py',143), + ('T -> MATRIX','T',1,'p_T','TA.py',144), + ('T -> CUBE','T',1,'p_T','TA.py',145), + ('R -> ROUTINE LEFT_PARENTESIS ID RIGHT_PARENTESIS V B RETURN R','R',8,'p_R','TA.py',152), + ('R -> ','R',0,'p_R','TA.py',153), + ('B -> CALL ID SEMICOLON V B','B',5,'p_B','TA.py',159), + ('B -> ID INDICES EQUAL E SEMICOLON V B','B',7,'p_B','TA.py',160), + ('B -> READ ID SEMICOLON V B','B',5,'p_B','TA.py',161), + ('B -> WRITE STRING WRITE_AUX SEMICOLON V B','B',6,'p_B','TA.py',162), + ('B -> WRITE E WRITE_AUX SEMICOLON V B','B',6,'p_B','TA.py',163), + ('B -> IF LEFT_PARENTESIS EL RIGHT_PARENTESIS B ELSE_AUX ENDIF V B','B',9,'p_B','TA.py',164), + ('B -> WHILE LEFT_PARENTESIS EL RIGHT_PARENTESIS V B ENDWHILE V B','B',9,'p_B','TA.py',165), + ('B -> FOR LEFT_PARENTESIS EL COMA B RIGHT_PARENTESIS V B ENDFOR V B','B',11,'p_B','TA.py',166), + ('B -> ','B',0,'p_B','TA.py',167), + ('INDICES -> LEFT_PARENTESIS E RIGHT_PARENTESIS','INDICES',3,'p_INDICES','TA.py',172), + ('INDICES -> LEFT_PARENTESIS E COMA E RIGHT_PARENTESIS','INDICES',5,'p_INDICES','TA.py',173), + ('INDICES -> LEFT_PARENTESIS E COMA E COMA E RIGHT_PARENTESIS','INDICES',7,'p_INDICES','TA.py',174), + ('INDICES -> ','INDICES',0,'p_INDICES','TA.py',175), + ('ELSE_AUX -> ELSE B','ELSE_AUX',2,'p_ELSE_AUX','TA.py',180), + ('ELSE_AUX -> ','ELSE_AUX',0,'p_ELSE_AUX','TA.py',181), + ('WRITE_AUX -> COMA STRING WRITE_AUX','WRITE_AUX',3,'p_WRITE_AUX','TA.py',186), + ('WRITE_AUX -> COMA ID INDICES WRITE_AUX','WRITE_AUX',4,'p_WRITE_AUX','TA.py',187), + ('WRITE_AUX -> ','WRITE_AUX',0,'p_WRITE_AUX','TA.py',188), + ('EL -> LEFT_PARENTESIS EL RIGHT_PARENTESIS EL_AUX','EL',4,'p_EL','TA.py',193), + ('EL -> CONSTANT EL_AUX','EL',2,'p_EL','TA.py',194), + ('EL -> ID EL_AUX','EL',2,'p_EL','TA.py',195), + ('EL_AUX -> COMPARISON EL','EL_AUX',2,'p_EL_AUX','TA.py',200), + ('EL_AUX -> ','EL_AUX',0,'p_EL_AUX','TA.py',201), + ('E -> LEFT_PARENTESIS E RIGHT_PARENTESIS E_AUX','E',4,'p_E','TA.py',206), + ('E -> CONSTANT E_AUX','E',2,'p_E','TA.py',207), + ('E -> ID INDICES E_AUX','E',3,'p_E','TA.py',208), + ('E_AUX -> PLUS E','E_AUX',2,'p_E_AUX','TA.py',213), + ('E_AUX -> STAR E','E_AUX',2,'p_E_AUX','TA.py',214), + ('E_AUX -> SLASH E','E_AUX',2,'p_E_AUX','TA.py',215), + ('E_AUX -> MINUS E','E_AUX',2,'p_E_AUX','TA.py',216), + ('E_AUX -> ','E_AUX',0,'p_E_AUX','TA.py',217), ]