Introduction. Introduction. Introduction. Lexical Analysis. Lexical Analysis 4/2/2019. Chapter 4. Lexical and Syntax Analysis.

Transcription

1 Chapter 4. Lexical and Syntax Analysis Introduction Introduction The Parsing Problem Three approaches to implementing programming languages Compilation Compiler translates programs written in a highlevel programming language into machine code. Pure Interpretation - perform no translation; rather, programs are interpreted in their original form by a software interpreter. Hybrid implementation translate programs written in highlevel languages into intermediate forms, which are interpreted All three of the implementation approaches use both lexical and syntax analyzers. 1 2 Introduction Introduction Syntax analyzers(parsers) are based on context-free grammars (BNF). Using BNF has at least three compelling advantages. BNF descriptions of the syntax of programs are clear and concise, both for humans and for software systems that use them. the BNF description can be used as the direct basis for the syntax analyzer. Implementations are relatively easy to maintain because of their modularity of BNF. Most of compilers separate the task of analyzing syntax into two distinct parts: lexical analysis and syntax analysis. Lexical analyzer deals with small-scale language constructs, such as names and numeric literals. Syntax Analyzer - deals with the large-scale constructs, such as expressions, statements, and program units. Reasons to Separate Lexical and Syntax Analysis Simplicity - less complex approaches can be used for lexical analysis; separating them simplifies the parser (divide and conquer) Efficiency - separation allows optimization of the lexical analyzer Portability - parts of the lexical analyzer may not be portable, but the parser always is portable 3 4 A lexical analyzer is a pattern matcher for character strings. A lexical analyzer serves as the front end of a syntax analyzer. A lexical analyzer performs syntax analysis at the lowest level of program structure. An input program appears to a compiler as a single string of characters. The lexical analyzer collects characters into logical groupings and assigns internal codes to the groupings according to their structure. These logical groupings are named lexemes, and the internal codes for categories of these groupings are named tokens Example of an assignment statement: result = oldsum value / 100; Token IDENT ASSIGN_OP = IDENT SUB_OP IDENT Lexeme result oldsum DIV_OP / value INT_LIT 100 SEMICOLON ; 5 6 1

2 Lexical analyzers extract lexemes from a given input string and produce the corresponding tokens. Lexical analyzers are subprograms that locate the next lexeme in the input, determine its associated token code, and return them to the caller, which is the syntax analyzer. Each call to the lexical analyzer returns a single lexeme and its token. The lexical-analysis process includes skipping comments and white space outside lexemes. Also, the lexical analyzer inserts lexemes for user-defined names into the symbol table, which is used by later phases of the compiler (need assign with a value now or later). Finally, lexical analyzers detect syntactic errors in tokens, and report errors to the user. The lexical analyzer is usually a function that is called by the parser when it needs the next token Three approaches to building a lexical analyzer: Write a formal description of the tokens and use a software tool that constructs a table-driven lexical analyzer from such a description Design a state diagram that describes the tokens and write a program that implements the state diagram Design a state diagram that describes the tokens and hand-construct a table-driven implementation of the state diagram 7 8 The State diagram (directed graph) Nodes are labeled with state name The arcs are labeled with the input characters that cause the transitions among the states. An arc may also include actions the lexical analyzer must perform when the transition is taken. State diagrams of the form used for lexical analyzers are representations of a class of mathematical machines called finite automata. Finite automata can be designed to recognize members of a class of languages called regular languages. Regular grammars are generative devices for regular languages. The state diagram could simply include states and transitions for each and every token pattern. However, that approach results in a very large and complex diagram, because every node in the state diagram would need a transition for every character in the character set of the language being analyzed. We therefore consider ways to simplify it. Check following example: lexical analyzer that recognizes only arithmetic expressions, including variable names and integer literals as operands. The variable names consist of strings of uppercase letters, lowercase letters, and digits but must begin with a letter. Names have no length limitation. There are 52 different characters that can begin a name Check following example: lexical analyzer that recognizes only arithmetic expressions, including variable names and integer literals as operands. The variable names consist of strings of uppercase letters, lowercase letters, and digits but must begin with a letter. Names have no length limitation. There are 52 different characters that can begin a name. Lexical analyzer is interested only in determining that it is a name and is not concerned with which specific name it happens to be. We define a character class named LETTER or all 52 letters and use a single transition on the first letter of any name. There are 10 different characters that could begin an integer literal lexeme. Lexical analyzer is interested only in determining that it is a integer and is not concerned with which specific number it happens to be. We define a number class named DIGIT for digites

