Datalog Parser Solution

Datalog Parser Solution

A lexical analyzer groups characters in an input stream S into tokens. Parsing determines if an input stream of tokens is a member of a language L as defined by a grammar G. In other words, you need to determine if S ∈ L(G). The test is accomplished by creating an LL(1) parser for a simple variant of the Datalog language.

 Project Description

Using your LexicalAnalyzer from Project 1, write a parser for the Datalog grammar defined below. You will want to add a few methods to your LexicalAnalyzer to make it easy for you to access the tokens and use the tokens in order to determine if the given input is an instance of a valid Datalog program.


If the parse is successful, S ∈ L(G), return the string: 'Success!' followed by all the schemes, facts, rules, queries, and the domain values (i.e., all the strings that appear in the facts). Include the number of items in each list. Note that the domain is a sorted set (no duplicates) of strings.

 

If the parse is unsuccessful, S ∉ L(G) , output 'Failure!' followed by the offending token, (i.e., its triple including its token‑ID name, string value, and line number). Note that the parser stops after encountering the first offending token.
 

Requirements (Get the Design Right)

The following are required for successful pass‑off (and will help you succeed in this project):

 
You must implement an LL(1) parser (that is to say a deterministic top‑down parser that chooses the rule to expand based on the current token). The parser implementation must also be recursive meaning it either uses the runtime stack to keep track of rules in the parse or it manages a stack or rules directly similar to the parse table. Either solution works though using the runtime stack is more direct and simple (i.e., create a method for every rule in the grammar).



A class for each type of object. You must create classes for at least the following parts of the language: datalogProgram, rule, predicate, parameter, and possibly expressions or other aspects of the grammar. Additionally, you will need list objects to collect lists of schemes, facts, rules, or queries. Each class that contains objects to be output must have a toString method, and the output of the program must be formed by these toString methods (not by the parse methods).



You need to collect a list of domain values. A domain value is any string constant that appears in a fact. The set of all unique string constants is the domain. Store the domain as a sorted list. As a reminder, only unique values should appear in the list (no duplicates).

Datalog Grammar

Production start with lower‑case letters (nonterminals). Any production that starts with an upper‑case letter, such as those at the end of

 

http://wiki.cs.byu.edu/cs-236/datalog-parser                                                                                                                                                                                                                                                         1/7

3/23/2015                                                                                                                                      cs-236:datalog-parser[CS W iki]

 

the grammar, represent tokens (terminals). These tokens are input from your scanner and are defined similarly in the Lexical Analyzer. Note that comments do not appear anywhere in the grammar because comments should be ignored. In terms of parsing, this means that you should be able to skip any number of comments showing up at any place in the program. The easiest way to do that is to simply have the lexical analysis ignore comments.



 

g   r   a   m   m   a   r
D   a   t   a   l   o   g   ;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
/   *   *   *   *   *   *   *   *   *   *   *   *   *   *   *   *   *   *   *   *   *   *   *   *   *   *   *   *   *   *   *   *   *   *   *   *   *   *   *   *   *   *   *   *   *   *   *   *   *   *   *   *   *   *   *   *
 
 
 
 
 
*
P   r   o   d   u   c   t   i   o   n   s
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
*   *   *   *   *   *   *   *   *   *   *   *   *   *   *   *   *   *   *   *   *   *   *   *   *   *   *   *   *   *   *   *   *   *   *   *   *   *   *   *   *   *   *   *   *   *   *   *   *   *   *   *   *   *   *   *   /
 
 
 
 
 
d   a   t   a   l   o   g   P   r   o   g   r   a   m
-  
S   C   H   E   M   E   S
C   O   L   O   N
s   c   h   e   m   e
s   c   h   e   m   e   L   i   s   t
 
 
 
 
 
 
 
 
 
 
F   A   C   T   S
 
C   O   L   O   N
f   a   c   t   L   i   s   t
 
 
 
 
 
 
 
 
 
 
 
 
 
R   U   L   E   S
 
