X-Git-Url: http://matita.cs.unibo.it/gitweb/?a=blobdiff_plain;f=helm%2Fsoftware%2Fcomponents%2Facic_content%2FtermAcicContent.ml;h=0c0b0232829ff10619d71bd9985fb535e91e9a71;hb=11b2157bacf59cfc561c2ef6f92ee41ee2c1a006;hp=fddd777f7e13959fac65a76ff202f40ae23f4738;hpb=55b82bd235d82ff7f0a40d980effe1efde1f5073;p=helm.git

diff --git a/helm/software/components/acic_content/termAcicContent.ml b/helm/software/components/acic_content/termAcicContent.ml
index fddd777f7..0c0b02328 100644
--- a/helm/software/components/acic_content/termAcicContent.ml
+++ b/helm/software/components/acic_content/termAcicContent.ml
@@ -28,6 +28,7 @@
 open Printf
 
 module Ast = CicNotationPt
+module Obj = LibraryObjects
 
 let debug = false
 let debug_print s = if debug then prerr_endline (Lazy.force s) else ()
@@ -42,19 +43,19 @@ type term_info =
   }
 
 let get_types uri =
-  let o,_ = CicEnvironment.get_obj CicUniv.empty_ugraph uri in
+  let o,_ = CicEnvironment.get_obj CicUniv.oblivion_ugraph uri in
     match o with
-      | Cic.InductiveDefinition (l,_,_,_) -> l 
+      | Cic.InductiveDefinition (l,_,lpsno,_) -> l, lpsno 
       | _ -> assert false
 
 let name_of_inductive_type uri i = 
-  let types = get_types uri in
+  let types, _ = get_types uri in
   let (name, _, _, _) = try List.nth types i with Not_found -> assert false in
   name
 
   (* returns <name, type> pairs *)
 let constructors_of_inductive_type uri i =
-  let types = get_types uri in
+  let types, _ = get_types uri in
   let (_, _, _, constructors) = 
     try List.nth types i with Not_found -> assert false
   in
@@ -66,7 +67,26 @@ let constructor_of_inductive_type uri i j =
     fst (List.nth (constructors_of_inductive_type uri i) (j-1))
   with Not_found -> assert false)
 
-let ast_of_acic0 term_info acic k =
+  (* returns the number of left parameters *)
+let left_params_no_of_inductive_type uri =
+   snd (get_types uri)
+
+let destroy_nat annterm =
+  let is_zero = function
+    | Cic.AMutConstruct (_, uri, 0, 1, _) when Obj.is_nat_URI uri -> true
+    | _ -> false
+  in
+  let is_succ = function
+    | Cic.AMutConstruct (_, uri, 0, 2, _) when Obj.is_nat_URI uri -> true
+    | _ -> false
+  in
+  let rec aux acc = function
+    | Cic.AAppl (_, [he ; tl]) when is_succ he -> aux (acc + 1) tl
+    | t when is_zero t -> Some acc
+    | _ -> None in
+  aux 0 annterm
+
+let ast_of_acic0 ~output_type term_info acic k =
   let k = k term_info in
   let id_to_uris = term_info.uri in
   let register_uri id uri = Hashtbl.add id_to_uris id uri in