3 /**************************************************************/ /* lex - a simple lexical analyzer for arithmetic expressions */ /**************************************************************/ int lex() lexlen = 0; getnonblank(); switch (charclass) /* Parse identifiers: start with a letter */ case LETTER: /*add a character to global buffer lexeme[100] */ getchar(); /*get a character and assign to global char nextchar */ while (charclass == LETTER charclass == DIGIT) getchar(); nexttoken = IDENT; /* Parse integer literals: start with number */ case DIGIT: getchar(); while (charclass == DIGIT) getchar(); nexttoken = INT_LIT; /* Parentheses and operators: operators *, +, -, or parentheses */ case UNKNOWN: lookup(nextchar); getchar(); /* EOF */ case EOF: nexttoken = EOF; lexeme[0] = 'E'; lexeme[1] = 'O'; lexeme[2] = 'F'; lexeme[3] = 0; /* End of switch */ printf("next token is: %d, Next lexeme is %s\n", nexttoken, lexeme); return nexttoken; /* End of function lex */ 13 /**************************************************/ /* addchar - a function to add nextchar to lexeme */ /**************************************************/ void addchar() if (lexlen <= 98) lexeme[lexlen++] = nextchar; lexeme[lexlen] = 0; printf("error - lexeme is too long \n"); /*********************************************************************************************/ /* getchar - a function to get the next character of input and determine its character class */ /*********************************************************************************************/ void getchar() if ((nextchar = getc(in_fp))!= EOF) if (isalpha(nextchar)) charclass = LETTER; if (isdigit(nextchar)) charclass = DIGIT; charclass = UNKNOWN; charclass = EOF; 14 /********************************************************************************/ /* lookup - a function to lookup operators and parentheses and return the token */ /********************************************************************************/ int lookup(char ch) switch (ch) case '(': nexttoken = LEFT_PAREN; case ')': nexttoken = RIGHT_PAREN; case '+': nexttoken = ADD_OP; case '-': nexttoken = SUB_OP; case '*': nexttoken = MULT_OP; case '/': nexttoken = DIV_OP; default: nexttoken = EOF; return nexttoken; #include <stdio.h> #include <ctype.h> /* Global variable declarations */ int charclass; char lexeme [100]; char nextchar; int lexlen; int token; int nexttoken; FILE *in_fp, *fopen(); /* Function prototype */ void void getchar(); void getnonblank(); int lex(); /* Character classes */ #define LETTER 0 #define DIGIT 1 #define UNKNOWN 99 /* Token codes */ #define INT_LIT 10 #define IDENT 11 #define ASSIGN_OP 20 #define ADD_OP 21 #define SUB_OP 22 #define MULT_OP 23 #define DIV_OP 24 #define LEFT_PAREN 25 #define RIGHT_PAREN /****************************************************************************************/ /* getnonblank - a function to call getchar until it returns a non-whitespace character */ /****************************************************************************************/ void getnonblank() while (isspace(nextchar)) getchar(); /******************************************************/ /* main driver */ /******************************************************/ int main() /* Open the input data file and process its contents */ if ((in_fp = fopen("front.in", "r")) == NULL) printf("error - cannot open front.in \n"); getchar(); do lex(); while (nexttoken!= EOF); return 0; Consider the following expression: (sum + 47) / total The lexical analyzer front.c will be create following outputs. Next token is: 25 Next lexeme is ( Next token is: 11 Next lexeme is sum Next token is: 21 Next lexeme is + Next token is: 10 Next lexeme is 47 Next token is: 26 Next lexeme is ) Next token is: 24 Next lexeme is / Next token is: 11 Next lexeme is total Next token is: -1 Next lexeme is EOF

