From ed32f5dba4e25b9d9f106529667c8fec70e38c83 Mon Sep 17 00:00:00 2001 From: brayvasq Date: Sun, 26 Aug 2018 17:49:58 -0500 Subject: [PATCH 1/4] =?UTF-8?q?analizador=20l=C3=A9xico?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .gitignore | 5 ++ Modelo/__init__.py | 0 Modelo/lexico.py | 219 +++++++++++++++++++++++++++++++++++++++++++++ README.md | 13 ++- tokens_lexico.txt | 176 ++++++++++++++++++++++++++++++++++++ 5 files changed, 412 insertions(+), 1 deletion(-) create mode 100644 Modelo/__init__.py create mode 100644 Modelo/lexico.py create mode 100644 tokens_lexico.txt diff --git a/.gitignore b/.gitignore index 894a44c..f0909f9 100644 --- a/.gitignore +++ b/.gitignore @@ -6,6 +6,11 @@ __pycache__/ # C extensions *.so +# IDES +.idea/ +.project +.pydevproject + # Distribution / packaging .Python build/ diff --git a/Modelo/__init__.py b/Modelo/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/Modelo/lexico.py b/Modelo/lexico.py new file mode 100644 index 0000000..6d31360 --- /dev/null +++ b/Modelo/lexico.py @@ -0,0 +1,219 @@ +import ply.lex as lex +import sys + +keywords = { + #LLAVE = value VALOR = TOKEN + 'BEGIN' : 'BEGIN', + 'END' : 'END', + 'VAR' : 'VAR', + 'INTEGER' : 'INTEGER', + 'DOUBLE' : 'DOUBLE', + 'STRING' : 'STRING', + 'BOOLEAN' : 'BOOLEAN', + 'FOR' : 'FOR', + 'WHILE' : 'WHILE', + 'REPEAT' : 'REPEAT', + 'IF' : 'IF', + 'ELSE' : 'ELSE', + 'PROCEDURE' : 'PROCEDURE', + 'FUNCTION' : 'FUNCTION', + 'E' : 'MODOVALOR', + 'ES' : 'MODOREFERENCIA', + 'CALL' : 'CALL', + 'MOD' : 'MOD', + 'FLOOR' : 'FLOOR', + 'CEIL' : 'CEIL', + 'DIV' : 'DIV', + 'AND' : 'AND', + 'OR' : 'OR', + 'NOT' : 'NOT', + 'NULL' : 'NULL', + 'T' : 'TRUE', + 'F' : 'FALSE', + 'LENGTH' : 'LENGTH', + 'RECORD' : 'RECORD', + 'STACK' : 'STACK', + 'QUEUE' : 'QUEUE', + 'LIST' : 'LIST', + 'GRAPH' : 'GRAPH', + 'TO' : 'TO', + 'DO' : 'DO', + 'WRITELN' : 'WRITELN', + 'THEN' : 'THEN', + 'UNTIL' : 'UNTIL', + 'STR' : 'STR', + 'RETURN' : 'RETURN' + } + +tokens = [ + 'COMENTARIO', + 'ID', + 'DOUBLEVAL', + 'INTEGERVAL', + 'STRINGVAL', + 'ASIGNACION', + 'POR', + 'DIVIDIR', + 'MAS', + 'MENOS', + 'PA', + 'PC', + 'MENORIGUAL', + 'MENOR', + 'MAYORIGUAL', + 'MAYOR', + 'IGUAL', + 'DIFERENTE', + 'ARRAY', + 'SUBARRAY', + 'PUNTOCOMA', + 'PUNTO', + 'DOSPUNTOS', + 'COMA' + + ] + list(keywords.values()) + + + +def t_COMENTARIO(t): + r'\#.*' # el caracter numerico junto a cualquier otra cosa exepto una nueva linea (.), 0 o muchas veces (*) + pass + # No retornamos nada, porque descartamos el token + + +def t_ID(t): + r'[a-zA-Z_][a-zA-Z_0-9]*' + t.type = keywords.get(t.value, 'ID') #Si no esta en las palabras reservadas retornamos el ID + #Sino la palabra reservada + return t + +def t_DOUBLEVAL(t): + r'\d+\.\d+' + t.value = float(t.value) + return t + +def t_INTEGERVAL(t): + r'\d+' + t.value = int(t.value) + return t + +def t_STRINGVAL(t): + r'\"(\s*\w*\_*\+*\-*\.*\,*\€*\!*\@*\#*\$*\%*\^*\**\(*\)*\;*\:*\\*\/*\|*\<*\>*\!*\¡*\?*\¿*\}*\{*\[*\]*\~*)*\"' + t.value = str(t.value) + #t.value = t.value.replace("\"","") # quitamos las comillas + + return t + + + +t_ASIGNACION = r'\<--' +t_POR = r'\*' +t_DIVIDIR = r'\/' +t_MAS = r'\+' +t_MENOS = r'-' +t_PA = r'\(' +t_PC = r'\)' +t_MENORIGUAL = r'\<\=' +t_MENOR = r'\<' +t_MAYORIGUAL = r'\>\=' +t_MAYOR = r'\>' +t_IGUAL = r'\=' +t_DIFERENTE = r'\!\=' +t_ARRAY = r'\[\d+\]' +t_SUBARRAY = r'\[\d+\s*\.\.\s*\d+\]' +t_PUNTOCOMA = r'\;' +t_PUNTO = r'\.' +t_DOSPUNTOS = r'\:' +t_COMA = r'\,' + + + +def t_newline(t): + r'\n+' #Regex salto de linea una o mas veces + t.lexer.lineno += len(t.value) + +#Un string que contiene los caracteres que ingnoraremos en este caso los espacios y tabulaciones +t_ignore = ' \t' + +#Regla que manejare los errores, cuando encontramos un caracter no valido +def t_error(t): + print("Caracter invalido '%s'" % t.value[0], file=sys.stderr) #imprimimos como error + t.lexer.skip(1) + + +lexer = lex.lex() + +data = ''' + VAR + x : INT [5]; + y : STACK; + m : QUEUE; + a : LIST; + d : GRAPH; + b : INTEGER; + c : STRING; + e : BOOLEAN; + f : DOUBLE; + BEGIN + e <-- T; + x[2] <-- 5; + b <-- 0; + f <-- 5.0; + FOR i <-- 5 TO 10 DO + BEGIN + WHILE( e != F )DO + BEGIN + REPEAT + b <-- CEIL(b DIV 5); + b <-- FLOOR(b MOD 3); + UNTIL (f >= 10) + END + END + IF( b = 15 )THEN + BEGIN + WRITELN("FUNCIONOOOO GRACIAS A DIOS , DIOS LO BENDIGA " + LENGHT(x)); + ADD(a, 5.023); + a <-- NULL; + #ESTO ES UN HERMOSO COMENTARIO \n + + END + ELSE + BEGIN + WRITELN("NO FUNCIONO, INTENELO DENUEVO CON LA AYUDA DE DIOS "); + END + END + + ''' + +data2 = ''' + VAR \n + x : INTEGER [5]; \n + y : STACK; \n + m : QUEUE; \n + a : LIST; \n + d : GRAPH; \n + b : INTEGER; \n + c : STRING; \n + e : BOOLEAN; \n + f : DOUBLE; \n + BEGIN \n + e <-- STR("HOLA"); \n + x <-- 5; \n + END \n +''' + +lexer.input(data2) +while True: + tok = lexer.token() + + if not tok: + break + print(tok.type, tok.value, tok.lineno, tok.lexpos) + + + + + + + + diff --git a/README.md b/README.md index 321a32d..7c40edd 100644 --- a/README.md +++ b/README.md @@ -1,2 +1,13 @@ # interprete-analisis -Proyecto para la asignatura análisis y diseño de algoritmos +El Objetivo del proyecto propuesto fue desarrollar una herramienta que facilite al usuario el análisis de los algoritmos iterativos. Dicho proyecto debe cumplir con los siguientes requisitos principales: + +- Poseer un editor que permita la escritura de algoritmos iterativos. +- Permitir al usuario seguir el algoritmo paso a paso y visualizar el estado de las variables. +- Permitir al usuario Observar el árbol de ejecución generado. +- Establecer breakpoints (que tiene como función contar las veces que se pasa por la línea marcada) esto para tener un acercamiento de la complejidad del algoritmo digitado. + +En la presente rama está el código fuente del analizador léxico usando la librería PLY. + +##### Requisitos + +- Instalar PLY: `pip install ply` \ No newline at end of file diff --git a/tokens_lexico.txt b/tokens_lexico.txt new file mode 100644 index 0000000..9e93762 --- /dev/null +++ b/tokens_lexico.txt @@ -0,0 +1,176 @@ +**KEYWORDS + +BEGIN BEGIN +END END +VAR VAR + +INTEGER INTEGER +DOUBLE DOUBLE +STRING STRING +BOOLEAN BOOLEAN + + +FOR FOR +WHILE WHILE +REPEAT REPEAT + +IF IF +ELSE ELSE + +THEN +UNTIL + + +PROCEDURE PROCEDURE +FUNCTION FUNCTION +CALL CALL + +MOD MOD +DIV DIV + +AND AND +OR OR +NOT NOT + +NULL NULL + +TRUE T +FALSE F + +MODOVALOR E +MODOREFERENCIA ES + +LENGHT LENGHT + +RECORD RECORD +STACK STACK +QUEUE QUEUE +GRAPH GRAPH +LIST LIST + +ADD ADD +REMOVE REMOVE +SIZE SIZE +GET GET + +ENQUEUE ENQUEUE +DEQUEUE DEQUEUE +GET_Q GET_Q +SIZE_QUEUE SIZE_QUEUE + +PUSH PUSH +POP POP +GET_P GET_P +SIZE_STACK SIZE_STACK + +ADD_NODE ADD_NODE +ADD_TRANS ADD_TRANS +REMOVE_NODE REMOVE_NODE +REMOVE_TRANS REMOVE_TRANS +WIDTH WIDTH +DEEP DEEP + +WRITELN WRITELN + + +FLOOR FLOOR +CEIL CEIL + +TO TO +DO DO + + ++++++++++++++++++++++++++++++ +ID : STACK +ID : QUEUE +ID : GRAPH +ID : LIST + + +----------- LIST --------------------- + ADD(LISTA , Valor); + REMOVE(LISTA, Valor); + SIZE(LISTA); ---> retorna + GET(LISTA, Posicion) ---> retorna + +------------- QUEUE --------------------- + ENQUEUE(COLA, Valor); --> ENCOLAMOS + DEQUEUE(COLA); --> Retornamos eliminando + GET_Q(COLA); --> Retornamos sin eliminar + SIZE_QUEUE(COLA); --> Retornamos tamano de la cola + +------------ STACK ---------------------- + + PUSH(PILA,VALOR); + POP(PILA,VALOR); + GET_P(PILA); + SIZE_STACK(PILA); + +------------GRAPH---------------------------- + ADD_NODE(GRAPH,VALOR); + ADD_TRANS(GRAPH,VALOR,VALOR,VALOR); + REMOVE_NODE(GRAPH,VALOR); + REMOVE_TRANS(GRAPH,VALOR,VALOR,VALOR); + DEEP(GRAPH); + WIDTH(GRAPH); + + +RECORD ID +BEGIN + ID : TIPO + ID2 : TIPO + . + . + . + +END + +++++++++++++++++++++++++++++++++++++++++++++++++++++++++ + + + +ID r'[a-zA-Z_][a-zA-Z_0-9]*' + +INTEGERVAL r'\d+' +STRINGVAL r'\"(\s*\w*\_*\+*\-*\.*\,*\€*\!*\@*\#*\$*\%*\^*\&*\**\(*\)*\;*\:*\\*\/*\|*\<*\>*\!*\¡*\?*\¿*\}*\{*\[*\]*\~*)*\"'# Recordar tomar en cuenta los saltos de linea +DOUBLEVAL r'\d+\.\d+' + + + + +COMENTARIO r'\#.*' + + + + +ASIGNACION <-- r'\<--' + +POR * r'\*' +DIVIDIR / r'\/' +MAS + r'\+' +MENOS - r'-' + + +PA ( r'\(' +PC ) r'\)' + + +MENORIGUAL <= r'\<\=' +MENOR < r'\<' +MAYORIGUAL >= r'\>\=' +MAYOR > r'\>' +IGUAL = r'\=' +DIFERENTE != r'\!\=' + + +ARRAY [] r'\[\d+\]' +SUBARRAY [12312 .. 12312] r'\[\d+\s*\.\.\s*\d+\]' + +PUNTOCOMA r'\;' +PUNTO r'\.' +DOSPUNTOS r'\:' +COMA r'\,' + + + +# falta el de los comentarios From 986322d7b5d9ab8ec04e1c8dc44f3dadbbbc4425 Mon Sep 17 00:00:00 2001 From: brayvasq Date: Sun, 26 Aug 2018 18:00:25 -0500 Subject: [PATCH 2/4] analizador sintactico --- Modelo/lexico.py | 58 +- Modelo/parser.out | 2365 ++++++++++++++++++++++++++++++++++++++++++ Modelo/parsetab.py | 93 ++ Modelo/sintactico.py | 260 +++++ README.md | 2 +- 5 files changed, 2747 insertions(+), 31 deletions(-) create mode 100644 Modelo/parser.out create mode 100644 Modelo/parsetab.py create mode 100644 Modelo/sintactico.py diff --git a/Modelo/lexico.py b/Modelo/lexico.py index 6d31360..8864e8b 100644 --- a/Modelo/lexico.py +++ b/Modelo/lexico.py @@ -36,13 +36,29 @@ 'QUEUE' : 'QUEUE', 'LIST' : 'LIST', 'GRAPH' : 'GRAPH', + 'ADD' : 'ADD', + 'REMOVE' : 'REMOVE', + 'SIZE' : 'SIZE', + 'GET' : 'GET', + 'ENQUEUE' : 'ENQUEUE', + 'DEQUEUE' : 'DEQUEUE', + 'GET_Q' : 'GET_Q', + 'SIZE_QUEUE': 'SIZE_QUEUE', + 'PUSH' : 'PUSH', + 'POP' : 'POP', + 'GET_P' : 'GET_P', + 'SIZES_TACK': 'SIZE_STACK', + 'ADD_NODE' : 'ADD_NODE', + 'ADD_TRANS' : 'ADD_TRANS', + 'REMOVE_NODE' : 'REMOVE_NODE', + 'REMOVE_TRANS' : 'REMOVE_TRANS', + 'WIDTH' : 'WIDTH', + 'DEEP' : 'DEEP', 'TO' : 'TO', 'DO' : 'DO', 'WRITELN' : 'WRITELN', 'THEN' : 'THEN', - 'UNTIL' : 'UNTIL', - 'STR' : 'STR', - 'RETURN' : 'RETURN' + 'UNTIL' : 'UNTIL' } tokens = [ @@ -98,10 +114,8 @@ def t_INTEGERVAL(t): return t def t_STRINGVAL(t): - r'\"(\s*\w*\_*\+*\-*\.*\,*\€*\!*\@*\#*\$*\%*\^*\**\(*\)*\;*\:*\\*\/*\|*\<*\>*\!*\¡*\?*\¿*\}*\{*\[*\]*\~*)*\"' + r'\"(.*)\"' t.value = str(t.value) - #t.value = t.value.replace("\"","") # quitamos las comillas - return t @@ -130,7 +144,7 @@ def t_STRINGVAL(t): def t_newline(t): r'\n+' #Regex salto de linea una o mas veces - t.lexer.lineno += len(t.value) + t.lexer.lineno = len(t.value) #Un string que contiene los caracteres que ingnoraremos en este caso los espacios y tabulaciones t_ignore = ' \t' @@ -145,7 +159,7 @@ def t_error(t): data = ''' VAR - x : INT [5]; + x : [5]; y : STACK; m : QUEUE; a : LIST; @@ -161,7 +175,7 @@ def t_error(t): f <-- 5.0; FOR i <-- 5 TO 10 DO BEGIN - WHILE( e != F )DO + WHILE e != F DO BEGIN REPEAT b <-- CEIL(b DIV 5); @@ -169,7 +183,7 @@ def t_error(t): UNTIL (f >= 10) END END - IF( b = 15 )THEN + IF b = 15 THEN BEGIN WRITELN("FUNCIONOOOO GRACIAS A DIOS , DIOS LO BENDIGA " + LENGHT(x)); ADD(a, 5.023); @@ -184,33 +198,17 @@ def t_error(t): END ''' + +lexer.input(data) -data2 = ''' - VAR \n - x : INTEGER [5]; \n - y : STACK; \n - m : QUEUE; \n - a : LIST; \n - d : GRAPH; \n - b : INTEGER; \n - c : STRING; \n - e : BOOLEAN; \n - f : DOUBLE; \n - BEGIN \n - e <-- STR("HOLA"); \n - x <-- 5; \n - END \n ''' - -lexer.input(data2) while True: tok = lexer.token() - + if not tok: break print(tok.type, tok.value, tok.lineno, tok.lexpos) - - + ''' diff --git a/Modelo/parser.out b/Modelo/parser.out new file mode 100644 index 0000000..79d38d4 --- /dev/null +++ b/Modelo/parser.out @@ -0,0 +1,2365 @@ +Created by PLY version 3.11 (http://www.dabeaz.com/ply) + +Unused terminals: + + ADD + ADD_NODE + ADD_TRANS + AND + ARRAY + ASIGNACION + BEGIN + BOOLEAN + COMENTARIO + DIFERENTE + DO + DOSPUNTOS + DOUBLE + ELSE + END + ENQUEUE + FOR + FUNCTION + GRAPH + IF + IGUAL + INTEGER + LIST + MAYOR + MAYORIGUAL + MENOR + MENORIGUAL + MODOREFERENCIA + MODOVALOR + NOT + NULL + OR + PROCEDURE + PUNTO + PUNTOCOMA + PUSH + QUEUE + RECORD + REMOVE + REMOVE_NODE + REMOVE_TRANS + REPEAT + STACK + STRING + THEN + TO + UNTIL + VAR + WHILE + WRITELN + +Grammar + +Rule 0 S' -> operacion +Rule 1 operacion -> par +Rule 2 operacion -> SUBARRAY +Rule 3 par -> opmath +Rule 4 par -> PA par PC parAux +Rule 5 parAux -> mathsymbol par +Rule 6 parAux -> empty +Rule 7 opmath -> valor +Rule 8 opmath -> valor mathsymbol par +Rule 9 mathsymbol -> MAS +Rule 10 mathsymbol -> MENOS +Rule 11 mathsymbol -> POR +Rule 12 mathsymbol -> DIVIDIR +Rule 13 mathsymbol -> DIV +Rule 14 mathsymbol -> MOD +Rule 15 techo -> CEIL PA opmath PC +Rule 16 piso -> FLOOR PA opmath PC +Rule 17 valor -> ID +Rule 18 valor -> INTEGERVAL +Rule 19 valor -> DOUBLEVAL +Rule 20 valor -> STRINGVAL +Rule 21 valor -> TRUE +Rule 22 valor -> FALSE +Rule 23 valor -> techo +Rule 24 valor -> piso +Rule 25 valor -> longitud +Rule 26 valor -> dequeue +Rule 27 valor -> pop +Rule 28 valor -> get +Rule 29 valor -> getq +Rule 30 valor -> getp +Rule 31 valor -> size +Rule 32 valor -> sizequeue +Rule 33 valor -> sizestack +Rule 34 valor -> deep +Rule 35 valor -> width +Rule 36 valor -> llamar +Rule 37 longitud -> LENGTH PA STRINGVAL PC +Rule 38 dequeue -> DEQUEUE PA ID PC +Rule 39 pop -> POP PA ID PC +Rule 40 get -> GET PA ID COMA INTEGERVAL PC +Rule 41 getq -> GET_P PA ID PC +Rule 42 getp -> GET_Q PA ID PC +Rule 43 size -> SIZE PA ID PC +Rule 44 sizequeue -> SIZE_QUEUE PA ID PC +Rule 45 sizestack -> SIZE_STACK PA ID PC +Rule 46 deep -> DEEP PA ID PC +Rule 47 width -> WIDTH PA ID PC +Rule 48 llamar -> CALL ID PA valoresCall PC +Rule 49 llamar -> CALL ID PA PC +Rule 50 valoresCall -> valor +Rule 51 valoresCall -> valor COMA valoresCall +Rule 52 empty -> +Rule 53 longitud -> LENGTH PA error PC +Rule 54 dequeue -> DEQUEUE PA error PC +Rule 55 pop -> POP PA error PC +Rule 56 get -> GET PA ID COMA error PC +Rule 57 getq -> GET_P PA error PC +Rule 58 getp -> GET_Q PA error PC +Rule 59 size -> SIZE PA error PC +Rule 60 sizequeue -> SIZE_QUEUE PA error PC +Rule 61 sizestack -> SIZE_STACK PA error PC +Rule 62 deep -> DEEP PA error PC +Rule 63 width -> WIDTH PA error PC + +Terminals, with rules where they appear + +ADD : +ADD_NODE : +ADD_TRANS : +AND : +ARRAY : +ASIGNACION : +BEGIN : +BOOLEAN : +CALL : 48 49 +CEIL : 15 +COMA : 40 51 56 +COMENTARIO : +DEEP : 46 62 +DEQUEUE : 38 54 +DIFERENTE : +DIV : 13 +DIVIDIR : 12 +DO : +DOSPUNTOS : +DOUBLE : +DOUBLEVAL : 19 +ELSE : +END : +ENQUEUE : +FALSE : 22 +FLOOR : 16 +FOR : +FUNCTION : +GET : 40 56 +GET_P : 41 57 +GET_Q : 42 58 +GRAPH : +ID : 17 38 39 40 41 42 43 44 45 46 47 48 49 56 +IF : +IGUAL : +INTEGER : +INTEGERVAL : 18 40 +LENGTH : 37 53 +LIST : +MAS : 9 +MAYOR : +MAYORIGUAL : +MENOR : +MENORIGUAL : +MENOS : 10 +MOD : 14 +MODOREFERENCIA : +MODOVALOR : +NOT : +NULL : +OR : +PA : 4 15 16 37 38 39 40 41 42 43 44 45 46 47 48 49 53 54 55 56 57 58 59 60 61 62 63 +PC : 4 15 16 37 38 39 40 41 42 43 44 45 46 47 48 49 53 54 55 56 57 58 59 60 61 62 63 +POP : 39 55 +POR : 11 +PROCEDURE : +PUNTO : +PUNTOCOMA : +PUSH : +QUEUE : +RECORD : +REMOVE : +REMOVE_NODE : +REMOVE_TRANS : +REPEAT : +SIZE : 43 59 +SIZE_QUEUE : 44 60 +SIZE_STACK : 45 61 +STACK : +STRING : +STRINGVAL : 20 37 +SUBARRAY : 2 +THEN : +TO : +TRUE : 21 +UNTIL : +VAR : +WHILE : +WIDTH : 47 63 +WRITELN : +error : 53 54 55 56 57 58 59 60 61 62 63 + +Nonterminals, with rules where they appear + +deep : 34 +dequeue : 26 +empty : 6 +get : 28 +getp : 30 +getq : 29 +llamar : 36 +longitud : 25 +mathsymbol : 5 8 +operacion : 0 +opmath : 3 15 16 +par : 1 4 5 8 +parAux : 4 +piso : 24 +pop : 27 +size : 31 +sizequeue : 32 +sizestack : 33 +techo : 23 +valor : 7 8 50 51 +valoresCall : 48 51 +width : 35 + +Parsing method: LALR + +state 0 + + (0) S' -> . operacion + (1) operacion -> . par + (2) operacion -> . SUBARRAY + (3) par -> . opmath + (4) par -> . PA par PC parAux + (7) opmath -> . valor + (8) opmath -> . valor mathsymbol par + (17) valor -> . ID + (18) valor -> . INTEGERVAL + (19) valor -> . DOUBLEVAL + (20) valor -> . STRINGVAL + (21) valor -> . TRUE + (22) valor -> . FALSE + (23) valor -> . techo + (24) valor -> . piso + (25) valor -> . longitud + (26) valor -> . dequeue + (27) valor -> . pop + (28) valor -> . get + (29) valor -> . getq + (30) valor -> . getp + (31) valor -> . size + (32) valor -> . sizequeue + (33) valor -> . sizestack + (34) valor -> . deep + (35) valor -> . width + (36) valor -> . llamar + (15) techo -> . CEIL PA opmath PC + (16) piso -> . FLOOR PA opmath PC + (37) longitud -> . LENGTH PA STRINGVAL PC + (53) longitud -> . LENGTH PA error PC + (38) dequeue -> . DEQUEUE PA ID PC + (54) dequeue -> . DEQUEUE PA error PC + (39) pop -> . POP PA ID PC + (55) pop -> . POP PA error PC + (40) get -> . GET PA ID COMA INTEGERVAL PC + (56) get -> . GET PA ID COMA error PC + (41) getq -> . GET_P PA ID PC + (57) getq -> . GET_P PA error PC + (42) getp -> . GET_Q PA ID PC + (58) getp -> . GET_Q PA error PC + (43) size -> . SIZE PA ID PC + (59) size -> . SIZE PA error PC + (44) sizequeue -> . SIZE_QUEUE PA ID PC + (60) sizequeue -> . SIZE_QUEUE PA error PC + (45) sizestack -> . SIZE_STACK PA ID PC + (61) sizestack -> . SIZE_STACK PA error PC + (46) deep -> . DEEP PA ID PC + (62) deep -> . DEEP PA error PC + (47) width -> . WIDTH PA ID PC + (63) width -> . WIDTH PA error PC + (48) llamar -> . CALL ID PA valoresCall PC + (49) llamar -> . CALL ID PA PC + + SUBARRAY shift and go to state 3 + PA shift and go to state 5 + ID shift and go to state 7 + INTEGERVAL shift and go to state 8 + DOUBLEVAL shift and go to state 9 + STRINGVAL shift and go to state 10 + TRUE shift and go to state 11 + FALSE shift and go to state 12 + CEIL shift and go to state 27 + FLOOR shift and go to state 28 + LENGTH shift and go to state 29 + DEQUEUE shift and go to state 30 + POP shift and go to state 31 + GET shift and go to state 32 + GET_P shift and go to state 33 + GET_Q shift and go to state 34 + SIZE shift and go to state 35 + SIZE_QUEUE shift and go to state 36 + SIZE_STACK shift and go to state 37 + DEEP shift and go to state 38 + WIDTH shift and go to state 39 + CALL shift and go to state 40 + + operacion shift and go to state 1 + par shift and go to state 2 + opmath shift and go to state 4 + valor shift and go to state 6 + techo shift and go to state 13 + piso shift and go to state 14 + longitud shift and go to state 15 + dequeue shift and go to state 16 + pop shift and go to state 17 + get shift and go to state 18 + getq shift and go to state 19 + getp shift and go to state 20 + size shift and go to state 21 + sizequeue shift and go to state 22 + sizestack shift and go to state 23 + deep shift and go to state 24 + width shift and go to state 25 + llamar shift and go to state 26 + +state 1 + + (0) S' -> operacion . + + + +state 2 + + (1) operacion -> par . + + $end reduce using rule 1 (operacion -> par .) + + +state 3 + + (2) operacion -> SUBARRAY . + + $end reduce using rule 2 (operacion -> SUBARRAY .) + + +state 4 + + (3) par -> opmath . + + $end reduce using rule 3 (par -> opmath .) + PC reduce using rule 3 (par -> opmath .) + + +state 5 + + (4) par -> PA . par PC parAux + (3) par -> . opmath + (4) par -> . PA par PC parAux + (7) opmath -> . valor + (8) opmath -> . valor mathsymbol par + (17) valor -> . ID + (18) valor -> . INTEGERVAL + (19) valor -> . DOUBLEVAL + (20) valor -> . STRINGVAL + (21) valor -> . TRUE + (22) valor -> . FALSE + (23) valor -> . techo + (24) valor -> . piso + (25) valor -> . longitud + (26) valor -> . dequeue + (27) valor -> . pop + (28) valor -> . get + (29) valor -> . getq + (30) valor -> . getp + (31) valor -> . size + (32) valor -> . sizequeue + (33) valor -> . sizestack + (34) valor -> . deep + (35) valor -> . width + (36) valor -> . llamar + (15) techo -> . CEIL PA opmath PC + (16) piso -> . FLOOR PA opmath PC + (37) longitud -> . LENGTH PA STRINGVAL PC + (53) longitud -> . LENGTH PA error PC + (38) dequeue -> . DEQUEUE PA ID PC + (54) dequeue -> . DEQUEUE PA error PC + (39) pop -> . POP PA ID PC + (55) pop -> . POP PA error PC + (40) get -> . GET PA ID COMA INTEGERVAL PC + (56) get -> . GET PA ID COMA error PC + (41) getq -> . GET_P PA ID PC + (57) getq -> . GET_P PA error PC + (42) getp -> . GET_Q PA ID PC + (58) getp -> . GET_Q PA error PC + (43) size -> . SIZE PA ID PC + (59) size -> . SIZE PA error PC + (44) sizequeue -> . SIZE_QUEUE PA ID PC + (60) sizequeue -> . SIZE_QUEUE PA error PC + (45) sizestack -> . SIZE_STACK PA ID PC + (61) sizestack -> . SIZE_STACK PA error PC + (46) deep -> . DEEP PA ID PC + (62) deep -> . DEEP PA error PC + (47) width -> . WIDTH PA ID PC + (63) width -> . WIDTH PA error PC + (48) llamar -> . CALL ID PA valoresCall PC + (49) llamar -> . CALL ID PA PC + + PA shift and go to state 5 + ID shift and go to state 7 + INTEGERVAL shift and go to state 8 + DOUBLEVAL shift and go to state 9 + STRINGVAL shift and go to state 10 + TRUE shift and go to state 11 + FALSE shift and go to state 12 + CEIL shift and go to state 27 + FLOOR shift and go to state 28 + LENGTH shift and go to state 29 + DEQUEUE shift and go to state 30 + POP shift and go to state 31 + GET shift and go to state 32 + GET_P shift and go to state 33 + GET_Q shift and go to state 34 + SIZE shift and go to state 35 + SIZE_QUEUE shift and go to state 36 + SIZE_STACK shift and go to state 37 + DEEP shift and go to state 38 + WIDTH shift and go to state 39 + CALL shift and go to state 40 + + par shift and go to state 41 + opmath shift and go to state 4 + valor shift and go to state 6 + techo shift and go to state 13 + piso shift and go to state 14 + longitud shift and go to state 15 + dequeue shift and go to state 16 + pop shift and go to state 17 + get shift and go to state 18 + getq shift and go to state 19 + getp shift and go to state 20 + size shift and go to state 21 + sizequeue shift and go to state 22 + sizestack shift and go to state 23 + deep shift and go to state 24 + width shift and go to state 25 + llamar shift and go to state 26 + +state 6 + + (7) opmath -> valor . + (8) opmath -> valor . mathsymbol par + (9) mathsymbol -> . MAS + (10) mathsymbol -> . MENOS + (11) mathsymbol -> . POR + (12) mathsymbol -> . DIVIDIR + (13) mathsymbol -> . DIV + (14) mathsymbol -> . MOD + + $end reduce using rule 7 (opmath -> valor .) + PC reduce using rule 7 (opmath -> valor .) + MAS shift and go to state 43 + MENOS shift and go to state 44 + POR shift and go to state 45 + DIVIDIR shift and go to state 46 + DIV shift and go to state 47 + MOD shift and go to state 48 + + mathsymbol shift and go to state 42 + +state 7 + + (17) valor -> ID . + + MAS reduce using rule 17 (valor -> ID .) + MENOS reduce using rule 17 (valor -> ID .) + POR reduce using rule 17 (valor -> ID .) + DIVIDIR reduce using rule 17 (valor -> ID .) + DIV reduce using rule 17 (valor -> ID .) + MOD reduce using rule 17 (valor -> ID .) + $end reduce using rule 17 (valor -> ID .) + PC reduce using rule 17 (valor -> ID .) + COMA reduce using rule 17 (valor -> ID .) + + +state 8 + + (18) valor -> INTEGERVAL . + + MAS reduce using rule 18 (valor -> INTEGERVAL .) + MENOS reduce using rule 18 (valor -> INTEGERVAL .) + POR reduce using rule 18 (valor -> INTEGERVAL .) + DIVIDIR reduce using rule 18 (valor -> INTEGERVAL .) + DIV reduce using rule 18 (valor -> INTEGERVAL .) + MOD reduce using rule 18 (valor -> INTEGERVAL .) + $end reduce using rule 18 (valor -> INTEGERVAL .) + PC reduce using rule 18 (valor -> INTEGERVAL .) + COMA reduce using rule 18 (valor -> INTEGERVAL .) + + +state 9 + + (19) valor -> DOUBLEVAL . + + MAS reduce using rule 19 (valor -> DOUBLEVAL .) + MENOS reduce using rule 19 (valor -> DOUBLEVAL .) + POR reduce using rule 19 (valor -> DOUBLEVAL .) + DIVIDIR reduce using rule 19 (valor -> DOUBLEVAL .) + DIV reduce using rule 19 (valor -> DOUBLEVAL .) + MOD reduce using rule 19 (valor -> DOUBLEVAL .) + $end reduce using rule 19 (valor -> DOUBLEVAL .) + PC reduce using rule 19 (valor -> DOUBLEVAL .) + COMA reduce using rule 19 (valor -> DOUBLEVAL .) + + +state 10 + + (20) valor -> STRINGVAL . + + MAS reduce using rule 20 (valor -> STRINGVAL .) + MENOS reduce using rule 20 (valor -> STRINGVAL .) + POR reduce using rule 20 (valor -> STRINGVAL .) + DIVIDIR reduce using rule 20 (valor -> STRINGVAL .) + DIV reduce using rule 20 (valor -> STRINGVAL .) + MOD reduce using rule 20 (valor -> STRINGVAL .) + $end reduce using rule 20 (valor -> STRINGVAL .) + PC reduce using rule 20 (valor -> STRINGVAL .) + COMA reduce using rule 20 (valor -> STRINGVAL .) + + +state 11 + + (21) valor -> TRUE . + + MAS reduce using rule 21 (valor -> TRUE .) + MENOS reduce using rule 21 (valor -> TRUE .) + POR reduce using rule 21 (valor -> TRUE .) + DIVIDIR reduce using rule 21 (valor -> TRUE .) + DIV reduce using rule 21 (valor -> TRUE .) + MOD reduce using rule 21 (valor -> TRUE .) + $end reduce using rule 21 (valor -> TRUE .) + PC reduce using rule 21 (valor -> TRUE .) + COMA reduce using rule 21 (valor -> TRUE .) + + +state 12 + + (22) valor -> FALSE . + + MAS reduce using rule 22 (valor -> FALSE .) + MENOS reduce using rule 22 (valor -> FALSE .) + POR reduce using rule 22 (valor -> FALSE .) + DIVIDIR reduce using rule 22 (valor -> FALSE .) + DIV reduce using rule 22 (valor -> FALSE .) + MOD reduce using rule 22 (valor -> FALSE .) + $end reduce using rule 22 (valor -> FALSE .) + PC reduce using rule 22 (valor -> FALSE .) + COMA reduce using rule 22 (valor -> FALSE .) + + +state 13 + + (23) valor -> techo . + + MAS reduce using rule 23 (valor -> techo .) + MENOS reduce using rule 23 (valor -> techo .) + POR reduce using rule 23 (valor -> techo .) + DIVIDIR reduce using rule 23 (valor -> techo .) + DIV reduce using rule 23 (valor -> techo .) + MOD reduce using rule 23 (valor -> techo .) + $end reduce using rule 23 (valor -> techo .) + PC reduce using rule 23 (valor -> techo .) + COMA reduce using rule 23 (valor -> techo .) + + +state 14 + + (24) valor -> piso . + + MAS reduce using rule 24 (valor -> piso .) + MENOS reduce using rule 24 (valor -> piso .) + POR reduce using rule 24 (valor -> piso .) + DIVIDIR reduce using rule 24 (valor -> piso .) + DIV reduce using rule 24 (valor -> piso .) + MOD reduce using rule 24 (valor -> piso .) + $end reduce using rule 24 (valor -> piso .) + PC reduce using rule 24 (valor -> piso .) + COMA reduce using rule 24 (valor -> piso .) + + +state 15 + + (25) valor -> longitud . + + MAS reduce using rule 25 (valor -> longitud .) + MENOS reduce using rule 25 (valor -> longitud .) + POR reduce using rule 25 (valor -> longitud .) + DIVIDIR reduce using rule 25 (valor -> longitud .) + DIV reduce using rule 25 (valor -> longitud .) + MOD reduce using rule 25 (valor -> longitud .) + $end reduce using rule 25 (valor -> longitud .) + PC reduce using rule 25 (valor -> longitud .) + COMA reduce using rule 25 (valor -> longitud .) + + +state 16 + + (26) valor -> dequeue . + + MAS reduce using rule 26 (valor -> dequeue .) + MENOS reduce using rule 26 (valor -> dequeue .) + POR reduce using rule 26 (valor -> dequeue .) + DIVIDIR reduce using rule 26 (valor -> dequeue .) + DIV reduce using rule 26 (valor -> dequeue .) + MOD reduce using rule 26 (valor -> dequeue .) + $end reduce using rule 26 (valor -> dequeue .) + PC reduce using rule 26 (valor -> dequeue .) + COMA reduce using rule 26 (valor -> dequeue .) + + +state 17 + + (27) valor -> pop . + + MAS reduce using rule 27 (valor -> pop .) + MENOS reduce using rule 27 (valor -> pop .) + POR reduce using rule 27 (valor -> pop .) + DIVIDIR reduce using rule 27 (valor -> pop .) + DIV reduce using rule 27 (valor -> pop .) + MOD reduce using rule 27 (valor -> pop .) + $end reduce using rule 27 (valor -> pop .) + PC reduce using rule 27 (valor -> pop .) + COMA reduce using rule 27 (valor -> pop .) + + +state 18 + + (28) valor -> get . + + MAS reduce using rule 28 (valor -> get .) + MENOS reduce using rule 28 (valor -> get .) + POR reduce using rule 28 (valor -> get .) + DIVIDIR reduce using rule 28 (valor -> get .) + DIV reduce using rule 28 (valor -> get .) + MOD reduce using rule 28 (valor -> get .) + $end reduce using rule 28 (valor -> get .) + PC reduce using rule 28 (valor -> get .) + COMA reduce using rule 28 (valor -> get .) + + +state 19 + + (29) valor -> getq . + + MAS reduce using rule 29 (valor -> getq .) + MENOS reduce using rule 29 (valor -> getq .) + POR reduce using rule 29 (valor -> getq .) + DIVIDIR reduce using rule 29 (valor -> getq .) + DIV reduce using rule 29 (valor -> getq .) + MOD reduce using rule 29 (valor -> getq .) + $end reduce using rule 29 (valor -> getq .) + PC reduce using rule 29 (valor -> getq .) + COMA reduce using rule 29 (valor -> getq .) + + +state 20 + + (30) valor -> getp . + + MAS reduce using rule 30 (valor -> getp .) + MENOS reduce using rule 30 (valor -> getp .) + POR reduce using rule 30 (valor -> getp .) + DIVIDIR reduce using rule 30 (valor -> getp .) + DIV reduce using rule 30 (valor -> getp .) + MOD reduce using rule 30 (valor -> getp .) + $end reduce using rule 30 (valor -> getp .) + PC reduce using rule 30 (valor -> getp .) + COMA reduce using rule 30 (valor -> getp .) + + +state 21 + + (31) valor -> size . + + MAS reduce using rule 31 (valor -> size .) + MENOS reduce using rule 31 (valor -> size .) + POR reduce using rule 31 (valor -> size .) + DIVIDIR reduce using rule 31 (valor -> size .) + DIV reduce using rule 31 (valor -> size .) + MOD reduce using rule 31 (valor -> size .) + $end reduce using rule 31 (valor -> size .) + PC reduce using rule 31 (valor -> size .) + COMA reduce using rule 31 (valor -> size .) + + +state 22 + + (32) valor -> sizequeue . + + MAS reduce using rule 32 (valor -> sizequeue .) + MENOS reduce using rule 32 (valor -> sizequeue .) + POR reduce using rule 32 (valor -> sizequeue .) + DIVIDIR reduce using rule 32 (valor -> sizequeue .) + DIV reduce using rule 32 (valor -> sizequeue .) + MOD reduce using rule 32 (valor -> sizequeue .) + $end reduce using rule 32 (valor -> sizequeue .) + PC reduce using rule 32 (valor -> sizequeue .) + COMA reduce using rule 32 (valor -> sizequeue .) + + +state 23 + + (33) valor -> sizestack . + + MAS reduce using rule 33 (valor -> sizestack .) + MENOS reduce using rule 33 (valor -> sizestack .) + POR reduce using rule 33 (valor -> sizestack .) + DIVIDIR reduce using rule 33 (valor -> sizestack .) + DIV reduce using rule 33 (valor -> sizestack .) + MOD reduce using rule 33 (valor -> sizestack .) + $end reduce using rule 33 (valor -> sizestack .) + PC reduce using rule 33 (valor -> sizestack .) + COMA reduce using rule 33 (valor -> sizestack .) + + +state 24 + + (34) valor -> deep . + + MAS reduce using rule 34 (valor -> deep .) + MENOS reduce using rule 34 (valor -> deep .) + POR reduce using rule 34 (valor -> deep .) + DIVIDIR reduce using rule 34 (valor -> deep .) + DIV reduce using rule 34 (valor -> deep .) + MOD reduce using rule 34 (valor -> deep .) + $end reduce using rule 34 (valor -> deep .) + PC reduce using rule 34 (valor -> deep .) + COMA reduce using rule 34 (valor -> deep .) + + +state 25 + + (35) valor -> width . + + MAS reduce using rule 35 (valor -> width .) + MENOS reduce using rule 35 (valor -> width .) + POR reduce using rule 35 (valor -> width .) + DIVIDIR reduce using rule 35 (valor -> width .) + DIV reduce using rule 35 (valor -> width .) + MOD reduce using rule 35 (valor -> width .) + $end reduce using rule 35 (valor -> width .) + PC reduce using rule 35 (valor -> width .) + COMA reduce using rule 35 (valor -> width .) + + +state 26 + + (36) valor -> llamar . + + MAS reduce using rule 36 (valor -> llamar .) + MENOS reduce using rule 36 (valor -> llamar .) + POR reduce using rule 36 (valor -> llamar .) + DIVIDIR reduce using rule 36 (valor -> llamar .) + DIV reduce using rule 36 (valor -> llamar .) + MOD reduce using rule 36 (valor -> llamar .) + $end reduce using rule 36 (valor -> llamar .) + PC reduce using rule 36 (valor -> llamar .) + COMA reduce using rule 36 (valor -> llamar .) + + +state 27 + + (15) techo -> CEIL . PA opmath PC + + PA shift and go to state 49 + + +state 28 + + (16) piso -> FLOOR . PA opmath PC + + PA shift and go to state 50 + + +state 29 + + (37) longitud -> LENGTH . PA STRINGVAL PC + (53) longitud -> LENGTH . PA error PC + + PA shift and go to state 51 + + +state 30 + + (38) dequeue -> DEQUEUE . PA ID PC + (54) dequeue -> DEQUEUE . PA error PC + + PA shift and go to state 52 + + +state 31 + + (39) pop -> POP . PA ID PC + (55) pop -> POP . PA error PC + + PA shift and go to state 53 + + +state 32 + + (40) get -> GET . PA ID COMA INTEGERVAL PC + (56) get -> GET . PA ID COMA error PC + + PA shift and go to state 54 + + +state 33 + + (41) getq -> GET_P . PA ID PC + (57) getq -> GET_P . PA error PC + + PA shift and go to state 55 + + +state 34 + + (42) getp -> GET_Q . PA ID PC + (58) getp -> GET_Q . PA error PC + + PA shift and go to state 56 + + +state 35 + + (43) size -> SIZE . PA ID PC + (59) size -> SIZE . PA error PC + + PA shift and go to state 57 + + +state 36 + + (44) sizequeue -> SIZE_QUEUE . PA ID PC + (60) sizequeue -> SIZE_QUEUE . PA error PC + + PA shift and go to state 58 + + +state 37 + + (45) sizestack -> SIZE_STACK . PA ID PC + (61) sizestack -> SIZE_STACK . PA error PC + + PA shift and go to state 59 + + +state 38 + + (46) deep -> DEEP . PA ID PC + (62) deep -> DEEP . PA error PC + + PA shift and go to state 60 + + +state 39 + + (47) width -> WIDTH . PA ID PC + (63) width -> WIDTH . PA error PC + + PA shift and go to state 61 + + +state 40 + + (48) llamar -> CALL . ID PA valoresCall PC + (49) llamar -> CALL . ID PA PC + + ID shift and go to state 62 + + +state 41 + + (4) par -> PA par . PC parAux + + PC shift and go to state 63 + + +state 42 + + (8) opmath -> valor mathsymbol . par + (3) par -> . opmath + (4) par -> . PA par PC parAux + (7) opmath -> . valor + (8) opmath -> . valor mathsymbol par + (17) valor -> . ID + (18) valor -> . INTEGERVAL + (19) valor -> . DOUBLEVAL + (20) valor -> . STRINGVAL + (21) valor -> . TRUE + (22) valor -> . FALSE + (23) valor -> . techo + (24) valor -> . piso + (25) valor -> . longitud + (26) valor -> . dequeue + (27) valor -> . pop + (28) valor -> . get + (29) valor -> . getq + (30) valor -> . getp + (31) valor -> . size + (32) valor -> . sizequeue + (33) valor -> . sizestack + (34) valor -> . deep + (35) valor -> . width + (36) valor -> . llamar + (15) techo -> . CEIL PA opmath PC + (16) piso -> . FLOOR PA opmath PC + (37) longitud -> . LENGTH PA STRINGVAL PC + (53) longitud -> . LENGTH PA error PC + (38) dequeue -> . DEQUEUE PA ID PC + (54) dequeue -> . DEQUEUE PA error PC + (39) pop -> . POP PA ID PC + (55) pop -> . POP PA error PC + (40) get -> . GET PA ID COMA INTEGERVAL PC + (56) get -> . GET PA ID COMA error PC + (41) getq -> . GET_P PA ID PC + (57) getq -> . GET_P PA error PC + (42) getp -> . GET_Q PA ID PC + (58) getp -> . GET_Q PA error PC + (43) size -> . SIZE PA ID PC + (59) size -> . SIZE PA error PC + (44) sizequeue -> . SIZE_QUEUE PA ID PC + (60) sizequeue -> . SIZE_QUEUE PA error PC + (45) sizestack -> . SIZE_STACK PA ID PC + (61) sizestack -> . SIZE_STACK PA error PC + (46) deep -> . DEEP PA ID PC + (62) deep -> . DEEP PA error PC + (47) width -> . WIDTH PA ID PC + (63) width -> . WIDTH PA error PC + (48) llamar -> . CALL ID PA valoresCall PC + (49) llamar -> . CALL ID PA PC + + PA shift and go to state 5 + ID shift and go to state 7 + INTEGERVAL shift and go to state 8 + DOUBLEVAL shift and go to state 9 + STRINGVAL shift and go to state 10 + TRUE shift and go to state 11 + FALSE shift and go to state 12 + CEIL shift and go to state 27 + FLOOR shift and go to state 28 + LENGTH shift and go to state 29 + DEQUEUE shift and go to state 30 + POP shift and go to state 31 + GET shift and go to state 32 + GET_P shift and go to state 33 + GET_Q shift and go to state 34 + SIZE shift and go to state 35 + SIZE_QUEUE shift and go to state 36 + SIZE_STACK shift and go to state 37 + DEEP shift and go to state 38 + WIDTH shift and go to state 39 + CALL shift and go to state 40 + + valor shift and go to state 6 + par shift and go to state 64 + opmath shift and go to state 4 + techo shift and go to state 13 + piso shift and go to state 14 + longitud shift and go to state 15 + dequeue shift and go to state 16 + pop shift and go to state 17 + get shift and go to state 18 + getq shift and go to state 19 + getp shift and go to state 20 + size shift and go to state 21 + sizequeue shift and go to state 22 + sizestack shift and go to state 23 + deep shift and go to state 24 + width shift and go to state 25 + llamar shift and go to state 26 + +state 43 + + (9) mathsymbol -> MAS . + + PA reduce using rule 9 (mathsymbol -> MAS .) + ID reduce using rule 9 (mathsymbol -> MAS .) + INTEGERVAL reduce using rule 9 (mathsymbol -> MAS .) + DOUBLEVAL reduce using rule 9 (mathsymbol -> MAS .) + STRINGVAL reduce using rule 9 (mathsymbol -> MAS .) + TRUE reduce using rule 9 (mathsymbol -> MAS .) + FALSE reduce using rule 9 (mathsymbol -> MAS .) + CEIL reduce using rule 9 (mathsymbol -> MAS .) + FLOOR reduce using rule 9 (mathsymbol -> MAS .) + LENGTH reduce using rule 9 (mathsymbol -> MAS .) + DEQUEUE reduce using rule 9 (mathsymbol -> MAS .) + POP reduce using rule 9 (mathsymbol -> MAS .) + GET reduce using rule 9 (mathsymbol -> MAS .) + GET_P reduce using rule 9 (mathsymbol -> MAS .) + GET_Q reduce using rule 9 (mathsymbol -> MAS .) + SIZE reduce using rule 9 (mathsymbol -> MAS .) + SIZE_QUEUE reduce using rule 9 (mathsymbol -> MAS .) + SIZE_STACK reduce using rule 9 (mathsymbol -> MAS .) + DEEP reduce using rule 9 (mathsymbol -> MAS .) + WIDTH reduce using rule 9 (mathsymbol -> MAS .) + CALL reduce using rule 9 (mathsymbol -> MAS .) + + +state 44 + + (10) mathsymbol -> MENOS . + + PA reduce using rule 10 (mathsymbol -> MENOS .) + ID reduce using rule 10 (mathsymbol -> MENOS .) + INTEGERVAL reduce using rule 10 (mathsymbol -> MENOS .) + DOUBLEVAL reduce using rule 10 (mathsymbol -> MENOS .) + STRINGVAL reduce using rule 10 (mathsymbol -> MENOS .) + TRUE reduce using rule 10 (mathsymbol -> MENOS .) + FALSE reduce using rule 10 (mathsymbol -> MENOS .) + CEIL reduce using rule 10 (mathsymbol -> MENOS .) + FLOOR reduce using rule 10 (mathsymbol -> MENOS .) + LENGTH reduce using rule 10 (mathsymbol -> MENOS .) + DEQUEUE reduce using rule 10 (mathsymbol -> MENOS .) + POP reduce using rule 10 (mathsymbol -> MENOS .) + GET reduce using rule 10 (mathsymbol -> MENOS .) + GET_P reduce using rule 10 (mathsymbol -> MENOS .) + GET_Q reduce using rule 10 (mathsymbol -> MENOS .) + SIZE reduce using rule 10 (mathsymbol -> MENOS .) + SIZE_QUEUE reduce using rule 10 (mathsymbol -> MENOS .) + SIZE_STACK reduce using rule 10 (mathsymbol -> MENOS .) + DEEP reduce using rule 10 (mathsymbol -> MENOS .) + WIDTH reduce using rule 10 (mathsymbol -> MENOS .) + CALL reduce using rule 10 (mathsymbol -> MENOS .) + + +state 45 + + (11) mathsymbol -> POR . + + PA reduce using rule 11 (mathsymbol -> POR .) + ID reduce using rule 11 (mathsymbol -> POR .) + INTEGERVAL reduce using rule 11 (mathsymbol -> POR .) + DOUBLEVAL reduce using rule 11 (mathsymbol -> POR .) + STRINGVAL reduce using rule 11 (mathsymbol -> POR .) + TRUE reduce using rule 11 (mathsymbol -> POR .) + FALSE reduce using rule 11 (mathsymbol -> POR .) + CEIL reduce using rule 11 (mathsymbol -> POR .) + FLOOR reduce using rule 11 (mathsymbol -> POR .) + LENGTH reduce using rule 11 (mathsymbol -> POR .) + DEQUEUE reduce using rule 11 (mathsymbol -> POR .) + POP reduce using rule 11 (mathsymbol -> POR .) + GET reduce using rule 11 (mathsymbol -> POR .) + GET_P reduce using rule 11 (mathsymbol -> POR .) + GET_Q reduce using rule 11 (mathsymbol -> POR .) + SIZE reduce using rule 11 (mathsymbol -> POR .) + SIZE_QUEUE reduce using rule 11 (mathsymbol -> POR .) + SIZE_STACK reduce using rule 11 (mathsymbol -> POR .) + DEEP reduce using rule 11 (mathsymbol -> POR .) + WIDTH reduce using rule 11 (mathsymbol -> POR .) + CALL reduce using rule 11 (mathsymbol -> POR .) + + +state 46 + + (12) mathsymbol -> DIVIDIR . + + PA reduce using rule 12 (mathsymbol -> DIVIDIR .) + ID reduce using rule 12 (mathsymbol -> DIVIDIR .) + INTEGERVAL reduce using rule 12 (mathsymbol -> DIVIDIR .) + DOUBLEVAL reduce using rule 12 (mathsymbol -> DIVIDIR .) + STRINGVAL reduce using rule 12 (mathsymbol -> DIVIDIR .) + TRUE reduce using rule 12 (mathsymbol -> DIVIDIR .) + FALSE reduce using rule 12 (mathsymbol -> DIVIDIR .) + CEIL reduce using rule 12 (mathsymbol -> DIVIDIR .) + FLOOR reduce using rule 12 (mathsymbol -> DIVIDIR .) + LENGTH reduce using rule 12 (mathsymbol -> DIVIDIR .) + DEQUEUE reduce using rule 12 (mathsymbol -> DIVIDIR .) + POP reduce using rule 12 (mathsymbol -> DIVIDIR .) + GET reduce using rule 12 (mathsymbol -> DIVIDIR .) + GET_P reduce using rule 12 (mathsymbol -> DIVIDIR .) + GET_Q reduce using rule 12 (mathsymbol -> DIVIDIR .) + SIZE reduce using rule 12 (mathsymbol -> DIVIDIR .) + SIZE_QUEUE reduce using rule 12 (mathsymbol -> DIVIDIR .) + SIZE_STACK reduce using rule 12 (mathsymbol -> DIVIDIR .) + DEEP reduce using rule 12 (mathsymbol -> DIVIDIR .) + WIDTH reduce using rule 12 (mathsymbol -> DIVIDIR .) + CALL reduce using rule 12 (mathsymbol -> DIVIDIR .) + + +state 47 + + (13) mathsymbol -> DIV . + + PA reduce using rule 13 (mathsymbol -> DIV .) + ID reduce using rule 13 (mathsymbol -> DIV .) + INTEGERVAL reduce using rule 13 (mathsymbol -> DIV .) + DOUBLEVAL reduce using rule 13 (mathsymbol -> DIV .) + STRINGVAL reduce using rule 13 (mathsymbol -> DIV .) + TRUE reduce using rule 13 (mathsymbol -> DIV .) + FALSE reduce using rule 13 (mathsymbol -> DIV .) + CEIL reduce using rule 13 (mathsymbol -> DIV .) + FLOOR reduce using rule 13 (mathsymbol -> DIV .) + LENGTH reduce using rule 13 (mathsymbol -> DIV .) + DEQUEUE reduce using rule 13 (mathsymbol -> DIV .) + POP reduce using rule 13 (mathsymbol -> DIV .) + GET reduce using rule 13 (mathsymbol -> DIV .) + GET_P reduce using rule 13 (mathsymbol -> DIV .) + GET_Q reduce using rule 13 (mathsymbol -> DIV .) + SIZE reduce using rule 13 (mathsymbol -> DIV .) + SIZE_QUEUE reduce using rule 13 (mathsymbol -> DIV .) + SIZE_STACK reduce using rule 13 (mathsymbol -> DIV .) + DEEP reduce using rule 13 (mathsymbol -> DIV .) + WIDTH reduce using rule 13 (mathsymbol -> DIV .) + CALL reduce using rule 13 (mathsymbol -> DIV .) + + +state 48 + + (14) mathsymbol -> MOD . + + PA reduce using rule 14 (mathsymbol -> MOD .) + ID reduce using rule 14 (mathsymbol -> MOD .) + INTEGERVAL reduce using rule 14 (mathsymbol -> MOD .) + DOUBLEVAL reduce using rule 14 (mathsymbol -> MOD .) + STRINGVAL reduce using rule 14 (mathsymbol -> MOD .) + TRUE reduce using rule 14 (mathsymbol -> MOD .) + FALSE reduce using rule 14 (mathsymbol -> MOD .) + CEIL reduce using rule 14 (mathsymbol -> MOD .) + FLOOR reduce using rule 14 (mathsymbol -> MOD .) + LENGTH reduce using rule 14 (mathsymbol -> MOD .) + DEQUEUE reduce using rule 14 (mathsymbol -> MOD .) + POP reduce using rule 14 (mathsymbol -> MOD .) + GET reduce using rule 14 (mathsymbol -> MOD .) + GET_P reduce using rule 14 (mathsymbol -> MOD .) + GET_Q reduce using rule 14 (mathsymbol -> MOD .) + SIZE reduce using rule 14 (mathsymbol -> MOD .) + SIZE_QUEUE reduce using rule 14 (mathsymbol -> MOD .) + SIZE_STACK reduce using rule 14 (mathsymbol -> MOD .) + DEEP reduce using rule 14 (mathsymbol -> MOD .) + WIDTH reduce using rule 14 (mathsymbol -> MOD .) + CALL reduce using rule 14 (mathsymbol -> MOD .) + + +state 49 + + (15) techo -> CEIL PA . opmath PC + (7) opmath -> . valor + (8) opmath -> . valor mathsymbol par + (17) valor -> . ID + (18) valor -> . INTEGERVAL + (19) valor -> . DOUBLEVAL + (20) valor -> . STRINGVAL + (21) valor -> . TRUE + (22) valor -> . FALSE + (23) valor -> . techo + (24) valor -> . piso + (25) valor -> . longitud + (26) valor -> . dequeue + (27) valor -> . pop + (28) valor -> . get + (29) valor -> . getq + (30) valor -> . getp + (31) valor -> . size + (32) valor -> . sizequeue + (33) valor -> . sizestack + (34) valor -> . deep + (35) valor -> . width + (36) valor -> . llamar + (15) techo -> . CEIL PA opmath PC + (16) piso -> . FLOOR PA opmath PC + (37) longitud -> . LENGTH PA STRINGVAL PC + (53) longitud -> . LENGTH PA error PC + (38) dequeue -> . DEQUEUE PA ID PC + (54) dequeue -> . DEQUEUE PA error PC + (39) pop -> . POP PA ID PC + (55) pop -> . POP PA error PC + (40) get -> . GET PA ID COMA INTEGERVAL PC + (56) get -> . GET PA ID COMA error PC + (41) getq -> . GET_P PA ID PC + (57) getq -> . GET_P PA error PC + (42) getp -> . GET_Q PA ID PC + (58) getp -> . GET_Q PA error PC + (43) size -> . SIZE PA ID PC + (59) size -> . SIZE PA error PC + (44) sizequeue -> . SIZE_QUEUE PA ID PC + (60) sizequeue -> . SIZE_QUEUE PA error PC + (45) sizestack -> . SIZE_STACK PA ID PC + (61) sizestack -> . SIZE_STACK PA error PC + (46) deep -> . DEEP PA ID PC + (62) deep -> . DEEP PA error PC + (47) width -> . WIDTH PA ID PC + (63) width -> . WIDTH PA error PC + (48) llamar -> . CALL ID PA valoresCall PC + (49) llamar -> . CALL ID PA PC + + ID shift and go to state 7 + INTEGERVAL shift and go to state 8 + DOUBLEVAL shift and go to state 9 + STRINGVAL shift and go to state 10 + TRUE shift and go to state 11 + FALSE shift and go to state 12 + CEIL shift and go to state 27 + FLOOR shift and go to state 28 + LENGTH shift and go to state 29 + DEQUEUE shift and go to state 30 + POP shift and go to state 31 + GET shift and go to state 32 + GET_P shift and go to state 33 + GET_Q shift and go to state 34 + SIZE shift and go to state 35 + SIZE_QUEUE shift and go to state 36 + SIZE_STACK shift and go to state 37 + DEEP shift and go to state 38 + WIDTH shift and go to state 39 + CALL shift and go to state 40 + + opmath shift and go to state 65 + valor shift and go to state 6 + techo shift and go to state 13 + piso shift and go to state 14 + longitud shift and go to state 15 + dequeue shift and go to state 16 + pop shift and go to state 17 + get shift and go to state 18 + getq shift and go to state 19 + getp shift and go to state 20 + size shift and go to state 21 + sizequeue shift and go to state 22 + sizestack shift and go to state 23 + deep shift and go to state 24 + width shift and go to state 25 + llamar shift and go to state 26 + +state 50 + + (16) piso -> FLOOR PA . opmath PC + (7) opmath -> . valor + (8) opmath -> . valor mathsymbol par + (17) valor -> . ID + (18) valor -> . INTEGERVAL + (19) valor -> . DOUBLEVAL + (20) valor -> . STRINGVAL + (21) valor -> . TRUE + (22) valor -> . FALSE + (23) valor -> . techo + (24) valor -> . piso + (25) valor -> . longitud + (26) valor -> . dequeue + (27) valor -> . pop + (28) valor -> . get + (29) valor -> . getq + (30) valor -> . getp + (31) valor -> . size + (32) valor -> . sizequeue + (33) valor -> . sizestack + (34) valor -> . deep + (35) valor -> . width + (36) valor -> . llamar + (15) techo -> . CEIL PA opmath PC + (16) piso -> . FLOOR PA opmath PC + (37) longitud -> . LENGTH PA STRINGVAL PC + (53) longitud -> . LENGTH PA error PC + (38) dequeue -> . DEQUEUE PA ID PC + (54) dequeue -> . DEQUEUE PA error PC + (39) pop -> . POP PA ID PC + (55) pop -> . POP PA error PC + (40) get -> . GET PA ID COMA INTEGERVAL PC + (56) get -> . GET PA ID COMA error PC + (41) getq -> . GET_P PA ID PC + (57) getq -> . GET_P PA error PC + (42) getp -> . GET_Q PA ID PC + (58) getp -> . GET_Q PA error PC + (43) size -> . SIZE PA ID PC + (59) size -> . SIZE PA error PC + (44) sizequeue -> . SIZE_QUEUE PA ID PC + (60) sizequeue -> . SIZE_QUEUE PA error PC + (45) sizestack -> . SIZE_STACK PA ID PC + (61) sizestack -> . SIZE_STACK PA error PC + (46) deep -> . DEEP PA ID PC + (62) deep -> . DEEP PA error PC + (47) width -> . WIDTH PA ID PC + (63) width -> . WIDTH PA error PC + (48) llamar -> . CALL ID PA valoresCall PC + (49) llamar -> . CALL ID PA PC + + ID shift and go to state 7 + INTEGERVAL shift and go to state 8 + DOUBLEVAL shift and go to state 9 + STRINGVAL shift and go to state 10 + TRUE shift and go to state 11 + FALSE shift and go to state 12 + CEIL shift and go to state 27 + FLOOR shift and go to state 28 + LENGTH shift and go to state 29 + DEQUEUE shift and go to state 30 + POP shift and go to state 31 + GET shift and go to state 32 + GET_P shift and go to state 33 + GET_Q shift and go to state 34 + SIZE shift and go to state 35 + SIZE_QUEUE shift and go to state 36 + SIZE_STACK shift and go to state 37 + DEEP shift and go to state 38 + WIDTH shift and go to state 39 + CALL shift and go to state 40 + + opmath shift and go to state 66 + valor shift and go to state 6 + techo shift and go to state 13 + piso shift and go to state 14 + longitud shift and go to state 15 + dequeue shift and go to state 16 + pop shift and go to state 17 + get shift and go to state 18 + getq shift and go to state 19 + getp shift and go to state 20 + size shift and go to state 21 + sizequeue shift and go to state 22 + sizestack shift and go to state 23 + deep shift and go to state 24 + width shift and go to state 25 + llamar shift and go to state 26 + +state 51 + + (37) longitud -> LENGTH PA . STRINGVAL PC + (53) longitud -> LENGTH PA . error PC + + STRINGVAL shift and go to state 67 + error shift and go to state 68 + + +state 52 + + (38) dequeue -> DEQUEUE PA . ID PC + (54) dequeue -> DEQUEUE PA . error PC + + ID shift and go to state 69 + error shift and go to state 70 + + +state 53 + + (39) pop -> POP PA . ID PC + (55) pop -> POP PA . error PC + + ID shift and go to state 71 + error shift and go to state 72 + + +state 54 + + (40) get -> GET PA . ID COMA INTEGERVAL PC + (56) get -> GET PA . ID COMA error PC + + ID shift and go to state 73 + + +state 55 + + (41) getq -> GET_P PA . ID PC + (57) getq -> GET_P PA . error PC + + ID shift and go to state 74 + error shift and go to state 75 + + +state 56 + + (42) getp -> GET_Q PA . ID PC + (58) getp -> GET_Q PA . error PC + + ID shift and go to state 76 + error shift and go to state 77 + + +state 57 + + (43) size -> SIZE PA . ID PC + (59) size -> SIZE PA . error PC + + ID shift and go to state 78 + error shift and go to state 79 + + +state 58 + + (44) sizequeue -> SIZE_QUEUE PA . ID PC + (60) sizequeue -> SIZE_QUEUE PA . error PC + + ID shift and go to state 80 + error shift and go to state 81 + + +state 59 + + (45) sizestack -> SIZE_STACK PA . ID PC + (61) sizestack -> SIZE_STACK PA . error PC + + ID shift and go to state 82 + error shift and go to state 83 + + +state 60 + + (46) deep -> DEEP PA . ID PC + (62) deep -> DEEP PA . error PC + + ID shift and go to state 84 + error shift and go to state 85 + + +state 61 + + (47) width -> WIDTH PA . ID PC + (63) width -> WIDTH PA . error PC + + ID shift and go to state 86 + error shift and go to state 87 + + +state 62 + + (48) llamar -> CALL ID . PA valoresCall PC + (49) llamar -> CALL ID . PA PC + + PA shift and go to state 88 + + +state 63 + + (4) par -> PA par PC . parAux + (5) parAux -> . mathsymbol par + (6) parAux -> . empty + (9) mathsymbol -> . MAS + (10) mathsymbol -> . MENOS + (11) mathsymbol -> . POR + (12) mathsymbol -> . DIVIDIR + (13) mathsymbol -> . DIV + (14) mathsymbol -> . MOD + (52) empty -> . + + MAS shift and go to state 43 + MENOS shift and go to state 44 + POR shift and go to state 45 + DIVIDIR shift and go to state 46 + DIV shift and go to state 47 + MOD shift and go to state 48 + $end reduce using rule 52 (empty -> .) + PC reduce using rule 52 (empty -> .) + + parAux shift and go to state 89 + mathsymbol shift and go to state 90 + empty shift and go to state 91 + +state 64 + + (8) opmath -> valor mathsymbol par . + + $end reduce using rule 8 (opmath -> valor mathsymbol par .) + PC reduce using rule 8 (opmath -> valor mathsymbol par .) + + +state 65 + + (15) techo -> CEIL PA opmath . PC + + PC shift and go to state 92 + + +state 66 + + (16) piso -> FLOOR PA opmath . PC + + PC shift and go to state 93 + + +state 67 + + (37) longitud -> LENGTH PA STRINGVAL . PC + + PC shift and go to state 94 + + +state 68 + + (53) longitud -> LENGTH PA error . PC + + PC shift and go to state 95 + + +state 69 + + (38) dequeue -> DEQUEUE PA ID . PC + + PC shift and go to state 96 + + +state 70 + + (54) dequeue -> DEQUEUE PA error . PC + + PC shift and go to state 97 + + +state 71 + + (39) pop -> POP PA ID . PC + + PC shift and go to state 98 + + +state 72 + + (55) pop -> POP PA error . PC + + PC shift and go to state 99 + + +state 73 + + (40) get -> GET PA ID . COMA INTEGERVAL PC + (56) get -> GET PA ID . COMA error PC + + COMA shift and go to state 100 + + +state 74 + + (41) getq -> GET_P PA ID . PC + + PC shift and go to state 101 + + +state 75 + + (57) getq -> GET_P PA error . PC + + PC shift and go to state 102 + + +state 76 + + (42) getp -> GET_Q PA ID . PC + + PC shift and go to state 103 + + +state 77 + + (58) getp -> GET_Q PA error . PC + + PC shift and go to state 104 + + +state 78 + + (43) size -> SIZE PA ID . PC + + PC shift and go to state 105 + + +state 79 + + (59) size -> SIZE PA error . PC + + PC shift and go to state 106 + + +state 80 + + (44) sizequeue -> SIZE_QUEUE PA ID . PC + + PC shift and go to state 107 + + +state 81 + + (60) sizequeue -> SIZE_QUEUE PA error . PC + + PC shift and go to state 108 + + +state 82 + + (45) sizestack -> SIZE_STACK PA ID . PC + + PC shift and go to state 109 + + +state 83 + + (61) sizestack -> SIZE_STACK PA error . PC + + PC shift and go to state 110 + + +state 84 + + (46) deep -> DEEP PA ID . PC + + PC shift and go to state 111 + + +state 85 + + (62) deep -> DEEP PA error . PC + + PC shift and go to state 112 + + +state 86 + + (47) width -> WIDTH PA ID . PC + + PC shift and go to state 113 + + +state 87 + + (63) width -> WIDTH PA error . PC + + PC shift and go to state 114 + + +state 88 + + (48) llamar -> CALL ID PA . valoresCall PC + (49) llamar -> CALL ID PA . PC + (50) valoresCall -> . valor + (51) valoresCall -> . valor COMA valoresCall + (17) valor -> . ID + (18) valor -> . INTEGERVAL + (19) valor -> . DOUBLEVAL + (20) valor -> . STRINGVAL + (21) valor -> . TRUE + (22) valor -> . FALSE + (23) valor -> . techo + (24) valor -> . piso + (25) valor -> . longitud + (26) valor -> . dequeue + (27) valor -> . pop + (28) valor -> . get + (29) valor -> . getq + (30) valor -> . getp + (31) valor -> . size + (32) valor -> . sizequeue + (33) valor -> . sizestack + (34) valor -> . deep + (35) valor -> . width + (36) valor -> . llamar + (15) techo -> . CEIL PA opmath PC + (16) piso -> . FLOOR PA opmath PC + (37) longitud -> . LENGTH PA STRINGVAL PC + (53) longitud -> . LENGTH PA error PC + (38) dequeue -> . DEQUEUE PA ID PC + (54) dequeue -> . DEQUEUE PA error PC + (39) pop -> . POP PA ID PC + (55) pop -> . POP PA error PC + (40) get -> . GET PA ID COMA INTEGERVAL PC + (56) get -> . GET PA ID COMA error PC + (41) getq -> . GET_P PA ID PC + (57) getq -> . GET_P PA error PC + (42) getp -> . GET_Q PA ID PC + (58) getp -> . GET_Q PA error PC + (43) size -> . SIZE PA ID PC + (59) size -> . SIZE PA error PC + (44) sizequeue -> . SIZE_QUEUE PA ID PC + (60) sizequeue -> . SIZE_QUEUE PA error PC + (45) sizestack -> . SIZE_STACK PA ID PC + (61) sizestack -> . SIZE_STACK PA error PC + (46) deep -> . DEEP PA ID PC + (62) deep -> . DEEP PA error PC + (47) width -> . WIDTH PA ID PC + (63) width -> . WIDTH PA error PC + (48) llamar -> . CALL ID PA valoresCall PC + (49) llamar -> . CALL ID PA PC + + PC shift and go to state 116 + ID shift and go to state 7 + INTEGERVAL shift and go to state 8 + DOUBLEVAL shift and go to state 9 + STRINGVAL shift and go to state 10 + TRUE shift and go to state 11 + FALSE shift and go to state 12 + CEIL shift and go to state 27 + FLOOR shift and go to state 28 + LENGTH shift and go to state 29 + DEQUEUE shift and go to state 30 + POP shift and go to state 31 + GET shift and go to state 32 + GET_P shift and go to state 33 + GET_Q shift and go to state 34 + SIZE shift and go to state 35 + SIZE_QUEUE shift and go to state 36 + SIZE_STACK shift and go to state 37 + DEEP shift and go to state 38 + WIDTH shift and go to state 39 + CALL shift and go to state 40 + + valoresCall shift and go to state 115 + valor shift and go to state 117 + techo shift and go to state 13 + piso shift and go to state 14 + longitud shift and go to state 15 + dequeue shift and go to state 16 + pop shift and go to state 17 + get shift and go to state 18 + getq shift and go to state 19 + getp shift and go to state 20 + size shift and go to state 21 + sizequeue shift and go to state 22 + sizestack shift and go to state 23 + deep shift and go to state 24 + width shift and go to state 25 + llamar shift and go to state 26 + +state 89 + + (4) par -> PA par PC parAux . + + $end reduce using rule 4 (par -> PA par PC parAux .) + PC reduce using rule 4 (par -> PA par PC parAux .) + + +state 90 + + (5) parAux -> mathsymbol . par + (3) par -> . opmath + (4) par -> . PA par PC parAux + (7) opmath -> . valor + (8) opmath -> . valor mathsymbol par + (17) valor -> . ID + (18) valor -> . INTEGERVAL + (19) valor -> . DOUBLEVAL + (20) valor -> . STRINGVAL + (21) valor -> . TRUE + (22) valor -> . FALSE + (23) valor -> . techo + (24) valor -> . piso + (25) valor -> . longitud + (26) valor -> . dequeue + (27) valor -> . pop + (28) valor -> . get + (29) valor -> . getq + (30) valor -> . getp + (31) valor -> . size + (32) valor -> . sizequeue + (33) valor -> . sizestack + (34) valor -> . deep + (35) valor -> . width + (36) valor -> . llamar + (15) techo -> . CEIL PA opmath PC + (16) piso -> . FLOOR PA opmath PC + (37) longitud -> . LENGTH PA STRINGVAL PC + (53) longitud -> . LENGTH PA error PC + (38) dequeue -> . DEQUEUE PA ID PC + (54) dequeue -> . DEQUEUE PA error PC + (39) pop -> . POP PA ID PC + (55) pop -> . POP PA error PC + (40) get -> . GET PA ID COMA INTEGERVAL PC + (56) get -> . GET PA ID COMA error PC + (41) getq -> . GET_P PA ID PC + (57) getq -> . GET_P PA error PC + (42) getp -> . GET_Q PA ID PC + (58) getp -> . GET_Q PA error PC + (43) size -> . SIZE PA ID PC + (59) size -> . SIZE PA error PC + (44) sizequeue -> . SIZE_QUEUE PA ID PC + (60) sizequeue -> . SIZE_QUEUE PA error PC + (45) sizestack -> . SIZE_STACK PA ID PC + (61) sizestack -> . SIZE_STACK PA error PC + (46) deep -> . DEEP PA ID PC + (62) deep -> . DEEP PA error PC + (47) width -> . WIDTH PA ID PC + (63) width -> . WIDTH PA error PC + (48) llamar -> . CALL ID PA valoresCall PC + (49) llamar -> . CALL ID PA PC + + PA shift and go to state 5 + ID shift and go to state 7 + INTEGERVAL shift and go to state 8 + DOUBLEVAL shift and go to state 9 + STRINGVAL shift and go to state 10 + TRUE shift and go to state 11 + FALSE shift and go to state 12 + CEIL shift and go to state 27 + FLOOR shift and go to state 28 + LENGTH shift and go to state 29 + DEQUEUE shift and go to state 30 + POP shift and go to state 31 + GET shift and go to state 32 + GET_P shift and go to state 33 + GET_Q shift and go to state 34 + SIZE shift and go to state 35 + SIZE_QUEUE shift and go to state 36 + SIZE_STACK shift and go to state 37 + DEEP shift and go to state 38 + WIDTH shift and go to state 39 + CALL shift and go to state 40 + + par shift and go to state 118 + opmath shift and go to state 4 + valor shift and go to state 6 + techo shift and go to state 13 + piso shift and go to state 14 + longitud shift and go to state 15 + dequeue shift and go to state 16 + pop shift and go to state 17 + get shift and go to state 18 + getq shift and go to state 19 + getp shift and go to state 20 + size shift and go to state 21 + sizequeue shift and go to state 22 + sizestack shift and go to state 23 + deep shift and go to state 24 + width shift and go to state 25 + llamar shift and go to state 26 + +state 91 + + (6) parAux -> empty . + + $end reduce using rule 6 (parAux -> empty .) + PC reduce using rule 6 (parAux -> empty .) + + +state 92 + + (15) techo -> CEIL PA opmath PC . + + MAS reduce using rule 15 (techo -> CEIL PA opmath PC .) + MENOS reduce using rule 15 (techo -> CEIL PA opmath PC .) + POR reduce using rule 15 (techo -> CEIL PA opmath PC .) + DIVIDIR reduce using rule 15 (techo -> CEIL PA opmath PC .) + DIV reduce using rule 15 (techo -> CEIL PA opmath PC .) + MOD reduce using rule 15 (techo -> CEIL PA opmath PC .) + $end reduce using rule 15 (techo -> CEIL PA opmath PC .) + PC reduce using rule 15 (techo -> CEIL PA opmath PC .) + COMA reduce using rule 15 (techo -> CEIL PA opmath PC .) + + +state 93 + + (16) piso -> FLOOR PA opmath PC . + + MAS reduce using rule 16 (piso -> FLOOR PA opmath PC .) + MENOS reduce using rule 16 (piso -> FLOOR PA opmath PC .) + POR reduce using rule 16 (piso -> FLOOR PA opmath PC .) + DIVIDIR reduce using rule 16 (piso -> FLOOR PA opmath PC .) + DIV reduce using rule 16 (piso -> FLOOR PA opmath PC .) + MOD reduce using rule 16 (piso -> FLOOR PA opmath PC .) + $end reduce using rule 16 (piso -> FLOOR PA opmath PC .) + PC reduce using rule 16 (piso -> FLOOR PA opmath PC .) + COMA reduce using rule 16 (piso -> FLOOR PA opmath PC .) + + +state 94 + + (37) longitud -> LENGTH PA STRINGVAL PC . + + MAS reduce using rule 37 (longitud -> LENGTH PA STRINGVAL PC .) + MENOS reduce using rule 37 (longitud -> LENGTH PA STRINGVAL PC .) + POR reduce using rule 37 (longitud -> LENGTH PA STRINGVAL PC .) + DIVIDIR reduce using rule 37 (longitud -> LENGTH PA STRINGVAL PC .) + DIV reduce using rule 37 (longitud -> LENGTH PA STRINGVAL PC .) + MOD reduce using rule 37 (longitud -> LENGTH PA STRINGVAL PC .) + $end reduce using rule 37 (longitud -> LENGTH PA STRINGVAL PC .) + PC reduce using rule 37 (longitud -> LENGTH PA STRINGVAL PC .) + COMA reduce using rule 37 (longitud -> LENGTH PA STRINGVAL PC .) + + +state 95 + + (53) longitud -> LENGTH PA error PC . + + MAS reduce using rule 53 (longitud -> LENGTH PA error PC .) + MENOS reduce using rule 53 (longitud -> LENGTH PA error PC .) + POR reduce using rule 53 (longitud -> LENGTH PA error PC .) + DIVIDIR reduce using rule 53 (longitud -> LENGTH PA error PC .) + DIV reduce using rule 53 (longitud -> LENGTH PA error PC .) + MOD reduce using rule 53 (longitud -> LENGTH PA error PC .) + $end reduce using rule 53 (longitud -> LENGTH PA error PC .) + PC reduce using rule 53 (longitud -> LENGTH PA error PC .) + COMA reduce using rule 53 (longitud -> LENGTH PA error PC .) + + +state 96 + + (38) dequeue -> DEQUEUE PA ID PC . + + MAS reduce using rule 38 (dequeue -> DEQUEUE PA ID PC .) + MENOS reduce using rule 38 (dequeue -> DEQUEUE PA ID PC .) + POR reduce using rule 38 (dequeue -> DEQUEUE PA ID PC .) + DIVIDIR reduce using rule 38 (dequeue -> DEQUEUE PA ID PC .) + DIV reduce using rule 38 (dequeue -> DEQUEUE PA ID PC .) + MOD reduce using rule 38 (dequeue -> DEQUEUE PA ID PC .) + $end reduce using rule 38 (dequeue -> DEQUEUE PA ID PC .) + PC reduce using rule 38 (dequeue -> DEQUEUE PA ID PC .) + COMA reduce using rule 38 (dequeue -> DEQUEUE PA ID PC .) + + +state 97 + + (54) dequeue -> DEQUEUE PA error PC . + + MAS reduce using rule 54 (dequeue -> DEQUEUE PA error PC .) + MENOS reduce using rule 54 (dequeue -> DEQUEUE PA error PC .) + POR reduce using rule 54 (dequeue -> DEQUEUE PA error PC .) + DIVIDIR reduce using rule 54 (dequeue -> DEQUEUE PA error PC .) + DIV reduce using rule 54 (dequeue -> DEQUEUE PA error PC .) + MOD reduce using rule 54 (dequeue -> DEQUEUE PA error PC .) + $end reduce using rule 54 (dequeue -> DEQUEUE PA error PC .) + PC reduce using rule 54 (dequeue -> DEQUEUE PA error PC .) + COMA reduce using rule 54 (dequeue -> DEQUEUE PA error PC .) + + +state 98 + + (39) pop -> POP PA ID PC . + + MAS reduce using rule 39 (pop -> POP PA ID PC .) + MENOS reduce using rule 39 (pop -> POP PA ID PC .) + POR reduce using rule 39 (pop -> POP PA ID PC .) + DIVIDIR reduce using rule 39 (pop -> POP PA ID PC .) + DIV reduce using rule 39 (pop -> POP PA ID PC .) + MOD reduce using rule 39 (pop -> POP PA ID PC .) + $end reduce using rule 39 (pop -> POP PA ID PC .) + PC reduce using rule 39 (pop -> POP PA ID PC .) + COMA reduce using rule 39 (pop -> POP PA ID PC .) + + +state 99 + + (55) pop -> POP PA error PC . + + MAS reduce using rule 55 (pop -> POP PA error PC .) + MENOS reduce using rule 55 (pop -> POP PA error PC .) + POR reduce using rule 55 (pop -> POP PA error PC .) + DIVIDIR reduce using rule 55 (pop -> POP PA error PC .) + DIV reduce using rule 55 (pop -> POP PA error PC .) + MOD reduce using rule 55 (pop -> POP PA error PC .) + $end reduce using rule 55 (pop -> POP PA error PC .) + PC reduce using rule 55 (pop -> POP PA error PC .) + COMA reduce using rule 55 (pop -> POP PA error PC .) + + +state 100 + + (40) get -> GET PA ID COMA . INTEGERVAL PC + (56) get -> GET PA ID COMA . error PC + + INTEGERVAL shift and go to state 119 + error shift and go to state 120 + + +state 101 + + (41) getq -> GET_P PA ID PC . + + MAS reduce using rule 41 (getq -> GET_P PA ID PC .) + MENOS reduce using rule 41 (getq -> GET_P PA ID PC .) + POR reduce using rule 41 (getq -> GET_P PA ID PC .) + DIVIDIR reduce using rule 41 (getq -> GET_P PA ID PC .) + DIV reduce using rule 41 (getq -> GET_P PA ID PC .) + MOD reduce using rule 41 (getq -> GET_P PA ID PC .) + $end reduce using rule 41 (getq -> GET_P PA ID PC .) + PC reduce using rule 41 (getq -> GET_P PA ID PC .) + COMA reduce using rule 41 (getq -> GET_P PA ID PC .) + + +state 102 + + (57) getq -> GET_P PA error PC . + + MAS reduce using rule 57 (getq -> GET_P PA error PC .) + MENOS reduce using rule 57 (getq -> GET_P PA error PC .) + POR reduce using rule 57 (getq -> GET_P PA error PC .) + DIVIDIR reduce using rule 57 (getq -> GET_P PA error PC .) + DIV reduce using rule 57 (getq -> GET_P PA error PC .) + MOD reduce using rule 57 (getq -> GET_P PA error PC .) + $end reduce using rule 57 (getq -> GET_P PA error PC .) + PC reduce using rule 57 (getq -> GET_P PA error PC .) + COMA reduce using rule 57 (getq -> GET_P PA error PC .) + + +state 103 + + (42) getp -> GET_Q PA ID PC . + + MAS reduce using rule 42 (getp -> GET_Q PA ID PC .) + MENOS reduce using rule 42 (getp -> GET_Q PA ID PC .) + POR reduce using rule 42 (getp -> GET_Q PA ID PC .) + DIVIDIR reduce using rule 42 (getp -> GET_Q PA ID PC .) + DIV reduce using rule 42 (getp -> GET_Q PA ID PC .) + MOD reduce using rule 42 (getp -> GET_Q PA ID PC .) + $end reduce using rule 42 (getp -> GET_Q PA ID PC .) + PC reduce using rule 42 (getp -> GET_Q PA ID PC .) + COMA reduce using rule 42 (getp -> GET_Q PA ID PC .) + + +state 104 + + (58) getp -> GET_Q PA error PC . + + MAS reduce using rule 58 (getp -> GET_Q PA error PC .) + MENOS reduce using rule 58 (getp -> GET_Q PA error PC .) + POR reduce using rule 58 (getp -> GET_Q PA error PC .) + DIVIDIR reduce using rule 58 (getp -> GET_Q PA error PC .) + DIV reduce using rule 58 (getp -> GET_Q PA error PC .) + MOD reduce using rule 58 (getp -> GET_Q PA error PC .) + $end reduce using rule 58 (getp -> GET_Q PA error PC .) + PC reduce using rule 58 (getp -> GET_Q PA error PC .) + COMA reduce using rule 58 (getp -> GET_Q PA error PC .) + + +state 105 + + (43) size -> SIZE PA ID PC . + + MAS reduce using rule 43 (size -> SIZE PA ID PC .) + MENOS reduce using rule 43 (size -> SIZE PA ID PC .) + POR reduce using rule 43 (size -> SIZE PA ID PC .) + DIVIDIR reduce using rule 43 (size -> SIZE PA ID PC .) + DIV reduce using rule 43 (size -> SIZE PA ID PC .) + MOD reduce using rule 43 (size -> SIZE PA ID PC .) + $end reduce using rule 43 (size -> SIZE PA ID PC .) + PC reduce using rule 43 (size -> SIZE PA ID PC .) + COMA reduce using rule 43 (size -> SIZE PA ID PC .) + + +state 106 + + (59) size -> SIZE PA error PC . + + MAS reduce using rule 59 (size -> SIZE PA error PC .) + MENOS reduce using rule 59 (size -> SIZE PA error PC .) + POR reduce using rule 59 (size -> SIZE PA error PC .) + DIVIDIR reduce using rule 59 (size -> SIZE PA error PC .) + DIV reduce using rule 59 (size -> SIZE PA error PC .) + MOD reduce using rule 59 (size -> SIZE PA error PC .) + $end reduce using rule 59 (size -> SIZE PA error PC .) + PC reduce using rule 59 (size -> SIZE PA error PC .) + COMA reduce using rule 59 (size -> SIZE PA error PC .) + + +state 107 + + (44) sizequeue -> SIZE_QUEUE PA ID PC . + + MAS reduce using rule 44 (sizequeue -> SIZE_QUEUE PA ID PC .) + MENOS reduce using rule 44 (sizequeue -> SIZE_QUEUE PA ID PC .) + POR reduce using rule 44 (sizequeue -> SIZE_QUEUE PA ID PC .) + DIVIDIR reduce using rule 44 (sizequeue -> SIZE_QUEUE PA ID PC .) + DIV reduce using rule 44 (sizequeue -> SIZE_QUEUE PA ID PC .) + MOD reduce using rule 44 (sizequeue -> SIZE_QUEUE PA ID PC .) + $end reduce using rule 44 (sizequeue -> SIZE_QUEUE PA ID PC .) + PC reduce using rule 44 (sizequeue -> SIZE_QUEUE PA ID PC .) + COMA reduce using rule 44 (sizequeue -> SIZE_QUEUE PA ID PC .) + + +state 108 + + (60) sizequeue -> SIZE_QUEUE PA error PC . + + MAS reduce using rule 60 (sizequeue -> SIZE_QUEUE PA error PC .) + MENOS reduce using rule 60 (sizequeue -> SIZE_QUEUE PA error PC .) + POR reduce using rule 60 (sizequeue -> SIZE_QUEUE PA error PC .) + DIVIDIR reduce using rule 60 (sizequeue -> SIZE_QUEUE PA error PC .) + DIV reduce using rule 60 (sizequeue -> SIZE_QUEUE PA error PC .) + MOD reduce using rule 60 (sizequeue -> SIZE_QUEUE PA error PC .) + $end reduce using rule 60 (sizequeue -> SIZE_QUEUE PA error PC .) + PC reduce using rule 60 (sizequeue -> SIZE_QUEUE PA error PC .) + COMA reduce using rule 60 (sizequeue -> SIZE_QUEUE PA error PC .) + + +state 109 + + (45) sizestack -> SIZE_STACK PA ID PC . + + MAS reduce using rule 45 (sizestack -> SIZE_STACK PA ID PC .) + MENOS reduce using rule 45 (sizestack -> SIZE_STACK PA ID PC .) + POR reduce using rule 45 (sizestack -> SIZE_STACK PA ID PC .) + DIVIDIR reduce using rule 45 (sizestack -> SIZE_STACK PA ID PC .) + DIV reduce using rule 45 (sizestack -> SIZE_STACK PA ID PC .) + MOD reduce using rule 45 (sizestack -> SIZE_STACK PA ID PC .) + $end reduce using rule 45 (sizestack -> SIZE_STACK PA ID PC .) + PC reduce using rule 45 (sizestack -> SIZE_STACK PA ID PC .) + COMA reduce using rule 45 (sizestack -> SIZE_STACK PA ID PC .) + + +state 110 + + (61) sizestack -> SIZE_STACK PA error PC . + + MAS reduce using rule 61 (sizestack -> SIZE_STACK PA error PC .) + MENOS reduce using rule 61 (sizestack -> SIZE_STACK PA error PC .) + POR reduce using rule 61 (sizestack -> SIZE_STACK PA error PC .) + DIVIDIR reduce using rule 61 (sizestack -> SIZE_STACK PA error PC .) + DIV reduce using rule 61 (sizestack -> SIZE_STACK PA error PC .) + MOD reduce using rule 61 (sizestack -> SIZE_STACK PA error PC .) + $end reduce using rule 61 (sizestack -> SIZE_STACK PA error PC .) + PC reduce using rule 61 (sizestack -> SIZE_STACK PA error PC .) + COMA reduce using rule 61 (sizestack -> SIZE_STACK PA error PC .) + + +state 111 + + (46) deep -> DEEP PA ID PC . + + MAS reduce using rule 46 (deep -> DEEP PA ID PC .) + MENOS reduce using rule 46 (deep -> DEEP PA ID PC .) + POR reduce using rule 46 (deep -> DEEP PA ID PC .) + DIVIDIR reduce using rule 46 (deep -> DEEP PA ID PC .) + DIV reduce using rule 46 (deep -> DEEP PA ID PC .) + MOD reduce using rule 46 (deep -> DEEP PA ID PC .) + $end reduce using rule 46 (deep -> DEEP PA ID PC .) + PC reduce using rule 46 (deep -> DEEP PA ID PC .) + COMA reduce using rule 46 (deep -> DEEP PA ID PC .) + + +state 112 + + (62) deep -> DEEP PA error PC . + + MAS reduce using rule 62 (deep -> DEEP PA error PC .) + MENOS reduce using rule 62 (deep -> DEEP PA error PC .) + POR reduce using rule 62 (deep -> DEEP PA error PC .) + DIVIDIR reduce using rule 62 (deep -> DEEP PA error PC .) + DIV reduce using rule 62 (deep -> DEEP PA error PC .) + MOD reduce using rule 62 (deep -> DEEP PA error PC .) + $end reduce using rule 62 (deep -> DEEP PA error PC .) + PC reduce using rule 62 (deep -> DEEP PA error PC .) + COMA reduce using rule 62 (deep -> DEEP PA error PC .) + + +state 113 + + (47) width -> WIDTH PA ID PC . + + MAS reduce using rule 47 (width -> WIDTH PA ID PC .) + MENOS reduce using rule 47 (width -> WIDTH PA ID PC .) + POR reduce using rule 47 (width -> WIDTH PA ID PC .) + DIVIDIR reduce using rule 47 (width -> WIDTH PA ID PC .) + DIV reduce using rule 47 (width -> WIDTH PA ID PC .) + MOD reduce using rule 47 (width -> WIDTH PA ID PC .) + $end reduce using rule 47 (width -> WIDTH PA ID PC .) + PC reduce using rule 47 (width -> WIDTH PA ID PC .) + COMA reduce using rule 47 (width -> WIDTH PA ID PC .) + + +state 114 + + (63) width -> WIDTH PA error PC . + + MAS reduce using rule 63 (width -> WIDTH PA error PC .) + MENOS reduce using rule 63 (width -> WIDTH PA error PC .) + POR reduce using rule 63 (width -> WIDTH PA error PC .) + DIVIDIR reduce using rule 63 (width -> WIDTH PA error PC .) + DIV reduce using rule 63 (width -> WIDTH PA error PC .) + MOD reduce using rule 63 (width -> WIDTH PA error PC .) + $end reduce using rule 63 (width -> WIDTH PA error PC .) + PC reduce using rule 63 (width -> WIDTH PA error PC .) + COMA reduce using rule 63 (width -> WIDTH PA error PC .) + + +state 115 + + (48) llamar -> CALL ID PA valoresCall . PC + + PC shift and go to state 121 + + +state 116 + + (49) llamar -> CALL ID PA PC . + + MAS reduce using rule 49 (llamar -> CALL ID PA PC .) + MENOS reduce using rule 49 (llamar -> CALL ID PA PC .) + POR reduce using rule 49 (llamar -> CALL ID PA PC .) + DIVIDIR reduce using rule 49 (llamar -> CALL ID PA PC .) + DIV reduce using rule 49 (llamar -> CALL ID PA PC .) + MOD reduce using rule 49 (llamar -> CALL ID PA PC .) + $end reduce using rule 49 (llamar -> CALL ID PA PC .) + PC reduce using rule 49 (llamar -> CALL ID PA PC .) + COMA reduce using rule 49 (llamar -> CALL ID PA PC .) + + +state 117 + + (50) valoresCall -> valor . + (51) valoresCall -> valor . COMA valoresCall + + PC reduce using rule 50 (valoresCall -> valor .) + COMA shift and go to state 122 + + +state 118 + + (5) parAux -> mathsymbol par . + + $end reduce using rule 5 (parAux -> mathsymbol par .) + PC reduce using rule 5 (parAux -> mathsymbol par .) + + +state 119 + + (40) get -> GET PA ID COMA INTEGERVAL . PC + + PC shift and go to state 123 + + +state 120 + + (56) get -> GET PA ID COMA error . PC + + PC shift and go to state 124 + + +state 121 + + (48) llamar -> CALL ID PA valoresCall PC . + + MAS reduce using rule 48 (llamar -> CALL ID PA valoresCall PC .) + MENOS reduce using rule 48 (llamar -> CALL ID PA valoresCall PC .) + POR reduce using rule 48 (llamar -> CALL ID PA valoresCall PC .) + DIVIDIR reduce using rule 48 (llamar -> CALL ID PA valoresCall PC .) + DIV reduce using rule 48 (llamar -> CALL ID PA valoresCall PC .) + MOD reduce using rule 48 (llamar -> CALL ID PA valoresCall PC .) + $end reduce using rule 48 (llamar -> CALL ID PA valoresCall PC .) + PC reduce using rule 48 (llamar -> CALL ID PA valoresCall PC .) + COMA reduce using rule 48 (llamar -> CALL ID PA valoresCall PC .) + + +state 122 + + (51) valoresCall -> valor COMA . valoresCall + (50) valoresCall -> . valor + (51) valoresCall -> . valor COMA valoresCall + (17) valor -> . ID + (18) valor -> . INTEGERVAL + (19) valor -> . DOUBLEVAL + (20) valor -> . STRINGVAL + (21) valor -> . TRUE + (22) valor -> . FALSE + (23) valor -> . techo + (24) valor -> . piso + (25) valor -> . longitud + (26) valor -> . dequeue + (27) valor -> . pop + (28) valor -> . get + (29) valor -> . getq + (30) valor -> . getp + (31) valor -> . size + (32) valor -> . sizequeue + (33) valor -> . sizestack + (34) valor -> . deep + (35) valor -> . width + (36) valor -> . llamar + (15) techo -> . CEIL PA opmath PC + (16) piso -> . FLOOR PA opmath PC + (37) longitud -> . LENGTH PA STRINGVAL PC + (53) longitud -> . LENGTH PA error PC + (38) dequeue -> . DEQUEUE PA ID PC + (54) dequeue -> . DEQUEUE PA error PC + (39) pop -> . POP PA ID PC + (55) pop -> . POP PA error PC + (40) get -> . GET PA ID COMA INTEGERVAL PC + (56) get -> . GET PA ID COMA error PC + (41) getq -> . GET_P PA ID PC + (57) getq -> . GET_P PA error PC + (42) getp -> . GET_Q PA ID PC + (58) getp -> . GET_Q PA error PC + (43) size -> . SIZE PA ID PC + (59) size -> . SIZE PA error PC + (44) sizequeue -> . SIZE_QUEUE PA ID PC + (60) sizequeue -> . SIZE_QUEUE PA error PC + (45) sizestack -> . SIZE_STACK PA ID PC + (61) sizestack -> . SIZE_STACK PA error PC + (46) deep -> . DEEP PA ID PC + (62) deep -> . DEEP PA error PC + (47) width -> . WIDTH PA ID PC + (63) width -> . WIDTH PA error PC + (48) llamar -> . CALL ID PA valoresCall PC + (49) llamar -> . CALL ID PA PC + + ID shift and go to state 7 + INTEGERVAL shift and go to state 8 + DOUBLEVAL shift and go to state 9 + STRINGVAL shift and go to state 10 + TRUE shift and go to state 11 + FALSE shift and go to state 12 + CEIL shift and go to state 27 + FLOOR shift and go to state 28 + LENGTH shift and go to state 29 + DEQUEUE shift and go to state 30 + POP shift and go to state 31 + GET shift and go to state 32 + GET_P shift and go to state 33 + GET_Q shift and go to state 34 + SIZE shift and go to state 35 + SIZE_QUEUE shift and go to state 36 + SIZE_STACK shift and go to state 37 + DEEP shift and go to state 38 + WIDTH shift and go to state 39 + CALL shift and go to state 40 + + valor shift and go to state 117 + valoresCall shift and go to state 125 + techo shift and go to state 13 + piso shift and go to state 14 + longitud shift and go to state 15 + dequeue shift and go to state 16 + pop shift and go to state 17 + get shift and go to state 18 + getq shift and go to state 19 + getp shift and go to state 20 + size shift and go to state 21 + sizequeue shift and go to state 22 + sizestack shift and go to state 23 + deep shift and go to state 24 + width shift and go to state 25 + llamar shift and go to state 26 + +state 123 + + (40) get -> GET PA ID COMA INTEGERVAL PC . + + MAS reduce using rule 40 (get -> GET PA ID COMA INTEGERVAL PC .) + MENOS reduce using rule 40 (get -> GET PA ID COMA INTEGERVAL PC .) + POR reduce using rule 40 (get -> GET PA ID COMA INTEGERVAL PC .) + DIVIDIR reduce using rule 40 (get -> GET PA ID COMA INTEGERVAL PC .) + DIV reduce using rule 40 (get -> GET PA ID COMA INTEGERVAL PC .) + MOD reduce using rule 40 (get -> GET PA ID COMA INTEGERVAL PC .) + $end reduce using rule 40 (get -> GET PA ID COMA INTEGERVAL PC .) + PC reduce using rule 40 (get -> GET PA ID COMA INTEGERVAL PC .) + COMA reduce using rule 40 (get -> GET PA ID COMA INTEGERVAL PC .) + + +state 124 + + (56) get -> GET PA ID COMA error PC . + + MAS reduce using rule 56 (get -> GET PA ID COMA error PC .) + MENOS reduce using rule 56 (get -> GET PA ID COMA error PC .) + POR reduce using rule 56 (get -> GET PA ID COMA error PC .) + DIVIDIR reduce using rule 56 (get -> GET PA ID COMA error PC .) + DIV reduce using rule 56 (get -> GET PA ID COMA error PC .) + MOD reduce using rule 56 (get -> GET PA ID COMA error PC .) + $end reduce using rule 56 (get -> GET PA ID COMA error PC .) + PC reduce using rule 56 (get -> GET PA ID COMA error PC .) + COMA reduce using rule 56 (get -> GET PA ID COMA error PC .) + + +state 125 + + (51) valoresCall -> valor COMA valoresCall . + + PC reduce using rule 51 (valoresCall -> valor COMA valoresCall .) + diff --git a/Modelo/parsetab.py b/Modelo/parsetab.py new file mode 100644 index 0000000..b439997 --- /dev/null +++ b/Modelo/parsetab.py @@ -0,0 +1,93 @@ + +# parsetab.py +# This file is automatically generated. Do not edit. +# pylint: disable=W,C,R +_tabversion = '3.10' + +_lr_method = 'LALR' + +_lr_signature = 'ADD ADD_NODE ADD_TRANS AND ARRAY ASIGNACION BEGIN BOOLEAN CALL CEIL COMA COMENTARIO DEEP DEQUEUE DIFERENTE DIV DIVIDIR DO DOSPUNTOS DOUBLE DOUBLEVAL ELSE END ENQUEUE FALSE FLOOR FOR FUNCTION GET GET_P GET_Q GRAPH ID IF IGUAL INTEGER INTEGERVAL LENGTH LIST MAS MAYOR MAYORIGUAL MENOR MENORIGUAL MENOS MOD MODOREFERENCIA MODOVALOR NOT NULL OR PA PC POP POR PROCEDURE PUNTO PUNTOCOMA PUSH QUEUE RECORD REMOVE REMOVE_NODE REMOVE_TRANS REPEAT SIZE SIZE_QUEUE SIZE_STACK STACK STRING STRINGVAL SUBARRAY THEN TO TRUE UNTIL VAR WHILE WIDTH WRITELNoperacion : paroperacion : SUBARRAYpar : opmathpar : PA par PC parAuxparAux : mathsymbol parparAux : emptyopmath : valoropmath : valor mathsymbol parmathsymbol : MASmathsymbol : MENOSmathsymbol : PORmathsymbol : DIVIDIRmathsymbol : DIVmathsymbol : MODtecho : CEIL PA opmath PCpiso : FLOOR PA opmath PCvalor : IDvalor : INTEGERVALvalor : DOUBLEVALvalor : STRINGVALvalor : TRUEvalor : FALSEvalor : techovalor : pisovalor : longitudvalor : dequeuevalor : popvalor : getvalor : getqvalor : getpvalor : sizevalor : sizequeuevalor : sizestackvalor : deepvalor : widthvalor : llamarlongitud : LENGTH PA STRINGVAL PCdequeue : DEQUEUE PA ID PCpop : POP PA ID PCget : GET PA ID COMA INTEGERVAL PCgetq : GET_P PA ID PCgetp : GET_Q PA ID PCsize : SIZE PA ID PCsizequeue : SIZE_QUEUE PA ID PCsizestack : SIZE_STACK PA ID PCdeep : DEEP PA ID PCwidth : WIDTH PA ID PCllamar : CALL ID PA valoresCall PCllamar : CALL ID PA PCvaloresCall : valorvaloresCall : valor COMA valoresCallempty : longitud : LENGTH PA error PCdequeue : DEQUEUE PA error PCpop : POP PA error PCget : GET PA ID COMA error PCgetq : GET_P PA error PCgetp : GET_Q PA error PCsize : SIZE PA error PCsizequeue : SIZE_QUEUE PA error PCsizestack : SIZE_STACK PA error PCdeep : DEEP PA error PCwidth : WIDTH PA error PC' + +_lr_action_items = {'SUBARRAY':([0,],[3,]),'PA':([0,5,27,28,29,30,31,32,33,34,35,36,37,38,39,42,43,44,45,46,47,48,62,90,],[5,5,49,50,51,52,53,54,55,56,57,58,59,60,61,5,-9,-10,-11,-12,-13,-14,88,5,]),'ID':([0,5,40,42,43,44,45,46,47,48,49,50,52,53,54,55,56,57,58,59,60,61,88,90,122,],[7,7,62,7,-9,-10,-11,-12,-13,-14,7,7,69,71,73,74,76,78,80,82,84,86,7,7,7,]),'INTEGERVAL':([0,5,42,43,44,45,46,47,48,49,50,88,90,100,122,],[8,8,8,-9,-10,-11,-12,-13,-14,8,8,8,8,119,8,]),'DOUBLEVAL':([0,5,42,43,44,45,46,47,48,49,50,88,90,122,],[9,9,9,-9,-10,-11,-12,-13,-14,9,9,9,9,9,]),'STRINGVAL':([0,5,42,43,44,45,46,47,48,49,50,51,88,90,122,],[10,10,10,-9,-10,-11,-12,-13,-14,10,10,67,10,10,10,]),'TRUE':([0,5,42,43,44,45,46,47,48,49,50,88,90,122,],[11,11,11,-9,-10,-11,-12,-13,-14,11,11,11,11,11,]),'FALSE':([0,5,42,43,44,45,46,47,48,49,50,88,90,122,],[12,12,12,-9,-10,-11,-12,-13,-14,12,12,12,12,12,]),'CEIL':([0,5,42,43,44,45,46,47,48,49,50,88,90,122,],[27,27,27,-9,-10,-11,-12,-13,-14,27,27,27,27,27,]),'FLOOR':([0,5,42,43,44,45,46,47,48,49,50,88,90,122,],[28,28,28,-9,-10,-11,-12,-13,-14,28,28,28,28,28,]),'LENGTH':([0,5,42,43,44,45,46,47,48,49,50,88,90,122,],[29,29,29,-9,-10,-11,-12,-13,-14,29,29,29,29,29,]),'DEQUEUE':([0,5,42,43,44,45,46,47,48,49,50,88,90,122,],[30,30,30,-9,-10,-11,-12,-13,-14,30,30,30,30,30,]),'POP':([0,5,42,43,44,45,46,47,48,49,50,88,90,122,],[31,31,31,-9,-10,-11,-12,-13,-14,31,31,31,31,31,]),'GET':([0,5,42,43,44,45,46,47,48,49,50,88,90,122,],[32,32,32,-9,-10,-11,-12,-13,-14,32,32,32,32,32,]),'GET_P':([0,5,42,43,44,45,46,47,48,49,50,88,90,122,],[33,33,33,-9,-10,-11,-12,-13,-14,33,33,33,33,33,]),'GET_Q':([0,5,42,43,44,45,46,47,48,49,50,88,90,122,],[34,34,34,-9,-10,-11,-12,-13,-14,34,34,34,34,34,]),'SIZE':([0,5,42,43,44,45,46,47,48,49,50,88,90,122,],[35,35,35,-9,-10,-11,-12,-13,-14,35,35,35,35,35,]),'SIZE_QUEUE':([0,5,42,43,44,45,46,47,48,49,50,88,90,122,],[36,36,36,-9,-10,-11,-12,-13,-14,36,36,36,36,36,]),'SIZE_STACK':([0,5,42,43,44,45,46,47,48,49,50,88,90,122,],[37,37,37,-9,-10,-11,-12,-13,-14,37,37,37,37,37,]),'DEEP':([0,5,42,43,44,45,46,47,48,49,50,88,90,122,],[38,38,38,-9,-10,-11,-12,-13,-14,38,38,38,38,38,]),'WIDTH':([0,5,42,43,44,45,46,47,48,49,50,88,90,122,],[39,39,39,-9,-10,-11,-12,-13,-14,39,39,39,39,39,]),'CALL':([0,5,42,43,44,45,46,47,48,49,50,88,90,122,],[40,40,40,-9,-10,-11,-12,-13,-14,40,40,40,40,40,]),'$end':([1,2,3,4,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,63,64,89,91,92,93,94,95,96,97,98,99,101,102,103,104,105,106,107,108,109,110,111,112,113,114,116,118,121,123,124,],[0,-1,-2,-3,-7,-17,-18,-19,-20,-21,-22,-23,-24,-25,-26,-27,-28,-29,-30,-31,-32,-33,-34,-35,-36,-52,-8,-4,-6,-15,-16,-37,-53,-38,-54,-39,-55,-41,-57,-42,-58,-43,-59,-44,-60,-45,-61,-46,-62,-47,-63,-49,-5,-48,-40,-56,]),'PC':([4,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,41,63,64,65,66,67,68,69,70,71,72,74,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,91,92,93,94,95,96,97,98,99,101,102,103,104,105,106,107,108,109,110,111,112,113,114,115,116,117,118,119,120,121,123,124,125,],[-3,-7,-17,-18,-19,-20,-21,-22,-23,-24,-25,-26,-27,-28,-29,-30,-31,-32,-33,-34,-35,-36,63,-52,-8,92,93,94,95,96,97,98,99,101,102,103,104,105,106,107,108,109,110,111,112,113,114,116,-4,-6,-15,-16,-37,-53,-38,-54,-39,-55,-41,-57,-42,-58,-43,-59,-44,-60,-45,-61,-46,-62,-47,-63,121,-49,-50,-5,123,124,-48,-40,-56,-51,]),'MAS':([6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,63,92,93,94,95,96,97,98,99,101,102,103,104,105,106,107,108,109,110,111,112,113,114,116,121,123,124,],[43,-17,-18,-19,-20,-21,-22,-23,-24,-25,-26,-27,-28,-29,-30,-31,-32,-33,-34,-35,-36,43,-15,-16,-37,-53,-38,-54,-39,-55,-41,-57,-42,-58,-43,-59,-44,-60,-45,-61,-46,-62,-47,-63,-49,-48,-40,-56,]),'MENOS':([6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,63,92,93,94,95,96,97,98,99,101,102,103,104,105,106,107,108,109,110,111,112,113,114,116,121,123,124,],[44,-17,-18,-19,-20,-21,-22,-23,-24,-25,-26,-27,-28,-29,-30,-31,-32,-33,-34,-35,-36,44,-15,-16,-37,-53,-38,-54,-39,-55,-41,-57,-42,-58,-43,-59,-44,-60,-45,-61,-46,-62,-47,-63,-49,-48,-40,-56,]),'POR':([6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,63,92,93,94,95,96,97,98,99,101,102,103,104,105,106,107,108,109,110,111,112,113,114,116,121,123,124,],[45,-17,-18,-19,-20,-21,-22,-23,-24,-25,-26,-27,-28,-29,-30,-31,-32,-33,-34,-35,-36,45,-15,-16,-37,-53,-38,-54,-39,-55,-41,-57,-42,-58,-43,-59,-44,-60,-45,-61,-46,-62,-47,-63,-49,-48,-40,-56,]),'DIVIDIR':([6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,63,92,93,94,95,96,97,98,99,101,102,103,104,105,106,107,108,109,110,111,112,113,114,116,121,123,124,],[46,-17,-18,-19,-20,-21,-22,-23,-24,-25,-26,-27,-28,-29,-30,-31,-32,-33,-34,-35,-36,46,-15,-16,-37,-53,-38,-54,-39,-55,-41,-57,-42,-58,-43,-59,-44,-60,-45,-61,-46,-62,-47,-63,-49,-48,-40,-56,]),'DIV':([6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,63,92,93,94,95,96,97,98,99,101,102,103,104,105,106,107,108,109,110,111,112,113,114,116,121,123,124,],[47,-17,-18,-19,-20,-21,-22,-23,-24,-25,-26,-27,-28,-29,-30,-31,-32,-33,-34,-35,-36,47,-15,-16,-37,-53,-38,-54,-39,-55,-41,-57,-42,-58,-43,-59,-44,-60,-45,-61,-46,-62,-47,-63,-49,-48,-40,-56,]),'MOD':([6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,63,92,93,94,95,96,97,98,99,101,102,103,104,105,106,107,108,109,110,111,112,113,114,116,121,123,124,],[48,-17,-18,-19,-20,-21,-22,-23,-24,-25,-26,-27,-28,-29,-30,-31,-32,-33,-34,-35,-36,48,-15,-16,-37,-53,-38,-54,-39,-55,-41,-57,-42,-58,-43,-59,-44,-60,-45,-61,-46,-62,-47,-63,-49,-48,-40,-56,]),'COMA':([7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,73,92,93,94,95,96,97,98,99,101,102,103,104,105,106,107,108,109,110,111,112,113,114,116,117,121,123,124,],[-17,-18,-19,-20,-21,-22,-23,-24,-25,-26,-27,-28,-29,-30,-31,-32,-33,-34,-35,-36,100,-15,-16,-37,-53,-38,-54,-39,-55,-41,-57,-42,-58,-43,-59,-44,-60,-45,-61,-46,-62,-47,-63,-49,122,-48,-40,-56,]),'error':([51,52,53,55,56,57,58,59,60,61,100,],[68,70,72,75,77,79,81,83,85,87,120,]),} + +_lr_action = {} +for _k, _v in _lr_action_items.items(): + for _x,_y in zip(_v[0],_v[1]): + if not _x in _lr_action: _lr_action[_x] = {} + _lr_action[_x][_k] = _y +del _lr_action_items + +_lr_goto_items = {'operacion':([0,],[1,]),'par':([0,5,42,90,],[2,41,64,118,]),'opmath':([0,5,42,49,50,90,],[4,4,4,65,66,4,]),'valor':([0,5,42,49,50,88,90,122,],[6,6,6,6,6,117,6,117,]),'techo':([0,5,42,49,50,88,90,122,],[13,13,13,13,13,13,13,13,]),'piso':([0,5,42,49,50,88,90,122,],[14,14,14,14,14,14,14,14,]),'longitud':([0,5,42,49,50,88,90,122,],[15,15,15,15,15,15,15,15,]),'dequeue':([0,5,42,49,50,88,90,122,],[16,16,16,16,16,16,16,16,]),'pop':([0,5,42,49,50,88,90,122,],[17,17,17,17,17,17,17,17,]),'get':([0,5,42,49,50,88,90,122,],[18,18,18,18,18,18,18,18,]),'getq':([0,5,42,49,50,88,90,122,],[19,19,19,19,19,19,19,19,]),'getp':([0,5,42,49,50,88,90,122,],[20,20,20,20,20,20,20,20,]),'size':([0,5,42,49,50,88,90,122,],[21,21,21,21,21,21,21,21,]),'sizequeue':([0,5,42,49,50,88,90,122,],[22,22,22,22,22,22,22,22,]),'sizestack':([0,5,42,49,50,88,90,122,],[23,23,23,23,23,23,23,23,]),'deep':([0,5,42,49,50,88,90,122,],[24,24,24,24,24,24,24,24,]),'width':([0,5,42,49,50,88,90,122,],[25,25,25,25,25,25,25,25,]),'llamar':([0,5,42,49,50,88,90,122,],[26,26,26,26,26,26,26,26,]),'mathsymbol':([6,63,],[42,90,]),'parAux':([63,],[89,]),'empty':([63,],[91,]),'valoresCall':([88,122,],[115,125,]),} + +_lr_goto = {} +for _k, _v in _lr_goto_items.items(): + for _x, _y in zip(_v[0], _v[1]): + if not _x in _lr_goto: _lr_goto[_x] = {} + _lr_goto[_x][_k] = _y +del _lr_goto_items +_lr_productions = [ + ("S' -> operacion","S'",1,None,None,None), + ('operacion -> par','operacion',1,'p_operacion_par','sintactico.py',8), + ('operacion -> SUBARRAY','operacion',1,'p_operacion_subarray','sintactico.py',11), + ('par -> opmath','par',1,'p_par_opmath','sintactico.py',14), + ('par -> PA par PC parAux','par',4,'p_par_parAux','sintactico.py',17), + ('parAux -> mathsymbol par','parAux',2,'p_parAux_mathsymbol','sintactico.py',24), + ('parAux -> empty','parAux',1,'p_parAux_empty','sintactico.py',27), + ('opmath -> valor','opmath',1,'p_opmath_valor','sintactico.py',34), + ('opmath -> valor mathsymbol par','opmath',3,'p_opmath_mathsymbol','sintactico.py',37), + ('mathsymbol -> MAS','mathsymbol',1,'p_mathsymbol_mas','sintactico.py',44), + ('mathsymbol -> MENOS','mathsymbol',1,'p_mathsymbol_menos','sintactico.py',47), + ('mathsymbol -> POR','mathsymbol',1,'p_mathsymbol_por','sintactico.py',50), + ('mathsymbol -> DIVIDIR','mathsymbol',1,'p_mathsymbol_dividir','sintactico.py',53), + ('mathsymbol -> DIV','mathsymbol',1,'p_mathsymbol_div','sintactico.py',56), + ('mathsymbol -> MOD','mathsymbol',1,'p_mathsymbol_mod','sintactico.py',59), + ('techo -> CEIL PA opmath PC','techo',4,'p_techo','sintactico.py',65), + ('piso -> FLOOR PA opmath PC','piso',4,'p_piso','sintactico.py',68), + ('valor -> ID','valor',1,'p_valor_id','sintactico.py',73), + ('valor -> INTEGERVAL','valor',1,'p_valor_integerval','sintactico.py',76), + ('valor -> DOUBLEVAL','valor',1,'p_valor_doubleval','sintactico.py',79), + ('valor -> STRINGVAL','valor',1,'p_valor_stringval','sintactico.py',82), + ('valor -> TRUE','valor',1,'p_valor_true','sintactico.py',85), + ('valor -> FALSE','valor',1,'p_valor_false','sintactico.py',88), + ('valor -> techo','valor',1,'p_valor_techo','sintactico.py',91), + ('valor -> piso','valor',1,'p_valor_piso','sintactico.py',94), + ('valor -> longitud','valor',1,'p_valor_longitud','sintactico.py',97), + ('valor -> dequeue','valor',1,'p_valor_dequeue','sintactico.py',100), + ('valor -> pop','valor',1,'p_valor_pop','sintactico.py',103), + ('valor -> get','valor',1,'p_valor_get','sintactico.py',106), + ('valor -> getq','valor',1,'p_valor_getq','sintactico.py',109), + ('valor -> getp','valor',1,'p_valor_getp','sintactico.py',112), + ('valor -> size','valor',1,'p_valor_size','sintactico.py',115), + ('valor -> sizequeue','valor',1,'p_valor_sizequeue','sintactico.py',118), + ('valor -> sizestack','valor',1,'p_valor_sizestack','sintactico.py',121), + ('valor -> deep','valor',1,'p_valor_deep','sintactico.py',124), + ('valor -> width','valor',1,'p_valor_width','sintactico.py',127), + ('valor -> llamar','valor',1,'p_valor_llamar','sintactico.py',130), + ('longitud -> LENGTH PA STRINGVAL PC','longitud',4,'p_longitud','sintactico.py',137), + ('dequeue -> DEQUEUE PA ID PC','dequeue',4,'p_dequeue','sintactico.py',140), + ('pop -> POP PA ID PC','pop',4,'p_pop','sintactico.py',143), + ('get -> GET PA ID COMA INTEGERVAL PC','get',6,'p_get','sintactico.py',146), + ('getq -> GET_P PA ID PC','getq',4,'p_getq','sintactico.py',149), + ('getp -> GET_Q PA ID PC','getp',4,'p_getp','sintactico.py',152), + ('size -> SIZE PA ID PC','size',4,'p_size','sintactico.py',155), + ('sizequeue -> SIZE_QUEUE PA ID PC','sizequeue',4,'p_sizequeue','sintactico.py',158), + ('sizestack -> SIZE_STACK PA ID PC','sizestack',4,'p_sizestack','sintactico.py',161), + ('deep -> DEEP PA ID PC','deep',4,'p_deep','sintactico.py',164), + ('width -> WIDTH PA ID PC','width',4,'p_width','sintactico.py',167), + ('llamar -> CALL ID PA valoresCall PC','llamar',5,'p_llamar_valoresCall','sintactico.py',172), + ('llamar -> CALL ID PA PC','llamar',4,'p_llamar_vacio','sintactico.py',175), + ('valoresCall -> valor','valoresCall',1,'p_valoresCall_valor','sintactico.py',180), + ('valoresCall -> valor COMA valoresCall','valoresCall',3,'p_valoresCall_varios','sintactico.py',183), + ('empty -> ','empty',0,'p_empty','sintactico.py',189), + ('longitud -> LENGTH PA error PC','longitud',4,'p_longitud_error','sintactico.py',194), + ('dequeue -> DEQUEUE PA error PC','dequeue',4,'p_dequeue_error','sintactico.py',198), + ('pop -> POP PA error PC','pop',4,'p_pop_error','sintactico.py',202), + ('get -> GET PA ID COMA error PC','get',6,'p_get_error','sintactico.py',206), + ('getq -> GET_P PA error PC','getq',4,'p_getq_error','sintactico.py',210), + ('getp -> GET_Q PA error PC','getp',4,'p_getp_error','sintactico.py',214), + ('size -> SIZE PA error PC','size',4,'p_size_error','sintactico.py',218), + ('sizequeue -> SIZE_QUEUE PA error PC','sizequeue',4,'p_sizequeue_error','sintactico.py',222), + ('sizestack -> SIZE_STACK PA error PC','sizestack',4,'p_sizestack_error','sintactico.py',226), + ('deep -> DEEP PA error PC','deep',4,'p_deep_error','sintactico.py',230), + ('width -> WIDTH PA error PC','width',4,'p_width_error','sintactico.py',234), +] diff --git a/Modelo/sintactico.py b/Modelo/sintactico.py new file mode 100644 index 0000000..0a543ad --- /dev/null +++ b/Modelo/sintactico.py @@ -0,0 +1,260 @@ +from Modelo.lexico import * +import ply.yacc as yacc + + + + +def p_operacion_par(p): + 'operacion : par' + +def p_operacion_subarray(p): + 'operacion : SUBARRAY' + +def p_par_opmath(p): + 'par : opmath' + +def p_par_parAux(p): + 'par : PA par PC parAux' + + + + + +def p_parAux_mathsymbol(p): + 'parAux : mathsymbol par' + +def p_parAux_empty(p): + 'parAux : empty' + + + + + +def p_opmath_valor(p): + 'opmath : valor' + +def p_opmath_mathsymbol(p): + 'opmath : valor mathsymbol par' + + + + + +def p_mathsymbol_mas(p): + 'mathsymbol : MAS' + +def p_mathsymbol_menos(p): + 'mathsymbol : MENOS' + +def p_mathsymbol_por(p): + 'mathsymbol : POR' + +def p_mathsymbol_dividir(p): + 'mathsymbol : DIVIDIR' + +def p_mathsymbol_div(p): + 'mathsymbol : DIV' + +def p_mathsymbol_mod(p): + 'mathsymbol : MOD' + + + + +def p_techo(p): + 'techo : CEIL PA opmath PC' + +def p_piso(p): + 'piso : FLOOR PA opmath PC' + + + +def p_valor_id(p): + 'valor : ID' + +def p_valor_integerval(p): + 'valor : INTEGERVAL' + +def p_valor_doubleval(p): + 'valor : DOUBLEVAL' + +def p_valor_stringval(p): + 'valor : STRINGVAL' + +def p_valor_true(p): + 'valor : TRUE' + +def p_valor_false(p): + 'valor : FALSE' + +def p_valor_techo(p): + 'valor : techo' + +def p_valor_piso(p): + 'valor : piso' + +def p_valor_longitud(p): + 'valor : longitud' + +def p_valor_dequeue(p): + 'valor : dequeue' + +def p_valor_pop(p): + 'valor : pop' + +def p_valor_get(p): + 'valor : get' + +def p_valor_getq(p): + 'valor : getq' + +def p_valor_getp(p): + 'valor : getp' + +def p_valor_size(p): + 'valor : size' + +def p_valor_sizequeue(p): + 'valor : sizequeue' + +def p_valor_sizestack(p): + 'valor : sizestack' + +def p_valor_deep(p): + 'valor : deep' + +def p_valor_width(p): + 'valor : width' + +def p_valor_llamar(p): + 'valor : llamar' + + + + + +def p_longitud(p): + 'longitud : LENGTH PA STRINGVAL PC' + +def p_dequeue(p): + 'dequeue : DEQUEUE PA ID PC' + +def p_pop(p): + 'pop : POP PA ID PC' + +def p_get(p): + 'get : GET PA ID COMA INTEGERVAL PC' + +def p_getq(p): + 'getq : GET_P PA ID PC' + +def p_getp(p): + 'getp : GET_Q PA ID PC' + +def p_size(p): + 'size : SIZE PA ID PC' + +def p_sizequeue(p): + 'sizequeue : SIZE_QUEUE PA ID PC' + +def p_sizestack(p): + 'sizestack : SIZE_STACK PA ID PC' + +def p_deep(p): + 'deep : DEEP PA ID PC' + +def p_width(p): + 'width : WIDTH PA ID PC' + + + +def p_llamar_valoresCall(p): + 'llamar : CALL ID PA valoresCall PC' + +def p_llamar_vacio(p): + 'llamar : CALL ID PA PC' + + + +def p_valoresCall_valor(p): + 'valoresCall : valor' + +def p_valoresCall_varios(p): + 'valoresCall : valor COMA valoresCall' + + + + +def p_empty(p): + 'empty : ' + pass + + +def p_longitud_error(p): + 'longitud : LENGTH PA error PC' + print("Tipo de dato invalido, se esperaba una cadena", file=sys.stderr) + +def p_dequeue_error(p): + 'dequeue : DEQUEUE PA error PC' + print("Tipo de dato invalido, se esperaba una variable", file=sys.stderr) + +def p_pop_error(p): + 'pop : POP PA error PC' + print("Tipo de dato invalido, se esperaba una variable", file=sys.stderr) + +def p_get_error(p): + 'get : GET PA ID COMA error PC' + print("Tipo de dato invalido, se esperaba un indice de tipo INTEGER", file=sys.stderr) + +def p_getq_error(p): + 'getq : GET_P PA error PC' + print("Tipo de dato invalido, se esperaba una variable", file=sys.stderr) + +def p_getp_error(p): + 'getp : GET_Q PA error PC' + print("Tipo de dato invalido, se esperaba una variable", file=sys.stderr) + +def p_size_error(p): + 'size : SIZE PA error PC' + print("Tipo de dato invalido, se esperaba una variable", file=sys.stderr) + +def p_sizequeue_error(p): + 'sizequeue : SIZE_QUEUE PA error PC' + print("Tipo de dato invalido, se esperaba una variable", file=sys.stderr) + +def p_sizestack_error(p): + 'sizestack : SIZE_STACK PA error PC' + print("Tipo de dato invalido, se esperaba una variable", file=sys.stderr) + +def p_deep_error(p): + 'deep : DEEP PA error PC' + print("Tipo de dato invalido, se esperaba una variable", file=sys.stderr) + +def p_width_error(p): + 'width : WIDTH PA error PC' + print("Tipo de dato invalido, se esperaba una variable", file=sys.stderr) + + + + +def p_error(p): + if(p != None): + print("Errror de Sintaxis en la linea " + str(p.lineno) + " en el token " + str(p.value)) + else: + print("Errror de Sintaxis") + + + + + +parser = yacc.yacc() + + +while True: + try: + s = input('') + except EOFError: + break + if not s: continue + result = parser.parse(s) + print(result) \ No newline at end of file diff --git a/README.md b/README.md index 7c40edd..e430b1f 100644 --- a/README.md +++ b/README.md @@ -6,7 +6,7 @@ El Objetivo del proyecto propuesto fue desarrollar una herramienta que facilite - Permitir al usuario Observar el árbol de ejecución generado. - Establecer breakpoints (que tiene como función contar las veces que se pasa por la línea marcada) esto para tener un acercamiento de la complejidad del algoritmo digitado. -En la presente rama está el código fuente del analizador léxico usando la librería PLY. +En la presente rama está el código fuente del analizador léxico y el analizador sintáctico usando la librería PLY. ##### Requisitos From 0d340534c19a85fc39a78edcc416e027c7c1e14b Mon Sep 17 00:00:00 2001 From: brayvasq Date: Sun, 26 Aug 2018 18:02:36 -0500 Subject: [PATCH 3/4] =?UTF-8?q?gram=C3=A1tica?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- gramatica.txt.docx | Bin 0 -> 8718 bytes 1 file changed, 0 insertions(+), 0 deletions(-) create mode 100644 gramatica.txt.docx diff --git a/gramatica.txt.docx b/gramatica.txt.docx new file mode 100644 index 0000000000000000000000000000000000000000..99b8ee4ac5e33715a14b5d9151b9f4bbf8202642 GIT binary patch literal 8718 zcmbVxWmH|swl(hV792uw5ALoxxLa^{C%7CexCeI&P6+Pq?k+)t1eXWgd%M&9Uf=PJ zuYSz2&)#S4+O^i2RjX=#kOqgq0D*yl0ikrjlLh&$p*>%_*w`B~SUXu67}=Xyo6x&j zS?0yc%5^fL1j@I)Aw5|n$0WvJJMx2LKlB0r78$En%R4hCxp!oj+NwYv7o@xuzIxTO zx%=xti={7sUg7NKw91v#*Gb7l$#3T!r@eGtYNJ!^p41WNt(UL3 zX)0Ah%mim_K$a1O>J)vu?NJzKX7&g}B@AY_un`tQT$bEnAjUCHdG=nkBaVb*AlDBR zcnTc9z@;zbuv-m!O?MY?X&Z}D&TZ7)wcOl6eR(IKHFSZMyt2c2HwN><`>jX-n)wrp zA&hziv(4R7LyIX8V<=xci-%QhO@a_RR(+qhU71M}9rB|s=%Rsyj0KKbzECH5SI0rl zViC}|Ci>fPVha@)PDKco+Eyc zhK7+u7xp#<1p(oO1OfT*k8wi%Pn;Z#937vdn zwaTN4^a)-Nvi>?0FTt42?W4E73Dda(>&68V-ZA_W2(tWq515{I**(k@(s5-9HJNBM z9fsQ3{9pMKR>wNHq9DG-)QFgvk53*CepFT4PrIsumyfDL`6d$K@Ld8e44=BKJT89% zpT-D+!<)^Cw2eTsxl78__OOk^VV7Kfk`9llSfnhvJ46jGD59#^-b*5@I8>kOF#v|; z?Fq_RsVz;RV`4ZkYiTw!*D9&bm-0Bz?ISvI!Dqq^a@U^+7ipGV0=xKh*HMLvL8dv3 zwKFB7{&u9sKf<9dL*5z4!On6DQ-CF*dRLHpt}(t}*{LX`iEjyWNgXGCNvGKn}x1Tq#PhH&Iw zDn3~ztb`A?fXb4UJ@PNe=V-j?_3}bK8pcnu;)Cu3*V|Pk&cdu&YVOcKiPLfHhP}t| z9#)LI*wG*Cp8PbI)Xtzu<{d|TpXyMHqKlE$T*PMi$pBdo=;V) zMT=o|#m;1&TlRpDUsXdLrU7R(3#*bJ`8!n2uaIAI=<{V%Dk1SgR4 zW0+e9sXoWfL>#V%w@1oyWuF@(ClxE{N00S6W3O8C39twkKoowWd3xo5M`};yX8hRN zj%grlH<+Y9@>iuEJX6g@Tyd-RLFA&`)!sq!1|vEs7L`~@%`O>fxxI>?(2}8|Bn_rS zU;KKm2`N7JSFEE(}LYcV_k>HwSu6PhOEoOP;1VtcJ+nURe^-hG{ z6K6i0(Cc;Z$p2D_lsd&FDfE=}A}%0yh1}xyNfG+cS5N8#66TpkC;rgdy5D4 z09+>fcd z$7q+3gql<+-t@G^loBVNxa2c?WvE$$HC>Pr zJVoiSeiti4%?>k03|VR1>B??9oZTS;F=JpMb5Ko%cJ(1SR0nmE5*}S<@nu7ic2t7k zG=5RT2S*7qw>{txMW1Xv{G9)&aSO4((vlFPI#+Z&@s+Ots)RP!m=_9_xD7`Wc%7fr z(7Jt8nx+JaZ(hJRtfJeg{>U#0S~{dC-^4TtgD$DuNX;8O?lRd{+D^N7L6*?g7VbfU z2$nY?$(2f`;#v*$u~aTy*JMh@-J#%6(bVc=eBQODlT0%*QhAlYuxgFdDNeg{2P$|+ zctGxm+AU8w6x4Y+1Lmyj$re-+7(j645Fsdjz#r<|s_5U#71{}8yMfZc%~3`zuM?-j zLJ8RfNMaK!(gCSNhlTh%+T7)86OWjNScd2NuMJT)?YU`n<7P(`8h_&LVAu$@=BEo@ z&ku~B`%pimUPqF=iPm1DLJse_K^+!c|M`|C$4M|YaMdZJl_Twac(=nxNzkP48AG5& z39Wq6YNnR?8*@$*k-KwE2gdj-Q#aR^H2ouseeuUlW~wd?U$Yv$OdVY&_CB#iOwwV! zeO#xNyQdFpI1#{l%dMW4h81>Dv4Jetm6hdY(WkYOScuA<DxcYxtn4G*3?? zGK`mxop!buoZaxHT{II`r&&3GrP5UKQzM1cg_M?j+`p zVIBIe2OGt^FLqqIWMwVp!^f>ny+)p*(skulmrv8|Yu(ve4*d5C3+#_zSGwNXkkHzY zC*71kvn8yzE6CrA8^EWC^fo6Rwd!#98_jnDbAn?@6SXHqRrr}rx=v)4_<5+`6@02< zs=YxWqlbQPrm%Do*0du^Y5pz$?7_oB78slRP67K2T$LgsIqhw4YYmy~DbMf}7;a;! z3ym9K%86;Uj8@)6wNYhoAHU~J8}6j6Ro5v#BstNHa%VzRyEL>1H%DulAWS#pL5IPV z9g7WK_39H1--cD*zR9+H*{Jx;-E!^B%pAggV~LRsTfuy+vu@2+slk29ua&p7BVD(V z-Rb6ClRR?LDbd(Z>C;anyK*9G%2gbBxFvmJlIm7v)T*l;Ao+KCx1)Ls`%U>gdDys% zj*S)QG#_xP29JkX}Yr% zvNiW`33PQ!R7#N#dK-vM5~fa_Kl;be$u=dopuw5!(Sn3WVY`yhXiPXCGP-|mPNfcH z3w!gR`U`G_^Ck6NqlD8LH!ZZ(#c2xy?q@B%8r>+1JrUzab@Kq(D*{vJ*tJgF;w6p= ziYwMTRJ)c5m z%w721?Y11$f3&yWOQD($R0_+Rp>5fh8@u53rgAwtN^qKbADsgoiRC~$Sv={=h0tw0 z;TT!4X38S&5nGEgVvSU7QxdfG5 zB;u)pGP3ajQ!;0ZSO^BQxR}*r@+H3wg?c8;go(&V%R@zOh08z3&@pB zFqFP=4BU2Ap1iKlhoh8+b(M87P8jE8t4uW|T9<%-lnX}-Od}Qfff*Q1@`_oI*>!bD zsM;($n+|6)cEgg;L9`Qx41P65j+^@kncn)~ol4WW%6q2ux7{ zLO_J#bO0gy>csoN)R{s>b#v^6W3q1V3xgA2o|gQwpkU3DA`c~v=~5p{3M_hq;Gq5|oxyvyg;va_GL_mq|dl|zVSDQd>J|u#BF?MQa!uPTTM5z9ABQUIP4rED@m&GC>89a1wk8)nD)> z2Q^W;d732}-zq+#-Jsjxu*zp7$a=Z~L;7cf2uMkcedV4#O7iN28mtaL@KL2g?Fpj@pYkdC(V6S`2!y;^h;&TVBw>*Sct6>$2 z)GYXO7_94M219)D#{UP_gx-ScvxZF2z?m`p9iwSq?%YuQ6T*vFwZ5-Yn?DjoE6^ur z2)FHdB(}Z%goDDL@#cP@Z;_~bedRa zY`BNBb|QA{8lX*7?r_eWxL4Jgqzpu;ZPKs+CyjcuyS?dF1dqvtd0a{Iwn1R58RKa% z@*Emj1F4%asOocKxVspi zUnURqQHds)?)mU~s%nFT9_`>X^lxB>ILR=m>+e%ZtdBe6yD^8Igxlu$49J%)>l)16 zsFMUam{dv8?6D+Rr7+O!QSww@QF)4+eCvgf|H9mb*XzmO@r9NqN=EhKR=uVj8#1L{ z^U7QsW`qS4!$Zx>z1$*8hXwNkJf~2fey-`jb-`<)>yy4S;UAh5ZLyR3VV99M4LJ(m z9~X7fau*risV_0|h8a;}OSXdw26*tr)nq*>?Is!>)rKIZQeI0}=7!@}b02zGvIN06 zZz|Bmwvl^YCLb`yXR$nmUT}gkQLVo9AX^e6S$y#*<|3JLx3$dBN?x)U%$r7Gvm|mL zZahZ)Wjl_aIarxVo?$}V7|4%|?%;D01zxju()mocix)zLtiR&qUr_~swBh*Tmkq}m zV6mE3$=SB$y(q1%)6$~%!(~O$lUO(r0fDoHle5@%fntfk5SLP3mxfMjl!g66u{!uc zqG~v0czx>+Bf!*IH!^g|t$(+ty(aU`;B4F=T?cEBk;qDU-G#=HBSB0CCY}J@&WFQiQi-@jY!E74ax?qvQ6ze%d28YLN|rbA zL;6z8c{zk2$;9U3kPnavSPN3-e({B32mu6p4_EWT^My-3?(itMn`u>~#3GbkEO`FF z+NK`WHA*rTaEpC+S?gEv6&_`J@05SO+|1oy(&~1bJxMc@@ zP|PPFNt{HtK>!>1sKdgNt{0bvdLUhGrgv8+4M&8|l<&j)U3)W&%!&7MReQ{!cGthH zfJ&-!P#B*?wfn(xwV2CuglRcX7z&X>+5y|+9Oe{LwgOag2cR8|m~Tx*>5ZmXVcbyh ze&mMjIIkL4J%|~`F2-W=w4gW0k%!| z;2O>UdRjzhI!apkJPzvT6Qh3~DdvBY#L?8q%820=nO=9d>e4og>;$dIb1uY=Hb(O* z`w&i{bCru_viRiI!GvbOgt-sd0uz#+_zRmppq=0KgE8l}%@wwsWFEBgj%2V6dBg_kd~ zk4@L1ds&@sX!nd~ek(!y*N$qO>X7_fMDa_Ta$0zow4^_0-U~9(MNg zhGV>WcUwaaez`BFE1nI4%$>I>n1C)G)~Aic6+jIHhcz{_)z6e}usudV-kTRp+Nsi9 z_aLllwbh%`3`e*_uBNRoi#~AUFCR-mo{apYfxmvtn~pce%;wgM33orrVk@sSy}}UOt?giat~UI!mIAyn;FgCev23>46#OBFv;R z1=2()hPj5dTiO{oo_|n8y9~d{!3dB2@lCz|X^W(@3w=wo9aw{mENvr6QDMU{@fHU$ z6M)LA=L&`?YB{fFW0r0omi|T}s}aMAk?p&oK=6Q!V}uw=B2ZE=#HIVarpt$57W6yW zDqT?_Wj$j9Nww|>)l;?gzCxzRq{t>;Wm5%v7t*HC&OAQ}=m5K^b6^~0il%`A;EJmT z$ziU3j=Y#OFx!K23vs9+a%szB8ATijFu@Dvx+H6Weiu5kxF5O+z#=^$H|%sc!)# zfwgfi&ir|L4s|z0#tXY0_-r(q&QWi{RkJ~>A(;eQ7#f*ozn)eS_YVd4+6z#I! zBg!Pf4|{{){{H;%tSCTEH$x6$%eh*j$$TBFmg#9AzYupQ1_gV5Wx^n%v)Zmmn0<1p zI&tqYG@o^39OG)4jbd1fBZK|^Z~~(7TN~BzcwKiO9H(Ozd9IFbTT4biSTjnTXfc|> z5BNPL)hhl2P0r6v{g7D;S)gbbTwmZINfwJM&LNEDv{wlW!bABKi)mu-T_i4H@pGpe zV-{?(Y!_tV#0|gQWX|XB<3T;tU$0Gg=0%uL7P=)2e=TD3vZ7J*;>DD!2DRAOHx4^E zp7>(&sYG@y!FPhebVI zxXnkbY3(jgH*}Wg%iCv0vc;R>{EYQ<5tn)+M^9YaOm3Mbqqb&}Dj})GpZqO1Y2{RE z;}FZlpv^eO!IN;iN;Dze;Pl|zA;v(ew(-!)NxGE*Mn3NjqCv0XJKja&3{{N(4UtZP2p!@>G=#*SIN!R$U*yMv8j!fweEOP zlE=73R#dviM3t2xupZRww8y{^Mj%RW<Mp#Q(ErzVr z6CfBzX^c$U+cW_?gkAb!HKO-wp{otYwW};RMK+_-H)3<+hwZ9{Dx8A-3#UTMy}tJ%BOkL8My zP(Z`NmH2?6D(?JG0z2=28k8(bc_|ETk_8K{HFsKod|@~BB-4Rc<7$!_8}t_nh|o1i zcrXglA;id5<(ad^&1JX|M@snYZgl;{QSEJk#PY-C{Hv13@)fzB_IX{WgLrW^C>RFF zpSu0;O7V-9_t*BnRs6r(|E?0g=*fS!!si}e?SEI7|8D-fNcGq551&h}SM$FJi+{KO z{XqUj%KEdFKFePJ>i!R5>+i~hZumQmUTU*H+XD8#KjH6{+TUOCdvd(+?awAj_ literal 0 HcmV?d00001 From 4b87ffe4214b036915fbf5e876ece172cc8ac5d4 Mon Sep 17 00:00:00 2001 From: brayvasq Date: Sun, 26 Aug 2018 18:05:13 -0500 Subject: [PATCH 4/4] =?UTF-8?q?gram=C3=A1tica=20txt?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- gramatica.txt | 162 +++++++++++++++++++++++++++++++++++++++++++++ gramatica.txt.docx | Bin 8718 -> 0 bytes 2 files changed, 162 insertions(+) create mode 100644 gramatica.txt delete mode 100644 gramatica.txt.docx diff --git a/gramatica.txt b/gramatica.txt new file mode 100644 index 0000000..b8009fd --- /dev/null +++ b/gramatica.txt @@ -0,0 +1,162 @@ +declaracionPrincipal -> VAR especiales declaracion +declaracion -> variable declaracion | € +variable -> nombresV DOSPUNTOS tipo PUNTOCOMA | nombresV DOSPUNTOS tipo ARRAY PUNTOCOMA +tipo -> INTEGER | DOUBLE | STRING | BOOLEAN | ARRAY | STACK | QUEUE | LIST | GRAPH +nombresV -> ID | ID COMA nombresV + +asignar -> arregloID ASIGNACION operacion PUNTOCOMA | arregloID ASIGNACION NULL PUNTOCOMA | asignarRecord +arregloID -> ID | ID ARRAY + + +par -> opmath | PA par PC parAux +opmath -> valor mathsymbol par | valor +mathsymbol -> MAS | MENOS | POR | DIVIDIR | DIV | MOD +techo -> CEIL PA opmath PC +piso -> FLOOR PA opmath PC +parAux -> mathsymbol par | € + + +valor -> ID | INTEGERVAL | DOUBLEVAL | STRINGVAL | TRUE | FALSE | techo | piso |longitud | dequeue | pop | get | getq | getp | size | sizequeue | sizestack | deep | width | llamar + + + +longitud -> LENGTH PA STRINGVAL PC PUNTOCOMA + + +llamar -> CALL ID PA valoresCall PC | CALL ID PA PC +valoresCall -> valor | valor COMA valoresCall + + +dequeue -> DEQUEUE PA ID PC +pop -> POP PA ID PC +size -> SIZE PA ID PC +sizequeue -> SIZE_QUEUE PA ID PC +sizestack -> SIZE_STACK PA ID PC +get -> GET PA ID COMA INTEGERVAL PC +getq -> GET_P PA ID PC +getp -> GET_Q PA ID PC +deep -> DEEP PA ID PC +width -> WIDTH PA ID PC + + + + + + +especiales -> registro especiales | funcion especiales | procedimiento especiales | € + + + +parametros -> MODOVALOR ID| MODOREFERENCIA ID | MODOVALOR ID COMA parametros | MODOREFERENCIA ID COMA parametros + + + +funcion -> FUNCTION ID PA parametros PC bloqueFuncion PUNTOCOMA +procedimiento -> PROCEDURE ID PA parametros PC bloque PUNTOCOMA +registro -> RECORD ID BEGIN declaracion END PUNTOCOMA | € + + + + + + + +asignarRecord -> ID punto ID ASIGNACION operacion PUNTOCOMA | ID punto asignarRecord + + + + + + +operacion -> par | SUBARRAY + + + + +escribir -> WRITELN PA par PC PUNTOCOMA + + + + + +addList -> ADD PA ID COMA valor PC PUNTOCOMA +enqueue -> ENQUEUE PA ID COMA valor PC PUNTOCOMA +push -> PUSH PA ID COMA valor PC PUNTOCOMA +addnode -> ADD_NODE PA ID COMA valor PC PUNTOCOMA +addtrans -> ADD_TRANS PA ID COMA valor COMA valor COMA valor PC PUNTOCOMA + + + + + + + + + + +remove -> REMOVE PA ID COMA valor PC PUNTOCOMA + + +remove_node -> REMOVE_NODE PA ID COMA valor PC PUNTOCOMA +remove_trans -> REMOVE_TRANS PA ID COMA valor COMA valor COMA valor PC PUNTOCOMA + + + + + + + + + + + + + + + + + + + + +para -> FOR ID ASIGNACION INTEGERVAL TO INTEGERVAL DO bloque +mientras -> WHILE PA condicion PC DO bloque +repetir -> REPEAT bloqueContenido UNTIL PA condicion PC + + + + + +si -> IF PA condicion PC THEN bloque sino +sino -> ELSE bloque | € + + + + + +condicion -> negacion par comparar par continuidad +comparar -> MAYOR | MENOR | MAYORIGUAL | MENORIGUAL | IGUAL | DIFERENTE +oplogico -> AND | OR +continuidad -> oplogico condicion | € +negacion -> NOT | € + + + + + + + + +bloqueP -> declaracionPrincipal bloque +bloque -> BEGIN bloqueContenido END +bloqueFuncion -> BEGIN bloqueContenido retorno END *** SOLO VA UN RETORNO DEBEMOS MIRAR ESO SI DIOS QUIERE*** +retorno -> RETURN valor | € +bloqueContenido -> si bloqueContenido| para bloqueContenido | mientras bloqueContenido | repeat bloqueContenido | asignar bloqueContenido | escribir bloqueContenido |€ + + + + + + + + diff --git a/gramatica.txt.docx b/gramatica.txt.docx deleted file mode 100644 index 99b8ee4ac5e33715a14b5d9151b9f4bbf8202642..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 8718 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