Better scoping in repeat/for, lazy expression (no implicit import yet)

regression/orig/test103.log

@@ -1,3 +1 @@
-> > > 0
+> > > 5
-0
-5

regression/orig/test104.log

@@ -0,0 +1,10 @@
+> 0
+1
+2
+3
+4
+5
+6
+7
+8
+9

regression/test068.expr

@@ -1,4 +1,4 @@
-fun lazy (f) {
+fun makeLazy (f) {
   local flag = 0, value = 0;
 
   return fun () {
@@ -12,7 +12,7 @@ fun lazy (f) {
   }
 }
 
-local l = lazy (fun () {write (1); return 800});
+local l = makeLazy (fun () {write (1); return 800});
 local x = read ();
 
 write (l ());

regression/test099.expr

@@ -1,4 +1,4 @@
-fun lazy (f) {
+fun makeLazy (f) {
   local flag = 0, value = 0;
 
    fun () {
@@ -12,7 +12,7 @@ fun lazy (f) {
   }
 }
 
-local l = lazy (fun () {write (1);  800});
+local l = makeLazy (fun () {write (1);  800});
 local x = read ();
 
 write (l ());

regression/test103.expr

@@ -1,4 +1,8 @@
+local x;
+
 repeat
   local n = read ();
-  write (n)
+  x := n
-until n > 0
+until n > 0;
+
+write (x)

regression/test103.input

@@ -1,3 +1,3 @@
 0
 0
-5
+5

regression/test104.expr

@@ -0,0 +1,5 @@
+local n = read ();
+
+for local i; i := 0, i<10, i := i + 1 do
+  write (i)
+od   

regression/test104.input

@@ -0,0 +1 @@
+5

src/Driver.ml

@@ -14,7 +14,7 @@ let parse cmd =
     "case"; "of"; "esac"; "when";
     "boxed"; "unboxed"; "string"; "sexp"; "array";
     "infix"; "infixl"; "infixr"; "at"; "before"; "after";
-    "true"; "false"]
+    "true"; "false"; "lazy"]
   in
   Util.parse
     (object

src/Language.ml

@@ -631,7 +631,7 @@ module Expr =
                           
     (* UGLY! *)
     let predefined_op : (Obj.t -> Obj.t -> Obj.t) ref = Pervasives.ref (fun _ _ -> invalid_arg "must not happen")
-                            
+                
     (* ======= *)
     ostap (
       parse[def][infix][atr]: h:basic[def][infix][Void] -";" t:parse[def][infix][atr] {Seq (h, t)}
@@ -731,8 +731,14 @@ module Expr =
       | %"while" e:parse[def][infix][Val] %"do" s:scope[def][infix][Void][parse def]
                                             => {isVoid atr} => %"od" {materialize atr (While (e, s))}
 
-      | %"for" i:parse[def][infix][Void] "," c:parse[def][infix][Val] "," s:parse[def][infix][Void] %"do" b:scope[def][infix][Void][parse def] => {isVoid atr} => %"od"
+      | %"for" i:scope[def][infix][Void][parse def] ","
-                                                                     {materialize atr (Seq (i, While (c, Seq (b, s))))}
+               c:parse[def][infix][Val]             ","
+               s:parse[def][infix][Void] %"do" b:scope[def][infix][Void][parse def] => {isVoid atr} => %"od"
+               {materialize atr
+                  (match i with
+                  | Scope (defs, i) -> Scope (defs, Seq (i, While (c, Seq (b, s))))
+                  | _               -> Seq (i, While (c, Seq (b, s))))
+               }
 
       | %"repeat" s:scope[def][infix][Void][parse def] %"until" e:basic[def][infix][Val] => {isVoid atr} => {
           materialize atr @@
@@ -753,7 +759,9 @@ module Expr =
       | %"return" e:basic[def][infix][Val]? => {isVoid atr} => {Return e}
 
       | %"case" l:$ e:parse[def][infix][Val] %"of" bs:!(Util.listBy)[ostap ("|")][ostap (!(Pattern.parse) -"->" scope[def][infix][atr][parse def])] %"esac"
-                                                                                                                                                 {Case (e, bs, l#coord, atr)}      
+                                                                                                                                                       {Case (e, bs, l#coord, atr)}
+      | l:$ %"lazy" e:basic[def][infix][Val] => {notRef atr} :: (not_a_reference l) => {ignore atr (Call (Var "makeLazy", [Lambda ([], e)]))}
+      
       | -"(" parse[def][infix][atr] -")"
     )
 

stdlib/Lazy.expr

@@ -1,4 +1,4 @@
-public fun lazy (f) {
+public fun makeLazy (f) {
   local value, set = false;
   
   fun () {