C   O   L   O   N
r   u   l   e   L   i   s   t
q   u   e   r   y   L   i   s   t
 
 
 
 
 
 
 
 
 
 
 
Q   U   E   R   I   E   S
C   O   L   O   N
q   u   e   r   y
 
 
 
 
 
 
 
s   c   h   e   m   e
 
-  
I   D
L   E   F   T   _   P   A   R   E   N
I   D
 
i   d   L   i   s   t
R   I   G   H   T   _   P   A   R   E   N
 
 
 
 
 
s   c   h   e   m   e   L   i   s   t
-  
s   c   h   e   m   e
s   c   h   e   m   e   L   i   s   t
|
l   a   m   b   d   a
 
 
 
 
 
 
 
i   d   L   i   s   t
 
-  
C   O   M   M   A
 
I   D
 
i   d   L   i   s   t
|
l   a   m   b   d   a
 
 
 
 
 
 
 
 
f   a   c   t
 
-  
I   D
L   E   F   T   _   P   A   R   E   N
S   T   R   I   N   G
s   t   r   i   n   g   L   i   s   t
R   I   G   H   T   _   P   A   R   E   N
P   E   R   I   O   D
f   a   c   t   L   i   s   t
 
-  
f   a   c   t
f   a   c   t   L   i   s   t
|
l   a   m   b   d   a
 
 
 
 
 
 
 
 
r   u   l   e
 
-  
h   e   a   d   P   r   e   d   i   c   a   t   e
C   O   L   O   N   _   D   A   S   H
p   r   e   d   i   c   a   t   e
p   r   e   d   i   c   a   t   e   L   i   s   t
P   E   R   I   O   D
r   u   l   e   L   i   s   t
 
-  
r   u   l   e
r   u   l   e   L   i   s   t
|
l   a   m   b   d   a
 
 
 
 
 
 
 
 
h   e   a   d   P   r   e   d   i   c   a   t   e
-  
I   D
L   E   F   T   _   P   A   R   E   N
I   D
 
i   d   L   i   s   t
R   I   G   H   T   _   P   A   R   E   N
 
 
 
 
 
p   r   e   d   i   c   a   t   e
-  
I   D
L   E   F   T   _   P   A   R   E   N
p   a   r   a   m   e   t   e   r
p   a   r   a   m   e   t   e   r   L   i   s   t
R   I   G   H   T   _   P   A   R   E   N
 
p   r   e   d   i   c   a   t   e   L   i   s   t
-  
C   O   M   M   A
 
p   r   e   d   i   c   a   t   e
p   r   e   d   i   c   a   t   e   L   i   s   t
|
l   a   m   b   d   a
 
 
 
 
p   a   r   a   m   e   t   e   r
-  
S   T   R   I   N   G
|
 
I   D
|
e   x   p   r   e   s   s   i   o   n
 
 
 
 
 
 
 
 
p   a   r   a   m   e   t   e   r   L   i   s   t
-  
C   O   M   M   A
 
p   a   r   a   m   e   t   e   r
p   a   r   a   m   e   t   e   r   L   i   s   t
|
l   a   m   b   d   a
 
 
 
 
e   x   p   r   e   s   s   i   o   n
-  
L   E   F   T   _   P   A   R   E   N
p   a   r   a   m   e   t   e   r
o   p   e   r   a   t   o   r
p   a   r   a   m   e   t   e   r
R   I   G   H   T   _   P   A   R   E   N
o   p   e   r   a   t   o   r
 
-  
A   D   D
|
 
M   U   L   T   I   P   L   Y
 
 
 
 
 
 
 
 
 
 
 
 
q   u   e   r   y
 
-  
p   r   e   d   i   c   a   t   e
Q   _   M   A   R   K
 
 
 
 
 
 
 
 
 
 
 


 

http://wiki.cs.byu.edu/cs-236/datalog-parser                                                                                                                                                                                                                                                         2/7

