GrafiteAst.Print (unused) removed.

[helm.git] / components / grafite_parser / grafiteDisambiguate.ml

diff --git a/components/grafite_parser/grafiteDisambiguate.ml b/components/grafite_parser/grafiteDisambiguate.ml
index f5ea66f2f6883e06a840744579277817577fe32f..4ced7a0afdd04e484836fc142195c70d2d597baa 100644 (file)
--- a/components/grafite_parser/grafiteDisambiguate.ml
+++ b/components/grafite_parser/grafiteDisambiguate.ml
@@ -27,30 +27,41 @@
 
 exception BaseUriNotSetYet
 
+type tactic = 
+ (CicNotationPt.term, CicNotationPt.term, 
+  CicNotationPt.term GrafiteAst.reduction, string) 
+   GrafiteAst.tactic
+   
+type lazy_tactic = 
+  (Cic.term, Cic.lazy_term, Cic.lazy_term GrafiteAst.reduction, string) 
+    GrafiteAst.tactic
+
 let singleton = function
   | [x], _ -> x
   | _ -> assert false
+;;
 
   (** @param term not meaningful when context is given *)
-let disambiguate_term lexicon_status_ref context metasenv term =
+let disambiguate_term text prefix_len lexicon_status_ref context metasenv term =
   let lexicon_status = !lexicon_status_ref in
   let (diff, metasenv, cic, _) =
     singleton
       (GrafiteDisambiguator.disambiguate_term ~dbd:(LibraryDb.instance ())
         ~aliases:lexicon_status.LexiconEngine.aliases
         ~universe:(Some lexicon_status.LexiconEngine.multi_aliases)
-        ~context ~metasenv term)
+        ~context ~metasenv (text,prefix_len,term))
   in
   let lexicon_status = LexiconEngine.set_proof_aliases lexicon_status diff in
   lexicon_status_ref := lexicon_status;
   metasenv,cic
-  
+;;
+
   (** disambiguate_lazy_term (circa): term -> (unit -> status) * lazy_term
    * rationale: lazy_term will be invoked in different context to obtain a term,
    * each invocation will disambiguate the term and can add aliases. Once all
    * disambiguations have been performed, the first returned function can be
    * used to obtain the resulting aliases *)
-let disambiguate_lazy_term lexicon_status_ref term =
+let disambiguate_lazy_term text prefix_len lexicon_status_ref term =
   (fun context metasenv ugraph ->
     let lexicon_status = !lexicon_status_ref in
     let (diff, metasenv, cic, ugraph) =
@@ -59,12 +70,15 @@ let disambiguate_lazy_term lexicon_status_ref term =
           ~initial_ugraph:ugraph ~aliases:lexicon_status.LexiconEngine.aliases
           ~universe:(Some lexicon_status.LexiconEngine.multi_aliases)
           ~context ~metasenv
-          term) in
+          (text,prefix_len,term)) in
     let lexicon_status = LexiconEngine.set_proof_aliases lexicon_status diff in
     lexicon_status_ref := lexicon_status;
     cic, metasenv, ugraph)
+;;
 
-let disambiguate_pattern lexicon_status_ref (wanted, hyp_paths, goal_path) =
+let disambiguate_pattern 
+  text prefix_len lexicon_status_ref (wanted, hyp_paths, goal_path) 
+=
   let interp path = Disambiguate.interpretate_path [] path in
   let goal_path = HExtlib.map_option interp goal_path in
   let hyp_paths = List.map (fun (name, path) -> name, interp path) hyp_paths in
@@ -72,27 +86,36 @@ let disambiguate_pattern lexicon_status_ref (wanted, hyp_paths, goal_path) =
    match wanted with
       None -> None
     | Some wanted ->
-       let wanted = disambiguate_lazy_term lexicon_status_ref wanted in
+       let wanted = 
+         disambiguate_lazy_term text prefix_len lexicon_status_ref wanted 
+       in
        Some wanted
   in
   (wanted, hyp_paths, goal_path)
+;;
 
-let disambiguate_reduction_kind lexicon_status_ref = function
+let disambiguate_reduction_kind text prefix_len lexicon_status_ref = function
   | `Unfold (Some t) ->
-      let t = disambiguate_lazy_term lexicon_status_ref t in
+      let t = disambiguate_lazy_term text prefix_len lexicon_status_ref t in
       `Unfold (Some t)
-  | `Demodulate
   | `Normalize
   | `Reduce
   | `Simpl
   | `Unfold None
   | `Whd as kind -> kind