4 it is possible to build a state diagram to recognize every specific reserved word of a programming language, that would result in a prohibitively large state diagram. It is much simpler and faster to have the lexical analyzer recognize names and reserved words with the same pattern and use a lookup in a table of reserved words to determine which names are reserved words. name IDENT Lookup reserved words Reserved words if A lexical analyzer often is responsible for the initial construction of the symbol table, which acts as a database of names for the compiler. The entries in the symbol table store information about user-defined names, as well as the attributes of the names. For example, if the name is that of a variable, the variable s type is one of its attributes that will be stored in the symbol table. Names are usually placed in the symbol table by the lexical analyzer. The attributes of a name are usually put in the symbol table by some part of the compiler. int Introduction to Parsing Introduction to Parsing Parsing is the part of the process of analyzing syntax. Parsers for programming languages construct parse trees for given programs. The information required to build the parse tree is created during the parse. Both parse trees and derivations include all of the syntactic information needed by a language processor. Two distinct goals of syntax analysis (parser): Check the input program to determine whether it is syntactically correct. Produce a complete parse tree, or at least trace the structure of the complete parse tree, for syntactically correct input. The parse tree (or its trace) is used as the basis for translation. Parsers are categorized according to the direction in which they build parse trees. Top-down parsing Start from starting symbol to the string with scanning left to right through the string corresponds to a left-most derivation. Bottom-up parsing Start from the sting to starting symbol with scanning left to right through the string corresponds to a right-most derivation in reverse order Introduction to Parsing (Top-down Parsers) Introduction to Parsing (Top-down Parsers) A top-down parser traces or builds a parse tree in preorder. A preorder traversal of a parse tree begins with the root. Each node is visited before its branches are followed. Branches from a particular node are followed in left-to-right order. This corresponds to a leftmost derivation. Given a sentential form that is part of a leftmost derivation, the parser s task is to find the next sentential form in that leftmost derivation. The general form of a left sentential form is xa, whereby our notational conventions x is a string of terminal symbols, A is the leftmost nonterminal, and is a mixed string. A will be expanded to get next sentential form in a left most derivation. Ex) with current sentential form xa and production rules for A: A bb cbb a. Top-down parser must choose among these three rules to get the next sentential form, which could be xbb, xcbb, or xa. This is the parsing decision problem for top-down parsers. The parser can easily choose the correct RHS based on the next token of input, which must be a, b, or c in this example. The most common top-down parsing algorithms: Recursive descent - a coded implementation LL parsers - table driven implementation (Left-to-right scan of input and Leftmost derivation)

5 Introduction to Parsing (Bottom-Up Parsers) A bottom-up parser constructs a parse tree by beginning at the leaves and progressing toward the root. This parse order corresponds to the reverse of a rightmost derivation. Given a right sentential form, the parser must determine what substring of is the RHS of the rule in the grammar that must be reduced to its LHS to produce the previous sentential form in the rightmost derivation. The most common bottom-up parsing algorithms are in the LR family (Left-to-right scan, Right most derivation in reverse order) Ex) S aac A aa b with sentence aabc aabc aaac aac S Introduction to Parsing (The Complexity of Parsing) The Complexity of Parsing Parsers that work for any unambiguous grammar are complex and inefficient ( O(n 3 ), where n is the length of the input ) Compilers use parsers that only work for a subset of all unambiguous grammars, but do it in linear time ( O(n), where n is the length of the input ) A recursive-descent parser is so named because it consists of a collection of subprograms, many of which are recursive, and it produces a parse tree in top-down order. EBNF is ideally suited for recursive-descent parsers. Consider the following examples: <if_statement> if <logic_expr> <statement> [ <statement>] <ident_list> ident, ident In the first rule, the clause of an if statement is optional. In the second, an <ident_list> is an identifier, followed by zero or more repetitions of a comma and an identifier. A recursive-descent parser has a subprogram for each nonterminal in its associated grammar. The responsibility of the subprogram associated with a particular nonterminal is as follows: When given an input string, it traces out the parse tree that can be rooted at that nonterminal and whose leaves match the input string. In effect, a recursive-descent parsing subprogram is a parser for the language (set of strings) that is generated by its associated nonterminal. We are going to define subprograms for each nonterminal with the following EBNF description of simple arithmetic expressions: <expr> <term> (+ -) <term> <term> <factor> (* /) <factor> <factor> id int_constant ( <expr> ) In the following recursive-descent function, expr, the lexical analyzer is the function that is implemented before. It gets the next lexeme and puts its token code in the global variable nexttoken. /*************************************************************************/ /* subprogram expr parses strings in the language generated by the rule: */ /* <expr> -> <term> (+ -) <term> */ /*************************************************************************/ void expr() printf("enter <expr>\n"); term(); /* Parse the first term */ Recursive-descent parsing subprograms are written with the convention that each one leaves the next token of input in nexttoken. So, whenever a parsing function begins, it assumes that nexttoken has the code for the leftmost token of the input that has not yet been used in the parsing process. /* As long as the next token is + or -, get the next token and parse the next term */ while (nexttoken == ADD_OP nexttoken == SUB_OP) lex(); term(); printf("exit <expr>\n"); /* End of function expr */

