ResNom.g

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