Baranov Ilya HW5

src/Expr.lama

@@ -1,18 +1,41 @@
--- Expression evaluator
-
-import List;
-import State;
-
-
--- The evaluator itself: takes a state and an expression,
--- returns integer value
---
--- An expression is represented by a data structure of the following shape:
---
--- expr = Var   (string)             |
---        Const (int)                |
---        Binop (string, expr, expr)
-
-public fun evalExpr (st, expr) {
-  failure ("evalExpr not implemented\n")
-}
+-- Expression evaluator
+
+import List;
+import State;
+
+
+-- The evaluator itself: takes a state and an expression,
+-- returns integer value
+--
+-- An expression is represented by a data structure of the following shape:
+--
+-- expr = Var   (string)             |
+--        Const (int)                |
+--        Binop (string, expr, expr)
+
+public fun ebinop(op, l, r) {
+    case op of
+		  "+" -> l + r 
+		| "-" -> l - r 
+		| "*" -> l * r 
+		| "/" -> l / r 
+		| "%" -> l % r
+		| "==" -> l == r 
+		| "!=" -> l != r 
+		| "<" -> l < r 
+		| ">" -> l > r 
+		| "<=" -> l <= r 
+		| ">=" -> l >= r 
+		| "&&" -> l && r 
+		| "!!" -> l !! r
+    esac
+}
+
+public fun evalExpr (st, expr) {
+	case expr of
+		  Var (x)	-> st(x)
+		| Binop (op, l, r) -> ebinop(op, evalExpr(st, l), evalExpr(st, r))
+		| Const (n)	-> n
+
+	esac
+} 

src/Parser.lama

@@ -1,25 +1,54 @@
--- Parser 
-
-import Ostap;
-import Lexer;
-import List;
-import Fun;
-import Matcher;
-
--- A parser of "something" in brackets; l, r are left and right
--- brackets as parsers, p --- a parser of "something"
-fun inbr (l, p, r) {
-  syntax (-l p -r)
-}
-
--- Primary expression
-local primary = memo $ eta (decimal @ fun (x) {Const (stringInt (x))} |
-                            lident  @ fun (x) {Var (x)} |
-                            inbr (s ("("), exp, s (")"))),
-      exp = memo $ eta (failure ("expression parsing not implemented\n"));
-
-local stmt = memo $ eta (failure ("statement parsing not implemented\n"));
-
-
--- Public top-level parser
-public parse = stmt;
+-- Parser 
+
+import Ostap;
+import Lexer;
+import List;
+import Fun;
+
+-- A parser of "something" in brackets; l, r are left and right
+-- brackets as parsers, p --- a parser of "something"
+fun inbr (l, p, r) {
+  syntax (-l p -r)
+}
+
+fun binOpop(l, op, r) {
+  Binop (op, l, r)
+}
+
+local oper = {[Left, [s("!!"), binOpop] : {}],
+             	[Left, [s("&&"), binOpop]: {}],
+             	[Nona, [s("==") | s("!=") | s("<") | s(">") | s(">=") | s("<="), binOpop] : {}],
+             	[Left, [s("+") | s("-"), binOpop] : {}],
+             	[Left, [s("*") | s("/") | s("%"), binOpop] : {}]
+};
+
+local primary = memo $ eta syntax (x=decimal {Const (stringInt (x))} |
+                                   x=lident  {Var (x)}               |
+                                   inbr[s("("), exp, s(")")]),
+      exp = memo $ eta expr(oper, primary);
+
+local stmt = memo $ eta syntax (
+		kWrite x = inbr[s("("), exp, s(")")] {Write(x)}  |
+		kRead x = inbr[s("("), lident, s(")")] {Read(x)} |
+		x = lident s[":="] y = exp {Assn(x, y)}          |
+		x1 = stmt s[";"] y1 = stmt end {Seq(x1, y1)}     |
+    kSkip {Skip} |
+		kIf cond=exp kThen st1=stmts st2=ifTailParser {If(cond, st1, st2)} |
+		kWhile cond=exp kDo st=stmts kOd {While (cond, st)}	|
+		kRepeat s=stmts kUntil cond=exp  {Repeat (s, cond)} |
+		kFor st1=stmts s[","] cond=exp s[","] st2=stmts kDo st=stmts kOd {Seq (st1, While(cond, Seq(st, st2)))}
+);
+
+local ifTailParser = memo $ eta syntax(
+    -kFi {Skip} |
+    -kElse stmts -kFi |
+    -kElif e=exp kThen s1=stmts s2=ifTailParser {If (e, s1, s2)}
+);
+
+local stmts = memo $ eta syntax (
+		stmt |
+		s1=stmt s[";"] s2=stmts {Seq(s1, s2)});
+
+
+-- Public top-level parser
+public parse = stmt;