diff --git a/.gitignore b/.gitignore index 4acafde1..12a6959c 100644 --- a/.gitignore +++ b/.gitignore @@ -394,7 +394,8 @@ dmypy.json .pyre/ ### VisualStudioCode ### -.vscode/* +.vs/ +.vscode/ !.vscode/settings.json !.vscode/tasks.json !.vscode/launch.json diff --git a/doc/Gramatica.md b/doc/Gramatica.md new file mode 100644 index 00000000..672139c5 --- /dev/null +++ b/doc/Gramatica.md @@ -0,0 +1,72 @@ +# Gramática usada +En lo siguiente mostraremos la gramática BNF usada para la realización de nuestro compilador: +``` +program : classdec program + | classdec +classdec : class type lbracket featurelist rbracket pcoma + | class type inherits type lbracket featurelist rbracket pcoma +featurelist : feature featurelist + | empty +feature : attribute pcoma + | methoddef pcoma +methoddef : id lparen rparen dpoint type lbracket expression rbracket + | id lparen param paramslistdef rparen dpoint type lbracket expression rbracket +paramslistdef : coma param paramslistdef + | empty +param : id dpoint type +attribute : id dpoint type + | id dpoint type assign expression +empty : +expression : constantexp + | identifier + | assignment + | dispatch + | conditional + | loopexp + | blockexp + | letexp + | caseexp + | newexp + | isvoidexp + | aritmetica + | comparison + |parenexpression +dispatch : id lparen rparen + | id lparen expression expressionparams rparen + | expression point id lparen rparen + | expression point id lparen expression expressionparams rparen + | expression arroba type point id lparen rparen + | expression arroba type point id lparen expression expressionparams rparen +expressionparams : coma expression expressionparams + | empty +conditional : if expression then expression else expression fi +loopexp : while expression loop expression pool +blockexp : lbracket expressionlist rbracket +expressionlist : expression pcoma expressionlist + | empty +letexp : let attribute letattributelist in expression +letattributelist : coma attribute letattributelist + | empty +caseexp : case expression of subcase listcase esac +listcase : subcase listcase + | empty +subcase : id dpoint type implica expression pcoma +newexp : new type +isvoidexp : isvoid expression +aritmetica : expression plus expression + | expression minus expression + | expression mult expression + | expression div expression + | intnot expression +comparison : expression less expression + | expression lesse expression + | expression equal expression + | not expression +parenexpression : lparen expression rparen +constantexp : number + | string + | true + | false +identifier : id +assignment : id assign expression +``` \ No newline at end of file diff --git a/doc/Readme.md b/doc/Readme.md index 402477c8..9cab301e 100644 --- a/doc/Readme.md +++ b/doc/Readme.md @@ -4,9 +4,8 @@ **Nombre** | **Grupo** | **Github** --|--|-- -Nombre1 Apellido1 Apellido2 | C4xx | [@github_user](https://github.com/) -Nombre2 Apellido1 Apellido2 | C4xx | [@github_user](https://github.com/) -Nombre3 Apellido1 Apellido2 | C4xx | [@github_user](https://github.com/) +José Gabriel Navarro Comabella | C412 | [@TTigre](https://github.com/TTigre) +Alberto Helguera Fleitas | C412 | [@Al3ERT](https://github.com/Al3ERT) ## Readme diff --git a/doc/Reporte.md b/doc/Reporte.md new file mode 100644 index 00000000..3eb2e3b2 --- /dev/null +++ b/doc/Reporte.md @@ -0,0 +1,128 @@ +# Reporte sobre el desarrollo del compilador +En este reporte expondremos los requerimientos y forma de uso de nuestro compilador, además daremos un repaso sobre el diseño del mismo y sus distintas fases. +## Formas de uso y requeriminetos +Nuestro compilador fue desarrollado en el lenguaje **Python** y actualmente para ser usado solo necesita del uso de módulo **ply** del mismo. +Para ser ejecutado solo se debe dirigir a `\src` en nuetro proyecto y ejecutar `python TigerandButiCompiler.py {input}` donde _input_ sería la dirección del archivo a compilar, como resultado se obtendrá un archivo _.mips_ con el mismo nombre del archivo original que luego podrá ser ejecutado por `spim`, simulador de **MIPS**. +## Estructura del proyecto +La totalidad del mismo se halla en `\src` siendo *TigerandButiCompiler* nuestro archivo principal además de contener las definiciones del lexer y el parser y en _AST_ se define el AST generado por nuestro parser. +Para la fase de chequeo semántico se creó *Semantics_Checking* donde se realiza el chequeo semántico, apoyándose en *Scope* donde se define el concepto de Scope y en *Cool_Type* donde se define el concepto de tipo de COOL además de definir los tipos básicos. +En la fase de generación de código se adiconan bastantes nuevos elementos como *CIL* donde se define un AST para la versión de CIL utlizada en nuestro proceso de compilación, en *ASTtoCIL* se realiza el proceso de convertir nuestro, AST generado por el parser, en un nuevo AST de CIL y en *DefaultClasses* se definen las clases básicas de COOL como nodos del AST original para ser aprovechadas, además se definen algunos métodos útiles para convertir los llamados a métodos basicos en código MIPS. Luego en *CILtoMIPS* se realiza la conversión de nuestro AST de CIL en un código en MIPS, para hacerlo se apoyan en un Scope usado para este caso definido en *ScopeMIPS* y en el archivo *AssemblyMethods* dentro de `\StaticCode` donde se definen la mayor parte de de los métodos básicos en código MIPS. +## Fases de desarrollo +El proyecto fue dividido en disitintas fases para su implementación, estas fueron: + 1. Lexing + 2. Parsing + 3. Semantic Checking + 4. Code Generation + +![Image](images/Estructura.png "Diagrama 1") + +A continuación daremos un resumen de como se desarrollaron las mismas así como algunas de las problemáticas principales que hallamos +### Lexing +Para su realización se analiza el programa de izquierda a derecha donde las diferentes componentes son agrupadas en *tokens*, componente lexico básico que tiene un significado. Durante este proceso se elimina del programa toda información innecesaria, espacios y comentarios por ejemplo, por lo que se puede decir que en esta fase el *Lexer* transforma el programa de entrada en una secuencia de los ya mencionados *tokens*. +Todo *token* obtenido como resultado de este proceso tendrá un lexema, string que lo identifica, y un tipo, string que define el tipo de *token* que es. Se definieron todas las palabras reservadas según las especificaciones del Manual de COOL primeramente y luego otros tipos como los string o identificadores de variables. El tipo y lexema de un *token* pueden coincidir o no; un ejemplo claro sería un string de **COOL** ya que su tipo seria `string` y su lexema puede ser cualquier string válido comparado con una palabra reservada del lenguaje, las cuales tienen un lexema fijo igual a su tipo. +La construcción de este lexer se realiza mediante el uso de la ya mencionada herramienta PLY en su submódulo **lex**. Para lograrlo se deben definir los distintos tipos de tokens en una lista, en este caso una variable **tokens**; luego se debe realizar una definición de que secuencia de caracteres son aceptados por cada *token* mediante el uso de expresiones regulares, en este caso esto es realizado dentro de un método `t_{name}`, siendo **name** el nombre del token a definir debido a la convención de **lex**. Un ejemplo de ello sería: +```python +def t_false(t): + r'false' + t.lexer.ty="Bool" + return t +``` +Es válido destacar que en el caso de los comentarios fue tomada la decisión de eliminarlos del texto del código en COOL mediante un preprocesamiento para hacer más facil nuestro trabajo. +### Parsing +La próxima fase sería el utilizar los *tokens* producidos y a partir de él construir un AST (árbol de sintaxis abstracta) del programa, quedando de esta forma validado el programa sintácticamente. +El proceso sería el siguiente, luego de obtener todos los tokens de nuestro programa de COOL gracias a **lex** los mismos son pasados a el otro submódulo de **ply** llamado **yacc**, el cual usamos para realizar la implementación. En el mismo mediante una definicion de una gramática BNF (Backus-Naur Form), usando los tokens dados por el lexer usado anteriormente, se logra la creación de un AST para el programa en COOL. +El proceso de definición de esta dependió sobre todo de los nodos definidos en el AST de COOL, mencionado antes, y de la gramática para programas válidos de COOL dada por nosotros. +Para la creación de las distintas producciones de la gramática, usando la convención de **yacc**, se crea una función `p_{name}` siendo **name** el nombre de la producción. Esta función comenzaría con un dosctring en forma EBNF (Extended BNF) para definir la forma de la producción, en el caso de **yacc** se usa los dos puntos (:) para separar el símbolo inicial de la producción del resto de la misma. Luego en el cuerpo de la función se definen los pasos que se necesiten para construir el o los nodos del AST que sean convenientes. Para acceder a los distintas partes de la producción se indexa sobre el parámetro de la producción (en el caso de **yacc** es usado comúnmente **p**) a partir de 1 y el resultado de la producción se guarda en 0. Además de guardan en los nodos del AST las posiciones en línea y columna de los mismos para posteriormente ser usados en el señalamiento de errores. Un ejemplo de ello sería lo siguiente: +```python +def p_conditional(p): + '''conditional : if expression then expression else expression fi''' + p[0] = ConditionalNode(predicate = p[2], then_body = p[4], else_body = p[6]) + (linea,columna) = posicion(p) + p[0].index = columna + p[0].line = linea + pass +``` +Con todo esto listo **yacc** genera un parser shift_reduce LALR(1) para nuestra gramática, Vale aclarar que a pesar de no poderse cubrir todo tipo de gramáticas mediante un parser de este tipo se realizaron ligeros cambios a la gramática que aparece en el Manual de COOL para lograr desambiguarla para este tipo de parser, con lo cual se obutvo la que se usa actualmente en nuestro programa. +Uno de los procesos mas engorrosos fueron los llamados a los distintos tipos de Dispatch ya que estos poseen varias definiciones según la forma en que se llame. Otra problemática que tuvimos fue debido al orden en que debía quedar el AST, debido a la ambigüedad existente en la gramática de **COOL** en el manual, lo cual se solucionó mediante la declaración de la precedencia entre distintos operadores. +Es bueno destacar que en aras de optimizar un poco el algoritmo y código generado se decidió preoperar las operaciones artiméticas o de comparación en que solo participen constantes enteras para lograr hacer un poco mas simple nuestro árbol y con ello el código final generado. Además se hizo un análisis de los métodos a los que se les realiza Dispatch para podar luego los que jamás son utilizados. +### Semantic Checking +En esta fase se desea asegurar el cumplimiento de los predicados semánticos definidos en el lenguaje, por lo cual se va a reunir informacón sobre el programa mediante el uso de distintos algoritmos y estructuras. +Debido la conveniencia del AST obtenido en la fase anterior el mismo es recorrido por nosotros para realizar este chequeo, este proceso se realiza mediante el uso del patrón **visitor**, potente herramienta que permite abstraer el recorrido de las acciones a realizar, con el cual comenzando desde el primer nodo del AST devuelto por **yacc**, se puede ir recorriendo la totalidad de estos. +Para usar este patrón se define una clase `Semantic_Checker` en la cual aparecen varios métodos auxiliares y se encuentran definidos los distintos métodos que utilizan el patrón para recorrer el árbol. Durante todo este proceso de recorrido se van guardando las clases, variables, atributos y métodos mediante el concepto de `Scope`, las cuales se actualizan durante el recorrido del mismo, exceptuando el caso de las clases que son guardadas al inicio del recorrido. Además se utiliza a la clase `Cool_Type` para guardar información sobre los clases y definir algunos métodos auxiliares necesarios para el desarrollo de este proceso. +Por cada nodo del AST, en que se vea necesario, se intenta inferir un tipo estático el cual es guardado en el mismo y devuelto hacia su nodo padre para que sea utilizado por él en su propio chequeo. Los errores que pueden levantarse en este proceso han sido definidos según el Manual de COOL para lograr su correcta implementación. +Una problemática a destacar fue el caso de hallar las clases con herencia cíclica, este proceso se realiza al comienzo del chequeo tratando de por cada nodo de clase, en estado 0 de no haber sido definido anteriormente, llegar a un antecesor común ya definido (estado 2), al comienzo este será Object, para luego definirse, si durante esta búsqueda se topa con un nodo que también está en medio del proceso (estado 1) significa que existe un ciclo por lo cual se devuelve un error. Ahora un diagrama en que se ve un estado intermedio de este proceso comenzando desde la clase C. +![Image](images/Diagrama.jpg "Diagrama 1") +Como se puede apreciar al comenzar se chequea que la clase C esta en el estado inicial 0, por lo que se pasa a chequear su antecesor directo y se cambia su estado a 1, en este caso A. Al estar A también en el estado 0 este pasa a estado 1 y se procede a revisar a su padre Object, al estar Object en estado 2 entonces se vuelve a A el cual pasa a estado 2 y de este a C que también pasa a estado 2. La clase B se mantiene todo el tiempo en estado 0 en este caso ya que no pertenece a los ancestros de A. Como ya se mencionó, un error durante este proceso sería que durante el proceso de revisar a los antecesores se tope con una clase en estado 1 lo cual sería imposible a menos que estemos en un ciclo por lo cual se lanza el error. + +### Codegen +Usando el AST que ya pasó por el semántico y con cierta información de tipos estáticos agregada procedemos a la generación de código intermedio que más tarde se utilizará para producir código MIPS; todo mediante el uso del patrón visitor. + +#### CIL +Los componentes del lenguaje CIL son bastante simples. Se encuentra integrado por: +* Instrucciones de a lo sumo dos operadores y un destino. +* Definición de Strings como Data: +* Definición de métodos como globales, que contienen las instrucciones, una lista de parámetros y de variables locales. +![Image](images/CILGlobalMethod.png "Diagrama 1") +* Definición de clases con un mapeo de sus nombres de métodos a los globales, así como definición de sus atributos. En esta definición se incluyen elementos que le pertenecen a su padre antes de los propios, conservando el orden en que se encuentran en el padre. Vale la pena mencionar en que el orden de los métodos y atributos definidos en su padre conservan el mismo orden y son los primeros. +![Image](images/CILClass.png "Diagrama 1") +* Programa CIL, que contiene todo lo anterior. +![Image](images/ProgramaCIL.png "Diagrama 1") + +La lista de instrucciones CIL se adjunta a continuación: +* CILTypeCheck: Usado en los case +* CILBinaryOperator: Que incluye a los operadores aritméticos y de comparación +* CILUnaryOperator: Incluye el complemento y el is void +* CILLabel: Para usar en los ciclos y condicionales como dirección destino de los saltos +* CILJump y CILConditionalJump: Usados para los saltos +* CILAllocate: Usado al crearse un nuevo objeto +* CILArgument: Usado para pasar parámetros a un método. Después de esta instrucción solo puede venir una del mismo tipo o una llamada a un método. +* CILCall y CILVirtualCall: El primero realiza una llamada normal y el segundo recibe un tipo y realiza la llamada asumiendo dicho tipo. +* CILStringLoad: Utilizada para cargar strings predefinidos. +* Instrucciones específicas: Instrucciones utilizadas en las clases base, como leer y escribir de la entrada estándar y manipulación de strings. + +Para lograr la conversión se agregan las clases por defecto y luego se ordenan las clases de forma que todo elemento siempre aparecerá antes que su hijo; lo que permitirá al analizar una clase ya haber analizado a sus ancestros. Seguidamente se mapean los métodos de clase a métodos globales que se poblarán más tarde. Ya en este paso se recopila la información de la clase que será utilizada en la **CILClass**. +![Image](images/ASTtoCIL.py.png) + +Por cada clase predefinida se le agrega a sus métodos globales el código CIL ya predefinido. Luego por cada clase se agrega su método **$init**, utilizado en la creación de instancias para asignarle valores a los atributos con valores ya definidos; en dicho método se llama al equivalente de su padre en caso de tenerlo, para luego evaluar sus propias expresiones. Por cada método de clase se realiza la transformación de sus nodos a instrucciones CIL que luego se guardan encapsuladas en un método global. En todo momento se sigue la política de que en el destino de la última instrucción contiene el resultado de la expresión analizada, incluyendo los mismos métodos. Aquí se omiten los métodos que se haya detectado desde el parser que nunca serán usados. + +La información anteriormente obtenida permite formar un Programa CIL, que constituye la salida de esta parte del programa. + +#### MIPS +Dado el programa CIL se lleva a una transformación a MIPS. +Una parte importante para entender la estructura es la representación de las instancias de clase. Toda instancia se guarda como una referencia a un conjunto de palabras, de las cuales la primera siempre es una referencia a su definición de clase y el resto son los atributos. Una variable que contenga una instancia en realidad lo que contendrá será una referencia a esta. +![Image](images/Instancia.png) + +##### Valores void +Para representar los valores void se le da de valor a la referencia a una instancia en un inicio el valor 0, por lo que saber si es void puede ser tan simple como preguntar si es igual a 0 la referencia a instancia. + +##### Qué es la definición de clase? +Se puede observar al inicio del programa con la forma *Nombreclase: .word Padreclase, f1, f2...*, que no es más que una ubicación en el heap donde se encuentra guardada la direccion de la definicion de su clase padre, seguida por las direcciones de sus métodos. Es el descriptor de los elementos estáticos de una clase es decir su padre y sus métodos. +![Image](images/Definicióndeclase.png) + +##### Llamada a un método +La llamada a los métodos tiene un indicador de la posición relativa a su definición de clase. Dependiendo del caso se busca la definición de clase a través de su referencia en la instancia y luego se llama al método, o se obtiene la definición de clase destino a través de un VirtualCall; Ya una vez con la definición de clase correcta se llama al método en la posición indicada. Por esta razón es que se insiste en el orden de los métodos en las clases. + +##### Trabajo con los atributos +Los atributos como se sabe residen en la instancia y por lo tanto para acceder a ellos simplemente se necesita su posición en esta. En ellos también se cumple el orden anteriormente expuesto para garantizar coherencia en los llamados. + +##### Estructura del programa +* Strings predefinidos +* Strings del programa CIL +* Definiciones de clase +* Código MIPS predefinido +* Métodos globales del programa en MIPS +![Image](images/ProgramaMIPS.png) + +#### Uso de registros +* Registros $a#: Se usan para pasarle parámetros a los métodos en el interior de los métodos se evita su uso y en caso de necesitar usarlos, primero se guardan en la pila para luego restaurarlos. El único caso en que se modifican es si es especificado por el código CIL recibido. +* Registros $s#: Se deben salvar antes de utilizarlos, para luego restaurarlos. No tienen reservada una función específica +* Registros $t#: No necesitan ser salvados antes de utilizarlos. Internamente se utilizan en casi cada conversión a MIPS como lugar donde se cargan los parámetros CIL de la instrucción origen +* Registro $v0: No necesita ser salvado en sus operaciones.Se utiliza para el valor de retorno de las funciones, así como de destino intermedio en la conversión a MIPS. $v1 no se usa +El resto de los registros tiene una función asignada por el estándar de MIPS que no se violó. nos referimos a $ra, $sp, etc. +Alguna regla se violó en el código predefinido, debido a que solo se usa en circunstancias específicas y basado en el modelo de programación seguido + +#### Tipos en tiempo de ejecución +Esto proviene de un tipo CIL que pide inferencia de tipos. Lo que se utiliza es la definición de clase. Se pregunta si tu definición de clase, a la que se puede acceder desde la instancia es la buscada, en caso de no serlo se compara con la del padre, y sucesivamente con la de su padre; si en estos casos se encuentra una respuesta afirmativa se retorna verdadero. En caso de ver que llegaste a una clase sin padre(Object), es decir padre igual a 0, se retorna falso. + +#### Helpers +A destacar son dos funciones utilizadas constantemente en la conversión a MIPS que fueron de gran utilidad. Una que se ocupa dado los parámetros de la instrucción CIL cargarlos en los registros $t# y otra que se ocupa dado el resultado en $v0 guardarlo. Lo importante de estos métodos es que son capaces de discernir si un parámetro es parámetro del método, variable local, número, etc y manejar los datos acorde, lo cual facilitó bastante el trabajo de conversión. \ No newline at end of file diff --git a/doc/compilers-1.pdf b/doc/compilers-1.pdf new file mode 100644 index 00000000..b68f6a49 Binary files /dev/null and b/doc/compilers-1.pdf differ diff --git a/doc/images/ASTtoCIL.py.png b/doc/images/ASTtoCIL.py.png new file mode 100644 index 00000000..b368f2d8 Binary files /dev/null and b/doc/images/ASTtoCIL.py.png differ diff --git a/doc/images/CILClass.png b/doc/images/CILClass.png new file mode 100644 index 00000000..748e5ddd Binary files /dev/null and b/doc/images/CILClass.png differ diff --git a/doc/images/CILGlobalMethod.png b/doc/images/CILGlobalMethod.png new file mode 100644 index 00000000..abfabe14 Binary files /dev/null and b/doc/images/CILGlobalMethod.png differ diff --git "a/doc/images/Definici\303\263ndeclase.png" "b/doc/images/Definici\303\263ndeclase.png" new file mode 100644 index 00000000..1d2dc6b0 Binary files /dev/null and "b/doc/images/Definici\303\263ndeclase.png" differ diff --git a/doc/images/Diagrama.jpg b/doc/images/Diagrama.jpg new file mode 100644 index 00000000..341b758d Binary files /dev/null and b/doc/images/Diagrama.jpg differ diff --git a/doc/images/Estructura.png b/doc/images/Estructura.png new file mode 100644 index 00000000..675c3b26 Binary files /dev/null and b/doc/images/Estructura.png differ diff --git a/doc/images/Instancia.png b/doc/images/Instancia.png new file mode 100644 index 00000000..9e98eed3 Binary files /dev/null and b/doc/images/Instancia.png differ diff --git a/doc/images/ProgramaCIL.png b/doc/images/ProgramaCIL.png new file mode 100644 index 00000000..980535fb Binary files /dev/null and b/doc/images/ProgramaCIL.png differ diff --git a/doc/images/ProgramaMIPS.png b/doc/images/ProgramaMIPS.png new file mode 100644 index 00000000..966d8f57 Binary files /dev/null and b/doc/images/ProgramaMIPS.png differ diff --git a/doc/mips_and_spim_manual.pdf b/doc/mips_and_spim_manual.pdf new file mode 100644 index 00000000..d62cca21 Binary files /dev/null and b/doc/mips_and_spim_manual.pdf differ diff --git a/requirements.txt b/requirements.txt index 9eb0cad1..cba16ee2 100644 --- a/requirements.txt +++ b/requirements.txt @@ -1,2 +1,3 @@ pytest pytest-ordering +ply diff --git a/src/AST.py b/src/AST.py new file mode 100644 index 00000000..5c33cb97 --- /dev/null +++ b/src/AST.py @@ -0,0 +1,177 @@ +class Node: + index=0 + line=0 + +class ProgramNode(Node): + def __init__(self, classes): + self.classes = classes + +class ClassNode(Node): + def __init__(self, name, parent, features): + self.name = name + self.parent = parent + self.methods = [] + self.attributes = [] + if features is not []: + for foo in features: + if isinstance(foo,AttributeNode): + self.attributes.append(foo) + else: + self.methods.append(foo) + +class ClassFeatureNode(Node): + pass + +class MethodNode(ClassFeatureNode): + def __init__(self, name, parameters, return_type, body): + self.name = name + self.parameters = parameters + self.return_type = return_type + self.body = body + +class AttributeNode(ClassFeatureNode): + def __init__(self, name, attr_type, value): + self.name = name + self.type = attr_type + self.value = value + +class ParameterNode(ClassFeatureNode): + def __init__(self, name, param_type): + self.name = name + self.type = param_type + +class ExpressionNode(Node): + pass + + +class AssignNode(ExpressionNode): + def __init__(self, variable, expr): + self.variable = variable + self.expression = expr + +class ConditionalNode(ExpressionNode): + def __init__(self, predicate, then_body, else_body): + self.predicate = predicate + self.then_body = then_body + self.else_body = else_body + +class LoopNode(ExpressionNode): + def __init__(self, predicate, body): + self.predicate = predicate + self.body = body + +class LetNode(ExpressionNode): + def __init__(self, declarations, in_body): + self.declarations = declarations + self.body = in_body + +class AtomicNode(ExpressionNode): + pass + +class ConstantNode(AtomicNode): + pass + +class StringNode(ConstantNode): + def __init__(self, value): + self.value = value + +class IntegerNode(ConstantNode): + def __init__(self, value): + self.value = value + +class BoolNode(ConstantNode): + def __init__(self, value): + self.value = value + +class NewNode(AtomicNode): + def __init__(self, new_type): + self.type = new_type + +class BlockNode(AtomicNode): + def __init__(self, expressions): + self.expressions = expressions + +class CaseNode(AtomicNode): + def __init__(self, expression, subcases): + self.expression = expression + self.subcases = subcases + +class SubCaseNode: + def __init__(self, name, sub_type, expression): + self.name = name + self.type = sub_type + self.expression = expression + +class DispatchNode(AtomicNode): + def __init__(self, func_id, parameters, left_expr, left_type=None): + self.func_id = func_id + self.parameters = parameters + self.left_expression = left_expr + self.left_type=left_type + +class StaticDispatchNode(AtomicNode): + def __init__(self, func_id, parent_id ,parameters, left_expr): + self.func_id = func_id + self.parent_id = parent_id + self.parameters = parameters + self.left_expression = left_expr + +class VariableNode(AtomicNode): + def __init__(self, var_id): + self.id = var_id + +class UnaryOperatorNode(ExpressionNode): + operator = "" + pass + +class IsVoidNode(UnaryOperatorNode): + def __init__(self, expr, tipo="Class"): + self.expression = expr + self.tipo=tipo + +class IntComplementNode(UnaryOperatorNode): + def __init__(self, right): + self.right = right + +class BoolComplementNode(UnaryOperatorNode): + def __init__(self, right): + self.right = right + +class BinaryOperatorNode(ExpressionNode): + operator="" + def __init__(self, left, right): + self.left = left + self.right = right + +class ComparisonNode(BinaryOperatorNode): + pass + +class LesserNode(ComparisonNode): + pass + +class LesserEqualNode(ComparisonNode): + pass + +class EqualNode(ComparisonNode): + def __init__(self,left,right, isString=False): + self.left = left + self.right = right + self.isString = isString + +class ArithmeticNode(BinaryOperatorNode): + pass + +class PlusNode(ArithmeticNode): + pass + +class MinusNode(ArithmeticNode): + pass + +class MultNode(ArithmeticNode): + pass + +class DivNode(ArithmeticNode): + pass + + + diff --git a/src/ASTtoCIL.py b/src/ASTtoCIL.py new file mode 100644 index 00000000..c5151569 --- /dev/null +++ b/src/ASTtoCIL.py @@ -0,0 +1,730 @@ +from AST import * +from CIL import * +from Scope import * +import visitor as visitor +from DefaultClasses import * + + +class CILTranspiler: + def __init__(self, metodosUsados=[]): + self.data={} + self.datacount=0 + self.variablecount=0 + self.labelcount=0 + self.classidcount=10 + self.caseResultStack=[] + self.caseEndStack=[] + self.caseExpresionStack=[] + # self.clasesordenadas=[] + self.clasesdiccionario={} + self.metodosUsados=metodosUsados + + def GenerarGrafoDeHerencia(self,classes:list): + grafo={} + for c in classes: + self.clasesdiccionario[c.name]=c + if c.parent in grafo.keys(): + grafo[c.parent].append(c) + else: + grafo[c.parent]=[c] + self.grafo=grafo + return grafo + + def OrdenarClasesPorHerenciaHelper(self, actual): + grafo=self.grafo + if actual not in self.grafo.keys(): + return [] + ordenados=grafo[actual].copy() + nuevos=[] + for elemento in ordenados: + # nuevos.append(elemento) + nuevos.extend(self.OrdenarClasesPorHerenciaHelper(elemento.name)) + + ordenados.extend(nuevos) + return ordenados + + def OrdenarClasesPorHerencia(self, classes:list): + grafo=self.GenerarGrafoDeHerencia(classes) + ordenados=[] + ordenados.extend(self.OrdenarClasesPorHerenciaHelper(None)) + # if "Object" in self.grafo.keys(): + # ordenados.extend(self.OrdenarClasesPorHerenciaHelper("Object")) + # if "IO" in self.grafo.keys(): + # ordenados.extend(self.OrdenarClasesPorHerenciaHelper("IO")) + + return ordenados + + def Profundidad(self, tipo): + if tipo=="Object": + return 0 + este=self.clasesdiccionario[tipo] + return 1+self.Profundidad(este.parent) + + + def GenerarDiccionarioAtributos(self, classes:list): + self.attrib={} + for c in classes: + misatributos={} + atributosordenadosname=[] + + if c.parent != None: + for elemento in self.attrib[c.parent]: + misatributos[elemento.name]=elemento + atributosordenadosname.append(elemento.name) + + + for at in c.attributes: + if not (at.name in misatributos.keys()): + atributosordenadosname.append(at.name) + misatributos[at.name]=at + + listaAtributos=[] + for name in atributosordenadosname: + listaAtributos.append(misatributos[name]) + + self.attrib[c.name]=listaAtributos + + return self.attrib + + def GenerarDiccionarioMetodos(self, classes:list): + self.methods={} + self.globalnames={} + counter=0 + for c in classes: + mismetodos={} + if c.parent != None: + for elemento in self.methods[c.parent]: + mismetodos[elemento.name]=elemento + if elemento.name == '$init' or elemento.name == 'type_name': + self.globalnames[c.name+"#"+elemento.name]="f"+str(counter) + counter+=1 + else: + self.globalnames[c.name+"#"+elemento.name]=self.globalnames[c.parent+"#"+elemento.name] + + else: + mismetodos["$init"]=MethodNode("$init",[],None,[]) + mismetodos["type_name"]=MethodNode("$init",[],None,[]) + self.globalnames[c.name+"#"+"$init"]="f"+str(counter) + counter+=1 + self.globalnames[c.name+"#"+"type_name"]="f"+str(counter) + counter+=1 + + for met in c.methods: + # if c.name+"#"+met.name in self.globalnames.keys(): + if met.name=="main": + print("Entre") + if not met.name in self.metodosUsados and not c.name in ["Object","String","IO","Bool","Int"]: + continue + self.globalnames[c.name+"#"+met.name]="f"+str(counter) + counter+=1 + + mismetodos[met.name]=met + + self.methods[c.name]=mismetodos.values() + + return (self.methods, self.globalnames) + + def GenerarNombreVariableBase(self): + self.variablecount+=1 + return "var.var"+str(self.variablecount) + + def GenerarNombreVariable(self, scope:Scope): + variable=self.GenerarNombreVariableBase() + scope.locals.append(variable) + return variable + + def GenerarInit(self, clase:ClassNode, scope:Scope): + # if clase.name in ["CellularAutomaton",'"CellularAutomaton"']: + # print("here") + instructions=[] + if clase.parent!=None: + dumb=self.GenerarNombreVariable(scope) + instructions.append(CILArgument(params=["self"])) + instructions.append(CILVirtualCall(dumb,[clase.parent,"$init"])) + + for a in clase.attributes: + inits=self.visit(a,scope) + instructions.extend(inits) + + final=self.GenerarNombreVariable(scope) + + result=CILAssign(final,['self']) + + instructions.append(result) + + return instructions + + def CILMainInstructions(self): + nuevo=NewNode("Main") + instruction=DispatchNode("main",[],nuevo,"Main") + scope=Scope("Main.special","Object") + result=self.visit(MethodNode("main",[],"SELF_TYPE",instruction),scope) + return result + + + + @visitor.on('node') + def visit(self, node, scope): + pass + + @visitor.when(ProgramNode) + def visit(self, node: ProgramNode, _): + claseObject=Defaults.ObjectClass() + claseIO=Defaults.IOClass() + claseString=Defaults.StringClass() + claseBool=Defaults.BoolClass() + claseInt=Defaults.IntClass() + + clasescompletas=node.classes.copy() + clasescompletas.extend([claseObject,claseIO,claseString,claseBool,claseInt]) + + classes=self.OrdenarClasesPorHerencia(clasescompletas) + # self.clasesordenadas=classes + atributosdic=self.GenerarDiccionarioAtributos(classes) + metodosdic,metodosglobalesdic=self.GenerarDiccionarioMetodos(classes) + + classesCIL=[] + metodosGlobalesCIL={} + + for c in classes: + #Generando los Types e informacion de clase + atributosAST=atributosdic[c.name] + metodosAST=metodosdic[c.name] + self.classidcount+=1 + + scope=Scope(c.name, c.parent) + scope.attributes=atributosAST + scope.class_name=c.name + + main=self.CILMainInstructions() + main.nombre="Main.Special" + metodosGlobalesCIL[main.nombre]=main + + #Inicializacion de atributos + initInstructions=self.GenerarInit(c,scope) + initName=metodosglobalesdic[c.name+"#"+"$init"] + globalInit=CILGlobalMethod(initName,["self"],scope.locals,initInstructions, c.name,c.name+".$init") + metodosGlobalesCIL[globalInit.nombre]=globalInit + + #Metodo type_name + metodotypename=MethodNode("type_name",[],"String",StringNode('"'+c.name+'"')) + nombreTypeName=metodosglobalesdic[c.name+"#"+"type_name"] + metodoglobal=self.visit(metodotypename, scope) + metodoglobal.nombre=nombreTypeName + metodosGlobalesCIL[nombreTypeName]=metodoglobal + + + atributosCIL=[] + for element in atributosAST: + nuevoCIL=CILAttribute(element.name, element.type) + atributosCIL.append(nuevoCIL) + + metodosClaseCIL=[] + for element in metodosAST: + if not c.name+"#"+element.name in metodosglobalesdic.keys(): + continue + nuevoCIL=CILClassMethod(element.name,metodosglobalesdic[c.name+"#"+element.name]) + metodosClaseCIL.append(nuevoCIL) + + if not (c.name in ["Object", "IO", "String"]): + for m in c.methods: + if not c.name+"#"+m.name in metodosglobalesdic.keys(): + continue + globalMethod=self.visit(m, scope) + globalMethod.nombre=metodosglobalesdic[c.name+"#"+m.name] + metodosGlobalesCIL[globalMethod.nombre]=globalMethod + + elif c.name == "Object": + #copy + globalMethod=Defaults.copy_CIL(len(c.attributes)) + globalMethod.nombre=metodosglobalesdic[c.name+"#"+globalMethod.nombre] + metodosGlobalesCIL[globalMethod.nombre]=globalMethod + + #abort + globalMethod=Defaults.abort_CIL() + globalMethod.nombre=metodosglobalesdic[c.name+"#"+globalMethod.nombre] + metodosGlobalesCIL[globalMethod.nombre]=globalMethod + + elif c.name == "IO": + #out_string + globalMethod=Defaults.out_string_CIL() + globalMethod.nombre=metodosglobalesdic[c.name+"#"+globalMethod.nombre] + metodosGlobalesCIL[globalMethod.nombre]=globalMethod + + #out_int + globalMethod=Defaults.out_int_CIL() + globalMethod.nombre=metodosglobalesdic[c.name+"#"+globalMethod.nombre] + metodosGlobalesCIL[globalMethod.nombre]=globalMethod + + #in_string + globalMethod=Defaults.in_string_CIL() + globalMethod.nombre=metodosglobalesdic[c.name+"#"+globalMethod.nombre] + metodosGlobalesCIL[globalMethod.nombre]=globalMethod + + #in_int + globalMethod=Defaults.in_int_CIL() + globalMethod.nombre=metodosglobalesdic[c.name+"#"+globalMethod.nombre] + metodosGlobalesCIL[globalMethod.nombre]=globalMethod + + elif c.name == "String": + #length + globalMethod=Defaults.len_string_CIL() + globalMethod.nombre=metodosglobalesdic[c.name+"#"+globalMethod.nombre] + metodosGlobalesCIL[globalMethod.nombre]=globalMethod + + #concat + globalMethod=Defaults.concat_string_CIL() + globalMethod.nombre=metodosglobalesdic[c.name+"#"+globalMethod.nombre] + metodosGlobalesCIL[globalMethod.nombre]=globalMethod + + #substring + globalMethod=Defaults.substring_string_CIL() + globalMethod.nombre=metodosglobalesdic[c.name+"#"+globalMethod.nombre] + metodosGlobalesCIL[globalMethod.nombre]=globalMethod + + claseCIL=CILClass(c.name,atributosCIL, metodosClaseCIL, c.parent) + classesCIL.append(claseCIL) + + return CILProgram(classesCIL,self.data.values(), metodosGlobalesCIL.values()) + + @visitor.when(StringNode) + def visit(self, node: StringNode, scope:Scope): + nombrestring="st"+str(self.datacount) + datadeclaration=CILDataDeclaration(nombrestring, node.value) + self.datacount+=1 + self.data[datadeclaration.nombre]=datadeclaration + destino=self.GenerarNombreVariable(scope) + scope.locals.append(destino) + return [CILStringLoad(destino, [nombrestring])] + + + @visitor.when(IntegerNode) + def visit(self, node: IntegerNode, scope:Scope): + destino=self.GenerarNombreVariable(scope) + instruccion=CILAssign(destino,[node.value]) + return [instruccion] + + @visitor.when(BoolNode) + def visit(self, node: BoolNode, scope:Scope): + destino=self.GenerarNombreVariable(scope) + instruccion=CILAssign(destino,[node.value]) + return [instruccion] + + @visitor.when(NewNode) + def visit(self, node: NewNode, scope:Scope): + destino=self.GenerarNombreVariable(scope) + instruccion=CILAllocate(destino,[node.type]) + if not node.type in ['Int','Bool']: + argument=CILArgument(params=[destino]) + init=CILCall(destino,[node.type,"$init"]) + return [instruccion, argument,init] + else: + return [instruccion] + + @visitor.when(BlockNode) + def visit(self, node: BlockNode, scope:Scope): + instrucciones=[] + for e in node.expressions: + instrucciones.extend(self.visit(e,scope)) + + return instrucciones + + @visitor.when(ConditionalNode) + def visit(self, node: ConditionalNode, scope:Scope): + predicateCode=self.visit(node.predicate,scope) + thencode=self.visit(node.then_body,scope) + elsecode=self.visit(node.else_body,scope) + + thenLabel=CILLabel(params=["Lbl"+str(self.labelcount)]) + self.labelcount+=1 + finalLabel=CILLabel(params=["Lbl"+str(self.labelcount)]) + self.labelcount+=1 + + resultadoPredicado=predicateCode[len(predicateCode)-1].destination + conditinalJump=CILConditionalJump(params=[resultadoPredicado,thenLabel.params[0]]) + saltoalfinal=CILJump(params=[finalLabel.params[0]]) + + destinoinicial=self.GenerarNombreVariable(scope) + asignacionThen=CILAssign(destinoinicial,[thencode[len(thencode)-1].destination]) + thencode.append(asignacionThen) + asignacionElse=CILAssign(destinoinicial,[elsecode[len(elsecode)-1].destination]) + elsecode.append(asignacionElse) + + instrucciones=predicateCode + instrucciones.append(conditinalJump) + instrucciones.extend(elsecode) + instrucciones.append(saltoalfinal) + instrucciones.append(thenLabel) + instrucciones.extend(thencode) + instrucciones.append(finalLabel) + + destinofinal=self.GenerarNombreVariable(scope) + asignacionFinal=CILAssign(destinofinal,[destinoinicial]) + instrucciones.append(asignacionFinal) + + return instrucciones + + @visitor.when(MethodNode) + def visit(self, node: MethodNode, scope:Scope): + parameters=["self"] + locales=[] + scope.locals=locales + for param in node.parameters: + parameters.append(param.name) + + scope.params=parameters + + instructions=[] + # for element in node.body: + instructions.extend(self.visit(node.body,scope)) + locales=scope.locals + + # retorno=CILReturn([]) + # if len(instructions)>0: + # ultimoDestino=instructions[len(instructions)-1].destination + # retorno=CILReturn([ultimoDestino]) + + return CILGlobalMethod(None,parameters,locales,instructions, scope.class_name, scope.class_name+"."+node.name) + + @visitor.when(AssignNode) + def visit(self, node: AssignNode, scope:Scope): + if node.variable not in self.attrib[scope.class_name] and node.variable not in scope.params and node.variable not in scope.locals: + scope.locals.append(node.variable) + + instrucciones=self.visit(node.expression,scope) + + nombrevariable=node.variable#self.GenerarNombreVariable(scope) + asignacion=CILAssign(nombrevariable,[instrucciones[len(instrucciones)-1].destination]) + instrucciones.append(asignacion) + + return instrucciones + + @visitor.when(VariableNode) + def visit(self, node: VariableNode, scope:Scope): + instrucciones=[] + nombrevariable=self.GenerarNombreVariable(scope) + asignacion=CILAssign(nombrevariable,[node.id]) + instrucciones.append(asignacion) + + return instrucciones + + @visitor.when(BinaryOperatorNode) + def visit(self, node: BinaryOperatorNode, scope:Scope): + instrucciones=self.visit(node.left,scope) + izquierda=instrucciones[len(instrucciones)-1].destination + instrucciones.extend(self.visit(node.right,scope)) + derecha=instrucciones[len(instrucciones)-1].destination + + nombrevariable=self.GenerarNombreVariable(scope) + if isinstance(node, PlusNode): + nuevoCIL=CILPlus(nombrevariable,[izquierda,derecha]) + elif isinstance(node, MinusNode): + nuevoCIL=CILMinus(nombrevariable,[izquierda,derecha]) + elif isinstance(node, MultNode): + nuevoCIL=CILMult(nombrevariable,[izquierda,derecha]) + elif isinstance(node, DivNode): + nuevoCIL=CILDiv(nombrevariable,[izquierda,derecha]) + elif isinstance(node, LesserNode): + nuevoCIL=CILLesser(nombrevariable,[izquierda,derecha]) + elif isinstance(node, LesserEqualNode): + nuevoCIL=CILLesserEqual(nombrevariable,[izquierda,derecha]) + elif isinstance(node, EqualNode): + if node.isString: + nuevoCIL=CILStringEqual(nombrevariable,[izquierda,derecha]) + else: + nuevoCIL=CILEqual(nombrevariable,[izquierda,derecha]) + + instrucciones.append(nuevoCIL) + self.variablecount+=1 + + scope.locals.append(nuevoCIL.destination) + return instrucciones + + @visitor.when(UnaryOperatorNode) + def visit(self, node: UnaryOperatorNode, scope:Scope): + instrucciones=[] + if isinstance(node, IsVoidNode): + instrucciones.extend(self.visit(node.expression, scope)) + else: + instrucciones.extend(self.visit(node.right, scope)) + + destinoExpresion=instrucciones[len(instrucciones)-1].destination + + nombrevariable=self.GenerarNombreVariable(scope) + scope.locals.append(nombrevariable) + nuevoCIL=CILInstructionNode() + if isinstance(node, IsVoidNode): + if node.tipo in ["Bool","Int","String"]: + nuevoCIL=CILAssign(nombrevariable, 0) + else: + nuevoCIL=CILIsVoid(nombrevariable, [destinoExpresion]) + elif isinstance(node, IntComplementNode): + nuevoCIL=CILIntComplement(nombrevariable, [destinoExpresion]) + elif isinstance(node, BoolComplementNode): + nuevoCIL=CILComplement(nombrevariable, [destinoExpresion]) + else: + assert False + + instrucciones.append(nuevoCIL) + return instrucciones + + + + @visitor.when(LoopNode) + def visit(self, node: LoopNode, scope:Scope): + label=CILLabel(params=["Lbl"+str(self.labelcount)]) + self.labelcount+=1 + finalciclo=CILLabel(params=["Lbl"+str(self.labelcount)]) + self.labelcount+=1 + + instructions=[label] + instructions.extend(self.visit(node.predicate,scope)) + + negado=self.GenerarNombreVariable(scope) + scope.locals.append(negado) + instructions.append(CILComplement(negado,[instructions[len(instructions)-1].destination])) + + instructions.append(CILConditionalJump(params=[negado,finalciclo.params[0]])) + + instructions.extend(self.visit(node.body,scope)) + + instructions.append(CILJump(params=[label.params[0]])) + + instructions.append(finalciclo) + + resultado=self.GenerarNombreVariable(scope) + scope.locals.append(resultado) + instructions.append(CILAssign(resultado,[0])) + + return instructions + + + ##TODO Agregarle a Dispatch unos modos que faltaron + @visitor.when(DispatchNode) + def visit(self, node:DispatchNode, scope:Scope): + instructions=[] + if node.left_expression==None: + node.left_expression=VariableNode("self") + node.left_type=scope.class_name + + leftInstructions=self.visit(node.left_expression, scope) + instructions.extend(leftInstructions) + + virtual=node.left_type in ["Int", "Bool", "String"] + + if virtual: #Caso de los tipos basicos + if node.func_id=="type_name": + elstring=StringNode('"'+node.left_type+'"') + instructions.extend(self.visit(elstring, scope)) + return instructions + + + # instructions.append(CILArgument(params=[leftInstructions[len(leftInstructions)-1].destination])) + + destinos=[] + for p in node.parameters: + paramInstruction=self.visit(p, scope) + destinos.append(paramInstruction[len(paramInstruction)-1].destination) + # paramInstruction.append(CILArgument(params=[paramInstruction[len(paramInstruction)-1].destination])) + instructions.extend(paramInstruction) + + instructions.append(CILArgument(params=[leftInstructions[len(leftInstructions)-1].destination])) + + for dest in destinos: + instructions.append(CILArgument(params=[dest])) + + # instructions.append(CILArgument(params=[leftInstructions[len(leftInstructions)-1].destination]))#Removido de los params: node.left_type, + resultVariable=self.GenerarNombreVariable(scope) + # if(node.left_type==None): + # print() + if virtual: + llamada=CILVirtualCall(resultVariable,[node.left_type,node.func_id]) + else: + llamada=CILCall(resultVariable,[node.left_type,node.func_id]) + instructions.append(llamada) + + return instructions + + @visitor.when(StaticDispatchNode) + def visit(self, node:StaticDispatchNode, scope:Scope): + instructions=[] + + leftInstructions=self.visit(node.left_expression, scope) + instructions.extend(leftInstructions) + + # instructions.append(CILArgument(params=[leftInstructions[len(leftInstructions)-1].destination])) + + destinos=[] + for p in node.parameters: + paramInstruction=self.visit(p, scope) + destinos.append(paramInstruction[len(paramInstruction)-1].destination) + # paramInstruction.append(CILArgument(params=[paramInstruction[len(paramInstruction)-1].destination])) + instructions.extend(paramInstruction) + + instructions.append(CILArgument(params=[leftInstructions[len(leftInstructions)-1].destination])) + + for dest in destinos: + instructions.append(CILArgument(params=[dest])) + + # instructions.append(CILArgument(params=[leftInstructions[len(leftInstructions)-1].destination])) + resultVariable=self.GenerarNombreVariable(scope) + llamada=CILVirtualCall(resultVariable,[node.parent_id,node.func_id]) + instructions.append(llamada) + + return instructions + + @visitor.when(LetNode) + def visit(self, node:LetNode, scope:Scope): + instructions=[] + asignacionessalva=[] + for at in node.declarations: + if at.name not in scope.locals: + scope.locals.append(at.name) + if at.value==None: + if at.type=="String": + at.value=StringNode('""') + elif at.type=="Bool": + at.value=BoolNode("false") + else: + at.value=IntegerNode(0) + delcaracionExp=self.visit(at.value,scope) + instructions.extend(delcaracionExp) + if len(delcaracionExp)>0: + temp=self.GenerarNombreVariable(scope) + salva=CILAssign(temp,[at.name]) + asignacionessalva.append(salva) + instructions.append(salva) + instructions.append(CILAssign(at.name,[delcaracionExp[len(delcaracionExp)-1].destination])) + else: + instructions.append(CILAssign(at.name,[0])) + + bodyExp=self.visit(node.body,scope) + + instructions.extend(bodyExp) + + varintermedia=self.GenerarNombreVariable(scope) + + instructions.append(CILAssign(varintermedia,[bodyExp[len(bodyExp)-1].destination])) + + for inst in asignacionessalva: + restauracion=CILAssign(inst.params[0],[inst.destination]) + instructions.append(restauracion) + + resultado=self.GenerarNombreVariable(scope) + instructions.append(CILAssign(resultado,[varintermedia])) + + return instructions + + @visitor.when(CaseNode) + def visit(self, node:CaseNode, scope:Scope): + instructions=[] + expresion0=self.visit(node.expression, scope) + instructions.extend(expresion0) + + destinoExpresion0=expresion0[len(expresion0)-1].destination + + resultado1=self.GenerarNombreVariable(scope) + saltofinal=self.GenerarNombreVariable(scope) + self.caseResultStack.append(resultado1) + self.caseExpresionStack.append(destinoExpresion0) + self.caseEndStack.append(saltofinal) + + subcasos=sorted(node.subcases,key=lambda subcaso: self.Profundidad(subcaso.type)) + subcasos.reverse() + + for sub in subcasos: + nueva=self.GenerarNombreVariable(scope) + subInstructions=self.visit(sub, scope) + instructions.extend(subInstructions) + + self.caseResultStack.pop() + self.caseExpresionStack.pop() + self.caseEndStack.append(saltofinal) + + instructions.append(CILLabel(params=[saltofinal])) + + resultadofinal=self.GenerarNombreVariable(scope) + instructions.append(CILAssign(resultadofinal,[resultado1])) + + return instructions + + + @visitor.when(SubCaseNode) + def visit(self, node:SubCaseNode, scope:Scope): + instructions=[] + # prevName=scope.class_name + # scope.class_name=node.type + + expresion0=self.caseExpresionStack.pop() + self.caseExpresionStack.append(expresion0) + + if not node.name in scope.locals: + scope.locals.append(node.name) + + + #tipoResult=Si es de ese tipo + tipoResult=self.GenerarNombreVariable(scope) + chequeo=CILTypeCheck(tipoResult,[expresion0, node.type]) + instructions.append(chequeo) + + #falloeltipo=not tiporesult + falloeltipo=self.GenerarNombreVariable(scope) + instructions.append(CILComplement(falloeltipo,[tipoResult])) + + #goto labelfinal if falloeltipo + labelfinal=self.GenerarNombreVariable(scope) + salto=CILConditionalJump(params=[falloeltipo,labelfinal]) + + instructions.append(salto) + + #Salvo la variable node.name + temporal=self.GenerarNombreVariable(scope) + salva=CILAssign(temporal,[node.name]) + instructions.append(salva) + + #No fallo, entonces node.name=expresion0 + asignacion=CILAssign(node.name, [expresion0]) + instructions.append(asignacion) + + #Evalua la expresion del subcase + instructions.extend(self.visit(node.expression,scope)) + + #resultVariable=resultado de la expresion + resultVariable=self.GenerarNombreVariable(scope) + asignacion=CILAssign(resultVariable,[instructions[len(instructions)-1].destination]) + + #Restaurando node.name + restauracion=CILAssign(node.name,[temporal]) + + #Buscar donde hay que guardar el resultado y guardarlo + resultHolder=self.caseResultStack.pop() + self.caseResultStack.append(resultHolder) + final=CILAssign(resultHolder,[resultVariable]) + + instructions.extend([asignacion, restauracion,final]) + + #Goto al final de la expresion case + saltofinal=self.caseEndStack.pop() + self.caseEndStack.append(saltofinal) + instructions.append(CILJump(params=[saltofinal])) + + # scope.class_name=prevName + #Label por si da falso el tipo + instructions.append(CILLabel(params=[labelfinal])) + + return instructions + + @visitor.when(AttributeNode) + def visit(self, node:AttributeNode, scope:Scope): + instructions=[] + if node.value==None: + if node.type=="String": + node.value=StringNode('""') + instructions.extend(self.visit(node.value, scope)) + if len(instructions)>0: + final=CILAssign(node.name,[instructions[len(instructions)-1].destination]) + else: + final=CILAssign(node.name,[0]) + instructions.append(final) + + return instructions \ No newline at end of file diff --git a/src/CIL.py b/src/CIL.py new file mode 100644 index 00000000..25639be8 --- /dev/null +++ b/src/CIL.py @@ -0,0 +1,144 @@ +class CILObject: + pass + +class CILInstructionNode: + def __init__(self,destination=None, params=[]): + self.destination=destination + self.params=params + + def instructionPrint(self): + print(str(type(self))+" "+str(self.destination)+"<-"+str(self.params)) + +class CILTypeCheck(CILInstructionNode): #Devuelve True si el tipo es correcto, se le pasa una variable y una variable con string + pass + +class CILBinaryOperator(CILInstructionNode): + pass + +class CILAritmetic(CILBinaryOperator): + pass + +class CILComparison(CILBinaryOperator): + pass + +class CILPlus(CILAritmetic): + pass +class CILMinus(CILAritmetic): + pass +class CILMult(CILAritmetic): + pass +class CILDiv(CILAritmetic): + pass + +class CILLesser(CILComparison): + pass +class CILLesserEqual(CILComparison): + pass +class CILEqual(CILComparison): + pass +class CILDifferent(CILComparison): + pass + +class CILLabel(CILInstructionNode): + pass +class CILConditionalJump(CILInstructionNode): + pass +class CILJump(CILInstructionNode): + pass + +class CILUnaryOperator(CILInstructionNode): + pass +class CILNot(CILUnaryOperator): + pass +class CILIntComplement(CILUnaryOperator): + pass +class CILComplement(CILUnaryOperator): + pass +class CILIsVoid(CILUnaryOperator): + pass +class CILAssign(CILUnaryOperator): + pass + +class CILMemory(CILInstructionNode): + pass +class CILAllocate(CILMemory): + pass + +class CILMethodInstruction(CILInstructionNode): + pass +class CILCall(CILMethodInstruction): + pass +class CILVirtualCall(CILMethodInstruction): + pass +class CILArgument(CILMethodInstruction): + pass +class CILReturn(CILMethodInstruction): + pass + +class CILStringInstruction(CILInstructionNode): + pass + +class CILStringLoad(CILStringInstruction): + pass +class CILStringLenght(CILStringInstruction): + pass +class CILStringConcat(CILStringInstruction): + pass +class CILStringSubstring(CILStringInstruction): + pass +class CILStringEqual(CILStringInstruction): + pass + +class CILIOInstruction(CILInstructionNode): + pass +class CILOutString(CILIOInstruction): + pass +class CILOutInt(CILIOInstruction): + pass +class CILInString(CILIOInstruction): + pass +class CILInInt(CILIOInstruction): + pass +class CILAbort(CILInstructionNode): + pass + +class CILCopy(CILInstructionNode): + pass + + +class CILClassMethod: + def __init__(self,localname,globalname): + self.localname=localname + self.globalname=globalname + +class CILAttribute: + def __init__(self,name, attributeType="Object"): + self.name=name + self.attributeType=attributeType + +class CILClass: + def __init__(self,name,listaAtributos=[], listaMetodos=[],parent=None): + self.name=name + self.parent=parent + self.listaAtributos=listaAtributos + self.listaMetodos=listaMetodos + +class CILDataDeclaration: + def __init__(self,nombre:str, valorString:str): + self.nombre=nombre + self.valorString=valorString + +class CILGlobalMethod: + def __init__(self,nombre, params=[], locals=[], intrucciones=[], originclass="Object",comments="None"): + self.nombre=nombre + self.params=params + self.locals=locals + self.intrucciones=intrucciones + self.originclass=originclass + self.comments=comments + +class CILProgram: + def __init__(self,Types=[],Data=[],Methods=[]): + self.Types=Types + self.Data=Data + self.Methods=Methods \ No newline at end of file diff --git a/src/CILtoMIPS.py b/src/CILtoMIPS.py new file mode 100644 index 00000000..5d56c007 --- /dev/null +++ b/src/CILtoMIPS.py @@ -0,0 +1,668 @@ +from AST import * +from CIL import * +from ScopeMIPS import * +import visitor as visitor +import os + +# class MIPSClass: +# def __init__(self, cantidadatributos, etiquetasfunciones): +# self.cantidadatributos=cantidadatributos +# self.etiquetasfunciones=etiquetasfunciones + +class MIPSCompiler: + def __init__(self): + self.clases=[] + self.atributos={} + self.metodos={} + self.metodosglobales={} + self.data={} + self.locals={} + self.registerparams={} + self.params={} + self.parents={} + + def load(self, node:CILInstructionNode,scope:ScopeMIPS, soloelprimero=False, desplazamiento=0): + instrucciones="" + parametro0=node.params[0] + # if isinstance(node, CILTypeCheck): + # print("here") + if scope.methodclass != "Main.special": + atributos=self.atributos[scope.methodclass] + else: + atributos=[] + DicNombreAtributos={} + nombresAtributos=[] + for at in atributos: + nombresAtributos.append(at.name) + DicNombreAtributos[at.name]=at.attributeType + + if isinstance(parametro0, int): + instrucciones+="li $t0,"+str(parametro0)+"\n" + elif parametro0 == 'true': + instrucciones+="li $t0,1\n" + elif parametro0 == 'false': + instrucciones+="move $t0, $zero\n" + elif parametro0 in nombresAtributos: + instrucciones+="lw $t0,"+str(nombresAtributos.index(parametro0)*4+4)+"($a0)\n" + elif parametro0 in scope.locals.keys(): + instrucciones+="lw $t0,"+str(scope.locals[parametro0]+desplazamiento)+"($sp)\n" + elif parametro0 in scope.parameters.keys(): + instrucciones+="lw $t0,"+str(scope.parameters[parametro0]+desplazamiento)+"($sp)\n" + elif parametro0 in scope.registerparameters.keys(): + instrucciones+="move $t0,"+scope.registerparameters[parametro0]+"\n" + elif parametro0 in self.data.keys(): + instrucciones+="la $t0,"+parametro0+"\n" + elif parametro0 in self.clases: + instrucciones+="la $t0,"+parametro0+"clase\n" + else: + node.instructionPrint() + assert False + + if len(node.params)<2 or soloelprimero: + return instrucciones + + parametro1=node.params[1] + + if isinstance(parametro1, int): + instrucciones+="li $t1,"+str(parametro1)+"\n" + elif parametro1 == 'true': + instrucciones+="li $t1,1\n" + elif parametro1 == 'false': + instrucciones+="move $t1, $zero\n" + elif parametro1 in nombresAtributos: + instrucciones+="lw $t1,"+str(nombresAtributos.index(parametro1)*4+4)+"($a0)\n" + elif parametro1 in scope.locals.keys(): + instrucciones+="lw $t1,"+str(scope.locals[parametro1]+desplazamiento)+"($sp)\n" + elif parametro1 in scope.parameters.keys(): + instrucciones+="lw $t1,"+str(scope.parameters[parametro1]+desplazamiento)+"($sp)\n" + elif parametro1 in scope.registerparameters.keys(): + instrucciones+="move $t1,"+scope.registerparameters[parametro1]+"\n" + elif parametro1 in nombresAtributos: + instrucciones+="lw $t1,"+str(nombresAtributos.index(parametro1)*4+4)+"($a0)\n" + elif parametro1 in self.clases: + instrucciones+="la $t1,"+parametro1+"clase\n" + else: + assert False + + if len(node.params)<3 or soloelprimero: + return instrucciones + + parametro2=node.params[2] + + if isinstance(parametro2, int): + instrucciones+="li $t2,"+str(parametro2)+"\n" + elif parametro2 == 'true': + instrucciones+="li $t2,1\n" + elif parametro2 == 'false': + instrucciones+="move $t2, $zero\n" + elif parametro2 in nombresAtributos: + instrucciones+="lw $t2,"+str(nombresAtributos.index(parametro2)*4+4)+"($a0)\n" + elif parametro2 in scope.locals.keys(): + instrucciones+="lw $t2,"+str(scope.locals[parametro2]+desplazamiento)+"($sp)\n" + elif parametro2 in scope.parameters.keys(): + instrucciones+="lw $t2,"+str(scope.parameters[parametro2]+desplazamiento)+"($sp)\n" + elif parametro2 in scope.registerparameters.keys(): + instrucciones+="move $t2,"+scope.registerparameters[parametro2]+"\n" + elif parametro2 in self.clases: + instrucciones+="la $t2,"+parametro2+"clase\n" + else: + assert False + + return instrucciones + + def save(self, destino:str,scope:ScopeMIPS, desplazamiento=0): + if scope.methodclass!="Main.special": + atributos=self.atributos[scope.methodclass] + else: + atributos=[] + instrucciones="" + nombresAtributos=[] + for at in atributos: + nombresAtributos.append(at.name) + + if destino in nombresAtributos: + instrucciones+="sw $v0,"+str(nombresAtributos.index(destino)*4+4)+"($a0)\n" + elif destino in scope.locals.keys(): + instrucciones+="sw $v0,"+str(scope.locals[destino]+desplazamiento)+"($sp)\n" + elif destino in scope.parameters.keys(): + instrucciones+="sw $v0,"+str(scope.parameters[destino]+desplazamiento)+"($sp)\n" + elif destino in scope.registerparameters.keys(): + instrucciones+="move "+scope.registerparameters[destino]+",$t0\n" + else: + # print(destino) + # print(scope.locals.keys()) + # print(scope.parameters.keys()) + # print(scope.registerparameters.keys()) + # print(nombresAtributos) + # print(self.data.keys()) + assert False + return instrucciones + + def loadAndSaveAndInstructions(self,node:CILInstructionNode, instructions:str, scope:ScopeMIPS): + return self.load(node,scope)+instructions+self.save(node.destination,scope) + + def MainInstruction(self): + instrucciones="" + instrucciones+="addi $sp ,$sp, -4\n" + instrucciones+="sw $ra, 0($sp)\n" + instrucciones+="jal Main.Special\n" + instrucciones+="lw $ra, 0($sp)\n" + instrucciones+="addi $sp ,$sp, 4\n" + instrucciones+="jr $ra\n" + instrucciones+="li $v0, 10\n" + instrucciones+="syscall\n" + return instrucciones + + @visitor.on('node') + def visit(self, node, sope:ScopeMIPS): + pass + + @visitor.when(CILProgram) + def visit(self, node:CILProgram, _): + datainstructions=".data\n" + datainstructions+='StringAbort: .asciiz "Abort called from class String'+'\\'+'n'+'"\n' + datainstructions+='index_error: .asciiz "Wrong Index Detected'+'\\'+'n'+'"\n' + for element in node.Data: + stringfinal=element.valorString.replace("\n","\\n") + datainstructions+=element.nombre+': .asciiz '+stringfinal+'\n' + self.data[element.nombre]=stringfinal + + scope=ScopeMIPS() + + for element in node.Types: + self.clases.append(element.name) + self.atributos[element.name]=element.listaAtributos + self.metodos[element.name]=element.listaMetodos + self.parents[element.name]=element.parent + metodosnombre=[] + for met in element.listaMetodos: + metodosnombre.append(met.localname) + + scope.classmethods[element.name]=metodosnombre + + datainstructions+=element.name+"clase: .word " + + if element.parent==None: + datainstructions+= "0" + else: + datainstructions+=element.parent+"clase" + + + for i in range(len(element.listaMetodos)): + datainstructions+="," + datainstructions+=element.listaMetodos[i].globalname + self.metodosglobales[element.name+"#"+element.listaMetodos[i].localname]=element.listaMetodos[i].globalname + + datainstructions+="\n" + + instrucciones=".text\n" + instrucciones+=".globl main\n" + instrucciones+="main:\n" + instrucciones+=self.MainInstruction() + file_dir = 'StaticCode' + files = [os.path.abspath(file) for file in os.listdir() if file.endswith('Code')] + archivo=open(os.path.join(files[0],"AssemblyMethods.asm"),encoding='utf-8') + metodosdefault=archivo.read() + instrucciones+=metodosdefault + archivo.close() + for element in node.Methods: + # if element.nombre=="f56": + # print() + instrucciones+=(self.visit(element, scope)) + + return datainstructions+instrucciones + + @visitor.when(CILGlobalMethod) + def visit(self, node:CILGlobalMethod, scope:ScopeMIPS): + # if node.nombre in ["f9","a2i"]: + # print("here") + # if scope.methodclass in ["CellularAutomaton", '"CellularAutomaton"']: + # print("here") + instrucciones="" + instrucciones+=node.nombre+": #"+node.comments+"\n" + + scope.methodname=node.nombre + scope.methodclass=node.originclass + + localespropias={} + for i in range(len(node.locals)): + localespropias[node.locals[i]]=(i*(4)+4)#+"($sp)" + + scope.locals=localespropias + + self.locals[node.nombre]=localespropias + + misregisterparams={} + misotrosparams={} + for i in range(len(node.params)): + if i<4: + if isinstance(node.params[i], str): + misregisterparams[node.params[i]]="$a"+str(i)#$a + else: + misregisterparams[node.params[i].name]="$a"+str(i) + else: + if isinstance(node.params[i], str): + misotrosparams[node.params[i]]=((i-4+len(node.locals)+1)*4)#+"($sp)" Puse el mas 1 porque siempre antes de llamar un metodo se guarda $ra en la pila, por lo que los parametros estarian desplazados + else: + misotrosparams[node.params[i].name]=((i-4+len(node.locals)+1)*4)#+"($sp)" + + scope.registerparameters=misregisterparams + scope.parameters=misotrosparams + + self.registerparams[node.nombre]=misregisterparams + self.params[node.nombre]=misotrosparams + + #Inicalizando variables locales + instrucciones+="addi $sp, $sp, -"+str(4*len(node.locals)+4)+"\n" + # instrucciones+="sw $ra, 0($sp)\n" Al parecer sobra + + for i in range(len(node.intrucciones)): + # if not isinstance(node.intrucciones[i],str): + # print(node.intrucciones[i]) + instrucciones+=self.visit(node.intrucciones[i], scope) + + retorno=None + if len(node.intrucciones)>0: + ultimainstruccion=node.intrucciones[len(node.intrucciones)-1] + retorno=ultimainstruccion.destination + + # if retorno != None: + # instrucciones+="lw $v0, 0($sp)\n" + + + # instrucciones+="lw $ra, 0($sp)\n" Al parecer sobra + instrucciones+="addi $sp, $sp, "+str(4*len(node.locals)+4)+"\n" + instrucciones+="jr $ra\n" + + return instrucciones + + @visitor.when(CILConditionalJump) + def visit(self, node:CILConditionalJump, scope:ScopeMIPS): + instrucciones=self.load(node,scope,True) + instrucciones+="bgtz $t0, "+node.params[1]+"\n" + return instrucciones + + @visitor.when(CILJump) + def visit(self, node:CILJump, scope:ScopeMIPS): + instrucciones="b "+node.params[0]+"\n" + return instrucciones + + @visitor.when(CILAbort) + def visit(self, node:CILAbort, scope:ScopeMIPS): + instrucciones="jal .Object.abort\n" + return instrucciones + + @visitor.when(CILAssign) + def visit(self, node:CILAssign, scope:ScopeMIPS): + instrucciones="" + instrucciones+=self.load(node,scope) + + instrucciones+="move $v0, $t0\n" + + instrucciones+=self.save(node.destination,scope) + + return instrucciones + + @visitor.when(CILPlus) + def visit(self, node:CILPlus, scope:ScopeMIPS): + instrucciones="" + instrucciones+=self.load(node, scope) + + instrucciones+="add $v0, $t0, $t1\n" + + instrucciones+=self.save(node.destination,scope) + + return instrucciones + + @visitor.when(CILMinus) + def visit(self, node:CILMinus, scope:ScopeMIPS): + instrucciones="sub $v0, $t0, $t1\n" + return self.loadAndSaveAndInstructions(node,instrucciones,scope) + + @visitor.when(CILMult) + def visit(self, node:CILMult, scope:ScopeMIPS): + instrucciones="mult $t0, $t1\n" + instrucciones+="mflo $v0\n" + return self.loadAndSaveAndInstructions(node,instrucciones,scope) + + @visitor.when(CILDiv) + def visit(self, node:CILDiv, scope:ScopeMIPS): + instrucciones="div $t0, $t1\n" + instrucciones+="mflo $v0\n" + return self.loadAndSaveAndInstructions(node,instrucciones,scope) + + @visitor.when(CILEqual) + def visit(self, node:CILEqual, scope:ScopeMIPS): + # instrucciones="move $s0, $a0\n" + # instrucciones+="move $s1, $a1\n" + # instrucciones+="move $a0, $t0\n" + # instrucciones+="move $a1, $t1\n" + instrucciones="seq $v0 ,$t0, $t1\n" + # instrucciones+="move $a0, $s0\n" + # instrucciones+="move $a1, $s1\n" + return self.loadAndSaveAndInstructions(node, instrucciones, scope) + @visitor.when(CILLesser) + def visit(self, node:CILLesser, scope:ScopeMIPS): + instrucciones="slt $v0, $t0, $t1\n" + return self.loadAndSaveAndInstructions(node, instrucciones, scope) + + @visitor.when(CILLesserEqual) + def visit(self, node:CILLesserEqual, scope:ScopeMIPS): + instrucciones="sle $v0, $t0, $t1\n" + return self.loadAndSaveAndInstructions(node, instrucciones, scope) + + @visitor.when(CILLabel) + def visit(self, node:CILLabel, scope:ScopeMIPS): + instrucciones=node.params[0]+":\n" + return instrucciones + + # @visitor.when(CILArgument) + # def visit(self, node:CILArgument, scope:ScopeMIPS): + # instrucciones=self.load(node,scope) + # if scope.paramcount<4: + # instrucciones+="move $a"+str(scope.paramcount)+", $t0\n" + # else: + # instrucciones+="addi $sp, $sp, -4\n" + # instrucciones+="sw $t0, 0($sp)\n" + + return instrucciones + + @visitor.when(CILAllocate) + def visit(self, node:CILAllocate, scope:ScopeMIPS): + instrucciones="" + tipo=node.params[0] + tamanno=4 + if not tipo in ['Int','Bool']: + tamanno=(len(self.atributos[tipo])+1)*4 + instrucciones+="addi $sp, $sp, -4\n" + instrucciones+="sw $a0, 0($sp)\n" + + instrucciones+="li $a0,"+str(tamanno)+"\n" + instrucciones+="li $v0, 9\n" + instrucciones+="syscall\n" + + instrucciones+="la $t0, "+tipo+"clase\n" + instrucciones+="sw $t0, 0($v0)\n" + + #Poniendo en 0 todos los elementos + if not tipo in ['Int','Bool',"String"]: + for i in range(len(self.atributos[tipo])): + instrucciones+="sw $zero, "+str(i*4+4)+"($v0)\n" + + instrucciones+="lw $a0, 0($sp)\n" + instrucciones+="addi $sp, $sp, 4\n" + + #TODO Llamar al metodo init suyo + + return instrucciones+self.save(node.destination,scope) + + @visitor.when(CILVirtualCall) + def visit(self, node:CILVirtualCall, scope:ScopeMIPS): + tipo=node.params[0] + func_id=node.params[1] + instrucciones="" + instrucciones+="la $t0,"+tipo+"clase\n" + instrucciones+="lw $t0,"+str(scope.classmethods[tipo].index(func_id)*4+4)+"($t0)\n" + instrucciones+="addi $sp, $sp, -4\n" + instrucciones+="sw $ra, 0($sp)\n" + instrucciones+="jal $t0 #"+str(node.destination)+"<-"+str(node.params)+"\n" + instrucciones+="lw $ra, 0($sp)\n" + instrucciones+="addi $sp, $sp, 4\n" + + if scope.paramcount>4: + instrucciones+="addi $sp, $sp, "+str((scope.paramcount-4)*4)+"\n" + scope.paramcount=4 + + for i in range(scope.paramcount): + instrucciones+="lw $a"+str(scope.paramcount-1-i)+", "+str(i*4)+"($sp)\n" + + instrucciones+="addi $sp, $sp, "+str(scope.paramcount*4)+"\n" + instrucciones+=self.save(node.destination,scope) + + scope.paramcount=0 + + return instrucciones + + @visitor.when(CILCall) + def visit(self, node:CILCall, scope:ScopeMIPS): + tipo=node.params[0] + func_id=node.params[1] + instrucciones="lw $t0, 0($a0)\n" + instrucciones+="lw $t0,"+str(scope.classmethods[tipo].index(func_id)*4+4)+"($t0)\n" + instrucciones+="addi $sp, $sp, -4\n" + instrucciones+="sw $ra, 0($sp)\n" + instrucciones+="jalr $ra,$t0 #"+str(node.destination)+"<-"+str(node.params)+"\n" + instrucciones+="lw $ra, 0($sp)\n" + instrucciones+="addi $sp, $sp, 4\n" + + if scope.paramcount>4: + instrucciones+="addi $sp, $sp, "+str((scope.paramcount-4)*4)+"\n" + scope.paramcount=4 + + for i in range(scope.paramcount): + instrucciones+="lw $a"+str(scope.paramcount-1-i)+", "+str(i*4)+"($sp)\n" + + instrucciones+="addi $sp, $sp, "+str(scope.paramcount*4)+"\n" + instrucciones+=self.save(node.destination,scope) + + scope.paramcount=0 + + return instrucciones + + @visitor.when(CILArgument) + def visit(self, node:CILArgument, scope:ScopeMIPS): + instrucciones="" + # if scope.methodname in ["main","f7"]: + # print("este") + instrucciones+=self.load(node,scope,desplazamiento=scope.paramcount*4) + instrucciones+="#Argument "+str(node.params[0])+"\n" + instrucciones+="addi $sp, $sp, -4\n" + if scope.paramcount<4: + instrucciones+="sw $a"+str(scope.paramcount)+", 0($sp)\n" + instrucciones+="move $a"+str(scope.paramcount)+",$t0\n" + else: + instrucciones+="sw $t0, 0($sp)\n" + + scope.paramcount+=1 + + return instrucciones + + @visitor.when(CILStringLoad) + def visit(self, node:CILStringLoad, scope:ScopeMIPS): + nombrestring=node.params[0] + instrucciones="la $v0, "+nombrestring+"\n" + instrucciones+=self.save(node.destination,scope) + return instrucciones + + @visitor.when(CILStringEqual) + def visit(self, node:CILStringEqual, scope:ScopeMIPS): + instrucciones="" + instrucciones+="addi $sp, $sp, -12\n" + instrucciones+="sw $a0, 0($sp)\n" + instrucciones+="sw $a1, 4($sp)\n" + instrucciones+="sw $ra, 8($sp)\n" + + instrucciones+="move $a0, $t0\n" + instrucciones+="move $a1, $t1\n" + instrucciones+="jal .Str.stringcomparison\n" + + instrucciones+="lw $a0, 0($sp)\n" + instrucciones+="lw $a1, 4($sp)\n" + instrucciones+="lw $ra, 8($sp)\n" + instrucciones+="addi $sp, $sp, 12\n" + + return self.loadAndSaveAndInstructions(node,instrucciones,scope) + + @visitor.when(CILStringSubstring) + def visit(self, node:CILStringSubstring, scope:ScopeMIPS): + instrucciones="" + instrucciones+="addi $sp, $sp, -16\n" + instrucciones+="sw $a0, 0($sp)\n" + instrucciones+="sw $a1, 4($sp)\n" + instrucciones+="sw $a2, 8($sp)\n" + instrucciones+="sw $ra, 12($sp)\n" + + instrucciones+="move $a0, $t0\n" + instrucciones+="move $a1, $t1\n" + instrucciones+="move $a2, $t2\n" + instrucciones+="jal .Str.substring\n" + + instrucciones+="lw $a0, 0($sp)\n" + instrucciones+="lw $a1, 4($sp)\n" + instrucciones+="lw $a2, 8($sp)\n" + instrucciones+="lw $ra, 12($sp)\n" + instrucciones+="addi $sp, $sp, 16\n" + + return self.loadAndSaveAndInstructions(node,instrucciones,scope) + + @visitor.when(CILStringConcat) + def visit(self, node:CILStringEqual, scope:ScopeMIPS): + instrucciones="" + instrucciones+="addi $sp, $sp, -12\n" + instrucciones+="sw $a0, 0($sp)\n" + instrucciones+="sw $a1, 4($sp)\n" + instrucciones+="sw $ra, 8($sp)\n" + + instrucciones+="move $a0, $t0\n" + instrucciones+="move $a1, $t1\n" + instrucciones+="jal .Str.stringconcat\n" + + instrucciones+="lw $a0, 0($sp)\n" + instrucciones+="lw $a1, 4($sp)\n" + instrucciones+="lw $ra, 8($sp)\n" + instrucciones+="addi $sp, $sp, 12\n" + + return self.loadAndSaveAndInstructions(node,instrucciones,scope) + + @visitor.when(CILStringLenght) + def visit(self, node:CILStringLenght, scope:ScopeMIPS): + instrucciones="" + instrucciones+="addi $sp, $sp, -8\n" + instrucciones+="sw $a0, 0($sp)\n" + instrucciones+="sw $ra, 4($sp)\n" + + instrucciones+="move $a0, $t0\n" + instrucciones+="jal .Str.stringlength\n" + + instrucciones+="lw $a0, 0($sp)\n" + instrucciones+="lw $ra, 4($sp)\n" + instrucciones+="addi $sp, $sp, 8\n" + + return self.loadAndSaveAndInstructions(node,instrucciones,scope) + + + #TODO A rectificar estos + + @visitor.when(CILOutString) + def visit(self, node:CILOutString, scope:ScopeMIPS): + instrucciones="" + instrucciones+="addi $sp, $sp, -8\n" + instrucciones+="sw $a0, 0($sp)\n" + instrucciones+="sw $ra, 4($sp)\n" + + instrucciones+="move $a0, $a1\n" + instrucciones+="jal .IO.out_string\n" + + instrucciones+="lw $a0, 0($sp)\n" + instrucciones+="lw $ra, 4($sp)\n" + instrucciones+="addi $sp, $sp, 8\n" + instrucciones+="move $v0, $a0\n" + + return instrucciones+self.save(node.destination,scope) + + @visitor.when(CILInString) + def visit(self, node:CILInString, scope:ScopeMIPS): + instrucciones="" + instrucciones+="addi $sp, $sp, -8\n" + instrucciones+="sw $a0, 0($sp)\n" + instrucciones+="sw $ra, 4($sp)\n" + + instrucciones+="move $a0, $t0\n" + instrucciones+="jal .IO.in_string\n" + + instrucciones+="lw $a0, 0($sp)\n" + instrucciones+="lw $ra, 4($sp)\n" + instrucciones+="addi $sp, $sp, 8\n" + + return instrucciones+self.save(node.destination,scope) + + @visitor.when(CILOutInt) + def visit(self, node:CILOutInt, scope:ScopeMIPS): + instrucciones="" + instrucciones+="addi $sp, $sp, -8\n" + instrucciones+="sw $a0, 0($sp)\n" + instrucciones+="sw $ra, 4($sp)\n" + + instrucciones+="move $a0, $a1\n" + instrucciones+="jal .IO.out_int\n" + + instrucciones+="lw $a0, 0($sp)\n" + instrucciones+="lw $ra, 4($sp)\n" + instrucciones+="addi $sp, $sp, 8\n" + instrucciones+="move $v0, $a0\n" + + return instrucciones+self.save(node.destination,scope) + + @visitor.when(CILInInt) + def visit(self, node:CILInInt, scope:ScopeMIPS): + instrucciones="" + instrucciones+="addi $sp, $sp, -8\n" + instrucciones+="sw $a0, 0($sp)\n" + instrucciones+="sw $ra, 4($sp)\n" + + instrucciones+="move $a0, $t0\n" + instrucciones+="jal .IO.in_int\n" + + instrucciones+="lw $a0, 0($sp)\n" + instrucciones+="lw $ra, 4($sp)\n" + instrucciones+="addi $sp, $sp, 8\n" + + return instrucciones+self.save(node.destination,scope) + + # @visitor.when(CILTypeCheck) + # def visit(self, node:CILTypeCheck, scope:ScopeMIPS): + # instrucciones="" + # instrucciones+="li $v0, 1\n" + + # return instrucciones + self.save(node.destination, scope) + + + @visitor.when(CILCopy) + def visit(self, node:CILCopy, scope:ScopeMIPS): + instrucciones="" + instrucciones+="addi $sp ,$sp, -4\n" + instrucciones+="sw $ra, 0($sp)\n" + instrucciones+="jal .Object.Copy\n" + instrucciones+="lw $ra, 0($sp)\n" + instrucciones+="addi $sp ,$sp, 4\n" + return self.loadAndSaveAndInstructions(node,instrucciones,scope) + + @visitor.when(CILIntComplement) + def visit(self, node:CILIntComplement, scope:ScopeMIPS): + instrucciones="neg $v0, $t0\n" + return self.loadAndSaveAndInstructions(node,instrucciones,scope) + + @visitor.when(CILComplement) + def visit(self, node:CILComplement, scope:ScopeMIPS): + instrucciones="" + instrucciones+="seq $v0, $t0, $zero\n" + # instrucciones+="addi $v0 ,$t0, 1\n" + # instrucciones+="li $t1, 2\n" + # instrucciones+="rem $v0, $v0, $t1\n" + return self.loadAndSaveAndInstructions(node,instrucciones,scope) + + @visitor.when(CILTypeCheck) + def visit(self, node:CILTypeCheck, scope:ScopeMIPS): + # intermedio=CILTypeCheckIntermediate(node.destination,[node.params[0]]) + instrucciones="" + instrucciones+="addi $sp ,$sp, -4\n" + instrucciones+="sw $ra, 0($sp)\n" + instrucciones+="jal .TypeCheck\n" + instrucciones+="lw $ra, 0($sp)\n" + instrucciones+="addi $sp ,$sp, 4\n" + return self.loadAndSaveAndInstructions(node, instrucciones, scope) + + @visitor.when(CILIsVoid) + def visit(self, node:CILIsVoid, scope:ScopeMIPS): + instrucciones="seq $v0, $t0, $zero\n" + return self.loadAndSaveAndInstructions(node, instrucciones, scope) \ No newline at end of file diff --git a/src/Cool_Type.py b/src/Cool_Type.py new file mode 100644 index 00000000..cc2fe9c2 --- /dev/null +++ b/src/Cool_Type.py @@ -0,0 +1,74 @@ +from AST import * + +class Cool_Type: + def __init__(self, name:str, parent:str=None, attributes = None, methods = None): + self.name = name + self.parent = parent + self.attributes = attributes + self.methods = methods + + def __eq__(self, other ): + return self.name == other.name #Aqui para arreglar le pondria al inicio self!=None and other !=None and + + + + + def add_methods(self, *methods): + for method in methods: + self.methods.append(method) + + def add_attributes(self, *attributes): + for attribute in attributes: + self.attributes.append(attribute) + + def search_attribute(self, attr): + for attribute in self.attributes: + if attr == attribute.name: + return attribute + return None + + def exists_method(self, method_name: str): + for method in self.methods: + if method_name == method.name: + return True + return False + + def get_method(self, method_name: str): + for method in self.methods: + if method_name == method.name: + return method + return None + + def delete_method(self, method_name: str): + new = [] + for method in self.methods: + if method_name != method.name: + new.append(method) + self.methods = new + +def get_basic_types(): + Object = Cool_Type("Object", None, [], []) + Int = Cool_Type("Int", "Object", [], []) + Bool = Cool_Type("Bool", "Object", [], []) + String = Cool_Type("String", "Object", [], []) + SelfType = Cool_Type("SELF_TYPE", None, [], []) + IO = Cool_Type("IO", "Object", [], []) + Object.add_methods( + MethodNode(name = "abort", parameters = [], return_type = "Object" , body = None), + MethodNode(name = "type_name", parameters = [], return_type = "String" , body = None), + MethodNode(name = "copy", parameters = [], return_type = "SELF_TYPE" , body = None) + ) + IO.add_methods( + MethodNode(name = "out_string", parameters = [ParameterNode(name = "x_1", param_type = "String")], return_type = "SELF_TYPE" , body = None), + MethodNode(name = "out_int", parameters = [ParameterNode(name = "x_1", param_type = "Int")], return_type = "SELF_TYPE" , body = None), + MethodNode(name = "in_string", parameters = [], return_type = "String" , body = None), + MethodNode(name = "in_int", parameters = [], return_type = "Int" , body = None) + ) + String.add_methods( + MethodNode(name = "length", parameters = [], return_type = "Int" , body = None), + MethodNode(name = "concat", parameters = [ParameterNode(name = "x_1", param_type = "String")], return_type = "String" , body = None), + MethodNode(name = "substr", parameters = [ParameterNode(name = "x_1", param_type = "Int"), ParameterNode(name = "x_2", param_type = "Int")], return_type = "String" , body = None) + ) + basics = [Object, Int, Bool, String, SelfType, IO] + return basics + diff --git a/src/DefaultClasses.py b/src/DefaultClasses.py new file mode 100644 index 00000000..42f156ea --- /dev/null +++ b/src/DefaultClasses.py @@ -0,0 +1,86 @@ +from AST import * +from CIL import * + +#TODO Definir en CIL algunos metodos predefinidos +class Defaults: + def ObjectClass(): + #selfattribute=AttributeNode("self","Int",IntegerNode(0)) + # identifier=AttributeNode("type#","Int",IntegerNode(0)) + abort=MethodNode("abort",[],"Object",[]) + typename=MethodNode("type_name",[],"String",[]) + copy=MethodNode("copy",[],"SELF_TYPE",[]) + init=MethodNode("$init",[],"SELF_TYPE",[]) + + clase=ClassNode("Object",None,[abort,typename,copy]) + + return clase + + def BoolClass(): + clase=ClassNode("Bool","Object",[]) + return clase + + def IOClass(): + #typeString=AttributeNode("$type","String",StringNode("IO")) + out_string=MethodNode("out_string",[ParameterNode("x","String")],"SELF_TYPE",[]) + out_int=MethodNode("out_int",[ParameterNode("x","Int")],"SELF_TYPE",[]) + in_string=MethodNode("in_string",[],"String",[]) + in_int=MethodNode("in_int",[],"Int",[]) + + clase=ClassNode("IO","Object",[out_string,out_int,in_string,in_int]) + + return clase + + def StringClass(): + #typeString=AttributeNode("$type","String",StringNode("String")) + #value=AttributeNode("value", "Int", IntegerNode(0)) + + length=MethodNode("length",[],"Int",[]) + concat=MethodNode("concat",[ParameterNode("s","String")],"String",[]) + substr=MethodNode("substr",[ParameterNode("i","Int"),ParameterNode("l","Int")],"String",[]) + + clase=ClassNode("String","Object",[length,concat,substr])#Removed typeString,value, + + return clase + + def IntClass(): + clase=ClassNode("Int","Object",[]) + return clase + + # def typename_CIL(): + # instrucciones=[CILAssign("$result",["$type"])] + # return CILGlobalMethod('typename',params=["self"],locals=["$result"],instrucciones=instrucciones) + def abort_CIL(): + instrucciones=[CILAbort("$result",[])] + return CILGlobalMethod('abort',[ParameterNode("self","SELF_TYPE")],["$result"],instrucciones,comments="Object.Abort") + + def copy_CIL(cantidadatributos): + instrucciones=[CILCopy("$result",["self",cantidadatributos])] + return CILGlobalMethod('copy',[ParameterNode("self","SELF_TYPE")],["$result"],instrucciones,comments="Object.Copy") + + def out_string_CIL(): + instrucciones=[CILOutString("x"),CILAssign("$result",["self"])] + return CILGlobalMethod('out_string',[ParameterNode("self","SELF_TYPE"),ParameterNode("x","String")],["$result"],instrucciones,comments="IO.out_string") + + def out_int_CIL(): + instrucciones=[CILOutInt("x"),CILAssign("$result",["self"])] + return CILGlobalMethod('out_int',[ParameterNode("self","SELF_TYPE"),ParameterNode("x","Int")],["$result"],instrucciones,comments="IO.out_int") + + def in_string_CIL(): + instrucciones=[CILInString("$result",[])] + return CILGlobalMethod('in_string',[ParameterNode("self","SELF_TYPE")],["$result"],instrucciones,comments="IO.in_string") + + def in_int_CIL(): + instrucciones=[CILInInt("$result",[])] + return CILGlobalMethod('in_int',[ParameterNode("self","SELF_TYPE")],["$result"],instrucciones,comments="IO.in_int") + + def len_string_CIL(): + instrucciones=[CILStringLenght("$result",["self"])] + return CILGlobalMethod('length',[ParameterNode("self","SELF_TYPE")],["$result"],instrucciones,comments="String.Length") + + def concat_string_CIL(): + instrucciones=[CILStringConcat("$result",["self","s"])] + return CILGlobalMethod('concat',[ParameterNode("self","SELF_TYPE"),ParameterNode("s","String")],["$result"],instrucciones,comments="String.Concat") + + def substring_string_CIL(): + instrucciones=[CILStringSubstring("$result",["self","i","l"])] + return CILGlobalMethod('substr',[ParameterNode("self","SELF_TYPE"),ParameterNode("i","Int"),ParameterNode("l","Int")],["$result"],instrucciones,comments="String.Substring") \ No newline at end of file diff --git a/src/Scope.py b/src/Scope.py new file mode 100644 index 00000000..096f5a63 --- /dev/null +++ b/src/Scope.py @@ -0,0 +1,212 @@ +from Cool_Type import * +from AST import * + +class Scope: + def __init__(self, class_name, parent=None, local=False): + self.parent = parent + self.class_name = class_name + self.cool_types = {} + self.variables = {} + self.attributes = {} + self.methods = {} + self.locals=[] + self.params={} + self.local = local + self.valid = True + if not parent: + self.cool_types = {cool_type.name: cool_type for cool_type in get_basic_types()} + + def invalidate(self): + scope = self + while scope: + if not scope.parent: + scope.valid = False + scope = scope.parent + + def get_type(self, type_name: str): + scope = self + i = 1 + while scope: + if type_name in scope.cool_types: + return scope.cool_types[type_name] + else: + scope = scope.parent + return None + + def lower_than(self, first : Cool_Type, other : Cool_Type ): + ct = first + while ct: + if ct == other: + return True + ct = self.get_type(ct.parent) + return False + + def exists_type(self, type_name: str): + if type_name in self.cool_types: + return True + if not self.parent is None: + return self.parent.exists_type(type_name) + return False + + def create_type(self, cool_type: Cool_Type): + if self.exists_type(cool_type.name): + return False + self.cool_types[cool_type.name] = cool_type + return True + + def exists_variable(self, variable: str): + if variable == 'self': + return True + ct = self + while ct.class_name: + if variable in ct.variables: + return True + if variable in ct.attributes: + return True + ct = ct.parent + cname = self.class_name + ctype = self.get_type(cname) + while ctype: + a = ctype.search_attribute(variable) + if a: + return True + ctype = self.get_type(ctype.parent) + return False + + def get_attribute(self, variable: str): + ct = self + while ct.class_name: + if variable in ct.attributes: + return ct.attributes[variable] + ct = ct.parent + cname = self.class_name + ctype = self.get_type(cname) + while ctype: + a = ctype.search_attribute(variable) + if a: + return a + ctype = self.get_type(ctype.parent) + return None + + def get_method(self, variable: str): + ct = self + while ct.class_name: + if variable in ct.methods: + return ct.methods[variable] + ct = ct.parent + cname = self.class_name + ctype = self.get_type(cname) + while ctype: + a = ctype.get_method(variable) + if a: + return a + ctype = self.get_type(ctype.parent) + return None + + def get_parent_attribute(self, variable: str): + cname = self.class_name + ptype = self.get_type(cname) + ctype = self.get_type(ptype.parent) + while ctype: + a = ctype.search_attribute(variable) + if a: + return a + ctype = self.get_type(ctype.parent) + return None + + def get_parent_method(self, variable: str): + cname = self.class_name + ptype = self.get_type(cname) + ctype = self.get_type(ptype.parent) + while ctype: + a = ctype.get_method(variable) + if a: + return a + ctype = self.get_type(ctype.parent) + return None + + def define_variable(self, var_name: str, cool_type: Cool_Type, override=False, value=None): + scope = self + if var_name == 'self': + return False + if not override and var_name in scope.variables: + return False + self.variables[var_name] = { + 'type': cool_type, + 'value': value + } + return True + + def get_variable_type(self, variable: str): + if variable == 'self': + return self.get_type("SELF_TYPE") + ct = self + while ct.class_name: + if variable in ct.variables: + return ct.variables[variable]['type'] + if variable in ct.attributes: + return self.get_type(ct.attributes[variable].type) + ct = ct.parent + cname = self.class_name + ctype = self.get_type(cname) + while ctype: + a = ctype.search_attribute(variable) + if a: + return self.get_type(a.type) + ctype = self.get_type(ctype.parent) + + + def get_types(self): + return self.cool_types + + def set_types(self, new_types): + self.cool_types = new_types + + def exists_attribute(self, attribute: str): + if attribute in self.attributes: + return True + if not self.parent is None: + return self.parent.exists_attribute(attribute) + return False + + def define_attribute(self, attribute: str, cool_type: Cool_Type, value=None): + if self.exists_attribute(attribute): + return False + self.attributes[attribute] = AttributeNode(name = attribute, attr_type = cool_type, value = value) + return True + + def exists_method(self, method: str): + if method in self.methods: + return True + if not self.parent is None: + return self.parent.exists_method(method) + return False + + def exists_type_method(self,ctype: Cool_Type,method:str): + rtype = ctype + while rtype: + if rtype.exists_method(method): + return True + rtype = self.get_type(rtype.parent) + return False + + def get_type_method(self,ctype: Cool_Type,method:str): + rtype = ctype + while rtype: + if rtype.exists_method(method): + return rtype.get_method(method) + rtype = self.get_type(rtype.parent) + return None + + def define_method(self, method: str, parameters:list, cool_type: Cool_Type, body=None): + if self.exists_method(method): + return False + self.methods[method] = MethodNode(name = method, parameters = parameters, return_type = cool_type, body = body) + return True + + def join(self, ctype: Cool_Type, other: Cool_Type): + first = ctype + while first: + if self.lower_than(other, first): + return first + first = self.get_type(first.parent) \ No newline at end of file diff --git a/src/ScopeMIPS.py b/src/ScopeMIPS.py new file mode 100644 index 00000000..50b0ab87 --- /dev/null +++ b/src/ScopeMIPS.py @@ -0,0 +1,11 @@ +class ScopeMIPS: + def __init__(self): + self.classmethods={} + self.methodname="" + self.locals={} + self.attributes=[] + self.registerparameters={} + self.parameters={} + self.paramcount=0 + self.methodclass="" + self.labelcount=0 \ No newline at end of file diff --git a/src/Semantic_Checking.py b/src/Semantic_Checking.py new file mode 100644 index 00000000..faa5cc0d --- /dev/null +++ b/src/Semantic_Checking.py @@ -0,0 +1,578 @@ +from AST import * +from Scope import * +from Cool_Type import * +import visitor as visitor + +class Semantics_Checker: + + def safe_methods(self, node1:MethodNode, node2: MethodNode, scope:Scope): + if not node1.name == node2.name: + return True + if len(node1.parameters)==len(node2.parameters): + for i in range(len(node1.parameters)): + if node1.parameters[i].type != node2.parameters[i].type: + print('('+str(node1.line)+', '+str(node1.index)+') - SemanticError: In redifined method '+node1.name+', parameter type '+node1.parameters[i].type+' is different from original type '+node2.parameters[i].type +'.') + scope.invalidate() + if node1.return_type != node2.return_type: + print('('+str(node1.line)+', '+str(node1.index)+') - SemanticError: In redifined method '+node1.name+', return type '+node1.return_type+' is different from original return type '+node2.return_type +'.') + scope.invalidate() + return True + print('('+str(node1.line)+', '+str(node1.index)+') - SemanticError: Incompatible number of formal parameters in redifined method '+node1.name+'.') + scope.invalidate() + return False + + def params_for_method(self, node1:list, node2: MethodNode, scope:Scope): + if len(node1)==len(node2.parameters): + for i in range(len(node2.parameters)): + if not scope.lower_than(node1[i], scope.get_type(node2.parameters[i].type)): + return node2.parameters[i].name + return "all clear" + return "wrong number" + + def check_inheritance(self, classes: list, scope:Scope): + mask = [0] * (len(classes) + 2) + mapper = {} + mask[-1] = 2 + mask[-2] = 2 + mapper["Object"] = len(classes) + 1 + mapper["IO"] = len(classes) + for i in range(len(classes)): + cclass = classes[i] + mapper[cclass.name] = i + for cclass in classes: + if cclass.parent in ["Int","String","Bool"]: + mask[mapper[cclass.name]]=2 + elif not cclass.parent in mapper: + print('('+str(cclass.line)+', '+str(cclass.index)+') - TypeError: Class '+ cclass.name +' inherits from an undefined class '+ cclass.parent +'.') + scope.invalidate() + cclass.parent = 'Object' + for i in range(len(classes)): + cclass = classes[i] + if cclass.parent in ["Int","String","Bool","Object","IO","SELF_TYPE"]: + pass + elif not self.check_cyclic_inheritance(i,mask,mapper,classes,scope)==2: + return False + return True + + def check_cyclic_inheritance(self, cclass: int, mask: list, mapper: dict, classes: list, scope:Scope): + if mask[cclass] == 2: + return 2 + elif mask[cclass] == 1: + mask[cclass] = 2 + return 1 + mask[cclass] = 1 + parent = mapper[classes[cclass].parent] + ret = self.check_cyclic_inheritance(parent, mask, mapper, classes,scope) + if ret == 1: + print('('+str(classes[cclass].line)+', '+str(classes[cclass].index)+') - SemanticError: Class '+ classes[cclass].name +', or an ancestor of '+ classes[cclass].name +', is involved in an inheritance cycle.') + scope.invalidate() + return 0 + mask[cclass] = 2 + return ret + + # def types_sort(self, types: dict): + # list_types = list(types.values()) + # mask = [False] * len(list_types) + # mapper = {} + # sorted = [] + # for i in range(len(classes)): + # cclass = classes[i] + # mapper[classes.name] = i + # mask[mapper["Object"]] = True + + # for i in range(len(classes)): + + + + @visitor.on('node') + def visit(self, node, scope): + pass + + @visitor.when(ProgramNode) + def visit(self, node: ProgramNode, _): + rscope = Scope(None) + if self.check_inheritance(node.classes,rscope): + for c_class in node.classes: + cool_type = Cool_Type(c_class.name, c_class.parent, c_class.attributes, c_class.methods) + if cool_type.name in ["Int","String","Bool","Object","IO","SELF_TYPE"]: + print('('+str(c_class.line)+', '+str(c_class.index)+') - SemanticError: Redefinition of basic class '+c_class.name+'.') + rscope.invalidate() + elif not rscope.create_type(cool_type): + print('('+str(c_class.line)+', '+str(c_class.index)+') - SemanticError: Classes may not be redifined.') + rscope.invalidate() + for c_class in node.classes: + if not c_class.name in ["Int","String","Bool","Object","IO","SELF_TYPE"]: + scope = Scope(c_class.name,rscope) + self.visit(c_class,scope) + else: + pass + return rscope.valid + + @visitor.when(ClassNode) + def visit(self, node: ClassNode, scope: Scope): + parent = node.parent + if node.parent in ["Int","String","Bool"]: + print('('+str(node.line)+', '+str(node.index)+') - SemanticError: Class '+ node.name +' cannot inherit class '+node.parent+'.') + scope.invalidate() + cparent = scope.get_type(parent) + for attr in node.attributes: + if cparent: + p_attr = scope.get_parent_attribute(attr.name) + if p_attr and attr.name == p_attr.name: + print('('+str(attr.line)+', '+str(attr.index)+') - SemanticError: Attribute '+attr.name+' is an attribute of an inherited class.') + scope.invalidate() + if not scope.define_attribute(attr.name, attr.type, attr.value): + print('('+str(attr.line)+', '+str(attr.index)+') - SemanticError: Attribute '+attr.name+' is multiply defined in class.') + scope.invalidate() + for method in node.methods: + if cparent: + p_method = scope.get_parent_method(method.name) + if not p_method is None: + self.safe_methods(method, p_method,scope) + if not scope.define_method(method.name, method.parameters, method.return_type, method.body): + print('('+str(method.line)+', '+str(method.index)+') - SemanticError: Method '+method.name+' is multiply defined.') + scope.invalidate() + for attr in node.attributes: + self.visit(attr,scope) + for method in node.methods: + nscope = Scope(scope.class_name,scope) + self.visit(method,nscope) + + @visitor.when(AttributeNode) + def visit(self, node: AttributeNode, scope: Scope): + if not scope.exists_type(node.type) and scope.local: + print('('+str(node.line)+', '+str(node.index)+') - TypeError: Class '+node.type+' of let-bound identifier '+node.name+' is undefined.') + scope.invalidate() + elif not scope.exists_type(node.type): + print('('+str(node.line)+', '+str(node.index)+') - TypeError: Class '+node.type+' of attribute '+node.name+' is undefined.') + scope.invalidate() + else: + node.static_type = scope.get_type(node.type) + t_value = node.static_type + if node.value: + t_value = self.visit(node.value,scope) + if scope.local: + if not scope.define_variable(node.name, node.static_type, True, node.value): + print('('+str(node.line)+', '+str(node.index)+") - SemanticError: 'self' cannot be bound in a 'let' expression.") + scope.invalidate() + elif not scope.lower_than(t_value, node.static_type): + print('('+str(node.line)+', '+str(node.index)+') - TypeError: Inferred type '+ t_value.name + ' of initialization of '+ node.name + ' does not conform to identifiers declared type ' + node.type) + scope.invalidate() + else: + if node.name == 'self': + print('('+str(node.line)+', '+str(node.index)+") - SemanticError: 'self' cannot be the name of an attribute") + scope.invalidate() + elif t_value and not scope.lower_than(t_value, node.static_type): + print('('+str(node.line)+', '+str(node.index)+') - TypeError: Inferred type '+ t_value.name + ' of initialization of attribute '+ node.name + ' does not conform to declared type ' + node.type) + scope.invalidate() + return scope.get_type(node.type) + + + @visitor.when(MethodNode) + def visit(self, node: MethodNode, scope: Scope): + nscope = Scope(scope.class_name, scope, True) + for param in node.parameters: + self.visit(param, nscope) + if not nscope.exists_type(node.return_type): + print('('+str(node.line)+', '+str(node.index)+') - TypeError: Undefined return type '+node.return_type+' in method '+node.name+'.') + scope.invalidate() + else: + t_value = self.visit(node.body,nscope) + node.static_type = nscope.get_type(node.return_type) + if not node.static_type.name == 'SELF_TYPE' and t_value.name == 'SELF_TYPE': + t_value = nscope.get_type(scope.class_name) + if not nscope.lower_than(t_value, node.static_type): + print('('+str(node.line)+', '+str(node.index)+') - TypeError: Inferred return type '+ t_value.name + ' of method '+ node.name + ' does not conform to declared return type ' + node.return_type) + scope.invalidate() + + @visitor.when(ParameterNode) + def visit(self, node: ParameterNode, scope: Scope): + if not scope.exists_type(node.type): + print('('+str(node.line)+', '+str(node.index)+') - TypeError: Class '+node.type+' of formal parameter '+node.name+' is undefined.') + scope.invalidate() + else: + if node.name == 'self': + print('('+str(node.line)+', '+str(node.index)+") - SemanticError: 'self' cannot be the name of a formal parameter") + scope.invalidate() + elif not scope.define_variable(node.name,scope.get_type(node.type)): + print('('+str(node.line)+', '+str(node.index)+') - SemanticError: Formal parameter '+ node.name +' is multiply defined.') + scope.invalidate() + + @visitor.when(IntegerNode) + def visit(self, node: IntegerNode, scope: Scope): + node.static_type = scope.get_type('Int') + return scope.get_type("Int") + + @visitor.when(StringNode) + def visit(self, node: StringNode, scope: Scope): + node.static_type = scope.get_type('String') + return scope.get_type("String") + + @visitor.when(BoolNode) + def visit(self, node: BoolNode, scope: Scope): + node.static_type = scope.get_type('Bool') + return scope.get_type("Bool") + + @visitor.when(NewNode) + def visit(self, node: NewNode, scope: Scope): + node.static_type = scope.get_type(node.type) + if node.static_type is None: + print('('+str(node.line)+', '+str(node.index)+") - TypeError: 'new' used with undefined class "+node.type+".") + scope.invalidate() + return scope.get_type(node.type) + + @visitor.when(VariableNode) + def visit(self, node: VariableNode, scope: Scope): + if not scope.exists_variable(node.id): + print('('+str(node.line)+', '+str(node.index)+') - NameError: Undeclared identifier '+node.id) + scope.invalidate() + return_type = scope.get_variable_type(node.id) + node.static_type = return_type + return return_type + + @visitor.when(IsVoidNode) + def visit(self, node: IsVoidNode, scope: Scope): + node.static_type = scope.get_type('Bool') + t_value = self.visit(node.expression, scope) + node.tipo=t_value.name + # if not scope.lower_than(t_value, node.static_type): + # pass + # #Agregar error de tipo invalido en la expresion + return scope.get_type("Bool") + + @visitor.when(AssignNode) + def visit(self, node: AssignNode, scope: Scope): + t_value = self.visit(node.expression,scope) + if not scope.exists_variable(node.variable): + pass + #Agregar error de variable indefinida + else: + static_type = scope.get_variable_type(node.variable) + if node.variable == 'self': + print('('+str(node.line)+', '+str(node.index)+") - SemanticError: Cannot assign to 'self'.") + scope.invalidate() + elif not scope.lower_than(t_value, static_type): + print('('+str(node.line)+', '+str(node.index)+') - TypeError: Inferred type '+ t_value.name + ' of initialization of attribute '+ node.variable + ' does not conform to declared type ' + static_type.name) + scope.invalidate() + node.static_type = t_value + return t_value + + @visitor.when(BlockNode) + def visit(self, node: BlockNode, scope: Scope): + expr_type = None + for expr in node.expressions: + expr_type = self.visit(expr, scope) + node.static_type = expr_type + return expr_type + + @visitor.when(DispatchNode) + def visit(self, node: DispatchNode, scope: Scope): + if node.line==95: + print() + if node.left_expression: + param_types = [] + for param in node.parameters: + param_type = self.visit(param,scope) + if param_type.name == "SELF_TYPE": + param_type = scope.get_type(scope.class_name) + param_types.append(param_type) + dtype = self.visit(node.left_expression,scope) + if dtype.name == "SELF_TYPE": + dtype = scope.get_type(scope.class_name) + node.left_type=dtype.name + if node.left_type==None: + print() + if not scope.exists_type_method(dtype,node.func_id): + print('('+str(node.line)+', '+str(node.index)+') - AttributeError: Dispatch to undefined method '+node.func_id+'.') + scope.invalidate() + else: + method = scope.get_type_method(dtype,node.func_id) + params = self.params_for_method(param_types,method,scope) + if params == "wrong number": + print('('+str(node.line)+', '+str(node.index)+') - SemanticError: Method '+node.func_id+' called with wrong number of arguments.') + scope.invalidate() + elif not params == "all clear": + print('('+str(node.line)+', '+str(node.index)+') - TypeError: In call of method '+ node.func_id +', type of parameter '+params+' does not conform to declared type.') + scope.invalidate() + return_type = scope.get_type(method.return_type) + if return_type.name == "SELF_TYPE": + return_type = dtype + node.static_type = return_type + return return_type + else: + param_types = [] + for param in node.parameters: + param_types.append(self.visit(param,scope)) + dtype = scope.get_type(scope.class_name) + node.left_type=dtype.name + if node.left_type==None: + print() + if not scope.exists_type_method(dtype,node.func_id): + print('('+str(node.line)+', '+str(node.index)+') - AttributeError: Dispatch to undefined method '+node.func_id) + scope.invalidate() + else: + method = scope.get_type_method(dtype,node.func_id) + params = self.params_for_method(param_types,method,scope) + if params == "wrong number": + print('('+str(node.line)+', '+str(node.index)+') - SemanticError: Method '+node.func_id+' called with wrong number of arguments.') + scope.invalidate() + elif not params == "all clear": + print('('+str(node.line)+', '+str(node.index)+') - TypeError: In call of method '+ node.func_id +', type of parameter '+params+' does not conform to declared type.') + scope.invalidate() + return_type = scope.get_type(method.return_type) + if return_type.name == "SELF_TYPE": + return_type = dtype + node.static_type = return_type + return return_type + + @visitor.when(StaticDispatchNode) + def visit(self, node: StaticDispatchNode, scope: Scope): + param_types = [] + for param in node.parameters: + param_type = self.visit(param, scope) + if param_type.name == "SELF_TYPE": + param_type = scope.get_type(scope.class_name) + param_types.append(param_type) + dtype = self.visit(node.left_expression,scope) + if dtype.name == "SELF_TYPE": + dtype = scope.get_type(scope.class_name) + node.left_type=dtype.name + parent_type = scope.get_type(node.parent_id) + if not scope.lower_than(dtype, parent_type): + print('('+str(node.line)+', '+str(node.index)+') - TypeError: Expression type '+ dtype.name +' does not conform to declared static dispatch type '+ parent_type.name +'.') + scope.invalidate() + elif not scope.exists_type_method(dtype,node.func_id): + print('('+str(node.line)+', '+str(node.index)+') - AttributeError: Dispatch to undefined method '+node.func_id) + scope.invalidate() + else: + method = scope.get_type_method(parent_type,node.func_id) + params = self.params_for_method(param_types,method,scope) + if params == "wrong number": + print('('+str(node.line)+', '+str(node.index)+') - SemanticError: Method '+node.func_id+' called with wrong number of arguments.') + scope.invalidate() + elif not params == "all clear": + print('('+str(node.line)+', '+str(node.index)+') - TypeError: In call of method '+ node.func_id +', type of parameter '+params+' does not conform to declared type.') + scope.invalidate() + return_type = scope.get_type(method.return_type) + if return_type.name == "SELF_TYPE": + return_type = dtype + node.static_type = return_type + return return_type + + @visitor.when(LetNode) + def visit(self, node: LetNode, scope: Scope): + nscope = Scope(scope.class_name, scope,True) + for declaration in node.declarations: + self.visit(declaration, nscope) + b_value = self.visit(node.body,nscope) + node.static_type = b_value + return b_value + + @visitor.when(ConditionalNode) + def visit(self, node: ConditionalNode, scope: Scope): + ptype = self.visit(node.predicate,scope) + if ptype and not ptype.name == "Bool": + print('('+str(node.line)+', '+str(node.index)+') - TypeError: Predicate of '+"'if'"+ 'does not have type Bool.') + scope.invalidate() + ttype = self.visit(node.then_body,scope) + etype = self.visit(node.else_body,scope) + if not ttype and not etype: + node.static_type = scope.get_type('Object') + return scope.get_type('Object') + elif not etype: + node.static_type = ttype + return ttype + elif not ttype: + node.static_type = etype + return etype + elif ttype.name == 'SELF_TYPE' and etype.name == 'SELF_TYPE': + node.static_type = ttype + return ttype + elif ttype.name == 'SELF_TYPE': + return_type = scope.join(etype,scope.get_type(scope.classname)) + node.static_type = return_type + return return_type + elif etype.name == 'SELF_TYPE': + return_type = scope.join(ttype,scope.get_type(scope.classname)) + node.static_type = return_type + return return_type + else: + return_type = scope.join(ttype,etype) + node.static_type = return_type + return return_type + + @visitor.when(LoopNode) + def visit(self, node: LoopNode, scope: Scope): + ptype = self.visit(node.predicate, scope) + if not ptype.name == "Bool": + print('('+str(node.line)+', '+str(node.index)+') - TypeError: Loop condition does not have type Bool.') + scope.invalidate() + self.visit(node.body,scope) + node.static_type = scope.get_type("Object") + return scope.get_type("Object") + + @visitor.when(CaseNode) + def visit(self, node: CaseNode, scope: Scope): + sub_types = [] + dtype = self.visit(node.expression,scope) + for subcase in node.subcases: + if not subcase.type in sub_types: + sub_types.append(subcase.type) + else: + print('('+str(subcase.line)+', '+str(subcase.index)+') - SemanticError: Duplicate branch'+subcase.type+'in case statement.') + scope.invalidate() + sub_rtypes = [] + for subcase in node.subcases: + nscope = Scope(scope.class_name,scope,True) + sub_rtypes.append(self.visit(subcase,nscope)) + return_type = sub_rtypes[0] + for subtype in sub_rtypes: + if return_type.name == "SELF_TYPE" and subtype.name == "SELF_TYPE": + continue + elif return_type.name == "SELF_TYPE": + return_type = scope.join(scope.get_type(scope.class_name),subtype) + elif subtype.name == "SELF_TYPE": + return_type = scope.join(scope.get_type(scope.class_name),return_type) + else: + return_type = scope.join(return_type,subtype) + node.static_type = return_type + return return_type + + @visitor.when(SubCaseNode) + def visit(self, node: SubCaseNode, scope: Scope): + stype = scope.get_type(node.type) + if stype is None: + print('('+str(node.line)+', '+str(node.index)+') - TypeError: Class '+node.type+' of case branch is undefined.') + scope.invalidate() + scope.define_variable(node.name,stype,True) + return_type = self.visit(node.expression,scope) + node.static_type = return_type + return return_type + + @visitor.when(IntComplementNode) + def visit(self, node: IntComplementNode, scope: Scope): + etype = self.visit(node.right, scope) + if not etype.name == "Int": + print('('+str(node.line)+', '+str(node.index)+") - TypeError: Argument of '~' has type "+etype.name+" instead of Int.") + scope.invalidate() + int_type = scope.get_type('Int') + node.static_type = int_type + return int_type + + @visitor.when(BoolComplementNode) + def visit(self, node: BoolComplementNode, scope: Scope): + etype = self.visit(node.right, scope) + if not etype.name == "Bool": + print('('+str(node.line)+', '+str(node.index)+") - TypeError: Argument of 'not' has type "+etype.name+" instead of Bool.") + scope.invalidate() + bool_type = scope.get_type('Bool') + node.static_type = bool_type + return bool_type + + @visitor.when(PlusNode) + def visit(self, node: PlusNode, scope: Scope): + ltype = self.visit(node.left, scope) + rtype = self.visit(node.right, scope) + if ltype and rtype and (not ltype.name == 'Int' or not rtype.name == 'Int'): + print('('+str(node.line)+', '+str(node.index)+') - TypeError: non-Int arguments: '+ ltype.name +' '+node.operator+' '+rtype.name) + scope.invalidate() + int_type = scope.get_type('Int') + node.static_type = int_type + return int_type + + @visitor.when(MinusNode) + def visit(self, node: MinusNode, scope: Scope): + ltype = self.visit(node.left, scope) + rtype = self.visit(node.right, scope) + if not ltype.name == 'Int' or not rtype.name == 'Int': + print('('+str(node.line)+', '+str(node.index)+') - TypeError: non-Int arguments: '+ ltype.name +' '+node.operator+' '+rtype.name) + scope.invalidate() + int_type = scope.get_type('Int') + node.static_type = int_type + return int_type + + @visitor.when(MultNode) + def visit(self, node: MultNode, scope: Scope): + ltype = self.visit(node.left, scope) + rtype = self.visit(node.right, scope) + if not ltype.name == 'Int' or not rtype.name == 'Int': + print('('+str(node.line)+', '+str(node.index)+') - TypeError: non-Int arguments: '+ ltype.name +' '+node.operator+' '+rtype.name) + scope.invalidate() + int_type = scope.get_type('Int') + node.static_type = int_type + return int_type + + @visitor.when(DivNode) + def visit(self, node: DivNode, scope: Scope): + ltype = self.visit(node.left, scope) + rtype = self.visit(node.right, scope) + if not ltype.name == 'Int' or not rtype.name == 'Int': + print('('+str(node.line)+', '+str(node.index)+') - TypeError: non-Int arguments: '+ ltype.name +' '+node.operator+' '+rtype.name) + scope.invalidate() + int_type = scope.get_type('Int') + node.static_type = int_type + return int_type + + @visitor.when(LesserNode) + def visit(self, node: LesserNode, scope: Scope): + ltype = self.visit(node.left, scope) + rtype = self.visit(node.right, scope) + if node.operator == '=': + if ltype.name in ['Int','Bool','String'] or rtype.name in ['Int','Bool','String']: + if not ltype.name == rtype.name: + print('('+str(node.line)+', '+str(node.index)+') - TypeError: Illegal comparison with a basic type.') + scope.invalidate() + else: + if not ltype.name == 'Int' or not rtype.name == 'Int': + print('('+str(node.line)+', '+str(node.index)+') - TypeError: non-Int arguments: '+ ltype.name +' '+node.operator+' '+rtype.name) + scope.invalidate() + bool_type = scope.get_type('Bool') + node.static_type = bool_type + return bool_type + + @visitor.when(LesserEqualNode) + def visit(self, node: LesserEqualNode, scope: Scope): + ltype = self.visit(node.left, scope) + rtype = self.visit(node.right, scope) + if node.operator == '=': + if ltype.name in ['Int','Bool','String'] or rtype.name in ['Int','Bool','String']: + if not ltype.name == rtype.name: + print('('+str(node.line)+', '+str(node.index)+') - TypeError: Illegal comparison with a basic type.') + scope.invalidate() + else: + if not ltype.name == 'Int' or not rtype.name == 'Int': + print('('+str(node.line)+', '+str(node.index)+') - TypeError: non-Int arguments: '+ ltype.name +' '+node.operator+' '+rtype.name) + scope.invalidate() + bool_type = scope.get_type('Bool') + node.static_type = bool_type + return bool_type + + @visitor.when(EqualNode) + def visit(self, node: EqualNode, scope: Scope): + ltype = self.visit(node.left, scope) + rtype = self.visit(node.right, scope) + if node.operator == '=': + if ltype.name == 'String': + node.isString=True + if ltype.name in ['Int','Bool','String'] or rtype.name in ['Int','Bool','String']: + if not ltype.name == rtype.name: + print('('+str(node.line)+', '+str(node.index)+') - TypeError: Illegal comparison with a basic type.') + scope.invalidate() + else: + if not ltype.name == 'Int' or not rtype.name == 'Int': + print('('+str(node.line)+', '+str(node.index)+') - TypeError: non-Int arguments: '+ ltype.name +' '+node.operator+' '+rtype.name) + scope.invalidate() + bool_type = scope.get_type('Bool') + node.static_type = bool_type + return bool_type + + + + + + + + + + + diff --git a/src/StaticCode/AssemblyMethods.asm b/src/StaticCode/AssemblyMethods.asm new file mode 100644 index 00000000..eeaa31d5 --- /dev/null +++ b/src/StaticCode/AssemblyMethods.asm @@ -0,0 +1,456 @@ + #$a0 debe ser el string + .IO.out_string: + li $v0, 4 + syscall + jr $ra + + #$a0 debe ser el string + .IO.out_int: + li $v0, 1 + syscall + jr $ra + + .IO.in_int: + li $v0, 5 + syscall + jr $ra + + .IO.in_string: + li $v0, 9 + move $s0, $a0 + li $a0, 1024 + syscall + move $t1, $v0 + move $a0, $v0 + li $a1, 1024 + li $v0, 8 + syscall + move $v0, $t1 + #Buscando y arreglando posible salto de linea + move $t0, $v0 + move $t1, $zero + li $t2, 10 + Iniciochequeofinlinea: + lb $t1, 0($t0) + beq $t1, $t2, Cambiafinlinea + addi $t0, $t0, 1 + bne $t1, $zero, Iniciochequeofinlinea + jr $ra + Cambiafinlinea: + sb $zero, 0($t0) + jr $ra + + #Los numeros como argumentos $a0 y $a1, y $a2 como donde guardar el resultado + .Int.suma: + lw $t1, 0($a0) + lw $t2, 0($a1) + add $v0, $t1, $t2 + sw $v0, 0($a2) + jr $ra + + .Int.resta: + lw $t1, 0($a0) + lw $t2, 0($a1) + sub $v0, $t1, $t2 + sw $v0, 0($a2) + jr $ra + + .Int.multiplicacion: + lw $t1, 0($a0) + lw $t2, 0($a1) + mult $t1, $t2 + mflo $v0 + sw $v0, 0($a2) + jr $ra + + .Int.division: + lw $t1, 0($a0) + lw $t2, 0($a1) + div $t1, $t2 + mflo $v0 + sw $v0, 0($a2) + jr $ra + + .Int.lesser: + lw $t1, 0($a0) + lw $t2, 0($a1) + blt $t1, $t2, LesserTrue + move $v0, $zero + b LesserEnd + LesserTrue: + li $v0, 1 + LesserEnd: + sw $v0, 0($a2) + jr $ra + + .Int.lesserequal: + lw $t1, 0($a0) + lw $t2, 0($a1) + ble $t1, $t2, LesserEqualTrue + li $v0, 0 + b LesserEqualEnd + LesserEqualTrue: + li $v0, 1 + LesserEqualEnd: + sw $v0, 0($a2) + jr $ra + + .Int.not: + lw $t1, 0($a0) + move $t2, $zero + beq $t1, $t2, FalseBool + li $v0, 0 + b NotBool + FalseBool: + li $v0, 1 + NotBool: + sw $v0, 0($a1) + jr $ra + + .Int.igual: + move $t1, $a0 + move $t2, $a1 + beq $t1, $t2, Iguales + li $v0, 0 + b FinalIgual + Iguales: + li $v0, 1 + FinalIgual: + sw $v0, 0($a2) + jr $ra + + .Str.stringlength: + move $t1, $a0 + move $v0, $zero + move $t2, $zero + + InicioStrLen: + add $t0, $t1, $v0 + lb $t2, 0($t0) + beq $t2, $zero, FinStrLen + addi $v0, $v0, 1 + b InicioStrLen + + FinStrLen: + #sw $v0, 0($a1) El protocolo cambio + jr $ra + + .Object.abort: + li $v0, 4 + la $a0, StringAbort + syscall + li $v0, 10 + syscall + jr $ra + + .Str.stringcomparison: + move $t1, $a0 + move $t2, $a1 + move $v0, $zero + move $t3, $zero + move $t4, $zero + move $v0, $zero + + StrCompCiclo: + add $t0, $t1, $v0 + lb $t3, 0($t0) + add $t0, $t2, $v0 + lb $t4, 0($t0) + addi $v0, $v0, 1 + bne $t3, $t4, StrDiferentes + beq $t3, $zero, StrIguales + b StrCompCiclo + + StrDiferentes: + move $v0, $zero + jr $ra + StrIguales: + li $v0, 1 + jr $ra + + .Str.stringconcat: + addi $sp, $sp, -20 + + sw $s0, 0($sp) + sw $s1, 4($sp) + sw $s2, 8($sp) + sw $s3, 12($sp) + sw $s4, 16($sp) + + move $s0, $a0 + move $s1, $a1 + move $s2, $a2 + move $s3, $ra + + jal .Str.stringlength + move $s4, $v0 + move $a0, $s1 + jal .Str.stringlength + add $s4, $s4, $v0 + addi $s4, $s4, 1 + + #Reservando memoria + move $a0, $s4 + li $v0, 9 + syscall + + move $t0, $v0 + move $t1, $zero + move $t2, $s0 + move $t3, $s1 + + InicioCicloCopia: + lb $t1, 0($t2) + beq $t1, $zero, SegundoString + sb $t1, 0($t0) + addi $t0, $t0, 1 + addi $t2, $t2, 1 + b InicioCicloCopia + + SegundoString: + lb $t1, 0($t3) + beq $t1, $zero, FinalCopia + sb $t1, 0($t0) + addi $t0, $t0, 1 + addi $t3, $t3, 1 + b SegundoString + + FinalCopia: + sb $zero, 0($t0) + + + move $a0, $s0 + move $a1, $s1 + move $a2, $s2 + move $ra, $s3 + + lw $s0, 0($sp) + lw $s1, 4($sp) + lw $s2, 8($sp) + lw $s3, 12($sp) + lw $s4, 16($sp) + + addi $sp, $sp, 20 + + jr $ra + + #Old.Str.stringconcat: + #Salvando registros + addi $sp, $sp, -20 + + sw $s0, 4($sp) + sw $s1, 8($sp) + sw $s2, 12($sp) + sw $s3, 16($sp) + + move $s0, $a0 + move $s1, $a1 + move $s2, $a2 + move $s3, $ra + + #sw $a0, 0($sp) + + #Obteniendo el lenght de la nueva cadena + jal .Str.stringlength + move $s4, $v0 + move $a0, $s1 + #move $a1, $sp + jal .Str.stringlength + add $s4, $s4, $v0 + addi $sp, $sp, 4 + addi $s4, $s4, 1 + + #Reservando memoria + move $a0, $s4 + li $v0, 9 + syscall + + move $t0, $v0 + move $t1, $s0 + move $t2, $zero + move $t3, $zero + + StrCicloCopia: + lb $t2, 0($t1) + addi $t1, 1 + addi $t0, 1 + + bne $t2, $zero, StrCicloCopia + sb $t2, 0($t0) + + bne $t3, $zero, StrFinCopia + move $t1, $s1 + + b StrCicloCopia + + StrFinCopia: + sb $zero, 0($t0) + + #sw $v0, 0($s2) + + move $a0, $s0 + move $a1, $s1 + move $a2, $s2 + move $ra, $s3 + + lw $s0, 4($sp) + lw $s1, 8($sp) + lw $s2, 12($sp) + lw $s3, 16($sp) + + addi $sp, $sp, 20 + + jr $ra + + .Str.substring: + addi $sp, $sp, -16 + + sw $s0 4($sp) + sw $s1 8($sp) + sw $s2 12($sp) + + move $s0, $a0 + move $s1, $a1 + move $s2, $a2 + + addi $a0, $a2, 1 + li $v0, 9 + syscall + + add $t0, $s0, $s1 + move $t1, $zero + move $t2, $zero + + iniciocopianuevosubstr: + + add $t3, $v0, $t1 + lb $t2, 0($t0) + sb $t2, 0($t3) + + addi $t0, $t0, 1 + addi $t1, $t1, 1 + + blt $t1, $s2, iniciocopianuevosubstr + add $t3, $v0, $t1 + sb $zero, 0($t3) + + move $a0, $s0 + move $a1, $s1 + move $a2, $s2 + + lw $s0, 4($sp) + lw $s1, 8($sp) + lw $s2, 12($sp) + + addi $sp, $sp, 16 + + jr $ra + + + + .Str.substringOld: + blt $a1, $zero, SubStrWrongIndex + + addi $sp, $sp, -20 + + sw $s0 4($sp) + sw $s1 8($sp) + sw $s2 12($sp) + sw $s3 16($sp) + + move $s0, $a0 + move $s1, $a1 + move $s2, $a2 + move $s3, $ra + + + jal .Str.stringlength + + blt $v0, $s1, SubStrWrongIndex + + addi $v0, $v0, 1 + + #Reservando memoria + move $a0, $v0 + li $v0, 9 + syscall + + move $t0, $v0 + move $t1, $s0 + move $t2, $zero + + StrInicioCopiaSubStr: + lb $t3, 0($t1) + sb $t3, 0($t0) + addi $t0, $t0, 1 + addi $t1, $t0, 1 + addi $t2, $t2, 1 + ble $t2, $s1, StrInicioCopiaSubStr + + sb $zero, 0($t0) + + sw $v0, 0($s2) + + move $ra, $s3 + + move $a0, $s0 + move $a1, $s1 + move $a2, $s2 + + lw $s0, 4($sp) + lw $s1, 8($sp) + lw $s2, 12($sp) + lw $s3, 16($sp) + + addi $sp, $sp, 20 + + jr $ra + + SubStrWrongIndex: + la $a0, index_error + li $v0, 4 + syscall + li $v0, 10 + syscall + + #En este metodo viole la regla usual de que los parametros van en los registros a, y se encuentran en los t. + #Esto se realizo ya que este metodo solo se usa en un lugar y atendiendo a la estructura del conversor a MIPS + .Object.Copy: + addi $sp, $sp, -8 + + sw $s0, 0($sp) + sw $s1, 4($sp) + move $s0, $t0 + move $s1, $t1 + addi $s1, 1 + move $a0, $s1 + li $v0, 9 + syscall + move $t1, $v0 + $ciclocopia: + beq $s1, $zero, $finciclocopia + lw $t0, 0($s0) + sw $t0, 0($t1) + addi $s0, 4 + addi $t1, 4 + addi $s1, -1 + b $ciclocopia + $finciclocopia: + lw $s0, 0($sp) + lw $s1, 4($sp) + addi $sp, 8 + jr $ra + + .TypeCheck: + #lw $t0, 0($t0) + InicioChequeo: + lw $t0, 0($t0) + beq $t0, $zero, ChequeoFalse + beq $t0, $t1, ChequeoTrue + b InicioChequeo + ChequeoFalse: + move $v0, $zero + jr $ra + ChequeoTrue: + li $v0, 1 + jr $ra diff --git a/src/TigerandButiCompiler.py b/src/TigerandButiCompiler.py new file mode 100644 index 00000000..70f18fad --- /dev/null +++ b/src/TigerandButiCompiler.py @@ -0,0 +1,818 @@ +import ply.lex as lex +import ply.yacc as yacc +import os +import sys +from AST import * +from Semantic_Checking import * +from ASTtoCIL import * +from CILtoMIPS import * + +LexerError=False +DispatchList = ["main"] +#Welcome='Tiger and Buti Compiler 2020 0.2.0\nCopyright (c) 2019: Jose Gabriel Navarro Comabella, Alberto Helguera Fleitas' + +#print(Welcome) + +tokens=( + 'class', 'else', 'false', 'if','fi', 'in', 'inherits', 'isvoid', 'let', 'loop', 'pool', 'then', 'while', 'case', 'esac', 'new', 'of', 'true', + 'type', 'constant', 'id','string','number', + 'lparen','rparen','assign','point','plus','minus','mult','div','arroba', + 'implica','less','lesse','equal', + 'intnot','not', + 'lbracket','rbracket','pcoma','coma','dpoint', + 'unfinished_string', + 'comment','eofcomment','eofstring' + ) +reserverd=('not','class', 'else', 'false', 'if','fi', 'in', 'inherits', 'isvoid', 'let', 'loop', 'pool', 'then', 'while', 'case', 'esac', 'new', 'of', 'true') + +def find_column(input, token): + line_start=input.rfind('\n',0,token.lexpos) + return (token.lexpos-line_start) +def find_column2(input, token): + line_start=input.rfind('\n',0,token.lexpos(1)) + return (token.lexpos(1)-line_start) + +def elimina_comentarios2(text): + acumulado=0 + respuesta="" + bypass=False + finlinea=False + + for indice in range(len(text)-1): + if finlinea: + if text[indice]=='\n': + finlinea=False + respuesta+='\n' + continue + + if(text[indice]=='-' and text[indice+1]=='-' and acumulado == 0 and not (indice>0 and text[indice-1]=='<')): + finlinea=True + respuesta+=' ' + continue + + if bypass: + bypass=False + respuesta+=' ' + continue + + if text[indice]=='(' and text[indice+1]=='*': + acumulado+=1 + bypass=True + respuesta+=' ' + continue + + if acumulado>0 and text[indice]=='*' and text[indice+1]==')': + acumulado-=1 + bypass=True + respuesta+=' ' + continue + + if acumulado==0 or text[indice]=='\n': + respuesta+=text[indice] + else: + respuesta+=' ' + + if acumulado>0: + respuesta+=' ###EOFCOMMENT###' + elif not bypass: + respuesta+=text[len(text)-1] + + return respuesta + + +def elimina_comentarios(text): + count=0 + faltan=0 + respuesta='' + for i in range(len(text)): + found=text.find('(*', i, i+2) + if(-1!=found): + count+=1 + found=text.find('*)',i, i+2) + if(-1!=found and count>0): + count-=1 + if(count==0): + faltan=2 + if count==0 and faltan==0: + respuesta+=text[i] + else: + faltan-=1 + if text.find('\n',i,i+1)>=0: + respuesta+='\n' + else: + respuesta+=' ' + if count>0: + + # for i in range(max(len(text)-text.rfind('\n')-1,0)): + # respuesta+=' ' + respuesta+='###EOFCOMMENT###' + return respuesta + + +#def t_comment(t): +# r'\(\*(.|\n)*\*\)' +# for a in t.value: +# if a=='\n': +# t.lexer.lineno+=1 +# pass + +def t_eofcomment(t): + r'\#\#\#EOFCOMMENT\#\#\#' + line_start=t.lexer.lexdata.rfind('\n',0,t.lexpos)+1 + columna=t.lexpos-line_start+1 + global LexerError + linea=1 + for i in range(t.lexpos): + if t.lexer.lexdata[i]=='\n': + linea+=1 + outstr="({0}, {1}) - LexicographicError: EOF in comment".format(linea, columna) + print(outstr)#'('+str(t.lexer.lineno)+','+str(columna)+') - LexicographicError: EOF in comment') + LexerError=True + +t_class=r'class' +t_else=r'else' +t_fi=r'fi' +t_if=r'if' +t_in=r'in' +t_inherits=r'inherits' +t_isvoid=r'isvoid' +t_let=r'let' +t_loop=r'loop' +t_pool=r'pool' +t_then=r'then' +t_while=r'while' +t_case=r'case' +t_esac=r'esac' +t_new=r'new' +t_of=r'of' + +t_lparen=r'\(' +t_rparen=r'\)' +t_assign=r'<-' +t_point=r'\.' +t_plus=r'\+' +t_minus=r'-' +t_mult=r'\*' +t_div=r'/' +t_arroba=r'\@' + +t_lbracket=r'{' +t_rbracket=r'}' +t_coma=r',' +t_pcoma=r';' +t_dpoint=r'\:' + +t_implica=r'\=\>' +t_less=r'\<' +t_lesse=r'\<\=' +t_equal=r'\=' + +t_intnot=r'~' +t_not=r'not' + +def t_true(t): + r'true' + t.lexer.ty="Bool" + return t + +def t_false(t): + r'false' + t.lexer.ty="Bool" + return t + +def t_type(t): + r'[A-Z][a-zA-Z_0-9]*' + if t.value.lower() not in reserverd: + t.type='type' + else: + t.type=t.value.lower() + t.value=t.value.lower() + return t + +def t_id(t): + r'[a-z][a-zA-Z_0-9]*' + if t.value.lower() not in reserverd: + t.type='id' + else: + t.type=t.value.lower() + t.value=t.value.lower() + return t + +def t_number(t): + r'[0-9]+' + #t.type='constant' + t.value=int(t.value) + t.lexer.ty = "Int" + return t + +def t_newline(t): + r'(\n)+' + t.lexer.lineno+=len(t.value) + +def t_string(t): + r'"([^"\\\n]|\\\n|\\.)*"' + #r'("(\\"|[^"])*")|(\'(\\\'|[^\'])*\')' + for a in t.value: + if a=='\n': + t.lexer.lineno+=1 + encontrado=t.value.find('\0') + if encontrado>-1: + columna=find_column(t.lexer.lexdata,t) + columna+=encontrado + linea=1 + for i in range(t.lexpos): + if t.lexer.lexdata[i]=='\n': + linea+=1 + outstr="({0}, {1}) - LexicographicError: String contains null character".format(linea, columna) + global LexerError + LexerError=True + print(outstr)#'('+str(t.lexer.lineno)+','+str(columna)+') - LexicographicError: String contains null character') + t.lexer.ty = "String" + return t + + + +def t_eofstring(t): + r'"(\\\s|\\(.)|[^"\n])*$' + pos=find_column(t.lexer.lexdata,t) + columna=pos + todavia=True + linea=1 + for i in range(t.lexpos): + if t.lexer.lexdata[i]=='\n': + linea+=1 + for a in t.value: + pos+=1 + if a=='\n': + t.lexer.lineno+=1 + linea+=1 + pos=1 + columna=pos + + outstr="({0}, {1}) - LexicographicError: EOF in string constant".format(linea, columna) + print(outstr)#'('+str(t.lexer.lineno)+','+str(columna)+') - LexicographicError: EOF string constant') + global LexerError + LexerError=True + return t + +def t_unfinished_string(t): + r'\"(\\\s|\\.|[^"\n])*\n' + pos=find_column(t.lexer.lexdata,t) + columna=pos + todavia=True + linea=t.lexer.lineno + for a in t.value: + pos+=1 + if a=='\n': + t.lexer.lineno+=1 + if todavia: + columna=pos-1 + todavia=False + outstr="({0}, {1}) - LexicographicError: Unterminated string constant".format(linea, columna) + print(outstr)#'('+str(linea)+','+str(columna)+') - LexicographicError: Unterminated string constant') + global LexerError + LexerError=True + return t + +def t_ignored(t): + r'(\s|\f|\t|\v)' + pass + +def t_error(t): + columna=find_column(t.lexer.lexdata, t) + token=t.value[0] + # if token=='\"':f + # print('('+str(t.lexer.lineno)+','+str(columna)+') - LexicographicError: EOF in string constant') + # else: + linea=1 + for i in range(t.lexpos): + if t.lexer.lexdata[i]=='\n': + linea+=1 + outstr="({0}, {1}) - LexicographicError: ERROR \"{2}\"".format(linea, columna,str(token)) + print(outstr)#'('+str(t.lexer.lineno)+','+str(columna)+') - LexicographicError: ERROR "'+ token+'"') + global LexerError + LexerError=True + t.lexer.skip(1) + +#Me falta agregar conteo de lineas + +mylex=lex.lex(debug=False) +#mylex.input(r'class P { f(): Int { 1 + 2 }; };') +#for t in mylex: +# print('el token =>'+str(t)) + +def posicion(p): + linea=1 + for i in range(p.lexpos(1)): + if p.lexer.lexdata[i]=='\n': + linea+=1 + columna=find_column2(p.lexer.lexdata, p) + return (linea,columna) + + +def p_program(p): + '''program : classdec program + | classdec''' + if len(p) == 3: + p[2].classes.insert(0,p[1]) + p[0] = ProgramNode(classes = p[2].classes) + else: + p[0] = ProgramNode(classes = [p[1]]) + (linea,columna) = posicion(p) + p[0].index = columna + p[0].line = linea + pass + +def p_empty(p): + 'empty :' + pass + +def p_classdec(p): + '''classdec : class type lbracket featurelist rbracket pcoma + | class type inherits type lbracket featurelist rbracket pcoma''' + if len(p)== 7: + p[0] = ClassNode(name = p[2], parent = "Object", features = p[4]) + else: + p[0] = ClassNode(name = p[2], parent = p[4], features = p[6]) + (linea,columna) = posicion(p) + p[0].index = columna + p[0].line = linea + pass + +def p_featurelist(p): + '''featurelist : feature featurelist + | empty''' + if len(p) == 3: + p[2].insert(0,p[1]) + p[0] = p[2] + else: + p[0] = [] + pass + +def p_feature(p): + '''feature : attribute pcoma + | methoddef pcoma''' + p[0] = p[1] + pass + +def p_expression(p): + '''expression : constantexp + | identifier + | assignment + | dispatch + | conditional + | loopexp + | blockexp + | letexp + | caseexp + | newexp + | isvoidexp + | aritmetica + | comparison + | parenexpression''' + p[0] = p[1] + pass + +def p_methoddef(p): + '''methoddef : id lparen rparen dpoint type lbracket expression rbracket + | id lparen param paramslistdef rparen dpoint type lbracket expression rbracket''' + if len(p) == 9: + p[0] = MethodNode(name = p[1], parameters = [], return_type = p[5], body = p[7]) + else: + p[4].insert( 0, p[3]) + p[0] = MethodNode(name = p[1], parameters = p[4], return_type = p[7], body = p[9]) + (linea,columna) = posicion(p) + p[0].index = columna + p[0].line = linea + pass + +def p_expressionlist(p): + '''expressionlist : expression pcoma expressionlist + | empty''' + if len(p)==4: + p[3].insert(0,p[1]) + p[0] = p[3] + else: + p[0] = [] + pass + +def p_param(p): + '''param : id dpoint type''' + p[0] = ParameterNode(name = p[1], param_type = p[3]) + (linea,columna) = posicion(p) + p[0].index = columna + p[0].line = linea + pass + +def p_attribute(p): + '''attribute : id dpoint type + | id dpoint type assign expression''' + if len(p)==4: + p[0] = AttributeNode(name = p[1], attr_type = p[3], value = None) + else: + p[0] = AttributeNode(name = p[1], attr_type = p[3], value = p[5]) + (linea,columna) = posicion(p) + p[0].index = columna + p[0].line = linea + pass + +def p_letattributelist(p): + '''letattributelist : coma attribute letattributelist + | empty''' + if len(p)==4: + p[3].insert(0,p[2]) + p[0] = p[3] + else: + p[0] = [] + pass + +def p_paramslistdef(p): + '''paramslistdef : coma param paramslistdef + | empty''' + if len(p)==4: + p[3].insert(0,p[2]) + p[0] = p[3] + else: + p[0] = [] + pass + +def p_dispatch(p): + '''dispatch : id lparen rparen + | id lparen expression expressionparams rparen + | expression point id lparen rparen + | expression point id lparen expression expressionparams rparen + | expression arroba type point id lparen rparen + | expression arroba type point id lparen expression expressionparams rparen''' + if p[3] == ')': + p[0] = DispatchNode(func_id = p[1], parameters = [], left_expr = None) + DispatchList.append(p[1]) + elif p[2] == '(': + p[4].insert(0,p[3]) + p[0] = DispatchNode(func_id = p[1], parameters = p[4], left_expr = None) + DispatchList.append(p[1]) + elif p[5] == ')': + p[0] = DispatchNode(func_id = p[3], parameters = [], left_expr = p[1]) + DispatchList.append(p[3]) + elif p[2] == '.': + p[6].insert(0,p[5]) + p[0] = DispatchNode(func_id = p[3], parameters = p[6], left_expr = p[1]) + DispatchList.append(p[3]) + elif p[7] == ")": + p[0] = StaticDispatchNode(func_id = p[5], parent_id = p[3] ,parameters = [], left_expr = p[1]) + DispatchList.append(p[5]) + else: + p[8].insert(0,p[7]) + p[0] = StaticDispatchNode(func_id = p[5], parent_id = p[3] ,parameters = p[8], left_expr = p[1]) + DispatchList.append(p[5]) + (linea,columna) = posicion(p) + p[0].index = columna + p[0].line = linea + pass + +precedence=( + #('left','expression'), + ('nonassoc','assign'), + ('right','not'), + ('nonassoc','less','lesse','equal'), + ('left','plus','minus'), + ('left','mult','div'), + ('right','isvoid'), + ('right','intnot'), + ('left','arroba'), + ('left','point'), + ) + +def p_expressionparams(p): + '''expressionparams : coma expression expressionparams + | empty''' + if len(p)==4: + p[3].insert(0,p[2]) + p[0] = p[3] + else: + p[0] = [] + pass + +def p_conditional(p): + '''conditional : if expression then expression else expression fi''' + p[0] = ConditionalNode(predicate = p[2], then_body = p[4], else_body = p[6]) + (linea,columna) = posicion(p) + p[0].index = columna + p[0].line = linea + pass + +def p_loopexp(p): + '''loopexp : while expression loop expression pool''' + p[0] = LoopNode(predicate = p[2], body = p[4]) + (linea,columna) = posicion(p) + p[0].index = columna + p[0].line = linea + pass + +def p_blockexp(p): + '''blockexp : lbracket expressionlist rbracket'''#'''blockexp : lbracket expression pcoma expressionlist rbracket''' + p[0] = BlockNode(expressions = p[2]) + (linea,columna) = posicion(p) + p[0].index = columna + p[0].line = linea + pass + +def p_letexp(p): + '''letexp : let attribute letattributelist in expression''' + p[3].insert(0,p[2]) + p[0] = LetNode(declarations = p[3], in_body = p[5]) + (linea,columna) = posicion(p) + p[0].index = columna + p[0].line = linea + pass + +def p_caseexp(p): + '''caseexp : case expression of subcase listcase esac''' + p[5].insert(0,p[4]) + p[0] = CaseNode(expression = p[2], subcases = p[5]) + (linea,columna) = posicion(p) + p[0].index = columna + p[0].line = linea + pass + +def p_listcase(p): + '''listcase : subcase listcase + | empty''' + if len(p)==3: + p[2].insert(0,p[1]) + p[0] = p[2] + else: + p[0] = [] + pass + pass + +def p_subcase(p): + '''subcase : id dpoint type implica expression pcoma''' + p[0] = SubCaseNode(name = p[1], sub_type = p[3], expression = p[5]) + (linea,columna) = posicion(p) + p[0].index = columna + p[0].line = linea + pass + +def p_newexp(p): + '''newexp : new type''' + p[0] = NewNode(new_type = p[2]) + (linea,columna) = posicion(p) + p[0].index = columna + p[0].line = linea + pass + +def p_isvoidexp(p): + '''isvoidexp : isvoid expression''' + p[0] = IsVoidNode(expr = p[2]) + pass + +def p_aritmetica(p): + '''aritmetica : expression plus expression + | expression minus expression + | expression mult expression + | expression div expression + | intnot expression''' + if p[2] == '+': + if isinstance(p[1],IntegerNode) and isinstance(p[3],IntegerNode): + v1 = int(p[1].value) + v2 = int(p[3].value) + res = v1 + v2 + p[0] = IntegerNode(value = str(res)) + else: + p[0] = PlusNode(left = p[1], right = p[3]) + p[0].operator = p[2] + elif p[2] == '-': + if isinstance(p[1],IntegerNode) and isinstance(p[3],IntegerNode): + v1 = int(p[1].value) + v2 = int(p[3].value) + res = v1 - v2 + p[0] = IntegerNode(value = str(res)) + else: + p[0] = MinusNode(left = p[1], right = p[3]) + p[0].operator = p[2] + elif p[2] == '*': + if isinstance(p[1],IntegerNode) and isinstance(p[3],IntegerNode): + v1 = int(p[1].value) + v2 = int(p[3].value) + res = v1 * v2 + p[0] = IntegerNode(value = str(res)) + else: + p[0] = MultNode(left = p[1], right = p[3]) + p[0].operator = p[2] + elif p[2] == '/': + if isinstance(p[1],IntegerNode) and isinstance(p[3],IntegerNode): + v1 = int(p[1].value) + v2 = int(p[3].value) + res = v1 // v2 + p[0] = IntegerNode(value = str(res)) + else: + p[0] = DivNode(left = p[1], right = p[3]) + p[0].operator = p[2] + else: + if isinstance(p[1],IntegerNode): + v1 = int(p[1].value) + res = -1*v1 + p[0] = IntegerNode(value = str(res)) + else: + p[0] = IntComplementNode(right = p[2]) + p[0].operator = p[1] + + (linea,columna) = posicion(p) + p[0].index = columna + p[0].line = linea + pass + +def p_comparison(p): + '''comparison : expression less expression + | expression lesse expression + | expression equal expression + | not expression''' + if p[2] == '<': + if isinstance(p[1],IntegerNode) and isinstance(p[3],IntegerNode): + v1 = int(p[1].value) + v2 = int(p[3].value) + res = v1 < v2 + p[0] = BoolNode(value = lower(str(res))) + else: + p[0] = LesserNode(left = p[1], right = p[3]) + p[0].operator = p[2] + elif p[2] == '<=': + if isinstance(p[1],IntegerNode) and isinstance(p[3],IntegerNode): + v1 = int(p[1].value) + v2 = int(p[3].value) + res = v1 <= v2 + p[0] = BoolNode(value = lower(str(res))) + else: + p[0] = LesserEqualNode(left = p[1], right = p[3]) + p[0].operator = p[2] + elif p[2] == '=': + p[0] = EqualNode(left = p[1], right = p[3]) + p[0].operator = p[2] + else: + p[0] = BoolComplementNode(right = p[2]) + p[0].operator = p[1] + + (linea,columna) = posicion(p) + p[0].index = columna + p[0].line = linea + pass + + pass + +def p_parenexpression(p): + '''parenexpression : lparen expression rparen''' + p[0] = p[2] + # p[0].type=p[2].type Esto lo comente, tiro error + pass + +def p_constantexp(p): + '''constantexp : number + | string + | true + | false''' + if p.lexer.ty == "Int": + p[0] = IntegerNode(value = p[1]) + elif p.lexer.ty == "String": + p[0] = StringNode(value = p[1]) + elif p.lexer.ty == "Bool": + p[0] = BoolNode(value = p[1]) + (linea,columna) = posicion(p) + p[0].index = columna + p[0].line = linea + pass + +def p_identifier(p): + '''identifier : id''' + p[0] = VariableNode(var_id = p[1]) + (linea,columna) = posicion(p) + p[0].index = columna + p[0].line = linea + pass + +def p_assignment(p): + '''assignment : id assign expression''' + p[0] = AssignNode(variable = p[1], expr = p[3]) + (linea,columna) = posicion(p) + p[0].index = columna + p[0].line = linea + pass + +def p_error(p): + if p==None: + print("(0, 0) - SyntacticError: 'ERROR at or near EOF'") + return + linea=1 + for i in range(p.lexpos): + if p.lexer.lexdata[i]=='\n': + linea+=1 + columna=find_column(p.lexer.lexdata, p) + token=p.value + print('('+str(linea)+', '+str(columna)+') - SyntacticError: ERROR at or near "'+ str(token)+'"') + return + +if __name__=='__main__': + nombrearchivo=sys.argv[1] + # nombrearchivo="C:\\codegen\\hairyscary.cl" + # archivoescritura=nombrearchivo[:-3] + # archivoescritura=archivoescritura[archivoescritura.rfind('/'):] + archivo=open(nombrearchivo,encoding='utf-8') + texto=archivo.read() + respuesta=elimina_comentarios2(texto) +# respuesta=elimina_comentarios_fin_de_linea(respuesta) + LexerError=False + mylex.input(respuesta) + for t in mylex: + pass + + parser=yacc.yacc() + if not LexerError: + ast=parser.parse(respuesta,lexer=mylex, tracking=True,debug=False) + else: + exit(1) + if parser.errorok: + semantic=Semantics_Checker() + semanticvalid=semantic.visit(ast,None) + if semanticvalid: + tocil=CILTranspiler(DispatchList) + codigoCIL=tocil.visit(ast, None) + + toMIPS=MIPSCompiler() + instrucciones=toMIPS.visit(codigoCIL, None) + with open(f'{sys.argv[1][:-3]}.mips', 'w') as f: + f.write(instrucciones) + else: + exit(1) + else: + exit(1) + # else: + # exit(1) + + # else: + # exit(1) +# else: +# exit(1) + + +if False: + tests = [(file) for file in os.listdir('tests\\codegen') if file.endswith('.cl')] + errors=[(file) for file in os.listdir('tests\\codegen') if file.endswith('_error.txt')] + for i in range(len(tests)): + LexerError=False + mylex.lineno=0 + te=tests[i] + print(te) + # if(te=="atoi.cl"): + # print("here") + # else: + # continue + archivo=open("tests\\codegen\\"+te,encoding='utf-8') + texto=archivo.read() + respuesta=elimina_comentarios2(texto) + # respuesta=elimina_comentarios_fin_de_linea(respuesta) + mylex.input(respuesta) + for t in mylex: + pass + if not LexerError: + parser=yacc.yacc() + ast = parser.parse(respuesta,lexer=mylex, tracking=True, debug = False) + # for classc in ast.classes: + # for foo in classc.methods: + # print(classc.name+'--'+foo.name) + semantic = Semantics_Checker() + semantic.visit(ast,None) + tocil=CILTranspiler(DispatchList) + programaCIL=tocil.visit(ast,None) + tipos=[] + for tipo in programaCIL.Types: + tipos.append(tipo) + # print("este") + metodos=[] + for met in programaCIL.Methods: + metodos.append(met) + # print("este") + #for metodo in programaCIL.Methods: + # for instruccion in metodo.intrucciones: + # instruccion.instructionPrint() + toMIPS=MIPSCompiler() + resultado=toMIPS.visit(programaCIL, None) + file=open("tests\\codegen\\"+te+".asm",mode="w") + file.write(resultado) + file.flush() + file.close() + + + else: + LexerError=False + # er=errors[i] + # print(er) + # archivoerror=open("tests\\semantic\\"+er,encoding='utf-8') + # print(archivoerror.read()) + +#archivo=open("tests\\parser\\program1.cl",encoding='utf-8') +#texto=archivo.read() +#respuesta=elimina_comentarios(texto) +#respuesta=elimina_comentarios_fin_de_linea(respuesta) +#parser.parse(respuesta,lexer=mylex, debug=True) +#print(parser.parse(r'clas%s P { f(): Int { variab <- 2 ;}; };', debug=True)) + +#return 1 diff --git a/src/coolc.sh b/src/coolc.sh index 3088de4f..cb0d8464 100755 --- a/src/coolc.sh +++ b/src/coolc.sh @@ -1,11 +1,12 @@ -# Incluya aquí las instrucciones necesarias para ejecutar su compilador +# Incluya aqui las instrucciones necesarias para ejecutar su compilador INPUT_FILE=$1 OUTPUT_FILE=${INPUT_FILE:0: -2}mips -# Si su compilador no lo hace ya, aquí puede imprimir la información de contacto -echo "LINEA_CON_NOMBRE_Y_VERSION_DEL_COMPILADOR" # TODO: Recuerde cambiar estas -echo "Copyright (c) 2019: Nombre1, Nombre2, Nombre3" # TODO: líneas a los valores correctos +# Si su compilador no lo hace ya, aqui puede imprimir la informacion de contacto +echo "Tiger and Buti Compiler 2020 V0.2.0" # TODO: Recuerde cambiar estas +echo "Copyright (c) 2020: Jose Gabriel Navarro Comabella, Alberto Helguera Fleitas" # TODO: lineas a los valores correctos # Llamar al compilador -echo "Compiling $INPUT_FILE into $OUTPUT_FILE" + +python TigerandButiCompiler.py $INPUT_FILE diff --git a/src/parser.out b/src/parser.out new file mode 100644 index 00000000..9931e3c6 --- /dev/null +++ b/src/parser.out @@ -0,0 +1,5005 @@ +Created by PLY version 3.11 (http://www.dabeaz.com/ply) + +Unused terminals: + + comment + constant + eofcomment + eofstring + unfinished_string + +Grammar + +Rule 0 S' -> program +Rule 1 program -> classdec program +Rule 2 program -> classdec +Rule 3 empty -> +Rule 4 classdec -> class type lbracket featurelist rbracket pcoma +Rule 5 classdec -> class type inherits type lbracket featurelist rbracket pcoma +Rule 6 featurelist -> feature featurelist +Rule 7 featurelist -> empty +Rule 8 feature -> attribute pcoma +Rule 9 feature -> methoddef pcoma +Rule 10 expression -> constantexp +Rule 11 expression -> identifier +Rule 12 expression -> assignment +Rule 13 expression -> dispatch +Rule 14 expression -> conditional +Rule 15 expression -> loopexp +Rule 16 expression -> blockexp +Rule 17 expression -> letexp +Rule 18 expression -> caseexp +Rule 19 expression -> newexp +Rule 20 expression -> isvoidexp +Rule 21 expression -> aritmetica +Rule 22 expression -> comparison +Rule 23 expression -> parenexpression +Rule 24 methoddef -> id lparen rparen dpoint type lbracket expression rbracket +Rule 25 methoddef -> id lparen param paramslistdef rparen dpoint type lbracket expression rbracket +Rule 26 expressionlist -> expression pcoma expressionlist +Rule 27 expressionlist -> empty +Rule 28 param -> id dpoint type +Rule 29 attribute -> id dpoint type +Rule 30 attribute -> id dpoint type assign expression +Rule 31 letattributelist -> coma attribute letattributelist +Rule 32 letattributelist -> empty +Rule 33 paramslistdef -> coma param paramslistdef +Rule 34 paramslistdef -> empty +Rule 35 dispatch -> id lparen rparen +Rule 36 dispatch -> id lparen expression expressionparams rparen +Rule 37 dispatch -> expression point id lparen rparen +Rule 38 dispatch -> expression point id lparen expression expressionparams rparen +Rule 39 dispatch -> expression arroba type point id lparen rparen +Rule 40 dispatch -> expression arroba type point id lparen expression expressionparams rparen +Rule 41 expressionparams -> coma expression expressionparams +Rule 42 expressionparams -> empty +Rule 43 conditional -> if expression then expression else expression fi +Rule 44 loopexp -> while expression loop expression pool +Rule 45 blockexp -> lbracket expressionlist rbracket +Rule 46 letexp -> let attribute letattributelist in expression +Rule 47 caseexp -> case expression of subcase listcase esac +Rule 48 listcase -> subcase listcase +Rule 49 listcase -> empty +Rule 50 subcase -> id dpoint type implica expression pcoma +Rule 51 newexp -> new type +Rule 52 isvoidexp -> isvoid expression +Rule 53 aritmetica -> expression plus expression +Rule 54 aritmetica -> expression minus expression +Rule 55 aritmetica -> expression mult expression +Rule 56 aritmetica -> expression div expression +Rule 57 aritmetica -> intnot expression +Rule 58 comparison -> expression less expression +Rule 59 comparison -> expression lesse expression +Rule 60 comparison -> expression equal expression +Rule 61 comparison -> not expression +Rule 62 parenexpression -> lparen expression rparen +Rule 63 constantexp -> number +Rule 64 constantexp -> string +Rule 65 constantexp -> true +Rule 66 constantexp -> false +Rule 67 identifier -> id +Rule 68 assignment -> id assign expression + +Terminals, with rules where they appear + +arroba : 39 40 +assign : 30 68 +case : 47 +class : 4 5 +coma : 31 33 41 +comment : +constant : +div : 56 +dpoint : 24 25 28 29 30 50 +else : 43 +eofcomment : +eofstring : +equal : 60 +error : +esac : 47 +false : 66 +fi : 43 +id : 24 25 28 29 30 35 36 37 38 39 40 50 67 68 +if : 43 +implica : 50 +in : 46 +inherits : 5 +intnot : 57 +isvoid : 52 +lbracket : 4 5 24 25 45 +less : 58 +lesse : 59 +let : 46 +loop : 44 +lparen : 24 25 35 36 37 38 39 40 62 +minus : 54 +mult : 55 +new : 51 +not : 61 +number : 63 +of : 47 +pcoma : 4 5 8 9 26 50 +plus : 53 +point : 37 38 39 40 +pool : 44 +rbracket : 4 5 24 25 45 +rparen : 24 25 35 36 37 38 39 40 62 +string : 64 +then : 43 +true : 65 +type : 4 5 5 24 25 28 29 30 39 40 50 51 +unfinished_string : +while : 44 + +Nonterminals, with rules where they appear + +aritmetica : 21 +assignment : 12 +attribute : 8 31 46 +blockexp : 16 +caseexp : 18 +classdec : 1 2 +comparison : 22 +conditional : 14 +constantexp : 10 +dispatch : 13 +empty : 7 27 32 34 42 49 +expression : 24 25 26 30 36 37 38 38 39 40 40 41 43 43 43 44 44 46 47 50 52 53 53 54 54 55 55 56 56 57 58 58 59 59 60 60 61 62 68 +expressionlist : 26 45 +expressionparams : 36 38 40 41 +feature : 6 +featurelist : 4 5 6 +identifier : 11 +isvoidexp : 20 +letattributelist : 31 46 +letexp : 17 +listcase : 47 48 +loopexp : 15 +methoddef : 9 +newexp : 19 +param : 25 33 +paramslistdef : 25 33 +parenexpression : 23 +program : 1 0 +subcase : 47 48 + +Parsing method: LALR + +state 0 + + (0) S' -> . program + (1) program -> . classdec program + (2) program -> . classdec + (4) classdec -> . class type lbracket featurelist rbracket pcoma + (5) classdec -> . class type inherits type lbracket featurelist rbracket pcoma + + class shift and go to state 3 + + program shift and go to state 1 + classdec shift and go to state 2 + +state 1 + + (0) S' -> program . + + + +state 2 + + (1) program -> classdec . program + (2) program -> classdec . + (1) program -> . classdec program + (2) program -> . classdec + (4) classdec -> . class type lbracket featurelist rbracket pcoma + (5) classdec -> . class type inherits type lbracket featurelist rbracket pcoma + + $end reduce using rule 2 (program -> classdec .) + class shift and go to state 3 + + classdec shift and go to state 2 + program shift and go to state 4 + +state 3 + + (4) classdec -> class . type lbracket featurelist rbracket pcoma + (5) classdec -> class . type inherits type lbracket featurelist rbracket pcoma + + type shift and go to state 5 + + +state 4 + + (1) program -> classdec program . + + $end reduce using rule 1 (program -> classdec program .) + + +state 5 + + (4) classdec -> class type . lbracket featurelist rbracket pcoma + (5) classdec -> class type . inherits type lbracket featurelist rbracket pcoma + + lbracket shift and go to state 6 + inherits shift and go to state 7 + + +state 6 + + (4) classdec -> class type lbracket . featurelist rbracket pcoma + (6) featurelist -> . feature featurelist + (7) featurelist -> . empty + (8) feature -> . attribute pcoma + (9) feature -> . methoddef pcoma + (3) empty -> . + (29) attribute -> . id dpoint type + (30) attribute -> . id dpoint type assign expression + (24) methoddef -> . id lparen rparen dpoint type lbracket expression rbracket + (25) methoddef -> . id lparen param paramslistdef rparen dpoint type lbracket expression rbracket + + rbracket reduce using rule 3 (empty -> .) + id shift and go to state 13 + + featurelist shift and go to state 8 + feature shift and go to state 9 + empty shift and go to state 10 + attribute shift and go to state 11 + methoddef shift and go to state 12 + +state 7 + + (5) classdec -> class type inherits . type lbracket featurelist rbracket pcoma + + type shift and go to state 14 + + +state 8 + + (4) classdec -> class type lbracket featurelist . rbracket pcoma + + rbracket shift and go to state 15 + + +state 9 + + (6) featurelist -> feature . featurelist + (6) featurelist -> . feature featurelist + (7) featurelist -> . empty + (8) feature -> . attribute pcoma + (9) feature -> . methoddef pcoma + (3) empty -> . + (29) attribute -> . id dpoint type + (30) attribute -> . id dpoint type assign expression + (24) methoddef -> . id lparen rparen dpoint type lbracket expression rbracket + (25) methoddef -> . id lparen param paramslistdef rparen dpoint type lbracket expression rbracket + + rbracket reduce using rule 3 (empty -> .) + id shift and go to state 13 + + feature shift and go to state 9 + featurelist shift and go to state 16 + empty shift and go to state 10 + attribute shift and go to state 11 + methoddef shift and go to state 12 + +state 10 + + (7) featurelist -> empty . + + rbracket reduce using rule 7 (featurelist -> empty .) + + +state 11 + + (8) feature -> attribute . pcoma + + pcoma shift and go to state 17 + + +state 12 + + (9) feature -> methoddef . pcoma + + pcoma shift and go to state 18 + + +state 13 + + (29) attribute -> id . dpoint type + (30) attribute -> id . dpoint type assign expression + (24) methoddef -> id . lparen rparen dpoint type lbracket expression rbracket + (25) methoddef -> id . lparen param paramslistdef rparen dpoint type lbracket expression rbracket + + dpoint shift and go to state 19 + lparen shift and go to state 20 + + +state 14 + + (5) classdec -> class type inherits type . lbracket featurelist rbracket pcoma + + lbracket shift and go to state 21 + + +state 15 + + (4) classdec -> class type lbracket featurelist rbracket . pcoma + + pcoma shift and go to state 22 + + +state 16 + + (6) featurelist -> feature featurelist . + + rbracket reduce using rule 6 (featurelist -> feature featurelist .) + + +state 17 + + (8) feature -> attribute pcoma . + + id reduce using rule 8 (feature -> attribute pcoma .) + rbracket reduce using rule 8 (feature -> attribute pcoma .) + + +state 18 + + (9) feature -> methoddef pcoma . + + id reduce using rule 9 (feature -> methoddef pcoma .) + rbracket reduce using rule 9 (feature -> methoddef pcoma .) + + +state 19 + + (29) attribute -> id dpoint . type + (30) attribute -> id dpoint . type assign expression + + type shift and go to state 23 + + +state 20 + + (24) methoddef -> id lparen . rparen dpoint type lbracket expression rbracket + (25) methoddef -> id lparen . param paramslistdef rparen dpoint type lbracket expression rbracket + (28) param -> . id dpoint type + + rparen shift and go to state 25 + id shift and go to state 24 + + param shift and go to state 26 + +state 21 + + (5) classdec -> class type inherits type lbracket . featurelist rbracket pcoma + (6) featurelist -> . feature featurelist + (7) featurelist -> . empty + (8) feature -> . attribute pcoma + (9) feature -> . methoddef pcoma + (3) empty -> . + (29) attribute -> . id dpoint type + (30) attribute -> . id dpoint type assign expression + (24) methoddef -> . id lparen rparen dpoint type lbracket expression rbracket + (25) methoddef -> . id lparen param paramslistdef rparen dpoint type lbracket expression rbracket + + rbracket reduce using rule 3 (empty -> .) + id shift and go to state 13 + + featurelist shift and go to state 27 + feature shift and go to state 9 + empty shift and go to state 10 + attribute shift and go to state 11 + methoddef shift and go to state 12 + +state 22 + + (4) classdec -> class type lbracket featurelist rbracket pcoma . + + class reduce using rule 4 (classdec -> class type lbracket featurelist rbracket pcoma .) + $end reduce using rule 4 (classdec -> class type lbracket featurelist rbracket pcoma .) + + +state 23 + + (29) attribute -> id dpoint type . + (30) attribute -> id dpoint type . assign expression + + pcoma reduce using rule 29 (attribute -> id dpoint type .) + coma reduce using rule 29 (attribute -> id dpoint type .) + in reduce using rule 29 (attribute -> id dpoint type .) + assign shift and go to state 28 + + +state 24 + + (28) param -> id . dpoint type + + dpoint shift and go to state 29 + + +state 25 + + (24) methoddef -> id lparen rparen . dpoint type lbracket expression rbracket + + dpoint shift and go to state 30 + + +state 26 + + (25) methoddef -> id lparen param . paramslistdef rparen dpoint type lbracket expression rbracket + (33) paramslistdef -> . coma param paramslistdef + (34) paramslistdef -> . empty + (3) empty -> . + + coma shift and go to state 32 + rparen reduce using rule 3 (empty -> .) + + paramslistdef shift and go to state 31 + empty shift and go to state 33 + +state 27 + + (5) classdec -> class type inherits type lbracket featurelist . rbracket pcoma + + rbracket shift and go to state 34 + + +state 28 + + (30) attribute -> id dpoint type assign . expression + (10) expression -> . constantexp + (11) expression -> . identifier + (12) expression -> . assignment + (13) expression -> . dispatch + (14) expression -> . conditional + (15) expression -> . loopexp + (16) expression -> . blockexp + (17) expression -> . letexp + (18) expression -> . caseexp + (19) expression -> . newexp + (20) expression -> . isvoidexp + (21) expression -> . aritmetica + (22) expression -> . comparison + (23) expression -> . parenexpression + (63) constantexp -> . number + (64) constantexp -> . string + (65) constantexp -> . true + (66) constantexp -> . false + (67) identifier -> . id + (68) assignment -> . id assign expression + (35) dispatch -> . id lparen rparen + (36) dispatch -> . id lparen expression expressionparams rparen + (37) dispatch -> . expression point id lparen rparen + (38) dispatch -> . expression point id lparen expression expressionparams rparen + (39) dispatch -> . expression arroba type point id lparen rparen + (40) dispatch -> . expression arroba type point id lparen expression expressionparams rparen + (43) conditional -> . if expression then expression else expression fi + (44) loopexp -> . while expression loop expression pool + (45) blockexp -> . lbracket expressionlist rbracket + (46) letexp -> . let attribute letattributelist in expression + (47) caseexp -> . case expression of subcase listcase esac + (51) newexp -> . new type + (52) isvoidexp -> . isvoid expression + (53) aritmetica -> . expression plus expression + (54) aritmetica -> . expression minus expression + (55) aritmetica -> . expression mult expression + (56) aritmetica -> . expression div expression + (57) aritmetica -> . intnot expression + (58) comparison -> . expression less expression + (59) comparison -> . expression lesse expression + (60) comparison -> . expression equal expression + (61) comparison -> . not expression + (62) parenexpression -> . lparen expression rparen + + number shift and go to state 51 + string shift and go to state 52 + true shift and go to state 53 + false shift and go to state 54 + id shift and go to state 35 + if shift and go to state 56 + while shift and go to state 57 + lbracket shift and go to state 58 + let shift and go to state 59 + case shift and go to state 60 + new shift and go to state 61 + isvoid shift and go to state 62 + intnot shift and go to state 63 + not shift and go to state 64 + lparen shift and go to state 55 + + expression shift and go to state 36 + constantexp shift and go to state 37 + identifier shift and go to state 38 + assignment shift and go to state 39 + dispatch shift and go to state 40 + conditional shift and go to state 41 + loopexp shift and go to state 42 + blockexp shift and go to state 43 + letexp shift and go to state 44 + caseexp shift and go to state 45 + newexp shift and go to state 46 + isvoidexp shift and go to state 47 + aritmetica shift and go to state 48 + comparison shift and go to state 49 + parenexpression shift and go to state 50 + +state 29 + + (28) param -> id dpoint . type + + type shift and go to state 65 + + +state 30 + + (24) methoddef -> id lparen rparen dpoint . type lbracket expression rbracket + + type shift and go to state 66 + + +state 31 + + (25) methoddef -> id lparen param paramslistdef . rparen dpoint type lbracket expression rbracket + + rparen shift and go to state 67 + + +state 32 + + (33) paramslistdef -> coma . param paramslistdef + (28) param -> . id dpoint type + + id shift and go to state 24 + + param shift and go to state 68 + +state 33 + + (34) paramslistdef -> empty . + + rparen reduce using rule 34 (paramslistdef -> empty .) + + +state 34 + + (5) classdec -> class type inherits type lbracket featurelist rbracket . pcoma + + pcoma shift and go to state 69 + + +state 35 + + (67) identifier -> id . + (68) assignment -> id . assign expression + (35) dispatch -> id . lparen rparen + (36) dispatch -> id . lparen expression expressionparams rparen + + point reduce using rule 67 (identifier -> id .) + arroba reduce using rule 67 (identifier -> id .) + plus reduce using rule 67 (identifier -> id .) + minus reduce using rule 67 (identifier -> id .) + mult reduce using rule 67 (identifier -> id .) + div reduce using rule 67 (identifier -> id .) + less reduce using rule 67 (identifier -> id .) + lesse reduce using rule 67 (identifier -> id .) + equal reduce using rule 67 (identifier -> id .) + pcoma reduce using rule 67 (identifier -> id .) + coma reduce using rule 67 (identifier -> id .) + in reduce using rule 67 (identifier -> id .) + rparen reduce using rule 67 (identifier -> id .) + then reduce using rule 67 (identifier -> id .) + loop reduce using rule 67 (identifier -> id .) + of reduce using rule 67 (identifier -> id .) + rbracket reduce using rule 67 (identifier -> id .) + else reduce using rule 67 (identifier -> id .) + pool reduce using rule 67 (identifier -> id .) + fi reduce using rule 67 (identifier -> id .) + assign shift and go to state 70 + lparen shift and go to state 71 + + +state 36 + + (30) attribute -> id dpoint type assign expression . + (37) dispatch -> expression . point id lparen rparen + (38) dispatch -> expression . point id lparen expression expressionparams rparen + (39) dispatch -> expression . arroba type point id lparen rparen + (40) dispatch -> expression . arroba type point id lparen expression expressionparams rparen + (53) aritmetica -> expression . plus expression + (54) aritmetica -> expression . minus expression + (55) aritmetica -> expression . mult expression + (56) aritmetica -> expression . div expression + (58) comparison -> expression . less expression + (59) comparison -> expression . lesse expression + (60) comparison -> expression . equal expression + + pcoma reduce using rule 30 (attribute -> id dpoint type assign expression .) + coma reduce using rule 30 (attribute -> id dpoint type assign expression .) + in reduce using rule 30 (attribute -> id dpoint type assign expression .) + point shift and go to state 72 + arroba shift and go to state 73 + plus shift and go to state 74 + minus shift and go to state 75 + mult shift and go to state 76 + div shift and go to state 77 + less shift and go to state 78 + lesse shift and go to state 79 + equal shift and go to state 80 + + +state 37 + + (10) expression -> constantexp . + + point reduce using rule 10 (expression -> constantexp .) + arroba reduce using rule 10 (expression -> constantexp .) + plus reduce using rule 10 (expression -> constantexp .) + minus reduce using rule 10 (expression -> constantexp .) + mult reduce using rule 10 (expression -> constantexp .) + div reduce using rule 10 (expression -> constantexp .) + less reduce using rule 10 (expression -> constantexp .) + lesse reduce using rule 10 (expression -> constantexp .) + equal reduce using rule 10 (expression -> constantexp .) + pcoma reduce using rule 10 (expression -> constantexp .) + coma reduce using rule 10 (expression -> constantexp .) + in reduce using rule 10 (expression -> constantexp .) + rparen reduce using rule 10 (expression -> constantexp .) + then reduce using rule 10 (expression -> constantexp .) + loop reduce using rule 10 (expression -> constantexp .) + of reduce using rule 10 (expression -> constantexp .) + rbracket reduce using rule 10 (expression -> constantexp .) + else reduce using rule 10 (expression -> constantexp .) + pool reduce using rule 10 (expression -> constantexp .) + fi reduce using rule 10 (expression -> constantexp .) + + +state 38 + + (11) expression -> identifier . + + point reduce using rule 11 (expression -> identifier .) + arroba reduce using rule 11 (expression -> identifier .) + plus reduce using rule 11 (expression -> identifier .) + minus reduce using rule 11 (expression -> identifier .) + mult reduce using rule 11 (expression -> identifier .) + div reduce using rule 11 (expression -> identifier .) + less reduce using rule 11 (expression -> identifier .) + lesse reduce using rule 11 (expression -> identifier .) + equal reduce using rule 11 (expression -> identifier .) + pcoma reduce using rule 11 (expression -> identifier .) + coma reduce using rule 11 (expression -> identifier .) + in reduce using rule 11 (expression -> identifier .) + rparen reduce using rule 11 (expression -> identifier .) + then reduce using rule 11 (expression -> identifier .) + loop reduce using rule 11 (expression -> identifier .) + of reduce using rule 11 (expression -> identifier .) + rbracket reduce using rule 11 (expression -> identifier .) + else reduce using rule 11 (expression -> identifier .) + pool reduce using rule 11 (expression -> identifier .) + fi reduce using rule 11 (expression -> identifier .) + + +state 39 + + (12) expression -> assignment . + + point reduce using rule 12 (expression -> assignment .) + arroba reduce using rule 12 (expression -> assignment .) + plus reduce using rule 12 (expression -> assignment .) + minus reduce using rule 12 (expression -> assignment .) + mult reduce using rule 12 (expression -> assignment .) + div reduce using rule 12 (expression -> assignment .) + less reduce using rule 12 (expression -> assignment .) + lesse reduce using rule 12 (expression -> assignment .) + equal reduce using rule 12 (expression -> assignment .) + pcoma reduce using rule 12 (expression -> assignment .) + coma reduce using rule 12 (expression -> assignment .) + in reduce using rule 12 (expression -> assignment .) + rparen reduce using rule 12 (expression -> assignment .) + then reduce using rule 12 (expression -> assignment .) + loop reduce using rule 12 (expression -> assignment .) + of reduce using rule 12 (expression -> assignment .) + rbracket reduce using rule 12 (expression -> assignment .) + else reduce using rule 12 (expression -> assignment .) + pool reduce using rule 12 (expression -> assignment .) + fi reduce using rule 12 (expression -> assignment .) + + +state 40 + + (13) expression -> dispatch . + + point reduce using rule 13 (expression -> dispatch .) + arroba reduce using rule 13 (expression -> dispatch .) + plus reduce using rule 13 (expression -> dispatch .) + minus reduce using rule 13 (expression -> dispatch .) + mult reduce using rule 13 (expression -> dispatch .) + div reduce using rule 13 (expression -> dispatch .) + less reduce using rule 13 (expression -> dispatch .) + lesse reduce using rule 13 (expression -> dispatch .) + equal reduce using rule 13 (expression -> dispatch .) + pcoma reduce using rule 13 (expression -> dispatch .) + coma reduce using rule 13 (expression -> dispatch .) + in reduce using rule 13 (expression -> dispatch .) + rparen reduce using rule 13 (expression -> dispatch .) + then reduce using rule 13 (expression -> dispatch .) + loop reduce using rule 13 (expression -> dispatch .) + of reduce using rule 13 (expression -> dispatch .) + rbracket reduce using rule 13 (expression -> dispatch .) + else reduce using rule 13 (expression -> dispatch .) + pool reduce using rule 13 (expression -> dispatch .) + fi reduce using rule 13 (expression -> dispatch .) + + +state 41 + + (14) expression -> conditional . + + point reduce using rule 14 (expression -> conditional .) + arroba reduce using rule 14 (expression -> conditional .) + plus reduce using rule 14 (expression -> conditional .) + minus reduce using rule 14 (expression -> conditional .) + mult reduce using rule 14 (expression -> conditional .) + div reduce using rule 14 (expression -> conditional .) + less reduce using rule 14 (expression -> conditional .) + lesse reduce using rule 14 (expression -> conditional .) + equal reduce using rule 14 (expression -> conditional .) + pcoma reduce using rule 14 (expression -> conditional .) + coma reduce using rule 14 (expression -> conditional .) + in reduce using rule 14 (expression -> conditional .) + rparen reduce using rule 14 (expression -> conditional .) + then reduce using rule 14 (expression -> conditional .) + loop reduce using rule 14 (expression -> conditional .) + of reduce using rule 14 (expression -> conditional .) + rbracket reduce using rule 14 (expression -> conditional .) + else reduce using rule 14 (expression -> conditional .) + pool reduce using rule 14 (expression -> conditional .) + fi reduce using rule 14 (expression -> conditional .) + + +state 42 + + (15) expression -> loopexp . + + point reduce using rule 15 (expression -> loopexp .) + arroba reduce using rule 15 (expression -> loopexp .) + plus reduce using rule 15 (expression -> loopexp .) + minus reduce using rule 15 (expression -> loopexp .) + mult reduce using rule 15 (expression -> loopexp .) + div reduce using rule 15 (expression -> loopexp .) + less reduce using rule 15 (expression -> loopexp .) + lesse reduce using rule 15 (expression -> loopexp .) + equal reduce using rule 15 (expression -> loopexp .) + pcoma reduce using rule 15 (expression -> loopexp .) + coma reduce using rule 15 (expression -> loopexp .) + in reduce using rule 15 (expression -> loopexp .) + rparen reduce using rule 15 (expression -> loopexp .) + then reduce using rule 15 (expression -> loopexp .) + loop reduce using rule 15 (expression -> loopexp .) + of reduce using rule 15 (expression -> loopexp .) + rbracket reduce using rule 15 (expression -> loopexp .) + else reduce using rule 15 (expression -> loopexp .) + pool reduce using rule 15 (expression -> loopexp .) + fi reduce using rule 15 (expression -> loopexp .) + + +state 43 + + (16) expression -> blockexp . + + point reduce using rule 16 (expression -> blockexp .) + arroba reduce using rule 16 (expression -> blockexp .) + plus reduce using rule 16 (expression -> blockexp .) + minus reduce using rule 16 (expression -> blockexp .) + mult reduce using rule 16 (expression -> blockexp .) + div reduce using rule 16 (expression -> blockexp .) + less reduce using rule 16 (expression -> blockexp .) + lesse reduce using rule 16 (expression -> blockexp .) + equal reduce using rule 16 (expression -> blockexp .) + pcoma reduce using rule 16 (expression -> blockexp .) + coma reduce using rule 16 (expression -> blockexp .) + in reduce using rule 16 (expression -> blockexp .) + rparen reduce using rule 16 (expression -> blockexp .) + then reduce using rule 16 (expression -> blockexp .) + loop reduce using rule 16 (expression -> blockexp .) + of reduce using rule 16 (expression -> blockexp .) + rbracket reduce using rule 16 (expression -> blockexp .) + else reduce using rule 16 (expression -> blockexp .) + pool reduce using rule 16 (expression -> blockexp .) + fi reduce using rule 16 (expression -> blockexp .) + + +state 44 + + (17) expression -> letexp . + + point reduce using rule 17 (expression -> letexp .) + arroba reduce using rule 17 (expression -> letexp .) + plus reduce using rule 17 (expression -> letexp .) + minus reduce using rule 17 (expression -> letexp .) + mult reduce using rule 17 (expression -> letexp .) + div reduce using rule 17 (expression -> letexp .) + less reduce using rule 17 (expression -> letexp .) + lesse reduce using rule 17 (expression -> letexp .) + equal reduce using rule 17 (expression -> letexp .) + pcoma reduce using rule 17 (expression -> letexp .) + coma reduce using rule 17 (expression -> letexp .) + in reduce using rule 17 (expression -> letexp .) + rparen reduce using rule 17 (expression -> letexp .) + then reduce using rule 17 (expression -> letexp .) + loop reduce using rule 17 (expression -> letexp .) + of reduce using rule 17 (expression -> letexp .) + rbracket reduce using rule 17 (expression -> letexp .) + else reduce using rule 17 (expression -> letexp .) + pool reduce using rule 17 (expression -> letexp .) + fi reduce using rule 17 (expression -> letexp .) + + +state 45 + + (18) expression -> caseexp . + + point reduce using rule 18 (expression -> caseexp .) + arroba reduce using rule 18 (expression -> caseexp .) + plus reduce using rule 18 (expression -> caseexp .) + minus reduce using rule 18 (expression -> caseexp .) + mult reduce using rule 18 (expression -> caseexp .) + div reduce using rule 18 (expression -> caseexp .) + less reduce using rule 18 (expression -> caseexp .) + lesse reduce using rule 18 (expression -> caseexp .) + equal reduce using rule 18 (expression -> caseexp .) + pcoma reduce using rule 18 (expression -> caseexp .) + coma reduce using rule 18 (expression -> caseexp .) + in reduce using rule 18 (expression -> caseexp .) + rparen reduce using rule 18 (expression -> caseexp .) + then reduce using rule 18 (expression -> caseexp .) + loop reduce using rule 18 (expression -> caseexp .) + of reduce using rule 18 (expression -> caseexp .) + rbracket reduce using rule 18 (expression -> caseexp .) + else reduce using rule 18 (expression -> caseexp .) + pool reduce using rule 18 (expression -> caseexp .) + fi reduce using rule 18 (expression -> caseexp .) + + +state 46 + + (19) expression -> newexp . + + point reduce using rule 19 (expression -> newexp .) + arroba reduce using rule 19 (expression -> newexp .) + plus reduce using rule 19 (expression -> newexp .) + minus reduce using rule 19 (expression -> newexp .) + mult reduce using rule 19 (expression -> newexp .) + div reduce using rule 19 (expression -> newexp .) + less reduce using rule 19 (expression -> newexp .) + lesse reduce using rule 19 (expression -> newexp .) + equal reduce using rule 19 (expression -> newexp .) + pcoma reduce using rule 19 (expression -> newexp .) + coma reduce using rule 19 (expression -> newexp .) + in reduce using rule 19 (expression -> newexp .) + rparen reduce using rule 19 (expression -> newexp .) + then reduce using rule 19 (expression -> newexp .) + loop reduce using rule 19 (expression -> newexp .) + of reduce using rule 19 (expression -> newexp .) + rbracket reduce using rule 19 (expression -> newexp .) + else reduce using rule 19 (expression -> newexp .) + pool reduce using rule 19 (expression -> newexp .) + fi reduce using rule 19 (expression -> newexp .) + + +state 47 + + (20) expression -> isvoidexp . + + point reduce using rule 20 (expression -> isvoidexp .) + arroba reduce using rule 20 (expression -> isvoidexp .) + plus reduce using rule 20 (expression -> isvoidexp .) + minus reduce using rule 20 (expression -> isvoidexp .) + mult reduce using rule 20 (expression -> isvoidexp .) + div reduce using rule 20 (expression -> isvoidexp .) + less reduce using rule 20 (expression -> isvoidexp .) + lesse reduce using rule 20 (expression -> isvoidexp .) + equal reduce using rule 20 (expression -> isvoidexp .) + pcoma reduce using rule 20 (expression -> isvoidexp .) + coma reduce using rule 20 (expression -> isvoidexp .) + in reduce using rule 20 (expression -> isvoidexp .) + rparen reduce using rule 20 (expression -> isvoidexp .) + then reduce using rule 20 (expression -> isvoidexp .) + loop reduce using rule 20 (expression -> isvoidexp .) + of reduce using rule 20 (expression -> isvoidexp .) + rbracket reduce using rule 20 (expression -> isvoidexp .) + else reduce using rule 20 (expression -> isvoidexp .) + pool reduce using rule 20 (expression -> isvoidexp .) + fi reduce using rule 20 (expression -> isvoidexp .) + + +state 48 + + (21) expression -> aritmetica . + + point reduce using rule 21 (expression -> aritmetica .) + arroba reduce using rule 21 (expression -> aritmetica .) + plus reduce using rule 21 (expression -> aritmetica .) + minus reduce using rule 21 (expression -> aritmetica .) + mult reduce using rule 21 (expression -> aritmetica .) + div reduce using rule 21 (expression -> aritmetica .) + less reduce using rule 21 (expression -> aritmetica .) + lesse reduce using rule 21 (expression -> aritmetica .) + equal reduce using rule 21 (expression -> aritmetica .) + pcoma reduce using rule 21 (expression -> aritmetica .) + coma reduce using rule 21 (expression -> aritmetica .) + in reduce using rule 21 (expression -> aritmetica .) + rparen reduce using rule 21 (expression -> aritmetica .) + then reduce using rule 21 (expression -> aritmetica .) + loop reduce using rule 21 (expression -> aritmetica .) + of reduce using rule 21 (expression -> aritmetica .) + rbracket reduce using rule 21 (expression -> aritmetica .) + else reduce using rule 21 (expression -> aritmetica .) + pool reduce using rule 21 (expression -> aritmetica .) + fi reduce using rule 21 (expression -> aritmetica .) + + +state 49 + + (22) expression -> comparison . + + point reduce using rule 22 (expression -> comparison .) + arroba reduce using rule 22 (expression -> comparison .) + plus reduce using rule 22 (expression -> comparison .) + minus reduce using rule 22 (expression -> comparison .) + mult reduce using rule 22 (expression -> comparison .) + div reduce using rule 22 (expression -> comparison .) + less reduce using rule 22 (expression -> comparison .) + lesse reduce using rule 22 (expression -> comparison .) + equal reduce using rule 22 (expression -> comparison .) + pcoma reduce using rule 22 (expression -> comparison .) + coma reduce using rule 22 (expression -> comparison .) + in reduce using rule 22 (expression -> comparison .) + rparen reduce using rule 22 (expression -> comparison .) + then reduce using rule 22 (expression -> comparison .) + loop reduce using rule 22 (expression -> comparison .) + of reduce using rule 22 (expression -> comparison .) + rbracket reduce using rule 22 (expression -> comparison .) + else reduce using rule 22 (expression -> comparison .) + pool reduce using rule 22 (expression -> comparison .) + fi reduce using rule 22 (expression -> comparison .) + + +state 50 + + (23) expression -> parenexpression . + + point reduce using rule 23 (expression -> parenexpression .) + arroba reduce using rule 23 (expression -> parenexpression .) + plus reduce using rule 23 (expression -> parenexpression .) + minus reduce using rule 23 (expression -> parenexpression .) + mult reduce using rule 23 (expression -> parenexpression .) + div reduce using rule 23 (expression -> parenexpression .) + less reduce using rule 23 (expression -> parenexpression .) + lesse reduce using rule 23 (expression -> parenexpression .) + equal reduce using rule 23 (expression -> parenexpression .) + pcoma reduce using rule 23 (expression -> parenexpression .) + coma reduce using rule 23 (expression -> parenexpression .) + in reduce using rule 23 (expression -> parenexpression .) + rparen reduce using rule 23 (expression -> parenexpression .) + then reduce using rule 23 (expression -> parenexpression .) + loop reduce using rule 23 (expression -> parenexpression .) + of reduce using rule 23 (expression -> parenexpression .) + rbracket reduce using rule 23 (expression -> parenexpression .) + else reduce using rule 23 (expression -> parenexpression .) + pool reduce using rule 23 (expression -> parenexpression .) + fi reduce using rule 23 (expression -> parenexpression .) + + +state 51 + + (63) constantexp -> number . + + point reduce using rule 63 (constantexp -> number .) + arroba reduce using rule 63 (constantexp -> number .) + plus reduce using rule 63 (constantexp -> number .) + minus reduce using rule 63 (constantexp -> number .) + mult reduce using rule 63 (constantexp -> number .) + div reduce using rule 63 (constantexp -> number .) + less reduce using rule 63 (constantexp -> number .) + lesse reduce using rule 63 (constantexp -> number .) + equal reduce using rule 63 (constantexp -> number .) + pcoma reduce using rule 63 (constantexp -> number .) + coma reduce using rule 63 (constantexp -> number .) + in reduce using rule 63 (constantexp -> number .) + rparen reduce using rule 63 (constantexp -> number .) + then reduce using rule 63 (constantexp -> number .) + loop reduce using rule 63 (constantexp -> number .) + of reduce using rule 63 (constantexp -> number .) + rbracket reduce using rule 63 (constantexp -> number .) + else reduce using rule 63 (constantexp -> number .) + pool reduce using rule 63 (constantexp -> number .) + fi reduce using rule 63 (constantexp -> number .) + + +state 52 + + (64) constantexp -> string . + + point reduce using rule 64 (constantexp -> string .) + arroba reduce using rule 64 (constantexp -> string .) + plus reduce using rule 64 (constantexp -> string .) + minus reduce using rule 64 (constantexp -> string .) + mult reduce using rule 64 (constantexp -> string .) + div reduce using rule 64 (constantexp -> string .) + less reduce using rule 64 (constantexp -> string .) + lesse reduce using rule 64 (constantexp -> string .) + equal reduce using rule 64 (constantexp -> string .) + pcoma reduce using rule 64 (constantexp -> string .) + coma reduce using rule 64 (constantexp -> string .) + in reduce using rule 64 (constantexp -> string .) + rparen reduce using rule 64 (constantexp -> string .) + then reduce using rule 64 (constantexp -> string .) + loop reduce using rule 64 (constantexp -> string .) + of reduce using rule 64 (constantexp -> string .) + rbracket reduce using rule 64 (constantexp -> string .) + else reduce using rule 64 (constantexp -> string .) + pool reduce using rule 64 (constantexp -> string .) + fi reduce using rule 64 (constantexp -> string .) + + +state 53 + + (65) constantexp -> true . + + point reduce using rule 65 (constantexp -> true .) + arroba reduce using rule 65 (constantexp -> true .) + plus reduce using rule 65 (constantexp -> true .) + minus reduce using rule 65 (constantexp -> true .) + mult reduce using rule 65 (constantexp -> true .) + div reduce using rule 65 (constantexp -> true .) + less reduce using rule 65 (constantexp -> true .) + lesse reduce using rule 65 (constantexp -> true .) + equal reduce using rule 65 (constantexp -> true .) + pcoma reduce using rule 65 (constantexp -> true .) + coma reduce using rule 65 (constantexp -> true .) + in reduce using rule 65 (constantexp -> true .) + rparen reduce using rule 65 (constantexp -> true .) + then reduce using rule 65 (constantexp -> true .) + loop reduce using rule 65 (constantexp -> true .) + of reduce using rule 65 (constantexp -> true .) + rbracket reduce using rule 65 (constantexp -> true .) + else reduce using rule 65 (constantexp -> true .) + pool reduce using rule 65 (constantexp -> true .) + fi reduce using rule 65 (constantexp -> true .) + + +state 54 + + (66) constantexp -> false . + + point reduce using rule 66 (constantexp -> false .) + arroba reduce using rule 66 (constantexp -> false .) + plus reduce using rule 66 (constantexp -> false .) + minus reduce using rule 66 (constantexp -> false .) + mult reduce using rule 66 (constantexp -> false .) + div reduce using rule 66 (constantexp -> false .) + less reduce using rule 66 (constantexp -> false .) + lesse reduce using rule 66 (constantexp -> false .) + equal reduce using rule 66 (constantexp -> false .) + pcoma reduce using rule 66 (constantexp -> false .) + coma reduce using rule 66 (constantexp -> false .) + in reduce using rule 66 (constantexp -> false .) + rparen reduce using rule 66 (constantexp -> false .) + then reduce using rule 66 (constantexp -> false .) + loop reduce using rule 66 (constantexp -> false .) + of reduce using rule 66 (constantexp -> false .) + rbracket reduce using rule 66 (constantexp -> false .) + else reduce using rule 66 (constantexp -> false .) + pool reduce using rule 66 (constantexp -> false .) + fi reduce using rule 66 (constantexp -> false .) + + +state 55 + + (62) parenexpression -> lparen . expression rparen + (10) expression -> . constantexp + (11) expression -> . identifier + (12) expression -> . assignment + (13) expression -> . dispatch + (14) expression -> . conditional + (15) expression -> . loopexp + (16) expression -> . blockexp + (17) expression -> . letexp + (18) expression -> . caseexp + (19) expression -> . newexp + (20) expression -> . isvoidexp + (21) expression -> . aritmetica + (22) expression -> . comparison + (23) expression -> . parenexpression + (63) constantexp -> . number + (64) constantexp -> . string + (65) constantexp -> . true + (66) constantexp -> . false + (67) identifier -> . id + (68) assignment -> . id assign expression + (35) dispatch -> . id lparen rparen + (36) dispatch -> . id lparen expression expressionparams rparen + (37) dispatch -> . expression point id lparen rparen + (38) dispatch -> . expression point id lparen expression expressionparams rparen + (39) dispatch -> . expression arroba type point id lparen rparen + (40) dispatch -> . expression arroba type point id lparen expression expressionparams rparen + (43) conditional -> . if expression then expression else expression fi + (44) loopexp -> . while expression loop expression pool + (45) blockexp -> . lbracket expressionlist rbracket + (46) letexp -> . let attribute letattributelist in expression + (47) caseexp -> . case expression of subcase listcase esac + (51) newexp -> . new type + (52) isvoidexp -> . isvoid expression + (53) aritmetica -> . expression plus expression + (54) aritmetica -> . expression minus expression + (55) aritmetica -> . expression mult expression + (56) aritmetica -> . expression div expression + (57) aritmetica -> . intnot expression + (58) comparison -> . expression less expression + (59) comparison -> . expression lesse expression + (60) comparison -> . expression equal expression + (61) comparison -> . not expression + (62) parenexpression -> . lparen expression rparen + + number shift and go to state 51 + string shift and go to state 52 + true shift and go to state 53 + false shift and go to state 54 + id shift and go to state 35 + if shift and go to state 56 + while shift and go to state 57 + lbracket shift and go to state 58 + let shift and go to state 59 + case shift and go to state 60 + new shift and go to state 61 + isvoid shift and go to state 62 + intnot shift and go to state 63 + not shift and go to state 64 + lparen shift and go to state 55 + + expression shift and go to state 81 + constantexp shift and go to state 37 + identifier shift and go to state 38 + assignment shift and go to state 39 + dispatch shift and go to state 40 + conditional shift and go to state 41 + loopexp shift and go to state 42 + blockexp shift and go to state 43 + letexp shift and go to state 44 + caseexp shift and go to state 45 + newexp shift and go to state 46 + isvoidexp shift and go to state 47 + aritmetica shift and go to state 48 + comparison shift and go to state 49 + parenexpression shift and go to state 50 + +state 56 + + (43) conditional -> if . expression then expression else expression fi + (10) expression -> . constantexp + (11) expression -> . identifier + (12) expression -> . assignment + (13) expression -> . dispatch + (14) expression -> . conditional + (15) expression -> . loopexp + (16) expression -> . blockexp + (17) expression -> . letexp + (18) expression -> . caseexp + (19) expression -> . newexp + (20) expression -> . isvoidexp + (21) expression -> . aritmetica + (22) expression -> . comparison + (23) expression -> . parenexpression + (63) constantexp -> . number + (64) constantexp -> . string + (65) constantexp -> . true + (66) constantexp -> . false + (67) identifier -> . id + (68) assignment -> . id assign expression + (35) dispatch -> . id lparen rparen + (36) dispatch -> . id lparen expression expressionparams rparen + (37) dispatch -> . expression point id lparen rparen + (38) dispatch -> . expression point id lparen expression expressionparams rparen + (39) dispatch -> . expression arroba type point id lparen rparen + (40) dispatch -> . expression arroba type point id lparen expression expressionparams rparen + (43) conditional -> . if expression then expression else expression fi + (44) loopexp -> . while expression loop expression pool + (45) blockexp -> . lbracket expressionlist rbracket + (46) letexp -> . let attribute letattributelist in expression + (47) caseexp -> . case expression of subcase listcase esac + (51) newexp -> . new type + (52) isvoidexp -> . isvoid expression + (53) aritmetica -> . expression plus expression + (54) aritmetica -> . expression minus expression + (55) aritmetica -> . expression mult expression + (56) aritmetica -> . expression div expression + (57) aritmetica -> . intnot expression + (58) comparison -> . expression less expression + (59) comparison -> . expression lesse expression + (60) comparison -> . expression equal expression + (61) comparison -> . not expression + (62) parenexpression -> . lparen expression rparen + + number shift and go to state 51 + string shift and go to state 52 + true shift and go to state 53 + false shift and go to state 54 + id shift and go to state 35 + if shift and go to state 56 + while shift and go to state 57 + lbracket shift and go to state 58 + let shift and go to state 59 + case shift and go to state 60 + new shift and go to state 61 + isvoid shift and go to state 62 + intnot shift and go to state 63 + not shift and go to state 64 + lparen shift and go to state 55 + + expression shift and go to state 82 + constantexp shift and go to state 37 + identifier shift and go to state 38 + assignment shift and go to state 39 + dispatch shift and go to state 40 + conditional shift and go to state 41 + loopexp shift and go to state 42 + blockexp shift and go to state 43 + letexp shift and go to state 44 + caseexp shift and go to state 45 + newexp shift and go to state 46 + isvoidexp shift and go to state 47 + aritmetica shift and go to state 48 + comparison shift and go to state 49 + parenexpression shift and go to state 50 + +state 57 + + (44) loopexp -> while . expression loop expression pool + (10) expression -> . constantexp + (11) expression -> . identifier + (12) expression -> . assignment + (13) expression -> . dispatch + (14) expression -> . conditional + (15) expression -> . loopexp + (16) expression -> . blockexp + (17) expression -> . letexp + (18) expression -> . caseexp + (19) expression -> . newexp + (20) expression -> . isvoidexp + (21) expression -> . aritmetica + (22) expression -> . comparison + (23) expression -> . parenexpression + (63) constantexp -> . number + (64) constantexp -> . string + (65) constantexp -> . true + (66) constantexp -> . false + (67) identifier -> . id + (68) assignment -> . id assign expression + (35) dispatch -> . id lparen rparen + (36) dispatch -> . id lparen expression expressionparams rparen + (37) dispatch -> . expression point id lparen rparen + (38) dispatch -> . expression point id lparen expression expressionparams rparen + (39) dispatch -> . expression arroba type point id lparen rparen + (40) dispatch -> . expression arroba type point id lparen expression expressionparams rparen + (43) conditional -> . if expression then expression else expression fi + (44) loopexp -> . while expression loop expression pool + (45) blockexp -> . lbracket expressionlist rbracket + (46) letexp -> . let attribute letattributelist in expression + (47) caseexp -> . case expression of subcase listcase esac + (51) newexp -> . new type + (52) isvoidexp -> . isvoid expression + (53) aritmetica -> . expression plus expression + (54) aritmetica -> . expression minus expression + (55) aritmetica -> . expression mult expression + (56) aritmetica -> . expression div expression + (57) aritmetica -> . intnot expression + (58) comparison -> . expression less expression + (59) comparison -> . expression lesse expression + (60) comparison -> . expression equal expression + (61) comparison -> . not expression + (62) parenexpression -> . lparen expression rparen + + number shift and go to state 51 + string shift and go to state 52 + true shift and go to state 53 + false shift and go to state 54 + id shift and go to state 35 + if shift and go to state 56 + while shift and go to state 57 + lbracket shift and go to state 58 + let shift and go to state 59 + case shift and go to state 60 + new shift and go to state 61 + isvoid shift and go to state 62 + intnot shift and go to state 63 + not shift and go to state 64 + lparen shift and go to state 55 + + expression shift and go to state 83 + constantexp shift and go to state 37 + identifier shift and go to state 38 + assignment shift and go to state 39 + dispatch shift and go to state 40 + conditional shift and go to state 41 + loopexp shift and go to state 42 + blockexp shift and go to state 43 + letexp shift and go to state 44 + caseexp shift and go to state 45 + newexp shift and go to state 46 + isvoidexp shift and go to state 47 + aritmetica shift and go to state 48 + comparison shift and go to state 49 + parenexpression shift and go to state 50 + +state 58 + + (45) blockexp -> lbracket . expressionlist rbracket + (26) expressionlist -> . expression pcoma expressionlist + (27) expressionlist -> . empty + (10) expression -> . constantexp + (11) expression -> . identifier + (12) expression -> . assignment + (13) expression -> . dispatch + (14) expression -> . conditional + (15) expression -> . loopexp + (16) expression -> . blockexp + (17) expression -> . letexp + (18) expression -> . caseexp + (19) expression -> . newexp + (20) expression -> . isvoidexp + (21) expression -> . aritmetica + (22) expression -> . comparison + (23) expression -> . parenexpression + (3) empty -> . + (63) constantexp -> . number + (64) constantexp -> . string + (65) constantexp -> . true + (66) constantexp -> . false + (67) identifier -> . id + (68) assignment -> . id assign expression + (35) dispatch -> . id lparen rparen + (36) dispatch -> . id lparen expression expressionparams rparen + (37) dispatch -> . expression point id lparen rparen + (38) dispatch -> . expression point id lparen expression expressionparams rparen + (39) dispatch -> . expression arroba type point id lparen rparen + (40) dispatch -> . expression arroba type point id lparen expression expressionparams rparen + (43) conditional -> . if expression then expression else expression fi + (44) loopexp -> . while expression loop expression pool + (45) blockexp -> . lbracket expressionlist rbracket + (46) letexp -> . let attribute letattributelist in expression + (47) caseexp -> . case expression of subcase listcase esac + (51) newexp -> . new type + (52) isvoidexp -> . isvoid expression + (53) aritmetica -> . expression plus expression + (54) aritmetica -> . expression minus expression + (55) aritmetica -> . expression mult expression + (56) aritmetica -> . expression div expression + (57) aritmetica -> . intnot expression + (58) comparison -> . expression less expression + (59) comparison -> . expression lesse expression + (60) comparison -> . expression equal expression + (61) comparison -> . not expression + (62) parenexpression -> . lparen expression rparen + + rbracket reduce using rule 3 (empty -> .) + number shift and go to state 51 + string shift and go to state 52 + true shift and go to state 53 + false shift and go to state 54 + id shift and go to state 35 + if shift and go to state 56 + while shift and go to state 57 + lbracket shift and go to state 58 + let shift and go to state 59 + case shift and go to state 60 + new shift and go to state 61 + isvoid shift and go to state 62 + intnot shift and go to state 63 + not shift and go to state 64 + lparen shift and go to state 55 + + expressionlist shift and go to state 84 + expression shift and go to state 85 + empty shift and go to state 86 + constantexp shift and go to state 37 + identifier shift and go to state 38 + assignment shift and go to state 39 + dispatch shift and go to state 40 + conditional shift and go to state 41 + loopexp shift and go to state 42 + blockexp shift and go to state 43 + letexp shift and go to state 44 + caseexp shift and go to state 45 + newexp shift and go to state 46 + isvoidexp shift and go to state 47 + aritmetica shift and go to state 48 + comparison shift and go to state 49 + parenexpression shift and go to state 50 + +state 59 + + (46) letexp -> let . attribute letattributelist in expression + (29) attribute -> . id dpoint type + (30) attribute -> . id dpoint type assign expression + + id shift and go to state 88 + + attribute shift and go to state 87 + +state 60 + + (47) caseexp -> case . expression of subcase listcase esac + (10) expression -> . constantexp + (11) expression -> . identifier + (12) expression -> . assignment + (13) expression -> . dispatch + (14) expression -> . conditional + (15) expression -> . loopexp + (16) expression -> . blockexp + (17) expression -> . letexp + (18) expression -> . caseexp + (19) expression -> . newexp + (20) expression -> . isvoidexp + (21) expression -> . aritmetica + (22) expression -> . comparison + (23) expression -> . parenexpression + (63) constantexp -> . number + (64) constantexp -> . string + (65) constantexp -> . true + (66) constantexp -> . false + (67) identifier -> . id + (68) assignment -> . id assign expression + (35) dispatch -> . id lparen rparen + (36) dispatch -> . id lparen expression expressionparams rparen + (37) dispatch -> . expression point id lparen rparen + (38) dispatch -> . expression point id lparen expression expressionparams rparen + (39) dispatch -> . expression arroba type point id lparen rparen + (40) dispatch -> . expression arroba type point id lparen expression expressionparams rparen + (43) conditional -> . if expression then expression else expression fi + (44) loopexp -> . while expression loop expression pool + (45) blockexp -> . lbracket expressionlist rbracket + (46) letexp -> . let attribute letattributelist in expression + (47) caseexp -> . case expression of subcase listcase esac + (51) newexp -> . new type + (52) isvoidexp -> . isvoid expression + (53) aritmetica -> . expression plus expression + (54) aritmetica -> . expression minus expression + (55) aritmetica -> . expression mult expression + (56) aritmetica -> . expression div expression + (57) aritmetica -> . intnot expression + (58) comparison -> . expression less expression + (59) comparison -> . expression lesse expression + (60) comparison -> . expression equal expression + (61) comparison -> . not expression + (62) parenexpression -> . lparen expression rparen + + number shift and go to state 51 + string shift and go to state 52 + true shift and go to state 53 + false shift and go to state 54 + id shift and go to state 35 + if shift and go to state 56 + while shift and go to state 57 + lbracket shift and go to state 58 + let shift and go to state 59 + case shift and go to state 60 + new shift and go to state 61 + isvoid shift and go to state 62 + intnot shift and go to state 63 + not shift and go to state 64 + lparen shift and go to state 55 + + expression shift and go to state 89 + constantexp shift and go to state 37 + identifier shift and go to state 38 + assignment shift and go to state 39 + dispatch shift and go to state 40 + conditional shift and go to state 41 + loopexp shift and go to state 42 + blockexp shift and go to state 43 + letexp shift and go to state 44 + caseexp shift and go to state 45 + newexp shift and go to state 46 + isvoidexp shift and go to state 47 + aritmetica shift and go to state 48 + comparison shift and go to state 49 + parenexpression shift and go to state 50 + +state 61 + + (51) newexp -> new . type + + type shift and go to state 90 + + +state 62 + + (52) isvoidexp -> isvoid . expression + (10) expression -> . constantexp + (11) expression -> . identifier + (12) expression -> . assignment + (13) expression -> . dispatch + (14) expression -> . conditional + (15) expression -> . loopexp + (16) expression -> . blockexp + (17) expression -> . letexp + (18) expression -> . caseexp + (19) expression -> . newexp + (20) expression -> . isvoidexp + (21) expression -> . aritmetica + (22) expression -> . comparison + (23) expression -> . parenexpression + (63) constantexp -> . number + (64) constantexp -> . string + (65) constantexp -> . true + (66) constantexp -> . false + (67) identifier -> . id + (68) assignment -> . id assign expression + (35) dispatch -> . id lparen rparen + (36) dispatch -> . id lparen expression expressionparams rparen + (37) dispatch -> . expression point id lparen rparen + (38) dispatch -> . expression point id lparen expression expressionparams rparen + (39) dispatch -> . expression arroba type point id lparen rparen + (40) dispatch -> . expression arroba type point id lparen expression expressionparams rparen + (43) conditional -> . if expression then expression else expression fi + (44) loopexp -> . while expression loop expression pool + (45) blockexp -> . lbracket expressionlist rbracket + (46) letexp -> . let attribute letattributelist in expression + (47) caseexp -> . case expression of subcase listcase esac + (51) newexp -> . new type + (52) isvoidexp -> . isvoid expression + (53) aritmetica -> . expression plus expression + (54) aritmetica -> . expression minus expression + (55) aritmetica -> . expression mult expression + (56) aritmetica -> . expression div expression + (57) aritmetica -> . intnot expression + (58) comparison -> . expression less expression + (59) comparison -> . expression lesse expression + (60) comparison -> . expression equal expression + (61) comparison -> . not expression + (62) parenexpression -> . lparen expression rparen + + number shift and go to state 51 + string shift and go to state 52 + true shift and go to state 53 + false shift and go to state 54 + id shift and go to state 35 + if shift and go to state 56 + while shift and go to state 57 + lbracket shift and go to state 58 + let shift and go to state 59 + case shift and go to state 60 + new shift and go to state 61 + isvoid shift and go to state 62 + intnot shift and go to state 63 + not shift and go to state 64 + lparen shift and go to state 55 + + expression shift and go to state 91 + constantexp shift and go to state 37 + identifier shift and go to state 38 + assignment shift and go to state 39 + dispatch shift and go to state 40 + conditional shift and go to state 41 + loopexp shift and go to state 42 + blockexp shift and go to state 43 + letexp shift and go to state 44 + caseexp shift and go to state 45 + newexp shift and go to state 46 + isvoidexp shift and go to state 47 + aritmetica shift and go to state 48 + comparison shift and go to state 49 + parenexpression shift and go to state 50 + +state 63 + + (57) aritmetica -> intnot . expression + (10) expression -> . constantexp + (11) expression -> . identifier + (12) expression -> . assignment + (13) expression -> . dispatch + (14) expression -> . conditional + (15) expression -> . loopexp + (16) expression -> . blockexp + (17) expression -> . letexp + (18) expression -> . caseexp + (19) expression -> . newexp + (20) expression -> . isvoidexp + (21) expression -> . aritmetica + (22) expression -> . comparison + (23) expression -> . parenexpression + (63) constantexp -> . number + (64) constantexp -> . string + (65) constantexp -> . true + (66) constantexp -> . false + (67) identifier -> . id + (68) assignment -> . id assign expression + (35) dispatch -> . id lparen rparen + (36) dispatch -> . id lparen expression expressionparams rparen + (37) dispatch -> . expression point id lparen rparen + (38) dispatch -> . expression point id lparen expression expressionparams rparen + (39) dispatch -> . expression arroba type point id lparen rparen + (40) dispatch -> . expression arroba type point id lparen expression expressionparams rparen + (43) conditional -> . if expression then expression else expression fi + (44) loopexp -> . while expression loop expression pool + (45) blockexp -> . lbracket expressionlist rbracket + (46) letexp -> . let attribute letattributelist in expression + (47) caseexp -> . case expression of subcase listcase esac + (51) newexp -> . new type + (52) isvoidexp -> . isvoid expression + (53) aritmetica -> . expression plus expression + (54) aritmetica -> . expression minus expression + (55) aritmetica -> . expression mult expression + (56) aritmetica -> . expression div expression + (57) aritmetica -> . intnot expression + (58) comparison -> . expression less expression + (59) comparison -> . expression lesse expression + (60) comparison -> . expression equal expression + (61) comparison -> . not expression + (62) parenexpression -> . lparen expression rparen + + number shift and go to state 51 + string shift and go to state 52 + true shift and go to state 53 + false shift and go to state 54 + id shift and go to state 35 + if shift and go to state 56 + while shift and go to state 57 + lbracket shift and go to state 58 + let shift and go to state 59 + case shift and go to state 60 + new shift and go to state 61 + isvoid shift and go to state 62 + intnot shift and go to state 63 + not shift and go to state 64 + lparen shift and go to state 55 + + expression shift and go to state 92 + constantexp shift and go to state 37 + identifier shift and go to state 38 + assignment shift and go to state 39 + dispatch shift and go to state 40 + conditional shift and go to state 41 + loopexp shift and go to state 42 + blockexp shift and go to state 43 + letexp shift and go to state 44 + caseexp shift and go to state 45 + newexp shift and go to state 46 + isvoidexp shift and go to state 47 + aritmetica shift and go to state 48 + comparison shift and go to state 49 + parenexpression shift and go to state 50 + +state 64 + + (61) comparison -> not . expression + (10) expression -> . constantexp + (11) expression -> . identifier + (12) expression -> . assignment + (13) expression -> . dispatch + (14) expression -> . conditional + (15) expression -> . loopexp + (16) expression -> . blockexp + (17) expression -> . letexp + (18) expression -> . caseexp + (19) expression -> . newexp + (20) expression -> . isvoidexp + (21) expression -> . aritmetica + (22) expression -> . comparison + (23) expression -> . parenexpression + (63) constantexp -> . number + (64) constantexp -> . string + (65) constantexp -> . true + (66) constantexp -> . false + (67) identifier -> . id + (68) assignment -> . id assign expression + (35) dispatch -> . id lparen rparen + (36) dispatch -> . id lparen expression expressionparams rparen + (37) dispatch -> . expression point id lparen rparen + (38) dispatch -> . expression point id lparen expression expressionparams rparen + (39) dispatch -> . expression arroba type point id lparen rparen + (40) dispatch -> . expression arroba type point id lparen expression expressionparams rparen + (43) conditional -> . if expression then expression else expression fi + (44) loopexp -> . while expression loop expression pool + (45) blockexp -> . lbracket expressionlist rbracket + (46) letexp -> . let attribute letattributelist in expression + (47) caseexp -> . case expression of subcase listcase esac + (51) newexp -> . new type + (52) isvoidexp -> . isvoid expression + (53) aritmetica -> . expression plus expression + (54) aritmetica -> . expression minus expression + (55) aritmetica -> . expression mult expression + (56) aritmetica -> . expression div expression + (57) aritmetica -> . intnot expression + (58) comparison -> . expression less expression + (59) comparison -> . expression lesse expression + (60) comparison -> . expression equal expression + (61) comparison -> . not expression + (62) parenexpression -> . lparen expression rparen + + number shift and go to state 51 + string shift and go to state 52 + true shift and go to state 53 + false shift and go to state 54 + id shift and go to state 35 + if shift and go to state 56 + while shift and go to state 57 + lbracket shift and go to state 58 + let shift and go to state 59 + case shift and go to state 60 + new shift and go to state 61 + isvoid shift and go to state 62 + intnot shift and go to state 63 + not shift and go to state 64 + lparen shift and go to state 55 + + expression shift and go to state 93 + constantexp shift and go to state 37 + identifier shift and go to state 38 + assignment shift and go to state 39 + dispatch shift and go to state 40 + conditional shift and go to state 41 + loopexp shift and go to state 42 + blockexp shift and go to state 43 + letexp shift and go to state 44 + caseexp shift and go to state 45 + newexp shift and go to state 46 + isvoidexp shift and go to state 47 + aritmetica shift and go to state 48 + comparison shift and go to state 49 + parenexpression shift and go to state 50 + +state 65 + + (28) param -> id dpoint type . + + coma reduce using rule 28 (param -> id dpoint type .) + rparen reduce using rule 28 (param -> id dpoint type .) + + +state 66 + + (24) methoddef -> id lparen rparen dpoint type . lbracket expression rbracket + + lbracket shift and go to state 94 + + +state 67 + + (25) methoddef -> id lparen param paramslistdef rparen . dpoint type lbracket expression rbracket + + dpoint shift and go to state 95 + + +state 68 + + (33) paramslistdef -> coma param . paramslistdef + (33) paramslistdef -> . coma param paramslistdef + (34) paramslistdef -> . empty + (3) empty -> . + + coma shift and go to state 32 + rparen reduce using rule 3 (empty -> .) + + paramslistdef shift and go to state 96 + empty shift and go to state 33 + +state 69 + + (5) classdec -> class type inherits type lbracket featurelist rbracket pcoma . + + class reduce using rule 5 (classdec -> class type inherits type lbracket featurelist rbracket pcoma .) + $end reduce using rule 5 (classdec -> class type inherits type lbracket featurelist rbracket pcoma .) + + +state 70 + + (68) assignment -> id assign . expression + (10) expression -> . constantexp + (11) expression -> . identifier + (12) expression -> . assignment + (13) expression -> . dispatch + (14) expression -> . conditional + (15) expression -> . loopexp + (16) expression -> . blockexp + (17) expression -> . letexp + (18) expression -> . caseexp + (19) expression -> . newexp + (20) expression -> . isvoidexp + (21) expression -> . aritmetica + (22) expression -> . comparison + (23) expression -> . parenexpression + (63) constantexp -> . number + (64) constantexp -> . string + (65) constantexp -> . true + (66) constantexp -> . false + (67) identifier -> . id + (68) assignment -> . id assign expression + (35) dispatch -> . id lparen rparen + (36) dispatch -> . id lparen expression expressionparams rparen + (37) dispatch -> . expression point id lparen rparen + (38) dispatch -> . expression point id lparen expression expressionparams rparen + (39) dispatch -> . expression arroba type point id lparen rparen + (40) dispatch -> . expression arroba type point id lparen expression expressionparams rparen + (43) conditional -> . if expression then expression else expression fi + (44) loopexp -> . while expression loop expression pool + (45) blockexp -> . lbracket expressionlist rbracket + (46) letexp -> . let attribute letattributelist in expression + (47) caseexp -> . case expression of subcase listcase esac + (51) newexp -> . new type + (52) isvoidexp -> . isvoid expression + (53) aritmetica -> . expression plus expression + (54) aritmetica -> . expression minus expression + (55) aritmetica -> . expression mult expression + (56) aritmetica -> . expression div expression + (57) aritmetica -> . intnot expression + (58) comparison -> . expression less expression + (59) comparison -> . expression lesse expression + (60) comparison -> . expression equal expression + (61) comparison -> . not expression + (62) parenexpression -> . lparen expression rparen + + number shift and go to state 51 + string shift and go to state 52 + true shift and go to state 53 + false shift and go to state 54 + id shift and go to state 35 + if shift and go to state 56 + while shift and go to state 57 + lbracket shift and go to state 58 + let shift and go to state 59 + case shift and go to state 60 + new shift and go to state 61 + isvoid shift and go to state 62 + intnot shift and go to state 63 + not shift and go to state 64 + lparen shift and go to state 55 + + expression shift and go to state 97 + constantexp shift and go to state 37 + identifier shift and go to state 38 + assignment shift and go to state 39 + dispatch shift and go to state 40 + conditional shift and go to state 41 + loopexp shift and go to state 42 + blockexp shift and go to state 43 + letexp shift and go to state 44 + caseexp shift and go to state 45 + newexp shift and go to state 46 + isvoidexp shift and go to state 47 + aritmetica shift and go to state 48 + comparison shift and go to state 49 + parenexpression shift and go to state 50 + +state 71 + + (35) dispatch -> id lparen . rparen + (36) dispatch -> id lparen . expression expressionparams rparen + (10) expression -> . constantexp + (11) expression -> . identifier + (12) expression -> . assignment + (13) expression -> . dispatch + (14) expression -> . conditional + (15) expression -> . loopexp + (16) expression -> . blockexp + (17) expression -> . letexp + (18) expression -> . caseexp + (19) expression -> . newexp + (20) expression -> . isvoidexp + (21) expression -> . aritmetica + (22) expression -> . comparison + (23) expression -> . parenexpression + (63) constantexp -> . number + (64) constantexp -> . string + (65) constantexp -> . true + (66) constantexp -> . false + (67) identifier -> . id + (68) assignment -> . id assign expression + (35) dispatch -> . id lparen rparen + (36) dispatch -> . id lparen expression expressionparams rparen + (37) dispatch -> . expression point id lparen rparen + (38) dispatch -> . expression point id lparen expression expressionparams rparen + (39) dispatch -> . expression arroba type point id lparen rparen + (40) dispatch -> . expression arroba type point id lparen expression expressionparams rparen + (43) conditional -> . if expression then expression else expression fi + (44) loopexp -> . while expression loop expression pool + (45) blockexp -> . lbracket expressionlist rbracket + (46) letexp -> . let attribute letattributelist in expression + (47) caseexp -> . case expression of subcase listcase esac + (51) newexp -> . new type + (52) isvoidexp -> . isvoid expression + (53) aritmetica -> . expression plus expression + (54) aritmetica -> . expression minus expression + (55) aritmetica -> . expression mult expression + (56) aritmetica -> . expression div expression + (57) aritmetica -> . intnot expression + (58) comparison -> . expression less expression + (59) comparison -> . expression lesse expression + (60) comparison -> . expression equal expression + (61) comparison -> . not expression + (62) parenexpression -> . lparen expression rparen + + rparen shift and go to state 98 + number shift and go to state 51 + string shift and go to state 52 + true shift and go to state 53 + false shift and go to state 54 + id shift and go to state 35 + if shift and go to state 56 + while shift and go to state 57 + lbracket shift and go to state 58 + let shift and go to state 59 + case shift and go to state 60 + new shift and go to state 61 + isvoid shift and go to state 62 + intnot shift and go to state 63 + not shift and go to state 64 + lparen shift and go to state 55 + + expression shift and go to state 99 + constantexp shift and go to state 37 + identifier shift and go to state 38 + assignment shift and go to state 39 + dispatch shift and go to state 40 + conditional shift and go to state 41 + loopexp shift and go to state 42 + blockexp shift and go to state 43 + letexp shift and go to state 44 + caseexp shift and go to state 45 + newexp shift and go to state 46 + isvoidexp shift and go to state 47 + aritmetica shift and go to state 48 + comparison shift and go to state 49 + parenexpression shift and go to state 50 + +state 72 + + (37) dispatch -> expression point . id lparen rparen + (38) dispatch -> expression point . id lparen expression expressionparams rparen + + id shift and go to state 100 + + +state 73 + + (39) dispatch -> expression arroba . type point id lparen rparen + (40) dispatch -> expression arroba . type point id lparen expression expressionparams rparen + + type shift and go to state 101 + + +state 74 + + (53) aritmetica -> expression plus . expression + (10) expression -> . constantexp + (11) expression -> . identifier + (12) expression -> . assignment + (13) expression -> . dispatch + (14) expression -> . conditional + (15) expression -> . loopexp + (16) expression -> . blockexp + (17) expression -> . letexp + (18) expression -> . caseexp + (19) expression -> . newexp + (20) expression -> . isvoidexp + (21) expression -> . aritmetica + (22) expression -> . comparison + (23) expression -> . parenexpression + (63) constantexp -> . number + (64) constantexp -> . string + (65) constantexp -> . true + (66) constantexp -> . false + (67) identifier -> . id + (68) assignment -> . id assign expression + (35) dispatch -> . id lparen rparen + (36) dispatch -> . id lparen expression expressionparams rparen + (37) dispatch -> . expression point id lparen rparen + (38) dispatch -> . expression point id lparen expression expressionparams rparen + (39) dispatch -> . expression arroba type point id lparen rparen + (40) dispatch -> . expression arroba type point id lparen expression expressionparams rparen + (43) conditional -> . if expression then expression else expression fi + (44) loopexp -> . while expression loop expression pool + (45) blockexp -> . lbracket expressionlist rbracket + (46) letexp -> . let attribute letattributelist in expression + (47) caseexp -> . case expression of subcase listcase esac + (51) newexp -> . new type + (52) isvoidexp -> . isvoid expression + (53) aritmetica -> . expression plus expression + (54) aritmetica -> . expression minus expression + (55) aritmetica -> . expression mult expression + (56) aritmetica -> . expression div expression + (57) aritmetica -> . intnot expression + (58) comparison -> . expression less expression + (59) comparison -> . expression lesse expression + (60) comparison -> . expression equal expression + (61) comparison -> . not expression + (62) parenexpression -> . lparen expression rparen + + number shift and go to state 51 + string shift and go to state 52 + true shift and go to state 53 + false shift and go to state 54 + id shift and go to state 35 + if shift and go to state 56 + while shift and go to state 57 + lbracket shift and go to state 58 + let shift and go to state 59 + case shift and go to state 60 + new shift and go to state 61 + isvoid shift and go to state 62 + intnot shift and go to state 63 + not shift and go to state 64 + lparen shift and go to state 55 + + expression shift and go to state 102 + constantexp shift and go to state 37 + identifier shift and go to state 38 + assignment shift and go to state 39 + dispatch shift and go to state 40 + conditional shift and go to state 41 + loopexp shift and go to state 42 + blockexp shift and go to state 43 + letexp shift and go to state 44 + caseexp shift and go to state 45 + newexp shift and go to state 46 + isvoidexp shift and go to state 47 + aritmetica shift and go to state 48 + comparison shift and go to state 49 + parenexpression shift and go to state 50 + +state 75 + + (54) aritmetica -> expression minus . expression + (10) expression -> . constantexp + (11) expression -> . identifier + (12) expression -> . assignment + (13) expression -> . dispatch + (14) expression -> . conditional + (15) expression -> . loopexp + (16) expression -> . blockexp + (17) expression -> . letexp + (18) expression -> . caseexp + (19) expression -> . newexp + (20) expression -> . isvoidexp + (21) expression -> . aritmetica + (22) expression -> . comparison + (23) expression -> . parenexpression + (63) constantexp -> . number + (64) constantexp -> . string + (65) constantexp -> . true + (66) constantexp -> . false + (67) identifier -> . id + (68) assignment -> . id assign expression + (35) dispatch -> . id lparen rparen + (36) dispatch -> . id lparen expression expressionparams rparen + (37) dispatch -> . expression point id lparen rparen + (38) dispatch -> . expression point id lparen expression expressionparams rparen + (39) dispatch -> . expression arroba type point id lparen rparen + (40) dispatch -> . expression arroba type point id lparen expression expressionparams rparen + (43) conditional -> . if expression then expression else expression fi + (44) loopexp -> . while expression loop expression pool + (45) blockexp -> . lbracket expressionlist rbracket + (46) letexp -> . let attribute letattributelist in expression + (47) caseexp -> . case expression of subcase listcase esac + (51) newexp -> . new type + (52) isvoidexp -> . isvoid expression + (53) aritmetica -> . expression plus expression + (54) aritmetica -> . expression minus expression + (55) aritmetica -> . expression mult expression + (56) aritmetica -> . expression div expression + (57) aritmetica -> . intnot expression + (58) comparison -> . expression less expression + (59) comparison -> . expression lesse expression + (60) comparison -> . expression equal expression + (61) comparison -> . not expression + (62) parenexpression -> . lparen expression rparen + + number shift and go to state 51 + string shift and go to state 52 + true shift and go to state 53 + false shift and go to state 54 + id shift and go to state 35 + if shift and go to state 56 + while shift and go to state 57 + lbracket shift and go to state 58 + let shift and go to state 59 + case shift and go to state 60 + new shift and go to state 61 + isvoid shift and go to state 62 + intnot shift and go to state 63 + not shift and go to state 64 + lparen shift and go to state 55 + + expression shift and go to state 103 + constantexp shift and go to state 37 + identifier shift and go to state 38 + assignment shift and go to state 39 + dispatch shift and go to state 40 + conditional shift and go to state 41 + loopexp shift and go to state 42 + blockexp shift and go to state 43 + letexp shift and go to state 44 + caseexp shift and go to state 45 + newexp shift and go to state 46 + isvoidexp shift and go to state 47 + aritmetica shift and go to state 48 + comparison shift and go to state 49 + parenexpression shift and go to state 50 + +state 76 + + (55) aritmetica -> expression mult . expression + (10) expression -> . constantexp + (11) expression -> . identifier + (12) expression -> . assignment + (13) expression -> . dispatch + (14) expression -> . conditional + (15) expression -> . loopexp + (16) expression -> . blockexp + (17) expression -> . letexp + (18) expression -> . caseexp + (19) expression -> . newexp + (20) expression -> . isvoidexp + (21) expression -> . aritmetica + (22) expression -> . comparison + (23) expression -> . parenexpression + (63) constantexp -> . number + (64) constantexp -> . string + (65) constantexp -> . true + (66) constantexp -> . false + (67) identifier -> . id + (68) assignment -> . id assign expression + (35) dispatch -> . id lparen rparen + (36) dispatch -> . id lparen expression expressionparams rparen + (37) dispatch -> . expression point id lparen rparen + (38) dispatch -> . expression point id lparen expression expressionparams rparen + (39) dispatch -> . expression arroba type point id lparen rparen + (40) dispatch -> . expression arroba type point id lparen expression expressionparams rparen + (43) conditional -> . if expression then expression else expression fi + (44) loopexp -> . while expression loop expression pool + (45) blockexp -> . lbracket expressionlist rbracket + (46) letexp -> . let attribute letattributelist in expression + (47) caseexp -> . case expression of subcase listcase esac + (51) newexp -> . new type + (52) isvoidexp -> . isvoid expression + (53) aritmetica -> . expression plus expression + (54) aritmetica -> . expression minus expression + (55) aritmetica -> . expression mult expression + (56) aritmetica -> . expression div expression + (57) aritmetica -> . intnot expression + (58) comparison -> . expression less expression + (59) comparison -> . expression lesse expression + (60) comparison -> . expression equal expression + (61) comparison -> . not expression + (62) parenexpression -> . lparen expression rparen + + number shift and go to state 51 + string shift and go to state 52 + true shift and go to state 53 + false shift and go to state 54 + id shift and go to state 35 + if shift and go to state 56 + while shift and go to state 57 + lbracket shift and go to state 58 + let shift and go to state 59 + case shift and go to state 60 + new shift and go to state 61 + isvoid shift and go to state 62 + intnot shift and go to state 63 + not shift and go to state 64 + lparen shift and go to state 55 + + expression shift and go to state 104 + constantexp shift and go to state 37 + identifier shift and go to state 38 + assignment shift and go to state 39 + dispatch shift and go to state 40 + conditional shift and go to state 41 + loopexp shift and go to state 42 + blockexp shift and go to state 43 + letexp shift and go to state 44 + caseexp shift and go to state 45 + newexp shift and go to state 46 + isvoidexp shift and go to state 47 + aritmetica shift and go to state 48 + comparison shift and go to state 49 + parenexpression shift and go to state 50 + +state 77 + + (56) aritmetica -> expression div . expression + (10) expression -> . constantexp + (11) expression -> . identifier + (12) expression -> . assignment + (13) expression -> . dispatch + (14) expression -> . conditional + (15) expression -> . loopexp + (16) expression -> . blockexp + (17) expression -> . letexp + (18) expression -> . caseexp + (19) expression -> . newexp + (20) expression -> . isvoidexp + (21) expression -> . aritmetica + (22) expression -> . comparison + (23) expression -> . parenexpression + (63) constantexp -> . number + (64) constantexp -> . string + (65) constantexp -> . true + (66) constantexp -> . false + (67) identifier -> . id + (68) assignment -> . id assign expression + (35) dispatch -> . id lparen rparen + (36) dispatch -> . id lparen expression expressionparams rparen + (37) dispatch -> . expression point id lparen rparen + (38) dispatch -> . expression point id lparen expression expressionparams rparen + (39) dispatch -> . expression arroba type point id lparen rparen + (40) dispatch -> . expression arroba type point id lparen expression expressionparams rparen + (43) conditional -> . if expression then expression else expression fi + (44) loopexp -> . while expression loop expression pool + (45) blockexp -> . lbracket expressionlist rbracket + (46) letexp -> . let attribute letattributelist in expression + (47) caseexp -> . case expression of subcase listcase esac + (51) newexp -> . new type + (52) isvoidexp -> . isvoid expression + (53) aritmetica -> . expression plus expression + (54) aritmetica -> . expression minus expression + (55) aritmetica -> . expression mult expression + (56) aritmetica -> . expression div expression + (57) aritmetica -> . intnot expression + (58) comparison -> . expression less expression + (59) comparison -> . expression lesse expression + (60) comparison -> . expression equal expression + (61) comparison -> . not expression + (62) parenexpression -> . lparen expression rparen + + number shift and go to state 51 + string shift and go to state 52 + true shift and go to state 53 + false shift and go to state 54 + id shift and go to state 35 + if shift and go to state 56 + while shift and go to state 57 + lbracket shift and go to state 58 + let shift and go to state 59 + case shift and go to state 60 + new shift and go to state 61 + isvoid shift and go to state 62 + intnot shift and go to state 63 + not shift and go to state 64 + lparen shift and go to state 55 + + expression shift and go to state 105 + constantexp shift and go to state 37 + identifier shift and go to state 38 + assignment shift and go to state 39 + dispatch shift and go to state 40 + conditional shift and go to state 41 + loopexp shift and go to state 42 + blockexp shift and go to state 43 + letexp shift and go to state 44 + caseexp shift and go to state 45 + newexp shift and go to state 46 + isvoidexp shift and go to state 47 + aritmetica shift and go to state 48 + comparison shift and go to state 49 + parenexpression shift and go to state 50 + +state 78 + + (58) comparison -> expression less . expression + (10) expression -> . constantexp + (11) expression -> . identifier + (12) expression -> . assignment + (13) expression -> . dispatch + (14) expression -> . conditional + (15) expression -> . loopexp + (16) expression -> . blockexp + (17) expression -> . letexp + (18) expression -> . caseexp + (19) expression -> . newexp + (20) expression -> . isvoidexp + (21) expression -> . aritmetica + (22) expression -> . comparison + (23) expression -> . parenexpression + (63) constantexp -> . number + (64) constantexp -> . string + (65) constantexp -> . true + (66) constantexp -> . false + (67) identifier -> . id + (68) assignment -> . id assign expression + (35) dispatch -> . id lparen rparen + (36) dispatch -> . id lparen expression expressionparams rparen + (37) dispatch -> . expression point id lparen rparen + (38) dispatch -> . expression point id lparen expression expressionparams rparen + (39) dispatch -> . expression arroba type point id lparen rparen + (40) dispatch -> . expression arroba type point id lparen expression expressionparams rparen + (43) conditional -> . if expression then expression else expression fi + (44) loopexp -> . while expression loop expression pool + (45) blockexp -> . lbracket expressionlist rbracket + (46) letexp -> . let attribute letattributelist in expression + (47) caseexp -> . case expression of subcase listcase esac + (51) newexp -> . new type + (52) isvoidexp -> . isvoid expression + (53) aritmetica -> . expression plus expression + (54) aritmetica -> . expression minus expression + (55) aritmetica -> . expression mult expression + (56) aritmetica -> . expression div expression + (57) aritmetica -> . intnot expression + (58) comparison -> . expression less expression + (59) comparison -> . expression lesse expression + (60) comparison -> . expression equal expression + (61) comparison -> . not expression + (62) parenexpression -> . lparen expression rparen + + number shift and go to state 51 + string shift and go to state 52 + true shift and go to state 53 + false shift and go to state 54 + id shift and go to state 35 + if shift and go to state 56 + while shift and go to state 57 + lbracket shift and go to state 58 + let shift and go to state 59 + case shift and go to state 60 + new shift and go to state 61 + isvoid shift and go to state 62 + intnot shift and go to state 63 + not shift and go to state 64 + lparen shift and go to state 55 + + expression shift and go to state 106 + constantexp shift and go to state 37 + identifier shift and go to state 38 + assignment shift and go to state 39 + dispatch shift and go to state 40 + conditional shift and go to state 41 + loopexp shift and go to state 42 + blockexp shift and go to state 43 + letexp shift and go to state 44 + caseexp shift and go to state 45 + newexp shift and go to state 46 + isvoidexp shift and go to state 47 + aritmetica shift and go to state 48 + comparison shift and go to state 49 + parenexpression shift and go to state 50 + +state 79 + + (59) comparison -> expression lesse . expression + (10) expression -> . constantexp + (11) expression -> . identifier + (12) expression -> . assignment + (13) expression -> . dispatch + (14) expression -> . conditional + (15) expression -> . loopexp + (16) expression -> . blockexp + (17) expression -> . letexp + (18) expression -> . caseexp + (19) expression -> . newexp + (20) expression -> . isvoidexp + (21) expression -> . aritmetica + (22) expression -> . comparison + (23) expression -> . parenexpression + (63) constantexp -> . number + (64) constantexp -> . string + (65) constantexp -> . true + (66) constantexp -> . false + (67) identifier -> . id + (68) assignment -> . id assign expression + (35) dispatch -> . id lparen rparen + (36) dispatch -> . id lparen expression expressionparams rparen + (37) dispatch -> . expression point id lparen rparen + (38) dispatch -> . expression point id lparen expression expressionparams rparen + (39) dispatch -> . expression arroba type point id lparen rparen + (40) dispatch -> . expression arroba type point id lparen expression expressionparams rparen + (43) conditional -> . if expression then expression else expression fi + (44) loopexp -> . while expression loop expression pool + (45) blockexp -> . lbracket expressionlist rbracket + (46) letexp -> . let attribute letattributelist in expression + (47) caseexp -> . case expression of subcase listcase esac + (51) newexp -> . new type + (52) isvoidexp -> . isvoid expression + (53) aritmetica -> . expression plus expression + (54) aritmetica -> . expression minus expression + (55) aritmetica -> . expression mult expression + (56) aritmetica -> . expression div expression + (57) aritmetica -> . intnot expression + (58) comparison -> . expression less expression + (59) comparison -> . expression lesse expression + (60) comparison -> . expression equal expression + (61) comparison -> . not expression + (62) parenexpression -> . lparen expression rparen + + number shift and go to state 51 + string shift and go to state 52 + true shift and go to state 53 + false shift and go to state 54 + id shift and go to state 35 + if shift and go to state 56 + while shift and go to state 57 + lbracket shift and go to state 58 + let shift and go to state 59 + case shift and go to state 60 + new shift and go to state 61 + isvoid shift and go to state 62 + intnot shift and go to state 63 + not shift and go to state 64 + lparen shift and go to state 55 + + expression shift and go to state 107 + constantexp shift and go to state 37 + identifier shift and go to state 38 + assignment shift and go to state 39 + dispatch shift and go to state 40 + conditional shift and go to state 41 + loopexp shift and go to state 42 + blockexp shift and go to state 43 + letexp shift and go to state 44 + caseexp shift and go to state 45 + newexp shift and go to state 46 + isvoidexp shift and go to state 47 + aritmetica shift and go to state 48 + comparison shift and go to state 49 + parenexpression shift and go to state 50 + +state 80 + + (60) comparison -> expression equal . expression + (10) expression -> . constantexp + (11) expression -> . identifier + (12) expression -> . assignment + (13) expression -> . dispatch + (14) expression -> . conditional + (15) expression -> . loopexp + (16) expression -> . blockexp + (17) expression -> . letexp + (18) expression -> . caseexp + (19) expression -> . newexp + (20) expression -> . isvoidexp + (21) expression -> . aritmetica + (22) expression -> . comparison + (23) expression -> . parenexpression + (63) constantexp -> . number + (64) constantexp -> . string + (65) constantexp -> . true + (66) constantexp -> . false + (67) identifier -> . id + (68) assignment -> . id assign expression + (35) dispatch -> . id lparen rparen + (36) dispatch -> . id lparen expression expressionparams rparen + (37) dispatch -> . expression point id lparen rparen + (38) dispatch -> . expression point id lparen expression expressionparams rparen + (39) dispatch -> . expression arroba type point id lparen rparen + (40) dispatch -> . expression arroba type point id lparen expression expressionparams rparen + (43) conditional -> . if expression then expression else expression fi + (44) loopexp -> . while expression loop expression pool + (45) blockexp -> . lbracket expressionlist rbracket + (46) letexp -> . let attribute letattributelist in expression + (47) caseexp -> . case expression of subcase listcase esac + (51) newexp -> . new type + (52) isvoidexp -> . isvoid expression + (53) aritmetica -> . expression plus expression + (54) aritmetica -> . expression minus expression + (55) aritmetica -> . expression mult expression + (56) aritmetica -> . expression div expression + (57) aritmetica -> . intnot expression + (58) comparison -> . expression less expression + (59) comparison -> . expression lesse expression + (60) comparison -> . expression equal expression + (61) comparison -> . not expression + (62) parenexpression -> . lparen expression rparen + + number shift and go to state 51 + string shift and go to state 52 + true shift and go to state 53 + false shift and go to state 54 + id shift and go to state 35 + if shift and go to state 56 + while shift and go to state 57 + lbracket shift and go to state 58 + let shift and go to state 59 + case shift and go to state 60 + new shift and go to state 61 + isvoid shift and go to state 62 + intnot shift and go to state 63 + not shift and go to state 64 + lparen shift and go to state 55 + + expression shift and go to state 108 + constantexp shift and go to state 37 + identifier shift and go to state 38 + assignment shift and go to state 39 + dispatch shift and go to state 40 + conditional shift and go to state 41 + loopexp shift and go to state 42 + blockexp shift and go to state 43 + letexp shift and go to state 44 + caseexp shift and go to state 45 + newexp shift and go to state 46 + isvoidexp shift and go to state 47 + aritmetica shift and go to state 48 + comparison shift and go to state 49 + parenexpression shift and go to state 50 + +state 81 + + (62) parenexpression -> lparen expression . rparen + (37) dispatch -> expression . point id lparen rparen + (38) dispatch -> expression . point id lparen expression expressionparams rparen + (39) dispatch -> expression . arroba type point id lparen rparen + (40) dispatch -> expression . arroba type point id lparen expression expressionparams rparen + (53) aritmetica -> expression . plus expression + (54) aritmetica -> expression . minus expression + (55) aritmetica -> expression . mult expression + (56) aritmetica -> expression . div expression + (58) comparison -> expression . less expression + (59) comparison -> expression . lesse expression + (60) comparison -> expression . equal expression + + rparen shift and go to state 109 + point shift and go to state 72 + arroba shift and go to state 73 + plus shift and go to state 74 + minus shift and go to state 75 + mult shift and go to state 76 + div shift and go to state 77 + less shift and go to state 78 + lesse shift and go to state 79 + equal shift and go to state 80 + + +state 82 + + (43) conditional -> if expression . then expression else expression fi + (37) dispatch -> expression . point id lparen rparen + (38) dispatch -> expression . point id lparen expression expressionparams rparen + (39) dispatch -> expression . arroba type point id lparen rparen + (40) dispatch -> expression . arroba type point id lparen expression expressionparams rparen + (53) aritmetica -> expression . plus expression + (54) aritmetica -> expression . minus expression + (55) aritmetica -> expression . mult expression + (56) aritmetica -> expression . div expression + (58) comparison -> expression . less expression + (59) comparison -> expression . lesse expression + (60) comparison -> expression . equal expression + + then shift and go to state 110 + point shift and go to state 72 + arroba shift and go to state 73 + plus shift and go to state 74 + minus shift and go to state 75 + mult shift and go to state 76 + div shift and go to state 77 + less shift and go to state 78 + lesse shift and go to state 79 + equal shift and go to state 80 + + +state 83 + + (44) loopexp -> while expression . loop expression pool + (37) dispatch -> expression . point id lparen rparen + (38) dispatch -> expression . point id lparen expression expressionparams rparen + (39) dispatch -> expression . arroba type point id lparen rparen + (40) dispatch -> expression . arroba type point id lparen expression expressionparams rparen + (53) aritmetica -> expression . plus expression + (54) aritmetica -> expression . minus expression + (55) aritmetica -> expression . mult expression + (56) aritmetica -> expression . div expression + (58) comparison -> expression . less expression + (59) comparison -> expression . lesse expression + (60) comparison -> expression . equal expression + + loop shift and go to state 111 + point shift and go to state 72 + arroba shift and go to state 73 + plus shift and go to state 74 + minus shift and go to state 75 + mult shift and go to state 76 + div shift and go to state 77 + less shift and go to state 78 + lesse shift and go to state 79 + equal shift and go to state 80 + + +state 84 + + (45) blockexp -> lbracket expressionlist . rbracket + + rbracket shift and go to state 112 + + +state 85 + + (26) expressionlist -> expression . pcoma expressionlist + (37) dispatch -> expression . point id lparen rparen + (38) dispatch -> expression . point id lparen expression expressionparams rparen + (39) dispatch -> expression . arroba type point id lparen rparen + (40) dispatch -> expression . arroba type point id lparen expression expressionparams rparen + (53) aritmetica -> expression . plus expression + (54) aritmetica -> expression . minus expression + (55) aritmetica -> expression . mult expression + (56) aritmetica -> expression . div expression + (58) comparison -> expression . less expression + (59) comparison -> expression . lesse expression + (60) comparison -> expression . equal expression + + pcoma shift and go to state 113 + point shift and go to state 72 + arroba shift and go to state 73 + plus shift and go to state 74 + minus shift and go to state 75 + mult shift and go to state 76 + div shift and go to state 77 + less shift and go to state 78 + lesse shift and go to state 79 + equal shift and go to state 80 + + +state 86 + + (27) expressionlist -> empty . + + rbracket reduce using rule 27 (expressionlist -> empty .) + + +state 87 + + (46) letexp -> let attribute . letattributelist in expression + (31) letattributelist -> . coma attribute letattributelist + (32) letattributelist -> . empty + (3) empty -> . + + coma shift and go to state 115 + in reduce using rule 3 (empty -> .) + + letattributelist shift and go to state 114 + empty shift and go to state 116 + +state 88 + + (29) attribute -> id . dpoint type + (30) attribute -> id . dpoint type assign expression + + dpoint shift and go to state 19 + + +state 89 + + (47) caseexp -> case expression . of subcase listcase esac + (37) dispatch -> expression . point id lparen rparen + (38) dispatch -> expression . point id lparen expression expressionparams rparen + (39) dispatch -> expression . arroba type point id lparen rparen + (40) dispatch -> expression . arroba type point id lparen expression expressionparams rparen + (53) aritmetica -> expression . plus expression + (54) aritmetica -> expression . minus expression + (55) aritmetica -> expression . mult expression + (56) aritmetica -> expression . div expression + (58) comparison -> expression . less expression + (59) comparison -> expression . lesse expression + (60) comparison -> expression . equal expression + + of shift and go to state 117 + point shift and go to state 72 + arroba shift and go to state 73 + plus shift and go to state 74 + minus shift and go to state 75 + mult shift and go to state 76 + div shift and go to state 77 + less shift and go to state 78 + lesse shift and go to state 79 + equal shift and go to state 80 + + +state 90 + + (51) newexp -> new type . + + point reduce using rule 51 (newexp -> new type .) + arroba reduce using rule 51 (newexp -> new type .) + plus reduce using rule 51 (newexp -> new type .) + minus reduce using rule 51 (newexp -> new type .) + mult reduce using rule 51 (newexp -> new type .) + div reduce using rule 51 (newexp -> new type .) + less reduce using rule 51 (newexp -> new type .) + lesse reduce using rule 51 (newexp -> new type .) + equal reduce using rule 51 (newexp -> new type .) + pcoma reduce using rule 51 (newexp -> new type .) + coma reduce using rule 51 (newexp -> new type .) + in reduce using rule 51 (newexp -> new type .) + rparen reduce using rule 51 (newexp -> new type .) + then reduce using rule 51 (newexp -> new type .) + loop reduce using rule 51 (newexp -> new type .) + of reduce using rule 51 (newexp -> new type .) + rbracket reduce using rule 51 (newexp -> new type .) + else reduce using rule 51 (newexp -> new type .) + pool reduce using rule 51 (newexp -> new type .) + fi reduce using rule 51 (newexp -> new type .) + + +state 91 + + (52) isvoidexp -> isvoid expression . + (37) dispatch -> expression . point id lparen rparen + (38) dispatch -> expression . point id lparen expression expressionparams rparen + (39) dispatch -> expression . arroba type point id lparen rparen + (40) dispatch -> expression . arroba type point id lparen expression expressionparams rparen + (53) aritmetica -> expression . plus expression + (54) aritmetica -> expression . minus expression + (55) aritmetica -> expression . mult expression + (56) aritmetica -> expression . div expression + (58) comparison -> expression . less expression + (59) comparison -> expression . lesse expression + (60) comparison -> expression . equal expression + + plus reduce using rule 52 (isvoidexp -> isvoid expression .) + minus reduce using rule 52 (isvoidexp -> isvoid expression .) + mult reduce using rule 52 (isvoidexp -> isvoid expression .) + div reduce using rule 52 (isvoidexp -> isvoid expression .) + less reduce using rule 52 (isvoidexp -> isvoid expression .) + lesse reduce using rule 52 (isvoidexp -> isvoid expression .) + equal reduce using rule 52 (isvoidexp -> isvoid expression .) + pcoma reduce using rule 52 (isvoidexp -> isvoid expression .) + coma reduce using rule 52 (isvoidexp -> isvoid expression .) + in reduce using rule 52 (isvoidexp -> isvoid expression .) + rparen reduce using rule 52 (isvoidexp -> isvoid expression .) + then reduce using rule 52 (isvoidexp -> isvoid expression .) + loop reduce using rule 52 (isvoidexp -> isvoid expression .) + of reduce using rule 52 (isvoidexp -> isvoid expression .) + rbracket reduce using rule 52 (isvoidexp -> isvoid expression .) + else reduce using rule 52 (isvoidexp -> isvoid expression .) + pool reduce using rule 52 (isvoidexp -> isvoid expression .) + fi reduce using rule 52 (isvoidexp -> isvoid expression .) + point shift and go to state 72 + arroba shift and go to state 73 + + ! point [ reduce using rule 52 (isvoidexp -> isvoid expression .) ] + ! arroba [ reduce using rule 52 (isvoidexp -> isvoid expression .) ] + ! plus [ shift and go to state 74 ] + ! minus [ shift and go to state 75 ] + ! mult [ shift and go to state 76 ] + ! div [ shift and go to state 77 ] + ! less [ shift and go to state 78 ] + ! lesse [ shift and go to state 79 ] + ! equal [ shift and go to state 80 ] + + +state 92 + + (57) aritmetica -> intnot expression . + (37) dispatch -> expression . point id lparen rparen + (38) dispatch -> expression . point id lparen expression expressionparams rparen + (39) dispatch -> expression . arroba type point id lparen rparen + (40) dispatch -> expression . arroba type point id lparen expression expressionparams rparen + (53) aritmetica -> expression . plus expression + (54) aritmetica -> expression . minus expression + (55) aritmetica -> expression . mult expression + (56) aritmetica -> expression . div expression + (58) comparison -> expression . less expression + (59) comparison -> expression . lesse expression + (60) comparison -> expression . equal expression + + plus reduce using rule 57 (aritmetica -> intnot expression .) + minus reduce using rule 57 (aritmetica -> intnot expression .) + mult reduce using rule 57 (aritmetica -> intnot expression .) + div reduce using rule 57 (aritmetica -> intnot expression .) + less reduce using rule 57 (aritmetica -> intnot expression .) + lesse reduce using rule 57 (aritmetica -> intnot expression .) + equal reduce using rule 57 (aritmetica -> intnot expression .) + pcoma reduce using rule 57 (aritmetica -> intnot expression .) + coma reduce using rule 57 (aritmetica -> intnot expression .) + in reduce using rule 57 (aritmetica -> intnot expression .) + rparen reduce using rule 57 (aritmetica -> intnot expression .) + then reduce using rule 57 (aritmetica -> intnot expression .) + loop reduce using rule 57 (aritmetica -> intnot expression .) + of reduce using rule 57 (aritmetica -> intnot expression .) + rbracket reduce using rule 57 (aritmetica -> intnot expression .) + else reduce using rule 57 (aritmetica -> intnot expression .) + pool reduce using rule 57 (aritmetica -> intnot expression .) + fi reduce using rule 57 (aritmetica -> intnot expression .) + point shift and go to state 72 + arroba shift and go to state 73 + + ! point [ reduce using rule 57 (aritmetica -> intnot expression .) ] + ! arroba [ reduce using rule 57 (aritmetica -> intnot expression .) ] + ! plus [ shift and go to state 74 ] + ! minus [ shift and go to state 75 ] + ! mult [ shift and go to state 76 ] + ! div [ shift and go to state 77 ] + ! less [ shift and go to state 78 ] + ! lesse [ shift and go to state 79 ] + ! equal [ shift and go to state 80 ] + + +state 93 + + (61) comparison -> not expression . + (37) dispatch -> expression . point id lparen rparen + (38) dispatch -> expression . point id lparen expression expressionparams rparen + (39) dispatch -> expression . arroba type point id lparen rparen + (40) dispatch -> expression . arroba type point id lparen expression expressionparams rparen + (53) aritmetica -> expression . plus expression + (54) aritmetica -> expression . minus expression + (55) aritmetica -> expression . mult expression + (56) aritmetica -> expression . div expression + (58) comparison -> expression . less expression + (59) comparison -> expression . lesse expression + (60) comparison -> expression . equal expression + + pcoma reduce using rule 61 (comparison -> not expression .) + coma reduce using rule 61 (comparison -> not expression .) + in reduce using rule 61 (comparison -> not expression .) + rparen reduce using rule 61 (comparison -> not expression .) + then reduce using rule 61 (comparison -> not expression .) + loop reduce using rule 61 (comparison -> not expression .) + of reduce using rule 61 (comparison -> not expression .) + rbracket reduce using rule 61 (comparison -> not expression .) + else reduce using rule 61 (comparison -> not expression .) + pool reduce using rule 61 (comparison -> not expression .) + fi reduce using rule 61 (comparison -> not expression .) + point shift and go to state 72 + arroba shift and go to state 73 + plus shift and go to state 74 + minus shift and go to state 75 + mult shift and go to state 76 + div shift and go to state 77 + less shift and go to state 78 + lesse shift and go to state 79 + equal shift and go to state 80 + + ! point [ reduce using rule 61 (comparison -> not expression .) ] + ! arroba [ reduce using rule 61 (comparison -> not expression .) ] + ! plus [ reduce using rule 61 (comparison -> not expression .) ] + ! minus [ reduce using rule 61 (comparison -> not expression .) ] + ! mult [ reduce using rule 61 (comparison -> not expression .) ] + ! div [ reduce using rule 61 (comparison -> not expression .) ] + ! less [ reduce using rule 61 (comparison -> not expression .) ] + ! lesse [ reduce using rule 61 (comparison -> not expression .) ] + ! equal [ reduce using rule 61 (comparison -> not expression .) ] + + +state 94 + + (24) methoddef -> id lparen rparen dpoint type lbracket . expression rbracket + (10) expression -> . constantexp + (11) expression -> . identifier + (12) expression -> . assignment + (13) expression -> . dispatch + (14) expression -> . conditional + (15) expression -> . loopexp + (16) expression -> . blockexp + (17) expression -> . letexp + (18) expression -> . caseexp + (19) expression -> . newexp + (20) expression -> . isvoidexp + (21) expression -> . aritmetica + (22) expression -> . comparison + (23) expression -> . parenexpression + (63) constantexp -> . number + (64) constantexp -> . string + (65) constantexp -> . true + (66) constantexp -> . false + (67) identifier -> . id + (68) assignment -> . id assign expression + (35) dispatch -> . id lparen rparen + (36) dispatch -> . id lparen expression expressionparams rparen + (37) dispatch -> . expression point id lparen rparen + (38) dispatch -> . expression point id lparen expression expressionparams rparen + (39) dispatch -> . expression arroba type point id lparen rparen + (40) dispatch -> . expression arroba type point id lparen expression expressionparams rparen + (43) conditional -> . if expression then expression else expression fi + (44) loopexp -> . while expression loop expression pool + (45) blockexp -> . lbracket expressionlist rbracket + (46) letexp -> . let attribute letattributelist in expression + (47) caseexp -> . case expression of subcase listcase esac + (51) newexp -> . new type + (52) isvoidexp -> . isvoid expression + (53) aritmetica -> . expression plus expression + (54) aritmetica -> . expression minus expression + (55) aritmetica -> . expression mult expression + (56) aritmetica -> . expression div expression + (57) aritmetica -> . intnot expression + (58) comparison -> . expression less expression + (59) comparison -> . expression lesse expression + (60) comparison -> . expression equal expression + (61) comparison -> . not expression + (62) parenexpression -> . lparen expression rparen + + number shift and go to state 51 + string shift and go to state 52 + true shift and go to state 53 + false shift and go to state 54 + id shift and go to state 35 + if shift and go to state 56 + while shift and go to state 57 + lbracket shift and go to state 58 + let shift and go to state 59 + case shift and go to state 60 + new shift and go to state 61 + isvoid shift and go to state 62 + intnot shift and go to state 63 + not shift and go to state 64 + lparen shift and go to state 55 + + expression shift and go to state 118 + constantexp shift and go to state 37 + identifier shift and go to state 38 + assignment shift and go to state 39 + dispatch shift and go to state 40 + conditional shift and go to state 41 + loopexp shift and go to state 42 + blockexp shift and go to state 43 + letexp shift and go to state 44 + caseexp shift and go to state 45 + newexp shift and go to state 46 + isvoidexp shift and go to state 47 + aritmetica shift and go to state 48 + comparison shift and go to state 49 + parenexpression shift and go to state 50 + +state 95 + + (25) methoddef -> id lparen param paramslistdef rparen dpoint . type lbracket expression rbracket + + type shift and go to state 119 + + +state 96 + + (33) paramslistdef -> coma param paramslistdef . + + rparen reduce using rule 33 (paramslistdef -> coma param paramslistdef .) + + +state 97 + + (68) assignment -> id assign expression . + (37) dispatch -> expression . point id lparen rparen + (38) dispatch -> expression . point id lparen expression expressionparams rparen + (39) dispatch -> expression . arroba type point id lparen rparen + (40) dispatch -> expression . arroba type point id lparen expression expressionparams rparen + (53) aritmetica -> expression . plus expression + (54) aritmetica -> expression . minus expression + (55) aritmetica -> expression . mult expression + (56) aritmetica -> expression . div expression + (58) comparison -> expression . less expression + (59) comparison -> expression . lesse expression + (60) comparison -> expression . equal expression + + pcoma reduce using rule 68 (assignment -> id assign expression .) + coma reduce using rule 68 (assignment -> id assign expression .) + in reduce using rule 68 (assignment -> id assign expression .) + rparen reduce using rule 68 (assignment -> id assign expression .) + then reduce using rule 68 (assignment -> id assign expression .) + loop reduce using rule 68 (assignment -> id assign expression .) + of reduce using rule 68 (assignment -> id assign expression .) + rbracket reduce using rule 68 (assignment -> id assign expression .) + else reduce using rule 68 (assignment -> id assign expression .) + pool reduce using rule 68 (assignment -> id assign expression .) + fi reduce using rule 68 (assignment -> id assign expression .) + point shift and go to state 72 + arroba shift and go to state 73 + plus shift and go to state 74 + minus shift and go to state 75 + mult shift and go to state 76 + div shift and go to state 77 + less shift and go to state 78 + lesse shift and go to state 79 + equal shift and go to state 80 + + ! point [ reduce using rule 68 (assignment -> id assign expression .) ] + ! arroba [ reduce using rule 68 (assignment -> id assign expression .) ] + ! plus [ reduce using rule 68 (assignment -> id assign expression .) ] + ! minus [ reduce using rule 68 (assignment -> id assign expression .) ] + ! mult [ reduce using rule 68 (assignment -> id assign expression .) ] + ! div [ reduce using rule 68 (assignment -> id assign expression .) ] + ! less [ reduce using rule 68 (assignment -> id assign expression .) ] + ! lesse [ reduce using rule 68 (assignment -> id assign expression .) ] + ! equal [ reduce using rule 68 (assignment -> id assign expression .) ] + + +state 98 + + (35) dispatch -> id lparen rparen . + + point reduce using rule 35 (dispatch -> id lparen rparen .) + arroba reduce using rule 35 (dispatch -> id lparen rparen .) + plus reduce using rule 35 (dispatch -> id lparen rparen .) + minus reduce using rule 35 (dispatch -> id lparen rparen .) + mult reduce using rule 35 (dispatch -> id lparen rparen .) + div reduce using rule 35 (dispatch -> id lparen rparen .) + less reduce using rule 35 (dispatch -> id lparen rparen .) + lesse reduce using rule 35 (dispatch -> id lparen rparen .) + equal reduce using rule 35 (dispatch -> id lparen rparen .) + pcoma reduce using rule 35 (dispatch -> id lparen rparen .) + coma reduce using rule 35 (dispatch -> id lparen rparen .) + in reduce using rule 35 (dispatch -> id lparen rparen .) + rparen reduce using rule 35 (dispatch -> id lparen rparen .) + then reduce using rule 35 (dispatch -> id lparen rparen .) + loop reduce using rule 35 (dispatch -> id lparen rparen .) + of reduce using rule 35 (dispatch -> id lparen rparen .) + rbracket reduce using rule 35 (dispatch -> id lparen rparen .) + else reduce using rule 35 (dispatch -> id lparen rparen .) + pool reduce using rule 35 (dispatch -> id lparen rparen .) + fi reduce using rule 35 (dispatch -> id lparen rparen .) + + +state 99 + + (36) dispatch -> id lparen expression . expressionparams rparen + (37) dispatch -> expression . point id lparen rparen + (38) dispatch -> expression . point id lparen expression expressionparams rparen + (39) dispatch -> expression . arroba type point id lparen rparen + (40) dispatch -> expression . arroba type point id lparen expression expressionparams rparen + (53) aritmetica -> expression . plus expression + (54) aritmetica -> expression . minus expression + (55) aritmetica -> expression . mult expression + (56) aritmetica -> expression . div expression + (58) comparison -> expression . less expression + (59) comparison -> expression . lesse expression + (60) comparison -> expression . equal expression + (41) expressionparams -> . coma expression expressionparams + (42) expressionparams -> . empty + (3) empty -> . + + point shift and go to state 72 + arroba shift and go to state 73 + plus shift and go to state 74 + minus shift and go to state 75 + mult shift and go to state 76 + div shift and go to state 77 + less shift and go to state 78 + lesse shift and go to state 79 + equal shift and go to state 80 + coma shift and go to state 121 + rparen reduce using rule 3 (empty -> .) + + expressionparams shift and go to state 120 + empty shift and go to state 122 + +state 100 + + (37) dispatch -> expression point id . lparen rparen + (38) dispatch -> expression point id . lparen expression expressionparams rparen + + lparen shift and go to state 123 + + +state 101 + + (39) dispatch -> expression arroba type . point id lparen rparen + (40) dispatch -> expression arroba type . point id lparen expression expressionparams rparen + + point shift and go to state 124 + + +state 102 + + (53) aritmetica -> expression plus expression . + (37) dispatch -> expression . point id lparen rparen + (38) dispatch -> expression . point id lparen expression expressionparams rparen + (39) dispatch -> expression . arroba type point id lparen rparen + (40) dispatch -> expression . arroba type point id lparen expression expressionparams rparen + (53) aritmetica -> expression . plus expression + (54) aritmetica -> expression . minus expression + (55) aritmetica -> expression . mult expression + (56) aritmetica -> expression . div expression + (58) comparison -> expression . less expression + (59) comparison -> expression . lesse expression + (60) comparison -> expression . equal expression + + plus reduce using rule 53 (aritmetica -> expression plus expression .) + minus reduce using rule 53 (aritmetica -> expression plus expression .) + less reduce using rule 53 (aritmetica -> expression plus expression .) + lesse reduce using rule 53 (aritmetica -> expression plus expression .) + equal reduce using rule 53 (aritmetica -> expression plus expression .) + pcoma reduce using rule 53 (aritmetica -> expression plus expression .) + coma reduce using rule 53 (aritmetica -> expression plus expression .) + in reduce using rule 53 (aritmetica -> expression plus expression .) + rparen reduce using rule 53 (aritmetica -> expression plus expression .) + then reduce using rule 53 (aritmetica -> expression plus expression .) + loop reduce using rule 53 (aritmetica -> expression plus expression .) + of reduce using rule 53 (aritmetica -> expression plus expression .) + rbracket reduce using rule 53 (aritmetica -> expression plus expression .) + else reduce using rule 53 (aritmetica -> expression plus expression .) + pool reduce using rule 53 (aritmetica -> expression plus expression .) + fi reduce using rule 53 (aritmetica -> expression plus expression .) + point shift and go to state 72 + arroba shift and go to state 73 + mult shift and go to state 76 + div shift and go to state 77 + + ! point [ reduce using rule 53 (aritmetica -> expression plus expression .) ] + ! arroba [ reduce using rule 53 (aritmetica -> expression plus expression .) ] + ! mult [ reduce using rule 53 (aritmetica -> expression plus expression .) ] + ! div [ reduce using rule 53 (aritmetica -> expression plus expression .) ] + ! plus [ shift and go to state 74 ] + ! minus [ shift and go to state 75 ] + ! less [ shift and go to state 78 ] + ! lesse [ shift and go to state 79 ] + ! equal [ shift and go to state 80 ] + + +state 103 + + (54) aritmetica -> expression minus expression . + (37) dispatch -> expression . point id lparen rparen + (38) dispatch -> expression . point id lparen expression expressionparams rparen + (39) dispatch -> expression . arroba type point id lparen rparen + (40) dispatch -> expression . arroba type point id lparen expression expressionparams rparen + (53) aritmetica -> expression . plus expression + (54) aritmetica -> expression . minus expression + (55) aritmetica -> expression . mult expression + (56) aritmetica -> expression . div expression + (58) comparison -> expression . less expression + (59) comparison -> expression . lesse expression + (60) comparison -> expression . equal expression + + plus reduce using rule 54 (aritmetica -> expression minus expression .) + minus reduce using rule 54 (aritmetica -> expression minus expression .) + less reduce using rule 54 (aritmetica -> expression minus expression .) + lesse reduce using rule 54 (aritmetica -> expression minus expression .) + equal reduce using rule 54 (aritmetica -> expression minus expression .) + pcoma reduce using rule 54 (aritmetica -> expression minus expression .) + coma reduce using rule 54 (aritmetica -> expression minus expression .) + in reduce using rule 54 (aritmetica -> expression minus expression .) + rparen reduce using rule 54 (aritmetica -> expression minus expression .) + then reduce using rule 54 (aritmetica -> expression minus expression .) + loop reduce using rule 54 (aritmetica -> expression minus expression .) + of reduce using rule 54 (aritmetica -> expression minus expression .) + rbracket reduce using rule 54 (aritmetica -> expression minus expression .) + else reduce using rule 54 (aritmetica -> expression minus expression .) + pool reduce using rule 54 (aritmetica -> expression minus expression .) + fi reduce using rule 54 (aritmetica -> expression minus expression .) + point shift and go to state 72 + arroba shift and go to state 73 + mult shift and go to state 76 + div shift and go to state 77 + + ! point [ reduce using rule 54 (aritmetica -> expression minus expression .) ] + ! arroba [ reduce using rule 54 (aritmetica -> expression minus expression .) ] + ! mult [ reduce using rule 54 (aritmetica -> expression minus expression .) ] + ! div [ reduce using rule 54 (aritmetica -> expression minus expression .) ] + ! plus [ shift and go to state 74 ] + ! minus [ shift and go to state 75 ] + ! less [ shift and go to state 78 ] + ! lesse [ shift and go to state 79 ] + ! equal [ shift and go to state 80 ] + + +state 104 + + (55) aritmetica -> expression mult expression . + (37) dispatch -> expression . point id lparen rparen + (38) dispatch -> expression . point id lparen expression expressionparams rparen + (39) dispatch -> expression . arroba type point id lparen rparen + (40) dispatch -> expression . arroba type point id lparen expression expressionparams rparen + (53) aritmetica -> expression . plus expression + (54) aritmetica -> expression . minus expression + (55) aritmetica -> expression . mult expression + (56) aritmetica -> expression . div expression + (58) comparison -> expression . less expression + (59) comparison -> expression . lesse expression + (60) comparison -> expression . equal expression + + plus reduce using rule 55 (aritmetica -> expression mult expression .) + minus reduce using rule 55 (aritmetica -> expression mult expression .) + mult reduce using rule 55 (aritmetica -> expression mult expression .) + div reduce using rule 55 (aritmetica -> expression mult expression .) + less reduce using rule 55 (aritmetica -> expression mult expression .) + lesse reduce using rule 55 (aritmetica -> expression mult expression .) + equal reduce using rule 55 (aritmetica -> expression mult expression .) + pcoma reduce using rule 55 (aritmetica -> expression mult expression .) + coma reduce using rule 55 (aritmetica -> expression mult expression .) + in reduce using rule 55 (aritmetica -> expression mult expression .) + rparen reduce using rule 55 (aritmetica -> expression mult expression .) + then reduce using rule 55 (aritmetica -> expression mult expression .) + loop reduce using rule 55 (aritmetica -> expression mult expression .) + of reduce using rule 55 (aritmetica -> expression mult expression .) + rbracket reduce using rule 55 (aritmetica -> expression mult expression .) + else reduce using rule 55 (aritmetica -> expression mult expression .) + pool reduce using rule 55 (aritmetica -> expression mult expression .) + fi reduce using rule 55 (aritmetica -> expression mult expression .) + point shift and go to state 72 + arroba shift and go to state 73 + + ! point [ reduce using rule 55 (aritmetica -> expression mult expression .) ] + ! arroba [ reduce using rule 55 (aritmetica -> expression mult expression .) ] + ! plus [ shift and go to state 74 ] + ! minus [ shift and go to state 75 ] + ! mult [ shift and go to state 76 ] + ! div [ shift and go to state 77 ] + ! less [ shift and go to state 78 ] + ! lesse [ shift and go to state 79 ] + ! equal [ shift and go to state 80 ] + + +state 105 + + (56) aritmetica -> expression div expression . + (37) dispatch -> expression . point id lparen rparen + (38) dispatch -> expression . point id lparen expression expressionparams rparen + (39) dispatch -> expression . arroba type point id lparen rparen + (40) dispatch -> expression . arroba type point id lparen expression expressionparams rparen + (53) aritmetica -> expression . plus expression + (54) aritmetica -> expression . minus expression + (55) aritmetica -> expression . mult expression + (56) aritmetica -> expression . div expression + (58) comparison -> expression . less expression + (59) comparison -> expression . lesse expression + (60) comparison -> expression . equal expression + + plus reduce using rule 56 (aritmetica -> expression div expression .) + minus reduce using rule 56 (aritmetica -> expression div expression .) + mult reduce using rule 56 (aritmetica -> expression div expression .) + div reduce using rule 56 (aritmetica -> expression div expression .) + less reduce using rule 56 (aritmetica -> expression div expression .) + lesse reduce using rule 56 (aritmetica -> expression div expression .) + equal reduce using rule 56 (aritmetica -> expression div expression .) + pcoma reduce using rule 56 (aritmetica -> expression div expression .) + coma reduce using rule 56 (aritmetica -> expression div expression .) + in reduce using rule 56 (aritmetica -> expression div expression .) + rparen reduce using rule 56 (aritmetica -> expression div expression .) + then reduce using rule 56 (aritmetica -> expression div expression .) + loop reduce using rule 56 (aritmetica -> expression div expression .) + of reduce using rule 56 (aritmetica -> expression div expression .) + rbracket reduce using rule 56 (aritmetica -> expression div expression .) + else reduce using rule 56 (aritmetica -> expression div expression .) + pool reduce using rule 56 (aritmetica -> expression div expression .) + fi reduce using rule 56 (aritmetica -> expression div expression .) + point shift and go to state 72 + arroba shift and go to state 73 + + ! point [ reduce using rule 56 (aritmetica -> expression div expression .) ] + ! arroba [ reduce using rule 56 (aritmetica -> expression div expression .) ] + ! plus [ shift and go to state 74 ] + ! minus [ shift and go to state 75 ] + ! mult [ shift and go to state 76 ] + ! div [ shift and go to state 77 ] + ! less [ shift and go to state 78 ] + ! lesse [ shift and go to state 79 ] + ! equal [ shift and go to state 80 ] + + +state 106 + + (58) comparison -> expression less expression . + (37) dispatch -> expression . point id lparen rparen + (38) dispatch -> expression . point id lparen expression expressionparams rparen + (39) dispatch -> expression . arroba type point id lparen rparen + (40) dispatch -> expression . arroba type point id lparen expression expressionparams rparen + (53) aritmetica -> expression . plus expression + (54) aritmetica -> expression . minus expression + (55) aritmetica -> expression . mult expression + (56) aritmetica -> expression . div expression + (58) comparison -> expression . less expression + (59) comparison -> expression . lesse expression + (60) comparison -> expression . equal expression + + less reduce using rule 58 (comparison -> expression less expression .) + lesse reduce using rule 58 (comparison -> expression less expression .) + equal reduce using rule 58 (comparison -> expression less expression .) + pcoma reduce using rule 58 (comparison -> expression less expression .) + coma reduce using rule 58 (comparison -> expression less expression .) + in reduce using rule 58 (comparison -> expression less expression .) + rparen reduce using rule 58 (comparison -> expression less expression .) + then reduce using rule 58 (comparison -> expression less expression .) + loop reduce using rule 58 (comparison -> expression less expression .) + of reduce using rule 58 (comparison -> expression less expression .) + rbracket reduce using rule 58 (comparison -> expression less expression .) + else reduce using rule 58 (comparison -> expression less expression .) + pool reduce using rule 58 (comparison -> expression less expression .) + fi reduce using rule 58 (comparison -> expression less expression .) + point shift and go to state 72 + arroba shift and go to state 73 + plus shift and go to state 74 + minus shift and go to state 75 + mult shift and go to state 76 + div shift and go to state 77 + + ! point [ reduce using rule 58 (comparison -> expression less expression .) ] + ! arroba [ reduce using rule 58 (comparison -> expression less expression .) ] + ! plus [ reduce using rule 58 (comparison -> expression less expression .) ] + ! minus [ reduce using rule 58 (comparison -> expression less expression .) ] + ! mult [ reduce using rule 58 (comparison -> expression less expression .) ] + ! div [ reduce using rule 58 (comparison -> expression less expression .) ] + ! less [ shift and go to state 78 ] + ! lesse [ shift and go to state 79 ] + ! equal [ shift and go to state 80 ] + + +state 107 + + (59) comparison -> expression lesse expression . + (37) dispatch -> expression . point id lparen rparen + (38) dispatch -> expression . point id lparen expression expressionparams rparen + (39) dispatch -> expression . arroba type point id lparen rparen + (40) dispatch -> expression . arroba type point id lparen expression expressionparams rparen + (53) aritmetica -> expression . plus expression + (54) aritmetica -> expression . minus expression + (55) aritmetica -> expression . mult expression + (56) aritmetica -> expression . div expression + (58) comparison -> expression . less expression + (59) comparison -> expression . lesse expression + (60) comparison -> expression . equal expression + + less reduce using rule 59 (comparison -> expression lesse expression .) + lesse reduce using rule 59 (comparison -> expression lesse expression .) + equal reduce using rule 59 (comparison -> expression lesse expression .) + pcoma reduce using rule 59 (comparison -> expression lesse expression .) + coma reduce using rule 59 (comparison -> expression lesse expression .) + in reduce using rule 59 (comparison -> expression lesse expression .) + rparen reduce using rule 59 (comparison -> expression lesse expression .) + then reduce using rule 59 (comparison -> expression lesse expression .) + loop reduce using rule 59 (comparison -> expression lesse expression .) + of reduce using rule 59 (comparison -> expression lesse expression .) + rbracket reduce using rule 59 (comparison -> expression lesse expression .) + else reduce using rule 59 (comparison -> expression lesse expression .) + pool reduce using rule 59 (comparison -> expression lesse expression .) + fi reduce using rule 59 (comparison -> expression lesse expression .) + point shift and go to state 72 + arroba shift and go to state 73 + plus shift and go to state 74 + minus shift and go to state 75 + mult shift and go to state 76 + div shift and go to state 77 + + ! point [ reduce using rule 59 (comparison -> expression lesse expression .) ] + ! arroba [ reduce using rule 59 (comparison -> expression lesse expression .) ] + ! plus [ reduce using rule 59 (comparison -> expression lesse expression .) ] + ! minus [ reduce using rule 59 (comparison -> expression lesse expression .) ] + ! mult [ reduce using rule 59 (comparison -> expression lesse expression .) ] + ! div [ reduce using rule 59 (comparison -> expression lesse expression .) ] + ! less [ shift and go to state 78 ] + ! lesse [ shift and go to state 79 ] + ! equal [ shift and go to state 80 ] + + +state 108 + + (60) comparison -> expression equal expression . + (37) dispatch -> expression . point id lparen rparen + (38) dispatch -> expression . point id lparen expression expressionparams rparen + (39) dispatch -> expression . arroba type point id lparen rparen + (40) dispatch -> expression . arroba type point id lparen expression expressionparams rparen + (53) aritmetica -> expression . plus expression + (54) aritmetica -> expression . minus expression + (55) aritmetica -> expression . mult expression + (56) aritmetica -> expression . div expression + (58) comparison -> expression . less expression + (59) comparison -> expression . lesse expression + (60) comparison -> expression . equal expression + + less reduce using rule 60 (comparison -> expression equal expression .) + lesse reduce using rule 60 (comparison -> expression equal expression .) + equal reduce using rule 60 (comparison -> expression equal expression .) + pcoma reduce using rule 60 (comparison -> expression equal expression .) + coma reduce using rule 60 (comparison -> expression equal expression .) + in reduce using rule 60 (comparison -> expression equal expression .) + rparen reduce using rule 60 (comparison -> expression equal expression .) + then reduce using rule 60 (comparison -> expression equal expression .) + loop reduce using rule 60 (comparison -> expression equal expression .) + of reduce using rule 60 (comparison -> expression equal expression .) + rbracket reduce using rule 60 (comparison -> expression equal expression .) + else reduce using rule 60 (comparison -> expression equal expression .) + pool reduce using rule 60 (comparison -> expression equal expression .) + fi reduce using rule 60 (comparison -> expression equal expression .) + point shift and go to state 72 + arroba shift and go to state 73 + plus shift and go to state 74 + minus shift and go to state 75 + mult shift and go to state 76 + div shift and go to state 77 + + ! point [ reduce using rule 60 (comparison -> expression equal expression .) ] + ! arroba [ reduce using rule 60 (comparison -> expression equal expression .) ] + ! plus [ reduce using rule 60 (comparison -> expression equal expression .) ] + ! minus [ reduce using rule 60 (comparison -> expression equal expression .) ] + ! mult [ reduce using rule 60 (comparison -> expression equal expression .) ] + ! div [ reduce using rule 60 (comparison -> expression equal expression .) ] + ! less [ shift and go to state 78 ] + ! lesse [ shift and go to state 79 ] + ! equal [ shift and go to state 80 ] + + +state 109 + + (62) parenexpression -> lparen expression rparen . + + point reduce using rule 62 (parenexpression -> lparen expression rparen .) + arroba reduce using rule 62 (parenexpression -> lparen expression rparen .) + plus reduce using rule 62 (parenexpression -> lparen expression rparen .) + minus reduce using rule 62 (parenexpression -> lparen expression rparen .) + mult reduce using rule 62 (parenexpression -> lparen expression rparen .) + div reduce using rule 62 (parenexpression -> lparen expression rparen .) + less reduce using rule 62 (parenexpression -> lparen expression rparen .) + lesse reduce using rule 62 (parenexpression -> lparen expression rparen .) + equal reduce using rule 62 (parenexpression -> lparen expression rparen .) + pcoma reduce using rule 62 (parenexpression -> lparen expression rparen .) + coma reduce using rule 62 (parenexpression -> lparen expression rparen .) + in reduce using rule 62 (parenexpression -> lparen expression rparen .) + rparen reduce using rule 62 (parenexpression -> lparen expression rparen .) + then reduce using rule 62 (parenexpression -> lparen expression rparen .) + loop reduce using rule 62 (parenexpression -> lparen expression rparen .) + of reduce using rule 62 (parenexpression -> lparen expression rparen .) + rbracket reduce using rule 62 (parenexpression -> lparen expression rparen .) + else reduce using rule 62 (parenexpression -> lparen expression rparen .) + pool reduce using rule 62 (parenexpression -> lparen expression rparen .) + fi reduce using rule 62 (parenexpression -> lparen expression rparen .) + + +state 110 + + (43) conditional -> if expression then . expression else expression fi + (10) expression -> . constantexp + (11) expression -> . identifier + (12) expression -> . assignment + (13) expression -> . dispatch + (14) expression -> . conditional + (15) expression -> . loopexp + (16) expression -> . blockexp + (17) expression -> . letexp + (18) expression -> . caseexp + (19) expression -> . newexp + (20) expression -> . isvoidexp + (21) expression -> . aritmetica + (22) expression -> . comparison + (23) expression -> . parenexpression + (63) constantexp -> . number + (64) constantexp -> . string + (65) constantexp -> . true + (66) constantexp -> . false + (67) identifier -> . id + (68) assignment -> . id assign expression + (35) dispatch -> . id lparen rparen + (36) dispatch -> . id lparen expression expressionparams rparen + (37) dispatch -> . expression point id lparen rparen + (38) dispatch -> . expression point id lparen expression expressionparams rparen + (39) dispatch -> . expression arroba type point id lparen rparen + (40) dispatch -> . expression arroba type point id lparen expression expressionparams rparen + (43) conditional -> . if expression then expression else expression fi + (44) loopexp -> . while expression loop expression pool + (45) blockexp -> . lbracket expressionlist rbracket + (46) letexp -> . let attribute letattributelist in expression + (47) caseexp -> . case expression of subcase listcase esac + (51) newexp -> . new type + (52) isvoidexp -> . isvoid expression + (53) aritmetica -> . expression plus expression + (54) aritmetica -> . expression minus expression + (55) aritmetica -> . expression mult expression + (56) aritmetica -> . expression div expression + (57) aritmetica -> . intnot expression + (58) comparison -> . expression less expression + (59) comparison -> . expression lesse expression + (60) comparison -> . expression equal expression + (61) comparison -> . not expression + (62) parenexpression -> . lparen expression rparen + + number shift and go to state 51 + string shift and go to state 52 + true shift and go to state 53 + false shift and go to state 54 + id shift and go to state 35 + if shift and go to state 56 + while shift and go to state 57 + lbracket shift and go to state 58 + let shift and go to state 59 + case shift and go to state 60 + new shift and go to state 61 + isvoid shift and go to state 62 + intnot shift and go to state 63 + not shift and go to state 64 + lparen shift and go to state 55 + + expression shift and go to state 125 + constantexp shift and go to state 37 + identifier shift and go to state 38 + assignment shift and go to state 39 + dispatch shift and go to state 40 + conditional shift and go to state 41 + loopexp shift and go to state 42 + blockexp shift and go to state 43 + letexp shift and go to state 44 + caseexp shift and go to state 45 + newexp shift and go to state 46 + isvoidexp shift and go to state 47 + aritmetica shift and go to state 48 + comparison shift and go to state 49 + parenexpression shift and go to state 50 + +state 111 + + (44) loopexp -> while expression loop . expression pool + (10) expression -> . constantexp + (11) expression -> . identifier + (12) expression -> . assignment + (13) expression -> . dispatch + (14) expression -> . conditional + (15) expression -> . loopexp + (16) expression -> . blockexp + (17) expression -> . letexp + (18) expression -> . caseexp + (19) expression -> . newexp + (20) expression -> . isvoidexp + (21) expression -> . aritmetica + (22) expression -> . comparison + (23) expression -> . parenexpression + (63) constantexp -> . number + (64) constantexp -> . string + (65) constantexp -> . true + (66) constantexp -> . false + (67) identifier -> . id + (68) assignment -> . id assign expression + (35) dispatch -> . id lparen rparen + (36) dispatch -> . id lparen expression expressionparams rparen + (37) dispatch -> . expression point id lparen rparen + (38) dispatch -> . expression point id lparen expression expressionparams rparen + (39) dispatch -> . expression arroba type point id lparen rparen + (40) dispatch -> . expression arroba type point id lparen expression expressionparams rparen + (43) conditional -> . if expression then expression else expression fi + (44) loopexp -> . while expression loop expression pool + (45) blockexp -> . lbracket expressionlist rbracket + (46) letexp -> . let attribute letattributelist in expression + (47) caseexp -> . case expression of subcase listcase esac + (51) newexp -> . new type + (52) isvoidexp -> . isvoid expression + (53) aritmetica -> . expression plus expression + (54) aritmetica -> . expression minus expression + (55) aritmetica -> . expression mult expression + (56) aritmetica -> . expression div expression + (57) aritmetica -> . intnot expression + (58) comparison -> . expression less expression + (59) comparison -> . expression lesse expression + (60) comparison -> . expression equal expression + (61) comparison -> . not expression + (62) parenexpression -> . lparen expression rparen + + number shift and go to state 51 + string shift and go to state 52 + true shift and go to state 53 + false shift and go to state 54 + id shift and go to state 35 + if shift and go to state 56 + while shift and go to state 57 + lbracket shift and go to state 58 + let shift and go to state 59 + case shift and go to state 60 + new shift and go to state 61 + isvoid shift and go to state 62 + intnot shift and go to state 63 + not shift and go to state 64 + lparen shift and go to state 55 + + expression shift and go to state 126 + constantexp shift and go to state 37 + identifier shift and go to state 38 + assignment shift and go to state 39 + dispatch shift and go to state 40 + conditional shift and go to state 41 + loopexp shift and go to state 42 + blockexp shift and go to state 43 + letexp shift and go to state 44 + caseexp shift and go to state 45 + newexp shift and go to state 46 + isvoidexp shift and go to state 47 + aritmetica shift and go to state 48 + comparison shift and go to state 49 + parenexpression shift and go to state 50 + +state 112 + + (45) blockexp -> lbracket expressionlist rbracket . + + point reduce using rule 45 (blockexp -> lbracket expressionlist rbracket .) + arroba reduce using rule 45 (blockexp -> lbracket expressionlist rbracket .) + plus reduce using rule 45 (blockexp -> lbracket expressionlist rbracket .) + minus reduce using rule 45 (blockexp -> lbracket expressionlist rbracket .) + mult reduce using rule 45 (blockexp -> lbracket expressionlist rbracket .) + div reduce using rule 45 (blockexp -> lbracket expressionlist rbracket .) + less reduce using rule 45 (blockexp -> lbracket expressionlist rbracket .) + lesse reduce using rule 45 (blockexp -> lbracket expressionlist rbracket .) + equal reduce using rule 45 (blockexp -> lbracket expressionlist rbracket .) + pcoma reduce using rule 45 (blockexp -> lbracket expressionlist rbracket .) + coma reduce using rule 45 (blockexp -> lbracket expressionlist rbracket .) + in reduce using rule 45 (blockexp -> lbracket expressionlist rbracket .) + rparen reduce using rule 45 (blockexp -> lbracket expressionlist rbracket .) + then reduce using rule 45 (blockexp -> lbracket expressionlist rbracket .) + loop reduce using rule 45 (blockexp -> lbracket expressionlist rbracket .) + of reduce using rule 45 (blockexp -> lbracket expressionlist rbracket .) + rbracket reduce using rule 45 (blockexp -> lbracket expressionlist rbracket .) + else reduce using rule 45 (blockexp -> lbracket expressionlist rbracket .) + pool reduce using rule 45 (blockexp -> lbracket expressionlist rbracket .) + fi reduce using rule 45 (blockexp -> lbracket expressionlist rbracket .) + + +state 113 + + (26) expressionlist -> expression pcoma . expressionlist + (26) expressionlist -> . expression pcoma expressionlist + (27) expressionlist -> . empty + (10) expression -> . constantexp + (11) expression -> . identifier + (12) expression -> . assignment + (13) expression -> . dispatch + (14) expression -> . conditional + (15) expression -> . loopexp + (16) expression -> . blockexp + (17) expression -> . letexp + (18) expression -> . caseexp + (19) expression -> . newexp + (20) expression -> . isvoidexp + (21) expression -> . aritmetica + (22) expression -> . comparison + (23) expression -> . parenexpression + (3) empty -> . + (63) constantexp -> . number + (64) constantexp -> . string + (65) constantexp -> . true + (66) constantexp -> . false + (67) identifier -> . id + (68) assignment -> . id assign expression + (35) dispatch -> . id lparen rparen + (36) dispatch -> . id lparen expression expressionparams rparen + (37) dispatch -> . expression point id lparen rparen + (38) dispatch -> . expression point id lparen expression expressionparams rparen + (39) dispatch -> . expression arroba type point id lparen rparen + (40) dispatch -> . expression arroba type point id lparen expression expressionparams rparen + (43) conditional -> . if expression then expression else expression fi + (44) loopexp -> . while expression loop expression pool + (45) blockexp -> . lbracket expressionlist rbracket + (46) letexp -> . let attribute letattributelist in expression + (47) caseexp -> . case expression of subcase listcase esac + (51) newexp -> . new type + (52) isvoidexp -> . isvoid expression + (53) aritmetica -> . expression plus expression + (54) aritmetica -> . expression minus expression + (55) aritmetica -> . expression mult expression + (56) aritmetica -> . expression div expression + (57) aritmetica -> . intnot expression + (58) comparison -> . expression less expression + (59) comparison -> . expression lesse expression + (60) comparison -> . expression equal expression + (61) comparison -> . not expression + (62) parenexpression -> . lparen expression rparen + + rbracket reduce using rule 3 (empty -> .) + number shift and go to state 51 + string shift and go to state 52 + true shift and go to state 53 + false shift and go to state 54 + id shift and go to state 35 + if shift and go to state 56 + while shift and go to state 57 + lbracket shift and go to state 58 + let shift and go to state 59 + case shift and go to state 60 + new shift and go to state 61 + isvoid shift and go to state 62 + intnot shift and go to state 63 + not shift and go to state 64 + lparen shift and go to state 55 + + expression shift and go to state 85 + expressionlist shift and go to state 127 + empty shift and go to state 86 + constantexp shift and go to state 37 + identifier shift and go to state 38 + assignment shift and go to state 39 + dispatch shift and go to state 40 + conditional shift and go to state 41 + loopexp shift and go to state 42 + blockexp shift and go to state 43 + letexp shift and go to state 44 + caseexp shift and go to state 45 + newexp shift and go to state 46 + isvoidexp shift and go to state 47 + aritmetica shift and go to state 48 + comparison shift and go to state 49 + parenexpression shift and go to state 50 + +state 114 + + (46) letexp -> let attribute letattributelist . in expression + + in shift and go to state 128 + + +state 115 + + (31) letattributelist -> coma . attribute letattributelist + (29) attribute -> . id dpoint type + (30) attribute -> . id dpoint type assign expression + + id shift and go to state 88 + + attribute shift and go to state 129 + +state 116 + + (32) letattributelist -> empty . + + in reduce using rule 32 (letattributelist -> empty .) + + +state 117 + + (47) caseexp -> case expression of . subcase listcase esac + (50) subcase -> . id dpoint type implica expression pcoma + + id shift and go to state 131 + + subcase shift and go to state 130 + +state 118 + + (24) methoddef -> id lparen rparen dpoint type lbracket expression . rbracket + (37) dispatch -> expression . point id lparen rparen + (38) dispatch -> expression . point id lparen expression expressionparams rparen + (39) dispatch -> expression . arroba type point id lparen rparen + (40) dispatch -> expression . arroba type point id lparen expression expressionparams rparen + (53) aritmetica -> expression . plus expression + (54) aritmetica -> expression . minus expression + (55) aritmetica -> expression . mult expression + (56) aritmetica -> expression . div expression + (58) comparison -> expression . less expression + (59) comparison -> expression . lesse expression + (60) comparison -> expression . equal expression + + rbracket shift and go to state 132 + point shift and go to state 72 + arroba shift and go to state 73 + plus shift and go to state 74 + minus shift and go to state 75 + mult shift and go to state 76 + div shift and go to state 77 + less shift and go to state 78 + lesse shift and go to state 79 + equal shift and go to state 80 + + +state 119 + + (25) methoddef -> id lparen param paramslistdef rparen dpoint type . lbracket expression rbracket + + lbracket shift and go to state 133 + + +state 120 + + (36) dispatch -> id lparen expression expressionparams . rparen + + rparen shift and go to state 134 + + +state 121 + + (41) expressionparams -> coma . expression expressionparams + (10) expression -> . constantexp + (11) expression -> . identifier + (12) expression -> . assignment + (13) expression -> . dispatch + (14) expression -> . conditional + (15) expression -> . loopexp + (16) expression -> . blockexp + (17) expression -> . letexp + (18) expression -> . caseexp + (19) expression -> . newexp + (20) expression -> . isvoidexp + (21) expression -> . aritmetica + (22) expression -> . comparison + (23) expression -> . parenexpression + (63) constantexp -> . number + (64) constantexp -> . string + (65) constantexp -> . true + (66) constantexp -> . false + (67) identifier -> . id + (68) assignment -> . id assign expression + (35) dispatch -> . id lparen rparen + (36) dispatch -> . id lparen expression expressionparams rparen + (37) dispatch -> . expression point id lparen rparen + (38) dispatch -> . expression point id lparen expression expressionparams rparen + (39) dispatch -> . expression arroba type point id lparen rparen + (40) dispatch -> . expression arroba type point id lparen expression expressionparams rparen + (43) conditional -> . if expression then expression else expression fi + (44) loopexp -> . while expression loop expression pool + (45) blockexp -> . lbracket expressionlist rbracket + (46) letexp -> . let attribute letattributelist in expression + (47) caseexp -> . case expression of subcase listcase esac + (51) newexp -> . new type + (52) isvoidexp -> . isvoid expression + (53) aritmetica -> . expression plus expression + (54) aritmetica -> . expression minus expression + (55) aritmetica -> . expression mult expression + (56) aritmetica -> . expression div expression + (57) aritmetica -> . intnot expression + (58) comparison -> . expression less expression + (59) comparison -> . expression lesse expression + (60) comparison -> . expression equal expression + (61) comparison -> . not expression + (62) parenexpression -> . lparen expression rparen + + number shift and go to state 51 + string shift and go to state 52 + true shift and go to state 53 + false shift and go to state 54 + id shift and go to state 35 + if shift and go to state 56 + while shift and go to state 57 + lbracket shift and go to state 58 + let shift and go to state 59 + case shift and go to state 60 + new shift and go to state 61 + isvoid shift and go to state 62 + intnot shift and go to state 63 + not shift and go to state 64 + lparen shift and go to state 55 + + expression shift and go to state 135 + constantexp shift and go to state 37 + identifier shift and go to state 38 + assignment shift and go to state 39 + dispatch shift and go to state 40 + conditional shift and go to state 41 + loopexp shift and go to state 42 + blockexp shift and go to state 43 + letexp shift and go to state 44 + caseexp shift and go to state 45 + newexp shift and go to state 46 + isvoidexp shift and go to state 47 + aritmetica shift and go to state 48 + comparison shift and go to state 49 + parenexpression shift and go to state 50 + +state 122 + + (42) expressionparams -> empty . + + rparen reduce using rule 42 (expressionparams -> empty .) + + +state 123 + + (37) dispatch -> expression point id lparen . rparen + (38) dispatch -> expression point id lparen . expression expressionparams rparen + (10) expression -> . constantexp + (11) expression -> . identifier + (12) expression -> . assignment + (13) expression -> . dispatch + (14) expression -> . conditional + (15) expression -> . loopexp + (16) expression -> . blockexp + (17) expression -> . letexp + (18) expression -> . caseexp + (19) expression -> . newexp + (20) expression -> . isvoidexp + (21) expression -> . aritmetica + (22) expression -> . comparison + (23) expression -> . parenexpression + (63) constantexp -> . number + (64) constantexp -> . string + (65) constantexp -> . true + (66) constantexp -> . false + (67) identifier -> . id + (68) assignment -> . id assign expression + (35) dispatch -> . id lparen rparen + (36) dispatch -> . id lparen expression expressionparams rparen + (37) dispatch -> . expression point id lparen rparen + (38) dispatch -> . expression point id lparen expression expressionparams rparen + (39) dispatch -> . expression arroba type point id lparen rparen + (40) dispatch -> . expression arroba type point id lparen expression expressionparams rparen + (43) conditional -> . if expression then expression else expression fi + (44) loopexp -> . while expression loop expression pool + (45) blockexp -> . lbracket expressionlist rbracket + (46) letexp -> . let attribute letattributelist in expression + (47) caseexp -> . case expression of subcase listcase esac + (51) newexp -> . new type + (52) isvoidexp -> . isvoid expression + (53) aritmetica -> . expression plus expression + (54) aritmetica -> . expression minus expression + (55) aritmetica -> . expression mult expression + (56) aritmetica -> . expression div expression + (57) aritmetica -> . intnot expression + (58) comparison -> . expression less expression + (59) comparison -> . expression lesse expression + (60) comparison -> . expression equal expression + (61) comparison -> . not expression + (62) parenexpression -> . lparen expression rparen + + rparen shift and go to state 137 + number shift and go to state 51 + string shift and go to state 52 + true shift and go to state 53 + false shift and go to state 54 + id shift and go to state 35 + if shift and go to state 56 + while shift and go to state 57 + lbracket shift and go to state 58 + let shift and go to state 59 + case shift and go to state 60 + new shift and go to state 61 + isvoid shift and go to state 62 + intnot shift and go to state 63 + not shift and go to state 64 + lparen shift and go to state 55 + + expression shift and go to state 136 + constantexp shift and go to state 37 + identifier shift and go to state 38 + assignment shift and go to state 39 + dispatch shift and go to state 40 + conditional shift and go to state 41 + loopexp shift and go to state 42 + blockexp shift and go to state 43 + letexp shift and go to state 44 + caseexp shift and go to state 45 + newexp shift and go to state 46 + isvoidexp shift and go to state 47 + aritmetica shift and go to state 48 + comparison shift and go to state 49 + parenexpression shift and go to state 50 + +state 124 + + (39) dispatch -> expression arroba type point . id lparen rparen + (40) dispatch -> expression arroba type point . id lparen expression expressionparams rparen + + id shift and go to state 138 + + +state 125 + + (43) conditional -> if expression then expression . else expression fi + (37) dispatch -> expression . point id lparen rparen + (38) dispatch -> expression . point id lparen expression expressionparams rparen + (39) dispatch -> expression . arroba type point id lparen rparen + (40) dispatch -> expression . arroba type point id lparen expression expressionparams rparen + (53) aritmetica -> expression . plus expression + (54) aritmetica -> expression . minus expression + (55) aritmetica -> expression . mult expression + (56) aritmetica -> expression . div expression + (58) comparison -> expression . less expression + (59) comparison -> expression . lesse expression + (60) comparison -> expression . equal expression + + else shift and go to state 139 + point shift and go to state 72 + arroba shift and go to state 73 + plus shift and go to state 74 + minus shift and go to state 75 + mult shift and go to state 76 + div shift and go to state 77 + less shift and go to state 78 + lesse shift and go to state 79 + equal shift and go to state 80 + + +state 126 + + (44) loopexp -> while expression loop expression . pool + (37) dispatch -> expression . point id lparen rparen + (38) dispatch -> expression . point id lparen expression expressionparams rparen + (39) dispatch -> expression . arroba type point id lparen rparen + (40) dispatch -> expression . arroba type point id lparen expression expressionparams rparen + (53) aritmetica -> expression . plus expression + (54) aritmetica -> expression . minus expression + (55) aritmetica -> expression . mult expression + (56) aritmetica -> expression . div expression + (58) comparison -> expression . less expression + (59) comparison -> expression . lesse expression + (60) comparison -> expression . equal expression + + pool shift and go to state 140 + point shift and go to state 72 + arroba shift and go to state 73 + plus shift and go to state 74 + minus shift and go to state 75 + mult shift and go to state 76 + div shift and go to state 77 + less shift and go to state 78 + lesse shift and go to state 79 + equal shift and go to state 80 + + +state 127 + + (26) expressionlist -> expression pcoma expressionlist . + + rbracket reduce using rule 26 (expressionlist -> expression pcoma expressionlist .) + + +state 128 + + (46) letexp -> let attribute letattributelist in . expression + (10) expression -> . constantexp + (11) expression -> . identifier + (12) expression -> . assignment + (13) expression -> . dispatch + (14) expression -> . conditional + (15) expression -> . loopexp + (16) expression -> . blockexp + (17) expression -> . letexp + (18) expression -> . caseexp + (19) expression -> . newexp + (20) expression -> . isvoidexp + (21) expression -> . aritmetica + (22) expression -> . comparison + (23) expression -> . parenexpression + (63) constantexp -> . number + (64) constantexp -> . string + (65) constantexp -> . true + (66) constantexp -> . false + (67) identifier -> . id + (68) assignment -> . id assign expression + (35) dispatch -> . id lparen rparen + (36) dispatch -> . id lparen expression expressionparams rparen + (37) dispatch -> . expression point id lparen rparen + (38) dispatch -> . expression point id lparen expression expressionparams rparen + (39) dispatch -> . expression arroba type point id lparen rparen + (40) dispatch -> . expression arroba type point id lparen expression expressionparams rparen + (43) conditional -> . if expression then expression else expression fi + (44) loopexp -> . while expression loop expression pool + (45) blockexp -> . lbracket expressionlist rbracket + (46) letexp -> . let attribute letattributelist in expression + (47) caseexp -> . case expression of subcase listcase esac + (51) newexp -> . new type + (52) isvoidexp -> . isvoid expression + (53) aritmetica -> . expression plus expression + (54) aritmetica -> . expression minus expression + (55) aritmetica -> . expression mult expression + (56) aritmetica -> . expression div expression + (57) aritmetica -> . intnot expression + (58) comparison -> . expression less expression + (59) comparison -> . expression lesse expression + (60) comparison -> . expression equal expression + (61) comparison -> . not expression + (62) parenexpression -> . lparen expression rparen + + number shift and go to state 51 + string shift and go to state 52 + true shift and go to state 53 + false shift and go to state 54 + id shift and go to state 35 + if shift and go to state 56 + while shift and go to state 57 + lbracket shift and go to state 58 + let shift and go to state 59 + case shift and go to state 60 + new shift and go to state 61 + isvoid shift and go to state 62 + intnot shift and go to state 63 + not shift and go to state 64 + lparen shift and go to state 55 + + expression shift and go to state 141 + constantexp shift and go to state 37 + identifier shift and go to state 38 + assignment shift and go to state 39 + dispatch shift and go to state 40 + conditional shift and go to state 41 + loopexp shift and go to state 42 + blockexp shift and go to state 43 + letexp shift and go to state 44 + caseexp shift and go to state 45 + newexp shift and go to state 46 + isvoidexp shift and go to state 47 + aritmetica shift and go to state 48 + comparison shift and go to state 49 + parenexpression shift and go to state 50 + +state 129 + + (31) letattributelist -> coma attribute . letattributelist + (31) letattributelist -> . coma attribute letattributelist + (32) letattributelist -> . empty + (3) empty -> . + + coma shift and go to state 115 + in reduce using rule 3 (empty -> .) + + letattributelist shift and go to state 142 + empty shift and go to state 116 + +state 130 + + (47) caseexp -> case expression of subcase . listcase esac + (48) listcase -> . subcase listcase + (49) listcase -> . empty + (50) subcase -> . id dpoint type implica expression pcoma + (3) empty -> . + + id shift and go to state 131 + esac reduce using rule 3 (empty -> .) + + subcase shift and go to state 143 + listcase shift and go to state 144 + empty shift and go to state 145 + +state 131 + + (50) subcase -> id . dpoint type implica expression pcoma + + dpoint shift and go to state 146 + + +state 132 + + (24) methoddef -> id lparen rparen dpoint type lbracket expression rbracket . + + pcoma reduce using rule 24 (methoddef -> id lparen rparen dpoint type lbracket expression rbracket .) + + +state 133 + + (25) methoddef -> id lparen param paramslistdef rparen dpoint type lbracket . expression rbracket + (10) expression -> . constantexp + (11) expression -> . identifier + (12) expression -> . assignment + (13) expression -> . dispatch + (14) expression -> . conditional + (15) expression -> . loopexp + (16) expression -> . blockexp + (17) expression -> . letexp + (18) expression -> . caseexp + (19) expression -> . newexp + (20) expression -> . isvoidexp + (21) expression -> . aritmetica + (22) expression -> . comparison + (23) expression -> . parenexpression + (63) constantexp -> . number + (64) constantexp -> . string + (65) constantexp -> . true + (66) constantexp -> . false + (67) identifier -> . id + (68) assignment -> . id assign expression + (35) dispatch -> . id lparen rparen + (36) dispatch -> . id lparen expression expressionparams rparen + (37) dispatch -> . expression point id lparen rparen + (38) dispatch -> . expression point id lparen expression expressionparams rparen + (39) dispatch -> . expression arroba type point id lparen rparen + (40) dispatch -> . expression arroba type point id lparen expression expressionparams rparen + (43) conditional -> . if expression then expression else expression fi + (44) loopexp -> . while expression loop expression pool + (45) blockexp -> . lbracket expressionlist rbracket + (46) letexp -> . let attribute letattributelist in expression + (47) caseexp -> . case expression of subcase listcase esac + (51) newexp -> . new type + (52) isvoidexp -> . isvoid expression + (53) aritmetica -> . expression plus expression + (54) aritmetica -> . expression minus expression + (55) aritmetica -> . expression mult expression + (56) aritmetica -> . expression div expression + (57) aritmetica -> . intnot expression + (58) comparison -> . expression less expression + (59) comparison -> . expression lesse expression + (60) comparison -> . expression equal expression + (61) comparison -> . not expression + (62) parenexpression -> . lparen expression rparen + + number shift and go to state 51 + string shift and go to state 52 + true shift and go to state 53 + false shift and go to state 54 + id shift and go to state 35 + if shift and go to state 56 + while shift and go to state 57 + lbracket shift and go to state 58 + let shift and go to state 59 + case shift and go to state 60 + new shift and go to state 61 + isvoid shift and go to state 62 + intnot shift and go to state 63 + not shift and go to state 64 + lparen shift and go to state 55 + + expression shift and go to state 147 + constantexp shift and go to state 37 + identifier shift and go to state 38 + assignment shift and go to state 39 + dispatch shift and go to state 40 + conditional shift and go to state 41 + loopexp shift and go to state 42 + blockexp shift and go to state 43 + letexp shift and go to state 44 + caseexp shift and go to state 45 + newexp shift and go to state 46 + isvoidexp shift and go to state 47 + aritmetica shift and go to state 48 + comparison shift and go to state 49 + parenexpression shift and go to state 50 + +state 134 + + (36) dispatch -> id lparen expression expressionparams rparen . + + point reduce using rule 36 (dispatch -> id lparen expression expressionparams rparen .) + arroba reduce using rule 36 (dispatch -> id lparen expression expressionparams rparen .) + plus reduce using rule 36 (dispatch -> id lparen expression expressionparams rparen .) + minus reduce using rule 36 (dispatch -> id lparen expression expressionparams rparen .) + mult reduce using rule 36 (dispatch -> id lparen expression expressionparams rparen .) + div reduce using rule 36 (dispatch -> id lparen expression expressionparams rparen .) + less reduce using rule 36 (dispatch -> id lparen expression expressionparams rparen .) + lesse reduce using rule 36 (dispatch -> id lparen expression expressionparams rparen .) + equal reduce using rule 36 (dispatch -> id lparen expression expressionparams rparen .) + pcoma reduce using rule 36 (dispatch -> id lparen expression expressionparams rparen .) + coma reduce using rule 36 (dispatch -> id lparen expression expressionparams rparen .) + in reduce using rule 36 (dispatch -> id lparen expression expressionparams rparen .) + rparen reduce using rule 36 (dispatch -> id lparen expression expressionparams rparen .) + then reduce using rule 36 (dispatch -> id lparen expression expressionparams rparen .) + loop reduce using rule 36 (dispatch -> id lparen expression expressionparams rparen .) + of reduce using rule 36 (dispatch -> id lparen expression expressionparams rparen .) + rbracket reduce using rule 36 (dispatch -> id lparen expression expressionparams rparen .) + else reduce using rule 36 (dispatch -> id lparen expression expressionparams rparen .) + pool reduce using rule 36 (dispatch -> id lparen expression expressionparams rparen .) + fi reduce using rule 36 (dispatch -> id lparen expression expressionparams rparen .) + + +state 135 + + (41) expressionparams -> coma expression . expressionparams + (37) dispatch -> expression . point id lparen rparen + (38) dispatch -> expression . point id lparen expression expressionparams rparen + (39) dispatch -> expression . arroba type point id lparen rparen + (40) dispatch -> expression . arroba type point id lparen expression expressionparams rparen + (53) aritmetica -> expression . plus expression + (54) aritmetica -> expression . minus expression + (55) aritmetica -> expression . mult expression + (56) aritmetica -> expression . div expression + (58) comparison -> expression . less expression + (59) comparison -> expression . lesse expression + (60) comparison -> expression . equal expression + (41) expressionparams -> . coma expression expressionparams + (42) expressionparams -> . empty + (3) empty -> . + + point shift and go to state 72 + arroba shift and go to state 73 + plus shift and go to state 74 + minus shift and go to state 75 + mult shift and go to state 76 + div shift and go to state 77 + less shift and go to state 78 + lesse shift and go to state 79 + equal shift and go to state 80 + coma shift and go to state 121 + rparen reduce using rule 3 (empty -> .) + + expressionparams shift and go to state 148 + empty shift and go to state 122 + +state 136 + + (38) dispatch -> expression point id lparen expression . expressionparams rparen + (37) dispatch -> expression . point id lparen rparen + (38) dispatch -> expression . point id lparen expression expressionparams rparen + (39) dispatch -> expression . arroba type point id lparen rparen + (40) dispatch -> expression . arroba type point id lparen expression expressionparams rparen + (53) aritmetica -> expression . plus expression + (54) aritmetica -> expression . minus expression + (55) aritmetica -> expression . mult expression + (56) aritmetica -> expression . div expression + (58) comparison -> expression . less expression + (59) comparison -> expression . lesse expression + (60) comparison -> expression . equal expression + (41) expressionparams -> . coma expression expressionparams + (42) expressionparams -> . empty + (3) empty -> . + + point shift and go to state 72 + arroba shift and go to state 73 + plus shift and go to state 74 + minus shift and go to state 75 + mult shift and go to state 76 + div shift and go to state 77 + less shift and go to state 78 + lesse shift and go to state 79 + equal shift and go to state 80 + coma shift and go to state 121 + rparen reduce using rule 3 (empty -> .) + + expressionparams shift and go to state 149 + empty shift and go to state 122 + +state 137 + + (37) dispatch -> expression point id lparen rparen . + + point reduce using rule 37 (dispatch -> expression point id lparen rparen .) + arroba reduce using rule 37 (dispatch -> expression point id lparen rparen .) + plus reduce using rule 37 (dispatch -> expression point id lparen rparen .) + minus reduce using rule 37 (dispatch -> expression point id lparen rparen .) + mult reduce using rule 37 (dispatch -> expression point id lparen rparen .) + div reduce using rule 37 (dispatch -> expression point id lparen rparen .) + less reduce using rule 37 (dispatch -> expression point id lparen rparen .) + lesse reduce using rule 37 (dispatch -> expression point id lparen rparen .) + equal reduce using rule 37 (dispatch -> expression point id lparen rparen .) + pcoma reduce using rule 37 (dispatch -> expression point id lparen rparen .) + coma reduce using rule 37 (dispatch -> expression point id lparen rparen .) + in reduce using rule 37 (dispatch -> expression point id lparen rparen .) + rparen reduce using rule 37 (dispatch -> expression point id lparen rparen .) + then reduce using rule 37 (dispatch -> expression point id lparen rparen .) + loop reduce using rule 37 (dispatch -> expression point id lparen rparen .) + of reduce using rule 37 (dispatch -> expression point id lparen rparen .) + rbracket reduce using rule 37 (dispatch -> expression point id lparen rparen .) + else reduce using rule 37 (dispatch -> expression point id lparen rparen .) + pool reduce using rule 37 (dispatch -> expression point id lparen rparen .) + fi reduce using rule 37 (dispatch -> expression point id lparen rparen .) + + +state 138 + + (39) dispatch -> expression arroba type point id . lparen rparen + (40) dispatch -> expression arroba type point id . lparen expression expressionparams rparen + + lparen shift and go to state 150 + + +state 139 + + (43) conditional -> if expression then expression else . expression fi + (10) expression -> . constantexp + (11) expression -> . identifier + (12) expression -> . assignment + (13) expression -> . dispatch + (14) expression -> . conditional + (15) expression -> . loopexp + (16) expression -> . blockexp + (17) expression -> . letexp + (18) expression -> . caseexp + (19) expression -> . newexp + (20) expression -> . isvoidexp + (21) expression -> . aritmetica + (22) expression -> . comparison + (23) expression -> . parenexpression + (63) constantexp -> . number + (64) constantexp -> . string + (65) constantexp -> . true + (66) constantexp -> . false + (67) identifier -> . id + (68) assignment -> . id assign expression + (35) dispatch -> . id lparen rparen + (36) dispatch -> . id lparen expression expressionparams rparen + (37) dispatch -> . expression point id lparen rparen + (38) dispatch -> . expression point id lparen expression expressionparams rparen + (39) dispatch -> . expression arroba type point id lparen rparen + (40) dispatch -> . expression arroba type point id lparen expression expressionparams rparen + (43) conditional -> . if expression then expression else expression fi + (44) loopexp -> . while expression loop expression pool + (45) blockexp -> . lbracket expressionlist rbracket + (46) letexp -> . let attribute letattributelist in expression + (47) caseexp -> . case expression of subcase listcase esac + (51) newexp -> . new type + (52) isvoidexp -> . isvoid expression + (53) aritmetica -> . expression plus expression + (54) aritmetica -> . expression minus expression + (55) aritmetica -> . expression mult expression + (56) aritmetica -> . expression div expression + (57) aritmetica -> . intnot expression + (58) comparison -> . expression less expression + (59) comparison -> . expression lesse expression + (60) comparison -> . expression equal expression + (61) comparison -> . not expression + (62) parenexpression -> . lparen expression rparen + + number shift and go to state 51 + string shift and go to state 52 + true shift and go to state 53 + false shift and go to state 54 + id shift and go to state 35 + if shift and go to state 56 + while shift and go to state 57 + lbracket shift and go to state 58 + let shift and go to state 59 + case shift and go to state 60 + new shift and go to state 61 + isvoid shift and go to state 62 + intnot shift and go to state 63 + not shift and go to state 64 + lparen shift and go to state 55 + + expression shift and go to state 151 + constantexp shift and go to state 37 + identifier shift and go to state 38 + assignment shift and go to state 39 + dispatch shift and go to state 40 + conditional shift and go to state 41 + loopexp shift and go to state 42 + blockexp shift and go to state 43 + letexp shift and go to state 44 + caseexp shift and go to state 45 + newexp shift and go to state 46 + isvoidexp shift and go to state 47 + aritmetica shift and go to state 48 + comparison shift and go to state 49 + parenexpression shift and go to state 50 + +state 140 + + (44) loopexp -> while expression loop expression pool . + + point reduce using rule 44 (loopexp -> while expression loop expression pool .) + arroba reduce using rule 44 (loopexp -> while expression loop expression pool .) + plus reduce using rule 44 (loopexp -> while expression loop expression pool .) + minus reduce using rule 44 (loopexp -> while expression loop expression pool .) + mult reduce using rule 44 (loopexp -> while expression loop expression pool .) + div reduce using rule 44 (loopexp -> while expression loop expression pool .) + less reduce using rule 44 (loopexp -> while expression loop expression pool .) + lesse reduce using rule 44 (loopexp -> while expression loop expression pool .) + equal reduce using rule 44 (loopexp -> while expression loop expression pool .) + pcoma reduce using rule 44 (loopexp -> while expression loop expression pool .) + coma reduce using rule 44 (loopexp -> while expression loop expression pool .) + in reduce using rule 44 (loopexp -> while expression loop expression pool .) + rparen reduce using rule 44 (loopexp -> while expression loop expression pool .) + then reduce using rule 44 (loopexp -> while expression loop expression pool .) + loop reduce using rule 44 (loopexp -> while expression loop expression pool .) + of reduce using rule 44 (loopexp -> while expression loop expression pool .) + rbracket reduce using rule 44 (loopexp -> while expression loop expression pool .) + else reduce using rule 44 (loopexp -> while expression loop expression pool .) + pool reduce using rule 44 (loopexp -> while expression loop expression pool .) + fi reduce using rule 44 (loopexp -> while expression loop expression pool .) + + +state 141 + + (46) letexp -> let attribute letattributelist in expression . + (37) dispatch -> expression . point id lparen rparen + (38) dispatch -> expression . point id lparen expression expressionparams rparen + (39) dispatch -> expression . arroba type point id lparen rparen + (40) dispatch -> expression . arroba type point id lparen expression expressionparams rparen + (53) aritmetica -> expression . plus expression + (54) aritmetica -> expression . minus expression + (55) aritmetica -> expression . mult expression + (56) aritmetica -> expression . div expression + (58) comparison -> expression . less expression + (59) comparison -> expression . lesse expression + (60) comparison -> expression . equal expression + + ! shift/reduce conflict for point resolved as shift + ! shift/reduce conflict for arroba resolved as shift + ! shift/reduce conflict for plus resolved as shift + ! shift/reduce conflict for minus resolved as shift + ! shift/reduce conflict for mult resolved as shift + ! shift/reduce conflict for div resolved as shift + ! shift/reduce conflict for less resolved as shift + ! shift/reduce conflict for lesse resolved as shift + ! shift/reduce conflict for equal resolved as shift + pcoma reduce using rule 46 (letexp -> let attribute letattributelist in expression .) + coma reduce using rule 46 (letexp -> let attribute letattributelist in expression .) + in reduce using rule 46 (letexp -> let attribute letattributelist in expression .) + rparen reduce using rule 46 (letexp -> let attribute letattributelist in expression .) + then reduce using rule 46 (letexp -> let attribute letattributelist in expression .) + loop reduce using rule 46 (letexp -> let attribute letattributelist in expression .) + of reduce using rule 46 (letexp -> let attribute letattributelist in expression .) + rbracket reduce using rule 46 (letexp -> let attribute letattributelist in expression .) + else reduce using rule 46 (letexp -> let attribute letattributelist in expression .) + pool reduce using rule 46 (letexp -> let attribute letattributelist in expression .) + fi reduce using rule 46 (letexp -> let attribute letattributelist in expression .) + point shift and go to state 72 + arroba shift and go to state 73 + plus shift and go to state 74 + minus shift and go to state 75 + mult shift and go to state 76 + div shift and go to state 77 + less shift and go to state 78 + lesse shift and go to state 79 + equal shift and go to state 80 + + ! point [ reduce using rule 46 (letexp -> let attribute letattributelist in expression .) ] + ! arroba [ reduce using rule 46 (letexp -> let attribute letattributelist in expression .) ] + ! plus [ reduce using rule 46 (letexp -> let attribute letattributelist in expression .) ] + ! minus [ reduce using rule 46 (letexp -> let attribute letattributelist in expression .) ] + ! mult [ reduce using rule 46 (letexp -> let attribute letattributelist in expression .) ] + ! div [ reduce using rule 46 (letexp -> let attribute letattributelist in expression .) ] + ! less [ reduce using rule 46 (letexp -> let attribute letattributelist in expression .) ] + ! lesse [ reduce using rule 46 (letexp -> let attribute letattributelist in expression .) ] + ! equal [ reduce using rule 46 (letexp -> let attribute letattributelist in expression .) ] + + +state 142 + + (31) letattributelist -> coma attribute letattributelist . + + in reduce using rule 31 (letattributelist -> coma attribute letattributelist .) + + +state 143 + + (48) listcase -> subcase . listcase + (48) listcase -> . subcase listcase + (49) listcase -> . empty + (50) subcase -> . id dpoint type implica expression pcoma + (3) empty -> . + + id shift and go to state 131 + esac reduce using rule 3 (empty -> .) + + subcase shift and go to state 143 + listcase shift and go to state 152 + empty shift and go to state 145 + +state 144 + + (47) caseexp -> case expression of subcase listcase . esac + + esac shift and go to state 153 + + +state 145 + + (49) listcase -> empty . + + esac reduce using rule 49 (listcase -> empty .) + + +state 146 + + (50) subcase -> id dpoint . type implica expression pcoma + + type shift and go to state 154 + + +state 147 + + (25) methoddef -> id lparen param paramslistdef rparen dpoint type lbracket expression . rbracket + (37) dispatch -> expression . point id lparen rparen + (38) dispatch -> expression . point id lparen expression expressionparams rparen + (39) dispatch -> expression . arroba type point id lparen rparen + (40) dispatch -> expression . arroba type point id lparen expression expressionparams rparen + (53) aritmetica -> expression . plus expression + (54) aritmetica -> expression . minus expression + (55) aritmetica -> expression . mult expression + (56) aritmetica -> expression . div expression + (58) comparison -> expression . less expression + (59) comparison -> expression . lesse expression + (60) comparison -> expression . equal expression + + rbracket shift and go to state 155 + point shift and go to state 72 + arroba shift and go to state 73 + plus shift and go to state 74 + minus shift and go to state 75 + mult shift and go to state 76 + div shift and go to state 77 + less shift and go to state 78 + lesse shift and go to state 79 + equal shift and go to state 80 + + +state 148 + + (41) expressionparams -> coma expression expressionparams . + + rparen reduce using rule 41 (expressionparams -> coma expression expressionparams .) + + +state 149 + + (38) dispatch -> expression point id lparen expression expressionparams . rparen + + rparen shift and go to state 156 + + +state 150 + + (39) dispatch -> expression arroba type point id lparen . rparen + (40) dispatch -> expression arroba type point id lparen . expression expressionparams rparen + (10) expression -> . constantexp + (11) expression -> . identifier + (12) expression -> . assignment + (13) expression -> . dispatch + (14) expression -> . conditional + (15) expression -> . loopexp + (16) expression -> . blockexp + (17) expression -> . letexp + (18) expression -> . caseexp + (19) expression -> . newexp + (20) expression -> . isvoidexp + (21) expression -> . aritmetica + (22) expression -> . comparison + (23) expression -> . parenexpression + (63) constantexp -> . number + (64) constantexp -> . string + (65) constantexp -> . true + (66) constantexp -> . false + (67) identifier -> . id + (68) assignment -> . id assign expression + (35) dispatch -> . id lparen rparen + (36) dispatch -> . id lparen expression expressionparams rparen + (37) dispatch -> . expression point id lparen rparen + (38) dispatch -> . expression point id lparen expression expressionparams rparen + (39) dispatch -> . expression arroba type point id lparen rparen + (40) dispatch -> . expression arroba type point id lparen expression expressionparams rparen + (43) conditional -> . if expression then expression else expression fi + (44) loopexp -> . while expression loop expression pool + (45) blockexp -> . lbracket expressionlist rbracket + (46) letexp -> . let attribute letattributelist in expression + (47) caseexp -> . case expression of subcase listcase esac + (51) newexp -> . new type + (52) isvoidexp -> . isvoid expression + (53) aritmetica -> . expression plus expression + (54) aritmetica -> . expression minus expression + (55) aritmetica -> . expression mult expression + (56) aritmetica -> . expression div expression + (57) aritmetica -> . intnot expression + (58) comparison -> . expression less expression + (59) comparison -> . expression lesse expression + (60) comparison -> . expression equal expression + (61) comparison -> . not expression + (62) parenexpression -> . lparen expression rparen + + rparen shift and go to state 158 + number shift and go to state 51 + string shift and go to state 52 + true shift and go to state 53 + false shift and go to state 54 + id shift and go to state 35 + if shift and go to state 56 + while shift and go to state 57 + lbracket shift and go to state 58 + let shift and go to state 59 + case shift and go to state 60 + new shift and go to state 61 + isvoid shift and go to state 62 + intnot shift and go to state 63 + not shift and go to state 64 + lparen shift and go to state 55 + + expression shift and go to state 157 + constantexp shift and go to state 37 + identifier shift and go to state 38 + assignment shift and go to state 39 + dispatch shift and go to state 40 + conditional shift and go to state 41 + loopexp shift and go to state 42 + blockexp shift and go to state 43 + letexp shift and go to state 44 + caseexp shift and go to state 45 + newexp shift and go to state 46 + isvoidexp shift and go to state 47 + aritmetica shift and go to state 48 + comparison shift and go to state 49 + parenexpression shift and go to state 50 + +state 151 + + (43) conditional -> if expression then expression else expression . fi + (37) dispatch -> expression . point id lparen rparen + (38) dispatch -> expression . point id lparen expression expressionparams rparen + (39) dispatch -> expression . arroba type point id lparen rparen + (40) dispatch -> expression . arroba type point id lparen expression expressionparams rparen + (53) aritmetica -> expression . plus expression + (54) aritmetica -> expression . minus expression + (55) aritmetica -> expression . mult expression + (56) aritmetica -> expression . div expression + (58) comparison -> expression . less expression + (59) comparison -> expression . lesse expression + (60) comparison -> expression . equal expression + + fi shift and go to state 159 + point shift and go to state 72 + arroba shift and go to state 73 + plus shift and go to state 74 + minus shift and go to state 75 + mult shift and go to state 76 + div shift and go to state 77 + less shift and go to state 78 + lesse shift and go to state 79 + equal shift and go to state 80 + + +state 152 + + (48) listcase -> subcase listcase . + + esac reduce using rule 48 (listcase -> subcase listcase .) + + +state 153 + + (47) caseexp -> case expression of subcase listcase esac . + + point reduce using rule 47 (caseexp -> case expression of subcase listcase esac .) + arroba reduce using rule 47 (caseexp -> case expression of subcase listcase esac .) + plus reduce using rule 47 (caseexp -> case expression of subcase listcase esac .) + minus reduce using rule 47 (caseexp -> case expression of subcase listcase esac .) + mult reduce using rule 47 (caseexp -> case expression of subcase listcase esac .) + div reduce using rule 47 (caseexp -> case expression of subcase listcase esac .) + less reduce using rule 47 (caseexp -> case expression of subcase listcase esac .) + lesse reduce using rule 47 (caseexp -> case expression of subcase listcase esac .) + equal reduce using rule 47 (caseexp -> case expression of subcase listcase esac .) + pcoma reduce using rule 47 (caseexp -> case expression of subcase listcase esac .) + coma reduce using rule 47 (caseexp -> case expression of subcase listcase esac .) + in reduce using rule 47 (caseexp -> case expression of subcase listcase esac .) + rparen reduce using rule 47 (caseexp -> case expression of subcase listcase esac .) + then reduce using rule 47 (caseexp -> case expression of subcase listcase esac .) + loop reduce using rule 47 (caseexp -> case expression of subcase listcase esac .) + of reduce using rule 47 (caseexp -> case expression of subcase listcase esac .) + rbracket reduce using rule 47 (caseexp -> case expression of subcase listcase esac .) + else reduce using rule 47 (caseexp -> case expression of subcase listcase esac .) + pool reduce using rule 47 (caseexp -> case expression of subcase listcase esac .) + fi reduce using rule 47 (caseexp -> case expression of subcase listcase esac .) + + +state 154 + + (50) subcase -> id dpoint type . implica expression pcoma + + implica shift and go to state 160 + + +state 155 + + (25) methoddef -> id lparen param paramslistdef rparen dpoint type lbracket expression rbracket . + + pcoma reduce using rule 25 (methoddef -> id lparen param paramslistdef rparen dpoint type lbracket expression rbracket .) + + +state 156 + + (38) dispatch -> expression point id lparen expression expressionparams rparen . + + point reduce using rule 38 (dispatch -> expression point id lparen expression expressionparams rparen .) + arroba reduce using rule 38 (dispatch -> expression point id lparen expression expressionparams rparen .) + plus reduce using rule 38 (dispatch -> expression point id lparen expression expressionparams rparen .) + minus reduce using rule 38 (dispatch -> expression point id lparen expression expressionparams rparen .) + mult reduce using rule 38 (dispatch -> expression point id lparen expression expressionparams rparen .) + div reduce using rule 38 (dispatch -> expression point id lparen expression expressionparams rparen .) + less reduce using rule 38 (dispatch -> expression point id lparen expression expressionparams rparen .) + lesse reduce using rule 38 (dispatch -> expression point id lparen expression expressionparams rparen .) + equal reduce using rule 38 (dispatch -> expression point id lparen expression expressionparams rparen .) + pcoma reduce using rule 38 (dispatch -> expression point id lparen expression expressionparams rparen .) + coma reduce using rule 38 (dispatch -> expression point id lparen expression expressionparams rparen .) + in reduce using rule 38 (dispatch -> expression point id lparen expression expressionparams rparen .) + rparen reduce using rule 38 (dispatch -> expression point id lparen expression expressionparams rparen .) + then reduce using rule 38 (dispatch -> expression point id lparen expression expressionparams rparen .) + loop reduce using rule 38 (dispatch -> expression point id lparen expression expressionparams rparen .) + of reduce using rule 38 (dispatch -> expression point id lparen expression expressionparams rparen .) + rbracket reduce using rule 38 (dispatch -> expression point id lparen expression expressionparams rparen .) + else reduce using rule 38 (dispatch -> expression point id lparen expression expressionparams rparen .) + pool reduce using rule 38 (dispatch -> expression point id lparen expression expressionparams rparen .) + fi reduce using rule 38 (dispatch -> expression point id lparen expression expressionparams rparen .) + + +state 157 + + (40) dispatch -> expression arroba type point id lparen expression . expressionparams rparen + (37) dispatch -> expression . point id lparen rparen + (38) dispatch -> expression . point id lparen expression expressionparams rparen + (39) dispatch -> expression . arroba type point id lparen rparen + (40) dispatch -> expression . arroba type point id lparen expression expressionparams rparen + (53) aritmetica -> expression . plus expression + (54) aritmetica -> expression . minus expression + (55) aritmetica -> expression . mult expression + (56) aritmetica -> expression . div expression + (58) comparison -> expression . less expression + (59) comparison -> expression . lesse expression + (60) comparison -> expression . equal expression + (41) expressionparams -> . coma expression expressionparams + (42) expressionparams -> . empty + (3) empty -> . + + point shift and go to state 72 + arroba shift and go to state 73 + plus shift and go to state 74 + minus shift and go to state 75 + mult shift and go to state 76 + div shift and go to state 77 + less shift and go to state 78 + lesse shift and go to state 79 + equal shift and go to state 80 + coma shift and go to state 121 + rparen reduce using rule 3 (empty -> .) + + expressionparams shift and go to state 161 + empty shift and go to state 122 + +state 158 + + (39) dispatch -> expression arroba type point id lparen rparen . + + point reduce using rule 39 (dispatch -> expression arroba type point id lparen rparen .) + arroba reduce using rule 39 (dispatch -> expression arroba type point id lparen rparen .) + plus reduce using rule 39 (dispatch -> expression arroba type point id lparen rparen .) + minus reduce using rule 39 (dispatch -> expression arroba type point id lparen rparen .) + mult reduce using rule 39 (dispatch -> expression arroba type point id lparen rparen .) + div reduce using rule 39 (dispatch -> expression arroba type point id lparen rparen .) + less reduce using rule 39 (dispatch -> expression arroba type point id lparen rparen .) + lesse reduce using rule 39 (dispatch -> expression arroba type point id lparen rparen .) + equal reduce using rule 39 (dispatch -> expression arroba type point id lparen rparen .) + pcoma reduce using rule 39 (dispatch -> expression arroba type point id lparen rparen .) + coma reduce using rule 39 (dispatch -> expression arroba type point id lparen rparen .) + in reduce using rule 39 (dispatch -> expression arroba type point id lparen rparen .) + rparen reduce using rule 39 (dispatch -> expression arroba type point id lparen rparen .) + then reduce using rule 39 (dispatch -> expression arroba type point id lparen rparen .) + loop reduce using rule 39 (dispatch -> expression arroba type point id lparen rparen .) + of reduce using rule 39 (dispatch -> expression arroba type point id lparen rparen .) + rbracket reduce using rule 39 (dispatch -> expression arroba type point id lparen rparen .) + else reduce using rule 39 (dispatch -> expression arroba type point id lparen rparen .) + pool reduce using rule 39 (dispatch -> expression arroba type point id lparen rparen .) + fi reduce using rule 39 (dispatch -> expression arroba type point id lparen rparen .) + + +state 159 + + (43) conditional -> if expression then expression else expression fi . + + point reduce using rule 43 (conditional -> if expression then expression else expression fi .) + arroba reduce using rule 43 (conditional -> if expression then expression else expression fi .) + plus reduce using rule 43 (conditional -> if expression then expression else expression fi .) + minus reduce using rule 43 (conditional -> if expression then expression else expression fi .) + mult reduce using rule 43 (conditional -> if expression then expression else expression fi .) + div reduce using rule 43 (conditional -> if expression then expression else expression fi .) + less reduce using rule 43 (conditional -> if expression then expression else expression fi .) + lesse reduce using rule 43 (conditional -> if expression then expression else expression fi .) + equal reduce using rule 43 (conditional -> if expression then expression else expression fi .) + pcoma reduce using rule 43 (conditional -> if expression then expression else expression fi .) + coma reduce using rule 43 (conditional -> if expression then expression else expression fi .) + in reduce using rule 43 (conditional -> if expression then expression else expression fi .) + rparen reduce using rule 43 (conditional -> if expression then expression else expression fi .) + then reduce using rule 43 (conditional -> if expression then expression else expression fi .) + loop reduce using rule 43 (conditional -> if expression then expression else expression fi .) + of reduce using rule 43 (conditional -> if expression then expression else expression fi .) + rbracket reduce using rule 43 (conditional -> if expression then expression else expression fi .) + else reduce using rule 43 (conditional -> if expression then expression else expression fi .) + pool reduce using rule 43 (conditional -> if expression then expression else expression fi .) + fi reduce using rule 43 (conditional -> if expression then expression else expression fi .) + + +state 160 + + (50) subcase -> id dpoint type implica . expression pcoma + (10) expression -> . constantexp + (11) expression -> . identifier + (12) expression -> . assignment + (13) expression -> . dispatch + (14) expression -> . conditional + (15) expression -> . loopexp + (16) expression -> . blockexp + (17) expression -> . letexp + (18) expression -> . caseexp + (19) expression -> . newexp + (20) expression -> . isvoidexp + (21) expression -> . aritmetica + (22) expression -> . comparison + (23) expression -> . parenexpression + (63) constantexp -> . number + (64) constantexp -> . string + (65) constantexp -> . true + (66) constantexp -> . false + (67) identifier -> . id + (68) assignment -> . id assign expression + (35) dispatch -> . id lparen rparen + (36) dispatch -> . id lparen expression expressionparams rparen + (37) dispatch -> . expression point id lparen rparen + (38) dispatch -> . expression point id lparen expression expressionparams rparen + (39) dispatch -> . expression arroba type point id lparen rparen + (40) dispatch -> . expression arroba type point id lparen expression expressionparams rparen + (43) conditional -> . if expression then expression else expression fi + (44) loopexp -> . while expression loop expression pool + (45) blockexp -> . lbracket expressionlist rbracket + (46) letexp -> . let attribute letattributelist in expression + (47) caseexp -> . case expression of subcase listcase esac + (51) newexp -> . new type + (52) isvoidexp -> . isvoid expression + (53) aritmetica -> . expression plus expression + (54) aritmetica -> . expression minus expression + (55) aritmetica -> . expression mult expression + (56) aritmetica -> . expression div expression + (57) aritmetica -> . intnot expression + (58) comparison -> . expression less expression + (59) comparison -> . expression lesse expression + (60) comparison -> . expression equal expression + (61) comparison -> . not expression + (62) parenexpression -> . lparen expression rparen + + number shift and go to state 51 + string shift and go to state 52 + true shift and go to state 53 + false shift and go to state 54 + id shift and go to state 35 + if shift and go to state 56 + while shift and go to state 57 + lbracket shift and go to state 58 + let shift and go to state 59 + case shift and go to state 60 + new shift and go to state 61 + isvoid shift and go to state 62 + intnot shift and go to state 63 + not shift and go to state 64 + lparen shift and go to state 55 + + expression shift and go to state 162 + constantexp shift and go to state 37 + identifier shift and go to state 38 + assignment shift and go to state 39 + dispatch shift and go to state 40 + conditional shift and go to state 41 + loopexp shift and go to state 42 + blockexp shift and go to state 43 + letexp shift and go to state 44 + caseexp shift and go to state 45 + newexp shift and go to state 46 + isvoidexp shift and go to state 47 + aritmetica shift and go to state 48 + comparison shift and go to state 49 + parenexpression shift and go to state 50 + +state 161 + + (40) dispatch -> expression arroba type point id lparen expression expressionparams . rparen + + rparen shift and go to state 163 + + +state 162 + + (50) subcase -> id dpoint type implica expression . pcoma + (37) dispatch -> expression . point id lparen rparen + (38) dispatch -> expression . point id lparen expression expressionparams rparen + (39) dispatch -> expression . arroba type point id lparen rparen + (40) dispatch -> expression . arroba type point id lparen expression expressionparams rparen + (53) aritmetica -> expression . plus expression + (54) aritmetica -> expression . minus expression + (55) aritmetica -> expression . mult expression + (56) aritmetica -> expression . div expression + (58) comparison -> expression . less expression + (59) comparison -> expression . lesse expression + (60) comparison -> expression . equal expression + + pcoma shift and go to state 164 + point shift and go to state 72 + arroba shift and go to state 73 + plus shift and go to state 74 + minus shift and go to state 75 + mult shift and go to state 76 + div shift and go to state 77 + less shift and go to state 78 + lesse shift and go to state 79 + equal shift and go to state 80 + + +state 163 + + (40) dispatch -> expression arroba type point id lparen expression expressionparams rparen . + + point reduce using rule 40 (dispatch -> expression arroba type point id lparen expression expressionparams rparen .) + arroba reduce using rule 40 (dispatch -> expression arroba type point id lparen expression expressionparams rparen .) + plus reduce using rule 40 (dispatch -> expression arroba type point id lparen expression expressionparams rparen .) + minus reduce using rule 40 (dispatch -> expression arroba type point id lparen expression expressionparams rparen .) + mult reduce using rule 40 (dispatch -> expression arroba type point id lparen expression expressionparams rparen .) + div reduce using rule 40 (dispatch -> expression arroba type point id lparen expression expressionparams rparen .) + less reduce using rule 40 (dispatch -> expression arroba type point id lparen expression expressionparams rparen .) + lesse reduce using rule 40 (dispatch -> expression arroba type point id lparen expression expressionparams rparen .) + equal reduce using rule 40 (dispatch -> expression arroba type point id lparen expression expressionparams rparen .) + pcoma reduce using rule 40 (dispatch -> expression arroba type point id lparen expression expressionparams rparen .) + coma reduce using rule 40 (dispatch -> expression arroba type point id lparen expression expressionparams rparen .) + in reduce using rule 40 (dispatch -> expression arroba type point id lparen expression expressionparams rparen .) + rparen reduce using rule 40 (dispatch -> expression arroba type point id lparen expression expressionparams rparen .) + then reduce using rule 40 (dispatch -> expression arroba type point id lparen expression expressionparams rparen .) + loop reduce using rule 40 (dispatch -> expression arroba type point id lparen expression expressionparams rparen .) + of reduce using rule 40 (dispatch -> expression arroba type point id lparen expression expressionparams rparen .) + rbracket reduce using rule 40 (dispatch -> expression arroba type point id lparen expression expressionparams rparen .) + else reduce using rule 40 (dispatch -> expression arroba type point id lparen expression expressionparams rparen .) + pool reduce using rule 40 (dispatch -> expression arroba type point id lparen expression expressionparams rparen .) + fi reduce using rule 40 (dispatch -> expression arroba type point id lparen expression expressionparams rparen .) + + +state 164 + + (50) subcase -> id dpoint type implica expression pcoma . + + id reduce using rule 50 (subcase -> id dpoint type implica expression pcoma .) + esac reduce using rule 50 (subcase -> id dpoint type implica expression pcoma .) + +WARNING: +WARNING: Conflicts: +WARNING: +WARNING: shift/reduce conflict for point in state 141 resolved as shift +WARNING: shift/reduce conflict for arroba in state 141 resolved as shift +WARNING: shift/reduce conflict for plus in state 141 resolved as shift +WARNING: shift/reduce conflict for minus in state 141 resolved as shift +WARNING: shift/reduce conflict for mult in state 141 resolved as shift +WARNING: shift/reduce conflict for div in state 141 resolved as shift +WARNING: shift/reduce conflict for less in state 141 resolved as shift +WARNING: shift/reduce conflict for lesse in state 141 resolved as shift +WARNING: shift/reduce conflict for equal in state 141 resolved as shift diff --git a/src/parsetab.py b/src/parsetab.py new file mode 100644 index 00000000..cf9c9135 --- /dev/null +++ b/src/parsetab.py @@ -0,0 +1,98 @@ + +# parsetab.py +# This file is automatically generated. Do not edit. +# pylint: disable=W,C,R +_tabversion = '3.10' + +_lr_method = 'LALR' + +_lr_signature = 'nonassocassignrightnotnonassoclesslesseequalleftplusminusleftmultdivrightisvoidrightintnotleftarrobaleftpointarroba assign case class coma comment constant div dpoint else eofcomment eofstring equal esac false fi id if implica in inherits intnot isvoid lbracket less lesse let loop lparen minus mult new not number of pcoma plus point pool rbracket rparen string then true type unfinished_string whileprogram : classdec program\n | classdecempty :classdec : class type lbracket featurelist rbracket pcoma\n | class type inherits type lbracket featurelist rbracket pcomafeaturelist : feature featurelist\n | emptyfeature : attribute pcoma\n | methoddef pcomaexpression : constantexp\n | identifier\n | assignment\n | dispatch\n | conditional\n | loopexp\n | blockexp\n | letexp\n | caseexp\n | newexp\n | isvoidexp\n | aritmetica\n | comparison\n | parenexpressionmethoddef : id lparen rparen dpoint type lbracket expression rbracket\n | id lparen param paramslistdef rparen dpoint type lbracket expression rbracketexpressionlist : expression pcoma expressionlist\n | emptyparam : id dpoint typeattribute : id dpoint type\n | id dpoint type assign expressionletattributelist : coma attribute letattributelist\n | emptyparamslistdef : coma param paramslistdef\n | emptydispatch : id lparen rparen\n | id lparen expression expressionparams rparen\n | expression point id lparen rparen\n | expression point id lparen expression expressionparams rparen\n | expression arroba type point id lparen rparen\n | expression arroba type point id lparen expression expressionparams rparenexpressionparams : coma expression expressionparams\n | emptyconditional : if expression then expression else expression filoopexp : while expression loop expression poolblockexp : lbracket expressionlist rbracketletexp : let attribute letattributelist in expressioncaseexp : case expression of subcase listcase esaclistcase : subcase listcase\n | emptysubcase : id dpoint type implica expression pcomanewexp : new typeisvoidexp : isvoid expressionaritmetica : expression plus expression\n | expression minus expression\n | expression mult expression\n | expression div expression\n | intnot expressioncomparison : expression less expression\n | expression lesse expression\n | expression equal expression\n | not expressionparenexpression : lparen expression rparenconstantexp : number\n | string\n | true\n | falseidentifier : idassignment : id assign expression' + +_lr_action_items = {'class':([0,2,22,69,],[3,3,-4,-5,]),'$end':([1,2,4,22,69,],[0,-2,-1,-4,-5,]),'type':([3,7,19,29,30,61,73,95,146,],[5,14,23,65,66,90,101,119,154,]),'lbracket':([5,14,28,55,56,57,58,60,62,63,64,66,70,71,74,75,76,77,78,79,80,94,110,111,113,119,121,123,128,133,139,150,160,],[6,21,58,58,58,58,58,58,58,58,58,94,58,58,58,58,58,58,58,58,58,58,58,58,58,133,58,58,58,58,58,58,58,]),'inherits':([5,],[7,]),'rbracket':([6,8,9,10,16,17,18,21,27,35,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,58,84,86,90,91,92,93,97,98,102,103,104,105,106,107,108,109,112,113,118,127,134,137,140,141,147,153,156,158,159,163,],[-3,15,-3,-7,-6,-8,-9,-3,34,-67,-10,-11,-12,-13,-14,-15,-16,-17,-18,-19,-20,-21,-22,-23,-63,-64,-65,-66,-3,112,-27,-51,-52,-57,-61,-68,-35,-53,-54,-55,-56,-58,-59,-60,-62,-45,-3,132,-26,-36,-37,-44,-46,155,-47,-38,-39,-43,-40,]),'id':([6,9,17,18,20,21,28,32,55,56,57,58,59,60,62,63,64,70,71,72,74,75,76,77,78,79,80,94,110,111,113,115,117,121,123,124,128,130,133,139,143,150,160,164,],[13,13,-8,-9,24,13,35,24,35,35,35,35,88,35,35,35,35,35,35,100,35,35,35,35,35,35,35,35,35,35,35,88,131,35,35,138,35,131,35,35,131,35,35,-50,]),'pcoma':([11,12,15,23,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,85,90,91,92,93,97,98,102,103,104,105,106,107,108,109,112,132,134,137,140,141,153,155,156,158,159,162,163,],[17,18,22,-29,69,-67,-30,-10,-11,-12,-13,-14,-15,-16,-17,-18,-19,-20,-21,-22,-23,-63,-64,-65,-66,113,-51,-52,-57,-61,-68,-35,-53,-54,-55,-56,-58,-59,-60,-62,-45,-24,-36,-37,-44,-46,-47,-25,-38,-39,-43,164,-40,]),'dpoint':([13,24,25,67,88,131,],[19,29,30,95,19,146,]),'lparen':([13,28,35,55,56,57,58,60,62,63,64,70,71,74,75,76,77,78,79,80,94,100,110,111,113,121,123,128,133,138,139,150,160,],[20,55,71,55,55,55,55,55,55,55,55,55,55,55,55,55,55,55,55,55,55,123,55,55,55,55,55,55,55,150,55,55,55,]),'rparen':([20,26,31,33,35,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,65,68,71,81,90,91,92,93,96,97,98,99,102,103,104,105,106,107,108,109,112,120,122,123,134,135,136,137,140,141,148,149,150,153,156,157,158,159,161,163,],[25,-3,67,-34,-67,-10,-11,-12,-13,-14,-15,-16,-17,-18,-19,-20,-21,-22,-23,-63,-64,-65,-66,-28,-3,98,109,-51,-52,-57,-61,-33,-68,-35,-3,-53,-54,-55,-56,-58,-59,-60,-62,-45,134,-42,137,-36,-3,-3,-37,-44,-46,-41,156,158,-47,-38,-3,-39,-43,163,-40,]),'coma':([23,26,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,65,68,87,90,91,92,93,97,98,99,102,103,104,105,106,107,108,109,112,129,134,135,136,137,140,141,153,156,157,158,159,163,],[-29,32,-67,-30,-10,-11,-12,-13,-14,-15,-16,-17,-18,-19,-20,-21,-22,-23,-63,-64,-65,-66,-28,32,115,-51,-52,-57,-61,-68,-35,121,-53,-54,-55,-56,-58,-59,-60,-62,-45,115,-36,121,121,-37,-44,-46,-47,-38,121,-39,-43,-40,]),'in':([23,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,87,90,91,92,93,97,98,102,103,104,105,106,107,108,109,112,114,116,129,134,137,140,141,142,153,156,158,159,163,],[-29,-67,-30,-10,-11,-12,-13,-14,-15,-16,-17,-18,-19,-20,-21,-22,-23,-63,-64,-65,-66,-3,-51,-52,-57,-61,-68,-35,-53,-54,-55,-56,-58,-59,-60,-62,-45,128,-32,-3,-36,-37,-44,-46,-31,-47,-38,-39,-43,-40,]),'assign':([23,35,],[28,70,]),'number':([28,55,56,57,58,60,62,63,64,70,71,74,75,76,77,78,79,80,94,110,111,113,121,123,128,133,139,150,160,],[51,51,51,51,51,51,51,51,51,51,51,51,51,51,51,51,51,51,51,51,51,51,51,51,51,51,51,51,51,]),'string':([28,55,56,57,58,60,62,63,64,70,71,74,75,76,77,78,79,80,94,110,111,113,121,123,128,133,139,150,160,],[52,52,52,52,52,52,52,52,52,52,52,52,52,52,52,52,52,52,52,52,52,52,52,52,52,52,52,52,52,]),'true':([28,55,56,57,58,60,62,63,64,70,71,74,75,76,77,78,79,80,94,110,111,113,121,123,128,133,139,150,160,],[53,53,53,53,53,53,53,53,53,53,53,53,53,53,53,53,53,53,53,53,53,53,53,53,53,53,53,53,53,]),'false':([28,55,56,57,58,60,62,63,64,70,71,74,75,76,77,78,79,80,94,110,111,113,121,123,128,133,139,150,160,],[54,54,54,54,54,54,54,54,54,54,54,54,54,54,54,54,54,54,54,54,54,54,54,54,54,54,54,54,54,]),'if':([28,55,56,57,58,60,62,63,64,70,71,74,75,76,77,78,79,80,94,110,111,113,121,123,128,133,139,150,160,],[56,56,56,56,56,56,56,56,56,56,56,56,56,56,56,56,56,56,56,56,56,56,56,56,56,56,56,56,56,]),'while':([28,55,56,57,58,60,62,63,64,70,71,74,75,76,77,78,79,80,94,110,111,113,121,123,128,133,139,150,160,],[57,57,57,57,57,57,57,57,57,57,57,57,57,57,57,57,57,57,57,57,57,57,57,57,57,57,57,57,57,]),'let':([28,55,56,57,58,60,62,63,64,70,71,74,75,76,77,78,79,80,94,110,111,113,121,123,128,133,139,150,160,],[59,59,59,59,59,59,59,59,59,59,59,59,59,59,59,59,59,59,59,59,59,59,59,59,59,59,59,59,59,]),'case':([28,55,56,57,58,60,62,63,64,70,71,74,75,76,77,78,79,80,94,110,111,113,121,123,128,133,139,150,160,],[60,60,60,60,60,60,60,60,60,60,60,60,60,60,60,60,60,60,60,60,60,60,60,60,60,60,60,60,60,]),'new':([28,55,56,57,58,60,62,63,64,70,71,74,75,76,77,78,79,80,94,110,111,113,121,123,128,133,139,150,160,],[61,61,61,61,61,61,61,61,61,61,61,61,61,61,61,61,61,61,61,61,61,61,61,61,61,61,61,61,61,]),'isvoid':([28,55,56,57,58,60,62,63,64,70,71,74,75,76,77,78,79,80,94,110,111,113,121,123,128,133,139,150,160,],[62,62,62,62,62,62,62,62,62,62,62,62,62,62,62,62,62,62,62,62,62,62,62,62,62,62,62,62,62,]),'intnot':([28,55,56,57,58,60,62,63,64,70,71,74,75,76,77,78,79,80,94,110,111,113,121,123,128,133,139,150,160,],[63,63,63,63,63,63,63,63,63,63,63,63,63,63,63,63,63,63,63,63,63,63,63,63,63,63,63,63,63,]),'not':([28,55,56,57,58,60,62,63,64,70,71,74,75,76,77,78,79,80,94,110,111,113,121,123,128,133,139,150,160,],[64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,]),'point':([35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,81,82,83,85,89,90,91,92,93,97,98,99,101,102,103,104,105,106,107,108,109,112,118,125,126,134,135,136,137,140,141,147,151,153,156,157,158,159,162,163,],[-67,72,-10,-11,-12,-13,-14,-15,-16,-17,-18,-19,-20,-21,-22,-23,-63,-64,-65,-66,72,72,72,72,72,-51,72,72,72,72,-35,72,124,72,72,72,72,72,72,72,-62,-45,72,72,72,-36,72,72,-37,-44,72,72,72,-47,-38,72,-39,-43,72,-40,]),'arroba':([35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,81,82,83,85,89,90,91,92,93,97,98,99,102,103,104,105,106,107,108,109,112,118,125,126,134,135,136,137,140,141,147,151,153,156,157,158,159,162,163,],[-67,73,-10,-11,-12,-13,-14,-15,-16,-17,-18,-19,-20,-21,-22,-23,-63,-64,-65,-66,73,73,73,73,73,-51,73,73,73,73,-35,73,73,73,73,73,73,73,73,-62,-45,73,73,73,-36,73,73,-37,-44,73,73,73,-47,-38,73,-39,-43,73,-40,]),'plus':([35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,81,82,83,85,89,90,91,92,93,97,98,99,102,103,104,105,106,107,108,109,112,118,125,126,134,135,136,137,140,141,147,151,153,156,157,158,159,162,163,],[-67,74,-10,-11,-12,-13,-14,-15,-16,-17,-18,-19,-20,-21,-22,-23,-63,-64,-65,-66,74,74,74,74,74,-51,-52,-57,74,74,-35,74,-53,-54,-55,-56,74,74,74,-62,-45,74,74,74,-36,74,74,-37,-44,74,74,74,-47,-38,74,-39,-43,74,-40,]),'minus':([35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,81,82,83,85,89,90,91,92,93,97,98,99,102,103,104,105,106,107,108,109,112,118,125,126,134,135,136,137,140,141,147,151,153,156,157,158,159,162,163,],[-67,75,-10,-11,-12,-13,-14,-15,-16,-17,-18,-19,-20,-21,-22,-23,-63,-64,-65,-66,75,75,75,75,75,-51,-52,-57,75,75,-35,75,-53,-54,-55,-56,75,75,75,-62,-45,75,75,75,-36,75,75,-37,-44,75,75,75,-47,-38,75,-39,-43,75,-40,]),'mult':([35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,81,82,83,85,89,90,91,92,93,97,98,99,102,103,104,105,106,107,108,109,112,118,125,126,134,135,136,137,140,141,147,151,153,156,157,158,159,162,163,],[-67,76,-10,-11,-12,-13,-14,-15,-16,-17,-18,-19,-20,-21,-22,-23,-63,-64,-65,-66,76,76,76,76,76,-51,-52,-57,76,76,-35,76,76,76,-55,-56,76,76,76,-62,-45,76,76,76,-36,76,76,-37,-44,76,76,76,-47,-38,76,-39,-43,76,-40,]),'div':([35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,81,82,83,85,89,90,91,92,93,97,98,99,102,103,104,105,106,107,108,109,112,118,125,126,134,135,136,137,140,141,147,151,153,156,157,158,159,162,163,],[-67,77,-10,-11,-12,-13,-14,-15,-16,-17,-18,-19,-20,-21,-22,-23,-63,-64,-65,-66,77,77,77,77,77,-51,-52,-57,77,77,-35,77,77,77,-55,-56,77,77,77,-62,-45,77,77,77,-36,77,77,-37,-44,77,77,77,-47,-38,77,-39,-43,77,-40,]),'less':([35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,81,82,83,85,89,90,91,92,93,97,98,99,102,103,104,105,106,107,108,109,112,118,125,126,134,135,136,137,140,141,147,151,153,156,157,158,159,162,163,],[-67,78,-10,-11,-12,-13,-14,-15,-16,-17,-18,-19,-20,-21,-22,-23,-63,-64,-65,-66,78,78,78,78,78,-51,-52,-57,78,78,-35,78,-53,-54,-55,-56,None,None,None,-62,-45,78,78,78,-36,78,78,-37,-44,78,78,78,-47,-38,78,-39,-43,78,-40,]),'lesse':([35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,81,82,83,85,89,90,91,92,93,97,98,99,102,103,104,105,106,107,108,109,112,118,125,126,134,135,136,137,140,141,147,151,153,156,157,158,159,162,163,],[-67,79,-10,-11,-12,-13,-14,-15,-16,-17,-18,-19,-20,-21,-22,-23,-63,-64,-65,-66,79,79,79,79,79,-51,-52,-57,79,79,-35,79,-53,-54,-55,-56,None,None,None,-62,-45,79,79,79,-36,79,79,-37,-44,79,79,79,-47,-38,79,-39,-43,79,-40,]),'equal':([35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,81,82,83,85,89,90,91,92,93,97,98,99,102,103,104,105,106,107,108,109,112,118,125,126,134,135,136,137,140,141,147,151,153,156,157,158,159,162,163,],[-67,80,-10,-11,-12,-13,-14,-15,-16,-17,-18,-19,-20,-21,-22,-23,-63,-64,-65,-66,80,80,80,80,80,-51,-52,-57,80,80,-35,80,-53,-54,-55,-56,None,None,None,-62,-45,80,80,80,-36,80,80,-37,-44,80,80,80,-47,-38,80,-39,-43,80,-40,]),'then':([35,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,82,90,91,92,93,97,98,102,103,104,105,106,107,108,109,112,134,137,140,141,153,156,158,159,163,],[-67,-10,-11,-12,-13,-14,-15,-16,-17,-18,-19,-20,-21,-22,-23,-63,-64,-65,-66,110,-51,-52,-57,-61,-68,-35,-53,-54,-55,-56,-58,-59,-60,-62,-45,-36,-37,-44,-46,-47,-38,-39,-43,-40,]),'loop':([35,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,83,90,91,92,93,97,98,102,103,104,105,106,107,108,109,112,134,137,140,141,153,156,158,159,163,],[-67,-10,-11,-12,-13,-14,-15,-16,-17,-18,-19,-20,-21,-22,-23,-63,-64,-65,-66,111,-51,-52,-57,-61,-68,-35,-53,-54,-55,-56,-58,-59,-60,-62,-45,-36,-37,-44,-46,-47,-38,-39,-43,-40,]),'of':([35,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,89,90,91,92,93,97,98,102,103,104,105,106,107,108,109,112,134,137,140,141,153,156,158,159,163,],[-67,-10,-11,-12,-13,-14,-15,-16,-17,-18,-19,-20,-21,-22,-23,-63,-64,-65,-66,117,-51,-52,-57,-61,-68,-35,-53,-54,-55,-56,-58,-59,-60,-62,-45,-36,-37,-44,-46,-47,-38,-39,-43,-40,]),'else':([35,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,90,91,92,93,97,98,102,103,104,105,106,107,108,109,112,125,134,137,140,141,153,156,158,159,163,],[-67,-10,-11,-12,-13,-14,-15,-16,-17,-18,-19,-20,-21,-22,-23,-63,-64,-65,-66,-51,-52,-57,-61,-68,-35,-53,-54,-55,-56,-58,-59,-60,-62,-45,139,-36,-37,-44,-46,-47,-38,-39,-43,-40,]),'pool':([35,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,90,91,92,93,97,98,102,103,104,105,106,107,108,109,112,126,134,137,140,141,153,156,158,159,163,],[-67,-10,-11,-12,-13,-14,-15,-16,-17,-18,-19,-20,-21,-22,-23,-63,-64,-65,-66,-51,-52,-57,-61,-68,-35,-53,-54,-55,-56,-58,-59,-60,-62,-45,140,-36,-37,-44,-46,-47,-38,-39,-43,-40,]),'fi':([35,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,90,91,92,93,97,98,102,103,104,105,106,107,108,109,112,134,137,140,141,151,153,156,158,159,163,],[-67,-10,-11,-12,-13,-14,-15,-16,-17,-18,-19,-20,-21,-22,-23,-63,-64,-65,-66,-51,-52,-57,-61,-68,-35,-53,-54,-55,-56,-58,-59,-60,-62,-45,-36,-37,-44,-46,159,-47,-38,-39,-43,-40,]),'esac':([130,143,144,145,152,164,],[-3,-3,153,-49,-48,-50,]),'implica':([154,],[160,]),} + +_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 = {'program':([0,2,],[1,4,]),'classdec':([0,2,],[2,2,]),'featurelist':([6,9,21,],[8,16,27,]),'feature':([6,9,21,],[9,9,9,]),'empty':([6,9,21,26,58,68,87,99,113,129,130,135,136,143,157,],[10,10,10,33,86,33,116,122,86,116,145,122,122,145,122,]),'attribute':([6,9,21,59,115,],[11,11,11,87,129,]),'methoddef':([6,9,21,],[12,12,12,]),'param':([20,32,],[26,68,]),'paramslistdef':([26,68,],[31,96,]),'expression':([28,55,56,57,58,60,62,63,64,70,71,74,75,76,77,78,79,80,94,110,111,113,121,123,128,133,139,150,160,],[36,81,82,83,85,89,91,92,93,97,99,102,103,104,105,106,107,108,118,125,126,85,135,136,141,147,151,157,162,]),'constantexp':([28,55,56,57,58,60,62,63,64,70,71,74,75,76,77,78,79,80,94,110,111,113,121,123,128,133,139,150,160,],[37,37,37,37,37,37,37,37,37,37,37,37,37,37,37,37,37,37,37,37,37,37,37,37,37,37,37,37,37,]),'identifier':([28,55,56,57,58,60,62,63,64,70,71,74,75,76,77,78,79,80,94,110,111,113,121,123,128,133,139,150,160,],[38,38,38,38,38,38,38,38,38,38,38,38,38,38,38,38,38,38,38,38,38,38,38,38,38,38,38,38,38,]),'assignment':([28,55,56,57,58,60,62,63,64,70,71,74,75,76,77,78,79,80,94,110,111,113,121,123,128,133,139,150,160,],[39,39,39,39,39,39,39,39,39,39,39,39,39,39,39,39,39,39,39,39,39,39,39,39,39,39,39,39,39,]),'dispatch':([28,55,56,57,58,60,62,63,64,70,71,74,75,76,77,78,79,80,94,110,111,113,121,123,128,133,139,150,160,],[40,40,40,40,40,40,40,40,40,40,40,40,40,40,40,40,40,40,40,40,40,40,40,40,40,40,40,40,40,]),'conditional':([28,55,56,57,58,60,62,63,64,70,71,74,75,76,77,78,79,80,94,110,111,113,121,123,128,133,139,150,160,],[41,41,41,41,41,41,41,41,41,41,41,41,41,41,41,41,41,41,41,41,41,41,41,41,41,41,41,41,41,]),'loopexp':([28,55,56,57,58,60,62,63,64,70,71,74,75,76,77,78,79,80,94,110,111,113,121,123,128,133,139,150,160,],[42,42,42,42,42,42,42,42,42,42,42,42,42,42,42,42,42,42,42,42,42,42,42,42,42,42,42,42,42,]),'blockexp':([28,55,56,57,58,60,62,63,64,70,71,74,75,76,77,78,79,80,94,110,111,113,121,123,128,133,139,150,160,],[43,43,43,43,43,43,43,43,43,43,43,43,43,43,43,43,43,43,43,43,43,43,43,43,43,43,43,43,43,]),'letexp':([28,55,56,57,58,60,62,63,64,70,71,74,75,76,77,78,79,80,94,110,111,113,121,123,128,133,139,150,160,],[44,44,44,44,44,44,44,44,44,44,44,44,44,44,44,44,44,44,44,44,44,44,44,44,44,44,44,44,44,]),'caseexp':([28,55,56,57,58,60,62,63,64,70,71,74,75,76,77,78,79,80,94,110,111,113,121,123,128,133,139,150,160,],[45,45,45,45,45,45,45,45,45,45,45,45,45,45,45,45,45,45,45,45,45,45,45,45,45,45,45,45,45,]),'newexp':([28,55,56,57,58,60,62,63,64,70,71,74,75,76,77,78,79,80,94,110,111,113,121,123,128,133,139,150,160,],[46,46,46,46,46,46,46,46,46,46,46,46,46,46,46,46,46,46,46,46,46,46,46,46,46,46,46,46,46,]),'isvoidexp':([28,55,56,57,58,60,62,63,64,70,71,74,75,76,77,78,79,80,94,110,111,113,121,123,128,133,139,150,160,],[47,47,47,47,47,47,47,47,47,47,47,47,47,47,47,47,47,47,47,47,47,47,47,47,47,47,47,47,47,]),'aritmetica':([28,55,56,57,58,60,62,63,64,70,71,74,75,76,77,78,79,80,94,110,111,113,121,123,128,133,139,150,160,],[48,48,48,48,48,48,48,48,48,48,48,48,48,48,48,48,48,48,48,48,48,48,48,48,48,48,48,48,48,]),'comparison':([28,55,56,57,58,60,62,63,64,70,71,74,75,76,77,78,79,80,94,110,111,113,121,123,128,133,139,150,160,],[49,49,49,49,49,49,49,49,49,49,49,49,49,49,49,49,49,49,49,49,49,49,49,49,49,49,49,49,49,]),'parenexpression':([28,55,56,57,58,60,62,63,64,70,71,74,75,76,77,78,79,80,94,110,111,113,121,123,128,133,139,150,160,],[50,50,50,50,50,50,50,50,50,50,50,50,50,50,50,50,50,50,50,50,50,50,50,50,50,50,50,50,50,]),'expressionlist':([58,113,],[84,127,]),'letattributelist':([87,129,],[114,142,]),'expressionparams':([99,135,136,157,],[120,148,149,161,]),'subcase':([117,130,143,],[130,143,143,]),'listcase':([130,143,],[144,152,]),} + +_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' -> program","S'",1,None,None,None), + ('program -> classdec program','program',2,'p_program','TigerandButiCompiler.py',314), + ('program -> classdec','program',1,'p_program','TigerandButiCompiler.py',315), + ('empty -> ','empty',0,'p_empty','TigerandButiCompiler.py',327), + ('classdec -> class type lbracket featurelist rbracket pcoma','classdec',6,'p_classdec','TigerandButiCompiler.py',331), + ('classdec -> class type inherits type lbracket featurelist rbracket pcoma','classdec',8,'p_classdec','TigerandButiCompiler.py',332), + ('featurelist -> feature featurelist','featurelist',2,'p_featurelist','TigerandButiCompiler.py',343), + ('featurelist -> empty','featurelist',1,'p_featurelist','TigerandButiCompiler.py',344), + ('feature -> attribute pcoma','feature',2,'p_feature','TigerandButiCompiler.py',353), + ('feature -> methoddef pcoma','feature',2,'p_feature','TigerandButiCompiler.py',354), + ('expression -> constantexp','expression',1,'p_expression','TigerandButiCompiler.py',359), + ('expression -> identifier','expression',1,'p_expression','TigerandButiCompiler.py',360), + ('expression -> assignment','expression',1,'p_expression','TigerandButiCompiler.py',361), + ('expression -> dispatch','expression',1,'p_expression','TigerandButiCompiler.py',362), + ('expression -> conditional','expression',1,'p_expression','TigerandButiCompiler.py',363), + ('expression -> loopexp','expression',1,'p_expression','TigerandButiCompiler.py',364), + ('expression -> blockexp','expression',1,'p_expression','TigerandButiCompiler.py',365), + ('expression -> letexp','expression',1,'p_expression','TigerandButiCompiler.py',366), + ('expression -> caseexp','expression',1,'p_expression','TigerandButiCompiler.py',367), + ('expression -> newexp','expression',1,'p_expression','TigerandButiCompiler.py',368), + ('expression -> isvoidexp','expression',1,'p_expression','TigerandButiCompiler.py',369), + ('expression -> aritmetica','expression',1,'p_expression','TigerandButiCompiler.py',370), + ('expression -> comparison','expression',1,'p_expression','TigerandButiCompiler.py',371), + ('expression -> parenexpression','expression',1,'p_expression','TigerandButiCompiler.py',372), + ('methoddef -> id lparen rparen dpoint type lbracket expression rbracket','methoddef',8,'p_methoddef','TigerandButiCompiler.py',377), + ('methoddef -> id lparen param paramslistdef rparen dpoint type lbracket expression rbracket','methoddef',10,'p_methoddef','TigerandButiCompiler.py',378), + ('expressionlist -> expression pcoma expressionlist','expressionlist',3,'p_expressionlist','TigerandButiCompiler.py',390), + ('expressionlist -> empty','expressionlist',1,'p_expressionlist','TigerandButiCompiler.py',391), + ('param -> id dpoint type','param',3,'p_param','TigerandButiCompiler.py',400), + ('attribute -> id dpoint type','attribute',3,'p_attribute','TigerandButiCompiler.py',408), + ('attribute -> id dpoint type assign expression','attribute',5,'p_attribute','TigerandButiCompiler.py',409), + ('letattributelist -> coma attribute letattributelist','letattributelist',3,'p_letattributelist','TigerandButiCompiler.py',420), + ('letattributelist -> empty','letattributelist',1,'p_letattributelist','TigerandButiCompiler.py',421), + ('paramslistdef -> coma param paramslistdef','paramslistdef',3,'p_paramslistdef','TigerandButiCompiler.py',430), + ('paramslistdef -> empty','paramslistdef',1,'p_paramslistdef','TigerandButiCompiler.py',431), + ('dispatch -> id lparen rparen','dispatch',3,'p_dispatch','TigerandButiCompiler.py',440), + ('dispatch -> id lparen expression expressionparams rparen','dispatch',5,'p_dispatch','TigerandButiCompiler.py',441), + ('dispatch -> expression point id lparen rparen','dispatch',5,'p_dispatch','TigerandButiCompiler.py',442), + ('dispatch -> expression point id lparen expression expressionparams rparen','dispatch',7,'p_dispatch','TigerandButiCompiler.py',443), + ('dispatch -> expression arroba type point id lparen rparen','dispatch',7,'p_dispatch','TigerandButiCompiler.py',444), + ('dispatch -> expression arroba type point id lparen expression expressionparams rparen','dispatch',9,'p_dispatch','TigerandButiCompiler.py',445), + ('expressionparams -> coma expression expressionparams','expressionparams',3,'p_expressionparams','TigerandButiCompiler.py',480), + ('expressionparams -> empty','expressionparams',1,'p_expressionparams','TigerandButiCompiler.py',481), + ('conditional -> if expression then expression else expression fi','conditional',7,'p_conditional','TigerandButiCompiler.py',490), + ('loopexp -> while expression loop expression pool','loopexp',5,'p_loopexp','TigerandButiCompiler.py',498), + ('blockexp -> lbracket expressionlist rbracket','blockexp',3,'p_blockexp','TigerandButiCompiler.py',506), + ('letexp -> let attribute letattributelist in expression','letexp',5,'p_letexp','TigerandButiCompiler.py',514), + ('caseexp -> case expression of subcase listcase esac','caseexp',6,'p_caseexp','TigerandButiCompiler.py',523), + ('listcase -> subcase listcase','listcase',2,'p_listcase','TigerandButiCompiler.py',532), + ('listcase -> empty','listcase',1,'p_listcase','TigerandButiCompiler.py',533), + ('subcase -> id dpoint type implica expression pcoma','subcase',6,'p_subcase','TigerandButiCompiler.py',543), + ('newexp -> new type','newexp',2,'p_newexp','TigerandButiCompiler.py',551), + ('isvoidexp -> isvoid expression','isvoidexp',2,'p_isvoidexp','TigerandButiCompiler.py',559), + ('aritmetica -> expression plus expression','aritmetica',3,'p_aritmetica','TigerandButiCompiler.py',564), + ('aritmetica -> expression minus expression','aritmetica',3,'p_aritmetica','TigerandButiCompiler.py',565), + ('aritmetica -> expression mult expression','aritmetica',3,'p_aritmetica','TigerandButiCompiler.py',566), + ('aritmetica -> expression div expression','aritmetica',3,'p_aritmetica','TigerandButiCompiler.py',567), + ('aritmetica -> intnot expression','aritmetica',2,'p_aritmetica','TigerandButiCompiler.py',568), + ('comparison -> expression less expression','comparison',3,'p_comparison','TigerandButiCompiler.py',591), + ('comparison -> expression lesse expression','comparison',3,'p_comparison','TigerandButiCompiler.py',592), + ('comparison -> expression equal expression','comparison',3,'p_comparison','TigerandButiCompiler.py',593), + ('comparison -> not expression','comparison',2,'p_comparison','TigerandButiCompiler.py',594), + ('parenexpression -> lparen expression rparen','parenexpression',3,'p_parenexpression','TigerandButiCompiler.py',616), + ('constantexp -> number','constantexp',1,'p_constantexp','TigerandButiCompiler.py',622), + ('constantexp -> string','constantexp',1,'p_constantexp','TigerandButiCompiler.py',623), + ('constantexp -> true','constantexp',1,'p_constantexp','TigerandButiCompiler.py',624), + ('constantexp -> false','constantexp',1,'p_constantexp','TigerandButiCompiler.py',625), + ('identifier -> id','identifier',1,'p_identifier','TigerandButiCompiler.py',638), + ('assignment -> id assign expression','assignment',3,'p_assignment','TigerandButiCompiler.py',646), +] diff --git a/src/visitor.py b/src/visitor.py new file mode 100644 index 00000000..96484283 --- /dev/null +++ b/src/visitor.py @@ -0,0 +1,80 @@ +# The MIT License (MIT) +# +# Copyright (c) 2013 Curtis Schlak +# +# Permission is hereby granted, free of charge, to any person obtaining a copy +# of this software and associated documentation files (the "Software"), to deal +# in the Software without restriction, including without limitation the rights +# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +# copies of the Software, and to permit persons to whom the Software is +# furnished to do so, subject to the following conditions: +# +# The above copyright notice and this permission notice shall be included in +# all copies or substantial portions of the Software. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +# THE SOFTWARE. + +import inspect + +__all__ = ['on', 'when'] + +def on(param_name): + def f(fn): + dispatcher = Dispatcher(param_name, fn) + return dispatcher + return f + + +def when(param_type): + def f(fn): + frame = inspect.currentframe().f_back + func_name = fn.func_name if 'func_name' in dir(fn) else fn.__name__ + dispatcher = frame.f_locals[func_name] + if not isinstance(dispatcher, Dispatcher): + dispatcher = dispatcher.dispatcher + dispatcher.add_target(param_type, fn) + def ff(*args, **kw): + return dispatcher(*args, **kw) + ff.dispatcher = dispatcher + return ff + return f + + +class Dispatcher(object): + def __init__(self, param_name, fn): + frame = inspect.currentframe().f_back.f_back + top_level = frame.f_locals == frame.f_globals + self.param_index = self.__argspec(fn).args.index(param_name) + self.param_name = param_name + self.targets = {} + + def __call__(self, *args, **kw): + typ = args[self.param_index].__class__ + d = self.targets.get(typ) + if d is not None: + return d(*args, **kw) + else: + issub = issubclass + t = self.targets + ks = t.keys() + ans = [t[k](*args, **kw) for k in ks if issub(typ, k)] + if len(ans) == 1: + return ans.pop() + return ans + + def add_target(self, typ, target): + self.targets[typ] = target + + @staticmethod + def __argspec(fn): + # Support for Python 3 type hints requires inspect.getfullargspec + if hasattr(inspect, 'getfullargspec'): + return inspect.getfullargspec(fn) + else: + return inspect.getargspec(fn) diff --git a/tests/semantic/features1.cl b/tests/semantic/features1.cl old mode 100755 new mode 100644 index 96dd8ebc..66f650f4 --- a/tests/semantic/features1.cl +++ b/tests/semantic/features1.cl @@ -1,19 +1,19 @@ -(* -No method name may be defined multiple times in -a class, and no attribute name may be defined multiple times in a class, but a method and an attribute -may have the same name. -*) - -class Main inherits IO { - main(): IO { out_string("hi!") }; - - main: IO <- out_string("bye!"); -}; - -class A { - x: Int <- 3; - - x(): Int { 3 }; - - x: String <- ":)"; +(* +No method name may be defined multiple times in +a class, and no attribute name may be defined multiple times in a class, but a method and an attribute +may have the same name. +*) + +class Main inherits IO { + main(): IO { out_string("hi!") }; + + main: IO <- out_string("bye!"); +}; + +class A { + x: Int <- 3; + + x(): Int { 3 }; + + x: String <- ":)"; }; \ No newline at end of file diff --git a/tests/semantic/features1_error.txt b/tests/semantic/features1_error.txt old mode 100755 new mode 100644 diff --git a/tests/semantic/features2.cl b/tests/semantic/features2.cl old mode 100755 new mode 100644 index 2db177f7..5b1f7e9d --- a/tests/semantic/features2.cl +++ b/tests/semantic/features2.cl @@ -1,19 +1,19 @@ -(* -No method name may be defined multiple times in -a class, and no attribute name may be defined multiple times in a class, but a method and an attribute -may have the same name. -*) - -class Main inherits IO { - main(): IO { out_string("hi!") }; - - main: IO <- out_string("bye!"); -}; - -class A { - x: Int <- 3; - - x(): String { "3" }; - - x(): String { ":)" }; +(* +No method name may be defined multiple times in +a class, and no attribute name may be defined multiple times in a class, but a method and an attribute +may have the same name. +*) + +class Main inherits IO { + main(): IO { out_string("hi!") }; + + main: IO <- out_string("bye!"); +}; + +class A { + x: Int <- 3; + + x(): String { "3" }; + + x(): String { ":)" }; }; \ No newline at end of file diff --git a/tests/semantic/features2_error.txt b/tests/semantic/features2_error.txt old mode 100755 new mode 100644 diff --git a/tests/semantic/features3.cl b/tests/semantic/features3.cl old mode 100755 new mode 100644 index a3b59259..a892d011 --- a/tests/semantic/features3.cl +++ b/tests/semantic/features3.cl @@ -1,15 +1,15 @@ --- Missing type - -class Main inherits IO { - main(): IO { out_string("hi!") }; - - main: IO <- out_string("bye!"); -}; - -class A { - x: Int <- 3; - - x(): Int { 3 }; - - c: Cadena; +-- Missing type + +class Main inherits IO { + main(): IO { out_string("hi!") }; + + main: IO <- out_string("bye!"); +}; + +class A { + x: Int <- 3; + + x(): Int { 3 }; + + c: Cadena; }; \ No newline at end of file diff --git a/tests/semantic/features3_error.txt b/tests/semantic/features3_error.txt old mode 100755 new mode 100644 diff --git a/tests/semantic/inheritance1.cl b/tests/semantic/inheritance1.cl old mode 100755 new mode 100644 index 5adb59d9..1d92da30 --- a/tests/semantic/inheritance1.cl +++ b/tests/semantic/inheritance1.cl @@ -1,19 +1,19 @@ ---It is illegal to redefine attribute names. - -class Main inherits IO { - main(): IO { out_string("hi!") }; - - main: IO <- out_string("bye!"); -}; - -class A { - x: Int <- 3; - - x(): String { ":)" }; -}; - -class B inherits A { - x: Int; - - div(a: Int, b: Int): Int { a / b}; +--It is illegal to redefine attribute names. + +class Main inherits IO { + main(): IO { out_string("hi!") }; + + main: IO <- out_string("bye!"); +}; + +class A { + x: Int <- 3; + + x(): String { ":)" }; +}; + +class B inherits A { + x: Int; + + div(a: Int, b: Int): Int { a / b}; }; \ No newline at end of file diff --git a/tests/semantic/inheritance1_error.txt b/tests/semantic/inheritance1_error.txt old mode 100755 new mode 100644 diff --git a/tests/semantic/inheritance2.cl b/tests/semantic/inheritance2.cl old mode 100755 new mode 100644 index 2ed46f37..d453eca0 --- a/tests/semantic/inheritance2.cl +++ b/tests/semantic/inheritance2.cl @@ -1,19 +1,19 @@ ---If C inherits from P, then P must have a class definition somewhere in the program. - -class Main inherits IO { - main(): IO { out_string("hi!") }; - - main: IO <- out_string("bye!"); -}; - -class Alo { - x: Int <- 3; - - x(): String { "3" }; -}; - -class B inherits A { - div(a: Int, b: Int): Int { a / b}; - - x: String <- "2"; +--If C inherits from P, then P must have a class definition somewhere in the program. + +class Main inherits IO { + main(): IO { out_string("hi!") }; + + main: IO <- out_string("bye!"); +}; + +class Alo { + x: Int <- 3; + + x(): String { "3" }; +}; + +class B inherits A { + div(a: Int, b: Int): Int { a / b}; + + x: String <- "2"; }; \ No newline at end of file diff --git a/tests/semantic/inheritance2_error.txt b/tests/semantic/inheritance2_error.txt old mode 100755 new mode 100644 diff --git a/tests/semantic/inheritance3.cl b/tests/semantic/inheritance3.cl old mode 100755 new mode 100644 index 83a4e132..3ff170de --- a/tests/semantic/inheritance3.cl +++ b/tests/semantic/inheritance3.cl @@ -1,13 +1,13 @@ ---The parent-child relation on classes defines a graph. This graph may not contain cycles. - -class Main inherits IO { - main(): IO { out_string("hi!") }; - - main: IO <- out_string("bye!"); -}; - -class A inherits A { - x: Int <- 3; - - x(): String { ":)" }; +--The parent-child relation on classes defines a graph. This graph may not contain cycles. + +class Main inherits IO { + main(): IO { out_string("hi!") }; + + main: IO <- out_string("bye!"); +}; + +class A inherits A { + x: Int <- 3; + + x(): String { ":)" }; }; \ No newline at end of file diff --git a/tests/semantic/inheritance4.cl b/tests/semantic/inheritance4.cl old mode 100755 new mode 100644 index efe6e9a6..c985484b --- a/tests/semantic/inheritance4.cl +++ b/tests/semantic/inheritance4.cl @@ -1,19 +1,19 @@ ---The parent-child relation on classes defines a graph. This graph may not contain cycles. - -class Main inherits IO { - main(): IO { out_string("hi!") }; - - main: IO <- out_string("bye!"); -}; - -class A inherits B { - x: Int <- 3; - - x(): String { ":)" }; -}; - -class B inherits A { - y: Int <- 2; - - div(a: Int, b: Int): Int { a / b}; +--The parent-child relation on classes defines a graph. This graph may not contain cycles. + +class Main inherits IO { + main(): IO { out_string("hi!") }; + + main: IO <- out_string("bye!"); +}; + +class A inherits B { + x: Int <- 3; + + x(): String { ":)" }; +}; + +class B inherits A { + y: Int <- 2; + + div(a: Int, b: Int): Int { a / b}; }; \ No newline at end of file diff --git a/tests/semantic/inheritance5.cl b/tests/semantic/inheritance5.cl old mode 100755 new mode 100644 index 6650368c..f6ed885c --- a/tests/semantic/inheritance5.cl +++ b/tests/semantic/inheritance5.cl @@ -1,21 +1,21 @@ ---The parent-child relation on classes defines a graph. This graph may not contain cycles. - -class Main inherits IO { - main(): IO { out_string("hi!") }; - - main: IO <- out_string("bye!"); -}; - -class A inherits B { - x: Int <- 3; - - x(): String { ":)" }; -}; - -class B inherits C { - y: Int <- 2; - - div(a: Int, b: Int): Int { a / b}; -}; - +--The parent-child relation on classes defines a graph. This graph may not contain cycles. + +class Main inherits IO { + main(): IO { out_string("hi!") }; + + main: IO <- out_string("bye!"); +}; + +class A inherits B { + x: Int <- 3; + + x(): String { ":)" }; +}; + +class B inherits C { + y: Int <- 2; + + div(a: Int, b: Int): Int { a / b}; +}; + class C inherits A { }; \ No newline at end of file