Yep...

src/Language.ml

@@ -77,26 +77,7 @@ module Expr =
                                                                                                                   
     *)
     ostap (                                      
-      parse:
+      parse: empty {failwith "Not yet implemented"}
-	  !(Ostap.Util.expr 
-             (fun x -> x)
-	     (Array.map (fun (a, s) -> a, 
-                           List.map  (fun s -> ostap(- $(s)), (fun x y -> Binop (s, x, y))) s
-                        ) 
-              [|                
-		`Lefta, ["!!"];
-		`Lefta, ["&&"];
-		`Nona , ["=="; "!="; "<="; "<"; ">="; ">"];
-		`Lefta, ["+" ; "-"];
-		`Lefta, ["*" ; "/"; "%"];
-              |] 
-	     )
-	     primary);
-      
-      primary:
-        n:DECIMAL {Const n}
-      | x:IDENT   {Var x}
-      | -"(" parse -")"
     )
     
   end
@@ -130,13 +111,7 @@ module Stmt =
                                 
     (* Statement parser *)
     ostap (
-      parse:
+      parse: empty {failwith "Not yet implemented"}
-        s:stmt ";" ss:parse {Seq (s, ss)}
-      | stmt;
-      stmt:
-        "read" "(" x:IDENT ")"          {Read x}
-      | "write" "(" e:!(Expr.parse) ")" {Write e}
-      | x:IDENT ":=" e:!(Expr.parse)    {Assign (x, e)}            
     )
       
   end

src/SM.ml

@@ -23,19 +23,8 @@ type config = int list * Stmt.config
      val eval : config -> prg -> config
 
    Takes a configuration and a program, and returns a configuration as a result
- *)                         
+*)                         
-let rec eval ((stack, ((st, i, o) as c)) as conf) = function
+let rec eval conf prog = failwith "Not yet implemented"
-| [] -> conf
-| insn :: prg' ->
-   eval 
-     (match insn with
-      | BINOP op -> let y::x::stack' = stack in (Expr.to_func op x y :: stack', c)
-      | READ     -> let z::i'        = i     in (z::stack, (st, i', o))
-      | WRITE    -> let z::stack'    = stack in (stack', (st, i, o @ [z]))
-      | CONST i  -> (i::stack, c)
-      | LD x     -> (st x :: stack, c)
-      | ST x     -> let z::stack'    = stack in (stack', (Expr.update x z st, i, o))
-     ) prg'
 
 (* Top-level evaluation