ResNom.g

   1 header{
   2         import java.util.*;
   3         import antlr.ASTFactory;
   4         import java.util.Hashtable;
   5 }
   6
   7 class ResNom extends TreeParser;
   8
   9 options{
  10         buildAST = true;
  11         importVocab=Analex;
  12         importVocab=Anasint;
  13
  14 }
  15
  16 {
  17         LinkedList<String> leas = new LinkedList<String>();
  18         Tabla_Global t;
  19         TablaModulos mods;
  20         AST importaciones = null;
  21         String nombre_modulo = "";
  22         Hashtable<String,String> declaraciones = new Hashtable<String,String>();
  23
  24         void resolver_identificadores_tipo(){
  25                 Identificador_Tipo elemento;
  26                 String nombre;
  27                 LinkedList<Identificador_Tipo> i;
  28                 i = t.identtiposinresolver.getIdentificadores();
  29                 ListIterator<Identificador_Tipo> li = i.listIterator();
  30                 while(li.hasNext()){
  31                         elemento = (Identificador_Tipo) li.next();
  32                         nombre = elemento.getNombre();
  33
  34                         if(t.ambitomodulo.getDeclaracion(nombre) == null &&
  35                         mods.Declaracion(nombre, importaciones) == null){
  36                                 //identificador de tipo no declarado
  37                                 System.out.println("ERROR RN :"+t.ambitomodulo.getNombre()+".mod ("+elemento.getLinea()+"): identificador '" + nombre + "' no declarado");
  38                         }
  39                 }
  40         }
  41
  42         AST resolver_acceso_simple(String numero){
  43                 int no = Integer.parseInt(numero);
  44                 //nombre y ambito contenedor del acceso
  45                 Lista_Accesos acsr = t.accesossinresolver;
  46                 Acceso acc = t.accesossinresolver.getAcceso(no);
  47                 String nom = acc.getNombre();
  48                 Ambito amb = acc.getContenedor();
  49
  50                 Simbolo sim;
  51                 AST dec = #(#[ERROR, "error"]);
  52                 //comprobar si se ha declarado, buscando en la tabla de ambitos y declaraciones
  53                 //Hace falta mirar en los modulos, para el crear
  54                 if((sim = t.tablaambitos.buscar_simbolo(amb, nom)) == null ){
  55                         if (mods.Declaracion(nom, importaciones) != null){
  56                                 dec = mods.Declaracion(nom, importaciones);
  57                         }
  58                         //acceso simple no declarado
  59                         else
  60                                 if(!leas.contains(numero)){
  61                                         //System.out.println("ERROR RN: acceso simple " + nom + " no declarado");
  62                                         System.out.println("ERROR RN :"+t.ambitomodulo.getNombre()+".mod ("+acc.getLinea()+"): acceso simple '" + nom + "' no declarado");
  63                                         leas.add(numero);
  64                                 }
  65                 }
  66                 else {
  67                         dec = sim.getDeclaracion(); //referencia adelantada
  68                 }
  69
  70                 return dec;
  71         }
  72         AST resolver_acceso_objeto(AST arbol, AST ident){
  73                 String raiz, accs;
  74                 raiz = arbol.getFirstChild().getText();
  75                 accs = ident.getText();
  76
  77                 AST as = arbol.getFirstChild();
  78
  79                 Hashtable<String,String> xx = declaraciones;
  80                 String tipo = declaraciones.get(as.getText());
  81                 AST arbol2 = declaracion_tipo(#(#[IDENT, tipo]));
  82                 if (tipo == null){
  83                         System.out.println("DEBUG: Acceso a Clase No instanciable " + arbol.getFirstChild().getText());
  84                         String nombre = arbol.getFirstChild().getText();
  85                         arbol2 = mods.Declaracion_interna(nombre, nombre_modulo);
  86                         if (arbol2 == null)
  87                                 arbol2 = mods.Declaracion(arbol.getFirstChild().getText(), importaciones);
  88                 }
  89
  90                 if (arbol2 == null){
  91                         System.out.println("ERROR RN :"+t.ambitomodulo.getNombre()+".mod ("+((ArbolLineas)ident).getLinea()+"): acceso objeto '" + ident.getText() + "' no declarado");
  92                         return #(#[ERROR,"error"]);
  93                 }
  94
  95                 if (arbol2.getType() == ERROR)
  96                         arbol2 = mods.Declaracion(tipo, importaciones);
  97
  98                 if (arbol2 == null || arbol2.getType() == ERROR){
  99                         System.out.println("ERROR RN :"+t.ambitomodulo.getNombre()+".mod ("+((ArbolLineas)ident).getLinea()+"): acceso objeto '" + ident.getText() + "' no declarado");
 100                         return #(#[ERROR,"error"]);
 101                 }
 102
 103
 104                 arbol2 = arbol2.getFirstChild().getNextSibling().getNextSibling();
 105                 while(arbol2 != null){
 106                         if(arbol2.getType() == ATRIBUTO){
 107                                 AST visibilidad = arbol2.getFirstChild().getNextSibling().getNextSibling();
 108                                 if(arbol2.getFirstChild().getText().equals(ident.getText())){
 109                                         if (visibilidad.getType() != OCULTO){
 110                                                 return arbol2;
 111                                         }
 112                                         else{
 113                                                 System.out.println("ERROR RN :"+t.ambitomodulo.getNombre()+".mod ("+((ArbolLineas)ident).getLinea()+"): acceso objeto '" + ident.getText() + "' no es accesible");
 114                                                 return #(#[ERROR,"error"]);
 115                                         }
 116                                 }
 117                         }
 118                         else if (arbol2.getType() == METODO){
 119                                 AST visibilidad = arbol2.getFirstChild().getNextSibling().getNextSibling();
 120                                 if(arbol2.getFirstChild().getFirstChild().getText().equals(ident.getText())){
 121                                         if (visibilidad.getType() != OCULTO){
 122                                                 return arbol2;
 123                                         }
 124                                         else{
 125                                                 System.out.println("ERROR RN :"+t.ambitomodulo.getNombre()+".mod ("+((ArbolLineas)ident).getLinea()+"): acceso objeto '" + ident.getText() + "' no es accesible");
 126                                                 return #(#[ERROR,"error"]);
 127                                         }
 128                                 }
 129                         }
 130                         arbol2 = arbol2.getNextSibling();
 131                 }
 132                 System.out.println("ERROR RN :"+t.ambitomodulo.getNombre()+".mod ("+((ArbolLineas)ident).getLinea()+"): acceso objeto '" + ident.getText() + "' no declarado");
 133                 return #(#[ERROR,"error"]);
 134         }
 135
 136         void averiguar_importaciones() {
 137                 Ambito a = t.ambitomodulo;
 138                 Modulo mx = mods.get(a.getNombre());
 139                 importaciones = mx.getImportacion();
 140         }
 141
 142         //con esta funcion se podrian poner la clases
 143         //tipo: i:IDENT {#tipo = declaracion_tipo(#i);}
 144         AST declaracion_tipo(AST ident){
 145                 AST tipo = #(#[ERROR, "error"]);
 146                 Ambito modulo = t.ambitomodulo;
 147                 Simbolo s = modulo.getDeclaracion(ident.getText());
 148                 if (s != null){
 149                         ASTFactory f = new ASTFactory();
 150                         tipo = f.dupTree(s.getDeclaracion());
 151                 }
 152                 return tipo;
 153         }
 154 }
 155
 156 declaracion_modulo [String nombre, Tabla_Global tab, TablaModulos m, Hashtable d]:
 157 {
 158         nombre_modulo = nombre;
 159         t = tab;
 160         declaraciones = d;
 161         mods = m;
 162         averiguar_importaciones();
 163         resolver_identificadores_tipo();}
 164         #(MODULO nombre_modulo definicion_modulo);
 165
 166 // =============================== del fichero anasem.g ============================
 167
 168 nombre_modulo : IDENT ;
 169
 170 definicion_modulo:
 171         (importacion)?
 172         (exportacion)+
 173         (implementacion)?
 174 ;
 175
 176 importacion : #(IMPORTACION lista_ident);
 177 lista_ident: (IDENT)+;
 178
 179 exportacion : #(EXPORTACION lista_declaraciones_clases);
 180
 181 implementacion : #(IMPLEMENTACION lista_declaraciones_clases);
 182
 183 lista_declaraciones_clases: (declaracion_clase)*
 184 ;
 185
 186 declaracion_clase : #(CLASE nombre_clase cualificador_clase definicion_clase)
 187 ;
 188
 189 cualificador_clase : INST | NO_INST ;
 190
 191 nombre_clase : IDENT ;
 192
 193 definicion_clase : declaraciones_elementos_clase
 194 ;
 195
 196 declaraciones_elementos_clase : (declaracion_elemento_clase)* ;
 197
 198 declaracion_elemento_clase :
 199 #(METODO declaracion_metodo cualificador_elemento_clase)
 200 | #(ATRIBUTO i:IDENT t:tipo cualificador_elemento_clase)
 201 ;
 202
 203 cualificador_elemento_clase: OCULTO | VISIBLE ;
 204
 205 declaracion_metodo : prototipo_metodo definicion_metodo;
 206
 207 prototipo_metodo: #(PROTOTIPO IDENT #(PARAMETROS declaracion_parametros)
 208 #(RESULTADO (tipo | VACIO)));
 209
 210 declaracion_parametros : (declaracion_parametro)* ;
 211
 212 declaracion_parametro : #(PARAMETRO IDENT tipo) ;
 213
 214 definicion_metodo: #(DEFINICION #(VARIABLES_LOCALES declaracion_variables_locales) #(INSTRUCCIONES instrucciones))
 215 ;
 216
 217 declaracion_variables_locales : (declaracion_variable_local)* ;
 218
 219 declaracion_variable_local : #(VARIABLE_LOCAL i:IDENT t:tipo) ;
 220
 221 declaracion_error : ERROR;
 222
 223 instrucciones : (instruccion)* ;
 224
 225 instruccion : #(INSTRUCCION ( instruccion_simple | instruccion_compuesta))
 226 ;
 227
 228 instruccion_simple : llamada_metodo
 229 | crear
 230 | escribir
 231 | asignacion
 232 | retorno
 233 ;
 234
 235 instruccion_compuesta  :
 236 condicion
 237 | iteracion
 238 ;
 239
 240 crear : #(CREAR expresion expresion);
 241 escribir : #(ESCRIBIR expresion);
 242
 243 asignacion : #(ASIGNACION expresion expresion );
 244
 245 retorno: #(DEV expresion)
 246 ;
 247
 248 llamada_metodo :
 249 #(LLAMADA acceso #(EXPRESIONES lista_expresiones))
 250 ;
 251
 252 lista_expresiones: (expresion)* ;
 253
 254 condicion: #(SI expresion #(INSTRUCCIONES instrucciones)
 255 (#(INSTRUCCIONES instrucciones))?)
 256 ;
 257
 258 iteracion : #(MIENTRAS expresion #(INSTRUCCIONES
 259 instrucciones));
 260
 261 expresion:
 262 #(O expresion expresion)
 263 | #(Y expresion expresion)
 264 | #(NO expresion)
 265 | #(op1:MAYOR expresion expresion)
 266 | #(op2:MAYOR_IGUAL expresion expresion)
 267 | #(op3:MENOR expresion expresion)
 268 | #(op4:MENOR_IGUAL expresion expresion)
 269 | #(op5:IGUAL expresion expresion)
 270 | #(op6:DISTINTO expresion expresion)
 271 | #(MAS expresion expresion)
 272 | #(MENOS expresion expresion)
 273 | #(MENOSUNARIO expresion)
 274 | #(POR expresion expresion)
 275 | #(DIVISION expresion expresion)
 276 | #(LLAMADA acceso #(EXPRESIONES lista_expresiones))
 277 | #(ACCESO_TABLA acceso #(EXPRESIONES lista_expresiones_nv))
 278 | acceso
 279 | LIT_ENTERO
 280 | LIT_REAL
 281 | LIT_CAR
 282 | CIERTO
 283 | FALSO
 284 | #(ENTERO_A_REAL expresion)
 285 | #(REAL_A_ENTERO expresion)
 286 | ERROR
 287 ;
 288
 289 acceso : acceso_simple
 290 | #(ACCESO_OBJETO as:acceso_simple acceso_objeto[#as])
 291 ;
 292
 293 acceso_objeto [AST arbol] : a:IDENT {#acceso_objeto = resolver_acceso_objeto(arbol, #a);};
 294
 295 acceso_simple : #(ACCESO_SIMPLE i:IDENT d:declaracion_acceso)
 296 ;
 297
 298 declaracion_acceso: declaracion_modulo[nombre_modulo, t, mods, declaraciones]
 299 | declaracion_clase
 300 | declaracion_elemento_clase
 301 | declaracion_parametro
 302 | declaracion_variable_local
 303 | declaracion_error
 304 | i:LIT_ENTERO
 305 {#declaracion_acceso = resolver_acceso_simple(i.getText());
 306 }
 307 ;
 308
 309 lista_expresiones_nv : (expresion)+;
 310
 311 tipo :
 312 tipo_predefinido_simple
 313 | tipo_predefinido_compuesto
 314 | declaracion_error
 315 | i:IDENT {#tipo = declaracion_tipo(#i);}
 316 ;
 317
 318 tipo_predefinido_simple :
 319 ENTERO
 320 | REAL
 321 | LOGICO
 322 | CARACTER
 323 ;
 324
 325 tipo_predefinido_compuesto : formacion;
 326
 327 formacion : #(FORMACION #(LISTA_ENTEROS lista_enteros) tipo);
 328
 329 lista_enteros : (LIT_ENTERO)+ ;