X-Git-Url: http://matita.cs.unibo.it/gitweb/?a=blobdiff_plain;f=helm%2Fsoftware%2Fcomponents%2Fgrafite%2FgrafiteAstPp.ml;h=cf9106ea374d44527481c5e12297be63ee52f9f2;hb=1ca749a387695a5a4abc138a06de496a63abac4a;hp=521db02f3d28d3655d55e35bfc8613aa32869583;hpb=1acfe506c30e7fcc9d6e427d2523130c371a1159;p=helm.git

diff --git a/helm/software/components/grafite/grafiteAstPp.ml b/helm/software/components/grafite/grafiteAstPp.ml
index 521db02f3..cf9106ea3 100644
--- a/helm/software/components/grafite/grafiteAstPp.ml
+++ b/helm/software/components/grafite/grafiteAstPp.ml
@@ -44,7 +44,7 @@ let pp_reduction_kind ~term_pp = function
   | `Unfold None -> "unfold"
   | `Whd -> "whd"
  
-let pp_tactic_pattern ~term_pp ~lazy_term_pp (what, hyp, goal) = 
+let pp_tactic_pattern ~map_unicode_to_tex ~term_pp ~lazy_term_pp (what, hyp, goal) = 
   if what = None && hyp = [] && goal = None then "" else 
   let what_text =
     match what with
@@ -56,8 +56,11 @@ let pp_tactic_pattern ~term_pp ~lazy_term_pp (what, hyp, goal) =
   let goal_text =
     match goal with
     | None -> ""
-    | Some t -> Printf.sprintf "\\vdash (%s)" (term_pp t) in
-  Printf.sprintf "%sin %s%s" what_text hyp_text goal_text
+    | Some t ->
+       let vdash = if map_unicode_to_tex then "\\vdash" else "⊢" in
+        Printf.sprintf "%s (%s)" vdash (term_pp t)
+  in
+   Printf.sprintf "%sin %s%s" what_text hyp_text goal_text
 
 let pp_intros_specs s = function
    | None, []         -> ""
@@ -65,30 +68,34 @@ let pp_intros_specs s = function
    | None, idents     -> Printf.sprintf " %s%s" s (pp_idents idents)
    | Some num, idents -> Printf.sprintf " %s%i %s" s num (pp_idents idents)
 
-let terms_pp ~term_pp terms = String.concat ", " (List.map term_pp terms)
+let pp_terms ~term_pp terms = String.concat ", " (List.map term_pp terms)
 
 let opt_string_pp = function
    | None -> ""
    | Some what -> what ^ " "
 
-let rec pp_tactic ~term_pp ~lazy_term_pp =
-  let pp_reduction_kind = pp_reduction_kind ~term_pp in
-  let pp_tactic_pattern = pp_tactic_pattern ~lazy_term_pp ~term_pp in
+let rec pp_tactic ~map_unicode_to_tex ~term_pp ~lazy_term_pp =
+ let pp_terms = pp_terms ~term_pp in
+ let pp_tactics = pp_tactics ~map_unicode_to_tex ~term_pp ~lazy_term_pp in
+ let pp_reduction_kind = pp_reduction_kind ~term_pp in
+ let pp_tactic_pattern =
+  pp_tactic_pattern ~map_unicode_to_tex ~lazy_term_pp ~term_pp in
+ let rec pp_tactic =
   function
   (* Higher order tactics *)
   | Do (_, count, tac) ->
-      Printf.sprintf "do %d %s" count (pp_tactic ~term_pp ~lazy_term_pp tac)
-  | Repeat (_, tac) -> "repeat " ^ pp_tactic ~term_pp ~lazy_term_pp tac
-  | Seq (_, tacs) -> pp_tactics ~term_pp ~lazy_term_pp ~sep:"; " tacs
+      Printf.sprintf "do %d %s" count (pp_tactic tac)
+  | Repeat (_, tac) -> "repeat " ^ pp_tactic tac
+  | Seq (_, tacs) -> pp_tactics ~sep:"; " tacs
   | Then (_, tac, tacs) ->
-      Printf.sprintf "%s; [%s]" (pp_tactic ~term_pp ~lazy_term_pp tac)
-        (pp_tactics ~term_pp ~lazy_term_pp ~sep:" | " tacs)
+      Printf.sprintf "%s; [%s]" (pp_tactic tac)
+        (pp_tactics ~sep:" | " tacs)
   | First (_, tacs) ->
-     Printf.sprintf "tries [%s]" (pp_tactics ~term_pp ~lazy_term_pp ~sep:" | " tacs)
-  | Try (_, tac) -> "try " ^ pp_tactic ~term_pp ~lazy_term_pp tac
+     Printf.sprintf "tries [%s]" (pp_tactics ~sep:" | " tacs)
+  | Try (_, tac) -> "try " ^ pp_tactic tac
   | Solve (_, tac) ->