6 /*************************************************************************/ /* subprogram term parses strings in the language generated by the rule: */ /* <term> -> <factor> (* /) <factor>) */ /*************************************************************************/ void term() printf("enter <term>\n"); /* Parse the first factor */ factor(); /* As long as the next token is * or /, get the next token and parse the next factor */ while (nexttoken == MULT_OP nexttoken == DIV_OP) lex(); factor(); printf("exit <term>\n"); /* End of function term */ /**************************************************************************/ /* subprogram factor parses strings in the language generated by the rule:*/ /* <factor> -> id int_constant ( <expr> ) */ /**************************************************************************/ void factor() printf("enter <factor>\n"); /* Determine which RHS */ if (nexttoken == IDENT nexttoken == INT_LIT) lex(); /* Get the next token */ /* If the RHS is ( <expr>), call lex to pass over the left parenthesis, call expr, and check for the right parenthesis */ if (nexttoken == LEFT_PAREN) lex(); expr(); if (nexttoken == RIGHT_PAREN) lex(); error(); /* End of if (nexttoken ==... */ /* It was not an id, an integer literal, or a left parenthesis */ error(); /* End of */ printf("exit <factor>\n");; /* End of function factor */ Following is the trace of the parse of the example expression (sum + 47) / total, using the parsing functions expr, term, and factor, and the function lex. Next token is: 25 Next lexeme is ( Enter <expr> Enter <term> Enter <factor> Next token is: 11 Next lexeme is sum Enter <expr> Enter <term> Enter <factor> Next token is: 21 Next lexeme is + Exit <factor> Exit <term> Next token is: 10 Next lexeme is 47 Enter <term> Enter <factor> Next token is: 26 Next lexeme is ) Exit <factor> Exit <term> Exit <expr> Next token is: 24 Next lexeme is / Exit <factor> Next token is: 11 Next lexeme is total Enter <factor> Next token is: -1 Next lexeme is EOF Exit <factor> Exit <term> Exit <expr> <expr> <term> (+ -) <term> <term> <factor> (* /) <factor> <factor> id int_constant ( <expr> ) Parse tree for expression (sum + 47) / total <expr> <term> (+ -) <term> <term> <factor> (* /) <factor> <factor> id int_constant ( <expr> ) /**************************************************************************/ /* Function ifstmt parses strings in the language generated by the rule: */ /* <ifstmt> -> if (<boolexpr>) <statement> [ <statement>] */ /**************************************************************************/ void ifstmt() if (nexttoken!= IF_CODE) /* Be sure the first token is 'if' */ error(); lex(); /* Call lex to get to the next token */ if (nexttoken!= LEFT_PAREN) /* Check for the left parenthesis */ error(); boolexpr(); /* Call boolexpr to parse the Boolean expression */ if (nexttoken!= RIGHT_PAREN) /* Check for the right parenthesis */ error(); statement(); /* Call statement to parse the then clause */ if (nexttoken == ELSE_CODE) /* If an is next, parse the clause */ lex(); /* Call lex to get over the */ statement(); /* end of if (nexttoken == ELSE_CODE... */ /* end of of if (nexttoken!= RIGHT... */ /* end of of if (nexttoken!= LEFT... */ /* end of of if (nexttoken!= IF_CODE... */ /* end of ifstmt */ /* end of Organization ifstmt */ of Programming Language 35 One simple grammar characteristic that causes a catastrophic problem for LL parsers is left recursion. Consider the following rule: A A + B A recursive-descent parser subprogram for nonterminal A call itself to parse the first symbol in its RHS rule. It calls itself again and again The left recursion in the rule A A + B is called direct left recursion, because it occurs in one rule. 36 6

