Compiler Principle and Technology Prof. Dongming LU Mar. 7th, 2014.
-
Upload
jean-morris -
Category
Documents
-
view
217 -
download
1
Transcript of Compiler Principle and Technology Prof. Dongming LU Mar. 7th, 2014.
Compiler Principle and Technology
Prof. Dongming LUMar. 7th, 2014
3. Context-Free Grammars and Parsing
(PART TWO)
Contents
PART ONE3.1 The Parsing Process 3.2 Context-Free Grammars3.3 Parse Trees and Abstract
PART TWO3.4 Ambiguity3.5 Extended Notations: EBNF and Syntax
Diagrams 3.6 Formal Properties of Context-Free
Languages
3.4 Ambiguity
What is Ambiguity
Parse trees and syntax trees uniquely express the structure of syntax
It is possible for a grammar to permit a string to have more than one parse tree
For example, the simple integer arithmetic grammar: exp exp op exp|( exp ) | number op + | - | *
The string: 34-3*42
What is Ambiguity
exp
exp op exp
* number exp op exp
number - number
exp
exp op exp
_ exp op exp number number *
number
This string has two different parse trees.
What is Ambiguity
exp => exp op exp=> exp op exp op exp ,=> number op exp op exp=>number - exp op exp=> number - number op
exp=> number - number * exp=> number - number *
number
exp=> exp op exp =>number op exp =>number - exp =>number - exp op exp =>number - number op exp =>number - number * exp => number - number *
number
Corresponding to the two leftmost derivations
What is Ambiguity
The associated syntax trees are
An Ambiguous Grammar
A grammar that generates a string with two distinct parse trees and at least two distinct derivations. Represents a serious problem for a parser Not specify precisely the syntactic structure of a
program
In some sense, an ambiguous grammar is like a non-deterministic automaton Two separate paths can accept the same string
An Ambiguous Grammar Ambiguity in grammars
Cannot be removed nearly as easily as non-determinism in finite automata
No algorithm for doing so, unlike the situation in the case of automata
Ambiguous grammars Fail the tests that we introduce later for the
standard parsing algorithms A body of standard techniques have been developed
to deal with typical ambiguities that come up in programming languages.
Two Basic Methods dealing with Ambiguity1. A disambiguating rule: specifies in each ambiguous case which of the parse trees (or syntax trees) is the correct one
The advantage: it corrects the ambiguity without changing (and possibly complicating) the grammar.
The disadvantage: the syntactic structure of the language is no longer given by the grammar alone.
2. Change the grammar into a form: forces the construction of the correct parse tree, thus removing the ambiguity.
Of course, in either method, we must first decide which of the trees in an ambiguous case is the correct one.
Remove the Ambiguity in Simple Expression Grammar
A disambiguating rule that establishes the relative precedence of the three operations.
Give addition and subtraction the same precedence
And, to give multiplication a higher precedence
A further disambiguating rule is the associativity of each of the operations
Specify that all three of these operations are left associative
Remove the Ambiguity in simple Expression Grammar
Specify that an operation is nonassociative : A sequence of more than one operator in an expression is not allowed.
For instance, writing simple expression grammar in the following form: fully parenthesized expressions exp factor op factor | factor factor ( exp ) | number op + |- | *
Remove the Ambiguity in simple Expression Grammar
Strings such as 34-3-42 and even 34-3*42 are now illegal, and must instead be written with parentheses, such as
(34-3) -42 and 34- (3*42)
The disadvantage: not only changed the grammar, also changed the language being recognized.
3.4.2 Precedence and Associativity
Two Typical Kinds
of Ambiguities
1. The arithmetic grammars, such as : the simple integer arithmetic grammar:
exp exp op exp|( exp ) | number op + | - | *
The string: 34-3*42
2. The dangling else problem (We will discuss this later)
We use precedence and associativity to solve the first
kind of ambiguity
Group of Equal Precedence
The precedence can be added to our simple expression grammar as follows:
exp exp addop exp | termaddop + | -term term mulop term| factormulop *factor ( exp ) | number
Addition and subtraction will appear "higher" (closer to the root) in the parse and syntax trees Receive lower precedence.
Precedence Cascade Grouping operators into different precedence
levels. Cascade is a standard method in syntactic
specification using BNF.
Replacing the rule exp exp addop exp | term by exp exp addop term |term or exp term addop exp |term A left recursive rule makes operators associate on
the left A right recursive rule makes them associate on
the right
Removal of Ambiguity
Removal of ambiguity in the BNF rules for simple arithmetic expressions write the rules to make all the operations
left associativeexp exp addop term |termaddop + | -term term mulop factor | factormulop *factor ( exp ) | number
New Parse TreeThe parse tree for the expression 34-3*42 is
exp exp addop term term _ term mulop factor factor factor * number number number
New Parse Tree The parse tree for the expression 34-3-42 exp exp addop term exp addop term _ factor term _ factor number factor number number
• The precedence cascades cause the parse trees to become much more complex
• The syntax trees, however, are not affected
3.4.3 The dangling else problem
An Ambiguity Grammar
Consider the grammar from:statement if-stmt | otherif-stmt if ( exp ) statement | if ( exp ) statement else statement exp 0 | 1
This grammar is ambiguous as a result of the optional else. Consider the string
if (0) if (1) other else other
statement
if-stmt
( if exp ) statement
0 if-stmt
if ( exp ) statement
1 other
else statement
other
statement
unmatched-stmt
( if exp ) statement
0 if-stmt
if ( exp ) statement else statement
1 other other
Dangling else problem
Which tree is correct? The first associates the else-part with the first if-
statement; The second associates it with the second if-
statement. This ambiguity called dangling else problem
This disambiguating rule: the most closely nested rule Implies that the second parse tree above is the
correct one.
An Example
For example: if (x != 0)
if (y = = 1/x) ok = TRUE; else z = 1/x;
Note that, if we wanted we could associate the else-part with the first if-statement by using brackets {...} in C, as in
if (x != 0) { if (y = = 1/x) ok = TRUE; }
else z = 1/x;
A Solution to the dangling else ambiguity in the BNF
statement matched-stmt | unmatched-stmtmatched-stmt if ( exp ) matched-stmt else
matched-stmt | other unmatched-stmt if ( exp ) statement | if ( exp ) matched-stmt else unmatched-stmtexp 0 | 1
Permitting only a matched-stmt to come before an else in an if-statement Forcing all else-parts to be matched as soon as
possible.
statement
unmatched-stmt
( if exp ) statement
0 matched-stmt
if ( exp ) matched-stmt else matched-stmt
1 other other
More about dangling else The dangling else problem has its origins in the syntax
of Algol60.
It is possible to design the syntax in such a way that the dangling else problem does not appear. Require the presence of the else-part, and this
method has been used in LISP and other functional languages (where a value must also be returned).
Use a bracketing keyword for the if-statement languages that use this solution include Algol68 and Ada.
More About Dangling else
For example, in Ada, the programmer writes
if x /= 0 thenif y = 1/x then ok := true;else z := 1/x;end if; end if;
Associate the else-part with the second if-statement, the programmer writes
if x /= 0 thenif y = 1/x then ok := true;end ifelse z := 1/x; end if;
More about dangling else
BNF in Ada (somewhat simplified) is
if-stmt if condition then statement-sequence end if
| if condition then statement-sequence else
statement-sequence end if
3.4.4 Inessential ambiguity
Why Inessential
A grammar may be ambiguous and yet always produce unique abstract syntax trees.
The grammar ambiguously as
stmt-sequence stmt-sequence ; stmt-sequence
| stmt
stmt s
An ambiguity is called an inessential ambiguity
Either a right recursive or left recursive grammar rule would still result in the same syntax tree structure
Why Inessential Inessential ambiguity: the associated semantics do
not depend on what disambiguating rule is used.
Arithmetic addition or string concatenation, that represent associative operations (a binary operator • is associative if (a • b) • c = a • (b • c) for all values a, b, and c).
The syntax trees are still distinct, but represent the same semantic value
A parsing algorithm will need to apply some disambiguating rule that the compiler writer may need to supply
3.5 Extended Notations: EBNF and Syntax Diagrams
3.5.1 EBNF Notation
Special Notations for Repetitive Constructs
Repetition1. A A | (left recursive)2. A A | (right recursive)
where and are arbitrary strings of terminals and non-terminals, and
In the first rule does not begin with A
In the second does not end with A
Notation for repetition as regular expressions use, the asterisk * .
A * , and
A * EBNF opts to use curly brackets {. . .} to express repetition
A { } , and
A {} The problem with any repetition notation is that it obscures
how the parse tree is to be constructed, but, as we have seen, we often do not care.
Special Notations for Repetitive Constructs
Examples
Example: The case of statement sequences The grammar as follows, in right recursive form:
stmt-Sequence stmt ; stmt-Sequence | stmt
stmt s In EBNF this would appear as
stmt-sequence { stmt ; } stmt (right recursive form)
stmt-sequence stmt { ; stmt} (left recursive form)
Examples
A more significant problem occurs when the associativity matters
exp exp addop term | termexp term { addop term }
(imply left associativity)
exp {term addop } term (imply right associativity)
Optional construct are indicated by surrounding them with square brackets [...].
The grammar rules for if-statements with optional else-parts would be written as follows in EBNF:
statement if-stmt | other
if-stmt if ( exp ) statement [ else statement ]
exp 0 | 1
stmt-sequence stmt; stmt-sequence | stmt is written as
stmt-sequence stmt [ ; stmt-sequence ]
Special Notations for Repetitive Constructs
3.5.2 Syntax Diagrams
Syntax Diagrams
Syntax Diagrams: Graphical representations for visually representing
EBNF rules. An example: consider the grammar rule
factor ( exp ) | number The syntax diagram:
factor
number
( )exp
The syntax diagram for a context free grammar is like the DFA for RE
It help us to translate grammars
into programs
Syntax Diagrams
Boxes representing terminals and non-terminals. Arrowed lines representing sequencing and
choices. Non-terminal labels for each diagram representing
the grammar rule defining that Non-terminal. A round or oval box is used to indicate terminals
in a diagram. A square or rectangular box is used to indicate
non-terminals.
factor
number
( )exp
Syntax Diagrams
A repetition : A {B}
An optional : A [B]
B
A
B
A
Examples
Example: Consider the example of simple arithmetic expressions.
exp exp addop term | termaddop + | -term term mulop factor | factor mulop *factor ( exp ) | number
This BNF includes associativity and precedence
Examples
The corresponding EBNF isexp term { addop term }addop + | -term factor { mulop factor }mulop *factor ( exp ) | numberr ,
The corresponding syntax diagrams are given as follows:
exp
term
term addop
Examplesaddop
+
-
term
factor
factor mulop
*
mulop
factor
( exp )
number
Examples
Example: Consider the grammar of simplified if-statements, the BNF
Statement if-stmt | otherif-stmt if ( exp ) statement | if ( exp ) statement else statement exp 0 | 1
and the EBNF statement if-stmt | other if-stmt if ( exp ) statement [ else
statement ] exp 0 | 1
The corresponding syntax diagrams are given in following figure.
statement
number
if-stmt
if-stmt
if ( ) statementexp
else statement
exp
0
1
3.6 Formal Properties of Context-Free Language
3.6.1 A Formal Definition of Context-Free Language
Definition
Definition: A context-free grammar consists of the following:
1. A set T of terminals.2. A set N of non-terminals (disjoint from
T).3. A set P of productions, or grammar
rules, of the form A a, where A is an element of N and a is an element of (TN)* (a possibly empty sequence of terminals and non-terminals).
4. A start symbol S from the set N.
Definition
Let G be a grammar as defined above, G = (T, N, P, S).
A derivation step over G is of the forma A => a , Where a and are elements of (TN)*, and A is in P.
The set of symbols: The union T N of the sets of terminals and
non-terminals A sentential form:
a string a in (TN)*.
Definition
The relation a =>* is defined to be the transitive closure of the derivation step relation =>; ta =>* if and only if there is a
sequence of 0 or more derivation steps (n >= 0) a1=> a 2 =>…=> a n-1=> a n such that a =-a1, and = a n
(If n = 0, then a =)
Definition
A derivation over the grammar G is of the form S =>* w, where w T* (i.e., w is a string of terminals only,
called a sentence), and S is the start symbol of G
The language generated by G, written L(G), is defined as the set L(G) = {w T* | there exists a derivation S =>*
w of G}. L(G) is the set of sentences derivable from S.
Definition A leftmost derivation S =>*lm w
is a derivation in which each derivation step a A => a , is such that a T*; that is, a consists only of
terminals. A rightmost derivation is one in which each
derivation step a A => a has the property that T*.
Parse Tree over Grammar G
A rooted labeled tree with the following properties:1. Each node is labeled with a terminal or a non-
terminal or .2. The root node is labeled with the start symbol S.3. Each leaf node is labeled with a terminal or with .4. Each non-leaf node is labeled with a non-terminal.5. If a node with label A N has n children with labels
X1, X2,..., Xn(which may be terminals or non-terminals), then A X1X2 ... Xn P (a production of the
grammar).
CFG & Ambiguous
A set of strings L is said to be a context-free language if there is context-free grammar G such
that L = L (G).
A grammar G is ambiguous if there exists a string w L(G) such that
w has two distinct parse trees (or leftmost or rightmost derivations).
3.6.2 Grammar Rules as Equations
Meaning of Equation
The grammar rules use the arrow symbol instead of an
equal sign to represent the definition of names for
structures (non-terminals)
Left and right-hands sides still hold equality in some
extents, but the defining process of the language that
results from this view is different.
Consider, for example, the following grammar rule, which is extracted (in simplified form) from our simple expression grammar: exp exp+ exp | number
Rules as Equation A non-terminal name like exp defines a set of
strings of terminals, called E; (which is the language, of the grammar if the
non-terminal is the start symbol). let N be the set of natural numbers;
(corresponding to the regular expression name number).
Then, the given grammar rule can be interpreted as the set equation E = (E + E) N
This is a recursive equation for the set E: E = N (N+N) (N+N+N) (N+N+N+N) ……
3.6.3 Chomsky Hierarchy and Limits of Context-Free Syntax
The Power of CFGConsider the definition of a number as a sequence of digits using regular expressions:
digit = 0|1|2|3|4|5|6|7|8|9 number = digit digit*
Writing this definition using BNF, instead, asDigit 0 |1|2|3|4|5|6|7|8|9number number digit |digit
Note: the recursion in the second rule is used to express repetition only.
Regular Grammar A grammar is called a regular grammar
The recursion in the rule is used to express repetition only
Can express everything that regular expressions can Can design a parser accepting characters directly from
the input source file and dispense with the scanner altogether.
A parser is a more powerful machine than a scanner but less efficient. The grammar would then express the complete
syntactic structure, including the lexical structure The language implementers would be expected to
extract these definitions from the grammar and turn them into a scanner
Context Rules Free of context rule:
Non-terminals appear by themselves to the left of the arrow in context-free rules.
A rule says that A may be replaced regardless of where the A occurs.
Context-sensitive grammar rule: A rule would apply only if occurs before and occurs
after the non-terminal. We would write this as
A => a , (a )
Context-sensitive grammars are more powerful than context-free grammars Also much more difficult to use as the basis for a
parser.
Requirement of a Context-Sensitive Grammar Rule
The C rule requires declaration before use First: Include the name strings themselves in the
grammar rules rather than include all names as identifier tokens that are indistinguishable.
Second: For each name, we would have to write a rule establishing its declaration prior to a potential use.
Generally, the length of an identifier is unrestricted The number of possible identifiers is (at least potentially)
infinite.
Even if names are allowed to be only two characters long, The potential for hundreds of new grammar rules. Clearly,
this is an impossible situation
Solution like a Disambiguating Rule State a rule (declaration before use) not explicit in the
grammar Such a rule cannot be enforced by the parser itself,
since it is beyond the power of (reasonable) context-free rules to express.
This rule becomes part of semantic analysis Depends on the use of the symbol table (which
records which identifiers have been declared)
The static semantics of the language include type checking (in a statically typed language) and such rules as declaration before use.
Regard as syntax only those rules that can be expressed by BNF rules. Everything else we regard as semantics.
Unrestricted Grammars
More general than the context-sensitive grammars. It have grammar rules of the form
, where there are no restrictions on the form of
the strings a and (except that a cannot be )
Types of Grammars The language classes they construct are also referred
to as the Chomsky hierarchy, after Noam Chomsky, who pioneered their use to describe natural languages. type 0 : unrestricted grammar, equivalent to Turing
machinestype 1 : context sensitive grammartype 2 : context free grammar, equivalent to
pushdown automatontype 3 : regular grammar , equivalent to finite
automata These grammars represent distinct levels of computational power.
Type 0Type 0
Type 1Type 1
Type 2Type 2
Type 3Type 3
Summaries
Regular expressionRegular expression
Context free grammarContext free grammar
Power is limitedPower is limited
Formal Formal definitiodefinitionn
DerivationDerivationParse tree & Parse tree & Syntax treeSyntax tree
graphical graphical explanationexplanation
leftmost derivationleftmost derivation rightmost derivationrightmost derivation
AmbiguityAmbiguity ambiguity ambiguity eliminationelimination
Syntax analysisSyntax analysis
Lexical analysisLexical analysis
End of Part TwoTHANKS