-     Printf.sprintf "solve [%s]" (pp_tactics ~term_pp ~lazy_term_pp ~sep:" | " tac)
-  | Progress (_, tac) -> "progress " ^ pp_tactic ~term_pp ~lazy_term_pp tac
+     Printf.sprintf "solve [%s]" (pp_tactics ~sep:" | " tac)
+  | Progress (_, tac) -> "progress " ^ pp_tactic tac
   (* First order tactics *)
   | Absurd (_, term) -> "absurd" ^ term_pp term
   | Apply (_, term) -> "apply " ^ term_pp term
@@ -96,7 +103,7 @@ let rec pp_tactic ~term_pp ~lazy_term_pp =
      "applyS " ^ term_pp term ^
       String.concat " " 
         (List.map (fun (k,v) -> if v <> "" then k ^ "=" ^ v else k) params)
-  | Auto (_,params) -> "auto " ^ 
+  | AutoBatch (_,params) -> "auto batch " ^ 
       String.concat " " 
         (List.map (fun (k,v) -> if v <> "" then k ^ "=" ^ v else k) params)
   | Assumption _ -> "assumption"
@@ -107,6 +114,11 @@ let rec pp_tactic ~term_pp ~lazy_term_pp =
   | Clear (_,ids) -> Printf.sprintf "clear %s" (pp_hyps ids)
   | ClearBody (_,id) -> Printf.sprintf "clearbody %s" (pp_hyps [id])
   | Constructor (_,n) -> "constructor " ^ string_of_int n
+  | Compose (_,t1, t2, times, intro_specs) -> 
+      Printf.sprintf "compose %s%s %s%s" 
+        (if times > 0 then string_of_int times ^ " " else "")
+        (term_pp t1) (match t2 with None -> "" | Some t2 -> "with "^term_pp t2)
+        (pp_intros_specs " as " intro_specs)
   | Contradiction _ -> "contradiction"
   | Cut (_, ident, term) ->
      "cut " ^ term_pp term ^
@@ -115,7 +127,8 @@ let rec pp_tactic ~term_pp ~lazy_term_pp =
       Printf.sprintf "decompose%s" 
       (pp_intros_specs "names " (None, names)) 
   | Demodulate _ -> "demodulate"
-  | Destruct (_, term) -> "destruct " ^ term_pp term
+  | Destruct (_, None) -> "destruct" 
+  | Destruct (_, Some terms) -> "destruct " ^ pp_terms terms
   | Elim (_, what, using, pattern, specs) ->
       Printf.sprintf "elim %s%s %s%s" 
       (term_pp what)
@@ -147,7 +160,7 @@ let rec pp_tactic ~term_pp ~lazy_term_pp =
         (if linear then " linear " else "")
 	(match level_opt with None -> "" | Some i -> " depth = " ^ string_of_int i ^ " ")  
         (term_pp term) 
-        (match terms with [] -> "" | _ -> " to " ^ terms_pp ~term_pp terms)
+        (match terms with [] -> "" | _ -> " to " ^ pp_terms terms)
         (match ident_opt with None -> "" | Some ident -> " as " ^ ident)
   | Left _ -> "left"
   | LetIn (_, term, ident) -> 
@@ -166,7 +179,6 @@ let rec pp_tactic ~term_pp ~lazy_term_pp =
   | Right _ -> "right"
   | Ring _ -> "ring"
   | Split _ -> "split"
-  | Subst _ -> "subst"
   | Symmetry _ -> "symmetry"
   | Transitivity (_, term) -> "transitivity " ^ term_pp term
   (* Tattiche Aggiunte *)
@@ -182,15 +194,17 @@ let rec pp_tactic ~term_pp ~lazy_term_pp =
   | Thesisbecomes (_, term) -> "the thesis becomes " ^ term_pp term
   | ExistsElim (_, term0, ident, term, ident1, term1) -> "by " ^ (match term0 with None -> "_" | Some term -> term_pp term) ^ "let " ^ ident ^ ":" ^ term_pp term ^ "such that " ^ lazy_term_pp term1 ^ "(" ^ ident1 ^ ")"
   | AndElim (_, term, ident1, term1, ident2, term2) -> "by " ^ term_pp term ^ "we have " ^ term_pp term1 ^ " (" ^ ident1 ^ ") " ^ "and " ^ term_pp term2 ^ " (" ^ ident2 ^ ")" 
