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