ResNom.g

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