Introducción a Yacc - GIAA

Yacc 

Gramática 

BNF 

plan.y 

YACC 

plan.tab.c 

Compilador 

+ 

Enlazador 

Ejecutable 

Otros 

módulos

Yacc. Procesadores de Lenguaje II 

Estructura de Yacc 

Yet Another Compiler-Compiler 

• Bison: versión GNU 

Herramienta para generar analizadores sintácticos 

para gramáticas LALR 

YACC programa fuente 

{definición} 

%% 

{reglas} 

%% 

{subrutinas de usuario} 

Reglas: acción 

producciones pertenecen a una gramática G2 en BNF 

Acción: fragmentos de código C que especifican que 

hacer cuando se reduce una producción


Estructura de Yacc 

La forma natural de trabajar es conjuntamente con 

LEX: 

• yylex(): petición de siguiente token 

El analizador está contenido en la función 

yyparse() 

home\> yacc ejemplo.y 

home\> ls *.c 

home\> ejemplo.tab.c 

home\> flex patrones.lex 

home\> ls *.c 

home\> lex.yy.c ejemplo.tab.c 

home\> gcc -o sint lex.yy.c ejemplo.tab.c


Principio de Yacc 

Análisis previo de la gramática para construir 

el analizador LALR: notifica incidencias 

Funcionamiento general del analizador: pide 

tokens definidos al analizador léxico (yylex) 

• Como es LALR(1), pide un token de pre-análisis 

• Cuando realiza desplazamiento pide el siguiente 

token 

• Cuando realiza reducciones de producciones, 

ejecuta el código en sus acciones


Formato de Yacc 

Tres partes separadas por una línea con 

“%%” 

Declaraciones 

%% 

Reglas 

%% 

Código de usuario 

Previas al uso del scanner 

Reglas sintácticas y lo que hay 

que hacer cuando se activan 

Funciones C que se copian al 

fichero de salida


Sección de Declaraciones 

Declaraciones: 

• Código de usuario 

• Se copia a la salida 

• %{....%} 

• Declaraciones 

• Terminales y no terminales (opt): 

• %token símbolo 

• %type símbolo 

• Precedencia y asociatividad 

de operadores 

• %noassoc símbolos 

• %left símbolos 

• %right símbolos 

• Símbolo de arranque de la gramática 

• %start símbolo 

• Directivas de comportamiento 

%{ 

%} 

%% 

%% 

Código de usuario 

#include



Terminales 

