CS 314 Project 2: LL(1) Parser in Scheme

$30.00

Category:

Description

5/5 - (7 votes)

In this project, you will implement a Scheme functions to generate the correct PREDICT sets for random,
correctly-written, LL(1) grammars. Your functions will return the correct FIRST, FOLLOW, and PREDICT
sets for the grammar given.
1 Structure for the Grammars and FIRST, FOLLOW & PREDICT
Sets
This project will run functions based on random, correctly-generated LL(1) grammars. An LL(1) grammar
will be represented by a list of lists, where each sub-list begins with a non-terminal symbol, then subsequently
containing the right hand side of the rules corresponding to that non-terminal, which are lists comprising of
terminal and/or nonterminal symbols. So, a grammar will be of the following form:
’(
( NT1 rhsrule11 rhsrule12 …)
( NT2 rhsrule21 rhsrule22 …)

( NTk rhsrulek1 rhsrulek2 …)
)
We will use ”eps” for the symbol . If the right hand side of the rule is the list ’(”eps”), then that rule
corresponds to the symbol . RULES CAN HAVE OTHER NON-TERMINALS IN THEM. Remember, every non-terminal will have at least one production rule. The start nonterminal is the left hand side
nonterminal of the first rule. In the case above, the start nonterminal is NT1.
The list of FIRST sets and FOLLOW sets have the following form and structure: a list of pairs consisting
of the nonterminal and its corresponding FIRST or FOLLOW set:
’(
( NT1 FIRST ( NT1 ))
( NT2 FIRST ( NT2 ))

( NTk FIRST ( NTk ))
)
and
’(
( NT1 FOLLOW ( NT1 ))
( NT2 FOLLOW ( NT2 ))

( NTk FOLLOW ( NTk ))
)
The list of FIRST sets and FOLLOW sets are both associative lists. The list of PREDICT sets have the
following form and structure: a list of pairs consisting of the rule (which is a list) and the PREDICT set for
that rule:
’(
( rule11 PREDICT ( rule11 ))
( rule12 PREDICT ( rule12 ))

( rulek1 PREDICT ( rulek1 ))

)
An example of a random LL(1) grammar is the following:
’(
(A (x B) (“eps”))
(B (y A) (“eps”))
)
1
which has the following BNF form:
A ::= xB | 
B ::= yA | 
where A and B are nonterminals. A is the start nonterminal. x and y are terminals, since they don’t have any
production rules. A correct output of the PREDICT sets for the grammar is as follows:
’(
((A ::= (x B)) (x))
((A ::= (“eps”)) (eof)))
((B ::= (y A)) (y))
((B ::= (“eps”)) (eof)))
)
The structure of the output is as follows: the number of elements in the list will be the number of nonterminals there are in the grammar. The first element of each element of the list is the non-terminal. Then,
each subsequent element lists the rule, and then its PREDICT set. In this example, based on the grammar
given above, if one is currently reducing A and encounters the symbol x, then x should be expanded with the
rule A ::= xB, whereas if one is currently reducing B and encounters the symbol y, then y should be expanded
with the rule B ::= yA. Note that in both cases, if one encounters EOF, (i.e. if one sees nothing else), then
expansion of the rules is finished, and parsing is finished. This is denoted by ’(eof).
1.1 FIRST Sets
Recall the method for constructing a FIRST set for a symbol (or collection of symbols) X:
1. If X is a terminal, then FIRST(X) = {X}.
2. If X ::= , then  ∈ FIRST(X).
3. For each X as a non-terminal, initialize FIRST(X) = {}.
4. Iterate until no more terminals or  can be added to any FIRST(X), where X = Y1Y2 . . . Yk:
(a) add a to FIRST(X) if a ∈ FIRST(Y1).
(b) add a to FIRST(X) if a ∈ FIRST(Yi) and  ∈ FIRST(Yj ), for all 1 ≤ j < i and j ≥ 2. (c) add  to FIRST(X) if  ∈ FIRST(Yi), for all i where 1 ≤ i ≤ k. The algorithm is as follows, where NT is the set of all nonterminals in the grammar, and P is the set of production rules: for all A ∈ NT : FIRST ( A ) = {} while ( FIRST sets are still changing ) do for each p ∈ P , of the form X → Y1 Y2 ... Yk do temp ← FIRST ( Y1 ) - {} i ← 1 while ( i ≤ k - 1 and  ∈ FIRST ( Yi)) temp ← temp ∪ ( FIRST ( Yi+1 ) - {}) i ← i + 1 end // while loop if i == k and  ∈ FIRST ( Yk ) then temp ← temp ∪ {} end // if - then FIRST ( X ) ← FIRST ( X ) ∪ temp end // for loop end // while loop Also, refer to pg. 28 and 29 of Lecture 7 for more details. 2 1.2 FOLLOW Sets Recall the algorithm for constructing a FOLLOW set for a non-terminal X: 1. Place EOF in FOLLOW(start nonterminal). 2. For all other nonterminals X, initialize FOLLOW(X) = {}. 3. Iterate until no more terminals can be added to any FOLLOW(X). (a) if a rule is of the form A ::= αBβ: i. if  ∈ FIRST(β): A. FOLLOW(B) = FOLLOW(B) ∪ (FOLLOW(A) ∪ (FIRST(β) - {})) ii. otherwise: A. FOLLOW(B) = FIRST(β) ∪ FOLLOW(B). (b) if a rule is of the form A ::= αB, then FOLLOW(B) = FOLLOW(B) ∪ FOLLOW(A). The algorithm is as follows, where NT is the set of all nonterminals in the grammar, and P is the set of production rules: for all A ∈ NT : FOLLOW ( A ) = {} FOLLOW ( start nonterminal ) = { EOF } while ( FOLLOW sets are still changing ) do for each p ∈ P , of the form A → B1 B2 ... Bk do TRAILER ← FOLLOW ( A ) for i ← k down to 1 if Bi ∈ NT then FOLLOW ( Bi) ← FOLLOW ( Bi) ∪ TRAILER if  ∈ FIRST ( Bi) TRAILER ← TRAILER ∪ ( FIRST ( Bi) - {}) else TRAILER ← FIRST ( Bi) else TRAILER ← { Bi} Also, refer to pg. 49 of Lecture 7. 1.3 PREDICT sets Recall the algorithm for constructing a PREDICT for a rule A ::= δ: 1. If  ∈ FIRST(δ): (a) PREDICT(A ::= δ) = (FIRST(δ) - {}) ∪ FOLLOW(A) 2. otherwise: (a) PREDICT(A ::= δ) = FIRST(δ) For more information regarding FIRST, FOLLOW & PREDICT sets, please refer to the slides for recitation week 3, the last two slides for recitation week 5, and lectures 7 and 8. 2 Project Description For this project, you will have to complete the Scheme functions provided in order to generate the FIRST, FOLLOW, and PREDICT sets properly. You will need to complete the following tasks: 1. Complete the utility functions getStartSymbol, getNonterminals, getProductions, updateAssocList, and getInitSets. (a) Function signatures and descriptions: i. (getStartSymbol grammar) returns the start nonterminal of the grammar. As defined in the project description, the start nonterminal is the left-hand side nonterminal of the first rule of the grammar. (This function is useful for generating initial FOLLOW sets.) Input: grammar Output: the start non-terminal of the grammar. 3 ii. (getNonterminals grammar) returns a list of all nonterminals in the grammar. You may assume that every nonterminal in the grammar will have a rule! Input: grammar Output: a list of all nonterminals in the grammar: ’(NT1 NT2 ... NTk) iii. (getProductions grammar) Returns a list of all production rules in the grammar. If a rule happens to look like ”lhs ::= rhs1 | rhs2”, getProductions will separate those two rules into different elements of the list. Input: grammar Output: a list of every rule in the grammar Output format example: Given an example grammar: NT1 ::= rhs1 | rhs2 NT2 ::= rhs3 Which is of the form ’(( NT1 ( rhs1 ) ( rhs2 )) ( NT2 ( rhs3 ))) getProductions should return ’(( NT1 rhs1 ) ( NT1 rhs2 ) ( NT2 rhs3 )). iv. (updateAssocList assocList symbol set) takes as input an associative list, a symbol, and the set to be union-ed with the corresponding list of the symbol. Input: grammar • assocList: associative list • symbol: a symbol • set: the set to be union-ed with the corresponding list of the symbol in assocList Output: the updated associative list with the corresponding list of the symbol union-ed with set. An associative list is defined as follows: given symbols a, b, ..., k and their corresponding lists lista, listb, ... listk, an associative list is a list of pairs of symbols and their corresponding lists: ’( (a lista) (b listb) ... (k listk ) ) Each pair has the form ’(symbol list), where, for example, list can be the symbol’s FIRST set or FOLLOW set. So, the command (updateAssocList assocList b set) with assocList being the associative list given above, will output the following associative list: ’( (a lista) (b listb ∪ set ) ... (k listk ) ) v. (getInitSets NTs startSymbol setting): Depending on the setting (either ’first or ’follow), getInitSets returns the initialized FIRST sets or FOLLOW sets for all non-terminals in the grammar. Inputs: • NTS: the list of all nonterminals in the grammar • startSymbol: the start nonterminal of the grammar • setting: either ’first or ’follow Output: Depending on what the setting is, initSets returns an initialized list of empty FIRST sets or FOLLOW sets for each nonterminal of the grammar. Output format example: Given an example grammar: 4 NT1 ::= rhs1 | rhs2 NT2 ::= rhs3 Which is of the form ’(( NT1 ( rhs1 ) ( rhs2 )) ( NT2 ( rhs3 ))) (getInitSets ’(NT1 NT2) NT1 ’first) returns ’(( NT1 ()) ( NT2 ())) (getInitSets ’(NT1 NT2) NT1 ’follow) returns ’(( NT1 ( eof )) ( NT2 ())) 2. Complete the functions genFirstFunc, recurseFirstSets, genFollowFunc, recurseFollowSets, getFollowSets, and getPredictSets. (a) Function signatures and descriptions: i. (genFirstFunc NTs) returns a function that computes FIRST(symbolSeq) given a sequence of symbols (terminals and nonterminals) symbolSeq and an initial list of FIRST sets for all nonterminals in the grammar. Input: NTs: the list of all nonterminals in the grammar Output: a function called first that takes as input a sequence of symbols symbolSeq, and an initial list of FIRST sets firstSets, and outputs FIRST(symbolSeq). first has the following inputs and outputs: • Inputs: – symbolSeq: sequence of symbols – firstSets: a list of (potentially unfinished) FIRST sets for all nonterminals in the grammar • Output: FIRST(symbolSeq), i.e. the application (first symbolSeq firstSets) given inputs symbolSeq and firstSets. ii. (recurseFirstSets rules firstSets firstFunc) goes through each rule in the grammar and updates the FIRST sets based on the current rule. Inputs: • rules: the list of all production rules in the grammar • firstSets: a list of (potentially unfinished) FIRST sets • firstFunc: a function that takes as input a sequence of symbols and list of FIRST sets, and returns FIRST(sequence of symbols). (genFirstFunc generates this argument.) Output: an updated firstSets after making one pass through all the rules in the grammar iii. (genFollowFunc NTs) returns a function that takes as input the sequence of symbols (terminals and nonterminals) and an initial list of FOLLOW sets for all nonterminals in the grammar, along with a variable called trailer and the completed FIRST sets, and returns the updated FOLLOW sets. Input: NTs: the list of all nonterminals in the grammar Output: a function follow that takes as input a sequence of symbols symbolSeq, and an initial list of FOLLOW sets, the variable trailer, and the list of COMPLETED FIRST sets firstSets, and outputs the updated FOLLOW sets. follow has the following inputs and output: • Inputs: – symbolSeq: sequence of symbols – followSets: a list of (potentially unfinished) FOLLOW sets for all nonterminals in the grammar – trailer: trailer variable (Check the algorithm on FOLLOW sets) – firstSets: list of COMPLETED FIRST sets for all nonterminals in the grammar • Output: The updated FOLLOW sets, i.e. the application (follow symbolSeq followSets trailer firstSets) given inputs symbolSeq, followSets, trailer, and firstSets. iv. (recurseFollowSets rules followSets followFunc) goes through each rule in the grammar and updates the FOLLOW sets based on the current rule. Inputs: 5 • rules: a list of production rules in the grammar • followSets: a list of (potentially unfinished) FOLLOW sets • followFunc: a function that takes as input a sequence of symbols and list of FOLLOW sets, and returns an updated FOLLOW sets. (genFollowFunc generates this argument.) Output: an updated followSets after making one pass through all the rules in the grammar v. (getFollowSets rules followSets followFunc) returns the FOLLOW sets of all nonterminals in the grammar if the FOLLOW sets had no change. Inputs: • rules: a list of production rules in the grammar • followSets: a list of (potentially unfinished) FOLLOW sets • followFunc: a function that takes as input a sequence of symbols and list of FOLLOW sets, and returns an updated FOLLOW sets. Output: the updated followSets, which is a list of the FOLLOW sets of every non-terminal in the grammar vi. (getPredictSets rules NTs firstSets followSets firstFunc) returns the PREDICT sets for each rule in the grammar Inputs: • rules: the list of production rules of the grammar • NTs: the list of all nonterminals in the grammar • firstSets: the FIRST sets of all nonterminals in the grammar • followSets: the FOLLOW sets of all nonterminals in the grammar • firstFunc: a function that takes as input a sequence of symbols and list of FIRST sets, and returns FIRST(sequence of symbols). Output: a list of pairs, one for each production rule in the grammar, where the first element is the production rule output as a list, and the second element is the PREDICT set for that production rule Output format example: Given an example grammar: A ::= xB | " eps " B ::= yA | " eps " Which is of the form ’(( A ( x B ) ()) ( B ( y A ) ())) getPredictSets should return ’( (( A ::= ( x B )) ( x )) (( A ::= (" eps ")) ( eof )) (( B ::= ( y A )) ( y )) (( B ::= (" eps ")) ( eof ))) You MUST use let* for this problem: How do you define A? How do you define delta? How do you define FIRST(delta)? 2.1 Function closure genFirstFunc and genFollowFunc requires you to return a function, rather than a list or numerical value. If you bind certain variables inside the closure (either using let, let*, letrec, or lambda), you can pre-load those bound variables when defining the function you wish to return. For example, given the function plusXY: ( define plusXY ( lambda ( x y ) (+ x y ))) a way to return a function plusX that is similar to plusXY with y pre-loaded can be as follows: ( define plusX ( lambda ( y ) ( let (( plusXFunc ( lambda ( x ) (+ x y )))) plusXFunc ))) Then, (plusX 2) will return the function (lambda (x) (+ x 2)). For example, ((plusX 2) 10) = 12. 6 2.2 Given Functions For this project, most of the functions are self-contained, so there should be no need to construct new helper functions. If you decide to use helper functions that you construct, please detail clearly what the function does using comments. Remember to use the semi-colon for comments. Here is a list of the given utility functions (in utilFuncs.ss) and useful built-in Scheme functions: 1. (contains? lst x) checks whether or not an element x is in the list lst. (This is a top-level check: meaning (contains ’(1 2 3) 2) returns #t but (contains ’(1 (2 3)) 2) returns #f.) 2. (union a b) returns a new list that is a ∪ b, where a and b are sets. Since a set is defined to be a list where no element appears twice, the new list should also contain only elements of a and b such that there are no duplicates. 3. (removeMatch lst x) returns a new list with every instance of x removed from the list lst. If x is not in lst at all, removeMatch just returns the original list lst with no changes. 4. (epsilon) defines  as ”eps”. You can call this function without arguments like this: (epsilon). It will return the symbol ”eps”. In addition to these functions, you are also given getFirstSets. • (getFirstSets rules firstSets firstFunc) returns the FIRST sets of all nonterminals in the grammar if the FIRST sets had no change. Inputs: – rules: the list of all production rules in the grammar – firstSets: a list of (potentially unfinished) FIRST sets – firstFunc: a function that takes as input a sequence of symbols symbolSeq and list of FIRST sets, and returns FIRST(symbolSeq). (genFirstFunc generates this argument.) Output: the updated firstSets, which is a list of the FIRST sets of every non-terminal in the grammar 3 Implementation & Useful Built-in Scheme Functions For the implementation of the required functions, you can use standard built-in Scheme functions such as append, list, let, let*, letrec, map, assoc, and reverse. Here are some useful built-in Scheme functions: 1. (map function list) is a useful built-in Scheme function that returns an updated list, where each element of the list is applied with function. For example: (map even? ’(1 2 3 4 5)) = ’(#f #t #f #t #f). 2. (assoc assocList symbol) is a useful built-in Scheme function. An associative list is a list of pairs consisting of a symbol and a list corresponding to that symbol. An associative list has the following form. ’( ( a Lista) ( b Listb) ... ( k Listk ) ) (assoc symbol assocList) takes as input an associative list assocList, and a symbol, and returns the symbol and corresponding list of the symbol as a list. In this case, given the above associative list as assocList, (assoc ’a assocList) returns ’(a Lista). 3. (reverse lst) is a useful built-in Scheme function that returns the reverse of a list lst. For example: (reverse ’(1 (2 3) 4 (5 6 7))) = ’((5 6 7) 4 (2 3) 1). Some utility functions will be provided for you in utilFuncs.ss. You will use each of let, let*, letrec at least once. You must not use assignment (set!) in Scheme. 7 4 How To Get Started Copy the files proj2.ss and utilFuncs.ss into your own subdirectory. Both files must be in the same subdirectory. Open proj2.ss using either DrRacket or racket from the terminal (check Recitation week 7 for more information on how to do this). Remember to set the specific language to be R5RS. The file proj2.ss is split into five sections: The first section contains the utility functions, the next three sections contains the FIRST, FOLLOW, PREDICT set generators, and the last section contains the example grammars and the tester functions. Fill in the functions where it says ”YOUR CODE GOES HERE”. Once you have filled in the functions with your own Scheme code, run proj2.ss. The tester functions pre-define the variables and outputs the PREDICT sets for each grammar. In order to swap out grammars, replace ”grammar0” with the appropriate numbered grammar in the line (define grammar grammar). In the last section of the project description, we provide the FIRST, FOLLOW, and
PREDICT sets for the four example grammars given to you.
In addition to the tester functions and the example LL(1) grammars, we have also provided commands to
generate FIRST and FOLLOW sets separately. These commands are included in section 5 of proj2.ss. REMEMBER TO COMMENT OUT THE TEST COMMANDS BEFORE SUBMITTING YOUR
FILE. In another words, your proj2.ss should print nothing.
Read the proj2.ss already given to you, and understand the structure of the code. Use similar techniques
to assist you in constructing the required functions.
5 Grading
You will submit your modified version of the file proj2.ss via Sakai. Your programs will be graded primarily
on functionality, i.e. whether you have printed the correct PREDICT sets or not for each rule. Note that for
grading purposes, you have to print each set with the correct elements, i.e. the order of elements in each set
does not matter. This will be verified through automatic testing on a list of 10 correct LL(1) grammars, 4 of
which have been given to you as example grammars. You do not have to re-submit utilFuncs.ss.
6 Questions
Remember, if you have any questions regarding this project, the Sakai forum has a section provided for
questions regarding Project 2. START EARLY, since you will run into issues that will need to be resolved
on the way.
7 FIRST, FOLLOW, & PREDICT sets for the Example Grammars
There are four grammars given to you in section 5 of proj2.ss. This section lists their FIRST, FOLLOW,
and PREDICT sets, in the form that would be returned by proj2.ss. Note that the order of elements in the
FIRST, FOLLOW, and PREDICT sets do not matter. For example, for grammar1, FIRST(a) could’ve been
’(x ”eps”) instead of ’(”eps” x). Also, note that spaces between the terminals and nonterminals do not matter.
Recall the structure and form of the list of FIRST, FOLLOW, and PREDICT sets. (Refer to Section 1 of this
project description for the form and structure of the FIRST, FOLLOW, and PREDICT sets.)
• grammar0
start ::= a
FIRST sets
’(( start ( a )))
FOLLOW sets
’(( start ( eof )))
PREDICT sets
’(
(( start ::= ( a )) ( a ))
)
8
• grammar1
A ::= xB | 
B ::= yA | 
FIRST sets
’(( a (” eps ” x ))
( b (” eps ” y )))
FOLLOW sets
’(( a ( eof ))
( b ( eof )))
PREDICT sets
’(
(( a ::= ( x b )) ( x ))
(( a ::= (” eps “)) ( eof ))
(( b ::= ( y a )) ( y ))
(( b ::= (” eps “)) ( eof ))
)
• grammar2
start ::= expr
expr ::= + term term
term ::= a | b | c
FIRST sets
’(
( start (“+”))
( expr (“+”))
( term ( c b a ))
)
FOLLOW sets
’(( start ( eof ))
( expr ( eof ))
( term ( a b c eof ))
)
PREDICT sets
’(
(( start ::= ( expr )) (“+”))
(( expr ::= (“+” term term )) (“+”))
(( term ::= ( a )) ( a ))
(( term ::= ( b )) ( b ))
(( term ::= ( c )) ( c ))
)
• grammar3
start ::= stmts
stmts ::= assgn morestmts
morestmts ::= , stmts | 
assgn ::= var = value
var ::= a | b | c | d | e
value ::= 0 | 1 | 2 | 3 | … | 9
FIRST sets
9
’(
( start ( e d c b a ))
( stmts ( e d c b a ))
( morestmts (” eps ” ” ,”))
( assgn ( e d c b a ))
( var ( e d c b a ))
( value (9 8 7 6 5 4 3 2 1 0))
)
FOLLOW sets
’(
( start ( eof ))
( stmts ( eof ))
( morestmts ( eof ))
( assgn (” ,” eof ))
( var (“=”))
( value (” ,” eof ))
)
PREDICT sets
’(
(( start ::= ( stmts )) ( e d c b a ))
(( stmts ::= ( assgn morestmts )) ( e d c b a ))
(( morestmts ::= (” ,” stmts )) (” ,”))
(( morestmts ::= (” eps “)) ( eof ))
(( assgn ::= ( var “=” value )) ( e d c b a ))
(( var ::= ( a )) ( a ))
(( var ::= ( b )) ( b ))
(( var ::= ( c )) ( c ))
(( var ::= ( d )) ( d ))
(( var ::= ( e )) ( e ))
(( value ::= (0)) (0))
(( value ::= (1)) (1))
(( value ::= (2)) (2))
(( value ::= (3)) (3))
(( value ::= (4)) (4))
(( value ::= (5)) (5))
(( value ::= (6)) (6))
(( value ::= (7)) (7))
(( value ::= (8)) (8))
(( value ::= (9)) (9))
)
10