-  | RewritingStep (_, term, term1, term2, cont) -> (match term with None -> " " | Some (None,term) -> "conclude " ^ term_pp term | Some (Some name,term) -> "obtain (" ^ name ^ ") " ^ term_pp term) ^ "=" ^ term_pp term1 ^ (match term2 with `Auto params -> "_" ^ String.concat " " (List.map (fun (k,v) -> if v <> "" then k ^ "=" ^ v else k) params)  | `Term term2 -> term_pp term2) ^ (if cont then " done" else "")
+  | RewritingStep (_, term, term1, term2, cont) -> (match term with None -> " " | Some (None,term) -> "conclude " ^ term_pp term | Some (Some name,term) -> "obtain (" ^ name ^ ") " ^ term_pp term) ^ "=" ^ term_pp term1 ^ " by " ^ (match term2 with `Auto params -> "_" ^ String.concat " " (List.map (fun (k,v) -> if v <> "" then k ^ "=" ^ v else k) params)  | `Term term2 -> term_pp term2 | `Proof -> "proof") ^ (if cont then " done" else "")
   | Case (_, id, args) ->
      "case" ^ id ^
        String.concat " "
         (List.map (function (id,term) -> "(" ^ id ^ ": " ^ term_pp term ^  ")")
 	  args)
+ in pp_tactic
 
-and pp_tactics ~term_pp ~lazy_term_pp ~sep tacs =
-  String.concat sep (List.map (pp_tactic ~lazy_term_pp ~term_pp) tacs)
+and pp_tactics ~map_unicode_to_tex ~term_pp ~lazy_term_pp ~sep tacs =
+  String.concat sep
+   (List.map (pp_tactic ~map_unicode_to_tex ~lazy_term_pp ~term_pp) tacs)
 
  let pp_search_kind = function
   | `Locate -> "locate"
@@ -226,7 +240,11 @@ let pp_macro ~term_pp =
   | WMatch (_, term) -> "whelp match " ^ term_pp term
   (* real macros *)
   | Check (_, term) -> Printf.sprintf "check %s" (term_pp term)
-  | Hint _ -> "hint"
+  | Hint (_, true) -> "hint rewrite"
+  | Hint (_, false) -> "hint"
+  | AutoInteractive (_,params) -> "auto " ^ 
+      String.concat " " 
+        (List.map (fun (k,v) -> if v <> "" then k ^ "=" ^ v else k) params)
   | Inline (_, style, suri, prefix) ->  
       Printf.sprintf "inline %s\"%s\"%s" (style_pp style) suri (prefix_pp prefix) 
 
@@ -246,13 +264,15 @@ let pp_default what uris =
   Printf.sprintf "default \"%s\" %s" what
     (String.concat " " (List.map UriManager.string_of_uri uris))
 
-let pp_coercion uri do_composites arity =
-   Printf.sprintf "coercion %s %d (* %s *)" (UriManager.string_of_uri uri) arity
-     (if do_composites then "compounds" else "no compounds")
+let pp_coercion uri do_composites arity saturations=
+   Printf.sprintf "coercion %s %d %d (* %s *)"
+    (UriManager.string_of_uri uri) arity saturations
+    (if do_composites then "compounds" else "no compounds")
     
 let pp_command ~term_pp ~obj_pp = function
   | Index (_,_,uri) -> "Indexing " ^ UriManager.string_of_uri uri
-  | Coercion (_, uri, do_composites, i) -> pp_coercion uri do_composites i
+  | Coercion (_, uri, do_composites, i, j) ->
+     pp_coercion uri do_composites i j
   | Default (_,what,uris) -> pp_default what uris
   | Drop _ -> "drop"
   | Include (_,path) -> "include \"" ^ path ^ "\""
@@ -289,11 +309,11 @@ let pp_non_punctuation_tactical ~term_pp ~lazy_term_pp =
   | Unfocus _ -> "unfocus"
   | Skip _ -> "skip"
 
-let pp_executable ~term_pp ~lazy_term_pp ~obj_pp =
+let pp_executable ~map_unicode_to_tex ~term_pp ~lazy_term_pp ~obj_pp =
   function
   | Macro (_, macro) -> pp_macro ~term_pp macro ^ "."
   | Tactic (_, Some tac, punct) ->
-      pp_tactic ~lazy_term_pp ~term_pp tac
+      pp_tactic ~map_unicode_to_tex ~lazy_term_pp ~term_pp tac
       ^ pp_punctuation_tactical ~lazy_term_pp ~term_pp punct
   | Tactic (_, None, punct) ->
      pp_punctuation_tactical ~lazy_term_pp ~term_pp punct
@@ -302,12 +322,12 @@ let pp_executable ~term_pp ~lazy_term_pp ~obj_pp =
      ^ pp_punctuation_tactical ~lazy_term_pp ~term_pp punct
   | Command (_, cmd) -> pp_command ~term_pp ~obj_pp cmd ^ "."
                       
-let pp_comment ~term_pp ~lazy_term_pp ~obj_pp =
+let pp_comment ~map_unicode_to_tex ~term_pp ~lazy_term_pp ~obj_pp =
   function
   | Note (_,"") -> Printf.sprintf "\n"
   | Note (_,str) -> Printf.sprintf "\n(* %s *)" str
   | Code (_,code) ->
-      Printf.sprintf "\n(** %s. **)" (pp_executable ~term_pp ~lazy_term_pp ~obj_pp code)
+      Printf.sprintf "\n(** %s. **)" (pp_executable ~map_unicode_to_tex ~term_pp ~lazy_term_pp ~obj_pp code)
 
 let pp_statement ~term_pp ~lazy_term_pp ~obj_pp =
   function