Description
For this assignment you will write Haskell interpreter for a tiny programming
language, let’s call it TL (Tiny Language) . The language contains just three types of
statements:
let variableName = expression
if expression goto label
print expression1, expression2, …
input variableName
Each statement may contain a preceding label. A label is an alphanumeric string
ending with a colon (“:”).
A number of simplifying assumptions have been made about the syntax of the
language.
• White space (blanks) are important and must be used to separate each token
including around the arithmetic operators.
• There can be only one statement per line.
• The expressions are limited to constant numbers, constant strings, variable
names, and binary expressions involving just one of the following operators: “+”,
“-“, “*”, “/”, “<“, “>”, “<=”, “>=”, “==”, or “!=”, with their conventional meanings.
Note again that the operators must be surrounded by spaces, which makes for
easier parsing.
• The only types are strings and floating point numbers (Float in Haskell) and
strings are only used in print statements. The result of Boolean operations is 0 if
false and 1 if true. Furthermore any numeric expression can be used in an ifstatement
and as with the C language, 0 is false and everything else is true.
• Blank lines are ignored.
let variableName = expression computes the value of expression then binds that value
to the name variableName.
if expression goto label computes the value of expression, if the value is 0 execution
continues with the next statement. If the value is non-zero then execution continues
with the statement labeled label. If no such statement exists, the program
terminates with the message: “tli: Illegal goto label at line x.” where x is the actual
line number of the illegal goto statement.
print expression1, expression2, … evaluates each expression, then prints their values,
all on one line, separated by spaces, terminating the line with a newline character.
input variableName attempts to read a number from the standard input. If successful
that value is bound to the name variableName. If the read fails the program may
simply terminate with the default message: “tli: Prelude.read: no parse”.
If at any point an attempt is made to evaluate an expression that references a
variable variableName for which there is no binding, the program terminates with
the message: “tli: Undefined variable variableName at line x.” where x is the actual
line number of the failed expression.
Your program tli (tiny language interpreter) will take one command line argument,
the name of the source file. It will compile the program into an internal form and
then execute the compiled program. If the input program contains any syntax
errors, the program should exit printing a message of the form “tli: Syntax error on
line x.” for the first syntax error detected. Although your program is allowed to
continue and report additional syntax errors or provide additional error
information, that is not required and will not affect your score.
tli should make just one pass over the program source building an internal
representation that is a list of statements and a symbol table that maps labels into
line numbers. You may use this same symbol table to store variable bindings during
execution of the program. Each statement should be represented by a value of an
appropriately extended version of these data types
data Expr = Constant Float | Var String | Plus Expr Expr deriving (Show)
data Stmt = Let String Expr | Print Expr deriving (Show)
Here is a tiny language program that prints out a sequence of numbers.
input start
input end
let x = start
repeat: print x
let x = x + 1
if x < end goto repeat
print “done”, x
Assuming the above program is stored in “prog1.txt”, when executed the command
“tli prog1.txt” and the user entering 1 and 5, tli should produce the output
1.0
2.0
3.0
4.0
done 5.0
You should turn in one file, tli.hs. To help you get started, I have provided the file
nano.hs that parses and executes a nano-subset of the tiny language. You can find
that file in Canvas. I will spend time in class explaining nano.hs.
Scoring will be done according to the following with the points in ()s.
(1) parseExpr() works for all legal expressions
(2) parseTest() works for all legal statement lists including labels but the SymTable
produced is incorrect
(2) parseTest() works for all legal statement lists including labels with a correct and
complete SymTable of label to linenum mappings
(1) works for programs with no input and no goto
(1) works for programs with no input but goto
(2) works for all correct programs
(1) properly reports syntax and runtime errors