• Es lo que devuelve la función yylex() (llamada 

automáticamente desde yyparse() 

• Se convierten en #define en el fichero de salida 

• Se les asocia un número comenzando por 257 

• Se puede obligar a que tenga uno en concreto 

• %token T_LLAVE 345 

• Los terminales de un carácter no hace falta 

declararlos (están implícitos) 

• En yacc se podrá utilizar directamente el terminal ‘(‘ 

• Son tokens con valores numéricos el código ASCII 

(


Declaraciones de terminales 

Ejemplo definición terminales 

• Lenguaje de expresiones aritméticas con enteros 

%{ 

#include 

%} 

%token NUMERO, MAS, MENOS, POR, DIV, PAR_I, PAR_D 

%start expr /* simbolo axioma sentencial */ 

… 

Declaración en YACC de terminales 

(expresiones.y)


Declaraciones de terminales 

Ejemplo definición terminales 

%{ 

#include "expresiones_tab.h" 

%} 

digito [0-9] 

%% 

[ \t]+ ; 

{digito}+ {yylval=atoi(yytext); return NUMERO;} 

"+" return MAS; 

"-" return MENOS; 

"*" return POR; 

"/" return DIV; 

"(" return PAR_I; 

")" return PAR_D; 

. {printf("token erroneo\n");} 

Definición en Lex de patrones


Comunicación Flex-Yacc 

fich.l 

header 

fich.y 

lex fich.l 

yacc -d fich.y 

lex.yy.c 

fich.tab.h 

fich.tab.c 

cc lex.yy.c -c 

cc fich.tab.c -c 

lex.yy.o 

fich.tab.o 

gcc lex.yy.o fich.tab.o -o an_sintactico 

calc


Reglas en YACC 

Formato BNF simplificado 

LI: LD acción; 

• LI: es un símbolo no-terminal del lenguaje 

• LD: secuencia de símbolos no-terminales y terminales 

Agrupar varias reglas del mismo no terminal : 

expr: expr ´+´ expr {....} 

| expr ´-´ expr {....} 

; 

Si se deja vacía es el regla de la palabra vacía 

sentencias : sentencias ´;´ sentencia {....} 

| 

; 

acción: { sentencias en C } (puede ser vacío)


Declaraciones de reglas 


%start expr /* simbolo axioma sentencial */ 

%% 

expr: expr MAS term 

{printf("expr --> expr MAS term\n");} 

|expr MENOS term {printf("expr --> expr MENOS term\n");} 

|term 

{printf("expr --> term\n");} 

; 

term: term POR factor {printf("term --> term POR factor\n");} 

|term DIV factor {printf("term --> term DIV factor\n");} 

|factor 

{printf("term --> factor\n");} 

; 

factor: NUMERO 

{printf("factor--> NUMERO(%d)\n",$1);} 

|PAR_I expr PAR_D{printf("factor--> ( expr )\n");} 

; 

%% 

. . .


Ejemplo de análisis 

Gramática 

exprexpr + term 

exprterm 

termterm * factor 

termfactor 

factorNUMERO 

factor(expr) 

Ejemplo de ejecución 

• 5*(6+1)+3 

factor--> NUMERO (5) 

term --> factor 



expr --> term 



expr --> expr MAS term 

factor--> ( expr ) 

term --> term POR factor 

expr --> term 



expr --> expr MAS term


Resolución de ambigüedad 

Por defecto, después de avisar, yacc resuelve 

• D/R: Desplazar prioridad sobre reducir 

• R/R: Reducir por la producción primera 

Preferible resolver los conflictos explícitamente 

• Criterios de prioridad


Precedencia 

Especificación de precedencia 

• Asociatividad izquierda 

• %left op: x op y op z (x op y) op z 

• Asociatividad derecha 

• %right op: x op y op z x op (y op z) 

• No asociatividad 

• %nonassoc op: x op y op z INCORRECTO 

• Con otros operadores: los declarados en líneas posteriores 

más precedencia 

Ejemplo de asociación: 

% left ‘+’ ‘-’ 

% left ‘*’ ‘/’ 

• El último declarado es el que tiene más precedencia


Gramática expresiones con prioridad 

%token NUMERO, MAS, POR, '(', ')' 

%left MAS 

%left POR 

%start S /* simbolo axioma sentencial */ 

%% 

S: expr {printf("resultado: %d\n", $$); } 

expr: expr MAS expr 

|expr POR expr 

|'(' expr ')' 

| NUMERO 

%%


Reglas: valores semánticos 

El valor semántico que proporciona yylex() se utiliza 

con los operadores $n 

expr: NAT ´+´ NAT {$$=$1+$3}; 

• $$ identifica a la parte izquierda de la regla de producción 

• $n se corresponde con el n-ésimo símbolo de la parte 

derecha 

En la parte derecha cada componente se identifica 

por el orden que ocupa 

Por defecto se suponen valores enteros 

• Pueden declararse tipos complejos para los atributos


Ejemplo transporte atributos 

%% 



%% 


expr: expr MAS term {$$=$1+$3;} 

|expr MENOS term {$$=$1-$3;} 

|term {$$=$1;} 

; 

term: term POR factor {$$=$1*$3;} 

| term DIV factor {$$=$1/$3;;} 

| factor {$$=$1;} 

; 

factor: NUMERO {$$=$1;} 

| PAR_I expr PAR_D {$$=$1;} 

; 

. . . 

Se agrega 

automáticamente


Reglas: valores semánticos 

Los atributos de los tokens se obtienen en el 

análisis léxico: variable yylval 

• Es la comunicación lex-yacc 

• Representa el atributo del último token en el 

patrón reconocido 

• Por defecto es un atributo de tipo entero (int) 

• Ej.: … 

digito [0-9] 

%% 

Plantilla 

Lex: 

[ \t]+ ; 

"+" return MAS; 

"*“ return POR; 

{digito}+ {yylval=atoi(yytext); return NUMERO;}



Directiva %union 

• Por defecto todos los terminales tienen un atributo 

de tipo entero, yyval, asignado en yylex() 

• Los valores semánticos se declaran en %union 

%union{ 

int valent; 

char *cadena; 

tblPos *ptr; 

}



Por defecto todos los terminales tienen un atributo 

de tipo entero, yyval, asignado en yylex() 

• Para utilizar otro tipo de atributo puede usarse la variable 

YYSTYPE 

#define YYSTYPE double 

Directiva %union 

• Da mayor flexibilidad, permitiendo definir varios atributos 

por símbolo y atributos alternativos 

• Declara los tipos posibles como una “unión” de C 

%union{ 

int valent; 

char *cadena; 

tblPos *ptr; 

}



Uso de un tipo declarado en %union 

• Se puede asociar a un terminal en su declaración 

%token NATURAL 

• Para un no terminal en su declaración 

%type NO_TERMINAL 

• En una producción específica 

expr: NAT ´+´ NAT {$$=$1+$3}; 

En un símbolo terminal (análisis léxico) 

[-+]?{digito}+ { yyval.valent=atoi(yytext); 

return ENTERO;}



%union{ 

int valent; 

char *cadena; 

tblPos *ptr; 

} 

Uso de los tipos declarados en %union 

• Se puede asociar a un terminal en su declaración 

%token NATURAL 

• Para un no terminal en su declaración 

%type NO_TERMINAL 

• En una producción específica 

expr: NAT ´+´ NAT {$$=$1+$3}; 

En un símbolo terminal (análisis léxico): hay que 

especificar 

[-+]?{digito}+ { yyval.valent=atoi(yytext); 

return NUMERO;}


Almacenamiento de Atributos 

cima 

cima -1 

cima-2 

Técnica frecuente en analizadores ascendentes (LALR:yacc/bison, 

cup) 

Los atributos sintetizados se almacenan en una pila, y se evalúan 

al efectuar las reducciones: “pila semántica”: 

• Correspondencia con la pila de estados LR, asociados a los símbolos 

gramaticales 

Producción 

A::= XYZ 

Pila LR 

val 

... ... 

Z 

Y 

X 

Acciones 

semánticas 

A.s=f(X.x,Y.y,Z.z) 

Z.z 

Y.y 

X.x 

val [cima] 

val [cima –1] 

val [cima-2] 

int 

char 

%union{ 

int val1; 

char val2;} 

%typeX 

%typeY


Implementación en YACC 

Acciones embebidas: 

Las acciones pueden aparecer en el medio de una regla, 

ejecutándose antes de que la regla sea completamente 

evaluada. 

X: Y {acción} Z; 

Por ejemplo: 

X: Y {$$ := 2*$1;} z {$$ := $2+$3;} 

Establece el valor de x como 2*(valor de Y) + (valor de z) 

Pueden introducir conflictos en la resolución 

de la gramática!!!


Ejemplo Infija-Postfija 

Traductor infija->postfija 

E 

E::=T E’ 

E’::= op T {escribe op.lex} E’ 

E’::=λ 

T::= num {escribe num.lex} 

¡No hay atributos! 

Acc. sem.: escribir código 

(esquema de traducción) 

Sentencia: 9-5+2 

Resultado: 9 5 – 2 + 

T E’ 

num 1. e(‘9’) 3. e(‘-’) 

9 

operador T E’ 

- 2. e(‘5’) 

num 

5. e(‘+’) 

5 

operador T E’ 

+ 4. e(‘2’) 

num λ 

2



digito [0-9] 

letra [a-zA-Z] 

%option noyywrap 

%% 

[ \t]+ ; 

"(" return PAR_I; 

")" return PAR_D; 

[-+] {strcpy(yylval.lex, yytext); return OP;} 

{letra}({digito}|{letra})* 

{strcpy(yylval.lex, yytext); return VAR;} 

{digito}+ {strcpy(yylval.lex, yytext); return NUMERO;} 

. {printf("token erroneo\n");} 

%%



%union 

{ 

char lex[50]; 

} 

%token NUMERO, OP, PAR_I, PAR_D ASIG VAR 

%start E /* simbolo axioma sentencial */ 

%% 

E: T E1 {} 

E1: OP T {printf("%s ",$1);} E1 

| {} 

; 

T: NUMERO {printf("%s ",$1);} 

| VAR {printf("%s ",$1);} 

|PAR_I E PAR_D {} 

%%


Ejemplo Ejecución lex-yacc 

7-a+C-(4-b) 7 a - C + 4 b - -


Ejemplo Declaración Tipos 

digito [0-9] 

letra [a-zA-Z] 

%% 

[ \t]+ ; 

"," return COMA; 

";" return PCOMA; 

"=“ return ASIG; 

[-+*/] return OP; 

"float" return FLOAT; 

"int" return INT; 

{letra}({digito}|{letra})* {strcpy(yylval.nombre, 

yytext); return VAR;} 

{digito}+ {yylval.valor=atoi(yytext); 

return NUMEROENT;} 

{digito}+(.{digito}+) 

{yylval.valor=atof(yytext); 

return NUMEROREAL;} 

. {printf("token erroneo\n");}



%union 

{ 

int valor; 

char nombre[50]; 

char tipo[50]; 

} 

%token VAR 

%token NUMEROENT, NUMEROREAL 

%token OP, ASIG, COMA, PCOMA FLOAT, INT 

%left MAS OP 

%type T L S E 

%start P /* simbolo axioma sentencial */ 

...



... 

P: T L PCOMA S {} 

; 

L: L COMA VAR {printf("ponerTS(%s,%s)\n",$3,$0);} 

|VAR 

{printf("ponerTS(%s,%s)\n",$1,$0);} 

; 

T: FLOAT {sprintf($$, "float");} 

|INT 

{sprintf($$, "int");} 

; 

S: VAR ASIG E {printf("comprobar tipo var %s\n", $1);} 

| {} 

; 

E: E OP E {/*reglas combinacion de tipos (promocion)*/} 

|VAR 

{printf("buscarTS(%s)\n", $1);/*asignar tipo 

de VAR a E0*/} 

|NUMEROENT {strcpy($$, "int");} 

|NUMEROREAL {strcpy($$, "real");} 

;


Herencia de atributos, declaración tipos 

En la pila sólo hay atributos sintetizados 

Todos los atributos heredados están en posiciones predecibles en 

la pila (incluyendo el de la parte izquierda) 

cima 

cima -1 

cima -2 

cima -3 

símbolo val 

... ... 

VAR VAR.s 

COMA - 

L M 1 .s 

T T.s 

L->L COMA ID 

val [cima] $3 

val [cima–1] $2 

… 

val [cima-2] $1 

val [cima–3] $0


Ejemplo Ejecución lex-yacc 

float a,b,c,d,e,f; 

a=4*c-2.0 

ponerTS(a,float) 

ponerTS(b,float) 

ponerTS(c,float) 

ponerTS(d,float) 

ponerTS(e,float) 

ponerTS(f,float) 

buscarTS(c) 

comprobar tipo var a


Algunas opciones útiles 

Depuración del analizador: directiva 

YYDEBUG. Describe: 

• Cada una de las acciones realizadas 

(desplazamiento/reducción) 

• Tokens leídos 

• Estados visitados durante el análisis 

• Situación de la pila


Algunas opciones útiles 

Ejemplo de 

depuración: 

((a))


Ejemplo salida depuración 

Ejemplo de depuración: ((a)) 

Starting parse 

Entering state 0 

Reading a token: Next token is 40 ('(') 

Shifting token 40 ('('), Entering state 2 

Reading a token: Next token is 40 ('(') 

Shifting token 40 ('('), Entering state 2 

Reading a token: Next token is 97 ('a') 

Shifting token 97 ('a'), Entering state 1 

Reducing via rule 2 (line 12), 'a' -> S 

state stack now 0 2 2 


Reading a token: Next token is 41 (')') 

Shifting token 41 (')'), Entering state 4 

Reducing via rule 1 (line 11), '(' S ')' -> S 

state stack now 0 2 

Entering state 3


Ejemplo salida depuración 

Ejemplo de depuración: ((a)) 

state stack now 0 2 


Reading a token: Next token is 41 (')') 

Shifting token 41 (')'), Entering state 4 

Reducing via rule 1 (line 11), '(' S ')' -> S 

state stack now 0 


Reading a token: Now at end of input. 

Shifting token 0 ($), Entering state 6 

Now at end of input.


Ejemplo activación depuración 

%{ 

#include 

#define YYDEBUG 1 

%} 



%% 

... producciones 

%% 

main(int argc, char *argv[]) 

{ 

yydebug=1; 

... 

} 

Cuando yydebug no 

es 0: depuración


Gramática expresiones ambigua 

%token NUMERO, MAS, POR, '(', ')' 


%% 


expr: expr MAS expr 

|expr POR expr 

|'(' expr ')' 

| NUMERO 

%%


Información del analizador 

Opción “verbose” –v (descriptivo) 

• Descripción detallada de la tabla de análisis 

sintáctico LALR(1), y del autómata de 

reconocimiento 

• Características de la gramática: terminales no 

utilizados, símbolos no generativos, etc. 

• Notifica si hay conflictos desp/red y red/red 

home\> yacc –d –v ejemplo.y 

home\> ls 

home\> ejemplo.y ejemplo.tab.h 

ejemplo.tab.c ejemplo.output


Ejemplo Gramática Sencilla 

Ejemplo: Lenguaje: {( n a ) n }, n≥0 

Gramática: 

Σ T ={(, a, )}, Σ T ={S}, S, P} 

P: S(S) 

Sa


Ejemplo Salida yacc -v 

Grammar 

rule 1 S -> '(' S ')' 

rule 2 S -> 'a' 

Terminals, with rules where they appear 

$ (-1) 

'(' (40) 1 

')' (41) 1 

'a' (97) 2 

error (256) 

Nonterminals, with rules where they appear 

S (6) 

on left: 1 2, on right: 1


Ejemplo Salida yacc -v 

state 0 

'a' shift, and go to state 1 

'(' shift, and go to state 2 

S go to state 5 

state 1 

S -> 'a' . (rule 2) 

$default reduce using rule 2 (S) 

state 2 

S -> '(' . S ')' (rule 1) 

'a' shift, and go to state 1 

'(' shift, and go to state 2 

S go to state 3


Análisis de ambigüedad con yacc 

Opción -v 

home\> yacc –v expresiones.y 

home\> expresiones.y contains 4 

shift/reduce conflicts 

home\> ls 

home\> expresiones.y expresiones_tab.c 

expresiones.output


Ambigüedad con yacc 

State 8 contains 2 shift/reduce conflicts. 

State 9 contains 2 shift/reduce conflicts. 

Grammar 

rule 1 S -> expr 

rule 2 expr -> expr MAS expr 

rule 3 expr -> expr POR expr 

rule 4 expr -> '(' expr ')' 

rule 5 expr -> NUMERO 

Terminals, with rules where they appear 

$ (-1) 

'(' (40) 4 

')' (41) 4 

NUMERO (258) 5 

MAS (259) 2 

POR (260) 3



state 8 

expr -> expr . MAS expr (rule 2) 

expr -> expr MAS expr . (rule 2) 

expr -> expr . POR expr (rule 3) 

MAS shift, and go to state 5 

POR shift, and go to state 6 

MAS 

POR 

$default 

[reduce using rule 2 (expr)] 


reduce using rule 2 (expr)



state 9 

expr -> expr . MAS expr (rule 2) 

expr -> expr . POR expr (rule 3) 

expr -> expr POR expr . (rule 3) 

MAS shift, and go to state 5 

POR shift, and go to state 6 

MAS 

POR 

$default 



reduce using rule 3 (expr)

Introducción a Yacc - GIAA

Create successful ePaper yourself

Delete template?

Save as template?