RWTH Aachen University · Recap: LR(1) and LALR(1) Parsing LR(1) Items and Sets Observation: not...

Compiler ConstructionLecture 11: Syntax Analysis VII (Practical Issues)

Summer Semester 2016

Thomas NollSoftware Modeling and Verification GroupRWTH Aachen University

https://moves.rwth-aachen.de/teaching/ss-16/cc/

Recap: LR(1) and LALR(1) Parsing

Outline of Lecture 11

Bottom-Up Parsing of Ambiguous Grammars

Generating Parsers Using yacc and bison

Expressiveness of LL and LR Grammars

LL and LR Parsing in Practice

2 of 29 Compiler Construction

Summer Semester 2016Lecture 11: Syntax Analysis VII (Practical Issues)

LR(1) Items and Sets

Observation: not every element of fo(A) can follow every occurrence of A=⇒ refinement of LR(0) items by adding possible lookahead symbols

Definition (LR(1) items and sets)

Let G = 〈N,Σ,P,S〉 ∈ CFGΣ be start separated by S′ → S.• If S′ ⇒∗r αAaw ⇒r αβ1β2aw , then [A→ β1 · β2, a] is called an LR(1) item for αβ1.• If S′ ⇒∗r αA⇒r αβ1β2, then [A→ β1 · β2, ε] is called an LR(1) item for αβ1.• Given γ ∈ X ∗, LR(1)(γ) denotes the set of all LR(1) items for γ, called the LR(1) set (or:

LR(1) information) of γ.• LR(1)(G) := {LR(1)(γ) | γ ∈ X ∗}.

LR(1) Conflicts

Definition (LR(1) conflicts)

Let G = 〈N,Σ,P,S〉 ∈ CFGΣ and I ∈ LR(1)(G).• I has a shift/reduce conflict if there exist A→ α1aα2,B → β ∈ P and x ∈ Σε such that

[A→ α1 · aα2, x ], [B → β·, a] ∈ I.

• I has a reduce/reduce conflict if there exist x ∈ Σε andA→ α,B → β ∈ P with A 6= B or α 6= β such that

[A→ α·, x ], [B → β·, x ] ∈ I.

G ∈ LR(1) iff no I ∈ LR(1)(G) contains conflicting items.

The LR(1) Action Function

Definition (LR(1) action function)

The LR(1) action function

act : LR(1)(G)× Σε → {red i | i ∈ [p]} ∪ {shift, accept, error}is defined by

act(I, x) :=

red i if i 6= 0, πi = A→ α and [A→ α·, x] ∈ Ishift if [A→ α1 · xα2, y ] ∈ I and x ∈ Σaccept if [S′ → S·, ε] ∈ I and x = εerror otherwise

Corollary

For every G ∈ CFGΣ, G ∈ LR(1) iff its LR(1) action function is well defined.

LR(0) Equivalence

Observation: potential redundancy by containment of LR(0) sets in LR(1) sets (cf.Corollary 10.3)

Definition (LR(0) equivalence)

Let lr0 : LR(1)(G)→ LR(0)(G) be defined by

lr0(I) := {[A→ β1 · β2] | [A→ β1 · β2, x] ∈ I}.Two sets I1, I2 ∈ LR(1)(G) are called LR(0)-equivalent (notation: I1 ∼0 I2) iflr0(I1) = lr0(I2).

LALR(1) Sets I

Corollary

For every G ∈ CFGΣ, |LR(1)(G)/ ∼0 | = |LR(0)(G)|.Idea: merge LR(0)-equivalent LR(1) sets(maintaining the lookahead information, but possibly introducing conflicts)

Definition (LALR(1) sets)

Let G ∈ CFGΣ.• An information I ∈ LR(1)(G) determines the LALR(1) set⋃

[I]∼0 =⋃{I ′ ∈ LR(1)(G) | I ′ ∼0 I}.

• The set of all LALR(1) sets of G is denoted by LALR(1)(G).

Remark: by Corollary 10.16, |LALR(1)(G)| = |LR(0)(G)|(but LALR(1) sets provide additional lookahead information)

Ambiguous Grammars

Reminder (Definition 5.5): a context-free grammar G ∈ CFGΣ is called unambiguous if everyword w ∈ L(G) has exactly one syntax tree. Otherwise it is called ambiguous.

Lemma 11.1

If G ∈ CFGΣ is ambiguous, then G /∈ ⋃k∈N LR(k).

