Gramática abstracta. Gramática abstracta. Forma de escribirlas: Pizquierda : Pderecha <Predicado> atributos o acc. semánticas}

Transcripción

1 Gramática abstracta Nos permite enlazar más fácilmente el análisis sintáctico con el semántico se comienza a manejar cuestiones que trabaja el semántico. Denota los aspectos importantes del lenguaje (equivalente a conceptos) El orden no tiene importancia Se basa en: Categorías sintácticas (Terminales y NT que tienen asociada información. Son relevantes) Atributos asociados a terminales y no terminales Definiciones: para especificar nueva información. Compiladores e Intérpretes 1 Gramática abstracta Forma de escribirlas: Pizquierda : Pderecha <Predicado> atributos o acc. semánticas} {Relación El Predicado es la condición para que se cumpla la regla. Acciones semánticas o Relación atributos es la determinación de los valores de los atributos. Compiladores e Intérpretes 2

2 Gramática abstracta Ej: el lenguaje a n b n c n Categorías sintácticas: A,A1 ListaA, Iden para B,B1,C y C1, S programa Atributos:< int n > ListaA, ListaB, ListaC Definiciones: S: A B C < A.n = B.n = C.n > {} A: a < > {A.n = 1} A1 a < > {A.n = A1.n + 1} B: b < > {B.n = 1} B1 b < > {B.n = B1.n + 1} C: c < > {B.n = 1} B1 c < > {B.n = B1.n + 1} Compiladores e Intérpretes 3 Gramática abstracta Tipos de categorías (tipo 1) secuencia: una lista Bloque: Asig * (tipo 2) agregado: un registro Asig: v: var ; e:exp (tipo 3) alternativo: varias opciones Exp: Var Num Unaria Binaria (tipo 4) alternativo Terminales: la parte derecha son opciones únicamente de terminales Opb: suma resta mult div Compiladores e Intérpretes 4

3 Gramática abstracta Ejemplo G abstracta que describe expresiones aritméticas: Categorías Sintácticas: Bloque, Asig, Num, Var, Unaria, Binaria, Opb, Opu, Exp Atributos: < int v > Exp < int n > Var Compiladores e Intérpretes 5 Gramática abstracta Definiciones: Bloque: Asig * (tipo 1) Asig: v: var ; e:exp (tipo 2) Exp: Var Num Unaria Binaria (tipo 3) Unaria: on: Opu; e: Exp Binaria: e1,e2: Exp; ob: Opb Opu: Menos Opb: suma resta mult div (tipo 4) Compiladores e Intérpretes 6

4 Gramática abstracta Las gramáticas abstractas las utilizamos como un método mecánico nos ayudan a deducir las funciones de creación de árboles El objetivo es construir un árbol que represente la entrada Cada Categoría es un tipo de nodo de árbol Cada tipo de producción indica la clase de árbol que hay que construir Los nodos del árbol tienen asociado valores (atributos) Compiladores e Intérpretes 7 Un nodo árbol tendrá la información: tipo de árbol (T_Num, T_Binario,...) La información de los atributos (int v, int n,...) Enlace a su padre, hermanos e hijos. Compiladores e Intérpretes 8

5 Para las producciones de tipo 4: Los tokens son los nodos hoja. Un tipo de árbol para cada token y un árbol para cada aparición del token. Token Num--> tipo árbol T_Num Aparición Num --> contrucción del ábol Num() T_Num Num(); (T_Num es= un árbol con un solo nodo) T_Var Var(); T_Suma Suma(); Compiladores e Intérpretes 9 Para las producciones de tipo 2: manejar agregados, combinación de elementos (construir elementos a partir de otros). funciones que crean un árbol compuestos de otros: Ejemplo: T_Asig Asig (T_var v; T_Exp e) (T_Asig es= la raíz con dos nodos hijos: v y e) T_Binaria Binaria (T_Exp e1, e2; T_Opb ob); T_Unaria Unaria (T_Exp e1; T_Opu ou); Compiladores e Intérpretes 10

6 Para las producciones de tipo 1: las propias de manejo de lista de elementos (lista vacía, insertar un elemento, devolver el primero, etc.) T_Bloque Bloque_v(); T_Bloque Bloque_dt(T_Bloque s; T_asig a); (T_Bloque es= la raíz y a sus nodos hijos se le ha añadido uno más, a) T_Bloque Bloque_dl(T_asig a; T_Bloque s); T_Bloque Bloque_1(T_asig a); T_Bloque Bloque_2(T_asig a1,a2); Compiladores e Intérpretes 11 Para las de tipo 3: Son opciones en la generación de la gramática. No define nada nuevo. El árbol ya está construido. no se le asocia ninguna función constructora Compiladores e Intérpretes 12

7 Funciones asociadas a los atributos Acceder a ellos con el identificador: nombrecategoria_nombreatributo Para leer un atributo: una función con ese identificador y le paso el árbol T_Num t =Num(); Num_v(t) = el atributo v del noto t de tipo T_Num, donde: int Num_v( T_Num a); ejemplos: Binaria_v(t); Unaria_v(t); Var_v(t); Compiladores e Intérpretes 13 Para asignar valores al atributo una macro con ese identificador y le paso el árbol #define Num_v(t) t.v Num_v(t) = 3 Leo y escribo mediante la macro Compiladores e Intérpretes 14

8 t1=num(); Num_v(t1)=3; t2 =Num(); Num_v(t2) = 5; t3=var(); Var_n(t3) = Valor de Tabla_Simbolo(x); t4 = Binaria( Binaria (t3, t1, Suma()), Unaria( t2, Menos()), Mult()); * + - x 3 5 Compiladores e Intérpretes 15 Ejemplo: la gramática abstracta < int v > Exp < int n > Var Definiciones: Bloque: Asig * Asig: v: var ; e:exp Exp: Var Num Unaria Binaria Unaria: on: Opu; e: Exp Binaria: e1,e2: Exp; ob: Opb Opu: Menos Opb: suma resta mult div Compiladores e Intérpretes 16

9 %{ #include <arboles.h> #include <stido.h>... %} %union{ Arbol nodo; int val; char *name; } Compiladores e Intérpretes 17 %start list %token <val> NUM %token <name> VAR %type <nodo> list expr stat %left '+' '-' %left '*' '/' %left UMINOS %% list: {$$=Bloque_vc();} list stat{$$=bloque_dt($1,$2);} error ; Compiladores e Intérpretes 18

10 stat: VAR '=' exp '\n' {Arbol t1; t1=var();strcpy(var_n(t1),$1); $$=Asig(t1,$3);} error '\n' {yyerrok;} ; exp: '(' exp ')' {$$=$2;} exp '+' exp {$$=Binaria($1,$3, Suma());} exp '-' exp {$$=Binaria($1,$3,Resta());} exp '*' exp {$$=Binaria($1,$3,Mult());} exp '/' exp {$$=Binaria($1,$3,Div());} '-' exp %prec UMINOS {$$=Unaria($2, Menos());} VAR {$$=Var(); strcpy(var_n($$),$1); } NUM {$$=Num(); Num_v($$)=$1;} exp error exp '(' exp error error ; %% Compiladores e Intérpretes 19 Gramáticas para crear los árboles sintácticos Gramáticas s-atribuidas: solo contienen atributos sintetizados (el resultado de evaluar el atributo se pasa al padre). El atributo fluye desde las hojas a la raíz. Gramáticas lc-atribuidas: contienen atributos sintetizados y heredados de hermanos izquierdos (inmediatos o superiores (tíos)). Gramáticas l-atribuidas: contienen atributos sintetizados, heredados de hermanos izquierdos y heredados del padre. Compiladores e Intérpretes 20

11 Evaluación con Yacc de gramáticas lc-atribuidas Yacc permite realizar herencia entre los hermanos izquierdos superiores: Hay dos pilas: la pila de símbolos y la de atributos. Los atributos se nombran a partir del primer símbolo de la parte derecha de la regla con $0 y hacia la derecha aumenta y hacia la izquierda disminuye. Ej: declración opcional de tipo puntero. decl: pref tipo lisvar pref: {$$=0;} /*no es puntero*/ punt {$$=1;} /*es puntero*/ tipo: ENT {$$=T_Ent;} REAL {$$=T_Real;} lisvar: var {Pt3($1,$-1, $0);} /*Pt3(entradaTS e, int espuntero, tipodatos t)*/ lisvar var {Pt3 ($2, $-1, $0);} Compiladores e Intérpretes 21 Evaluación con Yacc de gramáticas lc-atribuidas decl: pref tipo lisvar pref: {$$=0;} /*no es puntero*/ punt {$$=1;} /*es puntero*/ tipo: ENT {$$=T_Ent;} REAL {$$=T_Real;} lisvar: var {Pt3($1,$-1, $0);} Entrada: Punt Int x y z lisvar var {Pt3 ($2, $-1, $0);} Pila G Pila atrib. Var $2 Cima de la pila Lisvar $1 Tipo $0 Primero de la derecha de Prefijo $-1 la producción Compiladores e Intérpretes 22

12 Realización de los árboles sintácticos con análisis descendente (basado en gramáticas l-atribuidas) Al ser descendente habrá que construir primero el nodo superior y posteriormente pasar a construir sus descendientes antes de construir los nodos correspondiente a los símbolos de la parte derecha de la producción habrá que construir la parte izquierda. Dos restricciones: la gramática debe verificar ser LL(1) y no se pueden utilizar atributos de hermanos derechos (aún no se han ejecutado sus correspondientes procedimientos). utilizar gramáticas l-atribuidas. Compiladores e Intérpretes 23 árboles sintácticos con análisis descendente list: stat* list: { $$=Bloque_v(); } (stat {$$ = Bloque_dt($$,$2); })* stat:var'='exp'\n'{arbolt;t = Var();Var_n(t)=$1);$$=Asig(t,$3);} exp: exp1 [opr exp1 {$1=Binaria($1,$3,$2);}] {$$=$1;} exp1: exp2 (opsr exp2)* con acción de construcción: exp1: exp2 (opsr exp2 {$1 = Binaria ($1, $3, $2); })* {$$=$1;} exp2: exp3 (opmd exp3 {$1=Binaria($1, $3, $2);})* {$$=$1;} exp3: {$1<val>=0;} [opu {$1<val>=1}] exp4 { $1<val>==1? $$=Unaria($4,$2): $$=$4; } base: VAR {$$=Var(); strcpy(var_n($$),$1);} NUM {$$=Num(); Num_v($$)=$1;} '(' exp ')' {$$=$2;} Compiladores e Intérpretes 24

13 Evaluación de árboles en análisis descendente con gramáticas l-atributidas. Los atributos heredados ($i.h) se utilizan para pasar información a los hijos. Los atributos sintetizados ($i.s). Para devolver información el hijo al padre. Con este tipo de herencia tan fuerte los analizadores LL1 son más potentes que los Yacc. Compiladores e Intérpretes 25 Evaluación de árboles en análisis descendente con gramáticas l- atributidas. fact: base resto resto: '^' fact con gramática heredada: fact: base {$2.h = $1;} resto {$$=$3.s;} resto: {$$.s=$$.h;} /*devuelve lo que ha pasado*/ '^' fact {$$.s=binaria ($$.h, $2, Pot()); } Compiladores e Intérpretes 26

14 Implementación de los árboles: Nodo: Constructor: dice el tipo (T_Exp, T_Binaria, etc.). Es un número (#define T_Exp ) Atributos: una unión de todos los atributos de los nodos. Nh: número de hijos Np: número de padres Hijos: * al primer hijo Hermanos: *puntero al siguiente hermano Padre: señala a un padre Compiladores e Intérpretes 27 Implementación de los árboles: typedef struct s_arbol{ int constructor; T_abributos, atributo; Int nh, np; struct s_arbol *hijos, *hermano, *padres }* Arbol Compiladores e Intérpretes 28