probando

src/Readme.md

@@ -1,78 +1,78 @@
-# COOL: Proyecto de Compilación
-
-La evaluación de la asignatura Complementos de Compilación, inscrita en el programa del 4to año de la Licenciatura en Ciencia de la Computación de la Facultad de Matemática y Computación de la
-Universidad de La Habana, consiste este curso en la implementación de un compilador completamente
-funcional para el lenguaje _COOL_.
-
-_COOL (Classroom Object-Oriented Language)_ es un pequeño lenguaje que puede ser implementado con un esfuerzo razonable en un semestre del curso. Aun así, _COOL_ mantiene muchas de las características de los lenguajes de programación modernos, incluyendo orientación a objetos, tipado estático y manejo automático de memoria.
-
-### Sobre el Lenguaje COOL
-
-Ud. podrá encontrar la especificación formal del lenguaje COOL en el documento _"COOL Language Reference Manual"_, que se distribuye junto con el presente texto.
-
-## Código Fuente
-
-### Compilando su proyecto
-
-Si es necesario compilar su proyecto, incluya todas las instrucciones necesarias en un archivo [`/src/makefile`](/src/makefile).
-Durante la evaluación su proyecto se compilará ejecutando la siguiente secuencia:
-
-```bash
-$ cd source
-$ make clean
-$ make
-```
-
-### Ejecutando su proyecto
-
-Incluya en un archivo [`/src/coolc.sh`](/src/coolc.sh) todas las instrucciones que hacen falta para lanzar su compilador. Recibirá como entrada un archivo con extensión `.cl` y debe generar como salida un archivo `.mips` cuyo nombre será el mismo que la entrada.
-
-Para lanzar el compilador, se ejecutará la siguiente instrucción:
-
-```bash
-$ cd source
-$ ./coolc.sh <input_file.cl>
-```
-
-### Sobre el Compilador de COOL
-
-El compilador de COOL se ejecutará como se ha definido anteriormente.
-En caso de que no ocurran errores durante la operación del compilador, **coolc.sh** deberá terminar con código de salida 0, generar (o sobrescribir si ya existe) en la misma carpeta del archivo **.cl** procesado, y con el mismo nombre que éste, un archivo con extension **.mips** que pueda ser ejecutado con **spim**. Además, reportar a la salida estándar solamente lo siguiente:
-
-    <línea_con_nombre_y_versión_del_compilador>
-    <línea_con_copyright_para_el_compilador>
-
-En caso de que ocurran errores durante la operación del compilador, **coolc.sh** deberá terminar con código
-de salida (exit code) 1 y reportar a la salida estándar (standard output stream) lo que sigue...
-
-    <línea_con_nombre_y_versión_del_compilador>
-    <línea_con_copyright_para_el_compilador>
-    <línea_de_error>_1
-    ...
-    <línea_de_error>_n
-
-... donde `<línea_de_error>_i` tiene el siguiente formato:
-
-    (<línea>,<columna>) - <tipo_de_error>: <texto_del_error>
-
-Los campos `<línea>` y `<columna>` indican la ubicación del error en el fichero **.cl** procesado. En caso
-de que la naturaleza del error sea tal que no pueda asociárselo a una línea y columna en el archivo de
-código fuente, el valor de dichos campos debe ser 0.
-
-El campo `<tipo_de_error>` será alguno entre:
-
-- `CompilerError`: se reporta al detectar alguna anomalía con la entrada del compilador. Por ejemplo, si el fichero a compilar no existe.
-- `LexicographicError`: errores detectados por el lexer.
-- `SyntacticError`: errores detectados por el parser.
-- `NameError`: se reporta al referenciar un `identificador` en un ámbito en el que no es visible.
-- `TypeError`: se reporta al detectar un problema de tipos. Incluye:
-    - incompatibilidad de tipos entre `rvalue` y `lvalue`,
-    - operación no definida entre objetos de ciertos tipos, y
-    - tipo referenciado pero no definido.
-- `AttributeError`: se reporta cuando un atributo o método se referencia pero no está definido.
-- `SemanticError`: cualquier otro error semántico.
-
-### Sobre la Implementación del Compilador de COOL
-
-El compilador debe estar implementado en `python`. Usted debe utilizar una herramienta generadora de analizadores
-lexicográficos y sintácticos. Puede utilizar la que sea de su preferencia.
+# COOL: Proyecto de Compilación
+
+La evaluación de la asignatura Complementos de Compilación, inscrita en el programa del 4to año de la Licenciatura en Ciencia de la Computación de la Facultad de Matemática y Computación de la
+Universidad de La Habana, consiste este curso en la implementación de un compilador completamente
+funcional para el lenguaje _COOL_.
+
+_COOL (Classroom Object-Oriented Language)_ es un pequeño lenguaje que puede ser implementado con un esfuerzo razonable en un semestre del curso. Aun así, _COOL_ mantiene muchas de las características de los lenguajes de programación modernos, incluyendo orientación a objetos, tipado estático y manejo automático de memoria.
+
+### Sobre el Lenguaje COOL
+
+Ud. podrá encontrar la especificación formal del lenguaje COOL en el documento _"COOL Language Reference Manual"_, que se distribuye junto con el presente texto.
+
+## Código Fuente
+
+### Compilando su proyecto
+
+Si es necesario compilar su proyecto, incluya todas las instrucciones necesarias en un archivo [`/src/makefile`](/src/makefile).
+Durante la evaluación su proyecto se compilará ejecutando la siguiente secuencia:
+
+```bash
+$ cd source
+$ make clean
+$ make
+```
+
+### Ejecutando su proyecto
+
+Incluya en un archivo [`/src/coolc.sh`](/src/coolc.sh) todas las instrucciones que hacen falta para lanzar su compilador. Recibirá como entrada un archivo con extensión `.cl` y debe generar como salida un archivo `.mips` cuyo nombre será el mismo que la entrada.
+
+Para lanzar el compilador, se ejecutará la siguiente instrucción:
+
+```bash
+$ cd source
+$ ./coolc.sh <input_file.cl>
+```
+
+### Sobre el Compilador de COOL
+
+El compilador de COOL se ejecutará como se ha definido anteriormente.
+En caso de que no ocurran errores durante la operación del compilador, **coolc.sh** deberá terminar con código de salida 0, generar (o sobrescribir si ya existe) en la misma carpeta del archivo **.cl** procesado, y con el mismo nombre que éste, un archivo con extension **.mips** que pueda ser ejecutado con **spim**. Además, reportar a la salida estándar solamente lo siguiente:
+
+    <línea_con_nombre_y_versión_del_compilador>
+    <línea_con_copyright_para_el_compilador>
+
+En caso de que ocurran errores durante la operación del compilador, **coolc.sh** deberá terminar con código
+de salida (exit code) 1 y reportar a la salida estándar (standard output stream) lo que sigue...
+
+    <línea_con_nombre_y_versión_del_compilador>
+    <línea_con_copyright_para_el_compilador>
+    <línea_de_error>_1
+    ...
+    <línea_de_error>_n
+
+... donde `<línea_de_error>_i` tiene el siguiente formato:
+
+    (<línea>,<columna>) - <tipo_de_error>: <texto_del_error>
+
+Los campos `<línea>` y `<columna>` indican la ubicación del error en el fichero **.cl** procesado. En caso
+de que la naturaleza del error sea tal que no pueda asociárselo a una línea y columna en el archivo de
+código fuente, el valor de dichos campos debe ser 0.
+
+El campo `<tipo_de_error>` será alguno entre:
+
+- `CompilerError`: se reporta al detectar alguna anomalía con la entrada del compilador. Por ejemplo, si el fichero a compilar no existe.
+- `LexicographicError`: errores detectados por el lexer.
+- `SyntacticError`: errores detectados por el parser.
+- `NameError`: se reporta al referenciar un `identificador` en un ámbito en el que no es visible.
+- `TypeError`: se reporta al detectar un problema de tipos. Incluye:
+    - incompatibilidad de tipos entre `rvalue` y `lvalue`,
+    - operación no definida entre objetos de ciertos tipos, y
+    - tipo referenciado pero no definido.
+- `AttributeError`: se reporta cuando un atributo o método se referencia pero no está definido.
+- `SemanticError`: cualquier otro error semántico.
+
+### Sobre la Implementación del Compilador de COOL
+
+El compilador debe estar implementado en `python`. Usted debe utilizar una herramienta generadora de analizadores
+lexicográficos y sintácticos. Puede utilizar la que sea de su preferencia.