Proof.

Assume that there exist k ∈ N and G ∈ LR(k) such that G is ambiguous.Hence there exists w ∈ L(G) with different right derivations. Let αAv be the last common sentenceof the two derivations (i.e., β 6= β′):

S ⇒∗r αAv

{⇒r αβv ⇒∗r w⇒r αβ

′v ⇒∗r w

But since firstk(v) = firstk(v) for every v ∈ Σ∗, Definition 8.8 yields that β = β′. Contradiction

However ambiguity is a natural specification method which generally avoids involved syntacticconstructs.

Ambiguous Grammars

Lemma 11.1

Proof.

S ⇒∗r αAv

′v ⇒∗r w

Ambiguous Grammars

Lemma 11.1

Proof.

Assume that there exist k ∈ N and G ∈ LR(k) such that G is ambiguous.

Hence there exists w ∈ L(G) with different right derivations. Let αAv be the last common sentenceof the two derivations (i.e., β 6= β′):

S ⇒∗r αAv

′v ⇒∗r w

Ambiguous Grammars

Lemma 11.1

Proof.

S ⇒∗r αAv

′v ⇒∗r w

Ambiguous Grammars

Lemma 11.1

Proof.

S ⇒∗r αAv

′v ⇒∗r w

Ambiguous Grammars

Lemma 11.1

Proof.

S ⇒∗r αAv

′v ⇒∗r w

Bottom-Up Parsing of Ambiguous Grammars I

Example 11.2 (Simple arithmetic expressions)

G : E ′ → E (0) E → E+E | E*E | a (1, 2, 3)

Precedence: * > + Associativity: left (thus: a+a*a+a :=(a+(a*a))+a)LR(0)(G): I0 := LR(0)(ε) : [E ′ → ·E ] [E → ·E+E ] [E → ·E*E ] [E → ·a]

I1 := LR(0)(E) : [E ′ → E·] [E → E · +E ] [E → E · *E ]I2 := LR(0)(a) : [E → a·]I3 := LR(0)(E+) : [E → E+ · E ] [E → ·E+E ] [E → ·E*E ] [E → ·a]I4 := LR(0)(E*) : [E → E* · E ] [E → ·E+E ] [E → ·E*E ] [E → ·a]I5 := LR(0)(E+E) : [E → E+E·] [E → E · +E ] [E → E · *E ]I6 := LR(0)(E*E) : [E → E*E·] [E → E · +E ] [E → E · *E ]

Conflicts: I1: SLR(1)-solvable (reduce on ε, shift on +/*)I5, I6: not SLR(1)-solvable (+, * ∈ fo(E))

Solution: I5: * > + =⇒ act(I5, *) := shift, + left assoc. =⇒ act(I5, +) := red 1I6: * > + =⇒ act(I6, +) := red 2, * left assoc. =⇒ act(I6, *) := red 2

G : E ′ → E (0) E → E+E | E*E | a (1, 2, 3)Precedence: * > + Associativity: left (thus: a+a*a+a :=(a+(a*a))+a)

LR(0)(G): I0 := LR(0)(ε) : [E ′ → ·E ] [E → ·E+E ] [E → ·E*E ] [E → ·a]I1 := LR(0)(E) : [E ′ → E·] [E → E · +E ] [E → E · *E ]I2 := LR(0)(a) : [E → a·]I3 := LR(0)(E+) : [E → E+ · E ] [E → ·E+E ] [E → ·E*E ] [E → ·a]I4 := LR(0)(E*) : [E → E* · E ] [E → ·E+E ] [E → ·E*E ] [E → ·a]I5 := LR(0)(E+E) : [E → E+E·] [E → E · +E ] [E → E · *E ]I6 := LR(0)(E*E) : [E → E*E·] [E → E · +E ] [E → E · *E ]

G : E ′ → E (0) E → E+E | E*E | a (1, 2, 3)Precedence: * > + Associativity: left (thus: a+a*a+a :=(a+(a*a))+a)LR(0)(G): I0 := LR(0)(ε) : [E ′ → ·E ] [E → ·E+E ] [E → ·E*E ] [E → ·a]

Conflicts: I1: SLR(1)-solvable (reduce on ε, shift on +/*)

I5, I6: not SLR(1)-solvable (+, * ∈ fo(E))Solution: I5: * > + =⇒ act(I5, *) := shift, + left assoc. =⇒ act(I5, +) := red 1

I6: * > + =⇒ act(I6, +) := red 2, * left assoc. =⇒ act(I6, *) := red 2

Solution: I5: * > + =⇒ act(I5, *) := shift, + left assoc. =⇒ act(I5, +) := red 1

I6: * > + =⇒ act(I6, +) := red 2, * left assoc. =⇒ act(I6, *) := red 2

Bottom-Up Parsing of Ambiguous Grammars II

Example 11.3 (“Dangling else”)

G : S′ → S S → iSeS | iS | a

Ambiguity: iiaea := (1) i(iaea) (common) or (2) i(ia)ea

LR(0)(G): I0 := LR(0)(ε) : [S′ → ·S] [S → ·iSeS] [S → ·iS] [S → ·a]I1 := LR(0)(S) : [S′ → S·]I2 := LR(0)(i) : [S → i · SeS] [S → i · S] [S → ·iSeS]

[S → ·iS] [S → ·a]I3 := LR(0)(a) : [S → a·]I4 := LR(0)(iS) : [S → iS · eS] [S → iS·]I5 := LR(0)(iSe) : [S → iSe · S] [S → ·iSeS] [S → ·iS] [S → ·a]I6 := LR(0)(iSeS) : [S → iSeS·]

Conflict in I4: e ∈ fo(S) =⇒ not SLR(1)-solvable

Solution (1): act(I4, e) := shift

G : S′ → S S → iSeS | iS | aAmbiguity: iiaea := (1) i(iaea) (common) or (2) i(ia)ea

The yacc and bison Tools

Usage of yacc (“yet another compiler compiler”):

spec.yyacc−→ y.tab.c lex.yy.c

[f]lex←− spec.l

yacc specification Parser source Scanner source [f]lex specification↓ cc ↓a.out

Executable LALR(1) parser

Like for [f]lex, a yacc specification is of the formDeclarations (optional)%%Rules%%Auxiliary procedures (optional)

bison : upward-compatible GNU implementation of yacc(more flexible w.r.t. file names, ...)

[f]lex←− spec.l

bison : upward-compatible GNU implementation of yacc(more flexible w.r.t. file names, ...)

[f]lex←− spec.l

bison : upward-compatible GNU implementation of yacc(more flexible w.r.t. file names, ...)13 of 29 Compiler Construction

yacc Specifications

Declarations: • Token definitions: %token Tokens• Not every token needs to be declared (’+’, ’=’, ...)• Start symbol: %start Symbol (optional)• C code for declarations etc.: %{ Code %}

Rules: context-free productions and semantic actions• A→ α1 | α2 | . . . | αn represented as

A : α1 {Action1}| α2 {Action2}...| αn {Actionn};

• Semantic actions = C statements for computing attribute values• $$ = attribute value of A• $i = attribute value of i-th symbol on right-hand side• Default action: $$ = $1

Auxiliary procedures: scanner (if not [f]lex), error routines, ...

yacc Specifications

Example: Simple Desk Calculator I%{/* SLR(1) grammar for arithmetic expressions (Example 9.11) */

#include <stdio.h>#include <ctype.h>

%}%token DIGIT%%line : expr ’\n’ { printf("%d\n", $1); };expr : expr ’+’ term { $$ = $1 + $3; }

| term { $$ = $1; };term : term ’*’ factor { $$ = $1 * $3; }

| factor { $$ = $1; };factor : ’(’ expr ’)’ { $$ = $2; }

| DIGIT { $$ = $1; };%%yylex() {

int c;c = getchar();if (isdigit(c)) yylval = c - ’0’; return DIGIT;return c;

}15 of 29 Compiler Construction

Example: Simple Desk Calculator II

> yacc calc.y> cc y.tab.c -ly> a.out2+35> a.out2+3*517

An Ambiguous Grammar I

%{/* Ambiguous grammar for arithmetic expressions (Example 11.2) */#include <stdio.h>#include <ctype.h>

%}%token DIGIT%%line : expr ’\n’ { printf("%d\n", $1); };expr : expr ’+’ expr { $$ = $1 + $3; }

| expr ’*’ expr { $$ = $1 * $3; }| DIGIT { $$ = $1; };

%%yylex() {

int c;c = getchar();if (isdigit(c)) {yylval = c - ’0’; return DIGIT;}return c;

An Ambiguous Grammar IIInvoking yacc with the option -v produces a report y.output:

...State 8

2 expr: expr . ’+’ expr2 | expr ’+’ expr .3 | expr . ’*’ expr

’+’ shift and goto state 6’*’ shift and goto state 7

’+’ [reduce with rule 2 (expr)]’*’ [reduce with rule 2 (expr)]

State 9

2 expr: expr . ’+’ expr3 | expr . ’*’ expr3 | expr ’*’ expr .

’+’ shift and goto state 6’*’ shift and goto state 7

’+’ [reduce with rule 3 (expr)]’*’ [reduce with rule 3 (expr)]

Conflict Handling in yacc

Default conflict resolving strategy in yacc:reduce/reduce: choose first conflicting production in specification

shift/reduce: prefer shift• resolves dangling-else ambiguity (Example 11.3) correctly• also adequate for strong following weak operator (* after +; Example 11.2) and for

right-associative operators• not appropriate for weak following strong operator and for left-associative binary

operators ( =⇒ reduce; see Example 11.2)For ambiguous grammar:> yacc ambig.yconflicts: 4 shift/reduce> cc y.tab.c -ly> a.out2+3*517> a.out2*3+516

Default conflict resolving strategy in yacc:reduce/reduce: choose first conflicting production in specificationshift/reduce: prefer shift

• resolves dangling-else ambiguity (Example 11.3) correctly• also adequate for strong following weak operator (* after +; Example 11.2) and for

operators ( =⇒ reduce; see Example 11.2)

For ambiguous grammar:> yacc ambig.yconflicts: 4 shift/reduce> cc y.tab.c -ly> a.out2+3*517> a.out2*3+516

Default conflict resolving strategy in yacc:reduce/reduce: choose first conflicting production in specificationshift/reduce: prefer shift

• resolves dangling-else ambiguity (Example 11.3) correctly• also adequate for strong following weak operator (* after +; Example 11.2) and for

operators ( =⇒ reduce; see Example 11.2)For ambiguous grammar:> yacc ambig.yconflicts: 4 shift/reduce> cc y.tab.c -ly> a.out2+3*517> a.out2*3+516

Precedences and Associativities in yacc I

General mechanism for resolving conflicts:%[left|right] Operators1

...%[left|right] Operatorsn

• operators in one line have given associativity and same precedence• precedence increases over lines

Example 11.4

%left ’+’ ’-’%left ’*’ ’/’%right ’^’

^ (right associative) binds stronger than * and / (left associative),which in turn bind stronger than + and - (left associative)

Precedences and Associativities in yacc I

General mechanism for resolving conflicts:%[left|right] Operators1

...%[left|right] Operatorsn

• operators in one line have given associativity and same precedence• precedence increases over lines

Example 11.4

%left ’+’ ’-’%left ’*’ ’/’%right ’^’

^ (right associative) binds stronger than * and / (left associative),which in turn bind stronger than + and - (left associative)

Precedences and Associativities in yacc II

%{/* Ambiguous grammar for arithmetic expressionswith precedences and associativities */

#include <stdio.h>#include <ctype.h>

%}%token DIGIT%left ’+’%left ’*’%%line : expr ’\n’ { printf("%d\n", $1); };expr : expr ’+’ expr { $$ = $1 + $3; }

| expr ’*’ expr { $$ = $1 * $3; }| DIGIT { $$ = $1; };

%%yylex() {

int c;c = getchar();if (isdigit(c)) {yylval = c - ’0’; return DIGIT;}return c;

Precedences and Associativities in yacc III

> yacc ambig-prio.y> cc y.tab.c -ly> a.out2*3+511> a.out2+3*517

Overview of Grammar Classes

LR(0) •G (Ex. 8.16)

SLR(1) •GAE (Ex. 9.15)

LL(1) •G ′AE (Ex. 7.4)

LR(1) •G (Ex. 10.24)

LALR(1) •GLR (Ex. 10.18)

Moreover:

LL(k) $ LL(k + 1)for every k ∈ N

LR(k) $ LR(k+1)for every k ∈ N

LL(k) ⊆ LR(k)for every k ∈ N

Overview of Language Classes

(cf. O. Mayer: Syntaxanalyse, BI-Verlag, 1978, p. 409ff)

L(LL(0))

L(LR(0))

L(LL(1))

L(SLR(1)) = L(LALR(1)) =

unambiguous CFL

L(LR(1)) = det. CFL

Moreover:

L(LL(k)) $L(LL(k + 1)) $L(LR(1))for every k ∈ N

L(LR(k)) =L(LR(1))for every k ≥ 1

Why REG 6⊆ L(LR(0))?

Definition 11.5

A language L ⊆ Σ∗ is called prefix-free if L ∩ L ·Σ+ = ∅, i.e., if no proper prefix of anelement of L is again in L.

Lemma 11.6

G ∈ LR(0) =⇒ L(G) prefix-free

Proof.

on the board

Corollary 11.7

{a, aa} ∈ REG \ L(LR(0))

Conjecture: L ∈ REG \ L(LR(0)) =⇒ L(G) not prefix-free?

Definition 11.5

Lemma 11.6

Proof.

on the board

Corollary 11.7

{a, aa} ∈ REG \ L(LR(0))

Definition 11.5

Lemma 11.6

Proof.

on the board

Corollary 11.7

{a, aa} ∈ REG \ L(LR(0))

Definition 11.5

Lemma 11.6

Proof.

on the board

Corollary 11.7

{a, aa} ∈ REG \ L(LR(0))

Definition 11.5

Lemma 11.6

Proof.

on the board

Corollary 11.7

{a, aa} ∈ REG \ L(LR(0))

Why REG ⊆ L(LL(1))?

Lemma 11.8 (cf. Lecture 2)

Every L ∈ REG can be recognized by a DFA.

Lemma 11.9

Every DFA can be transformed into an equivalent LL(1) grammar.

Proof.

on the board

Lemma 11.9

Proof.

on the board

Lemma 11.9

Proof.

on the board

In practice: use of LL(1) or LALR(1)

Detailed comparison (cf. Fischer/LeBlanc: Crafting a Compiler, Benjamin/Cummings,1988):

Simplicity: LL winsGenerality: LALR winsSemantic actions: (see semantic analysis) LL winsError handling: LL winsParser size: comparableParsing speed: comparable

Detailed comparison (cf. Fischer/LeBlanc: Crafting a Compiler, Benjamin/Cummings,1988):Simplicity: LL wins

• LL parsing technique easier to understand• recursive-descent parser easier to debug than LALR action tables

Generality: LALR winsSemantic actions: (see semantic analysis) LL winsError handling: LL winsParser size: comparableParsing speed: comparable

Detailed comparison (cf. Fischer/LeBlanc: Crafting a Compiler, Benjamin/Cummings,1988):Simplicity: LL winsGenerality: LALR wins

• “almost” LL(1) ⊆ LALR(1) (only pathological counterexamples)• LL requires elimination of left recursion and left factorization

Semantic actions: (see semantic analysis) LL winsError handling: LL winsParser size: comparableParsing speed: comparable

Detailed comparison (cf. Fischer/LeBlanc: Crafting a Compiler, Benjamin/Cummings,1988):Simplicity: LL winsGenerality: LALR winsSemantic actions: (see semantic analysis) LL wins

• actions can be placed anywhere in LL parsers without causing conflicts• in LALR: implicit ε-productions

=⇒ may generate conflicts

Error handling: LL winsParser size: comparableParsing speed: comparable

Detailed comparison (cf. Fischer/LeBlanc: Crafting a Compiler, Benjamin/Cummings,1988):Simplicity: LL winsGenerality: LALR winsSemantic actions: (see semantic analysis) LL winsError handling: LL wins

• top-down approach provides context information=⇒ better basis for reporting and/or repairing errors

Parser size: comparableParsing speed: comparable

Detailed comparison (cf. Fischer/LeBlanc: Crafting a Compiler, Benjamin/Cummings,1988):Simplicity: LL winsGenerality: LALR winsSemantic actions: (see semantic analysis) LL winsError handling: LL winsParser size: comparable

• LL: action table• LALR: action/goto table

Parsing speed: comparable

Detailed comparison (cf. Fischer/LeBlanc: Crafting a Compiler, Benjamin/Cummings,1988):Simplicity: LL winsGenerality: LALR winsSemantic actions: (see semantic analysis) LL winsError handling: LL winsParser size: comparableParsing speed: comparable

• both linear in length of input program(LL(1): see Lemma 7.13 for ε-free case)• concrete figures tool dependent

Detailed comparison (cf. Fischer/LeBlanc: Crafting a Compiler, Benjamin/Cummings,1988):Simplicity: LL winsGenerality: LALR winsSemantic actions: (see semantic analysis) LL winsError handling: LL winsParser size: comparableParsing speed: comparableConclusion: choose LL when possible(depending on available grammars and tools)

RWTH Aachen University · Recap: LR(1) and LALR(1) Parsing LR(1) Items and Sets Observation: not...

Documents

Transcript of RWTH Aachen University · Recap: LR(1) and LALR(1) Parsing LR(1) Items and Sets Observation: not...

Bison Tutorial - University of Toronto · 2017-12-03 · Description of Bison LALR(1) parser generator under the LALR(1) parser generator under the GNU license Bison Context Free

CS415 Compilers LR Parsing & Error Recoveryzz124/cs415_spring2014/... · Review: LR(k) items The LR(1) table construction algorithm uses LR(1) items to represent valid configurations

An annotated context-free grammar based vulnerability detection using LALR parser

dl.mahan.ac.irdl.mahan.ac.ir/soal93/مهندسی کامپیوتر - دفترچه 2.pdfS aBDb D I T— > xTx I x 513A LLO) 0 SLR LALR / LR(O) —S —S } LR(O) (Y LALR(I) ILL(I) S aAbB

& Collectible Items - .22 Box Identification Guide for ...22box-id.com/specials/tins/REM_Tins.pdf · & Collectible Items ... LR-11 FIVE POUNDER CANS Bulk packed round tin can of 675

1 Bottom up parsing General idea LR(0) SLR LR(1) LALR To best exploit JavaCUP, should understand the theoretical basis (LR parsing);

Análisis sintáctico - ulpgc.es · Análisis ascendente 3.1 LR parsing (bottom-up) 3.1.1 SLR 3.1.2 LR canónico 3.1.3 LALR 3.2 YACC (parser generator) 3 1. Introducción Objetivo

Tabelle LALR Costruzione delle tabelle LALR Metodo LALR Introduciamo lultimo metodo di costruzione di tabelle per il parsing LR Nome: lookahead-LR abbreviato.

Parsing V The LR(1) Table Construction - University of …cavazos/cisc672-fall08/...LR(1) items The LR(1) table construction algorithm uses LR(1) items to represent valid configurations

(SUBJECT TO REVISION) Plan 11 - Integrated Water ... · LR-WI-12 LR-WI-13 LR-WI-14 LR-WI-15 LR-WI-16 LR-WI-17 LR-WI-18 LR-WI-19 LR-WI-20 LR-WI-21 LR-WI-22 DEVON PARK DS OLDBURY DS

Oppgaver til INF 5110, kapittel 5 · For riktige setninger vil en med LALR(1)-tabellen og LR(1)-tabellen gjøre nøyaktig de samme skift- og reduser-stegene. For gale setninger kan

MEASURING AND EXTENDING LR(1) PARSER ...cssauh.com/xc/pub/chenx_dissertation.pdfCommonly used parser generation algorithms such as LALR, LL and SLR all have their restric-tions. The

LALR Parser Presentation ppt

Kap. 5 del 2 – SLR(1), LR(1) og LALR(1) – grammatikker INF5110 – v2005

(départ ou arrivée) DÉCEMBRE NOVEMBRE OCTOBRE … · 2019-09-16 · Les Glénans Solo LR LR LR LR LR LR LR LR CON LR LR LR BR BR BL LR LOR LOR LOR MA ZAD ZAD MA MA MA MA MA MA

COMPILER DESIGN - KopyKitab€¦ · 5.4.5 construction of me action and goto table for the lr(1) parser 171 5.4.6 construction of me lalr parsing table 173 5.4.7 parser conflicts

LR-анализ · lr-грамматикиАвтомат Кнутаlr(1)-анализ lr-анализ. lr-грамматикиАвтомат Кнутаlr(1)-анализ lr-анализ

LR(1) & LALR PARSER

Procesadores de Lenguaje...Analizadores LALR Procesadores de Lenguaje Crisna Tirnauca Domingo Gómez Pérez DPTO. DE MATEMÁTICAS, ESTADÍSTICA Y COMPUTACIÓN El Analizador LALR El

Reachability and error diagnosis in LR(1) parsersgallium.inria.fr/seminaires/transparents/20160215.Francois.Pottier.pdfOops Yea, right. $ menhir --lalr -lg 1 -la 1 parser.mly Grammar