7 Direct left recursion can be eliminated from a grammar by the following process. For each nonterminal A, 1. A A 1 A 2 A m 1 1 n where non of the begin with A. 2. Replace the original A rules with A 1 A 2 A n A A 1 A 2 A m A where is empty string. A rule that has as its RHS is called an erasure rule, because its use in a derivation effectively erases its LHS from the sentential form. Ex) Eliminate direct left recursion in following rules T 2. T T * F F 3. F (E) id From rule 1) 1 = + T, and 1 =T E T E E + T E From rule 2) 1 = * F and 1 = F T F T T * F T There is no direct left recursion in rule 3) Equivalent grammar without direct left recursive E T E E + T E T F T T * F T F (E) id Indirect left recursion poses the same problem as direct left recursion. For example, suppose we have production rule A B a A B A b A recursive-descent parser for these rules would have the A subprogram immediately call the subprogram for B, which immediately calls the A subprogram. So, the problem is the same as for direct left recursion. There is an algorithm to modify a given grammar to remove indirect left recursion(aho et al., 2006). When writing a grammar for a programming language, we can usually avoid including left recursion, both direct and indirect. There is a relatively simple test of a non left recursive grammar that indicates whether this can be done, called the pairwise disjointness test. This test requires the ability to compute a set based on the RHSs of a given nonterminal symbol in a grammar. These sets, which are called FIRST, are defined as FIRST() = a =>* a (If =>*, is in FIRST()) Pairwise Disjointness Test: For each nonterminal, A, in the grammar that has more than one RHS, for each pair of rules, A i and A j, it must be true that FIRST( i ) FIRST( j ) = In other words, if a nonterminal A has more than one RHS, the first terminal symbol that can be generated in a derivation for each of them must be unique to that RHS. Ex1) A ab bab Bb B cb d For non-terminal A, there are three rules First (ab) =a First(bAb)=b, First(Bb)=c, d :Disjoint Ex2) A ab BAb B ab b For non-terminal A, there are three possible rules First(aB)=a, First(BAb) = a, b :not disjoint

8 In many cases, a grammar that fails the pairwise disjointness test can be modified so that it will pass the test. For example, following production rule clearly do not pass the pairwise disjointness test, because both RHSs begin with the same terminal, identifier. <variable> identifier identifier [<expression>] This problem can be alleviated through a process called left factoring Our modified rule do pass the pairwise disjointness test. <variable> identifier <new> <new> [<expression>] Following production rule for arithmetic expressions has left recursive which cause problem in top-down parser since it do the leftmost derivation. E E + T T T T * F F F (E) id Left recursive is acceptable to bottom-up parsers since it use rightmost derivation. E => E + T => E + T * F => E + T * id => E + F * id => E + id * id => T + id * id => F + id * id => id + id * id The process of bottom-up parsing produces the reverse of a rightmost derivation. Rightmost Derivation E => E + T => E + T * F => E + T * id => E + F * id => E + id * id => T + id * id => F + id * id => id + id * id The reverse of Rightmost Derivation id + id * id => F + id * id => T + id * id => E + id * id => E + F * id => E + T * id => E + T * F => E + T => E A bottom-up parser starts with the last sentential form (the input sentence) and produces the sequence of sentential forms from there until all that remains is the start symbol, which in this grammar is E. In each step, the task of the bottom-up parser is to find the specific RHS, the handle, in the sentential form that must be rewritten to get the next (previous) sentential form. A right sentential form may include more than one RHS A right sentential form may include more than one RHS. From previous example E E + T T T T * F F F (E) id id + id * id => F + id * id => T + id * id => E + id * id => E + F * id => E + T * id => E * id : not legal right sentential form => E + T * id => E + T * F => E + T => E The handle of a right sentential form is unique. The task of a bottom-up parser is to find the handle of any given right sentential form that can be generated by its associated grammar. Def: is the handle of the right sentential form = w if and only if S =>* rm Aw => rm w Def: is a phrase of the right sentential form if and only if S =>* = 1 A 2 =>+ 1 2 Def: is a simple phrase of the right sentential form if and only if S =>* = 1 A 2 => 1 2 => rm specifies a rightmost derivation step, and => * rm specifies zero or more rightmost derivation steps. => + specifies one or more derivation steps

