X-Git-Url: http://git.annexia.org/?a=blobdiff_plain;f=src%2Feval.ml;h=59f4ca4dc87b4b8f299c14b1e9a2add29b04f4da;hb=109185686ffdc00520eba2b4c3a92f10a111fb60;hp=e928564c35f05c17ed5064fba700e4e3fd2201ac;hpb=b14ff66c953e6a73e9ac2fe8d42dd68e92e58f53;p=goals.git

diff --git a/src/eval.ml b/src/eval.ml
index e928564..59f4ca4 100644
--- a/src/eval.ml
+++ b/src/eval.ml
@@ -1,4 +1,4 @@
-(* Goalfile evaluation
+(* Goalfile Abstract Syntax Tree
  * Copyright (C) 2019 Richard W.M. Jones
  * Copyright (C) 2019 Red Hat Inc.
  *
@@ -17,189 +17,290 @@
  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  *)
 
-open Utils
-
-let rec evaluate_targets env exprs =
-  List.iter (evaluate_target env) exprs
-
-and evaluate_target env = function
-  | Ast.EGoal _ -> assert false
-
-  (* Call a goal. *)
-  | Ast.ECall (loc, name, args) ->
-     let expr =
-       try Ast.StringMap.find name env
-       with Not_found ->
-         failwithf "%a: goal ‘%s’ not found" Ast.string_loc loc name in
-     let goal =
-       match expr with
-       | Ast.EGoal (loc, goal) -> goal
-       | _ ->
-          failwithf "%a: tried to call ‘%s’ which is not a goal"
-            Ast.string_loc loc name in
-     run_goal loc env name args goal
-
-  | Ast.ETactic (loc, name, args) ->
-     (* All parameters of tactics must be simple expressions (strings,
-      * in future booleans, numbers, etc).
-      *)
-     let args = List.map (simplify env) args in
-     run_goal_for_tactic loc env name args
-
-  (* Look up the variable and substitute it. *)
-  | Ast.EVar (loc, name) ->
-     let expr =
-       try Ast.StringMap.find name env
-       with Not_found ->
-         failwithf "%a: variable ‘%s’ not found" Ast.string_loc loc name in
-     evaluate_target env expr
-
-  (* Lists are inlined when found as a target. *)
-  | Ast.EList (loc, exprs) ->
-     evaluate_targets env exprs
-
-  (* A string (with or without substitutions) implies *file(filename). *)
-  | Ast.ESubsts (loc, str) ->
-     let str = substitute loc env str in
-     run_goal_for_tactic loc env "file" [Ast.CString str]
-
-  | Ast.EConstant (loc, c) ->
-     run_goal_for_tactic loc env "file" [c]
-
-(* Find the goal which matches the given tactic and run it.
- * Params is a list of constants.
- *)
-and run_goal_for_tactic loc env tactic const_args =
-  (* Search across all goals for a matching tactic. *)
-  let goals =
-    let env = Ast.StringMap.bindings env in
-    filter_map
-      (function (name, Ast.EGoal (loc, goal)) -> Some (name, goal) | _ -> None)
-      env in
-  let name, goal =
-    (* If there are multiple goals matching, this must choose
-     * the most recently defined (XXX).
-     *)
-    try
-      List.find
-        (fun (_, (_, patterns, _, _)) ->
-          List.exists (matching_pattern loc env tactic const_args) patterns)
-        goals
-    with
-      Not_found ->
-        failwithf "%a: don't know how to build %s %s"
-          Ast.string_loc loc
-          tactic
-          (String.concat ", "
-             (List.map (function Ast.CString s -> s) const_args)) in
-
-  let args = [] (* XXX calculate free variables *) in
-  run_goal loc env name args goal
-
-(* XXX This only does exact matches at the moment. *)
-and matching_pattern loc env tactic const_args = function
-  | Ast.PTactic (loc, constructor, params)
-       when tactic = constructor &&
-            List.length const_args = List.length params ->
-     (* Try to simplify the parameters of this pattern down
-      * to constants, but don't fail here if we can't do this.
-      *)
-     (try
-        let params = List.map (substitute loc env) params in
-        let params = List.map (fun s -> Ast.CString s) params in
-        const_args = params
-      with Failure _ -> false
-     )
-
-  | Ast.PTactic _ -> false
-
-  | Ast.PVar (loc, name) -> assert false
-(*
-  NOT IMPLEMENTED - we need variables to contain constructors!
-     (try
-        let expr = Ast.StringMap.find name env in
-        let expr = simplify env expr in
-      with Not_found -> false
-     )
-*)
-
-(* Run a named goal. *)
-and run_goal loc env name args (params, patterns, deps, code) =
-  (* Substitute the args for the parameters in the environment. *)
-  let params =
-    try List.combine params args
-    with Invalid_argument _ ->
-      failwithf "%a: calling goal ‘%s’ with wrong number of arguments"
-        Ast.string_loc loc name in
-  let env =
-    List.fold_left (fun env (k, v) -> Ast.StringMap.add k v env)
-      env params in
+open Printf
 
-  (* Evaluate the dependencies first. *)
-  evaluate_targets env deps;
-
-  (* Check if any target needs to be updated. *)
-  (* XXX *)
-
-  (* Run the code (if any). *)
-  (match code with
-   | None -> ()
-   | Some code ->
-      let code = substitute loc env code in
-      Printf.printf "running : %s\n" code
-  );
+open Utils
 
-  (* Check all targets were updated (else it's an error). *)
-  (* XXX *)
+let pure_cache = Hashtbl.create 13
 
-(* Take any expression and simplify it down to a constant.
- * If the expression cannot be simplified then this throws
- * an error.
- *)
-and simplify env = function
+let rec to_constant env = function
   | Ast.EConstant (loc, c) -> c
 
-  | Ast.EVar (loc, name) ->
-     let expr =
-       try Ast.StringMap.find name env
-       with Not_found ->
-         failwithf "%a: variable ‘%s’ not found" Ast.string_loc loc name in
-     simplify env expr
+  | EVar (loc, name) ->
+     let expr = Ast.getvar env loc name in
+     to_constant env expr
 
-  | Ast.ESubsts (loc, str) ->
-     Ast.CString (substitute loc env str)
+  | ESubsts (loc, str) ->
+     CString (substitute env loc str)
 
-  | Ast.EList (loc, _) ->
+  | EList (loc, _) ->
      failwithf "%a: list found where constant expression expected"
        Ast.string_loc loc
 
-  | Ast.ECall (loc, name, _) ->
-     failwithf "%a: cannot use goal ‘%s’ in constant expression"
-       Ast.string_loc loc name
+  | ECall (loc, name, args) ->
+     let expr = Ast.getvar env loc name in
+     (match expr with
+      | EGoalDefn _ ->
+         (* Goals don't return anything so they cannot be used in
+          * constant expressions.  Use a function instead.
+          *)
+         failwithf "%a: cannot use goal call ‘%s’ in shell expansion"
+           Ast.string_loc loc name
+
+      | EFuncDefn (loc, func) ->
+         to_constant env (call_function env loc name args func)
+
+      | _ ->
+         failwithf "%a: cannot use ‘%s’ in constant expression"
+           Ast.string_loc loc name
+     )
 
-  | Ast.ETactic (loc, name, _) ->
-     failwithf "%a: cannot use tactic ‘*%s’ in constant expression"
+  | ETacticCtor (loc, name, _) ->
+     failwithf "%a: cannot use tactic ‘%s’ in constant expression"
        Ast.string_loc loc name
 
-  | Ast.EGoal (loc, _) ->
+  | EGoalDefn (loc, _) ->
      failwithf "%a: cannot use goal in constant expression"
        Ast.string_loc loc
 
-(* Take a substitution list and try to turn it into a simple
- * string by evaluating every variable.  If not possible this
- * throws an error.  Returns a string.
- *)
-and substitute loc env substs =
+  | EFuncDefn (loc, _) ->
+     failwithf "%a: cannot use function in constant expression"
+       Ast.string_loc loc
+
+  | ETacticDefn (loc, _) ->
+     failwithf "%a: cannot use tactic in constant expression"
+       Ast.string_loc loc
+
+and substitute env loc substs =
   let b = Buffer.create 13 in
   List.iter (
     function
     | Ast.SString s -> Buffer.add_string b s
-    | Ast.SVar name ->
-       let expr =
-         try Ast.StringMap.find name env
-         with Not_found ->
-           failwithf "%a: variable ‘%s’ not found" Ast.string_loc loc name in
-       match simplify env expr with
+    | SVar name ->
+       let expr = Ast.getvar env loc name in
+       match to_constant env expr with
        | Ast.CString s -> Buffer.add_string b s
   ) substs;
   Buffer.contents b
+
+and to_shell_script env loc substs =
+  let b = Buffer.create 13 in
+  List.iter (
+    function
+    | Ast.SString s -> Buffer.add_string b s
+    | SVar name ->
+       let expr = Ast.getvar env loc name in
+       let s = expr_to_shell_string env expr in
+       Buffer.add_string b s
+  ) substs;
+  Buffer.contents b
+
+and expr_to_shell_string env = function
+  | Ast.EConstant (loc, CString s) -> Filename.quote s
+
+  | EVar (loc, name) ->
+     let expr = Ast.getvar env loc name in
+     expr_to_shell_string env expr
+
+  | ESubsts (loc, str) ->
+     Filename.quote (substitute env loc str)
+
+  | EList (loc, exprs) ->
+     let strs = List.map (expr_to_shell_string env) exprs in
+     (* These are shell quoted so we can just concat them with space. *)
+     String.concat " " strs
+
+  | ECall (loc, name, args) ->
+     let expr = Ast.getvar env loc name in
+     (match expr with
+      | EGoalDefn _ ->
+         (* Goals don't return anything so they cannot be used in
+          * shell script expansions.  Use a function instead.
+          *)
+         failwithf "%a: cannot use goal call ‘%s’ in shell expansion"
+           Ast.string_loc loc name
+
+      | EFuncDefn (loc, func) ->
+         expr_to_shell_string env (call_function env loc name args func)
+
+      | _ ->
+         failwithf "%a: cannot call ‘%s’ which is not a function"
+           Ast.string_loc loc name
+     )
+
+  (* Tactics expand to the first parameter. *)
+  | ETacticCtor (loc, _, []) -> Filename.quote ""
+  | ETacticCtor (loc, _, (arg :: _)) -> expr_to_shell_string env arg
+
+  | EGoalDefn (loc, _) ->
+     failwithf "%a: cannot use goal in shell expansion"
+       Ast.string_loc loc
+
+  | EFuncDefn (loc, _) ->
+     failwithf "%a: cannot use function in shell expansion"
+       Ast.string_loc loc
+
+  | ETacticDefn (loc, _) ->
+     failwithf "%a: cannot use tactic in shell expansion"
+       Ast.string_loc loc
+
+and run_code env loc code =
+  let code = prepare_code env loc code in
+  Sys.command code
+
+and run_code_to_string env loc code =
+  let code = prepare_code env loc code in
+  let chan = Unix.open_process_in code in
+  let b = Buffer.create 1024 in
+  (try
+     while true do
+       Buffer.add_string b (input_line chan);
+       Buffer.add_char b '\n'
+     done
+   with End_of_file -> ());
+  let st = Unix.close_process_in chan in
+  let i =
+    match st with
+    | Unix.WEXITED i -> i
+    | Unix.WSIGNALED i ->
+       failwithf "%a: killed by signal %d" Ast.string_loc loc i
+    | Unix.WSTOPPED i ->
+       failwithf "%a: stopped by signal %d" Ast.string_loc loc i in
+  i, Buffer.contents b
+
+and run_code_to_string_list env loc code =
+  let code = prepare_code env loc code in
+  let chan = Unix.open_process_in code in
+  let lines = ref [] in
+  (try while true do lines := input_line chan :: !lines done
+   with End_of_file -> ());
+  let st = Unix.close_process_in chan in
+  let i =
+    match st with
+    | Unix.WEXITED i -> i
+    | Unix.WSIGNALED i ->
+       failwithf "%a: killed by signal %d" Ast.string_loc loc i
+    | Unix.WSTOPPED i ->
+       failwithf "%a: stopped by signal %d" Ast.string_loc loc i in
+  let lines = List.rev !lines in
+  i, lines
+
+and prepare_code env loc (code, quiet) =
+  let quiet = if Cmdline.debug_flag () then false else quiet in
+  let code = to_shell_script env loc code in
+  "source " ^ Filename.quote Cmdline.prelude_sh_file ^ "\n" ^
+  "set -e\n" ^
+  (if not quiet then "set -x\n" else "") ^
+  "\n" ^
+  code
+
+and evaluate_goal_arg env = function
+  | Ast.EVar (loc, name) ->
+     let expr = Ast.getvar env loc name in
+     evaluate_goal_arg env expr
+
+  | ESubsts (loc, str) ->
+     let str = substitute env loc str in
+     Ast.EConstant (loc, Ast.CString str)
+
+  | EList (loc, exprs) ->
+     Ast.EList (loc, List.map (evaluate_goal_arg env) exprs)
+
+  | ETacticCtor (loc, name, exprs) ->
+     Ast.ETacticCtor (loc, name, List.map (evaluate_goal_arg env) exprs)
+
+  | ECall (loc, name, args) ->
+     let expr = Ast.getvar env loc name in
+     (match expr with
+      | EGoalDefn _ ->
+         (* Goals don't return anything so they cannot be used in
+          * goal args.  Use a function instead.
+          *)
+         failwithf "%a: cannot use goal call ‘%s’ in goal argument"
+           Ast.string_loc loc name
+
+      | EFuncDefn (loc, func) ->
+         call_function env loc name args func
+
+      | _ ->
+         failwithf "%a: cannot call ‘%s’ which is not a function"
+           Ast.string_loc loc name
+     )
+
+  | EConstant _
+  | EGoalDefn _
+  | EFuncDefn _
+  | ETacticDefn _ as e -> e
+
+(* Functions are only called from goal args or when substituting
+ * into a shell script or constant expression (this may change if we
+ * implement ‘:=’ assignment for variables).  This evaluates a
+ * function by running the associated shell script and parsing
+ * the output as an expression, string or list of strings.
+ *)
+and call_function env loc name args (params, returning, pure, code) =
+  (* This is used to print the function in debug and error messages only. *)
+  let debug_func =
+    sprintf "%s (%s) returning %s" name
+      (String.concat ", " (List.map (Ast.string_expr ()) args))
+      (match returning with RetExpr -> "expression"
+                          | RetString -> "string"
+                          | RetStrings -> "strings") in
+  Cmdline.debug "%a: running function %s" Ast.string_loc loc debug_func;
+
+  (* Evaluate function args.  Must be done before updating the environment. *)
+  let args = List.map (evaluate_goal_arg env) args in
+
+  (* Create a new environment which maps the parameter names to
+   * the args.
+   *)
+  let env =
+    let params =
+      try List.combine params args
+      with Invalid_argument _ ->
+        failwithf "%a: calling function %s with wrong number of arguments, expecting %d args but got %d args"
+          Ast.string_loc loc debug_func
+          (List.length params) (List.length args) in
+    List.fold_left (fun env (k, v) -> Ast.Env.add k v env) env params in
+
+  if pure then call_function_pure env loc name returning code
+  else call_function_really env loc name returning code
+
+and call_function_really env loc name returning code =
+  match returning with
+  | RetExpr ->
+     let r, b = run_code_to_string env loc code in
+     if r <> 0 then
+       failwithf "function ‘%s’ failed with exit code %d" name r;
+     Parse.parse_expr (sprintf "function:%s" name) b
+
+  | RetString ->
+     let r, b = run_code_to_string env loc code in
+     if r <> 0 then
+       failwithf "function ‘%s’ failed with exit code %d" name r;
+     Ast.EConstant (loc, Ast.CString b)
+
+  | RetStrings ->
+     let r, lines = run_code_to_string_list env loc code in
+     let strs = List.map (fun s -> Ast.EConstant (loc, Ast.CString s)) lines in
+     EList (loc, strs)
+
+(* For pure functions, check if the function can be matched to
+ * a previously memoized result, but don't fail if this goes wrong.
+ *)
+and call_function_pure env loc name returning code =
+  let code_key =
+    try Some (to_shell_script env loc (fst code))
+    with Failure _ -> None in
+  match code_key with
+  | None -> call_function_really env loc name returning code
+  | Some code_key ->
+     let r =
+       try Some (Hashtbl.find pure_cache code_key)
+       with Not_found -> None in
+     match r with
+     | Some expr -> expr
+     | None ->
+        let expr = call_function_really env loc name returning code in
+        Hashtbl.add pure_cache code_key expr;
+        expr