X-Git-Url: http://git.annexia.org/?a=blobdiff_plain;f=src%2Feval.ml;h=5e271a79f9bd9d9af4c1ebe978f32a783e2fcab8;hb=7b81982e98bd98cba5813dc2417d7e0d71bdc452;hp=9e3bf3d282e3ec0b32a0e2f083c4c1d287af9afc;hpb=28a34f592996bec9dc524f1741764878c9c85e1c;p=goals.git

diff --git a/src/eval.ml b/src/eval.ml
index 9e3bf3d..5e271a7 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.
  *
@@ -19,134 +19,113 @@
 
 open Utils
 
-let rec evaluate_targets env exprs =
-  List.iter (evaluate_target env) exprs
+let rec to_constant env = function
+  | Ast.EConstant (loc, c) -> c
 
-and evaluate_target env = function
-  | Ast.EGoal _ -> assert false
+  | EVar (loc, name) ->
+     let expr = Ast.getvar env loc name in
+     to_constant env expr
+
+  | ESubsts (loc, str) ->
+     CString (substitute env loc str)
+
+  | EList (loc, _) ->
+     failwithf "%a: list found where constant expression expected"
+       Ast.string_loc loc
+
+  | ECallGoal (loc, name, _) ->
+     failwithf "%a: cannot use goal ‘%s’ in constant expression"
+       Ast.string_loc loc name
+
+  | ETacticCtor (loc, name, _) ->
+     failwithf "%a: cannot use tactic ‘%s’ in constant expression"
+       Ast.string_loc loc name
+
+  | EGoalDefn (loc, _) ->
+     failwithf "%a: cannot use goal 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
+    | 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
+
+let rec 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
 
-  (* Call a goal. *)
-  | Ast.ECall (loc, name, args) ->
-     let goal = Ast.getgoal env loc name in
-     run_goal env loc name args goal
+  | ESubsts (loc, str) ->
+     Filename.quote (substitute env loc str)
 
-  | Ast.ETactic (loc, name, args) ->
-     (* All parameters of tactics must be simple expressions (strings,
-      * in future booleans, numbers, etc).
-      *)
-     let args = List.map (Ast.to_constant env) args in
-     run_tactic env loc name args
+  | 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
+
+  | ECallGoal (loc, name, _) ->
+     failwithf "%a: cannot use goal ‘%s’ in shell expansion"
+       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
 
-  (* Look up the variable and substitute it. *)
+  | ETacticDefn (loc, _) ->
+     failwithf "%a: cannot use tactic in shell expansion"
+       Ast.string_loc loc
+
+let rec evaluate_goal_arg env = function
   | Ast.EVar (loc, name) ->
      let expr = Ast.getvar env loc name in
-     evaluate_target env expr
-
-  (* Lists are inlined when found as a target. *)
-  | Ast.EList (loc, exprs) ->
-     evaluate_targets env exprs
+     evaluate_goal_arg env expr
 
-  (* A string (with or without substitutions) implies *file(filename). *)
-  | Ast.ESubsts (loc, str) ->
+  | ESubsts (loc, str) ->
      let str = Ast.substitute env loc str in
-     run_tactic env loc "file" [Ast.CString str]
-
-  | Ast.EConstant (loc, c) ->
-     run_tactic env loc "file" [c]
-
-(* Run a goal by name. *)
-and run_goal env loc name args (params, patterns, deps, code) =
-  (* 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 goal ‘%s’ with wrong number of arguments"
-          Ast.string_loc loc name in
-    List.fold_left (fun env (k, v) -> Ast.Env.add k v env) env params in
-
-  (* Check all dependencies have been updated. *)
-  evaluate_targets env deps;
-
-  (* Check if any target (ie. pattern) needs to be rebuilt. *)
-  let rebuild =
-    List.exists (needs_rebuild env loc name deps) patterns in
-
-  if rebuild then (
-    (* Run the code (if any). *)
-    (match code with
-     | None -> ()
-     | Some code ->
-        let code = Ast.substitute env loc code in
-        Printf.printf "running : %s\n" code
-    );
-
-    (* Check all targets were updated (else it's an error). *)
-    let pattern_still_needs_rebuild =
-      try Some (List.find (needs_rebuild env loc name deps) patterns)
-      with Not_found -> None in
-    match pattern_still_needs_rebuild with
-    | None -> ()
-    | Some pattern ->
-       failwithf "%a: goal ‘%s’ ran successfully but it did not rebuild %a"
-         Ast.string_loc loc
-         name
-         Ast.string_pattern pattern
-  )
-
-(* Return whether the target (pattern) needs to be rebuilt. *)
-and needs_rebuild env loc name deps pattern =
-  false (* XXX *)
-
-(* Find the goal which matches the given tactic and run it.
- * const_args is a list of parameters (all constants).
- *)
-and run_tactic env loc tactic const_args =
-  (* Search across all goals for a matching tactic. *)
-  let goals =
-    let env = Ast.Env.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 env loc tactic const_args) patterns)
-        goals
-    with
-      Not_found ->
-        let tactic =
-          Ast.ETactic (loc, tactic,
-                       List.map (fun c -> Ast.EConstant (loc, c))
-                         const_args) in
-        failwithf "%a: don't know how to build %a"
-          Ast.string_loc loc Ast.string_expr tactic in
-
-  let args = [] (* XXX calculate free variables *) in
-  run_goal env loc name args goal
-
-(* XXX This only does exact matches at the moment. *)
-and matching_pattern env loc 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 (Ast.substitute env loc) params in
-        let params = List.map (fun s -> Ast.CString s) params in
-        const_args = params
-      with Failure _ -> false
-     )
+     Ast.EConstant (loc, Ast.CString str)
+
+  | EList (loc, exprs) ->
+     Ast.EList (loc, List.map (evaluate_goal_arg env) exprs)
 
-  | Ast.PTactic _ -> false
+  | ETacticCtor (loc, name, exprs) ->
+     Ast.ETacticCtor (loc, name, List.map (evaluate_goal_arg env) exprs)
 
-  | Ast.PVar (loc, name) -> assert false (* not implemented *)
+  | ECallGoal (loc, name, _) ->
+     (* Goals don't return anything so they cannot be used in
+      * goal args.  Use a function instead.
+      *)
+     failwithf "%a: cannot use goal ‘%s’ in goal argument"
+       Ast.string_loc loc name
 
+  | EConstant _
+  | EGoalDefn _
+  | ETacticDefn _ as e -> e