Winfried Bantel 25. Mai 2011 - Multimedia-Server Informatik

YACC 

Winfried Bantel 

HTW Aalen 

25. Mai 2011 

W. Bantel (HTW Aalen) YACC 25. Mai 2011 1 / 26

Allgemeines zu YACC 

Entwickelt in den 1970ern von Johnson bei Bell 

Yet another COmpiler-Compiler 

Häufig Varianten im Einsatz, etwa GNU-Bison oder JYACC 

Yacc produziert einen LALR-Parser 

Yacc Setzt eine Scanner-Funktoin mit dem Prototypen int yylex(); voraus 


Black-Box der Mittelwert-Funktion 

Scanner✲ 

✲ 

Grammatik 

YACC 

Parser (*.c) ✲ 


Verarbeitung von Yacc- und Lex-Datei 

Lex- 

Skript 

Yacc- 

Skript 

Lex 

Yacc 

✲ 

✲ 

C- 

Programm 

lex.yy.c 

✫✬ 

C- 

Programm 

y.tab.c 

C-Compiler 

✲ 

Ausführbares 

Programm 


Einführendes YACC-Beispiel 

Listing 1: Einführendes YACC-Beispiel (yacc/einfuehrung.y) 

%{ // D e f i n i t i o n e n und D e k l a r a t i o n e n 

#i n c l u d e 

i n t y y l e x ( ) ; 

v o i d y y e r r o r ( char ∗ ) ; 

%} 

%% // Regeln 

s t a r t : ’ a ’ | ’ ( ’ s t a r t ’ ) ’ ; 

%% // C−Code / Funtionen 

i n t main ( ) { r e t u r n y y p a r s e ( ) ; } 

i n t y y l e x ( ) { 

i n t c ; 

w h i l e ( c = g e t c h a r ( ) , c < 33 && c >−1); 

r e t u r n ( c < 0)? 0 : c ; 

} 

v o i d y y e r r o r ( char ∗ t x t ) { p r i n t f (” F e h l e r %s ” , t x t ) ; } 


Grundaufbau einer YACC-Datei (1) 

 

 

 


Grundaufbau einer YACC-Datei (2) 

Im ersten Teil werden vor allem Definitionen angegeben. Zusätzlich kann hier 

C-Code eingebracht werden, typischerweise Prototypen und Daten. 

Im zweiten Teil wird die Grammatik in einer YACC-spezifischen, der BNF 

ähnlichen Form eingegeben. Zusätzlich zur Grammatik kann Programmcode 

angegeben werden, der ausgeführt wird, wenn ein handle reduziert wird. 

Im dritten Teil werden C-Funktionen codiert. Manche Funktionen-wie etwa die 

Main-Funktion oder eine Funktion zur Fehlerausgabe-müssen hier codiert werden. 

Weitere Unterprogramme können hier ebenfalls codiert werden. 


YACC als Funktion 

YACC erzeugt Funktion 

i n t y y p a r s e ( ) ; 

YACC erwartet Scanner-Funktion 

i n t y y l e x ( ) ; 


YACC / LEX Zusammenspiel 

Scanner gibt Token zurück (Typ int) 

C-char-Konstanten sind gültige Token 

Weitere Token über %token-Direktive 

Zusätzliche Info über globale Variable yylval 

yylval -Typ über union-Deklaration 

Token können typisiert sein 


Term-Analyse in Ley / YACC (Scanner) 

Listing 2: Term-Analyse in Ley / YACC (Scanner) (yacc/term-parser.l) 

%{ 

#i n c l u d e ”y . tab . h” 

%} 

%% 

”+” r e t u r n t p l u s ; 

”∗” r e t u r n t m a l ; 

”(” r e t u r n t k l a a u f ; 

”)” r e t u r n t k l a z u ; 

[0 −9]+(”.”[0 −9]+)? r e t u r n t z a h l ; 

[ \ t \n ] /∗ do n o t h i n g ∗ / ; 

. r e t u r n t f e h l e r ; 

%% 


Term-Analyse in Lex / YACC (Parser) 

Listing 3: Term-Analyse in Lex / YACC (Parser) (yacc/term-parser.y) 