3/23/2015
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
cs-236:datalog-parser[CS W iki]
q   u   e   r   y   L   i   s   t
 
 
 
 
-  
 
 
 
 
q   u   e   r   y
q   u   e   r   y   L   i   s   t
 
|
l   a   m   b   d   a
 
 
s   t   r   i   n   g   L   i   s   t
 
 
 
-   
 
 
 
 
C   O   M   M   A
S   T   R   I   N   G
s   t   r   i   n   g   L   i   s   t
|
l   a   m   b   d   a
/   *   *   *   *   *   *   *   *   *   *   *   *   *   *   *   *   *   *   *   *   *   *   *   *   *   *   *   *   *   *   *   *   *   *   *   *   *   *   *   *   *   *   *   *   *   *   *   *   *   *   *   *   *   *   *   *
 
*
 
T   o   k   e   n
d   e   f   i   n   i   t   i   o   n   s
f   r   o   m
t   h   e
l   e   x   e   r
p   r   o   j   e   c   t
 
 
 
 
*
 
I   G   N   O   R   E   :
I   N   C   L   U   D   E   D
 
F   O   R
C   O   M   P   L   E   T   E   N   E   S   S
F   O   R
A   N   T   L   R
 
 
 
 
*   *   *   *   *   *   *   *   *   *   *   *   *   *   *   *   *   *   *   *   *   *   *   *   *   *   *   *   *   *   *   *   *   *   *   *   *   *   *   *   *   *   *   *   *   *   *   *   *   *   *   *   *   *   *   *   /
C
O
M
M
A
 
:
 
 
 
 
'
,
'
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
P
E
R
I
O
D
:
 
 
 
 
'   .
'
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Q
_
M
A
R
K
:
 
 
 
 
'
?
'
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
L   E   F   T   _   P   A   R   E   N
 
 
 
:
 
'   (   '
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
R   I   G   H   T   _   P   A   R   E   N
 
 
 
:
 
'   )   '
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
C
O
L
O
N
 
 
 
 
 
 
:
 
'
:
'
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
C   O   L   O   N   _   D   A   S   H
 
 
 
:
 
'   :   -   '
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
M   U   L   T   I   P   L   Y
 
 
 
 
:
 
'   *   '
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
A
D
D
 
 
 
 
 
 
 
 
:
 
'
+
'
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
S   C   H   E   M   E   S
 
 
 
 
:
 
'   S   c   h   e   m   e   s   '
 
 
 
 
 
 
 
 
 
F   A   C   T   S
 
 
 
 
 
 
;
 
'   F   a   c   t   s   '
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
:
 
 
 
 
 
 
 
 
 
 
 
R   U   L   E   S
 
 
 
 
 
 
;
 
'   R   u   l   e   s   '
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
:
 
 
 
 
 
 
 
 
 
 
 
Q   U   E   R   I   E   S
 
 
 
 
;
 
'   Q   u   e   r   i   e   s   '
 
 
 
 
 
 
 
 
 
 
 
 
 
:
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
I   D
 
 
:
 
(   '   a   '   .   .   '   z   '   |   '   A   '   .   .   '   Z   '   |   '   _   '   )
(   '   a   '   .   .   '   z   '   |   '   A   '   .   .   '   Z   '   |   '   0   '   .   .   '   9   '   |   '   _   '   )   *
 
 
 
 
;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
S
T
R
I
N
G
'   \   '   '
 
