diff --git a/compilador b/compilador new file mode 100755 index 0000000000000000000000000000000000000000..dec53b9f92a3cf7349e7606481764fe2e37bab4f Binary files /dev/null and b/compilador differ diff --git a/compilador.o b/compilador.o new file mode 100644 index 0000000000000000000000000000000000000000..51fe93764cc869d9934c3a514ac754bc372338ac Binary files /dev/null and b/compilador.o differ diff --git a/compilador.output b/compilador.output index 0d1692049bf5a33d6e4a70b0f6a51dce56b4430d..da63078abfaeb69e3ecec255d805ec97b69f3e7b 100644 --- a/compilador.output +++ b/compilador.output @@ -1,46 +1,45 @@ -Terminals which are not used +Terminais sem uso na gramática - TYPE - ARRAY - PROCEDURE - FUNCTION - GOTO - OR - AND - NOT + TYPE + ARRAY + FUNCTION + GOTO + OR + AND + NOT -State 60 conflicts: 1 reduce/reduce +Estado 61 conflitos: 1 de redução/redução -Grammar +Gramática 0 $accept: programa $end - 1 @1: /* empty */ + 1 $@1: ε - 2 programa: @1 PROGRAM IDENT ABRE_PARENTESES lista_idents FECHA_PARENTESES PONTO_E_VIRGULA bloco PONTO + 2 programa: $@1 PROGRAM IDENT ABRE_PARENTESES lista_idents FECHA_PARENTESES PONTO_E_VIRGULA bloco PONTO 3 bloco: parte_declara_rotulos parte_declara_vars parte_declara_subrotinas comando_composto 4 parte_declara_rotulos: LABEL VIRGULA - 5 | /* empty */ + 5 | ε 6 parte_declara_vars: var - 7 @2: /* empty */ + 7 $@2: ε - 8 var: @2 VAR declara_vars - 9 | /* empty */ + 8 var: $@2 VAR declara_vars + 9 | ε 10 declara_vars: declara_vars declara_var 11 | declara_var - 12 @3: /* empty */ + 12 $@3: ε - 13 @4: /* empty */ + 13 $@4: ε - 14 declara_var: @3 lista_id_var DOIS_PONTOS tipo @4 PONTO_E_VIRGULA + 14 declara_var: $@3 lista_id_var DOIS_PONTOS tipo $@4 PONTO_E_VIRGULA 15 tipo: IDENT @@ -52,1354 +51,1386 @@ Grammar 20 parte_declara_subrotinas: declaracao_procedimento - 21 declaracao_procedimento: /* empty */ + 21 declaracao_procedimento: PROCEDURE IDENT + 22 | ε - 22 comando_composto: T_BEGIN comandos T_END + 23 comando_composto: T_BEGIN comandos T_END - 23 comandos: comando PONTO_E_VIRGULA comandos - 24 | comando PONTO_E_VIRGULA - 25 | /* empty */ + 24 comandos: comando PONTO_E_VIRGULA comandos + 25 | comando PONTO_E_VIRGULA + 26 | ε - 26 comando: numero DOIS_PONTOS comando_sem_rotulo - 27 | comando_sem_rotulo + 27 comando: numero DOIS_PONTOS comando_sem_rotulo + 28 | comando_sem_rotulo + + 29 comando_sem_rotulo: atribuicao + 30 | comando_composto + 31 | comando_condicional + 32 | comando_repetitivo + 33 | leitura + 34 | escrita + + 35 leitura: READ ABRE_PARENTESES lista_leituras FECHA_PARENTESES - 28 comando_sem_rotulo: atribuicao - 29 | comando_composto - 30 | comando_condicional - 31 | comando_repetitivo - 32 | leitura - 33 | escrita - 34 | chamada_procedimento - - 35 chamada_procedimento: /* empty */ + 36 lista_leituras: lista_leituras VIRGULA simb_leitura + 37 | simb_leitura + + 38 simb_leitura: IDENT + + 39 escrita: WRITE ABRE_PARENTESES lista_escritas FECHA_PARENTESES + + 40 lista_escritas: lista_escritas VIRGULA expressao_simples + 41 | expressao_simples + + 42 expressao: expressao IGUAL expressao_simples + 43 | expressao DIFERENTE expressao_simples + 44 | expressao MENOR expressao_simples + 45 | expressao MENOR_IGUAL expressao_simples + 46 | expressao MAIOR expressao_simples + 47 | expressao MAIOR_IGUAL expressao_simples + 48 | expressao_simples + + 49 expressao_simples: expressao_simples MAIS termo + 50 | expressao_simples MENOS termo + 51 | termo + + 52 termo: termo ASTERISCO fator + 53 | termo DIV fator + 54 | fator + + 55 $@5: ε + + 56 atribuicao: IDENT $@5 ATRIBUICAO expressao_simples + + 57 fator: IDENT + 58 | NUMERO + + 59 numero: NUMERO + + 60 $@6: ε + + 61 $@7: ε + + 62 comando_repetitivo: $@6 WHILE expressao DO $@7 comando_sem_rotulo + + 63 comando_condicional: if_then cond_else + + 64 cond_else: ELSE comando_sem_rotulo + 65 | ε + + 66 $@8: ε + + 67 if_then: IF expressao $@8 THEN comando_sem_rotulo + + +Terminais, com as regras onde eles aparecem + + $end (0) 0 + error (256) + PROGRAM (258) 2 + ABRE_PARENTESES (259) 2 35 39 + FECHA_PARENTESES (260) 2 35 39 + VIRGULA (261) 4 16 18 36 40 + PONTO_E_VIRGULA (262) 2 14 24 25 + DOIS_PONTOS (263) 14 27 + PONTO (264) 2 + T_BEGIN (265) 23 + T_END (266) 23 + VAR (267) 8 + IDENT (268) 2 15 16 17 18 19 21 38 56 57 + ATRIBUICAO (269) 56 + LABEL (270) 4 + TYPE (271) + ARRAY (272) + PROCEDURE (273) 21 + FUNCTION (274) + GOTO (275) + IF (276) 67 + THEN (277) 67 + ELSE (278) 64 + WHILE (279) 62 + DO (280) 62 + OR (281) + DIV (282) 53 + AND (283) + NOT (284) + IGUAL (285) 42 + DIFERENTE (286) 43 + MENOR_IGUAL (287) 45 + MAIOR_IGUAL (288) 47 + MENOR (289) 44 + MAIOR (290) 46 + MAIS (291) 49 + MENOS (292) 50 + ASTERISCO (293) 52 + NUMERO (294) 58 59 + READ (295) 35 + WRITE (296) 39 + LOWER_THAN_ELSE (297) + + +Não terminais com as regras onde eles aparecem + + $accept (43) + à esquerda: 0 + programa (44) + à esquerda: 2 + à direita: 0 + $@1 (45) + à esquerda: 1 + à direita: 2 + bloco (46) + à esquerda: 3 + à direita: 2 + parte_declara_rotulos (47) + à esquerda: 4 5 + à direita: 3 + parte_declara_vars (48) + à esquerda: 6 + à direita: 3 + var (49) + à esquerda: 8 9 + à direita: 6 + $@2 (50) + à esquerda: 7 + à direita: 8 + declara_vars (51) + à esquerda: 10 11 + à direita: 8 10 + declara_var (52) + à esquerda: 14 + à direita: 10 11 + $@3 (53) + à esquerda: 12 + à direita: 14 + $@4 (54) + à esquerda: 13 + à direita: 14 + tipo (55) + à esquerda: 15 + à direita: 14 + lista_id_var (56) + à esquerda: 16 17 + à direita: 14 16 + lista_idents (57) + à esquerda: 18 19 + à direita: 2 18 + parte_declara_subrotinas (58) + à esquerda: 20 + à direita: 3 + declaracao_procedimento (59) + à esquerda: 21 22 + à direita: 20 + comando_composto (60) + à esquerda: 23 + à direita: 3 30 + comandos (61) + à esquerda: 24 25 26 + à direita: 23 24 + comando (62) + à esquerda: 27 28 + à direita: 24 25 + comando_sem_rotulo (63) + à esquerda: 29 30 31 32 33 34 + à direita: 27 28 62 64 67 + leitura (64) + à esquerda: 35 + à direita: 33 + lista_leituras (65) + à esquerda: 36 37 + à direita: 35 36 + simb_leitura (66) + à esquerda: 38 + à direita: 36 37 + escrita (67) + à esquerda: 39 + à direita: 34 + lista_escritas (68) + à esquerda: 40 41 + à direita: 39 40 + expressao (69) + à esquerda: 42 43 44 45 46 47 48 + à direita: 42 43 44 45 46 47 62 67 + expressao_simples (70) + à esquerda: 49 50 51 + à direita: 40 41 42 43 44 45 46 47 48 49 50 56 + termo (71) + à esquerda: 52 53 54 + à direita: 49 50 51 52 53 + atribuicao (72) + à esquerda: 56 + à direita: 29 + $@5 (73) + à esquerda: 55 + à direita: 56 + fator (74) + à esquerda: 57 58 + à direita: 52 53 54 + numero (75) + à esquerda: 59 + à direita: 27 + comando_repetitivo (76) + à esquerda: 62 + à direita: 32 + $@6 (77) + à esquerda: 60 + à direita: 62 + $@7 (78) + à esquerda: 61 + à direita: 62 + comando_condicional (79) + à esquerda: 63 + à direita: 31 + cond_else (80) + à esquerda: 64 65 + à direita: 63 + if_then (81) + à esquerda: 67 + à direita: 63 + $@8 (82) + à esquerda: 66 + à direita: 67 - 36 leitura: READ ABRE_PARENTESES lista_leituras FECHA_PARENTESES - 37 lista_leituras: lista_leituras VIRGULA simb_leitura - 38 | simb_leitura +Estado 0 - 39 simb_leitura: IDENT - - 40 escrita: WRITE ABRE_PARENTESES lista_escritas FECHA_PARENTESES - - 41 lista_escritas: lista_escritas VIRGULA expressao_simples - 42 | expressao_simples - - 43 expressao: expressao IGUAL expressao_simples - 44 | expressao DIFERENTE expressao_simples - 45 | expressao MENOR expressao_simples - 46 | expressao MENOR_IGUAL expressao_simples - 47 | expressao MAIOR expressao_simples - 48 | expressao MAIOR_IGUAL expressao_simples - 49 | expressao_simples - - 50 expressao_simples: expressao_simples MAIS termo - 51 | expressao_simples MENOS termo - 52 | termo - - 53 termo: termo ASTERISCO fator - 54 | termo DIV fator - 55 | fator - - 56 @5: /* empty */ - - 57 atribuicao: IDENT @5 ATRIBUICAO expressao_simples - - 58 fator: IDENT - 59 | NUMERO - - 60 numero: NUMERO - - 61 @6: /* empty */ - - 62 @7: /* empty */ - - 63 comando_repetitivo: @6 WHILE expressao DO @7 comando_sem_rotulo - - 64 comando_condicional: if_then cond_else - - 65 cond_else: ELSE comando_sem_rotulo - 66 | /* empty */ - - 67 @8: /* empty */ - - 68 if_then: IF expressao @8 THEN comando_sem_rotulo - - -Terminals, with rules where they appear - -$end (0) 0 -error (256) -PROGRAM (258) 2 -ABRE_PARENTESES (259) 2 36 40 -FECHA_PARENTESES (260) 2 36 40 -VIRGULA (261) 4 16 18 37 41 -PONTO_E_VIRGULA (262) 2 14 23 24 -DOIS_PONTOS (263) 14 26 -PONTO (264) 2 -T_BEGIN (265) 22 -T_END (266) 22 -VAR (267) 8 -IDENT (268) 2 15 16 17 18 19 39 57 58 -ATRIBUICAO (269) 57 -LABEL (270) 4 -TYPE (271) -ARRAY (272) -PROCEDURE (273) -FUNCTION (274) -GOTO (275) -IF (276) 68 -THEN (277) 68 -ELSE (278) 65 -WHILE (279) 63 -DO (280) 63 -OR (281) -DIV (282) 54 -AND (283) -NOT (284) -IGUAL (285) 43 -DIFERENTE (286) 44 -MENOR_IGUAL (287) 46 -MAIOR_IGUAL (288) 48 -MENOR (289) 45 -MAIOR (290) 47 -MAIS (291) 50 -MENOS (292) 51 -ASTERISCO (293) 53 -NUMERO (294) 59 60 -READ (295) 36 -WRITE (296) 40 -LOWER_THAN_ELSE (297) - - -Nonterminals, with rules where they appear - -$accept (43) - on left: 0 -programa (44) - on left: 2, on right: 0 -@1 (45) - on left: 1, on right: 2 -bloco (46) - on left: 3, on right: 2 -parte_declara_rotulos (47) - on left: 4 5, on right: 3 -parte_declara_vars (48) - on left: 6, on right: 3 -var (49) - on left: 8 9, on right: 6 -@2 (50) - on left: 7, on right: 8 -declara_vars (51) - on left: 10 11, on right: 8 10 -declara_var (52) - on left: 14, on right: 10 11 -@3 (53) - on left: 12, on right: 14 -@4 (54) - on left: 13, on right: 14 -tipo (55) - on left: 15, on right: 14 -lista_id_var (56) - on left: 16 17, on right: 14 16 -lista_idents (57) - on left: 18 19, on right: 2 18 -parte_declara_subrotinas (58) - on left: 20, on right: 3 -declaracao_procedimento (59) - on left: 21, on right: 20 -comando_composto (60) - on left: 22, on right: 3 29 -comandos (61) - on left: 23 24 25, on right: 22 23 -comando (62) - on left: 26 27, on right: 23 24 -comando_sem_rotulo (63) - on left: 28 29 30 31 32 33 34, on right: 26 27 63 65 68 -chamada_procedimento (64) - on left: 35, on right: 34 -leitura (65) - on left: 36, on right: 32 -lista_leituras (66) - on left: 37 38, on right: 36 37 -simb_leitura (67) - on left: 39, on right: 37 38 -escrita (68) - on left: 40, on right: 33 -lista_escritas (69) - on left: 41 42, on right: 40 41 -expressao (70) - on left: 43 44 45 46 47 48 49, on right: 43 44 45 46 47 48 63 68 -expressao_simples (71) - on left: 50 51 52, on right: 41 42 43 44 45 46 47 48 49 50 51 57 -termo (72) - on left: 53 54 55, on right: 50 51 52 53 54 -atribuicao (73) - on left: 57, on right: 28 -@5 (74) - on left: 56, on right: 57 -fator (75) - on left: 58 59, on right: 53 54 55 -numero (76) - on left: 60, on right: 26 -comando_repetitivo (77) - on left: 63, on right: 31 -@6 (78) - on left: 61, on right: 63 -@7 (79) - on left: 62, on right: 63 -comando_condicional (80) - on left: 64, on right: 30 -cond_else (81) - on left: 65 66, on right: 64 -if_then (82) - on left: 68, on right: 64 -@8 (83) - on left: 67, on right: 68 + 0 $accept: • programa $end + $padrão reduzir usando a regra 1 ($@1) -state 0 + programa ir ao estado 1 + $@1 ir ao estado 2 - 0 $accept: . programa $end - $default reduce using rule 1 (@1) +Estado 1 - programa go to state 1 - @1 go to state 2 + 0 $accept: programa • $end + $end deslocar, e ir ao estado 3 -state 1 - 0 $accept: programa . $end +Estado 2 - $end shift, and go to state 3 + 2 programa: $@1 • PROGRAM IDENT ABRE_PARENTESES lista_idents FECHA_PARENTESES PONTO_E_VIRGULA bloco PONTO + PROGRAM deslocar, e ir ao estado 4 -state 2 - 2 programa: @1 . PROGRAM IDENT ABRE_PARENTESES lista_idents FECHA_PARENTESES PONTO_E_VIRGULA bloco PONTO +Estado 3 - PROGRAM shift, and go to state 4 + 0 $accept: programa $end • + $padrão aceitar -state 3 - 0 $accept: programa $end . +Estado 4 - $default accept + 2 programa: $@1 PROGRAM • IDENT ABRE_PARENTESES lista_idents FECHA_PARENTESES PONTO_E_VIRGULA bloco PONTO + IDENT deslocar, e ir ao estado 5 -state 4 - 2 programa: @1 PROGRAM . IDENT ABRE_PARENTESES lista_idents FECHA_PARENTESES PONTO_E_VIRGULA bloco PONTO +Estado 5 - IDENT shift, and go to state 5 + 2 programa: $@1 PROGRAM IDENT • ABRE_PARENTESES lista_idents FECHA_PARENTESES PONTO_E_VIRGULA bloco PONTO + ABRE_PARENTESES deslocar, e ir ao estado 6 -state 5 - 2 programa: @1 PROGRAM IDENT . ABRE_PARENTESES lista_idents FECHA_PARENTESES PONTO_E_VIRGULA bloco PONTO +Estado 6 - ABRE_PARENTESES shift, and go to state 6 + 2 programa: $@1 PROGRAM IDENT ABRE_PARENTESES • lista_idents FECHA_PARENTESES PONTO_E_VIRGULA bloco PONTO + IDENT deslocar, e ir ao estado 7 -state 6 + lista_idents ir ao estado 8 - 2 programa: @1 PROGRAM IDENT ABRE_PARENTESES . lista_idents FECHA_PARENTESES PONTO_E_VIRGULA bloco PONTO - IDENT shift, and go to state 7 +Estado 7 - lista_idents go to state 8 + 19 lista_idents: IDENT • + $padrão reduzir usando a regra 19 (lista_idents) -state 7 - 19 lista_idents: IDENT . +Estado 8 - $default reduce using rule 19 (lista_idents) + 2 programa: $@1 PROGRAM IDENT ABRE_PARENTESES lista_idents • FECHA_PARENTESES PONTO_E_VIRGULA bloco PONTO + 18 lista_idents: lista_idents • VIRGULA IDENT + FECHA_PARENTESES deslocar, e ir ao estado 9 + VIRGULA deslocar, e ir ao estado 10 -state 8 - 2 programa: @1 PROGRAM IDENT ABRE_PARENTESES lista_idents . FECHA_PARENTESES PONTO_E_VIRGULA bloco PONTO - 18 lista_idents: lista_idents . VIRGULA IDENT +Estado 9 - FECHA_PARENTESES shift, and go to state 9 - VIRGULA shift, and go to state 10 + 2 programa: $@1 PROGRAM IDENT ABRE_PARENTESES lista_idents FECHA_PARENTESES • PONTO_E_VIRGULA bloco PONTO + PONTO_E_VIRGULA deslocar, e ir ao estado 11 -state 9 - 2 programa: @1 PROGRAM IDENT ABRE_PARENTESES lista_idents FECHA_PARENTESES . PONTO_E_VIRGULA bloco PONTO +Estado 10 - PONTO_E_VIRGULA shift, and go to state 11 + 18 lista_idents: lista_idents VIRGULA • IDENT + IDENT deslocar, e ir ao estado 12 -state 10 - 18 lista_idents: lista_idents VIRGULA . IDENT +Estado 11 - IDENT shift, and go to state 12 + 2 programa: $@1 PROGRAM IDENT ABRE_PARENTESES lista_idents FECHA_PARENTESES PONTO_E_VIRGULA • bloco PONTO + LABEL deslocar, e ir ao estado 13 -state 11 + $padrão reduzir usando a regra 5 (parte_declara_rotulos) - 2 programa: @1 PROGRAM IDENT ABRE_PARENTESES lista_idents FECHA_PARENTESES PONTO_E_VIRGULA . bloco PONTO + bloco ir ao estado 14 + parte_declara_rotulos ir ao estado 15 - LABEL shift, and go to state 13 - $default reduce using rule 5 (parte_declara_rotulos) +Estado 12 - bloco go to state 14 - parte_declara_rotulos go to state 15 + 18 lista_idents: lista_idents VIRGULA IDENT • + $padrão reduzir usando a regra 18 (lista_idents) -state 12 - 18 lista_idents: lista_idents VIRGULA IDENT . +Estado 13 - $default reduce using rule 18 (lista_idents) + 4 parte_declara_rotulos: LABEL • VIRGULA + VIRGULA deslocar, e ir ao estado 16 -state 13 - 4 parte_declara_rotulos: LABEL . VIRGULA +Estado 14 - VIRGULA shift, and go to state 16 + 2 programa: $@1 PROGRAM IDENT ABRE_PARENTESES lista_idents FECHA_PARENTESES PONTO_E_VIRGULA bloco • PONTO + PONTO deslocar, e ir ao estado 17 -state 14 - 2 programa: @1 PROGRAM IDENT ABRE_PARENTESES lista_idents FECHA_PARENTESES PONTO_E_VIRGULA bloco . PONTO +Estado 15 - PONTO shift, and go to state 17 + 3 bloco: parte_declara_rotulos • parte_declara_vars parte_declara_subrotinas comando_composto + VAR reduzir usando a regra 7 ($@2) + $padrão reduzir usando a regra 9 (var) -state 15 + parte_declara_vars ir ao estado 18 + var ir ao estado 19 + $@2 ir ao estado 20 - 3 bloco: parte_declara_rotulos . parte_declara_vars parte_declara_subrotinas comando_composto - T_BEGIN reduce using rule 9 (var) - $default reduce using rule 7 (@2) +Estado 16 - parte_declara_vars go to state 18 - var go to state 19 - @2 go to state 20 + 4 parte_declara_rotulos: LABEL VIRGULA • + $padrão reduzir usando a regra 4 (parte_declara_rotulos) -state 16 - 4 parte_declara_rotulos: LABEL VIRGULA . +Estado 17 - $default reduce using rule 4 (parte_declara_rotulos) + 2 programa: $@1 PROGRAM IDENT ABRE_PARENTESES lista_idents FECHA_PARENTESES PONTO_E_VIRGULA bloco PONTO • + $padrão reduzir usando a regra 2 (programa) -state 17 - 2 programa: @1 PROGRAM IDENT ABRE_PARENTESES lista_idents FECHA_PARENTESES PONTO_E_VIRGULA bloco PONTO . +Estado 18 - $default reduce using rule 2 (programa) + 3 bloco: parte_declara_rotulos parte_declara_vars • parte_declara_subrotinas comando_composto + PROCEDURE deslocar, e ir ao estado 21 -state 18 + $padrão reduzir usando a regra 22 (declaracao_procedimento) - 3 bloco: parte_declara_rotulos parte_declara_vars . parte_declara_subrotinas comando_composto + parte_declara_subrotinas ir ao estado 22 + declaracao_procedimento ir ao estado 23 - $default reduce using rule 21 (declaracao_procedimento) - parte_declara_subrotinas go to state 21 - declaracao_procedimento go to state 22 +Estado 19 + 6 parte_declara_vars: var • -state 19 + $padrão reduzir usando a regra 6 (parte_declara_vars) - 6 parte_declara_vars: var . - $default reduce using rule 6 (parte_declara_vars) +Estado 20 + 8 var: $@2 • VAR declara_vars -state 20 + VAR deslocar, e ir ao estado 24 - 8 var: @2 . VAR declara_vars - VAR shift, and go to state 23 +Estado 21 + 21 declaracao_procedimento: PROCEDURE • IDENT -state 21 + IDENT deslocar, e ir ao estado 25 - 3 bloco: parte_declara_rotulos parte_declara_vars parte_declara_subrotinas . comando_composto - T_BEGIN shift, and go to state 24 +Estado 22 - comando_composto go to state 25 + 3 bloco: parte_declara_rotulos parte_declara_vars parte_declara_subrotinas • comando_composto + T_BEGIN deslocar, e ir ao estado 26 -state 22 + comando_composto ir ao estado 27 - 20 parte_declara_subrotinas: declaracao_procedimento . - $default reduce using rule 20 (parte_declara_subrotinas) +Estado 23 + 20 parte_declara_subrotinas: declaracao_procedimento • -state 23 + $padrão reduzir usando a regra 20 (parte_declara_subrotinas) - 8 var: @2 VAR . declara_vars - $default reduce using rule 12 (@3) +Estado 24 - declara_vars go to state 26 - declara_var go to state 27 - @3 go to state 28 + 8 var: $@2 VAR • declara_vars + $padrão reduzir usando a regra 12 ($@3) -state 24 + declara_vars ir ao estado 28 + declara_var ir ao estado 29 + $@3 ir ao estado 30 - 22 comando_composto: T_BEGIN . comandos T_END - T_BEGIN shift, and go to state 24 - IDENT shift, and go to state 29 - IF shift, and go to state 30 - NUMERO shift, and go to state 31 - READ shift, and go to state 32 - WRITE shift, and go to state 33 +Estado 25 - PONTO_E_VIRGULA reduce using rule 35 (chamada_procedimento) - WHILE reduce using rule 61 (@6) - $default reduce using rule 25 (comandos) + 21 declaracao_procedimento: PROCEDURE IDENT • - comando_composto go to state 34 - comandos go to state 35 - comando go to state 36 - comando_sem_rotulo go to state 37 - chamada_procedimento go to state 38 - leitura go to state 39 - escrita go to state 40 - atribuicao go to state 41 - numero go to state 42 - comando_repetitivo go to state 43 - @6 go to state 44 - comando_condicional go to state 45 - if_then go to state 46 + $padrão reduzir usando a regra 21 (declaracao_procedimento) -state 25 +Estado 26 - 3 bloco: parte_declara_rotulos parte_declara_vars parte_declara_subrotinas comando_composto . + 23 comando_composto: T_BEGIN • comandos T_END - $default reduce using rule 3 (bloco) + T_BEGIN deslocar, e ir ao estado 26 + IDENT deslocar, e ir ao estado 31 + IF deslocar, e ir ao estado 32 + NUMERO deslocar, e ir ao estado 33 + READ deslocar, e ir ao estado 34 + WRITE deslocar, e ir ao estado 35 + WHILE reduzir usando a regra 60 ($@6) + $padrão reduzir usando a regra 26 (comandos) -state 26 + comando_composto ir ao estado 36 + comandos ir ao estado 37 + comando ir ao estado 38 + comando_sem_rotulo ir ao estado 39 + leitura ir ao estado 40 + escrita ir ao estado 41 + atribuicao ir ao estado 42 + numero ir ao estado 43 + comando_repetitivo ir ao estado 44 + $@6 ir ao estado 45 + comando_condicional ir ao estado 46 + if_then ir ao estado 47 - 8 var: @2 VAR declara_vars . - 10 declara_vars: declara_vars . declara_var - IDENT reduce using rule 12 (@3) - $default reduce using rule 8 (var) +Estado 27 - declara_var go to state 47 - @3 go to state 28 + 3 bloco: parte_declara_rotulos parte_declara_vars parte_declara_subrotinas comando_composto • + $padrão reduzir usando a regra 3 (bloco) -state 27 - 11 declara_vars: declara_var . +Estado 28 - $default reduce using rule 11 (declara_vars) + 8 var: $@2 VAR declara_vars • + 10 declara_vars: declara_vars • declara_var + IDENT reduzir usando a regra 12 ($@3) + $padrão reduzir usando a regra 8 (var) -state 28 + declara_var ir ao estado 48 + $@3 ir ao estado 30 - 14 declara_var: @3 . lista_id_var DOIS_PONTOS tipo @4 PONTO_E_VIRGULA - IDENT shift, and go to state 48 +Estado 29 - lista_id_var go to state 49 + 11 declara_vars: declara_var • + $padrão reduzir usando a regra 11 (declara_vars) -state 29 - 57 atribuicao: IDENT . @5 ATRIBUICAO expressao_simples +Estado 30 - $default reduce using rule 56 (@5) + 14 declara_var: $@3 • lista_id_var DOIS_PONTOS tipo $@4 PONTO_E_VIRGULA - @5 go to state 50 + IDENT deslocar, e ir ao estado 49 + lista_id_var ir ao estado 50 -state 30 - 68 if_then: IF . expressao @8 THEN comando_sem_rotulo +Estado 31 - IDENT shift, and go to state 51 - NUMERO shift, and go to state 52 + 56 atribuicao: IDENT • $@5 ATRIBUICAO expressao_simples - expressao go to state 53 - expressao_simples go to state 54 - termo go to state 55 - fator go to state 56 + $padrão reduzir usando a regra 55 ($@5) + $@5 ir ao estado 51 -state 31 - 60 numero: NUMERO . +Estado 32 - $default reduce using rule 60 (numero) + 67 if_then: IF • expressao $@8 THEN comando_sem_rotulo + IDENT deslocar, e ir ao estado 52 + NUMERO deslocar, e ir ao estado 53 -state 32 + expressao ir ao estado 54 + expressao_simples ir ao estado 55 + termo ir ao estado 56 + fator ir ao estado 57 - 36 leitura: READ . ABRE_PARENTESES lista_leituras FECHA_PARENTESES - ABRE_PARENTESES shift, and go to state 57 +Estado 33 + 59 numero: NUMERO • -state 33 + $padrão reduzir usando a regra 59 (numero) - 40 escrita: WRITE . ABRE_PARENTESES lista_escritas FECHA_PARENTESES - ABRE_PARENTESES shift, and go to state 58 +Estado 34 + 35 leitura: READ • ABRE_PARENTESES lista_leituras FECHA_PARENTESES -state 34 + ABRE_PARENTESES deslocar, e ir ao estado 58 - 29 comando_sem_rotulo: comando_composto . - $default reduce using rule 29 (comando_sem_rotulo) +Estado 35 + 39 escrita: WRITE • ABRE_PARENTESES lista_escritas FECHA_PARENTESES -state 35 + ABRE_PARENTESES deslocar, e ir ao estado 59 - 22 comando_composto: T_BEGIN comandos . T_END - T_END shift, and go to state 59 +Estado 36 + 30 comando_sem_rotulo: comando_composto • -state 36 + $padrão reduzir usando a regra 30 (comando_sem_rotulo) - 23 comandos: comando . PONTO_E_VIRGULA comandos - 24 | comando . PONTO_E_VIRGULA - PONTO_E_VIRGULA shift, and go to state 60 +Estado 37 + 23 comando_composto: T_BEGIN comandos • T_END -state 37 + T_END deslocar, e ir ao estado 60 - 27 comando: comando_sem_rotulo . - $default reduce using rule 27 (comando) +Estado 38 + 24 comandos: comando • PONTO_E_VIRGULA comandos + 25 | comando • PONTO_E_VIRGULA -state 38 + PONTO_E_VIRGULA deslocar, e ir ao estado 61 - 34 comando_sem_rotulo: chamada_procedimento . - $default reduce using rule 34 (comando_sem_rotulo) +Estado 39 + 28 comando: comando_sem_rotulo • -state 39 + $padrão reduzir usando a regra 28 (comando) - 32 comando_sem_rotulo: leitura . - $default reduce using rule 32 (comando_sem_rotulo) +Estado 40 + 33 comando_sem_rotulo: leitura • -state 40 + $padrão reduzir usando a regra 33 (comando_sem_rotulo) - 33 comando_sem_rotulo: escrita . - $default reduce using rule 33 (comando_sem_rotulo) +Estado 41 + 34 comando_sem_rotulo: escrita • -state 41 + $padrão reduzir usando a regra 34 (comando_sem_rotulo) - 28 comando_sem_rotulo: atribuicao . - $default reduce using rule 28 (comando_sem_rotulo) +Estado 42 + 29 comando_sem_rotulo: atribuicao • -state 42 + $padrão reduzir usando a regra 29 (comando_sem_rotulo) - 26 comando: numero . DOIS_PONTOS comando_sem_rotulo - DOIS_PONTOS shift, and go to state 61 +Estado 43 + 27 comando: numero • DOIS_PONTOS comando_sem_rotulo -state 43 + DOIS_PONTOS deslocar, e ir ao estado 62 - 31 comando_sem_rotulo: comando_repetitivo . - $default reduce using rule 31 (comando_sem_rotulo) +Estado 44 + 32 comando_sem_rotulo: comando_repetitivo • -state 44 + $padrão reduzir usando a regra 32 (comando_sem_rotulo) - 63 comando_repetitivo: @6 . WHILE expressao DO @7 comando_sem_rotulo - WHILE shift, and go to state 62 +Estado 45 + 62 comando_repetitivo: $@6 • WHILE expressao DO $@7 comando_sem_rotulo -state 45 + WHILE deslocar, e ir ao estado 63 - 30 comando_sem_rotulo: comando_condicional . - $default reduce using rule 30 (comando_sem_rotulo) +Estado 46 + 31 comando_sem_rotulo: comando_condicional • -state 46 + $padrão reduzir usando a regra 31 (comando_sem_rotulo) - 64 comando_condicional: if_then . cond_else - ELSE shift, and go to state 63 +Estado 47 - $default reduce using rule 66 (cond_else) + 63 comando_condicional: if_then • cond_else - cond_else go to state 64 + ELSE deslocar, e ir ao estado 64 + $padrão reduzir usando a regra 65 (cond_else) -state 47 + cond_else ir ao estado 65 - 10 declara_vars: declara_vars declara_var . - $default reduce using rule 10 (declara_vars) +Estado 48 + 10 declara_vars: declara_vars declara_var • -state 48 + $padrão reduzir usando a regra 10 (declara_vars) - 17 lista_id_var: IDENT . - $default reduce using rule 17 (lista_id_var) +Estado 49 + 17 lista_id_var: IDENT • -state 49 + $padrão reduzir usando a regra 17 (lista_id_var) - 14 declara_var: @3 lista_id_var . DOIS_PONTOS tipo @4 PONTO_E_VIRGULA - 16 lista_id_var: lista_id_var . VIRGULA IDENT - VIRGULA shift, and go to state 65 - DOIS_PONTOS shift, and go to state 66 +Estado 50 + 14 declara_var: $@3 lista_id_var • DOIS_PONTOS tipo $@4 PONTO_E_VIRGULA + 16 lista_id_var: lista_id_var • VIRGULA IDENT -state 50 + VIRGULA deslocar, e ir ao estado 66 + DOIS_PONTOS deslocar, e ir ao estado 67 - 57 atribuicao: IDENT @5 . ATRIBUICAO expressao_simples - ATRIBUICAO shift, and go to state 67 +Estado 51 + 56 atribuicao: IDENT $@5 • ATRIBUICAO expressao_simples -state 51 + ATRIBUICAO deslocar, e ir ao estado 68 - 58 fator: IDENT . - $default reduce using rule 58 (fator) +Estado 52 + 57 fator: IDENT • -state 52 + $padrão reduzir usando a regra 57 (fator) - 59 fator: NUMERO . - $default reduce using rule 59 (fator) +Estado 53 + 58 fator: NUMERO • -state 53 + $padrão reduzir usando a regra 58 (fator) - 43 expressao: expressao . IGUAL expressao_simples - 44 | expressao . DIFERENTE expressao_simples - 45 | expressao . MENOR expressao_simples - 46 | expressao . MENOR_IGUAL expressao_simples - 47 | expressao . MAIOR expressao_simples - 48 | expressao . MAIOR_IGUAL expressao_simples - 68 if_then: IF expressao . @8 THEN comando_sem_rotulo - IGUAL shift, and go to state 68 - DIFERENTE shift, and go to state 69 - MENOR_IGUAL shift, and go to state 70 - MAIOR_IGUAL shift, and go to state 71 - MENOR shift, and go to state 72 - MAIOR shift, and go to state 73 +Estado 54 - $default reduce using rule 67 (@8) + 42 expressao: expressao • IGUAL expressao_simples + 43 | expressao • DIFERENTE expressao_simples + 44 | expressao • MENOR expressao_simples + 45 | expressao • MENOR_IGUAL expressao_simples + 46 | expressao • MAIOR expressao_simples + 47 | expressao • MAIOR_IGUAL expressao_simples + 67 if_then: IF expressao • $@8 THEN comando_sem_rotulo - @8 go to state 74 + IGUAL deslocar, e ir ao estado 69 + DIFERENTE deslocar, e ir ao estado 70 + MENOR_IGUAL deslocar, e ir ao estado 71 + MAIOR_IGUAL deslocar, e ir ao estado 72 + MENOR deslocar, e ir ao estado 73 + MAIOR deslocar, e ir ao estado 74 + $padrão reduzir usando a regra 66 ($@8) -state 54 + $@8 ir ao estado 75 - 49 expressao: expressao_simples . - 50 expressao_simples: expressao_simples . MAIS termo - 51 | expressao_simples . MENOS termo - MAIS shift, and go to state 75 - MENOS shift, and go to state 76 +Estado 55 - $default reduce using rule 49 (expressao) + 48 expressao: expressao_simples • + 49 expressao_simples: expressao_simples • MAIS termo + 50 | expressao_simples • MENOS termo + MAIS deslocar, e ir ao estado 76 + MENOS deslocar, e ir ao estado 77 -state 55 + $padrão reduzir usando a regra 48 (expressao) - 52 expressao_simples: termo . - 53 termo: termo . ASTERISCO fator - 54 | termo . DIV fator - DIV shift, and go to state 77 - ASTERISCO shift, and go to state 78 +Estado 56 - $default reduce using rule 52 (expressao_simples) + 51 expressao_simples: termo • + 52 termo: termo • ASTERISCO fator + 53 | termo • DIV fator + DIV deslocar, e ir ao estado 78 + ASTERISCO deslocar, e ir ao estado 79 -state 56 + $padrão reduzir usando a regra 51 (expressao_simples) - 55 termo: fator . - $default reduce using rule 55 (termo) +Estado 57 + 54 termo: fator • -state 57 + $padrão reduzir usando a regra 54 (termo) - 36 leitura: READ ABRE_PARENTESES . lista_leituras FECHA_PARENTESES - IDENT shift, and go to state 79 +Estado 58 - lista_leituras go to state 80 - simb_leitura go to state 81 + 35 leitura: READ ABRE_PARENTESES • lista_leituras FECHA_PARENTESES + IDENT deslocar, e ir ao estado 80 -state 58 + lista_leituras ir ao estado 81 + simb_leitura ir ao estado 82 - 40 escrita: WRITE ABRE_PARENTESES . lista_escritas FECHA_PARENTESES - IDENT shift, and go to state 51 - NUMERO shift, and go to state 52 +Estado 59 - lista_escritas go to state 82 - expressao_simples go to state 83 - termo go to state 55 - fator go to state 56 + 39 escrita: WRITE ABRE_PARENTESES • lista_escritas FECHA_PARENTESES + IDENT deslocar, e ir ao estado 52 + NUMERO deslocar, e ir ao estado 53 -state 59 + lista_escritas ir ao estado 83 + expressao_simples ir ao estado 84 + termo ir ao estado 56 + fator ir ao estado 57 - 22 comando_composto: T_BEGIN comandos T_END . - $default reduce using rule 22 (comando_composto) +Estado 60 + 23 comando_composto: T_BEGIN comandos T_END • -state 60 + $padrão reduzir usando a regra 23 (comando_composto) - 23 comandos: comando PONTO_E_VIRGULA . comandos - 24 | comando PONTO_E_VIRGULA . - T_BEGIN shift, and go to state 24 - IDENT shift, and go to state 29 - IF shift, and go to state 30 - NUMERO shift, and go to state 31 - READ shift, and go to state 32 - WRITE shift, and go to state 33 +Estado 61 - PONTO_E_VIRGULA reduce using rule 35 (chamada_procedimento) - T_END reduce using rule 24 (comandos) - T_END [reduce using rule 25 (comandos)] - WHILE reduce using rule 61 (@6) - $default reduce using rule 24 (comandos) + 24 comandos: comando PONTO_E_VIRGULA • comandos + 25 | comando PONTO_E_VIRGULA • - comando_composto go to state 34 - comandos go to state 84 - comando go to state 36 - comando_sem_rotulo go to state 37 - chamada_procedimento go to state 38 - leitura go to state 39 - escrita go to state 40 - atribuicao go to state 41 - numero go to state 42 - comando_repetitivo go to state 43 - @6 go to state 44 - comando_condicional go to state 45 - if_then go to state 46 + T_BEGIN deslocar, e ir ao estado 26 + IDENT deslocar, e ir ao estado 31 + IF deslocar, e ir ao estado 32 + NUMERO deslocar, e ir ao estado 33 + READ deslocar, e ir ao estado 34 + WRITE deslocar, e ir ao estado 35 + T_END reduzir usando a regra 25 (comandos) + T_END [reduzir usando a regra 26 (comandos)] + WHILE reduzir usando a regra 60 ($@6) + $padrão reduzir usando a regra 25 (comandos) -state 61 + comando_composto ir ao estado 36 + comandos ir ao estado 85 + comando ir ao estado 38 + comando_sem_rotulo ir ao estado 39 + leitura ir ao estado 40 + escrita ir ao estado 41 + atribuicao ir ao estado 42 + numero ir ao estado 43 + comando_repetitivo ir ao estado 44 + $@6 ir ao estado 45 + comando_condicional ir ao estado 46 + if_then ir ao estado 47 - 26 comando: numero DOIS_PONTOS . comando_sem_rotulo - T_BEGIN shift, and go to state 24 - IDENT shift, and go to state 29 - IF shift, and go to state 30 - READ shift, and go to state 32 - WRITE shift, and go to state 33 +Estado 62 - WHILE reduce using rule 61 (@6) - $default reduce using rule 35 (chamada_procedimento) + 27 comando: numero DOIS_PONTOS • comando_sem_rotulo - comando_composto go to state 34 - comando_sem_rotulo go to state 85 - chamada_procedimento go to state 38 - leitura go to state 39 - escrita go to state 40 - atribuicao go to state 41 - comando_repetitivo go to state 43 - @6 go to state 44 - comando_condicional go to state 45 - if_then go to state 46 + T_BEGIN deslocar, e ir ao estado 26 + IDENT deslocar, e ir ao estado 31 + IF deslocar, e ir ao estado 32 + READ deslocar, e ir ao estado 34 + WRITE deslocar, e ir ao estado 35 + $padrão reduzir usando a regra 60 ($@6) -state 62 + comando_composto ir ao estado 36 + comando_sem_rotulo ir ao estado 86 + leitura ir ao estado 40 + escrita ir ao estado 41 + atribuicao ir ao estado 42 + comando_repetitivo ir ao estado 44 + $@6 ir ao estado 45 + comando_condicional ir ao estado 46 + if_then ir ao estado 47 - 63 comando_repetitivo: @6 WHILE . expressao DO @7 comando_sem_rotulo - IDENT shift, and go to state 51 - NUMERO shift, and go to state 52 +Estado 63 - expressao go to state 86 - expressao_simples go to state 54 - termo go to state 55 - fator go to state 56 + 62 comando_repetitivo: $@6 WHILE • expressao DO $@7 comando_sem_rotulo + IDENT deslocar, e ir ao estado 52 + NUMERO deslocar, e ir ao estado 53 -state 63 + expressao ir ao estado 87 + expressao_simples ir ao estado 55 + termo ir ao estado 56 + fator ir ao estado 57 - 65 cond_else: ELSE . comando_sem_rotulo - T_BEGIN shift, and go to state 24 - IDENT shift, and go to state 29 - IF shift, and go to state 30 - READ shift, and go to state 32 - WRITE shift, and go to state 33 +Estado 64 - WHILE reduce using rule 61 (@6) - $default reduce using rule 35 (chamada_procedimento) + 64 cond_else: ELSE • comando_sem_rotulo - comando_composto go to state 34 - comando_sem_rotulo go to state 87 - chamada_procedimento go to state 38 - leitura go to state 39 - escrita go to state 40 - atribuicao go to state 41 - comando_repetitivo go to state 43 - @6 go to state 44 - comando_condicional go to state 45 - if_then go to state 46 + T_BEGIN deslocar, e ir ao estado 26 + IDENT deslocar, e ir ao estado 31 + IF deslocar, e ir ao estado 32 + READ deslocar, e ir ao estado 34 + WRITE deslocar, e ir ao estado 35 + $padrão reduzir usando a regra 60 ($@6) -state 64 + comando_composto ir ao estado 36 + comando_sem_rotulo ir ao estado 88 + leitura ir ao estado 40 + escrita ir ao estado 41 + atribuicao ir ao estado 42 + comando_repetitivo ir ao estado 44 + $@6 ir ao estado 45 + comando_condicional ir ao estado 46 + if_then ir ao estado 47 - 64 comando_condicional: if_then cond_else . - $default reduce using rule 64 (comando_condicional) +Estado 65 + 63 comando_condicional: if_then cond_else • -state 65 + $padrão reduzir usando a regra 63 (comando_condicional) - 16 lista_id_var: lista_id_var VIRGULA . IDENT - IDENT shift, and go to state 88 +Estado 66 + 16 lista_id_var: lista_id_var VIRGULA • IDENT -state 66 + IDENT deslocar, e ir ao estado 89 - 14 declara_var: @3 lista_id_var DOIS_PONTOS . tipo @4 PONTO_E_VIRGULA - IDENT shift, and go to state 89 +Estado 67 - tipo go to state 90 + 14 declara_var: $@3 lista_id_var DOIS_PONTOS • tipo $@4 PONTO_E_VIRGULA + IDENT deslocar, e ir ao estado 90 -state 67 + tipo ir ao estado 91 - 57 atribuicao: IDENT @5 ATRIBUICAO . expressao_simples - IDENT shift, and go to state 51 - NUMERO shift, and go to state 52 +Estado 68 - expressao_simples go to state 91 - termo go to state 55 - fator go to state 56 + 56 atribuicao: IDENT $@5 ATRIBUICAO • expressao_simples + IDENT deslocar, e ir ao estado 52 + NUMERO deslocar, e ir ao estado 53 -state 68 + expressao_simples ir ao estado 92 + termo ir ao estado 56 + fator ir ao estado 57 - 43 expressao: expressao IGUAL . expressao_simples - IDENT shift, and go to state 51 - NUMERO shift, and go to state 52 +Estado 69 - expressao_simples go to state 92 - termo go to state 55 - fator go to state 56 + 42 expressao: expressao IGUAL • expressao_simples + IDENT deslocar, e ir ao estado 52 + NUMERO deslocar, e ir ao estado 53 -state 69 + expressao_simples ir ao estado 93 + termo ir ao estado 56 + fator ir ao estado 57 - 44 expressao: expressao DIFERENTE . expressao_simples - IDENT shift, and go to state 51 - NUMERO shift, and go to state 52 +Estado 70 - expressao_simples go to state 93 - termo go to state 55 - fator go to state 56 + 43 expressao: expressao DIFERENTE • expressao_simples + IDENT deslocar, e ir ao estado 52 + NUMERO deslocar, e ir ao estado 53 -state 70 + expressao_simples ir ao estado 94 + termo ir ao estado 56 + fator ir ao estado 57 - 46 expressao: expressao MENOR_IGUAL . expressao_simples - IDENT shift, and go to state 51 - NUMERO shift, and go to state 52 +Estado 71 - expressao_simples go to state 94 - termo go to state 55 - fator go to state 56 + 45 expressao: expressao MENOR_IGUAL • expressao_simples + IDENT deslocar, e ir ao estado 52 + NUMERO deslocar, e ir ao estado 53 -state 71 + expressao_simples ir ao estado 95 + termo ir ao estado 56 + fator ir ao estado 57 - 48 expressao: expressao MAIOR_IGUAL . expressao_simples - IDENT shift, and go to state 51 - NUMERO shift, and go to state 52 +Estado 72 - expressao_simples go to state 95 - termo go to state 55 - fator go to state 56 + 47 expressao: expressao MAIOR_IGUAL • expressao_simples + IDENT deslocar, e ir ao estado 52 + NUMERO deslocar, e ir ao estado 53 -state 72 + expressao_simples ir ao estado 96 + termo ir ao estado 56 + fator ir ao estado 57 - 45 expressao: expressao MENOR . expressao_simples - IDENT shift, and go to state 51 - NUMERO shift, and go to state 52 +Estado 73 - expressao_simples go to state 96 - termo go to state 55 - fator go to state 56 + 44 expressao: expressao MENOR • expressao_simples + IDENT deslocar, e ir ao estado 52 + NUMERO deslocar, e ir ao estado 53 -state 73 + expressao_simples ir ao estado 97 + termo ir ao estado 56 + fator ir ao estado 57 - 47 expressao: expressao MAIOR . expressao_simples - IDENT shift, and go to state 51 - NUMERO shift, and go to state 52 +Estado 74 - expressao_simples go to state 97 - termo go to state 55 - fator go to state 56 + 46 expressao: expressao MAIOR • expressao_simples + IDENT deslocar, e ir ao estado 52 + NUMERO deslocar, e ir ao estado 53 -state 74 + expressao_simples ir ao estado 98 + termo ir ao estado 56 + fator ir ao estado 57 - 68 if_then: IF expressao @8 . THEN comando_sem_rotulo - THEN shift, and go to state 98 +Estado 75 + 67 if_then: IF expressao $@8 • THEN comando_sem_rotulo -state 75 + THEN deslocar, e ir ao estado 99 - 50 expressao_simples: expressao_simples MAIS . termo - IDENT shift, and go to state 51 - NUMERO shift, and go to state 52 +Estado 76 - termo go to state 99 - fator go to state 56 + 49 expressao_simples: expressao_simples MAIS • termo + IDENT deslocar, e ir ao estado 52 + NUMERO deslocar, e ir ao estado 53 -state 76 + termo ir ao estado 100 + fator ir ao estado 57 - 51 expressao_simples: expressao_simples MENOS . termo - IDENT shift, and go to state 51 - NUMERO shift, and go to state 52 +Estado 77 - termo go to state 100 - fator go to state 56 + 50 expressao_simples: expressao_simples MENOS • termo + IDENT deslocar, e ir ao estado 52 + NUMERO deslocar, e ir ao estado 53 -state 77 + termo ir ao estado 101 + fator ir ao estado 57 - 54 termo: termo DIV . fator - IDENT shift, and go to state 51 - NUMERO shift, and go to state 52 +Estado 78 - fator go to state 101 + 53 termo: termo DIV • fator + IDENT deslocar, e ir ao estado 52 + NUMERO deslocar, e ir ao estado 53 -state 78 + fator ir ao estado 102 - 53 termo: termo ASTERISCO . fator - IDENT shift, and go to state 51 - NUMERO shift, and go to state 52 +Estado 79 - fator go to state 102 + 52 termo: termo ASTERISCO • fator + IDENT deslocar, e ir ao estado 52 + NUMERO deslocar, e ir ao estado 53 -state 79 + fator ir ao estado 103 - 39 simb_leitura: IDENT . - $default reduce using rule 39 (simb_leitura) +Estado 80 + 38 simb_leitura: IDENT • -state 80 + $padrão reduzir usando a regra 38 (simb_leitura) - 36 leitura: READ ABRE_PARENTESES lista_leituras . FECHA_PARENTESES - 37 lista_leituras: lista_leituras . VIRGULA simb_leitura - FECHA_PARENTESES shift, and go to state 103 - VIRGULA shift, and go to state 104 +Estado 81 + 35 leitura: READ ABRE_PARENTESES lista_leituras • FECHA_PARENTESES + 36 lista_leituras: lista_leituras • VIRGULA simb_leitura -state 81 + FECHA_PARENTESES deslocar, e ir ao estado 104 + VIRGULA deslocar, e ir ao estado 105 - 38 lista_leituras: simb_leitura . - $default reduce using rule 38 (lista_leituras) +Estado 82 + 37 lista_leituras: simb_leitura • -state 82 + $padrão reduzir usando a regra 37 (lista_leituras) - 40 escrita: WRITE ABRE_PARENTESES lista_escritas . FECHA_PARENTESES - 41 lista_escritas: lista_escritas . VIRGULA expressao_simples - FECHA_PARENTESES shift, and go to state 105 - VIRGULA shift, and go to state 106 +Estado 83 + 39 escrita: WRITE ABRE_PARENTESES lista_escritas • FECHA_PARENTESES + 40 lista_escritas: lista_escritas • VIRGULA expressao_simples -state 83 + FECHA_PARENTESES deslocar, e ir ao estado 106 + VIRGULA deslocar, e ir ao estado 107 - 42 lista_escritas: expressao_simples . - 50 expressao_simples: expressao_simples . MAIS termo - 51 | expressao_simples . MENOS termo - MAIS shift, and go to state 75 - MENOS shift, and go to state 76 +Estado 84 - $default reduce using rule 42 (lista_escritas) + 41 lista_escritas: expressao_simples • + 49 expressao_simples: expressao_simples • MAIS termo + 50 | expressao_simples • MENOS termo + MAIS deslocar, e ir ao estado 76 + MENOS deslocar, e ir ao estado 77 -state 84 + $padrão reduzir usando a regra 41 (lista_escritas) - 23 comandos: comando PONTO_E_VIRGULA comandos . - $default reduce using rule 23 (comandos) +Estado 85 + 24 comandos: comando PONTO_E_VIRGULA comandos • -state 85 + $padrão reduzir usando a regra 24 (comandos) - 26 comando: numero DOIS_PONTOS comando_sem_rotulo . - $default reduce using rule 26 (comando) +Estado 86 + 27 comando: numero DOIS_PONTOS comando_sem_rotulo • -state 86 + $padrão reduzir usando a regra 27 (comando) - 43 expressao: expressao . IGUAL expressao_simples - 44 | expressao . DIFERENTE expressao_simples - 45 | expressao . MENOR expressao_simples - 46 | expressao . MENOR_IGUAL expressao_simples - 47 | expressao . MAIOR expressao_simples - 48 | expressao . MAIOR_IGUAL expressao_simples - 63 comando_repetitivo: @6 WHILE expressao . DO @7 comando_sem_rotulo - DO shift, and go to state 107 - IGUAL shift, and go to state 68 - DIFERENTE shift, and go to state 69 - MENOR_IGUAL shift, and go to state 70 - MAIOR_IGUAL shift, and go to state 71 - MENOR shift, and go to state 72 - MAIOR shift, and go to state 73 +Estado 87 + 42 expressao: expressao • IGUAL expressao_simples + 43 | expressao • DIFERENTE expressao_simples + 44 | expressao • MENOR expressao_simples + 45 | expressao • MENOR_IGUAL expressao_simples + 46 | expressao • MAIOR expressao_simples + 47 | expressao • MAIOR_IGUAL expressao_simples + 62 comando_repetitivo: $@6 WHILE expressao • DO $@7 comando_sem_rotulo -state 87 + DO deslocar, e ir ao estado 108 + IGUAL deslocar, e ir ao estado 69 + DIFERENTE deslocar, e ir ao estado 70 + MENOR_IGUAL deslocar, e ir ao estado 71 + MAIOR_IGUAL deslocar, e ir ao estado 72 + MENOR deslocar, e ir ao estado 73 + MAIOR deslocar, e ir ao estado 74 - 65 cond_else: ELSE comando_sem_rotulo . - $default reduce using rule 65 (cond_else) +Estado 88 + 64 cond_else: ELSE comando_sem_rotulo • -state 88 + $padrão reduzir usando a regra 64 (cond_else) - 16 lista_id_var: lista_id_var VIRGULA IDENT . - $default reduce using rule 16 (lista_id_var) +Estado 89 + 16 lista_id_var: lista_id_var VIRGULA IDENT • -state 89 + $padrão reduzir usando a regra 16 (lista_id_var) - 15 tipo: IDENT . - $default reduce using rule 15 (tipo) +Estado 90 + 15 tipo: IDENT • -state 90 + $padrão reduzir usando a regra 15 (tipo) - 14 declara_var: @3 lista_id_var DOIS_PONTOS tipo . @4 PONTO_E_VIRGULA - $default reduce using rule 13 (@4) +Estado 91 - @4 go to state 108 + 14 declara_var: $@3 lista_id_var DOIS_PONTOS tipo • $@4 PONTO_E_VIRGULA + $padrão reduzir usando a regra 13 ($@4) -state 91 + $@4 ir ao estado 109 - 50 expressao_simples: expressao_simples . MAIS termo - 51 | expressao_simples . MENOS termo - 57 atribuicao: IDENT @5 ATRIBUICAO expressao_simples . - MAIS shift, and go to state 75 - MENOS shift, and go to state 76 +Estado 92 - $default reduce using rule 57 (atribuicao) + 49 expressao_simples: expressao_simples • MAIS termo + 50 | expressao_simples • MENOS termo + 56 atribuicao: IDENT $@5 ATRIBUICAO expressao_simples • + MAIS deslocar, e ir ao estado 76 + MENOS deslocar, e ir ao estado 77 -state 92 + $padrão reduzir usando a regra 56 (atribuicao) - 43 expressao: expressao IGUAL expressao_simples . - 50 expressao_simples: expressao_simples . MAIS termo - 51 | expressao_simples . MENOS termo - MAIS shift, and go to state 75 - MENOS shift, and go to state 76 +Estado 93 - $default reduce using rule 43 (expressao) + 42 expressao: expressao IGUAL expressao_simples • + 49 expressao_simples: expressao_simples • MAIS termo + 50 | expressao_simples • MENOS termo + MAIS deslocar, e ir ao estado 76 + MENOS deslocar, e ir ao estado 77 -state 93 + $padrão reduzir usando a regra 42 (expressao) - 44 expressao: expressao DIFERENTE expressao_simples . - 50 expressao_simples: expressao_simples . MAIS termo - 51 | expressao_simples . MENOS termo - MAIS shift, and go to state 75 - MENOS shift, and go to state 76 +Estado 94 - $default reduce using rule 44 (expressao) + 43 expressao: expressao DIFERENTE expressao_simples • + 49 expressao_simples: expressao_simples • MAIS termo + 50 | expressao_simples • MENOS termo + MAIS deslocar, e ir ao estado 76 + MENOS deslocar, e ir ao estado 77 -state 94 + $padrão reduzir usando a regra 43 (expressao) - 46 expressao: expressao MENOR_IGUAL expressao_simples . - 50 expressao_simples: expressao_simples . MAIS termo - 51 | expressao_simples . MENOS termo - MAIS shift, and go to state 75 - MENOS shift, and go to state 76 +Estado 95 - $default reduce using rule 46 (expressao) + 45 expressao: expressao MENOR_IGUAL expressao_simples • + 49 expressao_simples: expressao_simples • MAIS termo + 50 | expressao_simples • MENOS termo + MAIS deslocar, e ir ao estado 76 + MENOS deslocar, e ir ao estado 77 -state 95 + $padrão reduzir usando a regra 45 (expressao) - 48 expressao: expressao MAIOR_IGUAL expressao_simples . - 50 expressao_simples: expressao_simples . MAIS termo - 51 | expressao_simples . MENOS termo - MAIS shift, and go to state 75 - MENOS shift, and go to state 76 +Estado 96 - $default reduce using rule 48 (expressao) + 47 expressao: expressao MAIOR_IGUAL expressao_simples • + 49 expressao_simples: expressao_simples • MAIS termo + 50 | expressao_simples • MENOS termo + MAIS deslocar, e ir ao estado 76 + MENOS deslocar, e ir ao estado 77 -state 96 + $padrão reduzir usando a regra 47 (expressao) - 45 expressao: expressao MENOR expressao_simples . - 50 expressao_simples: expressao_simples . MAIS termo - 51 | expressao_simples . MENOS termo - MAIS shift, and go to state 75 - MENOS shift, and go to state 76 +Estado 97 - $default reduce using rule 45 (expressao) + 44 expressao: expressao MENOR expressao_simples • + 49 expressao_simples: expressao_simples • MAIS termo + 50 | expressao_simples • MENOS termo + MAIS deslocar, e ir ao estado 76 + MENOS deslocar, e ir ao estado 77 -state 97 + $padrão reduzir usando a regra 44 (expressao) - 47 expressao: expressao MAIOR expressao_simples . - 50 expressao_simples: expressao_simples . MAIS termo - 51 | expressao_simples . MENOS termo - MAIS shift, and go to state 75 - MENOS shift, and go to state 76 +Estado 98 - $default reduce using rule 47 (expressao) + 46 expressao: expressao MAIOR expressao_simples • + 49 expressao_simples: expressao_simples • MAIS termo + 50 | expressao_simples • MENOS termo + MAIS deslocar, e ir ao estado 76 + MENOS deslocar, e ir ao estado 77 -state 98 + $padrão reduzir usando a regra 46 (expressao) - 68 if_then: IF expressao @8 THEN . comando_sem_rotulo - T_BEGIN shift, and go to state 24 - IDENT shift, and go to state 29 - IF shift, and go to state 30 - READ shift, and go to state 32 - WRITE shift, and go to state 33 +Estado 99 - WHILE reduce using rule 61 (@6) - $default reduce using rule 35 (chamada_procedimento) + 67 if_then: IF expressao $@8 THEN • comando_sem_rotulo - comando_composto go to state 34 - comando_sem_rotulo go to state 109 - chamada_procedimento go to state 38 - leitura go to state 39 - escrita go to state 40 - atribuicao go to state 41 - comando_repetitivo go to state 43 - @6 go to state 44 - comando_condicional go to state 45 - if_then go to state 46 + T_BEGIN deslocar, e ir ao estado 26 + IDENT deslocar, e ir ao estado 31 + IF deslocar, e ir ao estado 32 + READ deslocar, e ir ao estado 34 + WRITE deslocar, e ir ao estado 35 + $padrão reduzir usando a regra 60 ($@6) -state 99 + comando_composto ir ao estado 36 + comando_sem_rotulo ir ao estado 110 + leitura ir ao estado 40 + escrita ir ao estado 41 + atribuicao ir ao estado 42 + comando_repetitivo ir ao estado 44 + $@6 ir ao estado 45 + comando_condicional ir ao estado 46 + if_then ir ao estado 47 - 50 expressao_simples: expressao_simples MAIS termo . - 53 termo: termo . ASTERISCO fator - 54 | termo . DIV fator - DIV shift, and go to state 77 - ASTERISCO shift, and go to state 78 +Estado 100 - $default reduce using rule 50 (expressao_simples) + 49 expressao_simples: expressao_simples MAIS termo • + 52 termo: termo • ASTERISCO fator + 53 | termo • DIV fator + DIV deslocar, e ir ao estado 78 + ASTERISCO deslocar, e ir ao estado 79 -state 100 + $padrão reduzir usando a regra 49 (expressao_simples) - 51 expressao_simples: expressao_simples MENOS termo . - 53 termo: termo . ASTERISCO fator - 54 | termo . DIV fator - DIV shift, and go to state 77 - ASTERISCO shift, and go to state 78 +Estado 101 - $default reduce using rule 51 (expressao_simples) + 50 expressao_simples: expressao_simples MENOS termo • + 52 termo: termo • ASTERISCO fator + 53 | termo • DIV fator + DIV deslocar, e ir ao estado 78 + ASTERISCO deslocar, e ir ao estado 79 -state 101 + $padrão reduzir usando a regra 50 (expressao_simples) - 54 termo: termo DIV fator . - $default reduce using rule 54 (termo) +Estado 102 + 53 termo: termo DIV fator • -state 102 + $padrão reduzir usando a regra 53 (termo) - 53 termo: termo ASTERISCO fator . - $default reduce using rule 53 (termo) +Estado 103 + 52 termo: termo ASTERISCO fator • -state 103 + $padrão reduzir usando a regra 52 (termo) - 36 leitura: READ ABRE_PARENTESES lista_leituras FECHA_PARENTESES . - $default reduce using rule 36 (leitura) +Estado 104 + 35 leitura: READ ABRE_PARENTESES lista_leituras FECHA_PARENTESES • -state 104 + $padrão reduzir usando a regra 35 (leitura) - 37 lista_leituras: lista_leituras VIRGULA . simb_leitura - IDENT shift, and go to state 79 +Estado 105 - simb_leitura go to state 110 + 36 lista_leituras: lista_leituras VIRGULA • simb_leitura + IDENT deslocar, e ir ao estado 80 -state 105 + simb_leitura ir ao estado 111 - 40 escrita: WRITE ABRE_PARENTESES lista_escritas FECHA_PARENTESES . - $default reduce using rule 40 (escrita) +Estado 106 + 39 escrita: WRITE ABRE_PARENTESES lista_escritas FECHA_PARENTESES • -state 106 + $padrão reduzir usando a regra 39 (escrita) - 41 lista_escritas: lista_escritas VIRGULA . expressao_simples - IDENT shift, and go to state 51 - NUMERO shift, and go to state 52 +Estado 107 - expressao_simples go to state 111 - termo go to state 55 - fator go to state 56 + 40 lista_escritas: lista_escritas VIRGULA • expressao_simples + IDENT deslocar, e ir ao estado 52 + NUMERO deslocar, e ir ao estado 53 -state 107 + expressao_simples ir ao estado 112 + termo ir ao estado 56 + fator ir ao estado 57 - 63 comando_repetitivo: @6 WHILE expressao DO . @7 comando_sem_rotulo - $default reduce using rule 62 (@7) +Estado 108 - @7 go to state 112 + 62 comando_repetitivo: $@6 WHILE expressao DO • $@7 comando_sem_rotulo + $padrão reduzir usando a regra 61 ($@7) -state 108 + $@7 ir ao estado 113 - 14 declara_var: @3 lista_id_var DOIS_PONTOS tipo @4 . PONTO_E_VIRGULA - PONTO_E_VIRGULA shift, and go to state 113 +Estado 109 + 14 declara_var: $@3 lista_id_var DOIS_PONTOS tipo $@4 • PONTO_E_VIRGULA -state 109 + PONTO_E_VIRGULA deslocar, e ir ao estado 114 - 68 if_then: IF expressao @8 THEN comando_sem_rotulo . - $default reduce using rule 68 (if_then) +Estado 110 + 67 if_then: IF expressao $@8 THEN comando_sem_rotulo • -state 110 + $padrão reduzir usando a regra 67 (if_then) - 37 lista_leituras: lista_leituras VIRGULA simb_leitura . - $default reduce using rule 37 (lista_leituras) +Estado 111 + 36 lista_leituras: lista_leituras VIRGULA simb_leitura • -state 111 + $padrão reduzir usando a regra 36 (lista_leituras) - 41 lista_escritas: lista_escritas VIRGULA expressao_simples . - 50 expressao_simples: expressao_simples . MAIS termo - 51 | expressao_simples . MENOS termo - MAIS shift, and go to state 75 - MENOS shift, and go to state 76 +Estado 112 - $default reduce using rule 41 (lista_escritas) + 40 lista_escritas: lista_escritas VIRGULA expressao_simples • + 49 expressao_simples: expressao_simples • MAIS termo + 50 | expressao_simples • MENOS termo + MAIS deslocar, e ir ao estado 76 + MENOS deslocar, e ir ao estado 77 -state 112 + $padrão reduzir usando a regra 40 (lista_escritas) - 63 comando_repetitivo: @6 WHILE expressao DO @7 . comando_sem_rotulo - T_BEGIN shift, and go to state 24 - IDENT shift, and go to state 29 - IF shift, and go to state 30 - READ shift, and go to state 32 - WRITE shift, and go to state 33 +Estado 113 - WHILE reduce using rule 61 (@6) - $default reduce using rule 35 (chamada_procedimento) + 62 comando_repetitivo: $@6 WHILE expressao DO $@7 • comando_sem_rotulo - comando_composto go to state 34 - comando_sem_rotulo go to state 114 - chamada_procedimento go to state 38 - leitura go to state 39 - escrita go to state 40 - atribuicao go to state 41 - comando_repetitivo go to state 43 - @6 go to state 44 - comando_condicional go to state 45 - if_then go to state 46 + T_BEGIN deslocar, e ir ao estado 26 + IDENT deslocar, e ir ao estado 31 + IF deslocar, e ir ao estado 32 + READ deslocar, e ir ao estado 34 + WRITE deslocar, e ir ao estado 35 + $padrão reduzir usando a regra 60 ($@6) -state 113 + comando_composto ir ao estado 36 + comando_sem_rotulo ir ao estado 115 + leitura ir ao estado 40 + escrita ir ao estado 41 + atribuicao ir ao estado 42 + comando_repetitivo ir ao estado 44 + $@6 ir ao estado 45 + comando_condicional ir ao estado 46 + if_then ir ao estado 47 - 14 declara_var: @3 lista_id_var DOIS_PONTOS tipo @4 PONTO_E_VIRGULA . - $default reduce using rule 14 (declara_var) +Estado 114 + 14 declara_var: $@3 lista_id_var DOIS_PONTOS tipo $@4 PONTO_E_VIRGULA • -state 114 + $padrão reduzir usando a regra 14 (declara_var) - 63 comando_repetitivo: @6 WHILE expressao DO @7 comando_sem_rotulo . - $default reduce using rule 63 (comando_repetitivo) +Estado 115 + + 62 comando_repetitivo: $@6 WHILE expressao DO $@7 comando_sem_rotulo • + + $padrão reduzir usando a regra 62 (comando_repetitivo) diff --git a/compilador.tab.c b/compilador.tab.c new file mode 100644 index 0000000000000000000000000000000000000000..7aa196fadfd7032162ab9d1495d75b42e96a7024 --- /dev/null +++ b/compilador.tab.c @@ -0,0 +1,1814 @@ +/* A Bison parser, made by GNU Bison 3.8.2. */ + +/* Bison implementation for Yacc-like parsers in C + + Copyright (C) 1984, 1989-1990, 2000-2015, 2018-2021 Free Software Foundation, + Inc. + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see <https://www.gnu.org/licenses/>. */ + +/* As a special exception, you may create a larger work that contains + part or all of the Bison parser skeleton and distribute that work + under terms of your choice, so long as that work isn't itself a + parser generator using the skeleton or a modified version thereof + as a parser skeleton. Alternatively, if you modify or redistribute + the parser skeleton itself, you may (at your option) remove this + special exception, which will cause the skeleton and the resulting + Bison output files to be licensed under the GNU General Public + License without this special exception. + + This special exception was added by the Free Software Foundation in + version 2.2 of Bison. */ + +/* C LALR(1) parser skeleton written by Richard Stallman, by + simplifying the original so-called "semantic" parser. */ + +/* DO NOT RELY ON FEATURES THAT ARE NOT DOCUMENTED in the manual, + especially those whose name start with YY_ or yy_. They are + private implementation details that can be changed or removed. */ + +/* All symbols defined below should begin with yy or YY, to avoid + infringing on user name space. This should be done even for local + variables, as they might otherwise be expanded by user macros. + There are some unavoidable exceptions within include files to + define necessary library symbols; they are noted "INFRINGES ON + USER NAME SPACE" below. */ + +/* Identify Bison output, and Bison version. */ +#define YYBISON 30802 + +/* Bison version string. */ +#define YYBISON_VERSION "3.8.2" + +/* Skeleton name. */ +#define YYSKELETON_NAME "yacc.c" + +/* Pure parsers. */ +#define YYPURE 0 + +/* Push parsers. */ +#define YYPUSH 0 + +/* Pull parsers. */ +#define YYPULL 1 + + + + +/* First part of user prologue. */ +#line 6 "compilador.y" + +#include <stdio.h> +#include <ctype.h> +#include <stdlib.h> +#include <string.h> +#include "compilador.h" +#include "ts/ts.h" +#include "stack/stack.h" + +int num_vars; +ts_t *ts; +int nivel_lexico; +int desloc; +int destino_nivel; +int destino_desloc; +simb_t *l_elem; +int rot_id; +stack_t_custom *rot; + + +#line 92 "compilador.tab.c" + +# ifndef YY_CAST +# ifdef __cplusplus +# define YY_CAST(Type, Val) static_cast<Type> (Val) +# define YY_REINTERPRET_CAST(Type, Val) reinterpret_cast<Type> (Val) +# else +# define YY_CAST(Type, Val) ((Type) (Val)) +# define YY_REINTERPRET_CAST(Type, Val) ((Type) (Val)) +# endif +# endif +# ifndef YY_NULLPTR +# if defined __cplusplus +# if 201103L <= __cplusplus +# define YY_NULLPTR nullptr +# else +# define YY_NULLPTR 0 +# endif +# else +# define YY_NULLPTR ((void*)0) +# endif +# endif + +#include "compilador.tab.h" +/* Symbol kind. */ +enum yysymbol_kind_t +{ + YYSYMBOL_YYEMPTY = -2, + YYSYMBOL_YYEOF = 0, /* "end of file" */ + YYSYMBOL_YYerror = 1, /* error */ + YYSYMBOL_YYUNDEF = 2, /* "invalid token" */ + YYSYMBOL_PROGRAM = 3, /* PROGRAM */ + YYSYMBOL_ABRE_PARENTESES = 4, /* ABRE_PARENTESES */ + YYSYMBOL_FECHA_PARENTESES = 5, /* FECHA_PARENTESES */ + YYSYMBOL_VIRGULA = 6, /* VIRGULA */ + YYSYMBOL_PONTO_E_VIRGULA = 7, /* PONTO_E_VIRGULA */ + YYSYMBOL_DOIS_PONTOS = 8, /* DOIS_PONTOS */ + YYSYMBOL_PONTO = 9, /* PONTO */ + YYSYMBOL_T_BEGIN = 10, /* T_BEGIN */ + YYSYMBOL_T_END = 11, /* T_END */ + YYSYMBOL_VAR = 12, /* VAR */ + YYSYMBOL_IDENT = 13, /* IDENT */ + YYSYMBOL_ATRIBUICAO = 14, /* ATRIBUICAO */ + YYSYMBOL_LABEL = 15, /* LABEL */ + YYSYMBOL_TYPE = 16, /* TYPE */ + YYSYMBOL_ARRAY = 17, /* ARRAY */ + YYSYMBOL_PROCEDURE = 18, /* PROCEDURE */ + YYSYMBOL_FUNCTION = 19, /* FUNCTION */ + YYSYMBOL_GOTO = 20, /* GOTO */ + YYSYMBOL_IF = 21, /* IF */ + YYSYMBOL_THEN = 22, /* THEN */ + YYSYMBOL_ELSE = 23, /* ELSE */ + YYSYMBOL_WHILE = 24, /* WHILE */ + YYSYMBOL_DO = 25, /* DO */ + YYSYMBOL_OR = 26, /* OR */ + YYSYMBOL_DIV = 27, /* DIV */ + YYSYMBOL_AND = 28, /* AND */ + YYSYMBOL_NOT = 29, /* NOT */ + YYSYMBOL_IGUAL = 30, /* IGUAL */ + YYSYMBOL_DIFERENTE = 31, /* DIFERENTE */ + YYSYMBOL_MENOR_IGUAL = 32, /* MENOR_IGUAL */ + YYSYMBOL_MAIOR_IGUAL = 33, /* MAIOR_IGUAL */ + YYSYMBOL_MENOR = 34, /* MENOR */ + YYSYMBOL_MAIOR = 35, /* MAIOR */ + YYSYMBOL_MAIS = 36, /* MAIS */ + YYSYMBOL_MENOS = 37, /* MENOS */ + YYSYMBOL_ASTERISCO = 38, /* ASTERISCO */ + YYSYMBOL_NUMERO = 39, /* NUMERO */ + YYSYMBOL_READ = 40, /* READ */ + YYSYMBOL_WRITE = 41, /* WRITE */ + YYSYMBOL_LOWER_THAN_ELSE = 42, /* LOWER_THAN_ELSE */ + YYSYMBOL_YYACCEPT = 43, /* $accept */ + YYSYMBOL_programa = 44, /* programa */ + YYSYMBOL_45_1 = 45, /* $@1 */ + YYSYMBOL_bloco = 46, /* bloco */ + YYSYMBOL_parte_declara_rotulos = 47, /* parte_declara_rotulos */ + YYSYMBOL_parte_declara_vars = 48, /* parte_declara_vars */ + YYSYMBOL_var = 49, /* var */ + YYSYMBOL_50_2 = 50, /* $@2 */ + YYSYMBOL_declara_vars = 51, /* declara_vars */ + YYSYMBOL_declara_var = 52, /* declara_var */ + YYSYMBOL_53_3 = 53, /* $@3 */ + YYSYMBOL_54_4 = 54, /* $@4 */ + YYSYMBOL_tipo = 55, /* tipo */ + YYSYMBOL_lista_id_var = 56, /* lista_id_var */ + YYSYMBOL_lista_idents = 57, /* lista_idents */ + YYSYMBOL_parte_declara_subrotinas = 58, /* parte_declara_subrotinas */ + YYSYMBOL_declaracao_procedimento = 59, /* declaracao_procedimento */ + YYSYMBOL_comando_composto = 60, /* comando_composto */ + YYSYMBOL_comandos = 61, /* comandos */ + YYSYMBOL_comando = 62, /* comando */ + YYSYMBOL_comando_sem_rotulo = 63, /* comando_sem_rotulo */ + YYSYMBOL_leitura = 64, /* leitura */ + YYSYMBOL_lista_leituras = 65, /* lista_leituras */ + YYSYMBOL_simb_leitura = 66, /* simb_leitura */ + YYSYMBOL_escrita = 67, /* escrita */ + YYSYMBOL_lista_escritas = 68, /* lista_escritas */ + YYSYMBOL_expressao = 69, /* expressao */ + YYSYMBOL_expressao_simples = 70, /* expressao_simples */ + YYSYMBOL_termo = 71, /* termo */ + YYSYMBOL_atribuicao = 72, /* atribuicao */ + YYSYMBOL_73_5 = 73, /* $@5 */ + YYSYMBOL_fator = 74, /* fator */ + YYSYMBOL_numero = 75, /* numero */ + YYSYMBOL_comando_repetitivo = 76, /* comando_repetitivo */ + YYSYMBOL_77_6 = 77, /* $@6 */ + YYSYMBOL_78_7 = 78, /* $@7 */ + YYSYMBOL_comando_condicional = 79, /* comando_condicional */ + YYSYMBOL_cond_else = 80, /* cond_else */ + YYSYMBOL_if_then = 81, /* if_then */ + YYSYMBOL_82_8 = 82 /* $@8 */ +}; +typedef enum yysymbol_kind_t yysymbol_kind_t; + + + + +#ifdef short +# undef short +#endif + +/* On compilers that do not define __PTRDIFF_MAX__ etc., make sure + <limits.h> and (if available) <stdint.h> are included + so that the code can choose integer types of a good width. */ + +#ifndef __PTRDIFF_MAX__ +# include <limits.h> /* INFRINGES ON USER NAME SPACE */ +# if defined __STDC_VERSION__ && 199901 <= __STDC_VERSION__ +# include <stdint.h> /* INFRINGES ON USER NAME SPACE */ +# define YY_STDINT_H +# endif +#endif + +/* Narrow types that promote to a signed type and that can represent a + signed or unsigned integer of at least N bits. In tables they can + save space and decrease cache pressure. Promoting to a signed type + helps avoid bugs in integer arithmetic. */ + +#ifdef __INT_LEAST8_MAX__ +typedef __INT_LEAST8_TYPE__ yytype_int8; +#elif defined YY_STDINT_H +typedef int_least8_t yytype_int8; +#else +typedef signed char yytype_int8; +#endif + +#ifdef __INT_LEAST16_MAX__ +typedef __INT_LEAST16_TYPE__ yytype_int16; +#elif defined YY_STDINT_H +typedef int_least16_t yytype_int16; +#else +typedef short yytype_int16; +#endif + +/* Work around bug in HP-UX 11.23, which defines these macros + incorrectly for preprocessor constants. This workaround can likely + be removed in 2023, as HPE has promised support for HP-UX 11.23 + (aka HP-UX 11i v2) only through the end of 2022; see Table 2 of + <https://h20195.www2.hpe.com/V2/getpdf.aspx/4AA4-7673ENW.pdf>. */ +#ifdef __hpux +# undef UINT_LEAST8_MAX +# undef UINT_LEAST16_MAX +# define UINT_LEAST8_MAX 255 +# define UINT_LEAST16_MAX 65535 +#endif + +#if defined __UINT_LEAST8_MAX__ && __UINT_LEAST8_MAX__ <= __INT_MAX__ +typedef __UINT_LEAST8_TYPE__ yytype_uint8; +#elif (!defined __UINT_LEAST8_MAX__ && defined YY_STDINT_H \ + && UINT_LEAST8_MAX <= INT_MAX) +typedef uint_least8_t yytype_uint8; +#elif !defined __UINT_LEAST8_MAX__ && UCHAR_MAX <= INT_MAX +typedef unsigned char yytype_uint8; +#else +typedef short yytype_uint8; +#endif + +#if defined __UINT_LEAST16_MAX__ && __UINT_LEAST16_MAX__ <= __INT_MAX__ +typedef __UINT_LEAST16_TYPE__ yytype_uint16; +#elif (!defined __UINT_LEAST16_MAX__ && defined YY_STDINT_H \ + && UINT_LEAST16_MAX <= INT_MAX) +typedef uint_least16_t yytype_uint16; +#elif !defined __UINT_LEAST16_MAX__ && USHRT_MAX <= INT_MAX +typedef unsigned short yytype_uint16; +#else +typedef int yytype_uint16; +#endif + +#ifndef YYPTRDIFF_T +# if defined __PTRDIFF_TYPE__ && defined __PTRDIFF_MAX__ +# define YYPTRDIFF_T __PTRDIFF_TYPE__ +# define YYPTRDIFF_MAXIMUM __PTRDIFF_MAX__ +# elif defined PTRDIFF_MAX +# ifndef ptrdiff_t +# include <stddef.h> /* INFRINGES ON USER NAME SPACE */ +# endif +# define YYPTRDIFF_T ptrdiff_t +# define YYPTRDIFF_MAXIMUM PTRDIFF_MAX +# else +# define YYPTRDIFF_T long +# define YYPTRDIFF_MAXIMUM LONG_MAX +# endif +#endif + +#ifndef YYSIZE_T +# ifdef __SIZE_TYPE__ +# define YYSIZE_T __SIZE_TYPE__ +# elif defined size_t +# define YYSIZE_T size_t +# elif defined __STDC_VERSION__ && 199901 <= __STDC_VERSION__ +# include <stddef.h> /* INFRINGES ON USER NAME SPACE */ +# define YYSIZE_T size_t +# else +# define YYSIZE_T unsigned +# endif +#endif + +#define YYSIZE_MAXIMUM \ + YY_CAST (YYPTRDIFF_T, \ + (YYPTRDIFF_MAXIMUM < YY_CAST (YYSIZE_T, -1) \ + ? YYPTRDIFF_MAXIMUM \ + : YY_CAST (YYSIZE_T, -1))) + +#define YYSIZEOF(X) YY_CAST (YYPTRDIFF_T, sizeof (X)) + + +/* Stored state numbers (used for stacks). */ +typedef yytype_int8 yy_state_t; + +/* State numbers in computations. */ +typedef int yy_state_fast_t; + +#ifndef YY_ +# if defined YYENABLE_NLS && YYENABLE_NLS +# if ENABLE_NLS +# include <libintl.h> /* INFRINGES ON USER NAME SPACE */ +# define YY_(Msgid) dgettext ("bison-runtime", Msgid) +# endif +# endif +# ifndef YY_ +# define YY_(Msgid) Msgid +# endif +#endif + + +#ifndef YY_ATTRIBUTE_PURE +# if defined __GNUC__ && 2 < __GNUC__ + (96 <= __GNUC_MINOR__) +# define YY_ATTRIBUTE_PURE __attribute__ ((__pure__)) +# else +# define YY_ATTRIBUTE_PURE +# endif +#endif + +#ifndef YY_ATTRIBUTE_UNUSED +# if defined __GNUC__ && 2 < __GNUC__ + (7 <= __GNUC_MINOR__) +# define YY_ATTRIBUTE_UNUSED __attribute__ ((__unused__)) +# else +# define YY_ATTRIBUTE_UNUSED +# endif +#endif + +/* Suppress unused-variable warnings by "using" E. */ +#if ! defined lint || defined __GNUC__ +# define YY_USE(E) ((void) (E)) +#else +# define YY_USE(E) /* empty */ +#endif + +/* Suppress an incorrect diagnostic about yylval being uninitialized. */ +#if defined __GNUC__ && ! defined __ICC && 406 <= __GNUC__ * 100 + __GNUC_MINOR__ +# if __GNUC__ * 100 + __GNUC_MINOR__ < 407 +# define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN \ + _Pragma ("GCC diagnostic push") \ + _Pragma ("GCC diagnostic ignored \"-Wuninitialized\"") +# else +# define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN \ + _Pragma ("GCC diagnostic push") \ + _Pragma ("GCC diagnostic ignored \"-Wuninitialized\"") \ + _Pragma ("GCC diagnostic ignored \"-Wmaybe-uninitialized\"") +# endif +# define YY_IGNORE_MAYBE_UNINITIALIZED_END \ + _Pragma ("GCC diagnostic pop") +#else +# define YY_INITIAL_VALUE(Value) Value +#endif +#ifndef YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN +# define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN +# define YY_IGNORE_MAYBE_UNINITIALIZED_END +#endif +#ifndef YY_INITIAL_VALUE +# define YY_INITIAL_VALUE(Value) /* Nothing. */ +#endif + +#if defined __cplusplus && defined __GNUC__ && ! defined __ICC && 6 <= __GNUC__ +# define YY_IGNORE_USELESS_CAST_BEGIN \ + _Pragma ("GCC diagnostic push") \ + _Pragma ("GCC diagnostic ignored \"-Wuseless-cast\"") +# define YY_IGNORE_USELESS_CAST_END \ + _Pragma ("GCC diagnostic pop") +#endif +#ifndef YY_IGNORE_USELESS_CAST_BEGIN +# define YY_IGNORE_USELESS_CAST_BEGIN +# define YY_IGNORE_USELESS_CAST_END +#endif + + +#define YY_ASSERT(E) ((void) (0 && (E))) + +#if !defined yyoverflow + +/* The parser invokes alloca or malloc; define the necessary symbols. */ + +# ifdef YYSTACK_USE_ALLOCA +# if YYSTACK_USE_ALLOCA +# ifdef __GNUC__ +# define YYSTACK_ALLOC __builtin_alloca +# elif defined __BUILTIN_VA_ARG_INCR +# include <alloca.h> /* INFRINGES ON USER NAME SPACE */ +# elif defined _AIX +# define YYSTACK_ALLOC __alloca +# elif defined _MSC_VER +# include <malloc.h> /* INFRINGES ON USER NAME SPACE */ +# define alloca _alloca +# else +# define YYSTACK_ALLOC alloca +# if ! defined _ALLOCA_H && ! defined EXIT_SUCCESS +# include <stdlib.h> /* INFRINGES ON USER NAME SPACE */ + /* Use EXIT_SUCCESS as a witness for stdlib.h. */ +# ifndef EXIT_SUCCESS +# define EXIT_SUCCESS 0 +# endif +# endif +# endif +# endif +# endif + +# ifdef YYSTACK_ALLOC + /* Pacify GCC's 'empty if-body' warning. */ +# define YYSTACK_FREE(Ptr) do { /* empty */; } while (0) +# ifndef YYSTACK_ALLOC_MAXIMUM + /* The OS might guarantee only one guard page at the bottom of the stack, + and a page size can be as small as 4096 bytes. So we cannot safely + invoke alloca (N) if N exceeds 4096. Use a slightly smaller number + to allow for a few compiler-allocated temporary stack slots. */ +# define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2006 */ +# endif +# else +# define YYSTACK_ALLOC YYMALLOC +# define YYSTACK_FREE YYFREE +# ifndef YYSTACK_ALLOC_MAXIMUM +# define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM +# endif +# if (defined __cplusplus && ! defined EXIT_SUCCESS \ + && ! ((defined YYMALLOC || defined malloc) \ + && (defined YYFREE || defined free))) +# include <stdlib.h> /* INFRINGES ON USER NAME SPACE */ +# ifndef EXIT_SUCCESS +# define EXIT_SUCCESS 0 +# endif +# endif +# ifndef YYMALLOC +# define YYMALLOC malloc +# if ! defined malloc && ! defined EXIT_SUCCESS +void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */ +# endif +# endif +# ifndef YYFREE +# define YYFREE free +# if ! defined free && ! defined EXIT_SUCCESS +void free (void *); /* INFRINGES ON USER NAME SPACE */ +# endif +# endif +# endif +#endif /* !defined yyoverflow */ + +#if (! defined yyoverflow \ + && (! defined __cplusplus \ + || (defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL))) + +/* A type that is properly aligned for any stack member. */ +union yyalloc +{ + yy_state_t yyss_alloc; + YYSTYPE yyvs_alloc; +}; + +/* The size of the maximum gap between one aligned stack and the next. */ +# define YYSTACK_GAP_MAXIMUM (YYSIZEOF (union yyalloc) - 1) + +/* The size of an array large to enough to hold all stacks, each with + N elements. */ +# define YYSTACK_BYTES(N) \ + ((N) * (YYSIZEOF (yy_state_t) + YYSIZEOF (YYSTYPE)) \ + + YYSTACK_GAP_MAXIMUM) + +# define YYCOPY_NEEDED 1 + +/* Relocate STACK from its old location to the new one. The + local variables YYSIZE and YYSTACKSIZE give the old and new number of + elements in the stack, and YYPTR gives the new location of the + stack. Advance YYPTR to a properly aligned location for the next + stack. */ +# define YYSTACK_RELOCATE(Stack_alloc, Stack) \ + do \ + { \ + YYPTRDIFF_T yynewbytes; \ + YYCOPY (&yyptr->Stack_alloc, Stack, yysize); \ + Stack = &yyptr->Stack_alloc; \ + yynewbytes = yystacksize * YYSIZEOF (*Stack) + YYSTACK_GAP_MAXIMUM; \ + yyptr += yynewbytes / YYSIZEOF (*yyptr); \ + } \ + while (0) + +#endif + +#if defined YYCOPY_NEEDED && YYCOPY_NEEDED +/* Copy COUNT objects from SRC to DST. The source and destination do + not overlap. */ +# ifndef YYCOPY +# if defined __GNUC__ && 1 < __GNUC__ +# define YYCOPY(Dst, Src, Count) \ + __builtin_memcpy (Dst, Src, YY_CAST (YYSIZE_T, (Count)) * sizeof (*(Src))) +# else +# define YYCOPY(Dst, Src, Count) \ + do \ + { \ + YYPTRDIFF_T yyi; \ + for (yyi = 0; yyi < (Count); yyi++) \ + (Dst)[yyi] = (Src)[yyi]; \ + } \ + while (0) +# endif +# endif +#endif /* !YYCOPY_NEEDED */ + +/* YYFINAL -- State number of the termination state. */ +#define YYFINAL 3 +/* YYLAST -- Last index in YYTABLE. */ +#define YYLAST 97 + +/* YYNTOKENS -- Number of terminals. */ +#define YYNTOKENS 43 +/* YYNNTS -- Number of nonterminals. */ +#define YYNNTS 40 +/* YYNRULES -- Number of rules. */ +#define YYNRULES 68 +/* YYNSTATES -- Number of states. */ +#define YYNSTATES 116 + +/* YYMAXUTOK -- Last valid token kind. */ +#define YYMAXUTOK 297 + + +/* YYTRANSLATE(TOKEN-NUM) -- Symbol number corresponding to TOKEN-NUM + as returned by yylex, with out-of-bounds checking. */ +#define YYTRANSLATE(YYX) \ + (0 <= (YYX) && (YYX) <= YYMAXUTOK \ + ? YY_CAST (yysymbol_kind_t, yytranslate[YYX]) \ + : YYSYMBOL_YYUNDEF) + +/* YYTRANSLATE[TOKEN-NUM] -- Symbol number corresponding to TOKEN-NUM + as returned by yylex. */ +static const yytype_int8 yytranslate[] = +{ + 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 1, 2, 3, 4, + 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, + 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, + 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, + 35, 36, 37, 38, 39, 40, 41, 42 +}; + +#if YYDEBUG +/* YYRLINE[YYN] -- Source line where rule number YYN was defined. */ +static const yytype_int16 yyrline[] = +{ + 0, 42, 42, 42, 55, 69, 70, 73, 77, 77, + 78, 81, 82, 85, 88, 85, 96, 109, 118, 129, + 130, 134, 138, 139, 143, 146, 147, 148, 151, 152, + 155, 156, 157, 158, 159, 160, 166, 169, 170, 173, + 182, 185, 188, 193, 196, 199, 202, 205, 208, 211, + 214, 217, 220, 223, 226, 229, 232, 232, 249, 260, + 267, 269, 276, 269, 302, 309, 311, 314, 314 +}; +#endif + +/** Accessing symbol of state STATE. */ +#define YY_ACCESSING_SYMBOL(State) YY_CAST (yysymbol_kind_t, yystos[State]) + +#if YYDEBUG || 0 +/* The user-facing name of the symbol whose (internal) number is + YYSYMBOL. No bounds checking. */ +static const char *yysymbol_name (yysymbol_kind_t yysymbol) YY_ATTRIBUTE_UNUSED; + +/* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM. + First, the terminals, then, starting at YYNTOKENS, nonterminals. */ +static const char *const yytname[] = +{ + "\"end of file\"", "error", "\"invalid token\"", "PROGRAM", + "ABRE_PARENTESES", "FECHA_PARENTESES", "VIRGULA", "PONTO_E_VIRGULA", + "DOIS_PONTOS", "PONTO", "T_BEGIN", "T_END", "VAR", "IDENT", "ATRIBUICAO", + "LABEL", "TYPE", "ARRAY", "PROCEDURE", "FUNCTION", "GOTO", "IF", "THEN", + "ELSE", "WHILE", "DO", "OR", "DIV", "AND", "NOT", "IGUAL", "DIFERENTE", + "MENOR_IGUAL", "MAIOR_IGUAL", "MENOR", "MAIOR", "MAIS", "MENOS", + "ASTERISCO", "NUMERO", "READ", "WRITE", "LOWER_THAN_ELSE", "$accept", + "programa", "$@1", "bloco", "parte_declara_rotulos", + "parte_declara_vars", "var", "$@2", "declara_vars", "declara_var", "$@3", + "$@4", "tipo", "lista_id_var", "lista_idents", + "parte_declara_subrotinas", "declaracao_procedimento", + "comando_composto", "comandos", "comando", "comando_sem_rotulo", + "leitura", "lista_leituras", "simb_leitura", "escrita", "lista_escritas", + "expressao", "expressao_simples", "termo", "atribuicao", "$@5", "fator", + "numero", "comando_repetitivo", "$@6", "$@7", "comando_condicional", + "cond_else", "if_then", "$@8", YY_NULLPTR +}; + +static const char * +yysymbol_name (yysymbol_kind_t yysymbol) +{ + return yytname[yysymbol]; +} +#endif + +#define YYPACT_NINF (-63) + +#define yypact_value_is_default(Yyn) \ + ((Yyn) == YYPACT_NINF) + +#define YYTABLE_NINF (-62) + +#define yytable_value_is_error(Yyn) \ + 0 + +/* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing + STATE-NUM. */ +static const yytype_int8 yypact[] = +{ + -63, 5, 16, -63, 8, 26, 19, -63, 3, 31, + 32, 35, -63, 56, 57, 53, -63, -63, 49, -63, + 58, 55, 59, -63, -63, -63, 7, -63, 60, -63, + 61, -63, -10, -63, 67, 68, -63, 64, 69, -63, + -63, -63, -63, 70, -63, 62, -63, 54, -63, -63, + -2, 65, -63, -63, 24, -13, -20, -63, 71, -10, + -63, 7, 12, -10, 12, -63, 72, 74, -10, -10, + -10, -10, -10, -10, -10, 66, -10, -10, -10, -10, + -63, 21, -63, 30, -13, -63, -63, 9, -63, -63, + -63, -63, -13, -13, -13, -13, -13, -13, -13, 12, + -20, -20, -63, -63, -63, 71, -63, -10, -63, 73, + -63, -63, -13, 12, -63, -63 +}; + +/* YYDEFACT[STATE-NUM] -- Default reduction number in state STATE-NUM. + Performed when YYTABLE does not specify something else to do. Zero + means the default is an error. */ +static const yytype_int8 yydefact[] = +{ + 2, 0, 0, 1, 0, 0, 0, 20, 0, 0, + 0, 6, 19, 0, 0, 10, 5, 3, 23, 7, + 0, 0, 0, 21, 13, 22, 27, 4, 9, 12, + 0, 56, 0, 60, 0, 0, 31, 0, 0, 29, + 34, 35, 30, 0, 33, 0, 32, 66, 11, 18, + 0, 0, 58, 59, 67, 49, 52, 55, 0, 0, + 24, 26, 61, 0, 61, 64, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 39, 0, 38, 0, 42, 25, 28, 0, 65, 17, + 16, 14, 57, 43, 44, 46, 48, 45, 47, 61, + 50, 51, 54, 53, 36, 0, 40, 0, 62, 0, + 68, 37, 41, 61, 15, 63 +}; + +/* YYPGOTO[NTERM-NUM]. */ +static const yytype_int8 yypgoto[] = +{ + -63, -63, -63, -63, -63, -63, -63, -63, -63, 63, + -63, -63, -63, -63, -63, -63, -63, 75, 20, -63, + -62, -63, -63, -23, -63, -63, 27, -58, -16, -63, + -63, -15, -63, -63, -63, -63, -63, -63, -63, -63 +}; + +/* YYDEFGOTO[NTERM-NUM]. */ +static const yytype_int8 yydefgoto[] = +{ + 0, 1, 2, 14, 15, 18, 19, 20, 28, 29, + 30, 109, 91, 50, 8, 22, 23, 36, 37, 38, + 39, 40, 81, 82, 41, 83, 54, 55, 56, 42, + 51, 57, 43, 44, 45, 113, 46, 65, 47, 75 +}; + +/* YYTABLE[YYPACT[STATE-NUM]] -- What to do in state STATE-NUM. If + positive, shift that token. If negative, reduce the rule whose + number is the opposite. If YYTABLE_NINF, syntax error. */ +static const yytype_int8 yytable[] = +{ + 86, 84, 88, 52, 66, 3, 67, 78, 9, 10, + 92, 93, 94, 95, 96, 97, 98, 26, 79, 4, + 31, 5, 26, 76, 77, 31, 104, 105, 32, 53, + 6, -61, 7, 32, 108, 106, 107, 110, 11, 69, + 70, 71, 72, 73, 74, 12, 33, 34, 35, 112, + 13, 115, 34, 35, 69, 70, 71, 72, 73, 74, + 100, 101, 16, 102, 103, -8, 17, 21, 25, 26, + 24, 58, 59, -13, 49, 60, 61, 64, 62, 68, + 114, 85, 111, 0, 80, 89, 63, 90, 99, 0, + 87, 48, 0, 0, 0, 0, 0, 27 +}; + +static const yytype_int8 yycheck[] = +{ + 62, 59, 64, 13, 6, 0, 8, 27, 5, 6, + 68, 69, 70, 71, 72, 73, 74, 10, 38, 3, + 13, 13, 10, 36, 37, 13, 5, 6, 21, 39, + 4, 24, 13, 21, 25, 5, 6, 99, 7, 30, + 31, 32, 33, 34, 35, 13, 39, 40, 41, 107, + 15, 113, 40, 41, 30, 31, 32, 33, 34, 35, + 76, 77, 6, 78, 79, 12, 9, 18, 13, 10, + 12, 4, 4, 13, 13, 11, 7, 23, 8, 14, + 7, 61, 105, -1, 13, 13, 24, 13, 22, -1, + 63, 28, -1, -1, -1, -1, -1, 22 +}; + +/* YYSTOS[STATE-NUM] -- The symbol kind of the accessing symbol of + state STATE-NUM. */ +static const yytype_int8 yystos[] = +{ + 0, 44, 45, 0, 3, 13, 4, 13, 57, 5, + 6, 7, 13, 15, 46, 47, 6, 9, 48, 49, + 50, 18, 58, 59, 12, 13, 10, 60, 51, 52, + 53, 13, 21, 39, 40, 41, 60, 61, 62, 63, + 64, 67, 72, 75, 76, 77, 79, 81, 52, 13, + 56, 73, 13, 39, 69, 70, 71, 74, 4, 4, + 11, 7, 8, 24, 23, 80, 6, 8, 14, 30, + 31, 32, 33, 34, 35, 82, 36, 37, 27, 38, + 13, 65, 66, 68, 70, 61, 63, 69, 63, 13, + 13, 55, 70, 70, 70, 70, 70, 70, 70, 22, + 71, 71, 74, 74, 5, 6, 5, 6, 25, 54, + 63, 66, 70, 78, 7, 63 +}; + +/* YYR1[RULE-NUM] -- Symbol kind of the left-hand side of rule RULE-NUM. */ +static const yytype_int8 yyr1[] = +{ + 0, 43, 45, 44, 46, 47, 47, 48, 50, 49, + 49, 51, 51, 53, 54, 52, 55, 56, 56, 57, + 57, 58, 59, 59, 60, 61, 61, 61, 62, 62, + 63, 63, 63, 63, 63, 63, 64, 65, 65, 66, + 67, 68, 68, 69, 69, 69, 69, 69, 69, 69, + 70, 70, 70, 71, 71, 71, 73, 72, 74, 74, + 75, 77, 78, 76, 79, 80, 80, 82, 81 +}; + +/* YYR2[RULE-NUM] -- Number of symbols on the right-hand side of rule RULE-NUM. */ +static const yytype_int8 yyr2[] = +{ + 0, 2, 0, 9, 4, 2, 0, 1, 0, 3, + 0, 2, 1, 0, 0, 6, 1, 3, 1, 3, + 1, 1, 2, 0, 3, 3, 2, 0, 3, 1, + 1, 1, 1, 1, 1, 1, 4, 3, 1, 1, + 4, 3, 1, 3, 3, 3, 3, 3, 3, 1, + 3, 3, 1, 3, 3, 1, 0, 4, 1, 1, + 1, 0, 0, 6, 2, 2, 0, 0, 5 +}; + + +enum { YYENOMEM = -2 }; + +#define yyerrok (yyerrstatus = 0) +#define yyclearin (yychar = YYEMPTY) + +#define YYACCEPT goto yyacceptlab +#define YYABORT goto yyabortlab +#define YYERROR goto yyerrorlab +#define YYNOMEM goto yyexhaustedlab + + +#define YYRECOVERING() (!!yyerrstatus) + +#define YYBACKUP(Token, Value) \ + do \ + if (yychar == YYEMPTY) \ + { \ + yychar = (Token); \ + yylval = (Value); \ + YYPOPSTACK (yylen); \ + yystate = *yyssp; \ + goto yybackup; \ + } \ + else \ + { \ + yyerror (YY_("syntax error: cannot back up")); \ + YYERROR; \ + } \ + while (0) + +/* Backward compatibility with an undocumented macro. + Use YYerror or YYUNDEF. */ +#define YYERRCODE YYUNDEF + + +/* Enable debugging if requested. */ +#if YYDEBUG + +# ifndef YYFPRINTF +# include <stdio.h> /* INFRINGES ON USER NAME SPACE */ +# define YYFPRINTF fprintf +# endif + +# define YYDPRINTF(Args) \ +do { \ + if (yydebug) \ + YYFPRINTF Args; \ +} while (0) + + + + +# define YY_SYMBOL_PRINT(Title, Kind, Value, Location) \ +do { \ + if (yydebug) \ + { \ + YYFPRINTF (stderr, "%s ", Title); \ + yy_symbol_print (stderr, \ + Kind, Value); \ + YYFPRINTF (stderr, "\n"); \ + } \ +} while (0) + + +/*-----------------------------------. +| Print this symbol's value on YYO. | +`-----------------------------------*/ + +static void +yy_symbol_value_print (FILE *yyo, + yysymbol_kind_t yykind, YYSTYPE const * const yyvaluep) +{ + FILE *yyoutput = yyo; + YY_USE (yyoutput); + if (!yyvaluep) + return; + YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN + YY_USE (yykind); + YY_IGNORE_MAYBE_UNINITIALIZED_END +} + + +/*---------------------------. +| Print this symbol on YYO. | +`---------------------------*/ + +static void +yy_symbol_print (FILE *yyo, + yysymbol_kind_t yykind, YYSTYPE const * const yyvaluep) +{ + YYFPRINTF (yyo, "%s %s (", + yykind < YYNTOKENS ? "token" : "nterm", yysymbol_name (yykind)); + + yy_symbol_value_print (yyo, yykind, yyvaluep); + YYFPRINTF (yyo, ")"); +} + +/*------------------------------------------------------------------. +| yy_stack_print -- Print the state stack from its BOTTOM up to its | +| TOP (included). | +`------------------------------------------------------------------*/ + +static void +yy_stack_print (yy_state_t *yybottom, yy_state_t *yytop) +{ + YYFPRINTF (stderr, "Stack now"); + for (; yybottom <= yytop; yybottom++) + { + int yybot = *yybottom; + YYFPRINTF (stderr, " %d", yybot); + } + YYFPRINTF (stderr, "\n"); +} + +# define YY_STACK_PRINT(Bottom, Top) \ +do { \ + if (yydebug) \ + yy_stack_print ((Bottom), (Top)); \ +} while (0) + + +/*------------------------------------------------. +| Report that the YYRULE is going to be reduced. | +`------------------------------------------------*/ + +static void +yy_reduce_print (yy_state_t *yyssp, YYSTYPE *yyvsp, + int yyrule) +{ + int yylno = yyrline[yyrule]; + int yynrhs = yyr2[yyrule]; + int yyi; + YYFPRINTF (stderr, "Reducing stack by rule %d (line %d):\n", + yyrule - 1, yylno); + /* The symbols being reduced. */ + for (yyi = 0; yyi < yynrhs; yyi++) + { + YYFPRINTF (stderr, " $%d = ", yyi + 1); + yy_symbol_print (stderr, + YY_ACCESSING_SYMBOL (+yyssp[yyi + 1 - yynrhs]), + &yyvsp[(yyi + 1) - (yynrhs)]); + YYFPRINTF (stderr, "\n"); + } +} + +# define YY_REDUCE_PRINT(Rule) \ +do { \ + if (yydebug) \ + yy_reduce_print (yyssp, yyvsp, Rule); \ +} while (0) + +/* Nonzero means print parse trace. It is left uninitialized so that + multiple parsers can coexist. */ +int yydebug; +#else /* !YYDEBUG */ +# define YYDPRINTF(Args) ((void) 0) +# define YY_SYMBOL_PRINT(Title, Kind, Value, Location) +# define YY_STACK_PRINT(Bottom, Top) +# define YY_REDUCE_PRINT(Rule) +#endif /* !YYDEBUG */ + + +/* YYINITDEPTH -- initial size of the parser's stacks. */ +#ifndef YYINITDEPTH +# define YYINITDEPTH 200 +#endif + +/* YYMAXDEPTH -- maximum size the stacks can grow to (effective only + if the built-in stack extension method is used). + + Do not make this value too large; the results are undefined if + YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH) + evaluated with infinite-precision integer arithmetic. */ + +#ifndef YYMAXDEPTH +# define YYMAXDEPTH 10000 +#endif + + + + + + +/*-----------------------------------------------. +| Release the memory associated to this symbol. | +`-----------------------------------------------*/ + +static void +yydestruct (const char *yymsg, + yysymbol_kind_t yykind, YYSTYPE *yyvaluep) +{ + YY_USE (yyvaluep); + if (!yymsg) + yymsg = "Deleting"; + YY_SYMBOL_PRINT (yymsg, yykind, yyvaluep, yylocationp); + + YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN + YY_USE (yykind); + YY_IGNORE_MAYBE_UNINITIALIZED_END +} + + +/* Lookahead token kind. */ +int yychar; + +/* The semantic value of the lookahead symbol. */ +YYSTYPE yylval; +/* Number of syntax errors so far. */ +int yynerrs; + + + + +/*----------. +| yyparse. | +`----------*/ + +int +yyparse (void) +{ + yy_state_fast_t yystate = 0; + /* Number of tokens to shift before error messages enabled. */ + int yyerrstatus = 0; + + /* Refer to the stacks through separate pointers, to allow yyoverflow + to reallocate them elsewhere. */ + + /* Their size. */ + YYPTRDIFF_T yystacksize = YYINITDEPTH; + + /* The state stack: array, bottom, top. */ + yy_state_t yyssa[YYINITDEPTH]; + yy_state_t *yyss = yyssa; + yy_state_t *yyssp = yyss; + + /* The semantic value stack: array, bottom, top. */ + YYSTYPE yyvsa[YYINITDEPTH]; + YYSTYPE *yyvs = yyvsa; + YYSTYPE *yyvsp = yyvs; + + int yyn; + /* The return value of yyparse. */ + int yyresult; + /* Lookahead symbol kind. */ + yysymbol_kind_t yytoken = YYSYMBOL_YYEMPTY; + /* The variables used to return semantic value and location from the + action routines. */ + YYSTYPE yyval; + + + +#define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N)) + + /* The number of symbols on the RHS of the reduced rule. + Keep to zero when no symbol should be popped. */ + int yylen = 0; + + YYDPRINTF ((stderr, "Starting parse\n")); + + yychar = YYEMPTY; /* Cause a token to be read. */ + + goto yysetstate; + + +/*------------------------------------------------------------. +| yynewstate -- push a new state, which is found in yystate. | +`------------------------------------------------------------*/ +yynewstate: + /* In all cases, when you get here, the value and location stacks + have just been pushed. So pushing a state here evens the stacks. */ + yyssp++; + + +/*--------------------------------------------------------------------. +| yysetstate -- set current state (the top of the stack) to yystate. | +`--------------------------------------------------------------------*/ +yysetstate: + YYDPRINTF ((stderr, "Entering state %d\n", yystate)); + YY_ASSERT (0 <= yystate && yystate < YYNSTATES); + YY_IGNORE_USELESS_CAST_BEGIN + *yyssp = YY_CAST (yy_state_t, yystate); + YY_IGNORE_USELESS_CAST_END + YY_STACK_PRINT (yyss, yyssp); + + if (yyss + yystacksize - 1 <= yyssp) +#if !defined yyoverflow && !defined YYSTACK_RELOCATE + YYNOMEM; +#else + { + /* Get the current used size of the three stacks, in elements. */ + YYPTRDIFF_T yysize = yyssp - yyss + 1; + +# if defined yyoverflow + { + /* Give user a chance to reallocate the stack. Use copies of + these so that the &'s don't force the real ones into + memory. */ + yy_state_t *yyss1 = yyss; + YYSTYPE *yyvs1 = yyvs; + + /* Each stack pointer address is followed by the size of the + data in use in that stack, in bytes. This used to be a + conditional around just the two extra args, but that might + be undefined if yyoverflow is a macro. */ + yyoverflow (YY_("memory exhausted"), + &yyss1, yysize * YYSIZEOF (*yyssp), + &yyvs1, yysize * YYSIZEOF (*yyvsp), + &yystacksize); + yyss = yyss1; + yyvs = yyvs1; + } +# else /* defined YYSTACK_RELOCATE */ + /* Extend the stack our own way. */ + if (YYMAXDEPTH <= yystacksize) + YYNOMEM; + yystacksize *= 2; + if (YYMAXDEPTH < yystacksize) + yystacksize = YYMAXDEPTH; + + { + yy_state_t *yyss1 = yyss; + union yyalloc *yyptr = + YY_CAST (union yyalloc *, + YYSTACK_ALLOC (YY_CAST (YYSIZE_T, YYSTACK_BYTES (yystacksize)))); + if (! yyptr) + YYNOMEM; + YYSTACK_RELOCATE (yyss_alloc, yyss); + YYSTACK_RELOCATE (yyvs_alloc, yyvs); +# undef YYSTACK_RELOCATE + if (yyss1 != yyssa) + YYSTACK_FREE (yyss1); + } +# endif + + yyssp = yyss + yysize - 1; + yyvsp = yyvs + yysize - 1; + + YY_IGNORE_USELESS_CAST_BEGIN + YYDPRINTF ((stderr, "Stack size increased to %ld\n", + YY_CAST (long, yystacksize))); + YY_IGNORE_USELESS_CAST_END + + if (yyss + yystacksize - 1 <= yyssp) + YYABORT; + } +#endif /* !defined yyoverflow && !defined YYSTACK_RELOCATE */ + + + if (yystate == YYFINAL) + YYACCEPT; + + goto yybackup; + + +/*-----------. +| yybackup. | +`-----------*/ +yybackup: + /* Do appropriate processing given the current state. Read a + lookahead token if we need one and don't already have one. */ + + /* First try to decide what to do without reference to lookahead token. */ + yyn = yypact[yystate]; + if (yypact_value_is_default (yyn)) + goto yydefault; + + /* Not known => get a lookahead token if don't already have one. */ + + /* YYCHAR is either empty, or end-of-input, or a valid lookahead. */ + if (yychar == YYEMPTY) + { + YYDPRINTF ((stderr, "Reading a token\n")); + yychar = yylex (); + } + + if (yychar <= YYEOF) + { + yychar = YYEOF; + yytoken = YYSYMBOL_YYEOF; + YYDPRINTF ((stderr, "Now at end of input.\n")); + } + else if (yychar == YYerror) + { + /* The scanner already issued an error message, process directly + to error recovery. But do not keep the error token as + lookahead, it is too special and may lead us to an endless + loop in error recovery. */ + yychar = YYUNDEF; + yytoken = YYSYMBOL_YYerror; + goto yyerrlab1; + } + else + { + yytoken = YYTRANSLATE (yychar); + YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc); + } + + /* If the proper action on seeing token YYTOKEN is to reduce or to + detect an error, take that action. */ + yyn += yytoken; + if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken) + goto yydefault; + yyn = yytable[yyn]; + if (yyn <= 0) + { + if (yytable_value_is_error (yyn)) + goto yyerrlab; + yyn = -yyn; + goto yyreduce; + } + + /* Count tokens shifted since error; after three, turn off error + status. */ + if (yyerrstatus) + yyerrstatus--; + + /* Shift the lookahead token. */ + YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc); + yystate = yyn; + YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN + *++yyvsp = yylval; + YY_IGNORE_MAYBE_UNINITIALIZED_END + + /* Discard the shifted token. */ + yychar = YYEMPTY; + goto yynewstate; + + +/*-----------------------------------------------------------. +| yydefault -- do the default action for the current state. | +`-----------------------------------------------------------*/ +yydefault: + yyn = yydefact[yystate]; + if (yyn == 0) + goto yyerrlab; + goto yyreduce; + + +/*-----------------------------. +| yyreduce -- do a reduction. | +`-----------------------------*/ +yyreduce: + /* yyn is the number of a rule to reduce with. */ + yylen = yyr2[yyn]; + + /* If YYLEN is nonzero, implement the default value of the action: + '$$ = $1'. + + Otherwise, the following line sets YYVAL to garbage. + This behavior is undocumented and Bison + users should not rely upon it. Assigning to YYVAL + unconditionally makes the parser a bit smaller, and it avoids a + GCC warning that YYVAL may be used uninitialized. */ + yyval = yyvsp[1-yylen]; + + + YY_REDUCE_PRINT (yyn); + switch (yyn) + { + case 2: /* $@1: %empty */ +#line 42 "compilador.y" + { + geraCodigo (NULL, "INPP"); + } +#line 1242 "compilador.tab.c" + break; + + case 3: /* programa: $@1 PROGRAM IDENT ABRE_PARENTESES lista_idents FECHA_PARENTESES PONTO_E_VIRGULA bloco PONTO */ +#line 48 "compilador.y" + { + geraCodigo (NULL, "PARA"); + } +#line 1250 "compilador.tab.c" + break; + + case 4: /* bloco: parte_declara_rotulos parte_declara_vars parte_declara_subrotinas comando_composto */ +#line 59 "compilador.y" + { + retira(desloc,ts); + char buffer[50]; + sprintf(buffer,"DMEM %d",desloc); + geraCodigo(NULL,buffer); + desloc = 0; + } +#line 1262 "compilador.tab.c" + break; + + case 8: /* $@2: %empty */ +#line 77 "compilador.y" + { } +#line 1268 "compilador.tab.c" + break; + + case 13: /* $@3: %empty */ +#line 85 "compilador.y" + { num_vars = 0; } +#line 1274 "compilador.tab.c" + break; + + case 14: /* $@4: %empty */ +#line 88 "compilador.y" + { /* AMEM num_vars */ + char buffer[50]; + sprintf(buffer, "AMEM %d", num_vars); + geraCodigo(NULL, buffer); + } +#line 1284 "compilador.tab.c" + break; + + case 16: /* tipo: IDENT */ +#line 97 "compilador.y" + { + if (strcmp(token, "integer") == 0) { + atualiza_tipo(num_vars, INTEIRO, ts); + } else if (strcmp(token, "boolean") == 0) { + atualiza_tipo(num_vars, BOOLEAN, ts); + } else { + yyerror("Tipo não reconhecido. Somente 'integer' ou 'boolean' são permitidos."); + } + //mostra_ts(ts); // Mostra a tabela após a inserção + } +#line 1299 "compilador.tab.c" + break; + + case 17: /* lista_id_var: lista_id_var VIRGULA IDENT */ +#line 110 "compilador.y" + { /* insere �ltima vars na tabela de s�mbolos */ + num_vars += 1; + info_t info; + info.vs.tipo = NSEI; + info.vs.desloc = desloc; + insere_ts(token,VS,nivel_lexico,info,ts); + desloc += 1; + } +#line 1312 "compilador.tab.c" + break; + + case 18: /* lista_id_var: IDENT */ +#line 118 "compilador.y" + { + num_vars += 1; + info_t info; + info.vs.tipo = NSEI; + info.vs.desloc = desloc; + insere_ts(token,VS,nivel_lexico,info,ts); + desloc += 1; + /* insere vars na tabela de s�mbolos */ + } +#line 1326 "compilador.tab.c" + break; + + case 39: /* simb_leitura: IDENT */ +#line 173 "compilador.y" + { + geraCodigo(NULL, "LEIT"); + l_elem = busca(token,ts); + char buffer[50]; + sprintf(buffer,"ARMZ %d,%d",l_elem->nivel,l_elem->info.vs.desloc); + geraCodigo(NULL,buffer); + } +#line 1338 "compilador.tab.c" + break; + + case 41: /* lista_escritas: lista_escritas VIRGULA expressao_simples */ +#line 185 "compilador.y" + { + geraCodigo(NULL,"IMPR"); + } +#line 1346 "compilador.tab.c" + break; + + case 42: /* lista_escritas: expressao_simples */ +#line 188 "compilador.y" + { + geraCodigo(NULL,"IMPR"); + } +#line 1354 "compilador.tab.c" + break; + + case 43: /* expressao: expressao IGUAL expressao_simples */ +#line 193 "compilador.y" + { + geraCodigo(NULL, "CMIG"); // Adiciona operação de cmig + } +#line 1362 "compilador.tab.c" + break; + + case 44: /* expressao: expressao DIFERENTE expressao_simples */ +#line 196 "compilador.y" + { + geraCodigo(NULL, "CMDG"); // Adiciona operação de cmdg + } +#line 1370 "compilador.tab.c" + break; + + case 45: /* expressao: expressao MENOR expressao_simples */ +#line 199 "compilador.y" + { + geraCodigo(NULL, "CMME"); // Adiciona operação de cmme + } +#line 1378 "compilador.tab.c" + break; + + case 46: /* expressao: expressao MENOR_IGUAL expressao_simples */ +#line 202 "compilador.y" + { + geraCodigo(NULL, "CMEG"); // Adiciona operação de cmeg + } +#line 1386 "compilador.tab.c" + break; + + case 47: /* expressao: expressao MAIOR expressao_simples */ +#line 205 "compilador.y" + { + geraCodigo(NULL, "CMMA"); // Adiciona operação de cmma + } +#line 1394 "compilador.tab.c" + break; + + case 48: /* expressao: expressao MAIOR_IGUAL expressao_simples */ +#line 208 "compilador.y" + { + geraCodigo(NULL, "CMAG"); // Adiciona operação de cmag + } +#line 1402 "compilador.tab.c" + break; + + case 50: /* expressao_simples: expressao_simples MAIS termo */ +#line 214 "compilador.y" + { + geraCodigo(NULL, "SOMA"); // Adiciona operação de soma + } +#line 1410 "compilador.tab.c" + break; + + case 51: /* expressao_simples: expressao_simples MENOS termo */ +#line 217 "compilador.y" + { + geraCodigo(NULL, "SUBT"); // Adiciona operação de subt + } +#line 1418 "compilador.tab.c" + break; + + case 53: /* termo: termo ASTERISCO fator */ +#line 223 "compilador.y" + { + geraCodigo(NULL, "MULT"); // Adiciona operação de mult + } +#line 1426 "compilador.tab.c" + break; + + case 54: /* termo: termo DIV fator */ +#line 226 "compilador.y" + { + geraCodigo(NULL, "DIVI"); // Adiciona operação de divi + } +#line 1434 "compilador.tab.c" + break; + + case 56: /* $@5: %empty */ +#line 232 "compilador.y" + { + // Busca variável no lado esquerdo + l_elem = busca(token, ts); + if (l_elem == NULL) { + yyerror("Variável de destino não declarada"); + } else { + destino_nivel = l_elem->nivel; + destino_desloc = l_elem->info.vs.desloc; + } +} +#line 1449 "compilador.tab.c" + break; + + case 57: /* atribuicao: IDENT $@5 ATRIBUICAO expressao_simples */ +#line 241 "compilador.y" + { + // Gera código ARMZ para armazenar valor + char buffer[50]; + sprintf(buffer, "ARMZ %d,%d", destino_nivel, destino_desloc); + geraCodigo(NULL, buffer); +} +#line 1460 "compilador.tab.c" + break; + + case 58: /* fator: IDENT */ +#line 249 "compilador.y" + { + // Carrega variável + l_elem = busca(token, ts); + if (l_elem == NULL) { + yyerror("Variável não declarada"); + } else { + char buffer[50]; + sprintf(buffer, "CRVL %d,%d", l_elem->nivel, l_elem->info.vs.desloc); + geraCodigo(NULL, buffer); + } +} +#line 1476 "compilador.tab.c" + break; + + case 59: /* fator: NUMERO */ +#line 260 "compilador.y" + { + // Empilha constante + char buffer[50]; + sprintf(buffer, "CRCT %s", token); + geraCodigo(NULL, buffer); +} +#line 1487 "compilador.tab.c" + break; + + case 61: /* $@6: %empty */ +#line 269 "compilador.y" + { + char r_ini[4]; + sprintf(r_ini, "R%02d", rot_id); + empilha(r_ini, rot); + rot_id += 1; + geraCodigo(r_ini,"NADA"); + } +#line 1499 "compilador.tab.c" + break; + + case 62: /* $@7: %empty */ +#line 276 "compilador.y" + { + char r_fim[4]; + sprintf(r_fim, "R%02d", rot_id); + empilha(r_fim, rot); + rot_id += 1; + char buffer[50]; + strcpy(buffer, "DSVF "); + strcat(buffer,r_fim); + geraCodigo(NULL,buffer); + } +#line 1514 "compilador.tab.c" + break; + + case 63: /* comando_repetitivo: $@6 WHILE expressao DO $@7 comando_sem_rotulo */ +#line 286 "compilador.y" + { + char r_ini[4]; + char r_fim[4]; + + desempilha(r_fim,rot); + desempilha(r_ini,rot); + + char buffer[50]; + strcpy(buffer,"DSVS "); + strcat(buffer,r_ini); + geraCodigo(NULL,buffer); + + geraCodigo(r_fim,"NADA"); + } +#line 1533 "compilador.tab.c" + break; + + case 64: /* comando_condicional: if_then cond_else */ +#line 302 "compilador.y" + { + char r_fim[4]; + desempilha(r_fim,rot); + geraCodigo(r_fim,"NADA"); + } +#line 1543 "compilador.tab.c" + break; + + case 67: /* $@8: %empty */ +#line 314 "compilador.y" + { + char r_else[4]; + sprintf(r_else,"R%02d",rot_id); + empilha(r_else,rot); + rot_id += 1; + char buffer[50]; + strcpy(buffer, "DSVF "); + strcat(buffer,r_else); + geraCodigo(NULL,buffer); + + char r_fim[4]; + sprintf(r_fim, "R%02d", rot_id); + empilha(r_fim, rot); + rot_id += 1; + } +#line 1563 "compilador.tab.c" + break; + + case 68: /* if_then: IF expressao $@8 THEN comando_sem_rotulo */ +#line 329 "compilador.y" + { + char r_fim[4]; + desempilha(r_fim,rot); + char r_else[4]; + desempilha(r_else,rot); + + empilha(r_fim,rot); + char buffer[50]; + strcpy(buffer, "DSVS "); + strcat(buffer,r_fim); + geraCodigo(NULL,buffer); + + geraCodigo(r_else,"NADA"); + } +#line 1582 "compilador.tab.c" + break; + + +#line 1586 "compilador.tab.c" + + default: break; + } + /* User semantic actions sometimes alter yychar, and that requires + that yytoken be updated with the new translation. We take the + approach of translating immediately before every use of yytoken. + One alternative is translating here after every semantic action, + but that translation would be missed if the semantic action invokes + YYABORT, YYACCEPT, or YYERROR immediately after altering yychar or + if it invokes YYBACKUP. In the case of YYABORT or YYACCEPT, an + incorrect destructor might then be invoked immediately. In the + case of YYERROR or YYBACKUP, subsequent parser actions might lead + to an incorrect destructor call or verbose syntax error message + before the lookahead is translated. */ + YY_SYMBOL_PRINT ("-> $$ =", YY_CAST (yysymbol_kind_t, yyr1[yyn]), &yyval, &yyloc); + + YYPOPSTACK (yylen); + yylen = 0; + + *++yyvsp = yyval; + + /* Now 'shift' the result of the reduction. Determine what state + that goes to, based on the state we popped back to and the rule + number reduced by. */ + { + const int yylhs = yyr1[yyn] - YYNTOKENS; + const int yyi = yypgoto[yylhs] + *yyssp; + yystate = (0 <= yyi && yyi <= YYLAST && yycheck[yyi] == *yyssp + ? yytable[yyi] + : yydefgoto[yylhs]); + } + + goto yynewstate; + + +/*--------------------------------------. +| yyerrlab -- here on detecting error. | +`--------------------------------------*/ +yyerrlab: + /* Make sure we have latest lookahead translation. See comments at + user semantic actions for why this is necessary. */ + yytoken = yychar == YYEMPTY ? YYSYMBOL_YYEMPTY : YYTRANSLATE (yychar); + /* If not already recovering from an error, report this error. */ + if (!yyerrstatus) + { + ++yynerrs; + yyerror (YY_("syntax error")); + } + + if (yyerrstatus == 3) + { + /* If just tried and failed to reuse lookahead token after an + error, discard it. */ + + if (yychar <= YYEOF) + { + /* Return failure if at end of input. */ + if (yychar == YYEOF) + YYABORT; + } + else + { + yydestruct ("Error: discarding", + yytoken, &yylval); + yychar = YYEMPTY; + } + } + + /* Else will try to reuse lookahead token after shifting the error + token. */ + goto yyerrlab1; + + +/*---------------------------------------------------. +| yyerrorlab -- error raised explicitly by YYERROR. | +`---------------------------------------------------*/ +yyerrorlab: + /* Pacify compilers when the user code never invokes YYERROR and the + label yyerrorlab therefore never appears in user code. */ + if (0) + YYERROR; + ++yynerrs; + + /* Do not reclaim the symbols of the rule whose action triggered + this YYERROR. */ + YYPOPSTACK (yylen); + yylen = 0; + YY_STACK_PRINT (yyss, yyssp); + yystate = *yyssp; + goto yyerrlab1; + + +/*-------------------------------------------------------------. +| yyerrlab1 -- common code for both syntax error and YYERROR. | +`-------------------------------------------------------------*/ +yyerrlab1: + yyerrstatus = 3; /* Each real token shifted decrements this. */ + + /* Pop stack until we find a state that shifts the error token. */ + for (;;) + { + yyn = yypact[yystate]; + if (!yypact_value_is_default (yyn)) + { + yyn += YYSYMBOL_YYerror; + if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYSYMBOL_YYerror) + { + yyn = yytable[yyn]; + if (0 < yyn) + break; + } + } + + /* Pop the current state because it cannot handle the error token. */ + if (yyssp == yyss) + YYABORT; + + + yydestruct ("Error: popping", + YY_ACCESSING_SYMBOL (yystate), yyvsp); + YYPOPSTACK (1); + yystate = *yyssp; + YY_STACK_PRINT (yyss, yyssp); + } + + YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN + *++yyvsp = yylval; + YY_IGNORE_MAYBE_UNINITIALIZED_END + + + /* Shift the error token. */ + YY_SYMBOL_PRINT ("Shifting", YY_ACCESSING_SYMBOL (yyn), yyvsp, yylsp); + + yystate = yyn; + goto yynewstate; + + +/*-------------------------------------. +| yyacceptlab -- YYACCEPT comes here. | +`-------------------------------------*/ +yyacceptlab: + yyresult = 0; + goto yyreturnlab; + + +/*-----------------------------------. +| yyabortlab -- YYABORT comes here. | +`-----------------------------------*/ +yyabortlab: + yyresult = 1; + goto yyreturnlab; + + +/*-----------------------------------------------------------. +| yyexhaustedlab -- YYNOMEM (memory exhaustion) comes here. | +`-----------------------------------------------------------*/ +yyexhaustedlab: + yyerror (YY_("memory exhausted")); + yyresult = 2; + goto yyreturnlab; + + +/*----------------------------------------------------------. +| yyreturnlab -- parsing is finished, clean up and return. | +`----------------------------------------------------------*/ +yyreturnlab: + if (yychar != YYEMPTY) + { + /* Make sure we have latest lookahead translation. See comments at + user semantic actions for why this is necessary. */ + yytoken = YYTRANSLATE (yychar); + yydestruct ("Cleanup: discarding lookahead", + yytoken, &yylval); + } + /* Do not reclaim the symbols of the rule whose action triggered + this YYABORT or YYACCEPT. */ + YYPOPSTACK (yylen); + YY_STACK_PRINT (yyss, yyssp); + while (yyssp != yyss) + { + yydestruct ("Cleanup: popping", + YY_ACCESSING_SYMBOL (+*yyssp), yyvsp); + YYPOPSTACK (1); + } +#ifndef yyoverflow + if (yyss != yyssa) + YYSTACK_FREE (yyss); +#endif + + return yyresult; +} + +#line 346 "compilador.y" + + +int main (int argc, char** argv) { + FILE* fp; + extern FILE* yyin; + + if (argc<2 || argc>2) { + printf("usage compilador <arq>a %d\n", argc); + return(-1); + } + + fp=fopen (argv[1], "r"); + if (fp == NULL) { + printf("usage compilador <arq>b\n"); + return(-1); + } + + +/* ------------------------------------------------------------------- + * Inicia a Tabela de S�mbolos + * ------------------------------------------------------------------- */ + ts = (ts_t *)malloc(sizeof(ts_t)); + inicializa_ts(ts); + nivel_lexico = 0; + desloc = 0; + + // Inicializa Rotulos + rot = (stack_t_custom *)malloc(sizeof(stack_t_custom)); + inicializa_stack(rot); + rot_id = 0; + + yyin=fp; + yyparse(); + + return 0; +} diff --git a/compilador.tab.h b/compilador.tab.h new file mode 100644 index 0000000000000000000000000000000000000000..98da8d5548661fb0b6d86e8b8eea643b72be70af --- /dev/null +++ b/compilador.tab.h @@ -0,0 +1,115 @@ +/* A Bison parser, made by GNU Bison 3.8.2. */ + +/* Bison interface for Yacc-like parsers in C + + Copyright (C) 1984, 1989-1990, 2000-2015, 2018-2021 Free Software Foundation, + Inc. + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see <https://www.gnu.org/licenses/>. */ + +/* As a special exception, you may create a larger work that contains + part or all of the Bison parser skeleton and distribute that work + under terms of your choice, so long as that work isn't itself a + parser generator using the skeleton or a modified version thereof + as a parser skeleton. Alternatively, if you modify or redistribute + the parser skeleton itself, you may (at your option) remove this + special exception, which will cause the skeleton and the resulting + Bison output files to be licensed under the GNU General Public + License without this special exception. + + This special exception was added by the Free Software Foundation in + version 2.2 of Bison. */ + +/* DO NOT RELY ON FEATURES THAT ARE NOT DOCUMENTED in the manual, + especially those whose name start with YY_ or yy_. They are + private implementation details that can be changed or removed. */ + +#ifndef YY_YY_COMPILADOR_TAB_H_INCLUDED +# define YY_YY_COMPILADOR_TAB_H_INCLUDED +/* Debug traces. */ +#ifndef YYDEBUG +# define YYDEBUG 0 +#endif +#if YYDEBUG +extern int yydebug; +#endif + +/* Token kinds. */ +#ifndef YYTOKENTYPE +# define YYTOKENTYPE + enum yytokentype + { + YYEMPTY = -2, + YYEOF = 0, /* "end of file" */ + YYerror = 256, /* error */ + YYUNDEF = 257, /* "invalid token" */ + PROGRAM = 258, /* PROGRAM */ + ABRE_PARENTESES = 259, /* ABRE_PARENTESES */ + FECHA_PARENTESES = 260, /* FECHA_PARENTESES */ + VIRGULA = 261, /* VIRGULA */ + PONTO_E_VIRGULA = 262, /* PONTO_E_VIRGULA */ + DOIS_PONTOS = 263, /* DOIS_PONTOS */ + PONTO = 264, /* PONTO */ + T_BEGIN = 265, /* T_BEGIN */ + T_END = 266, /* T_END */ + VAR = 267, /* VAR */ + IDENT = 268, /* IDENT */ + ATRIBUICAO = 269, /* ATRIBUICAO */ + LABEL = 270, /* LABEL */ + TYPE = 271, /* TYPE */ + ARRAY = 272, /* ARRAY */ + PROCEDURE = 273, /* PROCEDURE */ + FUNCTION = 274, /* FUNCTION */ + GOTO = 275, /* GOTO */ + IF = 276, /* IF */ + THEN = 277, /* THEN */ + ELSE = 278, /* ELSE */ + WHILE = 279, /* WHILE */ + DO = 280, /* DO */ + OR = 281, /* OR */ + DIV = 282, /* DIV */ + AND = 283, /* AND */ + NOT = 284, /* NOT */ + IGUAL = 285, /* IGUAL */ + DIFERENTE = 286, /* DIFERENTE */ + MENOR_IGUAL = 287, /* MENOR_IGUAL */ + MAIOR_IGUAL = 288, /* MAIOR_IGUAL */ + MENOR = 289, /* MENOR */ + MAIOR = 290, /* MAIOR */ + MAIS = 291, /* MAIS */ + MENOS = 292, /* MENOS */ + ASTERISCO = 293, /* ASTERISCO */ + NUMERO = 294, /* NUMERO */ + READ = 295, /* READ */ + WRITE = 296, /* WRITE */ + LOWER_THAN_ELSE = 297 /* LOWER_THAN_ELSE */ + }; + typedef enum yytokentype yytoken_kind_t; +#endif + +/* Value type. */ +#if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED +typedef int YYSTYPE; +# define YYSTYPE_IS_TRIVIAL 1 +# define YYSTYPE_IS_DECLARED 1 +#endif + + +extern YYSTYPE yylval; + + +int yyparse (void); + + +#endif /* !YY_YY_COMPILADOR_TAB_H_INCLUDED */ diff --git a/compilador.y b/compilador.y index 8fe226b7c9245316239d05ed9fa4580ca18e0b02..5f266212c596a3d87c2f5405a9780a8a17e98713 100644 --- a/compilador.y +++ b/compilador.y @@ -102,19 +102,25 @@ tipo : IDENT } else { yyerror("Tipo não reconhecido. Somente 'integer' ou 'boolean' são permitidos."); } - mostra_ts(ts); // Mostra a tabela após a inserção + //mostra_ts(ts); // Mostra a tabela após a inserção } ; lista_id_var: lista_id_var VIRGULA IDENT { /* insere �ltima vars na tabela de s�mbolos */ num_vars += 1; - insere_ts(token,VS,nivel_lexico,NSEI,desloc,ts); + info_t info; + info.vs.tipo = NSEI; + info.vs.desloc = desloc; + insere_ts(token,VS,nivel_lexico,info,ts); desloc += 1; } | IDENT { num_vars += 1; - insere_ts(token,VS,nivel_lexico,NSEI,desloc,ts); + info_t info; + info.vs.tipo = NSEI; + info.vs.desloc = desloc; + insere_ts(token,VS,nivel_lexico,info,ts); desloc += 1; /* insere vars na tabela de s�mbolos */ } @@ -129,7 +135,9 @@ parte_declara_subrotinas: declaracao_procedimento ; // REGRA 12 -declaracao_procedimento: ; +declaracao_procedimento: PROCEDURE IDENT + | +; comando_composto: T_BEGIN comandos T_END @@ -150,10 +158,10 @@ comando_sem_rotulo: atribuicao | comando_repetitivo | leitura | escrita - | chamada_procedimento + //| chamada_procedimento ; -chamada_procedimento: ; +//chamada_procedimento: ; leitura: READ ABRE_PARENTESES lista_leituras FECHA_PARENTESES ; @@ -166,7 +174,7 @@ simb_leitura: IDENT { geraCodigo(NULL, "LEIT"); l_elem = busca(token,ts); char buffer[50]; - sprintf(buffer,"ARMZ %d,%d",l_elem->nivel,l_elem->desloc); + sprintf(buffer,"ARMZ %d,%d",l_elem->nivel,l_elem->info.vs.desloc); geraCodigo(NULL,buffer); } ; @@ -228,7 +236,7 @@ atribuicao: IDENT { yyerror("Variável de destino não declarada"); } else { destino_nivel = l_elem->nivel; - destino_desloc = l_elem->desloc; + destino_desloc = l_elem->info.vs.desloc; } } ATRIBUICAO expressao_simples { // Gera código ARMZ para armazenar valor @@ -245,7 +253,7 @@ fator: IDENT { yyerror("Variável não declarada"); } else { char buffer[50]; - sprintf(buffer, "CRVL %d,%d", l_elem->nivel, l_elem->desloc); + sprintf(buffer, "CRVL %d,%d", l_elem->nivel, l_elem->info.vs.desloc); geraCodigo(NULL, buffer); } } diff --git a/lex.yy.c b/lex.yy.c new file mode 100644 index 0000000000000000000000000000000000000000..ef6ad0e7b67a03c550188319338cd3adac742a1f --- /dev/null +++ b/lex.yy.c @@ -0,0 +1,2196 @@ + +#line 3 "lex.yy.c" + +#define YY_INT_ALIGNED short int + +/* A lexical scanner generated by flex */ + +#define FLEX_SCANNER +#define YY_FLEX_MAJOR_VERSION 2 +#define YY_FLEX_MINOR_VERSION 6 +#define YY_FLEX_SUBMINOR_VERSION 4 +#if YY_FLEX_SUBMINOR_VERSION > 0 +#define FLEX_BETA +#endif + +/* First, we deal with platform-specific or compiler-specific issues. */ + +/* begin standard C headers. */ +#include <stdio.h> +#include <string.h> +#include <errno.h> +#include <stdlib.h> + +/* end standard C headers. */ + +/* flex integer type definitions */ + +#ifndef FLEXINT_H +#define FLEXINT_H + +/* C99 systems have <inttypes.h>. Non-C99 systems may or may not. */ + +#if defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L + +/* C99 says to define __STDC_LIMIT_MACROS before including stdint.h, + * if you want the limit (max/min) macros for int types. + */ +#ifndef __STDC_LIMIT_MACROS +#define __STDC_LIMIT_MACROS 1 +#endif + +#include <inttypes.h> +typedef int8_t flex_int8_t; +typedef uint8_t flex_uint8_t; +typedef int16_t flex_int16_t; +typedef uint16_t flex_uint16_t; +typedef int32_t flex_int32_t; +typedef uint32_t flex_uint32_t; +#else +typedef signed char flex_int8_t; +typedef short int flex_int16_t; +typedef int flex_int32_t; +typedef unsigned char flex_uint8_t; +typedef unsigned short int flex_uint16_t; +typedef unsigned int flex_uint32_t; + +/* Limits of integral types. */ +#ifndef INT8_MIN +#define INT8_MIN (-128) +#endif +#ifndef INT16_MIN +#define INT16_MIN (-32767-1) +#endif +#ifndef INT32_MIN +#define INT32_MIN (-2147483647-1) +#endif +#ifndef INT8_MAX +#define INT8_MAX (127) +#endif +#ifndef INT16_MAX +#define INT16_MAX (32767) +#endif +#ifndef INT32_MAX +#define INT32_MAX (2147483647) +#endif +#ifndef UINT8_MAX +#define UINT8_MAX (255U) +#endif +#ifndef UINT16_MAX +#define UINT16_MAX (65535U) +#endif +#ifndef UINT32_MAX +#define UINT32_MAX (4294967295U) +#endif + +#ifndef SIZE_MAX +#define SIZE_MAX (~(size_t)0) +#endif + +#endif /* ! C99 */ + +#endif /* ! FLEXINT_H */ + +/* begin standard C++ headers. */ + +/* TODO: this is always defined, so inline it */ +#define yyconst const + +#if defined(__GNUC__) && __GNUC__ >= 3 +#define yynoreturn __attribute__((__noreturn__)) +#else +#define yynoreturn +#endif + +/* Returned upon end-of-file. */ +#define YY_NULL 0 + +/* Promotes a possibly negative, possibly signed char to an + * integer in range [0..255] for use as an array index. + */ +#define YY_SC_TO_UI(c) ((YY_CHAR) (c)) + +/* Enter a start condition. This macro really ought to take a parameter, + * but we do it the disgusting crufty way forced on us by the ()-less + * definition of BEGIN. + */ +#define BEGIN (yy_start) = 1 + 2 * +/* Translate the current start state into a value that can be later handed + * to BEGIN to return to the state. The YYSTATE alias is for lex + * compatibility. + */ +#define YY_START (((yy_start) - 1) / 2) +#define YYSTATE YY_START +/* Action number for EOF rule of a given start state. */ +#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1) +/* Special action meaning "start processing a new file". */ +#define YY_NEW_FILE yyrestart( yyin ) +#define YY_END_OF_BUFFER_CHAR 0 + +/* Size of default input buffer. */ +#ifndef YY_BUF_SIZE +#ifdef __ia64__ +/* On IA-64, the buffer size is 16k, not 8k. + * Moreover, YY_BUF_SIZE is 2*YY_READ_BUF_SIZE in the general case. + * Ditto for the __ia64__ case accordingly. + */ +#define YY_BUF_SIZE 32768 +#else +#define YY_BUF_SIZE 16384 +#endif /* __ia64__ */ +#endif + +/* The state buf must be large enough to hold one state per character in the main buffer. + */ +#define YY_STATE_BUF_SIZE ((YY_BUF_SIZE + 2) * sizeof(yy_state_type)) + +#ifndef YY_TYPEDEF_YY_BUFFER_STATE +#define YY_TYPEDEF_YY_BUFFER_STATE +typedef struct yy_buffer_state *YY_BUFFER_STATE; +#endif + +#ifndef YY_TYPEDEF_YY_SIZE_T +#define YY_TYPEDEF_YY_SIZE_T +typedef size_t yy_size_t; +#endif + +extern int yyleng; + +extern FILE *yyin, *yyout; + +#define EOB_ACT_CONTINUE_SCAN 0 +#define EOB_ACT_END_OF_FILE 1 +#define EOB_ACT_LAST_MATCH 2 + + #define YY_LESS_LINENO(n) + #define YY_LINENO_REWIND_TO(ptr) + +/* Return all but the first "n" matched characters back to the input stream. */ +#define yyless(n) \ + do \ + { \ + /* Undo effects of setting up yytext. */ \ + int yyless_macro_arg = (n); \ + YY_LESS_LINENO(yyless_macro_arg);\ + *yy_cp = (yy_hold_char); \ + YY_RESTORE_YY_MORE_OFFSET \ + (yy_c_buf_p) = yy_cp = yy_bp + yyless_macro_arg - YY_MORE_ADJ; \ + YY_DO_BEFORE_ACTION; /* set up yytext again */ \ + } \ + while ( 0 ) +#define unput(c) yyunput( c, (yytext_ptr) ) + +#ifndef YY_STRUCT_YY_BUFFER_STATE +#define YY_STRUCT_YY_BUFFER_STATE +struct yy_buffer_state + { + FILE *yy_input_file; + + char *yy_ch_buf; /* input buffer */ + char *yy_buf_pos; /* current position in input buffer */ + + /* Size of input buffer in bytes, not including room for EOB + * characters. + */ + int yy_buf_size; + + /* Number of characters read into yy_ch_buf, not including EOB + * characters. + */ + int yy_n_chars; + + /* Whether we "own" the buffer - i.e., we know we created it, + * and can realloc() it to grow it, and should free() it to + * delete it. + */ + int yy_is_our_buffer; + + /* Whether this is an "interactive" input source; if so, and + * if we're using stdio for input, then we want to use getc() + * instead of fread(), to make sure we stop fetching input after + * each newline. + */ + int yy_is_interactive; + + /* Whether we're considered to be at the beginning of a line. + * If so, '^' rules will be active on the next match, otherwise + * not. + */ + int yy_at_bol; + + int yy_bs_lineno; /**< The line count. */ + int yy_bs_column; /**< The column count. */ + + /* Whether to try to fill the input buffer when we reach the + * end of it. + */ + int yy_fill_buffer; + + int yy_buffer_status; + +#define YY_BUFFER_NEW 0 +#define YY_BUFFER_NORMAL 1 + /* When an EOF's been seen but there's still some text to process + * then we mark the buffer as YY_EOF_PENDING, to indicate that we + * shouldn't try reading from the input source any more. We might + * still have a bunch of tokens to match, though, because of + * possible backing-up. + * + * When we actually see the EOF, we change the status to "new" + * (via yyrestart()), so that the user can continue scanning by + * just pointing yyin at a new input file. + */ +#define YY_BUFFER_EOF_PENDING 2 + + }; +#endif /* !YY_STRUCT_YY_BUFFER_STATE */ + +/* Stack of input buffers. */ +static size_t yy_buffer_stack_top = 0; /**< index of top of stack. */ +static size_t yy_buffer_stack_max = 0; /**< capacity of stack. */ +static YY_BUFFER_STATE * yy_buffer_stack = NULL; /**< Stack as an array. */ + +/* We provide macros for accessing buffer states in case in the + * future we want to put the buffer states in a more general + * "scanner state". + * + * Returns the top of the stack, or NULL. + */ +#define YY_CURRENT_BUFFER ( (yy_buffer_stack) \ + ? (yy_buffer_stack)[(yy_buffer_stack_top)] \ + : NULL) +/* Same as previous macro, but useful when we know that the buffer stack is not + * NULL or when we need an lvalue. For internal use only. + */ +#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] + +/* yy_hold_char holds the character lost when yytext is formed. */ +static char yy_hold_char; +static int yy_n_chars; /* number of characters read into yy_ch_buf */ +int yyleng; + +/* Points to current character in buffer. */ +static char *yy_c_buf_p = NULL; +static int yy_init = 0; /* whether we need to initialize */ +static int yy_start = 0; /* start state number */ + +/* Flag which is used to allow yywrap()'s to do buffer switches + * instead of setting up a fresh yyin. A bit of a hack ... + */ +static int yy_did_buffer_switch_on_eof; + +void yyrestart ( FILE *input_file ); +void yy_switch_to_buffer ( YY_BUFFER_STATE new_buffer ); +YY_BUFFER_STATE yy_create_buffer ( FILE *file, int size ); +void yy_delete_buffer ( YY_BUFFER_STATE b ); +void yy_flush_buffer ( YY_BUFFER_STATE b ); +void yypush_buffer_state ( YY_BUFFER_STATE new_buffer ); +void yypop_buffer_state ( void ); + +static void yyensure_buffer_stack ( void ); +static void yy_load_buffer_state ( void ); +static void yy_init_buffer ( YY_BUFFER_STATE b, FILE *file ); +#define YY_FLUSH_BUFFER yy_flush_buffer( YY_CURRENT_BUFFER ) + +YY_BUFFER_STATE yy_scan_buffer ( char *base, yy_size_t size ); +YY_BUFFER_STATE yy_scan_string ( const char *yy_str ); +YY_BUFFER_STATE yy_scan_bytes ( const char *bytes, int len ); + +void *yyalloc ( yy_size_t ); +void *yyrealloc ( void *, yy_size_t ); +void yyfree ( void * ); + +#define yy_new_buffer yy_create_buffer +#define yy_set_interactive(is_interactive) \ + { \ + if ( ! YY_CURRENT_BUFFER ){ \ + yyensure_buffer_stack (); \ + YY_CURRENT_BUFFER_LVALUE = \ + yy_create_buffer( yyin, YY_BUF_SIZE ); \ + } \ + YY_CURRENT_BUFFER_LVALUE->yy_is_interactive = is_interactive; \ + } +#define yy_set_bol(at_bol) \ + { \ + if ( ! YY_CURRENT_BUFFER ){\ + yyensure_buffer_stack (); \ + YY_CURRENT_BUFFER_LVALUE = \ + yy_create_buffer( yyin, YY_BUF_SIZE ); \ + } \ + YY_CURRENT_BUFFER_LVALUE->yy_at_bol = at_bol; \ + } +#define YY_AT_BOL() (YY_CURRENT_BUFFER_LVALUE->yy_at_bol) + +/* Begin user sect3 */ +typedef flex_uint8_t YY_CHAR; + +FILE *yyin = NULL, *yyout = NULL; + +typedef int yy_state_type; + +extern int yylineno; +int yylineno = 1; + +extern char *yytext; +#ifdef yytext_ptr +#undef yytext_ptr +#endif +#define yytext_ptr yytext + +static yy_state_type yy_get_previous_state ( void ); +static yy_state_type yy_try_NUL_trans ( yy_state_type current_state ); +static int yy_get_next_buffer ( void ); +static void yynoreturn yy_fatal_error ( const char* msg ); + +/* Done after the current pattern has been matched and before the + * corresponding action - sets up yytext. + */ +#define YY_DO_BEFORE_ACTION \ + (yytext_ptr) = yy_bp; \ + yyleng = (int) (yy_cp - yy_bp); \ + (yy_hold_char) = *yy_cp; \ + *yy_cp = '\0'; \ + (yy_c_buf_p) = yy_cp; +#define YY_NUM_RULES 43 +#define YY_END_OF_BUFFER 44 +/* This struct is not used in this scanner, + but its presence is necessary. */ +struct yy_trans_info + { + flex_int32_t yy_verify; + flex_int32_t yy_nxt; + }; +static const flex_int16_t yy_accept[115] = + { 0, + 0, 0, 44, 43, 2, 1, 15, 16, 40, 38, + 13, 39, 14, 41, 12, 11, 36, 32, 37, 42, + 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, + 42, 42, 42, 42, 42, 2, 0, 41, 10, 34, + 33, 35, 42, 42, 42, 42, 42, 27, 42, 42, + 42, 42, 23, 42, 42, 28, 42, 42, 42, 42, + 42, 42, 42, 0, 0, 30, 42, 42, 29, 42, + 7, 42, 42, 42, 31, 42, 42, 42, 42, 5, + 42, 42, 3, 42, 42, 25, 42, 22, 42, 42, + 42, 8, 24, 18, 42, 42, 19, 6, 42, 17, + + 42, 42, 26, 9, 42, 42, 42, 42, 42, 4, + 21, 42, 20, 0 + } ; + +static const YY_CHAR yy_ec[256] = + { 0, + 1, 1, 1, 1, 1, 1, 1, 1, 2, 3, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 2, 1, 1, 1, 1, 1, 1, 1, 4, + 5, 6, 7, 8, 9, 10, 1, 11, 11, 11, + 11, 11, 11, 11, 11, 11, 11, 12, 13, 14, + 15, 16, 1, 1, 17, 17, 17, 17, 17, 17, + 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, + 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, + 1, 1, 1, 1, 1, 1, 18, 19, 20, 21, + + 22, 23, 24, 25, 26, 17, 17, 27, 28, 29, + 30, 31, 17, 32, 33, 34, 35, 36, 37, 17, + 38, 17, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1 + } ; + +static const YY_CHAR yy_meta[39] = + { 0, + 1, 1, 2, 1, 1, 1, 1, 1, 1, 1, + 3, 1, 1, 1, 1, 1, 3, 3, 3, 3, + 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, + 3, 3, 3, 3, 3, 3, 3, 3 + } ; + +static const flex_int16_t yy_base[117] = + { 0, + 0, 0, 123, 124, 120, 124, 115, 124, 124, 124, + 124, 124, 124, 109, 104, 124, 24, 124, 103, 0, + 12, 95, 16, 16, 81, 85, 91, 95, 82, 79, + 78, 87, 22, 90, 23, 105, 100, 94, 124, 124, + 124, 124, 0, 83, 71, 78, 65, 0, 67, 78, + 69, 63, 0, 77, 61, 0, 64, 75, 70, 60, + 58, 63, 62, 81, 44, 0, 68, 59, 0, 62, + 0, 63, 52, 59, 0, 32, 59, 50, 56, 0, + 50, 42, 69, 36, 44, 0, 38, 0, 44, 48, + 37, 0, 0, 0, 46, 45, 0, 0, 40, 0, + + 44, 46, 0, 0, 32, 24, 30, 28, 22, 0, + 0, 31, 0, 124, 48, 60 + } ; + +static const flex_int16_t yy_def[117] = + { 0, + 114, 1, 114, 114, 114, 114, 114, 114, 114, 114, + 114, 114, 114, 114, 114, 114, 114, 114, 114, 115, + 115, 115, 115, 115, 115, 115, 115, 115, 115, 115, + 115, 115, 115, 115, 115, 114, 116, 114, 114, 114, + 114, 114, 115, 115, 115, 115, 115, 115, 115, 115, + 115, 115, 115, 115, 115, 115, 115, 115, 115, 115, + 115, 115, 115, 116, 116, 115, 115, 115, 115, 115, + 115, 115, 115, 115, 115, 115, 115, 115, 115, 115, + 115, 115, 116, 115, 115, 115, 115, 115, 115, 115, + 115, 115, 115, 115, 115, 115, 115, 115, 115, 115, + + 115, 115, 115, 115, 115, 115, 115, 115, 115, 115, + 115, 115, 115, 0, 114, 114 + } ; + +static const flex_int16_t yy_nxt[163] = + { 0, + 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, + 14, 15, 16, 17, 18, 19, 20, 21, 22, 20, + 23, 24, 25, 26, 20, 27, 28, 20, 29, 30, + 31, 32, 20, 33, 20, 34, 35, 20, 40, 41, + 44, 47, 49, 45, 50, 48, 59, 62, 83, 65, + 43, 90, 113, 112, 63, 91, 111, 110, 109, 60, + 64, 108, 64, 107, 106, 105, 104, 103, 102, 101, + 100, 99, 98, 97, 65, 96, 95, 94, 93, 92, + 89, 88, 87, 86, 85, 84, 65, 82, 81, 80, + 79, 78, 77, 76, 75, 74, 73, 72, 71, 70, + + 69, 68, 67, 66, 38, 65, 36, 61, 58, 57, + 56, 55, 54, 53, 52, 51, 46, 42, 39, 38, + 37, 36, 114, 3, 114, 114, 114, 114, 114, 114, + 114, 114, 114, 114, 114, 114, 114, 114, 114, 114, + 114, 114, 114, 114, 114, 114, 114, 114, 114, 114, + 114, 114, 114, 114, 114, 114, 114, 114, 114, 114, + 114, 114 + } ; + +static const flex_int16_t yy_chk[163] = + { 0, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 17, 17, + 21, 23, 24, 21, 24, 23, 33, 35, 65, 65, + 115, 76, 112, 109, 35, 76, 108, 107, 106, 33, + 116, 105, 116, 102, 101, 99, 96, 95, 91, 90, + 89, 87, 85, 84, 83, 82, 81, 79, 78, 77, + 74, 73, 72, 70, 68, 67, 64, 63, 62, 61, + 60, 59, 58, 57, 55, 54, 52, 51, 50, 49, + + 47, 46, 45, 44, 38, 37, 36, 34, 32, 31, + 30, 29, 28, 27, 26, 25, 22, 19, 15, 14, + 7, 5, 3, 114, 114, 114, 114, 114, 114, 114, + 114, 114, 114, 114, 114, 114, 114, 114, 114, 114, + 114, 114, 114, 114, 114, 114, 114, 114, 114, 114, + 114, 114, 114, 114, 114, 114, 114, 114, 114, 114, + 114, 114 + } ; + +static yy_state_type yy_last_accepting_state; +static char *yy_last_accepting_cpos; + +extern int yy_flex_debug; +int yy_flex_debug = 0; + +/* The intent behind this definition is that it'll catch + * any uses of REJECT which flex missed. + */ +#define REJECT reject_used_but_not_detected +#define yymore() yymore_used_but_not_detected +#define YY_MORE_ADJ 0 +#define YY_RESTORE_YY_MORE_OFFSET +char *yytext; +#line 1 "compilador.l" +/* ------------------------------------------------------------------- + * Arquivo: compilador.l + * ------------------------------------------------------------------- + * Autor: Bruno Muller Junior + * Data: 08/2007 + * Atualizado em: [09/08/2020, 19h:01m] + * + * ------------------------------------------------------------------- + * + * Tipos, protótipos e variáveis globais do compilador (via extern) + * + * ------------------------------------------------------------------- */ +#line 16 "compilador.l" + + +#include<stdio.h> +#include<string.h> + +#include "compilador.h" +#include "compilador.tab.h" + +//#define IMPRIME(STR) {}; +#define IMPRIME(STR) printf("%s # %s \n", STR, token); + +int nl = 1; + +#line 540 "lex.yy.c" +#line 541 "lex.yy.c" + +#define INITIAL 0 + +#ifndef YY_NO_UNISTD_H +/* Special case for "unistd.h", since it is non-ANSI. We include it way + * down here because we want the user's section 1 to have been scanned first. + * The user has a chance to override it with an option. + */ +#include <unistd.h> +#endif + +#ifndef YY_EXTRA_TYPE +#define YY_EXTRA_TYPE void * +#endif + +static int yy_init_globals ( void ); + +/* Accessor methods to globals. + These are made visible to non-reentrant scanners for convenience. */ + +int yylex_destroy ( void ); + +int yyget_debug ( void ); + +void yyset_debug ( int debug_flag ); + +YY_EXTRA_TYPE yyget_extra ( void ); + +void yyset_extra ( YY_EXTRA_TYPE user_defined ); + +FILE *yyget_in ( void ); + +void yyset_in ( FILE * _in_str ); + +FILE *yyget_out ( void ); + +void yyset_out ( FILE * _out_str ); + + int yyget_leng ( void ); + +char *yyget_text ( void ); + +int yyget_lineno ( void ); + +void yyset_lineno ( int _line_number ); + +/* Macros after this point can all be overridden by user definitions in + * section 1. + */ + +#ifndef YY_SKIP_YYWRAP +#ifdef __cplusplus +extern "C" int yywrap ( void ); +#else +extern int yywrap ( void ); +#endif +#endif + +#ifndef YY_NO_UNPUT + + static void yyunput ( int c, char *buf_ptr ); + +#endif + +#ifndef yytext_ptr +static void yy_flex_strncpy ( char *, const char *, int ); +#endif + +#ifdef YY_NEED_STRLEN +static int yy_flex_strlen ( const char * ); +#endif + +#ifndef YY_NO_INPUT +#ifdef __cplusplus +static int yyinput ( void ); +#else +static int input ( void ); +#endif + +#endif + +/* Amount of stuff to slurp up with each read. */ +#ifndef YY_READ_BUF_SIZE +#ifdef __ia64__ +/* On IA-64, the buffer size is 16k, not 8k */ +#define YY_READ_BUF_SIZE 16384 +#else +#define YY_READ_BUF_SIZE 8192 +#endif /* __ia64__ */ +#endif + +/* Copy whatever the last rule matched to the standard output. */ +#ifndef ECHO +/* This used to be an fputs(), but since the string might contain NUL's, + * we now use fwrite(). + */ +#define ECHO do { if (fwrite( yytext, (size_t) yyleng, 1, yyout )) {} } while (0) +#endif + +/* Gets input and stuffs it into "buf". number of characters read, or YY_NULL, + * is returned in "result". + */ +#ifndef YY_INPUT +#define YY_INPUT(buf,result,max_size) \ + if ( YY_CURRENT_BUFFER_LVALUE->yy_is_interactive ) \ + { \ + int c = '*'; \ + int n; \ + for ( n = 0; n < max_size && \ + (c = getc( yyin )) != EOF && c != '\n'; ++n ) \ + buf[n] = (char) c; \ + if ( c == '\n' ) \ + buf[n++] = (char) c; \ + if ( c == EOF && ferror( yyin ) ) \ + YY_FATAL_ERROR( "input in flex scanner failed" ); \ + result = n; \ + } \ + else \ + { \ + errno=0; \ + while ( (result = (int) fread(buf, 1, (yy_size_t) max_size, yyin)) == 0 && ferror(yyin)) \ + { \ + if( errno != EINTR) \ + { \ + YY_FATAL_ERROR( "input in flex scanner failed" ); \ + break; \ + } \ + errno=0; \ + clearerr(yyin); \ + } \ + }\ +\ + +#endif + +/* No semi-colon after return; correct usage is to write "yyterminate();" - + * we don't want an extra ';' after the "return" because that will cause + * some compilers to complain about unreachable statements. + */ +#ifndef yyterminate +#define yyterminate() return YY_NULL +#endif + +/* Number of entries by which start-condition stack grows. */ +#ifndef YY_START_STACK_INCR +#define YY_START_STACK_INCR 25 +#endif + +/* Report a fatal error. */ +#ifndef YY_FATAL_ERROR +#define YY_FATAL_ERROR(msg) yy_fatal_error( msg ) +#endif + +/* end tables serialization structures and prototypes */ + +/* Default declaration of generated scanner - a define so the user can + * easily add parameters. + */ +#ifndef YY_DECL +#define YY_DECL_IS_OURS 1 + +extern int yylex (void); + +#define YY_DECL int yylex (void) +#endif /* !YY_DECL */ + +/* Code executed at the beginning of each rule, after yytext and yyleng + * have been set up. + */ +#ifndef YY_USER_ACTION +#define YY_USER_ACTION +#endif + +/* Code executed at the end of each rule. */ +#ifndef YY_BREAK +#define YY_BREAK /*LINTED*/break; +#endif + +#define YY_RULE_SETUP \ + YY_USER_ACTION + +/** The main scanner function which does all the work. + */ +YY_DECL +{ + yy_state_type yy_current_state; + char *yy_cp, *yy_bp; + int yy_act; + + if ( !(yy_init) ) + { + (yy_init) = 1; + +#ifdef YY_USER_INIT + YY_USER_INIT; +#endif + + if ( ! (yy_start) ) + (yy_start) = 1; /* first start state */ + + if ( ! yyin ) + yyin = stdin; + + if ( ! yyout ) + yyout = stdout; + + if ( ! YY_CURRENT_BUFFER ) { + yyensure_buffer_stack (); + YY_CURRENT_BUFFER_LVALUE = + yy_create_buffer( yyin, YY_BUF_SIZE ); + } + + yy_load_buffer_state( ); + } + + { +#line 41 "compilador.l" + + +#line 761 "lex.yy.c" + + while ( /*CONSTCOND*/1 ) /* loops until end-of-file is reached */ + { + yy_cp = (yy_c_buf_p); + + /* Support of yytext. */ + *yy_cp = (yy_hold_char); + + /* yy_bp points to the position in yy_ch_buf of the start of + * the current run. + */ + yy_bp = yy_cp; + + yy_current_state = (yy_start); +yy_match: + do + { + YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)] ; + if ( yy_accept[yy_current_state] ) + { + (yy_last_accepting_state) = yy_current_state; + (yy_last_accepting_cpos) = yy_cp; + } + while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) + { + yy_current_state = (int) yy_def[yy_current_state]; + if ( yy_current_state >= 115 ) + yy_c = yy_meta[yy_c]; + } + yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c]; + ++yy_cp; + } + while ( yy_base[yy_current_state] != 124 ); + +yy_find_action: + yy_act = yy_accept[yy_current_state]; + if ( yy_act == 0 ) + { /* have to back up */ + yy_cp = (yy_last_accepting_cpos); + yy_current_state = (yy_last_accepting_state); + yy_act = yy_accept[yy_current_state]; + } + + YY_DO_BEFORE_ACTION; + +do_action: /* This label is used only to access EOF actions. */ + + switch ( yy_act ) + { /* beginning of action switch */ + case 0: /* must back up */ + /* undo the effects of YY_DO_BEFORE_ACTION */ + *yy_cp = (yy_hold_char); + yy_cp = (yy_last_accepting_cpos); + yy_current_state = (yy_last_accepting_state); + goto yy_find_action; + +case 1: +/* rule 1 can match eol */ +YY_RULE_SETUP +#line 43 "compilador.l" +{nl++;} + YY_BREAK +case 2: +YY_RULE_SETUP +#line 45 "compilador.l" + + YY_BREAK +case 3: +YY_RULE_SETUP +#line 47 "compilador.l" + + YY_BREAK +case 4: +YY_RULE_SETUP +#line 49 "compilador.l" +{ simbolo = simb_program; + strncpy (token, yytext, TAM_TOKEN); + IMPRIME("program "); + return PROGRAM; + } + YY_BREAK +case 5: +YY_RULE_SETUP +#line 55 "compilador.l" +{ simbolo = simb_var; + strncpy (token, yytext, TAM_TOKEN); + IMPRIME("var "); + return VAR; + } + YY_BREAK +case 6: +YY_RULE_SETUP +#line 61 "compilador.l" +{ simbolo = simb_begin; + strncpy (token, yytext, TAM_TOKEN); + IMPRIME("begin "); + return T_BEGIN; + } + YY_BREAK +case 7: +YY_RULE_SETUP +#line 67 "compilador.l" +{ simbolo = simb_end; + strncpy (token, yytext, TAM_TOKEN); + IMPRIME("end "); + return T_END; + } + YY_BREAK +case 8: +YY_RULE_SETUP +#line 73 "compilador.l" +{ simbolo = simb_read; + strncpy (token, yytext, TAM_TOKEN); + IMPRIME("read "); + return READ; +} + YY_BREAK +case 9: +YY_RULE_SETUP +#line 79 "compilador.l" +{ simbolo = simb_write; + strncpy (token, yytext, TAM_TOKEN); + IMPRIME("write "); + return WRITE; +} + YY_BREAK +case 10: +YY_RULE_SETUP +#line 85 "compilador.l" +{ simbolo = simb_atribuicao; + strncpy (token, yytext, TAM_TOKEN); + IMPRIME(" atribuicao "); + return ATRIBUICAO; + } + YY_BREAK +case 11: +YY_RULE_SETUP +#line 91 "compilador.l" +{ simbolo = simb_ponto_e_virgula; + strncpy (token, yytext, TAM_TOKEN); + IMPRIME(" pt_virgula "); + return PONTO_E_VIRGULA; + } + YY_BREAK +case 12: +YY_RULE_SETUP +#line 97 "compilador.l" +{ simbolo = simb_dois_pontos; + strncpy (token, yytext, TAM_TOKEN); + IMPRIME(" dois pontos "); + return DOIS_PONTOS; + } + YY_BREAK +case 13: +YY_RULE_SETUP +#line 103 "compilador.l" +{ simbolo = simb_virgula; + strncpy (token, yytext, TAM_TOKEN); + IMPRIME(" virgula "); + return VIRGULA; + } + YY_BREAK +case 14: +YY_RULE_SETUP +#line 110 "compilador.l" +{ simbolo = simb_ponto; + strncpy (token, yytext, TAM_TOKEN); + IMPRIME(" ponto "); + return PONTO; + } + YY_BREAK +case 15: +YY_RULE_SETUP +#line 116 "compilador.l" +{ simbolo = simb_abre_parenteses; + strncpy (token, yytext, TAM_TOKEN); + IMPRIME(" abre_parenteses "); + return ABRE_PARENTESES; + } + YY_BREAK +case 16: +YY_RULE_SETUP +#line 122 "compilador.l" +{ simbolo = simb_fecha_parenteses; + strncpy (token, yytext, TAM_TOKEN); + IMPRIME(" fecha_parenteses "); + return FECHA_PARENTESES; + } + YY_BREAK +case 17: +YY_RULE_SETUP +#line 128 "compilador.l" +{ simbolo = simb_label; + strncpy (token, yytext, TAM_TOKEN); + IMPRIME("label "); + return LABEL; + } + YY_BREAK +case 18: +YY_RULE_SETUP +#line 134 "compilador.l" +{ simbolo = simb_type; + strncpy (token, yytext, TAM_TOKEN); + IMPRIME("type "); + return TYPE; + } + YY_BREAK +case 19: +YY_RULE_SETUP +#line 140 "compilador.l" +{ simbolo = simb_array; + strncpy (token, yytext, TAM_TOKEN); + IMPRIME("array "); + return ARRAY; + } + YY_BREAK +case 20: +YY_RULE_SETUP +#line 146 "compilador.l" +{ simbolo = simb_procedure; + strncpy (token, yytext, TAM_TOKEN); + IMPRIME("procedure "); + return PROCEDURE; + } + YY_BREAK +case 21: +YY_RULE_SETUP +#line 152 "compilador.l" +{ simbolo = simb_function; + strncpy (token, yytext, TAM_TOKEN); + IMPRIME("function "); + return FUNCTION; + } + YY_BREAK +case 22: +YY_RULE_SETUP +#line 158 "compilador.l" +{ simbolo = simb_goto; + strncpy (token, yytext, TAM_TOKEN); + IMPRIME("goto "); + return GOTO; + } + YY_BREAK +case 23: +YY_RULE_SETUP +#line 164 "compilador.l" +{ simbolo = simb_if; + strncpy (token, yytext, TAM_TOKEN); + IMPRIME("if "); + return IF; + } + YY_BREAK +case 24: +YY_RULE_SETUP +#line 170 "compilador.l" +{ simbolo = simb_then; + strncpy (token, yytext, TAM_TOKEN); + IMPRIME(" then "); + return THEN; + } + YY_BREAK +case 25: +YY_RULE_SETUP +#line 176 "compilador.l" +{ simbolo = simb_else; + strncpy (token, yytext, TAM_TOKEN); + IMPRIME(" else "); + return ELSE; + } + YY_BREAK +case 26: +YY_RULE_SETUP +#line 182 "compilador.l" +{ simbolo = simb_while; + strncpy (token, yytext, TAM_TOKEN); + IMPRIME("while "); + return WHILE; + } + YY_BREAK +case 27: +YY_RULE_SETUP +#line 188 "compilador.l" +{ simbolo = simb_do; + strncpy (token, yytext, TAM_TOKEN); + IMPRIME(" do "); + return DO; + } + YY_BREAK +case 28: +YY_RULE_SETUP +#line 194 "compilador.l" +{ simbolo = simb_or; + strncpy (token, yytext, TAM_TOKEN); + IMPRIME(" or "); + return OR; + } + YY_BREAK +case 29: +YY_RULE_SETUP +#line 200 "compilador.l" +{ simbolo = simb_div; + strncpy (token, yytext, TAM_TOKEN); + IMPRIME(" div "); + return DIV; + } + YY_BREAK +case 30: +YY_RULE_SETUP +#line 206 "compilador.l" +{ simbolo = simb_and; + strncpy (token, yytext, TAM_TOKEN); + IMPRIME(" and "); + return AND; + } + YY_BREAK +case 31: +YY_RULE_SETUP +#line 212 "compilador.l" +{ simbolo = simb_not; + strncpy (token, yytext, TAM_TOKEN); + IMPRIME(" not "); + return NOT; + } + YY_BREAK +case 32: +YY_RULE_SETUP +#line 218 "compilador.l" +{ simbolo = simb_igual; + strncpy (token, yytext, TAM_TOKEN); + IMPRIME(" igual "); + return IGUAL; + } + YY_BREAK +case 33: +YY_RULE_SETUP +#line 224 "compilador.l" +{ simbolo = simb_diferente; + strncpy (token, yytext, TAM_TOKEN); + IMPRIME(" diferente "); + return DIFERENTE; + } + YY_BREAK +case 34: +YY_RULE_SETUP +#line 230 "compilador.l" +{ simbolo = simb_menor_igual; + strncpy (token, yytext, TAM_TOKEN); + IMPRIME(" menor_igual "); + return MENOR_IGUAL; + } + YY_BREAK +case 35: +YY_RULE_SETUP +#line 236 "compilador.l" +{ simbolo = simb_maior_igual; + strncpy (token, yytext, TAM_TOKEN); + IMPRIME(" maior_igual "); + return MAIOR_IGUAL; + } + YY_BREAK +case 36: +YY_RULE_SETUP +#line 242 "compilador.l" +{ simbolo = simb_menor; + strncpy (token, yytext, TAM_TOKEN); + IMPRIME(" menor "); + return MENOR; + } + YY_BREAK +case 37: +YY_RULE_SETUP +#line 248 "compilador.l" +{ simbolo = simb_maior; + strncpy (token, yytext, TAM_TOKEN); + IMPRIME(" maior "); + return MAIOR; + } + YY_BREAK +case 38: +YY_RULE_SETUP +#line 254 "compilador.l" +{ simbolo = simb_mais; + strncpy (token, yytext, TAM_TOKEN); + IMPRIME(" mais "); + return MAIS; + } + YY_BREAK +case 39: +YY_RULE_SETUP +#line 260 "compilador.l" +{ simbolo = simb_menos; + strncpy (token, yytext, TAM_TOKEN); + IMPRIME(" menos "); + return MENOS; + } + YY_BREAK +case 40: +YY_RULE_SETUP +#line 266 "compilador.l" +{ simbolo = simb_asterisco; + strncpy (token, yytext, TAM_TOKEN); + IMPRIME(" asterisco "); + return ASTERISCO; + } + YY_BREAK +case 41: +YY_RULE_SETUP +#line 272 "compilador.l" +{ simbolo = simb_numero; + strncpy (token, yytext,TAM_TOKEN); + IMPRIME(" numero "); + return NUMERO; + } + YY_BREAK +case 42: +YY_RULE_SETUP +#line 278 "compilador.l" +{ simbolo = simb_identificador; + strncpy (token, yytext, TAM_TOKEN); + IMPRIME(" ident "); + return IDENT; + } + YY_BREAK +case 43: +YY_RULE_SETUP +#line 284 "compilador.l" +ECHO; + YY_BREAK +#line 1190 "lex.yy.c" +case YY_STATE_EOF(INITIAL): + yyterminate(); + + case YY_END_OF_BUFFER: + { + /* Amount of text matched not including the EOB char. */ + int yy_amount_of_matched_text = (int) (yy_cp - (yytext_ptr)) - 1; + + /* Undo the effects of YY_DO_BEFORE_ACTION. */ + *yy_cp = (yy_hold_char); + YY_RESTORE_YY_MORE_OFFSET + + if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_NEW ) + { + /* We're scanning a new file or input source. It's + * possible that this happened because the user + * just pointed yyin at a new source and called + * yylex(). If so, then we have to assure + * consistency between YY_CURRENT_BUFFER and our + * globals. Here is the right place to do so, because + * this is the first action (other than possibly a + * back-up) that will match for the new input source. + */ + (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars; + YY_CURRENT_BUFFER_LVALUE->yy_input_file = yyin; + YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_NORMAL; + } + + /* Note that here we test for yy_c_buf_p "<=" to the position + * of the first EOB in the buffer, since yy_c_buf_p will + * already have been incremented past the NUL character + * (since all states make transitions on EOB to the + * end-of-buffer state). Contrast this with the test + * in input(). + */ + if ( (yy_c_buf_p) <= &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] ) + { /* This was really a NUL. */ + yy_state_type yy_next_state; + + (yy_c_buf_p) = (yytext_ptr) + yy_amount_of_matched_text; + + yy_current_state = yy_get_previous_state( ); + + /* Okay, we're now positioned to make the NUL + * transition. We couldn't have + * yy_get_previous_state() go ahead and do it + * for us because it doesn't know how to deal + * with the possibility of jamming (and we don't + * want to build jamming into it because then it + * will run more slowly). + */ + + yy_next_state = yy_try_NUL_trans( yy_current_state ); + + yy_bp = (yytext_ptr) + YY_MORE_ADJ; + + if ( yy_next_state ) + { + /* Consume the NUL. */ + yy_cp = ++(yy_c_buf_p); + yy_current_state = yy_next_state; + goto yy_match; + } + + else + { + yy_cp = (yy_c_buf_p); + goto yy_find_action; + } + } + + else switch ( yy_get_next_buffer( ) ) + { + case EOB_ACT_END_OF_FILE: + { + (yy_did_buffer_switch_on_eof) = 0; + + if ( yywrap( ) ) + { + /* Note: because we've taken care in + * yy_get_next_buffer() to have set up + * yytext, we can now set up + * yy_c_buf_p so that if some total + * hoser (like flex itself) wants to + * call the scanner after we return the + * YY_NULL, it'll still work - another + * YY_NULL will get returned. + */ + (yy_c_buf_p) = (yytext_ptr) + YY_MORE_ADJ; + + yy_act = YY_STATE_EOF(YY_START); + goto do_action; + } + + else + { + if ( ! (yy_did_buffer_switch_on_eof) ) + YY_NEW_FILE; + } + break; + } + + case EOB_ACT_CONTINUE_SCAN: + (yy_c_buf_p) = + (yytext_ptr) + yy_amount_of_matched_text; + + yy_current_state = yy_get_previous_state( ); + + yy_cp = (yy_c_buf_p); + yy_bp = (yytext_ptr) + YY_MORE_ADJ; + goto yy_match; + + case EOB_ACT_LAST_MATCH: + (yy_c_buf_p) = + &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)]; + + yy_current_state = yy_get_previous_state( ); + + yy_cp = (yy_c_buf_p); + yy_bp = (yytext_ptr) + YY_MORE_ADJ; + goto yy_find_action; + } + break; + } + + default: + YY_FATAL_ERROR( + "fatal flex scanner internal error--no action found" ); + } /* end of action switch */ + } /* end of scanning one token */ + } /* end of user's declarations */ +} /* end of yylex */ + +/* yy_get_next_buffer - try to read in a new buffer + * + * Returns a code representing an action: + * EOB_ACT_LAST_MATCH - + * EOB_ACT_CONTINUE_SCAN - continue scanning from current position + * EOB_ACT_END_OF_FILE - end of file + */ +static int yy_get_next_buffer (void) +{ + char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf; + char *source = (yytext_ptr); + int number_to_move, i; + int ret_val; + + if ( (yy_c_buf_p) > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] ) + YY_FATAL_ERROR( + "fatal flex scanner internal error--end of buffer missed" ); + + if ( YY_CURRENT_BUFFER_LVALUE->yy_fill_buffer == 0 ) + { /* Don't try to fill the buffer, so this is an EOF. */ + if ( (yy_c_buf_p) - (yytext_ptr) - YY_MORE_ADJ == 1 ) + { + /* We matched a single character, the EOB, so + * treat this as a final EOF. + */ + return EOB_ACT_END_OF_FILE; + } + + else + { + /* We matched some text prior to the EOB, first + * process it. + */ + return EOB_ACT_LAST_MATCH; + } + } + + /* Try to read more data. */ + + /* First move last chars to start of buffer. */ + number_to_move = (int) ((yy_c_buf_p) - (yytext_ptr) - 1); + + for ( i = 0; i < number_to_move; ++i ) + *(dest++) = *(source++); + + if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_EOF_PENDING ) + /* don't do the read, it's not guaranteed to return an EOF, + * just force an EOF + */ + YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars) = 0; + + else + { + int num_to_read = + YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1; + + while ( num_to_read <= 0 ) + { /* Not enough room in the buffer - grow it. */ + + /* just a shorter name for the current buffer */ + YY_BUFFER_STATE b = YY_CURRENT_BUFFER_LVALUE; + + int yy_c_buf_p_offset = + (int) ((yy_c_buf_p) - b->yy_ch_buf); + + if ( b->yy_is_our_buffer ) + { + int new_size = b->yy_buf_size * 2; + + if ( new_size <= 0 ) + b->yy_buf_size += b->yy_buf_size / 8; + else + b->yy_buf_size *= 2; + + b->yy_ch_buf = (char *) + /* Include room in for 2 EOB chars. */ + yyrealloc( (void *) b->yy_ch_buf, + (yy_size_t) (b->yy_buf_size + 2) ); + } + else + /* Can't grow it, we don't own it. */ + b->yy_ch_buf = NULL; + + if ( ! b->yy_ch_buf ) + YY_FATAL_ERROR( + "fatal error - scanner input buffer overflow" ); + + (yy_c_buf_p) = &b->yy_ch_buf[yy_c_buf_p_offset]; + + num_to_read = YY_CURRENT_BUFFER_LVALUE->yy_buf_size - + number_to_move - 1; + + } + + if ( num_to_read > YY_READ_BUF_SIZE ) + num_to_read = YY_READ_BUF_SIZE; + + /* Read in more data. */ + YY_INPUT( (&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]), + (yy_n_chars), num_to_read ); + + YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars); + } + + if ( (yy_n_chars) == 0 ) + { + if ( number_to_move == YY_MORE_ADJ ) + { + ret_val = EOB_ACT_END_OF_FILE; + yyrestart( yyin ); + } + + else + { + ret_val = EOB_ACT_LAST_MATCH; + YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = + YY_BUFFER_EOF_PENDING; + } + } + + else + ret_val = EOB_ACT_CONTINUE_SCAN; + + if (((yy_n_chars) + number_to_move) > YY_CURRENT_BUFFER_LVALUE->yy_buf_size) { + /* Extend the array by 50%, plus the number we really need. */ + int new_size = (yy_n_chars) + number_to_move + ((yy_n_chars) >> 1); + YY_CURRENT_BUFFER_LVALUE->yy_ch_buf = (char *) yyrealloc( + (void *) YY_CURRENT_BUFFER_LVALUE->yy_ch_buf, (yy_size_t) new_size ); + if ( ! YY_CURRENT_BUFFER_LVALUE->yy_ch_buf ) + YY_FATAL_ERROR( "out of dynamic memory in yy_get_next_buffer()" ); + /* "- 2" to take care of EOB's */ + YY_CURRENT_BUFFER_LVALUE->yy_buf_size = (int) (new_size - 2); + } + + (yy_n_chars) += number_to_move; + YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] = YY_END_OF_BUFFER_CHAR; + YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] = YY_END_OF_BUFFER_CHAR; + + (yytext_ptr) = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[0]; + + return ret_val; +} + +/* yy_get_previous_state - get the state just before the EOB char was reached */ + + static yy_state_type yy_get_previous_state (void) +{ + yy_state_type yy_current_state; + char *yy_cp; + + yy_current_state = (yy_start); + + for ( yy_cp = (yytext_ptr) + YY_MORE_ADJ; yy_cp < (yy_c_buf_p); ++yy_cp ) + { + YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1); + if ( yy_accept[yy_current_state] ) + { + (yy_last_accepting_state) = yy_current_state; + (yy_last_accepting_cpos) = yy_cp; + } + while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) + { + yy_current_state = (int) yy_def[yy_current_state]; + if ( yy_current_state >= 115 ) + yy_c = yy_meta[yy_c]; + } + yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c]; + } + + return yy_current_state; +} + +/* yy_try_NUL_trans - try to make a transition on the NUL character + * + * synopsis + * next_state = yy_try_NUL_trans( current_state ); + */ + static yy_state_type yy_try_NUL_trans (yy_state_type yy_current_state ) +{ + int yy_is_jam; + char *yy_cp = (yy_c_buf_p); + + YY_CHAR yy_c = 1; + if ( yy_accept[yy_current_state] ) + { + (yy_last_accepting_state) = yy_current_state; + (yy_last_accepting_cpos) = yy_cp; + } + while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) + { + yy_current_state = (int) yy_def[yy_current_state]; + if ( yy_current_state >= 115 ) + yy_c = yy_meta[yy_c]; + } + yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c]; + yy_is_jam = (yy_current_state == 114); + + return yy_is_jam ? 0 : yy_current_state; +} + +#ifndef YY_NO_UNPUT + + static void yyunput (int c, char * yy_bp ) +{ + char *yy_cp; + + yy_cp = (yy_c_buf_p); + + /* undo effects of setting up yytext */ + *yy_cp = (yy_hold_char); + + if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 ) + { /* need to shift things up to make room */ + /* +2 for EOB chars. */ + int number_to_move = (yy_n_chars) + 2; + char *dest = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[ + YY_CURRENT_BUFFER_LVALUE->yy_buf_size + 2]; + char *source = + &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]; + + while ( source > YY_CURRENT_BUFFER_LVALUE->yy_ch_buf ) + *--dest = *--source; + + yy_cp += (int) (dest - source); + yy_bp += (int) (dest - source); + YY_CURRENT_BUFFER_LVALUE->yy_n_chars = + (yy_n_chars) = (int) YY_CURRENT_BUFFER_LVALUE->yy_buf_size; + + if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 ) + YY_FATAL_ERROR( "flex scanner push-back overflow" ); + } + + *--yy_cp = (char) c; + + (yytext_ptr) = yy_bp; + (yy_hold_char) = *yy_cp; + (yy_c_buf_p) = yy_cp; +} + +#endif + +#ifndef YY_NO_INPUT +#ifdef __cplusplus + static int yyinput (void) +#else + static int input (void) +#endif + +{ + int c; + + *(yy_c_buf_p) = (yy_hold_char); + + if ( *(yy_c_buf_p) == YY_END_OF_BUFFER_CHAR ) + { + /* yy_c_buf_p now points to the character we want to return. + * If this occurs *before* the EOB characters, then it's a + * valid NUL; if not, then we've hit the end of the buffer. + */ + if ( (yy_c_buf_p) < &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] ) + /* This was really a NUL. */ + *(yy_c_buf_p) = '\0'; + + else + { /* need more input */ + int offset = (int) ((yy_c_buf_p) - (yytext_ptr)); + ++(yy_c_buf_p); + + switch ( yy_get_next_buffer( ) ) + { + case EOB_ACT_LAST_MATCH: + /* This happens because yy_g_n_b() + * sees that we've accumulated a + * token and flags that we need to + * try matching the token before + * proceeding. But for input(), + * there's no matching to consider. + * So convert the EOB_ACT_LAST_MATCH + * to EOB_ACT_END_OF_FILE. + */ + + /* Reset buffer status. */ + yyrestart( yyin ); + + /*FALLTHROUGH*/ + + case EOB_ACT_END_OF_FILE: + { + if ( yywrap( ) ) + return 0; + + if ( ! (yy_did_buffer_switch_on_eof) ) + YY_NEW_FILE; +#ifdef __cplusplus + return yyinput(); +#else + return input(); +#endif + } + + case EOB_ACT_CONTINUE_SCAN: + (yy_c_buf_p) = (yytext_ptr) + offset; + break; + } + } + } + + c = *(unsigned char *) (yy_c_buf_p); /* cast for 8-bit char's */ + *(yy_c_buf_p) = '\0'; /* preserve yytext */ + (yy_hold_char) = *++(yy_c_buf_p); + + return c; +} +#endif /* ifndef YY_NO_INPUT */ + +/** Immediately switch to a different input stream. + * @param input_file A readable stream. + * + * @note This function does not reset the start condition to @c INITIAL . + */ + void yyrestart (FILE * input_file ) +{ + + if ( ! YY_CURRENT_BUFFER ){ + yyensure_buffer_stack (); + YY_CURRENT_BUFFER_LVALUE = + yy_create_buffer( yyin, YY_BUF_SIZE ); + } + + yy_init_buffer( YY_CURRENT_BUFFER, input_file ); + yy_load_buffer_state( ); +} + +/** Switch to a different input buffer. + * @param new_buffer The new input buffer. + * + */ + void yy_switch_to_buffer (YY_BUFFER_STATE new_buffer ) +{ + + /* TODO. We should be able to replace this entire function body + * with + * yypop_buffer_state(); + * yypush_buffer_state(new_buffer); + */ + yyensure_buffer_stack (); + if ( YY_CURRENT_BUFFER == new_buffer ) + return; + + if ( YY_CURRENT_BUFFER ) + { + /* Flush out information for old buffer. */ + *(yy_c_buf_p) = (yy_hold_char); + YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p); + YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars); + } + + YY_CURRENT_BUFFER_LVALUE = new_buffer; + yy_load_buffer_state( ); + + /* We don't actually know whether we did this switch during + * EOF (yywrap()) processing, but the only time this flag + * is looked at is after yywrap() is called, so it's safe + * to go ahead and always set it. + */ + (yy_did_buffer_switch_on_eof) = 1; +} + +static void yy_load_buffer_state (void) +{ + (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars; + (yytext_ptr) = (yy_c_buf_p) = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos; + yyin = YY_CURRENT_BUFFER_LVALUE->yy_input_file; + (yy_hold_char) = *(yy_c_buf_p); +} + +/** Allocate and initialize an input buffer state. + * @param file A readable stream. + * @param size The character buffer size in bytes. When in doubt, use @c YY_BUF_SIZE. + * + * @return the allocated buffer state. + */ + YY_BUFFER_STATE yy_create_buffer (FILE * file, int size ) +{ + YY_BUFFER_STATE b; + + b = (YY_BUFFER_STATE) yyalloc( sizeof( struct yy_buffer_state ) ); + if ( ! b ) + YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" ); + + b->yy_buf_size = size; + + /* yy_ch_buf has to be 2 characters longer than the size given because + * we need to put in 2 end-of-buffer characters. + */ + b->yy_ch_buf = (char *) yyalloc( (yy_size_t) (b->yy_buf_size + 2) ); + if ( ! b->yy_ch_buf ) + YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" ); + + b->yy_is_our_buffer = 1; + + yy_init_buffer( b, file ); + + return b; +} + +/** Destroy the buffer. + * @param b a buffer created with yy_create_buffer() + * + */ + void yy_delete_buffer (YY_BUFFER_STATE b ) +{ + + if ( ! b ) + return; + + if ( b == YY_CURRENT_BUFFER ) /* Not sure if we should pop here. */ + YY_CURRENT_BUFFER_LVALUE = (YY_BUFFER_STATE) 0; + + if ( b->yy_is_our_buffer ) + yyfree( (void *) b->yy_ch_buf ); + + yyfree( (void *) b ); +} + +/* Initializes or reinitializes a buffer. + * This function is sometimes called more than once on the same buffer, + * such as during a yyrestart() or at EOF. + */ + static void yy_init_buffer (YY_BUFFER_STATE b, FILE * file ) + +{ + int oerrno = errno; + + yy_flush_buffer( b ); + + b->yy_input_file = file; + b->yy_fill_buffer = 1; + + /* If b is the current buffer, then yy_init_buffer was _probably_ + * called from yyrestart() or through yy_get_next_buffer. + * In that case, we don't want to reset the lineno or column. + */ + if (b != YY_CURRENT_BUFFER){ + b->yy_bs_lineno = 1; + b->yy_bs_column = 0; + } + + b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0; + + errno = oerrno; +} + +/** Discard all buffered characters. On the next scan, YY_INPUT will be called. + * @param b the buffer state to be flushed, usually @c YY_CURRENT_BUFFER. + * + */ + void yy_flush_buffer (YY_BUFFER_STATE b ) +{ + if ( ! b ) + return; + + b->yy_n_chars = 0; + + /* We always need two end-of-buffer characters. The first causes + * a transition to the end-of-buffer state. The second causes + * a jam in that state. + */ + b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR; + b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR; + + b->yy_buf_pos = &b->yy_ch_buf[0]; + + b->yy_at_bol = 1; + b->yy_buffer_status = YY_BUFFER_NEW; + + if ( b == YY_CURRENT_BUFFER ) + yy_load_buffer_state( ); +} + +/** Pushes the new state onto the stack. The new state becomes + * the current state. This function will allocate the stack + * if necessary. + * @param new_buffer The new state. + * + */ +void yypush_buffer_state (YY_BUFFER_STATE new_buffer ) +{ + if (new_buffer == NULL) + return; + + yyensure_buffer_stack(); + + /* This block is copied from yy_switch_to_buffer. */ + if ( YY_CURRENT_BUFFER ) + { + /* Flush out information for old buffer. */ + *(yy_c_buf_p) = (yy_hold_char); + YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p); + YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars); + } + + /* Only push if top exists. Otherwise, replace top. */ + if (YY_CURRENT_BUFFER) + (yy_buffer_stack_top)++; + YY_CURRENT_BUFFER_LVALUE = new_buffer; + + /* copied from yy_switch_to_buffer. */ + yy_load_buffer_state( ); + (yy_did_buffer_switch_on_eof) = 1; +} + +/** Removes and deletes the top of the stack, if present. + * The next element becomes the new top. + * + */ +void yypop_buffer_state (void) +{ + if (!YY_CURRENT_BUFFER) + return; + + yy_delete_buffer(YY_CURRENT_BUFFER ); + YY_CURRENT_BUFFER_LVALUE = NULL; + if ((yy_buffer_stack_top) > 0) + --(yy_buffer_stack_top); + + if (YY_CURRENT_BUFFER) { + yy_load_buffer_state( ); + (yy_did_buffer_switch_on_eof) = 1; + } +} + +/* Allocates the stack if it does not exist. + * Guarantees space for at least one push. + */ +static void yyensure_buffer_stack (void) +{ + yy_size_t num_to_alloc; + + if (!(yy_buffer_stack)) { + + /* First allocation is just for 2 elements, since we don't know if this + * scanner will even need a stack. We use 2 instead of 1 to avoid an + * immediate realloc on the next call. + */ + num_to_alloc = 1; /* After all that talk, this was set to 1 anyways... */ + (yy_buffer_stack) = (struct yy_buffer_state**)yyalloc + (num_to_alloc * sizeof(struct yy_buffer_state*) + ); + if ( ! (yy_buffer_stack) ) + YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" ); + + memset((yy_buffer_stack), 0, num_to_alloc * sizeof(struct yy_buffer_state*)); + + (yy_buffer_stack_max) = num_to_alloc; + (yy_buffer_stack_top) = 0; + return; + } + + if ((yy_buffer_stack_top) >= ((yy_buffer_stack_max)) - 1){ + + /* Increase the buffer to prepare for a possible push. */ + yy_size_t grow_size = 8 /* arbitrary grow size */; + + num_to_alloc = (yy_buffer_stack_max) + grow_size; + (yy_buffer_stack) = (struct yy_buffer_state**)yyrealloc + ((yy_buffer_stack), + num_to_alloc * sizeof(struct yy_buffer_state*) + ); + if ( ! (yy_buffer_stack) ) + YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" ); + + /* zero only the new slots.*/ + memset((yy_buffer_stack) + (yy_buffer_stack_max), 0, grow_size * sizeof(struct yy_buffer_state*)); + (yy_buffer_stack_max) = num_to_alloc; + } +} + +/** Setup the input buffer state to scan directly from a user-specified character buffer. + * @param base the character buffer + * @param size the size in bytes of the character buffer + * + * @return the newly allocated buffer state object. + */ +YY_BUFFER_STATE yy_scan_buffer (char * base, yy_size_t size ) +{ + YY_BUFFER_STATE b; + + if ( size < 2 || + base[size-2] != YY_END_OF_BUFFER_CHAR || + base[size-1] != YY_END_OF_BUFFER_CHAR ) + /* They forgot to leave room for the EOB's. */ + return NULL; + + b = (YY_BUFFER_STATE) yyalloc( sizeof( struct yy_buffer_state ) ); + if ( ! b ) + YY_FATAL_ERROR( "out of dynamic memory in yy_scan_buffer()" ); + + b->yy_buf_size = (int) (size - 2); /* "- 2" to take care of EOB's */ + b->yy_buf_pos = b->yy_ch_buf = base; + b->yy_is_our_buffer = 0; + b->yy_input_file = NULL; + b->yy_n_chars = b->yy_buf_size; + b->yy_is_interactive = 0; + b->yy_at_bol = 1; + b->yy_fill_buffer = 0; + b->yy_buffer_status = YY_BUFFER_NEW; + + yy_switch_to_buffer( b ); + + return b; +} + +/** Setup the input buffer state to scan a string. The next call to yylex() will + * scan from a @e copy of @a str. + * @param yystr a NUL-terminated string to scan + * + * @return the newly allocated buffer state object. + * @note If you want to scan bytes that may contain NUL values, then use + * yy_scan_bytes() instead. + */ +YY_BUFFER_STATE yy_scan_string (const char * yystr ) +{ + + return yy_scan_bytes( yystr, (int) strlen(yystr) ); +} + +/** Setup the input buffer state to scan the given bytes. The next call to yylex() will + * scan from a @e copy of @a bytes. + * @param yybytes the byte buffer to scan + * @param _yybytes_len the number of bytes in the buffer pointed to by @a bytes. + * + * @return the newly allocated buffer state object. + */ +YY_BUFFER_STATE yy_scan_bytes (const char * yybytes, int _yybytes_len ) +{ + YY_BUFFER_STATE b; + char *buf; + yy_size_t n; + int i; + + /* Get memory for full buffer, including space for trailing EOB's. */ + n = (yy_size_t) (_yybytes_len + 2); + buf = (char *) yyalloc( n ); + if ( ! buf ) + YY_FATAL_ERROR( "out of dynamic memory in yy_scan_bytes()" ); + + for ( i = 0; i < _yybytes_len; ++i ) + buf[i] = yybytes[i]; + + buf[_yybytes_len] = buf[_yybytes_len+1] = YY_END_OF_BUFFER_CHAR; + + b = yy_scan_buffer( buf, n ); + if ( ! b ) + YY_FATAL_ERROR( "bad buffer in yy_scan_bytes()" ); + + /* It's okay to grow etc. this buffer, and we should throw it + * away when we're done. + */ + b->yy_is_our_buffer = 1; + + return b; +} + +#ifndef YY_EXIT_FAILURE +#define YY_EXIT_FAILURE 2 +#endif + +static void yynoreturn yy_fatal_error (const char* msg ) +{ + fprintf( stderr, "%s\n", msg ); + exit( YY_EXIT_FAILURE ); +} + +/* Redefine yyless() so it works in section 3 code. */ + +#undef yyless +#define yyless(n) \ + do \ + { \ + /* Undo effects of setting up yytext. */ \ + int yyless_macro_arg = (n); \ + YY_LESS_LINENO(yyless_macro_arg);\ + yytext[yyleng] = (yy_hold_char); \ + (yy_c_buf_p) = yytext + yyless_macro_arg; \ + (yy_hold_char) = *(yy_c_buf_p); \ + *(yy_c_buf_p) = '\0'; \ + yyleng = yyless_macro_arg; \ + } \ + while ( 0 ) + +/* Accessor methods (get/set functions) to struct members. */ + +/** Get the current line number. + * + */ +int yyget_lineno (void) +{ + + return yylineno; +} + +/** Get the input stream. + * + */ +FILE *yyget_in (void) +{ + return yyin; +} + +/** Get the output stream. + * + */ +FILE *yyget_out (void) +{ + return yyout; +} + +/** Get the length of the current token. + * + */ +int yyget_leng (void) +{ + return yyleng; +} + +/** Get the current token. + * + */ + +char *yyget_text (void) +{ + return yytext; +} + +/** Set the current line number. + * @param _line_number line number + * + */ +void yyset_lineno (int _line_number ) +{ + + yylineno = _line_number; +} + +/** Set the input stream. This does not discard the current + * input buffer. + * @param _in_str A readable stream. + * + * @see yy_switch_to_buffer + */ +void yyset_in (FILE * _in_str ) +{ + yyin = _in_str ; +} + +void yyset_out (FILE * _out_str ) +{ + yyout = _out_str ; +} + +int yyget_debug (void) +{ + return yy_flex_debug; +} + +void yyset_debug (int _bdebug ) +{ + yy_flex_debug = _bdebug ; +} + +static int yy_init_globals (void) +{ + /* Initialization is the same as for the non-reentrant scanner. + * This function is called from yylex_destroy(), so don't allocate here. + */ + + (yy_buffer_stack) = NULL; + (yy_buffer_stack_top) = 0; + (yy_buffer_stack_max) = 0; + (yy_c_buf_p) = NULL; + (yy_init) = 0; + (yy_start) = 0; + +/* Defined in main.c */ +#ifdef YY_STDINIT + yyin = stdin; + yyout = stdout; +#else + yyin = NULL; + yyout = NULL; +#endif + + /* For future reference: Set errno on error, since we are called by + * yylex_init() + */ + return 0; +} + +/* yylex_destroy is for both reentrant and non-reentrant scanners. */ +int yylex_destroy (void) +{ + + /* Pop the buffer stack, destroying each element. */ + while(YY_CURRENT_BUFFER){ + yy_delete_buffer( YY_CURRENT_BUFFER ); + YY_CURRENT_BUFFER_LVALUE = NULL; + yypop_buffer_state(); + } + + /* Destroy the stack itself. */ + yyfree((yy_buffer_stack) ); + (yy_buffer_stack) = NULL; + + /* Reset the globals. This is important in a non-reentrant scanner so the next time + * yylex() is called, initialization will occur. */ + yy_init_globals( ); + + return 0; +} + +/* + * Internal utility routines. + */ + +#ifndef yytext_ptr +static void yy_flex_strncpy (char* s1, const char * s2, int n ) +{ + + int i; + for ( i = 0; i < n; ++i ) + s1[i] = s2[i]; +} +#endif + +#ifdef YY_NEED_STRLEN +static int yy_flex_strlen (const char * s ) +{ + int n; + for ( n = 0; s[n]; ++n ) + ; + + return n; +} +#endif + +void *yyalloc (yy_size_t size ) +{ + return malloc(size); +} + +void *yyrealloc (void * ptr, yy_size_t size ) +{ + + /* The cast to (char *) in the following accommodates both + * implementations that use char* generic pointers, and those + * that use void* generic pointers. It works with the latter + * because both ANSI C and C++ allow castless assignment from + * any pointer type to void*, and deal with argument conversions + * as though doing an assignment. + */ + return realloc(ptr, size); +} + +void yyfree (void * ptr ) +{ + free( (char *) ptr ); /* see yyrealloc() for (char *) cast */ +} + +#define YYTABLES_NAME "yytables" + +#line 284 "compilador.l" + + diff --git a/stack/stack.o b/stack/stack.o new file mode 100644 index 0000000000000000000000000000000000000000..bae33562b9a8f80bca309d0e94ef23b97ef717df Binary files /dev/null and b/stack/stack.o differ diff --git a/ts/ts.c b/ts/ts.c index 72001c7dcd5beb4723c0820cb6a3db15004b0af1..12d505120bdb5868b9b79f5a6b44ab87d5117a23 100644 --- a/ts/ts.c +++ b/ts/ts.c @@ -8,7 +8,7 @@ void inicializa_ts(ts_t *ts){ ts->tam = 0; } -void insere_ts(char *ident, int categ, int nivel, int tipo, int desloc, ts_t *ts){ +void insere_ts(char *ident, int categ, int nivel, info_t info, ts_t *ts){ if(ts == NULL) return; simb_t *new = (simb_t *)malloc(sizeof(simb_t)); @@ -16,8 +16,19 @@ void insere_ts(char *ident, int categ, int nivel, int tipo, int desloc, ts_t *ts strcpy(new->ident, ident); new->categ = categ; new->nivel = nivel; - new->tipo = tipo; - new->desloc = desloc; + if (categ == VS) { + new->info.vs.tipo = info.vs.tipo; + new->info.vs.desloc = info.vs.desloc; + } else if (categ == PR) { + new->info.pr.rot = info.pr.rot; + new->info.pr.quant = info.pr.quant; + new->info.pr.param = (int **)malloc(info.pr.quant * sizeof(int *)); + for (int i = 0; i < info.pr.quant; i++) { + new->info.pr.param[i] = (int *)malloc(2 * sizeof(int)); + new->info.pr.param[i][0] = info.pr.param[i][0]; + new->info.pr.param[i][1] = info.pr.param[i][1]; + } + } new->prox = ts->topo; ts->topo = new; @@ -59,12 +70,12 @@ void atualiza_tipo(int n, int tipo, ts_t *ts){ simb_t *p = ts->topo; for (int i = 0; i < n; ++i){ - p->tipo = tipo; + p->info.vs.tipo = tipo; p = p->prox; } } -void mostra_ts(ts_t *ts) { +/*void mostra_ts(ts_t *ts) { if (ts == NULL || ts->topo == NULL) { printf("Tabela de Símbolos está vazia ou não inicializada.\n"); return; @@ -80,7 +91,7 @@ void mostra_ts(ts_t *ts) { while (p != NULL) { // Identificar o tipo como Inteiro, Boolean ou Indefinido const char *tipoStr; - switch (p->tipo) { + switch (p->info.vs.tipo) { case INTEIRO: tipoStr = "Inteiro"; break; @@ -97,9 +108,9 @@ void mostra_ts(ts_t *ts) { // Imprimir a entrada printf("| %-10s | %-8s | %-8d | %-10s | %-10d |\n", - p->ident, categStr, p->nivel, tipoStr, p->desloc); + p->ident, categStr, p->nivel, tipoStr, p->info.vs.desloc); p = p->prox; } printf("----------------------------------------------------------------------------------\n"); -} \ No newline at end of file +}*/ \ No newline at end of file diff --git a/ts/ts.h b/ts/ts.h index ea0221c5aa527043ed50842df80328f81eb35afb..a3ea8d463e2e2b3477ac26b72ec5882fae460ef4 100644 --- a/ts/ts.h +++ b/ts/ts.h @@ -1,12 +1,27 @@ #ifndef __TS__ #define __TS__ +typedef struct vs_t { + int tipo; + int desloc; +} vs_t; + +typedef struct pr_t { + char *rot; + int quant; + int **param; +} pr_t; + +typedef union info_t { + vs_t vs; + pr_t pr; +} info_t; + typedef struct simb_t { char *ident; int categ; int nivel; - int tipo; - int desloc; // Alterar para outros tipos além de VS + info_t info; struct simb_t *prox; // Corrigido: use explicitamente struct simb_t } simb_t; @@ -26,7 +41,7 @@ typedef struct ts_t { void inicializa_ts(ts_t *ts); -void insere_ts(char *ident, int categ, int nivel, int tipo, int desloc, ts_t *ts); +void insere_ts(char *ident, int categ, int nivel, info_t info, ts_t *ts); simb_t *busca(char *ident, ts_t *ts); // Corrigido: retorna ponteiro para simb_t @@ -34,6 +49,6 @@ void retira(int n, ts_t *ts); void atualiza_tipo(int n, int tipo, ts_t *ts); -void mostra_ts(ts_t *ts); +//void mostra_ts(ts_t *ts); #endif diff --git a/ts/ts.o b/ts/ts.o new file mode 100644 index 0000000000000000000000000000000000000000..45b0d9bc32a2d071f4485b2ad49fcf11a902a84a Binary files /dev/null and b/ts/ts.o differ