9 A phrase is related with a partial parse tree. A phrase is the string of all of the leaves of the partial parse tree that is rooted at one particular internal node of the whole parse tree. A simple phrase is just a phrase that takes a single derivation step from its root nonterminal node. In terms of a parse tree, a phrase can be derived from a single nonterminal in one or more tree levels, but a simple phrase can be derived in just a single tree level. The leaves of the parse tree comprise the sentential form E + T * id Three phrases generated by internal nodes E, T and F E + T * id T * id id Because there are three internal nodes, there are three phrases. Each internal node is the root of a subtree, whose leaves are a phrase Notice that phrases are not necessarily RHSs in the underlying grammar. The simple phrases are a subset of the phrases. A simple phrase is always an RHS in production rule of the grammar (Shift-Reduce Algorithm) The reason for discussing phrases and simple phrases is this: The handle of any rightmost sentential form is its leftmost simple phrase. So now we have a highly intuitive way to find the handle of any right sentential form, assuming we have the grammar and can draw a parse tree. This approach to finding handles is not practical for a parser. (If you already have a parse tree, why do you need a parser?) An integral part of every bottom-up parser is a stack. The shift action moves the next input token onto the parser s stack. A reduce action replaces an RHS (the handle) on top of the parser s stack by its corresponding LHS. Every parser for a programming language is a pushdown automaton (PDA)- PDA is a recognizer for a context-free language. A PDA is a very simple mathematical machine that scans strings of symbols from left to right. A PDA is so named because it uses a pushdown stack as its memory. PDAs can be used as recognizers for context-free languages () () Most of bottom-up parsing are variations of a process called LR ("L" stands for left-to-right scanning of the input. "R" stands for constructing a right most derivation in reverse). LR parsers use a relatively small program and a parsing table that is built for a specific programming language. The original LR algorithm was designed by Donald Knuth (Knuth, 1965). This algorithm, which is sometimes called canonical LR, was not used immediately because producing the required parsing table required large amounts of computer time and memory. Several variations on the canonical LR table construction process were developed (DeRemer, 1971; DeRemer and Pennello, 1982) with less cost of computer time and memory. Advantages to LR parsers They can be built for all programming languages. They can detect syntax errors as soon as it is possible in a left-to-right scan. The LR class of grammars is a proper superset of the class parsable by LL parsers (for example, many left recursive grammars are LR, but none are LL). Disadvantage Difficult to produce by hand the parsing table for a given grammar for a complete programming language. But there are programs available that take a grammar as input and produce the parsing table

