open Printf
module Ast = CicNotationPt
+module Obj = LibraryObjects
let debug = false
let debug_print s = if debug then prerr_endline (Lazy.force s) else ()
}
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,_,lpsno,_) -> l, lpsno
| _ -> assert false
let left_params_no_of_inductive_type uri =
snd (get_types uri)
-let ast_of_acic0 term_info acic k =
+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
| 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 _ -> `Forall
in
idref id (Ast.Binder (binder_kind,
(CicNotationUtil.name_of_cic_name n, Some (k s)), k t))
| 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,(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)) ->
- let last_n n l =
- let rec aux =
- function
- [] -> assert false
- | [_] as l -> l,1
- | he::tl ->
- let (res,len) as res' = aux tl in
- if len < n then
- he::res,len + 1
- else
- res'
- in
- match fst (aux l) with
- [] -> assert false
- | [t] -> t
- | Ast.AttributedTerm (_,(Ast.Appl l))::tl ->
- idref aid (Ast.Appl (l@tl))
- | l -> idref aid (Ast.Appl l)
- in
- let deannot_he = Deannotate.deannotate_term he in
- if CoercDb.is_a_coercion' deannot_he && !Acic2content.hide_coercions
- then
- match CoercDb.is_a_coercion_to_funclass deannot_he with
- | None -> idref aid (last_n 1 (List.map k tl))
- | Some i -> idref aid (last_n (i+1) (List.map k tl))
- else
- idref aid (Ast.Appl (List.map k 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 "TAC 1" (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) ->
List.map2
(fun (name, ty) pat ->
incr j;
- let (capture_variables, rhs) = eat_branch lpsno 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
(* 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 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
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
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
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
+ Hashtbl.find !level2_patterns32 pid
with Not_found -> assert false
in
let ast = instantiate32 term_info idrefs env' symbol args in
in
set_compiled32 (lazy (Acic2astMatcher.Matcher32.compiler t))
-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;
(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 () =
(function (_, _, id) ->
let (dsc, _, _, _) =
try
- Hashtbl.find level2_patterns32 id
+ Hashtbl.find !level2_patterns32 id
with Not_found -> assert false
in
(id, dsc))
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;
let _ = load_patterns32 []
-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 ->
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.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
projects / helm.git / blobdiff