@@ -99,14 +119,14 @@ let ast_of_acic0 term_info acic k =
     | Cic.ASort (id,Cic.Prop) -> idref id (Ast.Sort `Prop)
     | Cic.ASort (id,Cic.Set) -> idref id (Ast.Sort `Set)
     | Cic.ASort (id,Cic.Type u) -> idref id (Ast.Sort (`Type u))
-    | Cic.ASort (id,Cic.CProp) -> idref id (Ast.Sort `CProp)
+    | Cic.ASort (id,Cic.CProp u) -> idref id (Ast.Sort (`CProp u))
     | Cic.AImplicit (id, Some `Hole) -> idref id Ast.UserInput
     | Cic.AImplicit (id, _) -> idref id Ast.Implicit
     | Cic.AProd (id,n,s,t) ->
         let binder_kind =
           match sort_of_id id with
-          | `Set | `Type _ -> `Pi
-          | `Prop | `CProp -> `Forall
+          | `Set | `Type _ | `NType _ -> `Pi
+          | `Prop | `CProp _ | `NCProp _ -> `Forall
         in
         idref id (Ast.Binder (binder_kind,
           (CicNotationUtil.name_of_cic_name n, Some (k s)), k t))
@@ -114,10 +134,35 @@ let ast_of_acic0 term_info acic k =
     | Cic.ALambda (id,n,s,t) ->
         idref id (Ast.Binder (`Lambda,
           (CicNotationUtil.name_of_cic_name n, Some (k s)), k t))
-    | Cic.ALetIn (id,n,s,t) ->
-        idref id (Ast.LetIn ((CicNotationUtil.name_of_cic_name n, None),
+    | Cic.ALetIn (id,n,s,ty,t) ->
+        idref id (Ast.LetIn ((CicNotationUtil.name_of_cic_name n, Some (k ty)),
           k s, k t))
-    | Cic.AAppl (aid,args) -> idref aid (Ast.Appl (List.map k args))
+    | Cic.AAppl (aid,(Cic.AConst _ as he::tl as args))
+    | Cic.AAppl (aid,(Cic.AMutInd _ as he::tl as args))
+    | Cic.AAppl (aid,(Cic.AMutConstruct _ as he::tl as args)) as t ->
+       (match destroy_nat t with
+       | Some n -> idref aid (Ast.Num (string_of_int n, -1))
+       | None ->
+           let deannot_he = Deannotate.deannotate_term he in
+           let coercion_info = CoercDb.is_a_coercion deannot_he in
+           if coercion_info <> None && !Acic2content.hide_coercions then
+             match coercion_info with
+             | None -> assert false 
+             | Some (_,_,_,sats,cpos) -> 
+                 if cpos < List.length tl then
+                   let _,rest = 
+                     try HExtlib.split_nth (cpos+sats+1) tl with Failure _ -> [],[] 
+                   in
+                   if rest = [] then
+                     idref aid (List.nth (List.map k tl) cpos)
+                   else
+                     idref aid (Ast.Appl (List.map k (List.nth tl cpos::rest)))
+                 else
+                   idref aid (Ast.Appl (List.map k tl))
+           else
+             idref aid (Ast.Appl (List.map k args)))
+    | Cic.AAppl (aid,args) ->
+        idref aid (Ast.Appl (List.map k args))
     | Cic.AConst (id,uri,substs) ->
         register_uri id uri;
         idref id (Ast.Ident (UriManager.name_of_uri uri, aux_substs substs))
@@ -143,10 +188,12 @@ let ast_of_acic0 term_info acic k =
         in
         let case_indty = name, Some (UriManager.uri_of_string puri_str) in
         let constructors = constructors_of_inductive_type uri typeno in
-        let rec eat_branch ty pat =
+        let lpsno = left_params_no_of_inductive_type uri in
+	let rec eat_branch n ty pat =
           match (ty, pat) with
+	  | Cic.Prod (_, _, t), _ when n > 0 -> eat_branch (pred n) t pat 
           | Cic.Prod (_, _, t), Cic.ALambda (_, name, s, t') ->
-              let (cv, rhs) = eat_branch t t' in
+              let (cv, rhs) = eat_branch 0 t t' in
               (CicNotationUtil.name_of_cic_name name, Some (k s)) :: cv, rhs
           | _, _ -> [], k pat
         in
@@ -156,38 +203,91 @@ let ast_of_acic0 term_info acic k =
             List.map2
               (fun (name, ty) pat ->
                 incr j;
-                let (capture_variables, rhs) = eat_branch ty pat in
-                ((name, Some (ctor_puri !j), capture_variables), rhs))
-              constructors patterns
+                let name,(capture_variables,rhs) =
+                 match output_type with
+                    `Term -> name, eat_branch lpsno ty pat
+                  | `Pattern -> "_", ([], k pat)
+                in
+                 Ast.Pattern (name, Some (ctor_puri !j), capture_variables), rhs
+              ) constructors patterns
           with Invalid_argument _ -> assert false
         in
-        idref id (Ast.Case (k te, Some case_indty, Some (k ty), patterns))
+        let indty =
+         match output_type with
+            `Pattern -> None
+          | `Term -> Some case_indty
+        in
+        idref id (Ast.Case (k te, indty, Some (k ty), patterns))
     | Cic.AFix (id, no, funs) -> 
         let defs = 
           List.map
             (fun (_, n, decr_idx, ty, bo) ->
-              ((Ast.Ident (n, None), Some (k ty)), k bo, decr_idx))
+              let params,bo =
+               let rec aux =
+                function
+                   Cic.ALambda (_,name,so,ta) ->
+                    let params,rest = aux ta in
+                     (CicNotationUtil.name_of_cic_name name,Some (k so))::
+                      params, rest
+                 | t -> [],t
+               in
+                aux bo
+              in
+              let ty =
+               let rec eat_pis =
+                function
+                   0,ty -> ty
+                 | n,Cic.AProd (_,_,_,ta) -> eat_pis (n - 1,ta)
+                 | n,ty ->
+                    (* I should do a whd here, but I have no context *)
+                    assert false
+               in
+                eat_pis ((List.length params),ty)
+              in
+               (params,(Ast.Ident (n, None), Some (k ty)), k bo, decr_idx))
             funs
         in
         let name =
           try
             (match List.nth defs no with
-            | (Ast.Ident (n, _), _), _, _ when n <> "_" -> n
+            | _, (Ast.Ident (n, _), _), _, _ when n <> "_" -> n
             | _ -> assert false)
           with Not_found -> assert false
         in
-        idref id (Ast.LetRec (`Inductive, defs, Ast.Ident (name, None)))
+         idref id (Ast.LetRec (`Inductive, defs, Ast.Ident (name, None)))
     | Cic.ACoFix (id, no, funs) -> 
         let defs = 
           List.map
             (fun (_, n, ty, bo) ->
-              ((Ast.Ident (n, None), Some (k ty)), k bo, 0))
+              let params,bo =
+               let rec aux =
+                function
+                   Cic.ALambda (_,name,so,ta) ->
+                    let params,rest = aux ta in
+                     (CicNotationUtil.name_of_cic_name name,Some (k so))::
+                      params, rest
+                 | t -> [],t
+               in
+                aux bo
+              in
+              let ty =
+               let rec eat_pis =
+                function
+                   0,ty -> ty
+                 | n,Cic.AProd (_,_,_,ta) -> eat_pis (n - 1,ta)
+                 | n,ty ->
+                    (* I should do a whd here, but I have no context *)
+                    assert false
+               in
+                eat_pis ((List.length params),ty)
+              in
+               (params,(Ast.Ident (n, None), Some (k ty)), k bo, 0))
             funs
         in
         let name =
           try
             (match List.nth defs no with
-            | (Ast.Ident (n, _), _), _, _ when n <> "_" -> n
+            | _, (Ast.Ident (n, _), _), _, _ when n <> "_" -> n
             | _ -> assert false)
           with Not_found -> assert false
         in
@@ -197,11 +297,39 @@ let ast_of_acic0 term_info acic k =
 
   (* persistent state *)
 
-let level2_patterns32 = Hashtbl.create 211
-let interpretations = Hashtbl.create 211  (* symb -> id list ref *)
+let initial_level2_patterns32 () = Hashtbl.create 211
+let initial_interpretations () = Hashtbl.create 211
 
+let level2_patterns32 = ref (initial_level2_patterns32 ())
+(* symb -> id list ref *)
+let interpretations = ref (initial_interpretations ())
 let compiled32 = ref None
 let pattern32_matrix = ref []
+let counter = ref ~-1 
+let find_level2_patterns32 pid = Hashtbl.find !level2_patterns32 pid;;
+
+let stack = ref []
+
+let push () =
+ stack := (!counter,!level2_patterns32,!interpretations,!compiled32,!pattern32_matrix)::!stack;
+ counter := ~-1;
+ level2_patterns32 := initial_level2_patterns32 ();
+ interpretations := initial_interpretations ();
+ compiled32 := None;
+ pattern32_matrix := []
+;;
+
+let pop () =
+ match !stack with
+    [] -> assert false
+  | (ocounter,olevel2_patterns32,ointerpretations,ocompiled32,opattern32_matrix)::old ->
+   stack := old;
+   counter := ocounter;
+   level2_patterns32 := olevel2_patterns32;
+   interpretations := ointerpretations;
+   compiled32 := ocompiled32;
+   pattern32_matrix := opattern32_matrix
+;;
 
 let get_compiled32 () =
   match !compiled32 with
@@ -216,7 +344,11 @@ let add_idrefs =
 let instantiate32 term_info idrefs env symbol args =
   let rec instantiate_arg = function
     | Ast.IdentArg (n, name) ->
-        let t = (try List.assoc name env with Not_found -> assert false) in
+        let t = 
+          try List.assoc name env 
+          with Not_found -> prerr_endline ("name not found in env: "^name);
+                            assert false
+        in
         let rec count_lambda = function
           | Ast.AttributedTerm (_, t) -> count_lambda t
           | Ast.Binder (`Lambda, _, body) -> 1 + count_lambda body
@@ -239,11 +371,12 @@ let instantiate32 term_info idrefs env symbol args =
   if args = [] then head
   else Ast.Appl (head :: List.map instantiate_arg args)
 
-let rec ast_of_acic1 term_info annterm = 
+let rec ast_of_acic1 ~output_type term_info annterm = 
   let id_to_uris = term_info.uri in
   let register_uri id uri = Hashtbl.add id_to_uris id uri in
   match (get_compiled32 ()) annterm with
-  | None -> ast_of_acic0 term_info annterm ast_of_acic1
+  | None ->
+     ast_of_acic0 ~output_type term_info annterm (ast_of_acic1 ~output_type)
   | Some (env, ctors, pid) -> 
       let idrefs =
         List.map
@@ -257,45 +390,51 @@ let rec ast_of_acic1 term_info annterm =
           ctors
       in
       let env' =
-        List.map (fun (name, term) -> (name, ast_of_acic1 term_info term)) env
+       List.map
+        (fun (name, term) -> name, ast_of_acic1 ~output_type term_info term) env
       in
       let _, symbol, args, _ =
         try
-          Hashtbl.find level2_patterns32 pid
+          find_level2_patterns32 pid
         with Not_found -> assert false
       in
       let ast = instantiate32 term_info idrefs env' symbol args in
       Ast.AttributedTerm (`IdRef (CicUtil.id_of_annterm annterm), ast)
 
-let load_patterns32 t =
+let load_patterns32s =
+ let load_patterns32 t =
   let t =
     HExtlib.filter_map (function (true, ap, id) -> Some (ap, id) | _ -> None) t
   in
-  set_compiled32 (lazy (Acic2astMatcher.Matcher32.compiler t))
+   set_compiled32 (lazy (Acic2astMatcher.Matcher32.compiler t))
+ in
+  ref [load_patterns32]
+;;
+
+let add_load_patterns32 f = load_patterns32s := f :: !load_patterns32s;;
 
-let ast_of_acic id_to_sort annterm =
+let ast_of_acic ~output_type id_to_sort annterm =
   debug_print (lazy ("ast_of_acic <- "
     ^ CicPp.ppterm (Deannotate.deannotate_term annterm)));
   let term_info = { sort = id_to_sort; uri = Hashtbl.create 211 } in
-  let ast = ast_of_acic1 term_info annterm in
+  let ast = ast_of_acic1 ~output_type term_info annterm in
   debug_print (lazy ("ast_of_acic -> " ^ CicNotationPp.pp_term ast));
   ast, term_info.uri
 
 let fresh_id =
-  let counter = ref ~-1 in
   fun () ->
     incr counter;
     !counter
 
 let add_interpretation dsc (symbol, args) appl_pattern =
   let id = fresh_id () in
-  Hashtbl.add level2_patterns32 id (dsc, symbol, args, appl_pattern);
+  Hashtbl.add !level2_patterns32 id (dsc, symbol, args, appl_pattern);
   pattern32_matrix := (true, appl_pattern, id) :: !pattern32_matrix;
-  load_patterns32 !pattern32_matrix;
+  List.iter (fun f -> f !pattern32_matrix) !load_patterns32s;
   (try
-    let ids = Hashtbl.find interpretations symbol in
+    let ids = Hashtbl.find !interpretations symbol in
     ids := id :: !ids
-  with Not_found -> Hashtbl.add interpretations symbol (ref [id]));
+  with Not_found -> Hashtbl.add !interpretations symbol (ref [id]));
   id
 
 let get_all_interpretations () =
@@ -303,7 +442,7 @@ let get_all_interpretations () =
     (function (_, _, id) ->
       let (dsc, _, _, _) =
         try
-          Hashtbl.find level2_patterns32 id
+          Hashtbl.find !level2_patterns32 id
         with Not_found -> assert false
       in
       (id, dsc))
@@ -322,39 +461,44 @@ let set_active_interpretations ids =
       !pattern32_matrix
   in
   pattern32_matrix := pattern32_matrix';
-  load_patterns32 !pattern32_matrix
+  List.iter (fun f -> f !pattern32_matrix) !load_patterns32s
 
 exception Interpretation_not_found
 
-let lookup_interpretations symbol =
+let lookup_interpretations ?(sorted=true) symbol =
   try
-   HExtlib.list_uniq
-    (List.sort Pervasives.compare
-     (List.map
-      (fun id ->
-        let (dsc, _, args, appl_pattern) =
-          try
-            Hashtbl.find level2_patterns32 id
-          with Not_found -> assert false 
-        in
-        dsc, args, appl_pattern)
-      !(Hashtbl.find interpretations symbol)))
+    let raw = 
+      List.map (
+        fun id ->
+          let (dsc, _, args, appl_pattern) =
+            try
+              Hashtbl.find !level2_patterns32 id
+            with Not_found -> assert false 
+          in
+          dsc, args, appl_pattern
+      )
+      !(Hashtbl.find !interpretations symbol)
+    in
+    if sorted then HExtlib.list_uniq (List.sort Pervasives.compare raw)
+              else raw
   with Not_found -> raise Interpretation_not_found
 
 let remove_interpretation id =
   (try
-    let _, symbol, _, _ = Hashtbl.find level2_patterns32 id in
-    let ids = Hashtbl.find interpretations symbol in
+    let dsc, symbol, _, _ = Hashtbl.find !level2_patterns32 id in
+    let ids = Hashtbl.find !interpretations symbol in
     ids := List.filter ((<>) id) !ids;
-    Hashtbl.remove level2_patterns32 id;
+    Hashtbl.remove !level2_patterns32 id;
   with Not_found -> raise Interpretation_not_found);
   pattern32_matrix :=
     List.filter (fun (_, _, id') -> id <> id') !pattern32_matrix;
-  load_patterns32 !pattern32_matrix
+  List.iter (fun f -> f !pattern32_matrix) !load_patterns32s
 
-let _ = load_patterns32 []
+let init () = List.iter (fun f -> f []) !load_patterns32s
 
-let instantiate_appl_pattern env appl_pattern =
+let instantiate_appl_pattern 
+  ~mk_appl ~mk_implicit ~term_of_uri env appl_pattern 
+=
   let lookup name =
     try List.assoc name env
     with Not_found ->
@@ -362,10 +506,11 @@ let instantiate_appl_pattern env appl_pattern =
       assert false
   in
   let rec aux = function
-    | Ast.UriPattern uri -> CicUtil.term_of_uri uri
-    | Ast.ImplicitPattern -> Cic.Implicit None
+    | Ast.UriPattern uri -> term_of_uri uri
+    | Ast.NRefPattern _ -> assert false
+    | Ast.ImplicitPattern -> mk_implicit false
     | Ast.VarPattern name -> lookup name
-    | Ast.ApplPattern terms -> Cic.Appl (List.map aux terms)
+    | Ast.ApplPattern terms -> mk_appl (List.map aux terms)
   in
   aux appl_pattern