Sale!

Project 2: LL(1) Parser in Scheme

$30.00

Category:
Rate this product

CS 314 Principles of Programming Languages
Project 2: LL(1) Parser in Scheme
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<num). 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

Open chat
Need help?
Hello
Can we help you?