%token t p l u s t m a l t k l a a u f t k l a z u t z a h l t f e h l e r 

%% 

e x p r e s s i o n : term 

| e x p r e s s i o n t p l u s term 

; 

term : f a c t o r 

| term t m a l f a c t o r 

; 

f a c t o r : t z a h l 

| t k l a a u f e x p r e s s i o n t k l a z u 

; 

%% 


Term-Analyse in Lex / YACC (Hautprogramm) 

Listing 4: Term-Analyse in Lex / YACC (Hautprogramm) (yacc/term-parser.c) 


i n t main ( ) { 

} 

p r i n t f (” Parse−E r g e b n i s : %d\n ” , y y p a r s e ( ) ) ; 

r e t u r n 0 ; 

i n t y y e r r o r ( char ∗ s ) { 

p r i n t f (”% s \n ” , s ) ; 

} 


Term-Analyse in Lex / YACC (Erzeugung) 

Listing 5: Term-Analyse in Lex / YACC (Erzeugung) (yacc/term-parser.sh) 

l e x term−p a r s e r . l 

yacc −d term−p a r s e r . y 

gcc term−p a r s e r . c y . tab . c l e x . yy . c − l f l 


Term-Compilierung in Lex / YACC (Scanner) 

Listing 6: Term-Compilierung in Lex / YACC (Scanner) (yacc/term-compiler.l) 

%{ 

#i n c l u d e ”y . tab . h” 

#i n c l u d e < s t d l i b . h> 

%} 

%% 

”+” r e t u r n t p l u s ; 

”∗” r e t u r n t m a l ; 

”(” r e t u r n t k l a a u f ; 

”)” r e t u r n t k l a z u ; 

[0 −9]+(”.”[0 −9]+)? { y y l v a l . d = a t o f ( y y t e x t ) ; r e t u r n t z a h l ; } 

[ \ t \n ] /∗ do n o t h i n g ∗ / ; 

. r e t u r n t f e h l e r ; 

%% 


Term-Compilierung in Lex / YACC (Parser) 

Listing 7: Term-Compilierung in Lex / YACC (Parser) (yacc/term-compiler.y) 

%{ 


%} 

%union { double d ; } 

%token t p l u s t m a l t k l a a u f t k l a z u t f e h l e r 

%token< d> t z a h l 

%% 

e x p r e s s i o n : term 

| e x p r e s s i o n t p l u s term { p r i n t f (” add\n ” ) ; } 

; 

term : f a c t o r 

| term t m a l f a c t o r { p r i n t f (” mult \n ” ) ; } 

; 

f a c t o r : t z a h l { p r i n t f (” c o n s t %l f \n ” , $1 ) ; } 


; 

%% W. Bantel (HTW Aalen) YACC 25. Mai 2011 15 / 26

Term-Compilierung in Lex / YACC (Hautprogramm) 

Listing 8: Term-Compilierung in Lex / YACC (Hautprogramm) (yacc/term-compiler.c) 


i n t main ( ) { 

} 

p r i n t f (” Parse−E r g e b n i s : %d\n ” , y y p a r s e ( ) ) ; 

r e t u r n 0 ; 

i n t y y e r r o r ( char ∗ s ) { 

p r i n t f (”% s \n ” , s ) ; 

} 


Term-Compilierung in Lex / YACC (Erzeugung) 

Listing 9: Term-Compilierung in Lex / YACC (Erzeugung) (yacc/term-compiler.sh) 

l e x term−c o m p i l e r . l 

yacc −d term−c o m p i l e r . y 

gcc term−c o m p i l e r . c y . tab . c l e x . yy . c − l f l 


Term-Intertretierung in Lex / YACC (Parser) 

Listing 10: Term-Intertretierung in Lex / YACC (Parser) (yacc/term-interpreter.y) 

%{ 


%} 

%union { double d ; } 

%token t p l u s t m a l t k l a a u f t k l a z u t f e h l e r 

%token< d> t z a h l 

%type< d> e x p r e s s i o n term f a c t o r 

%% 

c a l c : e x p r e s s i o n { p r i n t f (”% l f \n ” , $1 ) ; } 

e x p r e s s i o n : term {$$ = $1 ; } 

| e x p r e s s i o n t p l u s term {$$ = $1 + $3 ; } 

