Permalink
Browse files

comprobacion de tipos, y ambitos

  • Loading branch information...
1 parent a7e1757 commit d651ef320da5c48c3181564bfccf5884a4a0c4d2 Jose Matute committed May 4, 2012
Showing with 2,484 additions and 1,209 deletions.
  1. +358 −0 ;
  2. +26 −8 Main.java
  3. +11 −0 Objeto.java
  4. +25 −2 Probando_declar.vb
  5. +2 −4 Registro.java
  6. +45 −9 Tipo.java
  7. +1,495 −1,030 parser.java
  8. +432 −135 prueba.cup
  9. +2 −2 prueba.java
  10. +2 −2 prueba.java~
  11. +13 −13 sym.java
  12. +48 −2 tabla.java
  13. +25 −2 tmp.txt
View
358 ;
@@ -0,0 +1,358 @@
+import java_cup.runtime.*;
+import java.util.*;
+parser code {:
+
+ String errores = "";
+ Boolean has_main = false;
+ Boolean first_time = true;
+ Boolean in_method = false;
+
+ tabla ambito;
+ HashMap<String,Tipo> seen_types;
+ Tipo tmp_tipo;
+
+ public int getline(Object info){
+ if(info instanceof java_cup.runtime.Symbol) {
+ java_cup.runtime.Symbol s=((java_cup.runtime.Symbol)info);
+ return s.left;
+ }
+ return -1;
+
+}
+
+
+ public void report_error(String message, Object info) {
+ StringBuffer m = new StringBuffer("Error");
+ if(info instanceof java_cup.runtime.Symbol) {
+ java_cup.runtime.Symbol s=((java_cup.runtime.Symbol)info);
+ if(s.left >= 0) {
+ m.append(" en linea "+(s.left+1));
+ if (s.right >= 0)
+ m.append(", y columna "+(s.right+1));
+ }
+ }
+ message = message.replaceAll("Syntax error","Error de sintaxis");
+ m.append(" : "+message);
+
+ errores += m;
+ errores += "\n";
+ System.out.println(m);
+ }
+
+ public void report_fatal_error(String message, Object info) {
+ message = message.replaceAll("Couldn't repair and continue parse","No se pudo recuperar");
+ report_error(message, info);
+
+ System.exit(1);
+ }
+
+:}
+
+terminal DO, PARDER, PARIZQ, TO, AS, DIM, SEPARADOR, FIN, REF, SUB, FUNCTION;
+terminal IGUAL,LOOP,IF,THEN, ELSE, ELSEIF,END,FOR,NEXT,WHILE ,NUM,TRUE,FALSE;
+terminal String NAME,OPREL,TIPO;
+terminal WRITE,WRITELN,INPUT;
+terminal POR,ENTRE,MAS,MENOS,ERROR;
+terminal TYPE,EXIT, PUNTO,CADENA,NOT,SALTOCADENA;
+non terminal String vars;
+non terminal Tipo tipo;
+
+non terminal Object statement, metodo, programa,linea, declaracion,declar_var, statements, loop_for, do_loop, if_block;
+non terminal Object schrodingerArgument,asignacion,if_inner,list_declar,list_expressions,argument, argumentlist, argumentlistHelper,bloque;
+non terminal Object variables_declar2,list_declar2,declaracion2,cadena_s,salir_param,variables_declar;
+non terminal Object retorno,salir_if,end_func,end_type,regresar,dectype,paramHelper,parametros,end_sub;
+non terminal Object rango,salir_loop,escribe,lee,subfunc ,funcion;
+non terminal Object fake_f;
+non terminal Objeto termino, factor, expression, nombre,funcionCall;
+
+
+// COSAS QUE FALTAN AHORITA
+// manejo de errores
+
+programa ::= FIN statements | statements | FIN |;
+
+
+statements ::= linea statements
+ |linea;
+
+
+linea ::= declar_var FIN
+ | metodo
+ | dectype
+ | error FIN {: parser.report_error(" Se esperaba declaracion de variables, metodos o estructuras",sym.ERROR); :};
+
+
+variables_declar ::= declar_var FIN;
+
+
+/*----declaracion de variables----*/
+
+declar_var ::= DIM declaracion;
+
+declaracion ::= vars:n1 AS tipo:t SEPARADOR declaracion
+ {: if ( parser.first_time && !parser.in_method ){ boolean meter = parser.ambito.agregarATabla(n1,t );
+ if(!meter ) parser.report_error("Ya existe man, osea chill" + n1,sym.SEPARADOR);
+ } :}
+ | vars:n1 AS tipo:t
+ {: if (parser.first_time && !parser.in_method ){boolean meter = parser.ambito.agregarATabla(n1,t );
+ if(!meter) parser.report_error("Ya existe man,osea chill" + n1, sym.AS);
+
+ }:}
+
+
+ | error {: parser.report_error("Declaracion de variables: Se esperaba ID",sym.ERROR); :} ;
+
+vars ::= NAME:n1 {: RESULT = n1.toLowerCase() ; :}
+ | NAME:n1 SEPARADOR vars:n2
+ {: if ( parser.first_time && !parser.in_method )
+ parser.ambito.agregarATabla(n1.toLowerCase(),parser.seen_types.get("variant") );
+ RESULT = n2.toLowerCase(); :}
+ | NAME SEPARADOR error {: parser.report_error("Declaracion de variables: Se esperaba nombre",sym.NAME); :};
+
+tipo ::= TIPO:n1 {:
+ if( parser.first_time){
+ Tipo x = parser.seen_types.get(n1.toLowerCase());
+ RESULT = x;}
+ :}
+
+ | NAME:n1 {:
+ if(parser.first_time){
+ Tipo x = parser.seen_types.get(n1.toLowerCase());
+ if( x ==null)
+ {
+ x = new Tipo(n1.toLowerCase());
+ }
+ RESULT = x;} :};
+/*--------------------------------*/
+
+/*---Declaracion de metodos-------*/
+metodo ::= subfunc
+ | funcion;
+
+subfunc ::= SUB NAME:n1 argumentlist FIN end_sub FIN {: if (n1.toLowerCase().equals("main")) parser.has_main = true; :};
+
+funcion ::= FUNCTION fake_f argumentlist retorno FIN end_func FIN {: parser.ambito = parser.ambito.parent; :}
+ |FUNCTION fake_f argumentlist retorno FIN error FIN {: parser.report_error("oh well",sym.ERROR); parser.ambito = parser.ambito.parent;:}
+ | FUNCTION error FIN {: parser.report_error("Se esperaba nombre de funcion",sym.ERROR); :}
+ | FUNCTION fake_f error PARIZQ retorno FIN end_func FIN {: parser.report_error("error de parametros",sym.ERROR); parser.ambito = parser.ambito.parent;:}
+ | FUNCTION fake_f error FIN end_func FIN {: parser.report_error("error de parametros",sym.ERROR); parser.ambito = parser.ambito.parent; :}
+ | FUNCTION fake_f error {: parser.report_error("Error en firma de funcion",sym.ERROR); parser.ambito = parser.ambito.parent; :};
+
+
+fake_f ::= NAME:n1 {: tabla nuevo_ambito = new tabla(parser.ambito,n1); parser.ambito.hijos.add(nuevo_ambito);
+ parser.ambito = nuevo_ambito;
+ parser.tmp_tipo = new Tipo(n1);
+ parser.tmp_tipo.setTipoFinal(1);
+
+ :};
+
+retorno ::= AS tipo:t1 {: parser.tmp_tipo.metodo_var.add(t1);
+ parser.seen_types.put( parser.tmp_tipo.getName(), parser.tmp_tipo);
+ :}
+ | error {: parser.report_error(" No existe tipo de retorno de funcion, se esperaba: As <Tipo>",sym.AS); :};
+
+
+end_sub ::= bloque END SUB
+ | END SUB
+ | END error {: parser.report_error(" Se esperaba End Sub",sym.ERROR); :} ;
+
+end_func ::= bloque END FUNCTION
+ | END FUNCTION
+ | bloque END error {: parser.report_error(" Se esperaba End Function", sym.ERROR); :} ;
+
+end_type ::= END TYPE
+ | END error {: parser.report_error("Se esperaba End Type",sym.ERROR); :};
+
+regresar ::= EXIT SUB FIN
+ | EXIT FUNCTION FIN
+ | EXIT error {: parser.report_error(" Salida de metodos: se esperaba Exit Sub o Exit Function",sym.ERROR); :};
+
+/*--------------------------------*/
+
+
+bloque ::= list_expressions
+ | list_expressions regresar
+ | list_declar list_expressions
+ | list_declar list_expressions regresar
+ | list_declar
+ | list_declar regresar
+ | regresar ;
+
+list_declar ::= variables_declar list_declar
+ | variables_declar;
+
+
+list_expressions ::= statement list_expressions | statement ;
+
+statement ::= if_block | loop_for | do_loop | asignacion
+ |funcionCall FIN
+ | escribe | lee
+ | NAME error {: parser.report_error(" Expresion no se esperaba.",sym.ERROR); :} ;
+
+escribe ::= WRITE cadena_s FIN
+ | WRITE nombre FIN
+ | WRITE error {: parser.report_error("Se esperaba cadena o variable",sym.WRITE);:}
+ | WRITELN nombre FIN
+ | WRITELN cadena_s FIN
+ | WRITELN error {: parser.report_error("Se esperaba cadena o variable",sym.WRITELN); :};
+
+lee ::= INPUT nombre FIN
+ | INPUT error {: parser.report_error(" Se esperaba variable",sym.ERROR); :} ;
+
+
+asignacion ::= nombre IGUAL expression FIN
+ | nombre IGUAL error FIN {: parser.report_error("No se puede asignar valor, error en expresion ",sym.ERROR); :};
+
+nombre ::= NAME:n1 {: Tipo tmp = ambito.BuscarEnTabla(n1);
+ System.out.println(tmp.toString());
+ :}
+ | NAME PUNTO NAME
+ | NAME PUNTO error {: parser.report_error(" Error de <id> en asignacion ",sym.ERROR); :};
+
+
+expression ::= expression MAS termino
+ | expression MENOS termino
+ | termino
+ | expression IGUAL termino;
+
+
+termino ::= factor POR termino
+ | factor ENTRE termino
+ | factor OPREL termino
+ | factor;
+
+
+factor ::= PARDER expression PARIZQ
+ | NOT factor
+ | NUM
+ | nombre
+ | TRUE
+ | FALSE
+ | cadena_s
+ | funcionCall;
+
+cadena_s ::= CADENA SALTOCADENA FIN cadena_s
+ |CADENA
+ |CADENA SALTOCADENA error {: parser.report_error("Se esperaba nueva cadena",sym.ERROR); :};
+
+
+funcionCall ::= NAME PARDER parametros ;
+
+parametros ::= expression paramHelper
+ | salir_param;
+
+paramHelper ::= SEPARADOR expression paramHelper
+ | salir_param;
+
+salir_param ::= PARIZQ; // | error {: parser.report_error("Se esperaba )",sym.ERROR); :};
+
+
+/*---Declaracion de argumentos ---*/
+
+
+
+argumentlist ::= PARDER schrodingerArgument;
+
+
+schrodingerArgument ::= argument argumentlistHelper
+ | PARIZQ
+ | error {: parser.report_error("error de argumentos",sym.ERROR); :};
+
+
+argumentlistHelper ::= SEPARADOR argument argumentlistHelper
+ | PARIZQ
+ |error PARIZQ {: parser.report_error("error de argumentos",sym.ERROR); :};
+
+argument ::= REF NAME:n1 AS tipo:t {: parser.ambito.agregarATabla(n1,t);
+ parser.tmp_tipo.metodo_var.add(t);
+ :}
+ | REF NAME AS error {: parser.report_error(" error en argumento, se esperaba un tipo de dato",sym.ERROR); :}
+ | REF NAME error {: parser.report_error(" error en argumento, se esperaba As <un tipo de dato>",sym.ERROR); :}
+
+ | REF error AS tipo {: parser.report_error(" error en argumento, no existe nombre de argumento",sym.NAME); :}
+ | error NAME AS tipo{: parser.report_error("error en argumento, no existe tipo de referencia",sym.ERROR); :};
+
+
+
+
+/*---if-----*/
+//Ya revisado, bexpression es lo que hay que ver
+
+if_block ::= IF expression THEN FIN bloque if_inner
+ |IF expression FIN bloque if_inner
+ |IF expression THEN FIN if_inner
+ |IF expression FIN if_inner
+ |IF error FIN if_inner {: parser.report_error("Se esperaba expresion booleana",sym.ERROR); :}
+ |IF error THEN FIN if_inner {: parser.report_error("Se esperaba expresion booleana",sym.ERROR); :}
+ |IF error FIN bloque if_inner {: parser.report_error("Se esperaba expresion booleana",sym.ERROR); :}
+ |IF error THEN FIN bloque if_inner {: parser.report_error("Se esperaba expresion booleana",sym.ERROR); :};
+
+
+
+if_inner ::= salir_if FIN
+ | ELSE FIN bloque salir_if FIN
+ | ELSE FIN salir_if FIN
+ | ELSE error {: parser.report_error("Error en expresion Else",sym.ERROR); :}
+ | ELSEIF expression FIN bloque if_inner
+ | ELSEIF expression THEN FIN bloque if_inner
+ | ELSEIF expression FIN if_inner
+ | ELSEIF expression THEN FIN if_inner
+ | ELSEIF error FIN if_inner {: parser.report_error("Se esperaba expresion booleana",sym.ERROR); :}
+ | ELSEIF error THEN FIN if_inner {: parser.report_error("Se esperaba expresion booleana",sym.ERROR); :}
+ | ELSEIF error FIN bloque if_inner {: parser.report_error("Se esperaba expresion booleana",sym.ERROR); :}
+ | ELSEIF error THEN FIN bloque if_inner {: parser.report_error("Se esperaba expresion booleana",sym.ERROR); :}
+ | ELSE FIN error salir_if FIN {: parser.report_error("Sentencia inesperada despues del Else",sym.ERROR); :}
+ | error salir_if{: parser.report_error("Error del bloque if, sentencia no esperada",sym.ERROR); :};
+
+salir_if ::= END IF
+ | END error {:parser.report_error("Se esperaba End If",sym.ERROR); :};
+
+/*--- do y for --*/
+do_loop ::= DO WHILE expression FIN bloque salir_loop
+ | DO WHILE expression FIN salir_loop
+ | DO error expression FIN bloque salir_loop {: parser.report_error("Se esperaba While <expresion booleana> ",sym.ERROR); :}
+ | DO error expression FIN salir_loop {: parser.report_error("Se esperaba While <expresion booleana> ",sym.ERROR); :}
+ | DO WHILE error FIN salir_loop {: parser.report_error("Se esperaba expresion booleana",sym.ERROR); :}
+ | DO WHILE error FIN bloque salir_loop {: parser.report_error("Se esperaba expresion booleana",sym.ERROR); :};
+
+
+salir_loop ::= LOOP FIN
+ |error {: parser.report_error("se esperaba salida de while",sym.ERROR); :};
+
+loop_for ::= FOR rango FIN bloque NEXT FIN
+ | FOR rango FIN NEXT FIN
+ | FOR error FIN NEXT FIN {: parser.report_error("Error en rango",sym.ERROR); :}
+ | FOR error FIN bloque NEXT FIN {: parser.report_error("Error en rango",sym.ERROR); :}
+ | FOR rango FIN error {: parser.report_error("Se esperaba un Next",sym.NEXT); :}
+ | FOR rango FIN bloque error {: parser.report_error("Se esperaba un Next",sym.NEXT); :};
+
+rango ::= NAME IGUAL expression TO expression
+ | NAME IGUAL TO error {: parser.report_error("Error de rangos, no existe valor inicial",sym.ERROR); :}
+ | NAME IGUAL error TO {: parser.report_error("Error de rangos, valor inicial y final",sym.ERROR); :}
+ | NAME IGUAL error {: parser.report_error("Error de rangos/asignacion",sym.ERROR); :}
+ | NAME IGUAL error TO error {: parser.report_error("Error de rangos",sym.ERROR); :}
+ | NAME IGUAL expression TO error {: parser.report_error("Se esperaba valor de final",sym.ERROR); :}
+ | NAME IGUAL error TO expression {: parser.report_error("Se esperaba valor de inicio",sym.ERROR); :}
+
+;
+
+/*---- estructuras ---*/
+
+
+
+dectype ::= TYPE NAME:n1 FIN {: if(parser.first_time) {parser.tmp_tipo = new Tipo(n1); parser.tmp_tipo.setTipoFinal(3);} :} list_declar2 end_type FIN
+ {: if(parser.first_time) {parser.seen_types.put(n1,parser.tmp_tipo);
+ } :}
+ | TYPE NAME error end_type FIN {: parser.report_error(" estructura no puede estar vacia",sym.ERROR); :} ;
+
+
+list_declar2 ::= variables_declar2 list_declar2
+ | variables_declar2;
+
+variables_declar2 ::= declaracion2 FIN;
+
+declaracion2 ::= DIM NAME:n1 AS tipo:t1 {: if(parser.first_time) parser.tmp_tipo.agregar_atributos(n1,t1); :}
+ | NAME:n1 AS tipo:t1 {: if( parser.first_time) parser.tmp_tipo.agregar_atributos(n1,t1); :}
+ | error {: parser.report_error("Se esperaba <id> As <tipo> ",sym.ERROR); :};
+
+
Oops, something went wrong.

0 comments on commit d651ef3

Please sign in to comment.