10 () () Knuth discovered that regardless of the length of the input string, the length of the sentential form, or the depth of the parse stack, there were only a relatively small number of different situations, as far as the parsing process is concerned. Each situation could be represented by a state and stored in the parse stack, one state symbol for each grammar symbol on the stack. At the top of the stack would always be a state symbol, which represented the relevant information from the entire history of the parse, up to the current time. Top S m X m S 1 X 1 S 0 Stack a i a i+1 Parser Input tape Parsing Table structure of an LR parser X are grammar symbols S are state symbols a n $ () () An LR parser configuration is a pair of strings (stack, input), with the detailed form. (S 0 X 1 S 1 X 2 S 2 X m S m, a i a i+1 a n $) Dollar sign $ is used as end of input symbol which is used for normal termination of the parser. Using this parser configuration, we can formally define the LR parser process, which is based on the parsing table. An LR parsing table has two parts, named ACTION and GOTO. The ACTION part of the table specifies most of what the parser does. It has state symbols as its row labels and the terminal symbols of the grammar as its column labels. The parser actions are informally defined as follows: The Shift process is simple: The next symbol of input is pushed onto the stack, along with the state symbol that is part of the Shift specification in the ACTION table. For a Reduce action, the handle must be removed from the stack. Because for every grammar symbol on the stack there is a state symbol, the number of symbols removed from the stack is twice the number of symbols in the handle. After removing the handle and its associated state symbols, the LHS of the rule is pushed onto the stack. Finally, the GOTO table is used, with the row label being the symbol that was exposed when the handle and its state symbols were removed from the stack, and the column label being the nonterminal that is the LHS of the rule used in the reduction. When the action is Accept, the parse is complete and no errors were found. When the action is Error, the parser calls an error-handling routine LR(0) stack Use LR(0) items SLR(1) Simple LR Input tape LR Parser Parsing Table LALR(1) Look Ahead LR Use LR(1) items CLR(1) Canonical LR Each have same structure except parting table (LR(0) Parser: Augmented Grammar) How to build LR(0) Parsing Table with a example S AA A aa b Add one production rule which is called augmented grammar. Augmented grammar: If G is a grammar with starting symbol S, then, the augmented grammar for G is G with a new start symbol S and production S ->S will be included. G accept same language as G S S S AA A aa b 10

11 (LR(0) Parser: LR(0) item) An LR(0) item is a production of grammar with exactly one dot on the right-hand side. For example production S AA leads to four LR(0) items: S.AA S A.A S AA. What is to the left of the dot has just been read, and the parser is ready to read the remainder, after dot (LR(0) Parser: Closure) Suppose that S is a set of LR(0) items. The following rules tell how to build closure(s). You must add LR(0) items to S until there are no more add. 1. All members of S are in the closure(s). 2. Suppose closure(s) contains item A α Bβ, where B is a nonterminal. Find all productions B γ 1,, B γ n with B on the left-hand side. Add LR(0) items B γ 1, B γ n to closure(s). For example, let s take the closure of set S A.A Since there is an item with a dot immediately before nonterminal A, we add A.aA and A.b The set now contains the following LR(0) items S A.A A.aA A.b (LR(0) Parser: Build Parsing Table with Exmple1) (LR(0) Parser: Build Parsing Table with Exmple1) Lets build LR(0) parsing table with following augmented grammar. The rules are numbered to provide a way to reference to parse table. S S 1. S AA 2. A aa 3. A b Since start symbol is S, start state is labeled by closer of set S S which are: S.S S.AA A.aA.b Closure of S.S I 0 S.S S.AA A.aA.b S A a b Closure of S S. S S. I 1 Closure of S A.A S A.A A.aA.b I 2 Closure of S a.a A a.a A.aA.b I 3 A b. b Closure of A b. a a A b Closure of S AA. A I 5 S AA. Closure of A aa. I 6 A aa. (LR(0) Parser: Build Parsing Table with Exmple1) In LR parsing table, abbreviations are used for the actions: R for reduce and S for shift. R4 means reduce using rule 4; S6 means shift the next symbol of input onto the stack and push state S6 onto the stack. LR parsing tables can easily be constructed using a software tool, such as yacc ( Johnson, 1975), which takes the grammar as input. (LR(0) Parser: Build Parsing Table with Exmple1) S S 1. S AA 2. A aa 3. A b Action Go to a b $ A S 0 S3 S Accept 2 S3 S4 5 3 S3 S4 6 4 R3 R3 R3 5 R1 R1 R1 6 R2 R2 R

