41eb74637fa794f7287d744d11df1cdab0b1dd48
[PL2.git] / 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)+ ;