(
 
E   S   C   _   S   E   Q
|
~   (   '   \   \   '   |   '   \   '   '   )
)   *
 
'   \   '   '
 
 
 
 
 
 
 
:
 
 
 
 
 
 
 
 
 
 
 
;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
C
O
M
M
E
N
T
 
 
~   (   '   \   n   '   |   '   \   r   '   )   *
'   \   r   '   ?
'   \   n   '
{   $   c   h   a   n   n   e   l   =   H   I   D   D   E   N   ;   }
 
 
 
 
:
 
'   #   '
 
 
 
 
 
|
 
'   #   |   '
 
(
o   p   t   i   o   n   s
 
{   g   r   e   e   d   y   =   f   a   l   s   e   ;   }
:
.
)   *
'   |   #   '
{   $   c   h   a   n   n   e   l   =   H   I   D   D   E   N   ;   }
 
 
 
 
;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
W
S
 
 
:
 
(
'
\
'
'
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
|
'
t
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
|
'
\
r
'
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 


 

http://wiki.cs.byu.edu/cs-236/datalog-parser                                                                                                                                                                                                                                                         3/7



3/23/2015
 
 
 
 
 
 
 
cs-236:datalog-parser[CS W iki]
 
 
 
 
 
 
 
|
'   \
n
'
 
 
 
 
 
 
;
 
 
)
{   $   c   h   a   n   n   e   l   =   H   I   D   D   E   N   ;   }
 
 
 
 
 
 
 
 
 
 
 
 
f
r
a
g
m
e
n
t
:
(   '   0   '   .   .   '   9   '   |   '   a   '   .   .   '   f   '   |   '   A   '   .   .   '   F   '   );
H   E   X   _   D   I   G   I   T
f
r
a
g
m
e
n
t
 
 
 
 
 
E
S
C
_
S
E
Q
'   \   \   '
 
(   '   b   '   |   '   t   '   |   '   n   '   |   '   f   '   |   '   r   '   |   '   \   "   '   |   '   \   '   '   |   '   \   \   '   )
 
 
 
 
:
 
 
 
 
 
 
 
|
 
 
U   N   I   C   O   D   E   _   E   S   C
 
 
 
 
 
|
 
 
O   C
T   A
L
_   E   S
C
 
 
 
 
 
;
 
 
 
 
 
 
 
 
f
r
a
g
m
e
n
t
 
 
 
 
 
O
C
T
A
L
_
E
S   C
 
 
(   '   0   '   .   .   '   3   '   )
(   '   0   '   .   .   '   7   '   )(   '   0   '   .   .   '   7   '   )
 
 
 
 
:
 
 
'   \   \   '
 
 
 
 
 
|
 
 
'   \   \   '
 
(   '   0   '   .   .   '   7   '   )
(   '   0   '   .   .   '   7   '   )
 
 
 
 
|
 
 
'   \   \   '
 
(   '   0   '   .   .   '   7   '   )
 
 
 
 
 
;
 
 
 
 
 
 
 
 
f
r
a
g
m
e
n
t
 
 
 
 
 
U   N   I   C   O   D   E   _   E   S   C
 
'   u   '
H   E   X   _   D   I   G   I   TH   E   X   _   D   I   G   I   TH   E   X   _   D   I   G   I   TH   E   X   _   D   I   G   I   T
 
 
 
 
:
 
 
'   \   \   '
 
 
 
 
 
;
 
 
 
 
 
 
 
 


 

 

Output Specifications



 

To format the output for pass‑off, you must make it formatted exactly like the examples, including capitalization, punctuation, and whitespace. The output for the parser is show below in the examples.

 

Indentation is two spaces



 

The ':‑' is separated by one space on either side



 

Schemes, rules, facts, and queries should be listed in program order (i.e., the order in which they appear in the file)



 

The domain should be sorted (e.g., standard std::string order)



 

The domain includes only strings that appear in facts



 

Examples



 

You program must exactly match the output format in the examples. Pass‑off involves comparing your output to expected output from a proper solution. Any mismatch in your output means the pass‑off failed. Further, these examples are not comprehensive in testing your parser. They only are sufficient to define the output format.

 

Example 1

 

 

 

http://wiki.cs.byu.edu/cs-236/datalog-parser                                                                                                                                                                                                                                                         4/7



3/23/2015

 

Input



 

S
c
h
e
m
e
s
:
 
 
 
 
 
 
 
s   n   a   p   (   S   ,   N   ,   A   ,   P   )
 
 
 
 
 
#
c
o
m
m
e
n
t
 
 
 
 
 
 
 
H   a   s   S   a   m   e   A   d   d   r   e   s   s   (   X   ,   Y   )
 
 
 
 
F   a   c   t   s   :
 
#   c   o   m   m   e   n   t
B   r   o   w   n   '   ,   '   1   2
A   p   p   l   e   '   ,   '   5   5   5   -   1   2   3   4   '   )   .
 
 
s   n   a   p   (   '   1   2   3   4   5   '   ,   '   C   .
 
 
s   n   a   p   (   '   3   3   3   3   3   '   ,   '   S   n   o   o   p   y   '   ,   '   1   2
A   p   p   l   e   '   ,   '   5   5   5   -   1   2   3   4   '   )   .
R
u
l
e
s
:
 
 
 
:   -
s   n   a   p   (   A   ,   X   ,   B   ,   C   )   ,   s   n   a   p   (   D   ,   Y   ,   B   ,   E   )   .
 
 
H   a   s   S   a   m   e   A   d   d   r   e   s   s   (   X   ,   Y   )
#
c
o
m
m
e
n
t
 
 
 
 
 
Q
u
e
r
i
e
s
:
 
 
 
 
 


H a  s S a m e A d d r e s s (  '      S      n      o      o      p      y      '      ,      W      h o )  ?



 

Output



 

S
u
c
c
e
s
s
!
 
 
 
 
 
 
 
 
 
S   c   h   e   m   e   s   (   2   )   :
 
 
 
 
 
 
 
 
s   n   a   p   (   S   ,   N   ,   A   ,   P   )
 
 
 
 
 
F
a
H   a   s   S   a   m   e   A   d   d   r   e   s   s   (   X   ,   Y   )
 
 
 
 
c
t
s
(
2
)
:
 
 
 
B   r   o   w   n   '   ,   '   1   2
A   p   p   l   e   '   ,   '   5   5   5   -   1   2   3   4   '   )   .
 
 
s   n   a   p   (   '   1   2   3   4   5   '   ,   '   C   .
R
u
s   n   a   p   (   '   3   3   3   3   3   '   ,   '   S   n   o   o   p   y   '   ,   '   1   2
A   p   p   l   e   '   ,   '   5   5   5   -   1   2   3   4   '   )   .
l
e
s
(
1
)
:
 
 
 
 
:   -
s   n   a   p   (   A   ,   X   ,   B   ,   C   )   ,   s   n   a   p   (   D   ,   Y   ,   B   ,   E   )   .
 
 
H   a   s   S   a   m   e   A   d   d   r   e   s   s   (   X   ,   Y   )
Q   u   e   r   i   e   s   (   1   )   :
 
 
 
 
 
 
D
o
H   a   s   S   a   m   e   A   d   d   r   e   s   s   (   '   S   n   o   o   p   y   '   ,   W   h   o   )   ?
m
a
i
n
(
6
)
:
e
'
 
 
 
 
 
 
 
'
1
2
3
A
p
p
l
 
 
 
 
 
 
 
'
1
2
4
5
'
 
 
 
 
 
 
 
 
 
 
'
3
3
3
3
3
'
3
4
'
 
 
 
 
 
 
 
'
5
5
5
-
1
2
 
 
 
 
 
 
 
'
C   .
o
B
r
o
w
n
'
 
 
 
 
 
 
 
'
S
n
o
p
y
'
 
 
 
 
 
 
 


 

Example 2

 

Input



 

S
c
h
e
m
e   s   :
 
 
 
 
 
 
 
 
 
 
 
 
s   n   a   p   (   S   ,   N   ,   A   ,   P   )
 
 
 
 
 
 
 
 
 
 
 
 
N   a   m   e   H   a   s   I   D   (   N   ,   S   )
 
 
 
 
 
 
 
 
F
a
c
t
s
:
B   r   o   w   n   '   ,   '   1   2
A   p   p   l   e   '   ,   '   5   5   5
-   1
2   3
4
'   )   .
 
 
 
 
s   n   a   p   (   '   1   2   3   4   5   '   ,   '   C   .
 
 
 
 
s   n   a   p   (   '   6   7   8   9   0   '   ,   '   L   .
V   a   n
P   e   l   t   '   ,   '   3   4
P   e   a   r   '   ,   '   5
5   5
-   5
6
7   8   '   )   .
R
u
l
e
s
:
 
 
 
 
 
 
 
 



cs-236:datalog-parser[CS W iki]



 

http://wiki.cs.byu.edu/cs-236/datalog-parser                                                                                                                                                                                                                                                         5/7



3/23/2015
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
cs-236:datalog-parser[CS W iki]
N   a
m   e
H
a
s
I
D
(
N
,
S
)
:
-
s
n
a
p
(
S   ,   N   ,   A   ,   P   )   ?
Q   u   e   r   i   e
s
:
H
a
s
I
D
(
'
S
n
o
o   p
y
'   ,
I
d
)
?
 
N   a
m
e
 


 

Output



 

F   a   i
l
u
r
e
!
K   ,   "   ?   "   ,   1   0   )
(
Q
_
M
A
R


 

FAQ



 

What do I have to change in my Lexical Analyzer?

 

The lexical analyzer needs to give the parser tokens. The parser also needs to be able to determine the type of the token too (i.e., STRING, COMMA, PERIOD, etc.). The analyzer may need to change to include the ability to give the parser tokens for analysis.

 

Why do we need the Parameter, Predicate, Rule, and Datalog Program classes, and what should be in these classes?

 

Each lab projects builds on the previous project. These classes are intended to support the next project. To determine what needs to be in each of these classes, use the grammar as a guide. For example, a parameter is defined as STRING | ID | expression. A such, the parameter class should be able to look like a STRING, ID, or expression, and a method should exist to determine the type of parameter. As another example, A predicate is defined as ID LEFT_PAREN parameter parameterList RIGHT_PAREN. A class to represent a predicate needs to store the ID, and a list of parameters. Other classes are defined similarly: guided by the grammar.

 

As a further point of clarification, the datalog program has a list for schemes, facts, rules, and queries. It is tempting to build new classes for a scheme or query; however, the predicate class should suffice to represent these objects.

 

What strings need to be included in the domain?

 

The domain consists of all strings found in the facts. It does not include strings in the rules or queries.

 

How should I represent an expression?

 

Use polymorphism! An expression is a parameter. That parameter has an operator with a left parameter and a right parameter. It is possible to define different types of parameters using polymorphism: an ID parameter, a STRING parameter, and an expression parameter that has an operator with a left parameter and a right parameter. Such a structure makes expressions, even arbitrarily nested expression trivial.

 

How should I print expressions?

 

Print expression exactly how they look on the input: left parameter operator right parameter. Remember the left or the right parameter can be either or both expressions. No problem! It is possible to have a to_string method for each type of parameter using polymorphism. That way, printing is easy: just call to_string() on the parameter, and the to_string method knows how to do the rest (i.e., if it is an expression, it first calls left.to_string(), add the operator, and then calls right.to_string().

 

http://wiki.cs.byu.edu/cs-236/datalog-parser                                                                                                                                                                                                                                                         6/7

3/23/2015                                                                                                                                      cs-236:datalog-parser[CS W iki]

 

What is the easiest way to handle a parse error?

 

The most direct way to handle a parse error is with an exception [http://www.cplusplus.com/doc/tutorial/exceptions/]. A parse error is able to throw the offending token. And the caller of the parser is able to catch the same token and provide the required output.

 

Submission



 

Review the project standards for creating a zip archive.

 

Navigate to Learning Suite [http://learningsuite.byu.edu], select 'CS 236', and click on 'Assignments' on the course home page. Click on the link to the relevant project and at the bottom of the description click on 'View/Submit'. Use the resulting upload dialog to upload your zip archive.

 

Pass‑off



 

Pass‑off your project directly to a TA during normal TA hours. TAs help students on a first‑come/first‑serve basis and are under no obligation to stay later than designated hours so plan accordingly. Please review the syllabus for the pass‑off requirements.
Powered by