(* Auxiliary antiquotations for the tutorial. *)

structure AntiquoteSetup =

struct

open OutputTutorial

(* functions for generating appropriate expressions *)

fun translate_string f str =

  implode (map f (Symbol.explode str))

fun prefix_lines prfx txt = 

  map (fn s => prfx ^ s) (split_lines txt)

fun ml_with_vars ys txt = 

    implode ["fn ", (case ys of [] => "_" | _ => enclose "(" ")" (commas ys)), " => (", txt, ")"]

fun ml_with_struct (NONE) txt = txt 

  | ml_with_struct (SOME st) txt = implode ["let open ", st, " in ", txt, " end"]

fun ml_val vs stru txt = 

    txt |> ml_with_struct stru

        |> ml_with_vars  vs 

fun ml_pat (lhs, pat) =

  implode ["val ", translate_string (fn "\<dots>" => "_" | s => s) pat, " = ", lhs] 

fun ml_struct txt = 

  implode ["functor DUMMY_FUNCTOR() = struct structure DUMMY = ", txt, " end"]

fun ml_type txt = 

  implode ["val _ = NONE : (", txt, ") option"];

(* eval function *)

fun eval_fn ctxt exp =

  ML_Context.eval_source_in (SOME ctxt) ML_Compiler.flags 

(* checks and prints a possibly open expressions, no index *)

  (eval_fn ctxt (ml_val vs stru txt); 

   output ctxt (split_lines txt))

val parser_ml = Scan.lift (Args.name --

  (Scan.optional (Args.$$$ "for" |-- Parse.!!! (Scan.repeat1 Args.name)) [] --

   Scan.option (Args.$$$ "in"  |-- Parse.!!! Args.name))) 

(* checks and prints a single ML-item and produces an index entry *)

  (eval_fn ctxt (ml_val [] stru txt); 

   case (stru, Long_Name.base_name txt, Long_Name.qualifier txt) of

   | (NONE, bn, qn)  => output_indexed ctxt {main = Code bn,  minor = Struct qn} (split_lines txt)

   | (SOME st, _, _) => output_indexed ctxt {main = Code txt, minor = Struct st} (split_lines txt))

val parser_ml_ind = Scan.lift (Args.name --

  Scan.option (Args.$$$ "in"  |-- Parse.!!! Args.name))

(* checks and prints structures *)

fun gen_output_struct outfn ctxt txt = 

  (eval_fn ctxt (ml_struct txt); 

   outfn {main = Code txt, minor = Plain "structure"} (split_lines txt))

(* prints functors; no checks *)

fun gen_output_funct outfn txt = 

  (outfn {main = Code txt, minor = Plain "functor"} (split_lines txt))

(* checks and prints types *)

fun gen_output_type outfn ctxt txt = 

  (eval_fn ctxt (ml_type txt); 

   outfn {main = Code txt, minor = Plain "type"} (split_lines txt))

(* checks and expression agains a result pattern *)

    (eval_fn ctxt (ml_pat (lhs, pat));

     output ctxt ((prefix_lines "" lhs) @ (prefix_lines "> " pat)))

(* checks the expressions, but does not check it against a result pattern *)

    (eval_fn ctxt (ml_val [] NONE lhs);

     output ctxt ((split_lines lhs) @ (prefix_lines "> " pat)))

(* checks the expressions, but does not check it against a result pattern *)

    (output ctxt ((split_lines lhs) @ (prefix_lines "> " pat)))

val single_arg = Scan.lift (Args.name)

val two_args   = Scan.lift (Args.name -- Args.name)

val test = Scan.lift (Args.name -- Args.name -- Scan.option (Args.$$$ "with"  |-- Args.name))

val ml_setup = 

(* FIXME: experimental *)

fun ml_eq (lhs, pat, eq) =

  implode ["val true = ((", eq, ") (", lhs, ",", pat, "))"] 

    (case eq of 

       NONE => eval_fn ctxt (ml_pat (lhs, pat))

     | SOME e => eval_fn ctxt (ml_eq (lhs, pat, e));

     output ctxt ((prefix_lines "" lhs) @ (prefix_lines "> " pat)))

val ml_response_setup = 

(* checks whether a file exists in the Isabelle distribution *)

fun href_link txt =

let 

  val path = "http://isabelle.in.tum.de/repos/isabelle/raw-file/tip/src/"    

in

end 

  (if File.exists (Path.append (Path.explode ("~~/src")) (Path.explode txt)) 

   else error (implode ["Source file ", quote txt, " does not exist."]))

(* replaces the official subgoal antiquotation with one *)

(* that is closer to the actual output                  *)

fun proof_state state =

  (case try (Proof.goal o Toplevel.proof_of) state of

    SOME {goal, ...} => goal

  | _ => error "No proof state");

let

  fun subgoals 0 = ""

    | subgoals 1 = "goal (1 subgoal):"

    | subgoals n = "goal (" ^ string_of_int n ^ " subgoals):"

  val goals = Goal_Display.pretty_goal ctxt state

  val (As, _) = Logic.strip_horn prop;

in 

end

  let

  in

  end

val subgoals_setup = 

val raw_goal_state_setup = 

val setup =

  ml_setup #>

  ml_response_setup #>

  ml_file_setup #>

  subgoals_setup #>

  raw_goal_state_setup

end;