; 

term : f a c t o r {$$ = $1 ; } 

| term t m a l f a c t o r {$$ = $1 ∗ $3 ; } 

; 

f a c t o r : t z a h l {$$ = $1 ; } 

| t k l a a u f e x p r e s s i o n t k l a z u {$$ = $2 ; } 


Term-Intertretierung in Lex / YACC (Erzeugung) 

Listing 11: Term-Intertretierung in Lex / YACC (Erzeugung) (yacc/term-interpreter.sh) 

l e x term−c o m p i l e r . l 

yacc −d term−i n t e r p r e t e r . y 

gcc term−c o m p i l e r . c y . tab . c l e x . yy . c − l f l 


YACC-Analyse 

> yacc -v term-parser.y 

> less y.output 

Terminals which are not used 

t_fehler 

Grammar 

0 $accept: expression $end 

1 expression: term 

2 | expression t_plus term 

3 term: factor 

4 | term t_mal factor 

5 factor: t_zahl 

6 | t_kla_auf expression t_kla_zu 


Operatoren 

Priorität: 1 + 2 * 3 

Assoziativität: a = b = 1 

Priorität über Grammatik geregelt (Hierarchie) 

Assoziativität über Grammatik geregelt (Rekursion) 

Grammatik Γ1: Assoziativität in der Grammatik 

R1 → R1 ◦ id | id 

R2 → id ◦ R2 | id 

Einfach, da Grammatrik vorliegt 

Umfangreich bei vielen Operatoren (C: 44!) 


Operatoren in YACC 

Operator-Priorität und Assoziativität über %left- und %right-Direktiven 

%left: Linksassoziativ 

%right: Rechtsassoziativi 

Reihenfolge: Priorität aufsteigend 

Voraussetzung: Mehrdeutrige Grammatik (!!!!), typischerweise 

shift-reduce-Konflikte 



Listing 12: YACC-Operatoren (yacc/term-operatoren.y) 

%token t p l u s t m a l t k l a a u f t k l a z u t z a h l t f e h l e r 

%l e f t t p l u s 

%l e f t t m a l 

%% 

e x p r e s s i o n : f a c t o r 

| e x p r e s s i o n t p l u s e x p r e s s i o n 

| e x p r e s s i o n t m a l e x p r e s s i o n 

; 

f a c t o r : t z a h l 


; 

%% 


Konflikte 

Schiebe-Reduziere-Konflikt 

Reduziere-Reduziere-Konflikt 

Warnungen (Schiebe-Reduziere) oder Fehler (Reduziere/Reduziere) 

YACC-Grammatiken sollen Konfliktfrei sein!!!! 

Große Probleme: Dangling-Else 



Listing 13: Dangling-else (yacc/if-else-konflikt.y) 

%{ 



%} 

%union { char t x t [ 2 0 0 ] ; } 

%type< t x t > stmt 

%% 

t x t : stmt { p r i n t f (” Loesung : %s \n ” , $1 ) ; } 

stmt : ’ i ’ ’ z ’ ’ t ’ stmt { s p r i n t f ( $$ , ” i z t (%s ) ” , $4 ) ; } 

| ’ i ’ ’ z ’ ’ t ’ stmt ’ e ’ stmt { s p r i n t f ( $$ , ” i z t (%s ) e (%s ) 

| ’ c ’ { s t r c p y ( $$ , ” c ” ) ; } 

; 

%% 

i n t main ( ) { r e t u r n y y p a r s e ( ) ; } 

i n t y y l e x ( ) { 

i n t c ; 

w h i l e ( c = g e t c h a r ( ) , c < 33 && c >−1); 

r e t u r n ( c < 0)? 0 : c ; 

} W. Bantel (HTW Aalen) YACC 25. Mai 2011 25 / 26


Bildschirmausgabe: 

> yacc -d if-else-konflikt.y 

conflicts: 1 shift/reduce 

> gcc y.tab.c -lfl 

> echo "i z t i z t c e c"|./a.out 

Loesung: i z t (i z t (c) e (c))

Winfried Bantel 25. Mai 2011 - Multimedia-Server Informatik

Create successful ePaper yourself

Delete template?

Save as template?