LALR parser generator

A lookahead LR parser (LALR) generator is a software tool that reads a context-free grammar (CFG) and creates an LALR parser which is capable of parsing files written in the context-free language defined by the CFG. LALR parsers are desirable because they are very fast and small in comparison to other types of parsers.

There are other types of parser generators, such as Simple LR parser, LR parser, GLR parser, LL parser and GLL parser generators. What differentiates one from another is the type of CFG which they are capable of accepting and the type of parsing algorithm which is used in the generated parser. An LALR parser generator accepts an LALR grammar as input and generates a parser that uses an LALR parsing algorithm (which is driven by LALR parser tables).

In practice, LALR offers a good solution, because LALR(1) grammars are more powerful than SLR(1), and can parse most practical LL(1) grammars. LR(1) grammars are more powerful than LALR(1), but ("canonical") LR(1) parsers can be extremely large in size and are considered not practical. Minimal LR(1) parsers are small in size and comparable to LALR(1) parsers.

## Contents

* 1 History
* 2 Overview
* 3 See also
* 4 References
* 5 Further reading

## History

Frank DeRemer invented LALR parsers with his PhD dissertation, called "Practical LR(k) Translators", in 1969, at MIT. This was an important breakthrough, because LR(k) translators, as defined by Donald Knuth in his 1965 paper, "On the Translation of Languages from Left to Right", were much too large for implementation on computer systems in the 1960s and 70's.

An early LALR parser generator and probably the most popular one for many years was "yacc" (Yet Another Compiler Compiler), created by Stephen Johnson in 1975 at AT&T Labs.[1] Another, "TWS", was created by Frank DeRemer and Tom Pennello. Today, there are many LALR parser generators available, many inspired by and largely compatible with the original Yacc, for example GNU bison, a pun on the original Yacc/Yak. See Comparison of deterministic context-free language parser generators for a more detailed list.

## Overview

The LALR parser and its alternatives, the SLR parser and the Canonical LR parser, have similar methods and parsing tables; their main difference is in the mathematical grammar analysis algorithm used by the parser generation tool. LALR generators accept more grammars than do SLR generators, but fewer grammars than full LR(1). Full LR involves much larger parse tables and is avoided unless clearly needed for some particular computer language. Real computer languages can often be expressed as LALR(1) grammars. In cases where they can't, a LALR(2) grammar is usually adequate. If the parser generator allows only LALR(1) grammars, the parser typically calls some hand-written code whenever it encounters constructs needing extended lookahead.

Similar to an SLR parser and Canonical LR parser generator, an LALR parser generator constructs the LR(0) state machine first and then computes the lookahead sets for all rules in the grammar, checking for ambiguity. The Canonical LR constructs full lookahead sets. LALR uses merge sets, that is it merges lookahead sets where the LR(0) core is the same. The SLR uses FOLLOW sets as lookahead sets which associate the right hand side of a LR(0) core to a lookahead terminal. This is a greater simplification than that in the case of LALR because many conflicts may arise from LR(0) cores sharing the same right hand side and lookahead terminal, conflicts which are not present in LALR. This is why SLR has less language recognition power than LALR with Canonical LR being stronger than both since it does not include any simplifications.

## See also

* Comparison of parser generators - for a more complete list, which also includes LL, SLR, GLR and LR parser generators.

## References

1. ↑ Stephen C. Johnson (1975). "Yacc: Yet Another Compiler-Compiler". AT&T Bell Laboratories. http://dinosaur.compilertools.net/yacc/.

* Alfred V. Aho, Ravi Sethi, and Jeffrey D. Ullman.  Principles, Techniques, and Tools Addison—Wesley, 1986. (AKA The Dragon Book, describes the traditional techniques for building LALR(1) parsers.)
* Richard Bornat Understanding and Writing Compilers, Macmillan, 1979. (Describes the principles of automated left-to-right parsing and how to construct the parser tables, what a follow set is, etc., in English, not mathematics – available freely from the author's page at [1].)

## Further reading

* Knuth, D. E. (July 1965). "On the translation of languages from left to right". Information and Control 8 (6): 607–639. doi:10.1016/S0019-9958(65)90426-2.
* DeRemer, Franklin L. (1969). Practical Translators for LR(k) languages (PDF) (Ph.D.). MIT. Archived from the original (PDF) on 2013-08-19. Retrieved 2013-08-19.
* Efficient Computation Of LALR(1) Look-Ahead Sets, DeRemer and Pennello, TOPLAS (1982)

* v
* t
* e

Parsing algorithms

Top-down|

* LL
* Recursive descent
* Tail recursive
* Pratt parser

Bottom-up|

* Precedence
* Simple
* Operator
* Shunting-yard
* Bounded-context
* LR
* Simple
* Look-ahead
* Canonical
* Generalized
* CYK
* Recursive ascent
* Shift-reduce

Mixed, other|

* Combinator
* Chart
* Earley

Related topics|

* PEG
* Definite clause grammar
* Dynamic programming
* Memoization
* Parser generator
* LALR
* Metacompiler
* Parse tree
* AST
* Scannerless parsing
* History of compiler construction
* Comparison of parser generators

0.00

(0 votes)

Original source: https://en.wikipedia.org/wiki/LALR parser generator. Read more

|

Retrieved from "https://handwiki.org/wiki/index.php?title=Software:LALR_parser_generator&oldid=778016"
*[v]: View this template
*[t]: Discuss this template
*[e]: Edit this template