-  
-let disambiguate_tactic lexicon_status_ref context metasenv tactic =
-  let disambiguate_term = disambiguate_term lexicon_status_ref in
-  let disambiguate_pattern = disambiguate_pattern lexicon_status_ref in
-  let disambiguate_reduction_kind = disambiguate_reduction_kind lexicon_status_ref in
-  let disambiguate_lazy_term = disambiguate_lazy_term lexicon_status_ref in
+;;
+
+let disambiguate_tactic 
+  lexicon_status_ref context metasenv (text,prefix_len,tactic) 
+=
+  let disambiguate_term = 
+    disambiguate_term text prefix_len lexicon_status_ref in
+  let disambiguate_pattern = 
+    disambiguate_pattern text prefix_len lexicon_status_ref in
+  let disambiguate_reduction_kind = 
+    disambiguate_reduction_kind text prefix_len lexicon_status_ref in
+  let disambiguate_lazy_term = 
+    disambiguate_lazy_term text prefix_len lexicon_status_ref in
    match tactic with
     | GrafiteAst.Absurd (loc, term) -> 
         let metasenv,cic = disambiguate_term context metasenv term in
@@ -100,10 +123,13 @@ let disambiguate_tactic lexicon_status_ref context metasenv tactic =
     | GrafiteAst.Apply (loc, term) ->
         let metasenv,cic = disambiguate_term context metasenv term in
         metasenv,GrafiteAst.Apply (loc, cic)
+    | GrafiteAst.ApplyS (loc, term) ->
+        let metasenv,cic = disambiguate_term context metasenv term in
+        metasenv,GrafiteAst.ApplyS (loc, cic)
     | GrafiteAst.Assumption loc ->
         metasenv,GrafiteAst.Assumption loc
-    | GrafiteAst.Auto (loc,depth,width,paramodulation,full) ->
-        metasenv,GrafiteAst.Auto (loc,depth,width,paramodulation,full)
+    | GrafiteAst.Auto (loc,params) ->
+        metasenv,GrafiteAst.Auto (loc,params)
     | GrafiteAst.Change (loc, pattern, with_what) -> 
         let with_what = disambiguate_lazy_term with_what in
         let pattern = disambiguate_pattern pattern in
@@ -112,9 +138,6 @@ let disambiguate_tactic lexicon_status_ref context metasenv tactic =
         metasenv,GrafiteAst.Clear (loc,id)
     | GrafiteAst.ClearBody (loc,id) ->
        metasenv,GrafiteAst.ClearBody (loc,id)
-    | GrafiteAst.Compare (loc,term) ->
-        let metasenv,term = disambiguate_term context metasenv term in
-        metasenv,GrafiteAst.Compare (loc,term)
     | GrafiteAst.Constructor (loc,n) ->
         metasenv,GrafiteAst.Constructor (loc,n)
     | GrafiteAst.Contradiction loc ->
@@ -122,8 +145,6 @@ let disambiguate_tactic lexicon_status_ref context metasenv tactic =
     | GrafiteAst.Cut (loc, ident, term) -> 
         let metasenv,cic = disambiguate_term context metasenv term in
         metasenv,GrafiteAst.Cut (loc, ident, cic)
-    | GrafiteAst.DecideEquality loc ->
-        metasenv,GrafiteAst.DecideEquality loc
     | GrafiteAst.Decompose (loc, types, what, names) ->
         let disambiguate (metasenv,types) = function
            | GrafiteAst.Type _   -> assert false
@@ -142,6 +163,8 @@ let disambiguate_tactic lexicon_status_ref context metasenv tactic =
          List.fold_left disambiguate (metasenv,[]) types
         in
          metasenv,GrafiteAst.Decompose (loc, types, what, names)
+    | GrafiteAst.Demodulate loc ->
+        metasenv,GrafiteAst.Demodulate loc
     | GrafiteAst.Discriminate (loc,term) ->
         let metasenv,term = disambiguate_term context metasenv term in
         metasenv,GrafiteAst.Discriminate(loc,term)
@@ -190,14 +213,14 @@ let disambiguate_tactic lexicon_status_ref context metasenv tactic =
     | GrafiteAst.Inversion (loc, term) ->
        let metasenv,term = disambiguate_term context metasenv term in
         metasenv,GrafiteAst.Inversion (loc, term)
-    | GrafiteAst.LApply (loc, depth, to_what, what, ident) ->
+    | GrafiteAst.LApply (loc, linear, depth, to_what, what, ident) ->
        let f term to_what =
           let metasenv,term = disambiguate_term context metasenv term in
           term :: to_what
        in
        let to_what = List.fold_right f to_what [] in 
        let metasenv,what = disambiguate_term context metasenv what in
