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 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
| Cic.ASort (id,Cic.Type u) -> idref id (Ast.Sort (`Type u))
| 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.AImplicit (id, _) -> idref id (Ast.Implicit `JustOne)
| 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))
| 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 LibraryObjects.destroy_nat t with
+ (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
try HExtlib.split_nth (cpos+sats+1) tl with Failure _ -> [],[]
in
if rest = [] then
- idref aid (List.nth (List.map k tl) cpos)
+ idref aid (k (List.nth tl cpos))
else
idref aid (Ast.Appl (List.map k (List.nth tl cpos::rest)))
else
- idref aid (Ast.Appl (List.map k tl))
+ idref aid (Ast.Appl (List.map k args))
else
idref aid (Ast.Appl (List.map k args)))
| Cic.AAppl (aid,args) ->
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 []
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 ~output_type id_to_sort annterm =
debug_print (lazy ("ast_of_acic <- "
let id = fresh_id () in
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
ids := id :: !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 =
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 ~term_of_nref 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.NRefPattern nref -> term_of_nref nref
+ | 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