src/check_inherit.py

@@ -0,0 +1,96 @@
+import visitor
+import cool_ast as ast
+from errors import *
+
+class CheckInherintance1:
+	def __init__(self, types):
+		self.types = types
+		self.errors = False
+
+	@visitor.on('node')
+	def visit(self, node):
+		pass
+
+	@visitor.when(ast.ProgramNode)
+	def visit(self, node):
+		for expr in node.expr:
+			self.visit(expr)
+
+	@visitor.when(ast.ClassNode)
+	def visit(self, node):
+		if node.inherits:
+			if not self.types.is_defined(node.inherits):
+				self.errors = True
+				print(TypeError(node.line, node.index2, "Class {} inherits from an undefined class {}.".format(node.type, node.inherits)))
+			else:
+				parent = self.types.get_type(node.inherits)
+				p = parent
+				#Check cycles
+				while p != None:
+					if p.name == node.type:
+						self.errors = True
+						print(SemanticError(node.line, node.index2, "Class {}, or an ancestor of {}, is involved in an inheritance cycle.".format(node.type, node.type)))
+						return
+					p = p.inherits
+				self.types.change_inherits(node.type, node.inherits)
+
+class CheckInherintance2:
+	def __init__(self):
+		self.errors = False
+
+	@visitor.on('node')
+	def visit(self, node):
+		pass
+
+	@visitor.when(ast.ProgramNode)
+	def visit(self, node):
+		for expr in node.expr:
+			self.visit(expr)
+
+	@visitor.when(ast.ClassNode)
+	def visit(self, node):
+		for n in node.body:
+			self.visit(n, node.info)
+
+	@visitor.when(ast.PropertyNode)
+	def visit(self, node, info):
+		self.visit(node.decl, info)
+
+	#Check attribute inherited
+	@visitor.when(ast.DeclarationNode)
+	def visit(self, node, info):
+		parent = info.inherits
+		while parent != None:
+			if node.id in parent.attrb.keys():
+				aux = parent.attrb[node.id]
+				if node.type == aux.decl.type:
+					self.errors = True
+					print(SemanticError(node.line, node.index, "Attribute {} is an attribute of an inherited class.".format(node.id)))
+					break
+			parent = parent.inherits
+
+	#Check overloads methods
+	@visitor.when(ast.MethodNode)
+	def visit(self, node, info):
+		parent = info.inherits
+		while parent != None:
+			if node.name in parent.methods.keys():
+				aux = parent.methods[node.name]
+				if node.type_ret != aux.type_ret:
+					self.errors = True
+					print(SemanticError(node.line, node.index2, "In redefined method {}, return type {} is different from original return type {}.".format(node.name, node.type_ret, aux.type_ret)))
+					break
+				elif len(node.params) != len(aux.params_types):
+						self.errors = True
+						print(SemanticError(node.line, node.index, "Incompatible number of formal parameters in redefined method {}.".format(node.name)))
+						break						
+				else:
+					params = aux.params_types
+					i = -1
+					for param in node.params:
+						i += 1 
+						if param.type != params[i]:
+							self.errors = True
+							print(SemanticError(param.line, param.index, "In redefined method {}, parameter type {} is different from original type {}.".format(node.name, param.type, params[i])))
+							return
+			parent = parent.inherits