-       metasenv,GrafiteAst.LApply (loc, depth, to_what, what, ident)
+       metasenv,GrafiteAst.LApply (loc, linear, depth, to_what, what, ident)
     | GrafiteAst.Left loc ->
        metasenv,GrafiteAst.Left loc
     | GrafiteAst.LetIn (loc, term, name) ->
@@ -228,8 +251,25 @@ let disambiguate_tactic lexicon_status_ref context metasenv tactic =
     | GrafiteAst.Transitivity (loc, term) -> 
         let metasenv,cic = disambiguate_term context metasenv term in
         metasenv,GrafiteAst.Transitivity (loc, cic)
+      (* Nuovi casi *)
+    | GrafiteAst.Assume (loc, id, term) -> 
+        let metasenv,cic = disambiguate_term context metasenv term in
+        metasenv,GrafiteAst.Assume (loc, id, cic)
+    | GrafiteAst.Suppose (loc, term, id) ->
+        let metasenv,cic = disambiguate_term context metasenv term in 
+       metasenv,GrafiteAst.Suppose (loc, cic, id)
+    | GrafiteAst.Bydone (loc,term) ->
+        let metasenv,cic = disambiguate_term context metasenv term in
+       metasenv,GrafiteAst.Bydone (loc, cic)
+    | GrafiteAst.We_need_to_prove (loc,term,id) ->
+        let metasenv,cic = disambiguate_term context metasenv term in
+       metasenv,GrafiteAst.We_need_to_prove (loc,cic,id)
+    | GrafiteAst.By_term_we_proved (loc,term,term',id) ->
+        let metasenv,cic = disambiguate_term context metasenv term in
+        let metasenv,cic' = disambiguate_term context metasenv term' in
+       metasenv,GrafiteAst.By_term_we_proved (loc,cic,cic',id)
 
-let disambiguate_obj lexicon_status ~baseuri metasenv obj =
+let disambiguate_obj lexicon_status ~baseuri metasenv (text,prefix_len,obj) =
   let uri =
    match obj with
     | CicNotationPt.Inductive (_,(name,_,_,_)::_)
@@ -244,12 +284,13 @@ let disambiguate_obj lexicon_status ~baseuri metasenv obj =
     singleton
       (GrafiteDisambiguator.disambiguate_obj ~dbd:(LibraryDb.instance ())
         ~aliases:lexicon_status.LexiconEngine.aliases
-        ~universe:(Some lexicon_status.LexiconEngine.multi_aliases) ~uri obj) in
+        ~universe:(Some lexicon_status.LexiconEngine.multi_aliases) ~uri 
+        (text,prefix_len,obj)) in
   let lexicon_status = LexiconEngine.set_proof_aliases lexicon_status diff in
   lexicon_status, metasenv, cic
   
-let disambiguate_command lexicon_status ~baseuri metasenv =
- function
+let disambiguate_command lexicon_status ~baseuri metasenv (text,prefix_len,cmd)=
+ match cmd with
   | GrafiteAst.Coercion _
   | GrafiteAst.Default _
   | GrafiteAst.Drop _
@@ -259,11 +300,13 @@ let disambiguate_command lexicon_status ~baseuri metasenv =
       lexicon_status,metasenv,cmd
   | GrafiteAst.Obj (loc,obj) ->
       let lexicon_status,metasenv,obj =
-       disambiguate_obj lexicon_status ~baseuri metasenv obj in
+       disambiguate_obj lexicon_status ~baseuri metasenv (text,prefix_len,obj)in
       lexicon_status, metasenv, GrafiteAst.Obj (loc,obj)
 
-let disambiguate_macro lexicon_status_ref metasenv context macro =
- let disambiguate_term = disambiguate_term lexicon_status_ref in
+let disambiguate_macro 
+  lexicon_status_ref metasenv context (text,prefix_len, macro) 
+=
+ let disambiguate_term = disambiguate_term text prefix_len lexicon_status_ref in
   match macro with
    | GrafiteAst.WMatch (loc,term) ->
       let metasenv,term = disambiguate_term context metasenv term in
@@ -283,7 +326,4 @@ let disambiguate_macro lexicon_status_ref metasenv context macro =
    | GrafiteAst.Hint _
    | GrafiteAst.WLocate _ as macro ->
       metasenv,macro
-   | GrafiteAst.Quit _
-   | GrafiteAst.Print _
-   | GrafiteAst.Search_pat _
-   | GrafiteAst.Search_term _ -> assert false
+   | GrafiteAst.Quit _ -> assert false