12 (LR(0) Parser: How to parse a string) (LR(0) Parser: Build Parsing Table with Example2) Trace of a parse of the string aabb Stack Input Action 0 aabb$ S3 0a3 aabb$ S3 0a3a3 aabb$ S4 0a3a3b4 aabb$ R3 0a3a3A6 aabb$ R2 0a3A6 aabb$ R2 0A2 aabb$ S4 0A2b4 aabb$ R3 Example2: grammar for arithmetic expression Create a augmented grammar by adding one production rule. E E 0A2A5 aabb$ R1 0S1 aabb$ accept 68 (LR(0) Parser: Build Parsing Table with Example2) (LR(0) Parser: Build Parsing Table with Example2) I 0 Since start symbol is E, start state is labeled by closer of set E E which are: Closure of E.E E.E E.T E.E + T T.F T.T * F E T F ( id I 1 I 2 I 3 I 5 I 1 I 2 I 3 E E. E E. + T E T. T T. * F T F. Closure of F (.E) F (.E) E.T E.E + T T.F T.T * F I 1 I 2 I 3 E E. E E. + T E T. T T. * F I 6 E E +.T + T.F T.T * F * I 7 T T *. F I 5 F id. T F (LR(0) Parser: Build Parsing Table with Example2) (LR(0) Parser: Build Parsing Table with Example2 I 6 F (.E) E.T E.E + T T.F T.T * F E E +.T T.F T.T * F E T I 2 F I 3 ( id I5 T F I 3 ( id I5 I 8 I 9 E E. + T F (E.) E E + T. T T. * F I 9 I 8 I 7 T T *. F E E. + T F (E.) E E + T. T T. * F F I 10 ( id I5 ) I 11 + I 6 * I 7 T T * F. F (E)

13 (LR(0) Parser: Build Parsing Table with Example2 (LR(0) Parser: Build Parsing Table with Example2 State Action Go to T id + * ( ) $ E F S5 S S6 accept 2 R2 S7 R2 R2 3 R4 R4 R4 R4 Trace of a parse of the string id + id * id Stack Input Action * id 0 id + id $ S5 0id5 + id * id $ R6 0F3 + id * id $ R4 0T2 + id * id $ R2 0E1 + id * id $ S6 4 S5 S E1+6 id * id $ S5 5 R6 R6 R6 R6 0E1+6id5 * id $ R6 6 S5 S E1+6F3 * id $ R4 7 S5 S4 10 0E1+6T9 * id $ S7 8 S6 S11 0E1+6T9*7 id $ S5 9 R1 S7 R1 R1 0E1+6T9*7id5 $ R6 10 R3 R3 R3 R3 0E1+6T9*7F10 $ R3 11 R5 R5 R5 R5 0E1+6T9 $ R1 0E1 $ Accept (LR(0) Parser: Build Parsing Table with Example2 Trace of a parse of the string (id + id) + id * id Stack Input Action ) + id S4 0 ( id + id * id$ 0 ( 4 id + id ) + id * id$ S5 0 ( 4 + id ) + id * id$ R6 id 5 0 ( 4 F 3 + id ) + id * id$ R4 0 ( 4 T 2 + id ) + id * id$ R2 0 ( 4 E 8 + id ) + id * id$ S6 0 ( 4 E id ) + id * id$ S5 0 ( 4 E ) + id * id$ R6 id 5 0 ( 4 E F 3 ) + id * id$ R4 0 ( 4 E T 9 ) + id * id$ R1 0 ( 4 E 8 ) + id * id$ S11 0 ( 4 E 8 ) 11 + id * id$ R5 0 F 3 + id * id$ R4 0 T 2 + id * id$ R2 0 E 1 + id * id$ S6 0 E id * id$ S5 0 E id 5 * id$ R6 0 E F 3 * id$ R4 0 E T 9 * id$ S7 0 E T 9 * 7 id$ S5 0 E T 9 * 7 id 5 $ R6 0 E T 9 * 7 F 10 $ R3 0 E T 9 $ R1 0 E 1 $ Accept 75 13