From 6b649aba925b6f7462da07599fe67ebb12a3460e Mon Sep 17 00:00:00 2001 From: Samuel Mimram Date: Wed, 28 Jul 2004 21:54:47 +0000 Subject: Imported Upstream version 8.0pl1 --- proofs/clenv.ml | 1175 +++++++++++++++++++++++++++++++++++++++++++++++ proofs/clenv.mli | 142 ++++++ proofs/doc.tex | 14 + proofs/evar_refiner.ml | 187 ++++++++ proofs/evar_refiner.mli | 57 +++ proofs/logic.ml | 786 +++++++++++++++++++++++++++++++ proofs/logic.mli | 73 +++ proofs/pfedit.ml | 333 ++++++++++++++ proofs/pfedit.mli | 183 ++++++++ proofs/proof_trees.ml | 253 ++++++++++ proofs/proof_trees.mli | 68 +++ proofs/proof_type.ml | 101 ++++ proofs/proof_type.mli | 128 ++++++ proofs/refiner.ml | 1030 +++++++++++++++++++++++++++++++++++++++++ proofs/refiner.mli | 210 +++++++++ proofs/tacexpr.ml | 314 +++++++++++++ proofs/tacmach.ml | 260 +++++++++++ proofs/tacmach.mli | 183 ++++++++ proofs/tactic_debug.ml | 179 ++++++++ proofs/tactic_debug.mli | 62 +++ proofs/tmp-src | 56 +++ 21 files changed, 5794 insertions(+) create mode 100644 proofs/clenv.ml create mode 100644 proofs/clenv.mli create mode 100644 proofs/doc.tex create mode 100644 proofs/evar_refiner.ml create mode 100644 proofs/evar_refiner.mli create mode 100644 proofs/logic.ml create mode 100644 proofs/logic.mli create mode 100644 proofs/pfedit.ml create mode 100644 proofs/pfedit.mli create mode 100644 proofs/proof_trees.ml create mode 100644 proofs/proof_trees.mli create mode 100644 proofs/proof_type.ml create mode 100644 proofs/proof_type.mli create mode 100644 proofs/refiner.ml create mode 100644 proofs/refiner.mli create mode 100644 proofs/tacexpr.ml create mode 100644 proofs/tacmach.ml create mode 100644 proofs/tacmach.mli create mode 100644 proofs/tactic_debug.ml create mode 100644 proofs/tactic_debug.mli create mode 100644 proofs/tmp-src (limited to 'proofs') diff --git a/proofs/clenv.ml b/proofs/clenv.ml new file mode 100644 index 00000000..423350d7 --- /dev/null +++ b/proofs/clenv.ml @@ -0,0 +1,1175 @@ +(************************************************************************) +(* v * The Coq Proof Assistant / The Coq Development Team *) +(* + let na = match kind_of_term a with Var id -> Name id | _ -> na in + if occur_meta ta then error "cannot find a type for the generalisation" + else if occur_meta a then lambda_name env (na,ta,t) + else lambda_name env (na,ta,subst_term_occ locc a t)) + c + (List.rev l) + lname_typ + +let abstract_list_all env sigma typ c l = + let ctxt,_ = decomp_n_prod env sigma (List.length l) typ in + let p = abstract_scheme env c (List.map (function a -> [],a) l) ctxt in + try + if is_conv_leq env sigma (Typing.type_of env sigma p) typ then p + else error "abstract_list_all" + with UserError _ -> + raise (RefinerError (CannotGeneralize typ)) + +(* Generator of metavariables *) +let new_meta = + let meta_ctr = ref 0 in + fun () -> incr meta_ctr; !meta_ctr + +(* replaces a mapping of existentials into a mapping of metas. + Problem if an evar appears in the type of another one (pops anomaly) *) +let exist_to_meta sigma (emap, c) = + let metamap = ref [] in + let change_exist evar = + let ty = nf_betaiota (nf_evar emap (existential_type emap evar)) in + let n = new_meta() in + metamap := (n, ty) :: !metamap; + mkMeta n in + let rec replace c = + match kind_of_term c with + Evar (k,_ as ev) when not (Evd.in_dom sigma k) -> change_exist ev + | _ -> map_constr replace c in + (!metamap, replace c) + +module Metaset = Intset + +module Metamap = Intmap + +let meta_exists p s = Metaset.fold (fun x b -> (p x) || b) s false + +let metamap_in_dom x m = + try let _ = Metamap.find x m in true with Not_found -> false + +let metamap_to_list m = + Metamap.fold (fun n v l -> (n,v)::l) m [] + +let metamap_inv m b = + Metamap.fold (fun n v l -> if v = b then n::l else l) m [] + +type 'a freelisted = { + rebus : 'a; + freemetas : Metaset.t } + +(* collects all metavar occurences, in left-to-right order, preserving + * repetitions and all. *) + +let collect_metas c = + let rec collrec acc c = + match kind_of_term c with + | Meta mv -> mv::acc + | _ -> fold_constr collrec acc c + in + List.rev (collrec [] c) + +let metavars_of c = + let rec collrec acc c = + match kind_of_term c with + | Meta mv -> Metaset.add mv acc + | _ -> fold_constr collrec acc c + in + collrec Metaset.empty c + +let mk_freelisted c = + { rebus = c; freemetas = metavars_of c } + + +(* Clausal environments *) + +type clbinding = + | Cltyp of constr freelisted + | Clval of constr freelisted * constr freelisted + +type 'a clausenv = { + templval : constr freelisted; + templtyp : constr freelisted; + namenv : identifier Metamap.t; + env : clbinding Metamap.t; + hook : 'a } + +type wc = named_context sigma + + +(* [mentions clenv mv0 mv1] is true if mv1 is defined and mentions + * mv0, or if one of the free vars on mv1's freelist mentions + * mv0 *) + +let mentions clenv mv0 = + let rec menrec mv1 = + try + (match Metamap.find mv1 clenv.env with + | Clval (b,_) -> + Metaset.mem mv0 b.freemetas || meta_exists menrec b.freemetas + | Cltyp _ -> false) + with Not_found -> + false + in + menrec + +(* Creates a new clause-environment, whose template has a given + * type, CTY. This is not all that useful, since not very often + * does one know the type of the clause - one usually only has + * a clause which one wants to backchain thru. *) + +let mk_clenv wc cty = + let mv = new_meta () in + let cty_fls = mk_freelisted cty in + { templval = mk_freelisted (mkMeta mv); + templtyp = cty_fls; + namenv = Metamap.empty; + env = Metamap.add mv (Cltyp cty_fls) Metamap.empty ; + hook = wc } + +let clenv_environments bound c = + let rec clrec (ne,e,metas) n c = + match n, kind_of_term c with + | (Some 0, _) -> (ne, e, List.rev metas, c) + | (n, Cast (c,_)) -> clrec (ne,e,metas) n c + | (n, Prod (na,c1,c2)) -> + let mv = new_meta () in + let dep = dependent (mkRel 1) c2 in + let ne' = + if dep then + match na with + | Anonymous -> ne + | Name id -> + if metamap_in_dom mv ne then begin + warning ("Cannot put metavar "^(string_of_meta mv)^ + " in name-environment twice"); + ne + end else + Metamap.add mv id ne + else + ne + in + let e' = Metamap.add mv (Cltyp (mk_freelisted c1)) e in + clrec (ne',e', (mkMeta mv)::metas) (option_app ((+) (-1)) n) + (if dep then (subst1 (mkMeta mv) c2) else c2) + | (n, LetIn (na,b,_,c)) -> + clrec (ne,e,metas) (option_app ((+) (-1)) n) (subst1 b c) + | (n, _) -> (ne, e, List.rev metas, c) + in + clrec (Metamap.empty,Metamap.empty,[]) bound c + +let mk_clenv_from_n wc n (c,cty) = + let (namenv,env,args,concl) = clenv_environments n cty in + { templval = mk_freelisted (match args with [] -> c | _ -> applist (c,args)); + templtyp = mk_freelisted concl; + namenv = namenv; + env = env; + hook = wc } + +let mk_clenv_from wc = mk_clenv_from_n wc None + +let map_fl f cfl = { cfl with rebus=f cfl.rebus } + +let map_clb f = function + | Cltyp cfl -> Cltyp (map_fl f cfl) + | Clval (cfl1,cfl2) -> Clval (map_fl f cfl1,map_fl f cfl2) + +let subst_clenv f sub clenv = + { templval = map_fl (subst_mps sub) clenv.templval; + templtyp = map_fl (subst_mps sub) clenv.templtyp; + namenv = clenv.namenv; + env = Metamap.map (map_clb (subst_mps sub)) clenv.env; + hook = f sub clenv.hook } + +let connect_clenv wc clenv = { clenv with hook = wc } + +(* Was used in wcclausenv.ml +(* Changes the head of a clenv with (templ,templty) *) +let clenv_change_head (templ,templty) clenv = + { templval = mk_freelisted templ; + templtyp = mk_freelisted templty; + namenv = clenv.namenv; + env = clenv.env; + hook = clenv.hook } +*) + +let mk_clenv_hnf_constr_type_of wc t = + mk_clenv_from wc (t,w_hnf_constr wc (w_type_of wc t)) + +let mk_clenv_rename_from wc (c,t) = + mk_clenv_from wc (c,rename_bound_var (w_env wc) [] t) + +let mk_clenv_rename_from_n wc n (c,t) = + mk_clenv_from_n wc n (c,rename_bound_var (w_env wc) [] t) + +let mk_clenv_rename_type_of wc t = + mk_clenv_from wc (t,rename_bound_var (w_env wc) [] (w_type_of wc t)) + +let mk_clenv_rename_hnf_constr_type_of wc t = + mk_clenv_from wc + (t,rename_bound_var (w_env wc) [] (w_hnf_constr wc (w_type_of wc t))) + +let mk_clenv_type_of wc t = mk_clenv_from wc (t,w_type_of wc t) + +let clenv_assign mv rhs clenv = + let rhs_fls = mk_freelisted rhs in + if meta_exists (mentions clenv mv) rhs_fls.freemetas then + error "clenv__assign: circularity in unification"; + try + (match Metamap.find mv clenv.env with + | Clval (fls,ty) -> + if not (eq_constr fls.rebus rhs) then + try + (* Streams are lazy, force evaluation of id to catch Not_found*) + let id = Metamap.find mv clenv.namenv in + errorlabstrm "clenv_assign" + (str "An incompatible instantiation has already been found for " ++ + pr_id id) + with Not_found -> + anomaly "clenv_assign: non dependent metavar already assigned" + else + clenv + | Cltyp bty -> + { templval = clenv.templval; + templtyp = clenv.templtyp; + namenv = clenv.namenv; + env = Metamap.add mv (Clval (rhs_fls,bty)) clenv.env; + hook = clenv.hook }) + with Not_found -> + error "clenv_assign" + +let clenv_val_of clenv mv = + let rec valrec mv = + try + (match Metamap.find mv clenv.env with + | Cltyp _ -> mkMeta mv + | Clval(b,_) -> + instance (List.map (fun mv' -> (mv',valrec mv')) + (Metaset.elements b.freemetas)) b.rebus) + with Not_found -> + mkMeta mv + in + valrec mv + +let clenv_instance clenv b = + let c_sigma = + List.map + (fun mv -> (mv,clenv_val_of clenv mv)) (Metaset.elements b.freemetas) + in + instance c_sigma b.rebus + +let clenv_instance_term clenv c = + clenv_instance clenv (mk_freelisted c) + + +(* This function put casts around metavariables whose type could not be + * infered by the refiner, that is head of applications, predicates and + * subject of Cases. + * Does check that the casted type is closed. Anyway, the refiner would + * fail in this case... *) + +let clenv_cast_meta clenv = + let rec crec u = + match kind_of_term u with + | App _ | Case _ -> crec_hd u + | Cast (c,_) when isMeta c -> u + | _ -> map_constr crec u + + and crec_hd u = + match kind_of_term (strip_outer_cast u) with + | Meta mv -> + (try + match Metamap.find mv clenv.env with + | Cltyp b -> + let b' = clenv_instance clenv b in + if occur_meta b' then u else mkCast (mkMeta mv, b') + | Clval(_) -> u + with Not_found -> + u) + | App(f,args) -> mkApp (crec_hd f, Array.map crec args) + | Case(ci,p,c,br) -> + mkCase (ci, crec_hd p, crec_hd c, Array.map crec br) + | _ -> u + in + crec + + +(* [clenv_pose (na,mv,cty) clenv] + * returns a new clausenv which has added to it the metavar MV, + * with type CTY. the name NA, if it is not ANONYMOUS, will + * be entered into the name-map, as a way of accessing the new + * metavar. *) + +let clenv_pose (na,mv,cty) clenv = + { templval = clenv.templval; + templtyp = clenv.templtyp; + env = Metamap.add mv (Cltyp (mk_freelisted cty)) clenv.env; + namenv = (match na with + | Anonymous -> clenv.namenv + | Name id -> Metamap.add mv id clenv.namenv); + hook = clenv.hook } + +let clenv_defined clenv mv = + match Metamap.find mv clenv.env with + | Clval _ -> true + | Cltyp _ -> false + +let clenv_value clenv mv = + match Metamap.find mv clenv.env with + | Clval(b,_) -> b + | Cltyp _ -> failwith "clenv_value" + +let clenv_type clenv mv = + match Metamap.find mv clenv.env with + | Cltyp b -> b + | Clval(_,b) -> b + +let clenv_template clenv = clenv.templval + +let clenv_template_type clenv = clenv.templtyp + +let clenv_instance_value clenv mv = + clenv_instance clenv (clenv_value clenv mv) + +let clenv_instance_type clenv mv = + clenv_instance clenv (clenv_type clenv mv) + +let clenv_instance_template clenv = + clenv_instance clenv (clenv_template clenv) + +let clenv_instance_template_type clenv = + clenv_instance clenv (clenv_template_type clenv) + +let clenv_wtactic wt clenv = + { templval = clenv.templval; + templtyp = clenv.templtyp; + namenv = clenv.namenv; + env = clenv.env; + hook = wt clenv.hook } + +let clenv_type_of ce c = + let metamap = + List.map + (function + | (n,Clval(_,typ)) -> (n,typ.rebus) + | (n,Cltyp typ) -> (n,typ.rebus)) + (metamap_to_list ce.env) + in + Retyping.get_type_of_with_meta (w_env ce.hook) (w_Underlying ce.hook) metamap c + +let clenv_instance_type_of ce c = + clenv_instance ce (mk_freelisted (clenv_type_of ce c)) + + + +(* Unification à l'ordre 0 de m et n: [unify_0 mc wc m n] renvoie deux listes: + + metasubst:(int*constr)list récolte les instances des (Meta k) + evarsubst:(constr*constr)list récolte les instances des (Const "?k") + + Attention : pas d'unification entre les différences instances d'une + même meta ou evar, il peut rester des doublons *) + +(* Unification order: *) +(* Left to right: unifies first argument and then the other arguments *) +(*let unify_l2r x = List.rev x +(* Right to left: unifies last argument and then the other arguments *) +let unify_r2l x = x + +let sort_eqns = unify_r2l +*) + +let unify_0 cv_pb wc m n = + let env = w_env wc + and sigma = w_Underlying wc in + let trivial_unify pb substn m n = + if (not(occur_meta m)) & is_fconv pb env sigma m n then substn + else error_cannot_unify (m,n) in + let rec unirec_rec pb ((metasubst,evarsubst) as substn) m n = + let cM = Evarutil.whd_castappevar sigma m + and cN = Evarutil.whd_castappevar sigma n in + match (kind_of_term cM,kind_of_term cN) with + | Meta k1, Meta k2 -> + if k1 < k2 then (k1,cN)::metasubst,evarsubst + else if k1 = k2 then substn + else (k2,cM)::metasubst,evarsubst + | Meta k, _ -> (k,cN)::metasubst,evarsubst + | _, Meta k -> (k,cM)::metasubst,evarsubst + | Evar _, _ -> metasubst,((cM,cN)::evarsubst) + | _, Evar _ -> metasubst,((cN,cM)::evarsubst) + + | Lambda (_,t1,c1), Lambda (_,t2,c2) -> + unirec_rec CONV (unirec_rec CONV substn t1 t2) c1 c2 + | Prod (_,t1,c1), Prod (_,t2,c2) -> + unirec_rec pb (unirec_rec CONV substn t1 t2) c1 c2 + | LetIn (_,b,_,c), _ -> unirec_rec pb substn (subst1 b c) cN + | _, LetIn (_,b,_,c) -> unirec_rec pb substn cM (subst1 b c) + + | App (f1,l1), App (f2,l2) -> + let len1 = Array.length l1 + and len2 = Array.length l2 in + let (f1,l1,f2,l2) = + if len1 = len2 then (f1,l1,f2,l2) + else if len1 < len2 then + let extras,restl2 = array_chop (len2-len1) l2 in + (f1, l1, appvect (f2,extras), restl2) + else + let extras,restl1 = array_chop (len1-len2) l1 in + (appvect (f1,extras), restl1, f2, l2) in + (try + array_fold_left2 (unirec_rec CONV) + (unirec_rec CONV substn f1 f2) l1 l2 + with ex when catchable_exception ex -> + trivial_unify pb substn cM cN) + | Case (_,p1,c1,cl1), Case (_,p2,c2,cl2) -> + array_fold_left2 (unirec_rec CONV) + (unirec_rec CONV (unirec_rec CONV substn p1 p2) c1 c2) cl1 cl2 + + | _ -> trivial_unify pb substn cM cN + + in + if (not(occur_meta m)) & is_fconv cv_pb env sigma m n then + ([],[]) + else + let (mc,ec) = unirec_rec cv_pb ([],[]) m n in + ((*sort_eqns*) mc, (*sort_eqns*) ec) + + +(* Unification + * + * Procedure: + * (1) The function [unify mc wc M N] produces two lists: + * (a) a list of bindings Meta->RHS + * (b) a list of bindings EVAR->RHS + * + * The Meta->RHS bindings cannot themselves contain + * meta-vars, so they get applied eagerly to the other + * bindings. This may or may not close off all RHSs of + * the EVARs. For each EVAR whose RHS is closed off, + * we can just apply it, and go on. For each which + * is not closed off, we need to do a mimick step - + * in general, we have something like: + * + * ?X == (c e1 e2 ... ei[Meta(k)] ... en) + * + * so we need to do a mimick step, converting ?X + * into + * + * ?X -> (c ?z1 ... ?zn) + * + * of the proper types. Then, we can decompose the + * equation into + * + * ?z1 --> e1 + * ... + * ?zi --> ei[Meta(k)] + * ... + * ?zn --> en + * + * and keep on going. Whenever we find that a R.H.S. + * is closed, we can, as before, apply the constraint + * directly. Whenever we find an equation of the form: + * + * ?z -> Meta(n) + * + * we can reverse the equation, put it into our metavar + * substitution, and keep going. + * + * The most efficient mimick possible is, for each + * Meta-var remaining in the term, to declare a + * new EVAR of the same type. This is supposedly + * determinable from the clausale form context - + * we look up the metavar, take its type there, + * and apply the metavar substitution to it, to + * close it off. But this might not always work, + * since other metavars might also need to be resolved. *) + +let applyHead n c wc = + let rec apprec n c cty wc = + if n = 0 then + (wc,c) + else + match kind_of_term (w_whd_betadeltaiota wc cty) with + | Prod (_,c1,c2) -> + let evar = Evarutil.new_evar_in_sign (w_env wc) in + let (evar_n, _) = destEvar evar in + (compose + (apprec (n-1) (applist(c,[evar])) (subst1 evar c2)) + (w_Declare evar_n c1)) + wc + | _ -> error "Apply_Head_Then" + in + apprec n c (w_type_of wc c) wc + +let is_mimick_head f = + match kind_of_term f with + (Const _|Var _|Rel _|Construct _|Ind _) -> true + | _ -> false + +let rec mimick_evar hdc nargs sp wc = + let evd = Evd.map wc.sigma sp in + let wc' = extract_decl sp wc in + let (wc'', c) = applyHead nargs hdc wc' in + let (mc,ec) = unify_0 CONV wc'' (w_type_of wc'' c) (evd.evar_concl) in + let (wc''',_) = w_resrec mc ec wc'' in + if wc'== wc''' + then w_Define sp c wc + else + let wc'''' = restore_decl sp evd wc''' in + w_Define sp (Evarutil.nf_evar wc''''.sigma c) {it = wc.it ; sigma = wc''''.sigma} + +and w_Unify cv_pb m n wc = + let (mc',ec') = unify_0 cv_pb wc m n in + w_resrec mc' ec' wc + +and w_resrec metas evars wc = + match evars with + | [] -> (wc,metas) + + | (lhs,rhs) :: t -> + match kind_of_term rhs with + + | Meta k -> w_resrec ((k,lhs)::metas) t wc + + | krhs -> + match kind_of_term lhs with + + | Evar (evn,_) -> + if w_defined_evar wc evn then + let (wc',metas') = w_Unify CONV rhs lhs wc in + w_resrec (metas@metas') t wc' + else + (try + w_resrec metas t (w_Define evn rhs wc) + with ex when catchable_exception ex -> + (match krhs with + | App (f,cl) when is_mimick_head f -> + let wc' = mimick_evar f (Array.length cl) evn wc in + w_resrec metas evars wc' + | _ -> raise ex (*error "w_Unify" *))) + | _ -> anomaly "w_resrec" + + +(* [unifyTerms] et [unify] ne semble pas gérer les Meta, en + particulier ne semblent pas vérifier que des instances différentes + d'une même Meta sont compatibles. D'ailleurs le "fst" jette les metas + provenant de w_Unify. (Utilisé seulement dans prolog.ml) *) + +(* let unifyTerms m n = walking (fun wc -> fst (w_Unify CONV m n [] wc)) *) +let unifyTerms m n gls = + tclIDTAC {it = gls.it; + sigma = (get_gc (fst (w_Unify CONV m n (Refiner.project_with_focus gls))))} + +let unify m gls = + let n = pf_concl gls in unifyTerms m n gls + +(* [clenv_merge b metas evars clenv] merges common instances in metas + or in evars, possibly generating new unification problems; if [b] + is true, unification of types of metas is required *) + +let clenv_merge with_types metas evars clenv = + let ty_metas = ref [] in + let ty_evars = ref [] in + let rec clenv_resrec metas evars clenv = + match (evars,metas) with + | ([], []) -> clenv + + | ((lhs,rhs)::t, metas) -> + (match kind_of_term rhs with + + | Meta k -> clenv_resrec ((k,lhs)::metas) t clenv + + | krhs -> + (match kind_of_term lhs with + + | Evar (evn,_) -> + if w_defined_evar clenv.hook evn then + let (metas',evars') = unify_0 CONV clenv.hook rhs lhs in + clenv_resrec (metas'@metas) (evars'@t) clenv + else begin + let rhs' = + if occur_meta rhs then subst_meta metas rhs else rhs + in + if occur_evar evn rhs' then error "w_Unify"; + try + clenv_resrec metas t + (clenv_wtactic (w_Define evn rhs') clenv) + with ex when catchable_exception ex -> + (match krhs with + | App (f,cl) when is_mimick_head f -> + clenv_resrec metas evars + (clenv_wtactic + (mimick_evar f (Array.length cl) evn) + clenv) + | _ -> raise ex (********* error "w_Unify" *)) + end + + | _ -> anomaly "clenv_resrec")) + + | ([], (mv,n)::t) -> + if clenv_defined clenv mv then + let (metas',evars') = + unify_0 CONV clenv.hook (clenv_value clenv mv).rebus n in + clenv_resrec (metas'@t) evars' clenv + else + begin + if with_types (* or occur_meta mvty *) then + (let mvty = clenv_instance_type clenv mv in + try + let nty = clenv_type_of clenv + (clenv_instance clenv (mk_freelisted n)) in + let (mc,ec) = unify_0 CUMUL clenv.hook nty mvty in + ty_metas := mc @ !ty_metas; + ty_evars := ec @ !ty_evars + with e when Logic.catchable_exception e -> ()); + clenv_resrec t [] (clenv_assign mv n clenv) + end in + (* merge constraints *) + let clenv' = clenv_resrec metas evars clenv in + if with_types then + (* merge constraints about types: if they fail, don't worry *) + try clenv_resrec !ty_metas !ty_evars clenv' + with e when Logic.catchable_exception e -> clenv' + else clenv' + +(* [clenv_unify M N clenv] + performs a unification of M and N, generating a bunch of + unification constraints in the process. These constraints + are processed, one-by-one - they may either generate new + bindings, or, if there is already a binding, new unifications, + which themselves generate new constraints. This continues + until we get failure, or we run out of constraints. + [clenv_typed_unify M N clenv] expects in addition that expected + types of metavars are unifiable with the types of their instances *) + +let clenv_unify_core_0 with_types cv_pb m n clenv = + let (mc,ec) = unify_0 cv_pb clenv.hook m n in + clenv_merge with_types mc ec clenv + +let clenv_unify_0 = clenv_unify_core_0 false +let clenv_typed_unify = clenv_unify_core_0 true + + +(* takes a substitution s, an open term op and a closed term cl + try to find a subterm of cl which matches op, if op is just a Meta + FAIL because we cannot find a binding *) + +let iter_fail f a = + let n = Array.length a in + let rec ffail i = + if i = n then error "iter_fail" + else + try f a.(i) + with ex when catchable_exception ex -> ffail (i+1) + in ffail 0 + +(* Tries to find an instance of term [cl] in term [op]. + Unifies [cl] to every subterm of [op] until it finds a match. + Fails if no match is found *) +let unify_to_subterm clause (op,cl) = + let rec matchrec cl = + let cl = strip_outer_cast cl in + (try + if closed0 cl + then clenv_unify_0 CONV op cl clause,cl + else error "Bound 1" + with ex when catchable_exception ex -> + (match kind_of_term cl with + | App (f,args) -> + let n = Array.length args in + assert (n>0); + let c1 = mkApp (f,Array.sub args 0 (n-1)) in + let c2 = args.(n-1) in + (try + matchrec c1 + with ex when catchable_exception ex -> + matchrec c2) + | Case(_,_,c,lf) -> (* does not search in the predicate *) + (try + matchrec c + with ex when catchable_exception ex -> + iter_fail matchrec lf) + | LetIn(_,c1,_,c2) -> + (try + matchrec c1 + with ex when catchable_exception ex -> + matchrec c2) + + | Fix(_,(_,types,terms)) -> + (try + iter_fail matchrec types + with ex when catchable_exception ex -> + iter_fail matchrec terms) + + | CoFix(_,(_,types,terms)) -> + (try + iter_fail matchrec types + with ex when catchable_exception ex -> + iter_fail matchrec terms) + + | Prod (_,t,c) -> + (try + matchrec t + with ex when catchable_exception ex -> + matchrec c) + | Lambda (_,t,c) -> + (try + matchrec t + with ex when catchable_exception ex -> + matchrec c) + | _ -> error "Match_subterm")) + in + try matchrec cl + with ex when catchable_exception ex -> + raise (RefinerError (NoOccurrenceFound op)) + +let unify_to_subterm_list allow_K clause oplist t = + List.fold_right + (fun op (clause,l) -> + if isMeta op then + if allow_K then (clause,op::l) + else error "Match_subterm" + else if occur_meta op then + let (clause',cl) = + try + (* This is up to delta for subterms w/o metas ... *) + unify_to_subterm clause (strip_outer_cast op,t) + with RefinerError (NoOccurrenceFound _) when allow_K -> (clause,op) + in + (clause',cl::l) + else if not allow_K & not (dependent op t) then + (* This is not up to delta ... *) + raise (RefinerError (NoOccurrenceFound op)) + else + (clause,op::l)) + oplist + (clause,[]) + +let secondOrderAbstraction allow_K typ (p, oplist) clause = + let env = w_env clause.hook in + let sigma = w_Underlying clause.hook in + let (clause',cllist) = unify_to_subterm_list allow_K clause oplist typ in + let typp = clenv_instance_type clause' p in + let pred = abstract_list_all env sigma typp typ cllist in + clenv_unify_0 CONV (mkMeta p) pred clause' + +let clenv_unify2 allow_K cv_pb ty1 ty2 clause = + let c1, oplist1 = whd_stack ty1 in + let c2, oplist2 = whd_stack ty2 in + match kind_of_term c1, kind_of_term c2 with + | Meta p1, _ -> + (* Find the predicate *) + let clause' = + secondOrderAbstraction allow_K ty2 (p1,oplist1) clause in + (* Resume first order unification *) + clenv_unify_0 cv_pb (clenv_instance_term clause' ty1) ty2 clause' + | _, Meta p2 -> + (* Find the predicate *) + let clause' = + secondOrderAbstraction allow_K ty1 (p2, oplist2) clause in + (* Resume first order unification *) + clenv_unify_0 cv_pb ty1 (clenv_instance_term clause' ty2) clause' + | _ -> error "clenv_unify2" + + +(* The unique unification algorithm works like this: If the pattern is + flexible, and the goal has a lambda-abstraction at the head, then + we do a first-order unification. + + If the pattern is not flexible, then we do a first-order + unification, too. + + If the pattern is flexible, and the goal doesn't have a + lambda-abstraction head, then we second-order unification. *) + +(* We decide here if first-order or second-order unif is used for Apply *) +(* We apply a term of type (ai:Ai)C and try to solve a goal C' *) +(* The type C is in clenv.templtyp.rebus with a lot of Meta to solve *) + +(* 3-4-99 [HH] New fo/so choice heuristic : + In case we have to unify (Meta(1) args) with ([x:A]t args') + we first try second-order unification and if it fails first-order. + Before, second-order was used if the type of Meta(1) and [x:A]t was + convertible and first-order otherwise. But if failed if e.g. the type of + Meta(1) had meta-variables in it. *) +let clenv_unify allow_K cv_pb ty1 ty2 clenv = + let hd1,l1 = whd_stack ty1 in + let hd2,l2 = whd_stack ty2 in + match kind_of_term hd1, l1<>[], kind_of_term hd2, l2<>[] with + (* Pattern case *) + | (Meta _, true, Lambda _, _ | Lambda _, _, Meta _, true) + when List.length l1 = List.length l2 -> + (try + clenv_typed_unify cv_pb ty1 ty2 clenv + with ex when catchable_exception ex -> + try + clenv_unify2 allow_K cv_pb ty1 ty2 clenv + with RefinerError (NoOccurrenceFound c) as e -> raise e + | ex when catchable_exception ex -> + error "Cannot solve a second-order unification problem") + + (* Second order case *) + | (Meta _, true, _, _ | _, _, Meta _, true) -> + (try + clenv_unify2 allow_K cv_pb ty1 ty2 clenv + with RefinerError (NoOccurrenceFound c) as e -> raise e + | ex when catchable_exception ex -> + try + clenv_typed_unify cv_pb ty1 ty2 clenv + with ex when catchable_exception ex -> + error "Cannot solve a second-order unification problem") + + (* General case: try first order *) + | _ -> clenv_unify_0 cv_pb ty1 ty2 clenv + + +(* [clenv_bchain mv clenv' clenv] + * + * Resolves the value of "mv" (which must be undefined) in clenv to be + * the template of clenv' be the value "c", applied to "n" fresh + * metavars, whose types are chosen by destructing "clf", which should + * be a clausale forme generated from the type of "c". The process of + * resolution can cause unification of already-existing metavars, and + * of the fresh ones which get created. This operation is a composite + * of operations which pose new metavars, perform unification on + * terms, and make bindings. *) + +let clenv_bchain mv subclenv clenv = + (* Add the metavars of [subclenv] to [clenv], with their name-environment *) + let clenv' = + { templval = clenv.templval; + templtyp = clenv.templtyp; + namenv = + List.fold_left (fun ne (mv,id) -> + if clenv_defined subclenv mv then + ne + else if metamap_in_dom mv ne then begin + warning ("Cannot put metavar "^(string_of_meta mv)^ + " in name-environment twice"); + ne + end else + Metamap.add mv id ne) + clenv.namenv (metamap_to_list subclenv.namenv); + env = List.fold_left (fun m (n,v) -> Metamap.add n v m) + clenv.env (metamap_to_list subclenv.env); + hook = clenv.hook } + in + (* unify the type of the template of [subclenv] with the type of [mv] *) + let clenv'' = + clenv_unify true CUMUL + (clenv_instance clenv' (clenv_template_type subclenv)) + (clenv_instance_type clenv' mv) + clenv' + in + (* assign the metavar *) + let clenv''' = + clenv_assign mv (clenv_instance clenv' (clenv_template subclenv)) clenv'' + in + clenv''' + + +(* swaps the "hooks" in [clenv1] and [clenv2], so we can then use + backchain to hook them together *) + +let clenv_swap clenv1 clenv2 = + let clenv1' = { templval = clenv1.templval; + templtyp = clenv1.templtyp; + namenv = clenv1.namenv; + env = clenv1.env; + hook = clenv2.hook} + and clenv2' = { templval = clenv2.templval; + templtyp = clenv2.templtyp; + namenv = clenv2.namenv; + env = clenv2.env; + hook = clenv1.hook} + in + (clenv1',clenv2') + +let clenv_fchain mv nextclenv clenv = + let (clenv',nextclenv') = clenv_swap clenv nextclenv in + clenv_bchain mv clenv' nextclenv' + +let clenv_refine kONT clenv gls = + tclTHEN + (kONT clenv.hook) + (refine (clenv_instance_template clenv)) gls + +let clenv_refine_cast kONT clenv gls = + tclTHEN + (kONT clenv.hook) + (refine (clenv_cast_meta clenv (clenv_instance_template clenv))) + gls + +(* [clenv_metavars clenv mv] + * returns a list of the metavars which appear in the type of + * the metavar mv. The list is unordered. *) + +let clenv_metavars clenv mv = + match Metamap.find mv clenv.env with + | Clval(_,b) -> b.freemetas + | Cltyp b -> b.freemetas + +let clenv_template_metavars clenv = clenv.templval.freemetas + +(* [clenv_dependent hyps_only clenv] + * returns a list of the metavars which appear in the template of clenv, + * and which are dependent, This is computed by taking the metavars in cval, + * in right-to-left order, and collecting the metavars which appear + * in their types, and adding in all the metavars appearing in the + * type of clenv. + * If [hyps_only] then metavariables occurring in the type are _excluded_ *) + +let dependent_metas clenv mvs conclmetas = + List.fold_right + (fun mv deps -> + Metaset.union deps (clenv_metavars clenv mv)) + mvs conclmetas + +let clenv_dependent hyps_only clenv = + let mvs = collect_metas (clenv_instance_template clenv) in + let ctyp_mvs = metavars_of (clenv_instance_template_type clenv) in + let deps = dependent_metas clenv mvs ctyp_mvs in + List.filter + (fun mv -> Metaset.mem mv deps && not (hyps_only && Metaset.mem mv ctyp_mvs)) + mvs + +let clenv_missing c = clenv_dependent true c + +(* [clenv_independent clenv] + * returns a list of metavariables which appear in the term cval, + * and which are not dependent. That is, they do not appear in + * the types of other metavars which are in cval, nor in the type + * of cval, ctyp. *) + +let clenv_independent clenv = + let mvs = collect_metas (clenv_instance_template clenv) in + let ctyp_mvs = metavars_of (clenv_instance_template_type clenv) in + let deps = dependent_metas clenv mvs ctyp_mvs in + List.filter (fun mv -> not (Metaset.mem mv deps)) mvs + +let w_coerce wc c ctyp target = + let j = make_judge c ctyp in + let env = w_env wc in + let isevars = Evarutil.create_evar_defs (w_Underlying wc) in + let j' = Coercion.inh_conv_coerce_to dummy_loc env isevars j target in + (* faire quelque chose avec isevars ? *) + j'.uj_val + +let clenv_constrain_dep_args hyps_only clause = function + | [] -> clause + | mlist -> + let occlist = clenv_dependent hyps_only clause in + if List.length occlist = List.length mlist then + List.fold_left2 + (fun clenv k c -> + let wc = clause.hook in + try + let k_typ = w_hnf_constr wc (clenv_instance_type clause k) in + let c_typ = w_hnf_constr wc (w_type_of wc c) in + let c' = w_coerce wc c c_typ k_typ in + clenv_unify true CONV (mkMeta k) c' clenv + with _ -> + clenv_unify true CONV (mkMeta k) c clenv) + clause occlist mlist + else + error ("Not the right number of missing arguments (expected " + ^(string_of_int (List.length occlist))^")") + +let clenv_constrain_missing_args mlist clause = + clenv_constrain_dep_args true clause mlist + +let clenv_lookup_name clenv id = + match metamap_inv clenv.namenv id with + | [] -> + errorlabstrm "clenv_lookup_name" + (str"No such bound variable " ++ pr_id id) + | [n] -> + n + | _ -> + anomaly "clenv_lookup_name: a name occurs more than once in clause" + +let clenv_match_args s clause = + let mvs = clenv_independent clause in + let rec matchrec clause = function + | [] -> clause + | (loc,b,c)::t -> + let k = + match b with + | NamedHyp s -> + if List.exists (fun (_,b',_) -> b=b') t then + errorlabstrm "clenv_match_args" + (str "The variable " ++ pr_id s ++ + str " occurs more than once in binding") + else + clenv_lookup_name clause s + | AnonHyp n -> + if List.exists (fun (_,b',_) -> b=b') t then + errorlabstrm "clenv_match_args" + (str "The position " ++ int n ++ + str " occurs more than once in binding"); + try + List.nth mvs (n-1) + with (Failure _|Invalid_argument _) -> + errorlabstrm "clenv_match_args" (str "No such binder") + in + let k_typ = w_hnf_constr clause.hook (clenv_instance_type clause k) + (* nf_betaiota was before in type_of - useful to reduce types like *) + (* (x:A)([x]P u) *) + and c_typ = w_hnf_constr clause.hook + (nf_betaiota (w_type_of clause.hook c)) in + let cl = + (* Try to infer some Meta/Evar from the type of [c] *) + try + clenv_assign k c (clenv_unify true CUMUL c_typ k_typ clause) + with _ -> + (* Try to coerce to the type of [k]; cannot merge with the + previous case because Coercion does not handle Meta *) + let c' = w_coerce clause.hook c c_typ k_typ in + try clenv_unify true CONV (mkMeta k) c' clause + with RefinerError (CannotUnify (m,n)) -> + Stdpp.raise_with_loc loc + (RefinerError (CannotUnifyBindingType (m,n))) + in matchrec cl t + in + matchrec clause s + +type arg_bindings = (int * constr) list + +let clenv_constrain_with_bindings bl clause = + if bl = [] then + clause + else + let all_mvs = collect_metas (clenv_template clause).rebus in + let rec matchrec clause = function + | [] -> clause + | (n,c)::t -> + let k = + (try + if n > 0 then + List.nth all_mvs (n-1) + else if n < 0 then + List.nth (List.rev all_mvs) (-n-1) + else error "clenv_constrain_with_bindings" + with Failure _ -> + errorlabstrm "clenv_constrain_with_bindings" + (str"Clause did not have " ++ int n ++ str"-th" ++ + str" absolute argument")) in + let env = Global.env () in + let sigma = Evd.empty in + let k_typ = nf_betaiota (clenv_instance_type clause k) in + let c_typ = nf_betaiota (w_type_of clause.hook c) in + matchrec + (clenv_assign k c (clenv_unify true CUMUL c_typ k_typ clause)) t + in + matchrec clause bl + + +(* [clenv_pose_dependent_evars clenv] + * For each dependent evar in the clause-env which does not have a value, + * pose a value for it by constructing a fresh evar. We do this in + * left-to-right order, so that every evar's type is always closed w.r.t. + * metas. *) + +let clenv_pose_dependent_evars clenv = + let dep_mvs = clenv_dependent false clenv in + List.fold_left + (fun clenv mv -> + let evar = Evarutil.new_evar_in_sign (w_env clenv.hook) in + let (evar_n,_) = destEvar evar in + let tY = clenv_instance_type clenv mv in + let clenv' = clenv_wtactic (w_Declare evar_n tY) clenv in + clenv_assign mv evar clenv') + clenv + dep_mvs + +(***************************) + +let clenv_unique_resolver allow_K clause gl = + clenv_unify allow_K CUMUL + (clenv_instance_template_type clause) (pf_concl gl) clause + +let res_pf kONT clenv gls = + clenv_refine kONT (clenv_unique_resolver false clenv gls) gls + +let res_pf_cast kONT clenv gls = + clenv_refine_cast kONT (clenv_unique_resolver false clenv gls) gls + +let elim_res_pf kONT clenv allow_K gls = + clenv_refine_cast kONT (clenv_unique_resolver allow_K clenv gls) gls + +let elim_res_pf_THEN_i kONT clenv tac gls = + let clenv' = (clenv_unique_resolver true clenv gls) in + tclTHENLASTn (clenv_refine kONT clenv') (tac clenv') gls + +let e_res_pf kONT clenv gls = + clenv_refine kONT + (clenv_pose_dependent_evars (clenv_unique_resolver false clenv gls)) gls + +(* Clausal environment for an application *) + +let make_clenv_binding_gen n wc (c,t) = function + | ImplicitBindings largs -> + let clause = mk_clenv_from_n wc n (c,t) in + clenv_constrain_dep_args (n <> None) clause largs + | ExplicitBindings lbind -> + let clause = mk_clenv_rename_from_n wc n (c,t) in + clenv_match_args lbind clause + | NoBindings -> + mk_clenv_from_n wc n (c,t) + +let make_clenv_binding_apply wc n = make_clenv_binding_gen (Some n) wc +let make_clenv_binding = make_clenv_binding_gen None + +open Printer + +let pr_clenv clenv = + let pr_name mv = + try + let id = Metamap.find mv clenv.namenv in + (str"[" ++ pr_id id ++ str"]") + with Not_found -> (mt ()) + in + let pr_meta_binding = function + | (mv,Cltyp b) -> + hov 0 + (pr_meta mv ++ pr_name mv ++ str " : " ++ prterm b.rebus ++ fnl ()) + | (mv,Clval(b,_)) -> + hov 0 + (pr_meta mv ++ pr_name mv ++ str " := " ++ prterm b.rebus ++ fnl ()) + in + (str"TEMPL: " ++ prterm clenv.templval.rebus ++ + str" : " ++ prterm clenv.templtyp.rebus ++ fnl () ++ + (prlist pr_meta_binding (metamap_to_list clenv.env))) diff --git a/proofs/clenv.mli b/proofs/clenv.mli new file mode 100644 index 00000000..10e0004e --- /dev/null +++ b/proofs/clenv.mli @@ -0,0 +1,142 @@ +(************************************************************************) +(* v * The Coq Proof Assistant / The Coq Development Team *) +(* metavariable + +(* [exist_to_meta] generates new metavariables for each existential + and performs the replacement in the given constr *) +val exist_to_meta : + Evd.evar_map -> Pretyping.open_constr -> (Termops.metamap * constr) + +(* The Type of Constructions clausale environments. *) + +module Metaset : Set.S with type elt = metavariable + +module Metamap : Map.S with type key = metavariable + +type 'a freelisted = { + rebus : 'a; + freemetas : Metaset.t } + +type clbinding = + | Cltyp of constr freelisted + | Clval of constr freelisted * constr freelisted + +type 'a clausenv = { + templval : constr freelisted; + templtyp : constr freelisted; + namenv : identifier Metamap.t; + env : clbinding Metamap.t; + hook : 'a } + +type wc = named_context sigma (* for a better reading of the following *) + +(* [templval] is the template which we are trying to fill out. + * [templtyp] is its type. + * [namenv] is a mapping from metavar numbers to names, for + * use in instanciating metavars by name. + * [env] is the mapping from metavar numbers to their types + * and values. + * [hook] is the pointer to the current walking context, for + * integrating existential vars and metavars. *) + +val collect_metas : constr -> metavariable list +val mk_clenv : 'a -> constr -> 'a clausenv +val mk_clenv_from : 'a -> constr * constr -> 'a clausenv +val mk_clenv_from_n : 'a -> int option -> constr * constr -> 'a clausenv +val mk_clenv_rename_from : wc -> constr * constr -> wc clausenv +val mk_clenv_rename_from_n : wc -> int option -> constr * constr -> wc clausenv +val mk_clenv_hnf_constr_type_of : wc -> constr -> wc clausenv +val mk_clenv_type_of : wc -> constr -> wc clausenv + +val subst_clenv : (substitution -> 'a -> 'a) -> + substitution -> 'a clausenv -> 'a clausenv + +val connect_clenv : wc -> 'a clausenv -> wc clausenv +(*i Was used in wcclausenv.ml +val clenv_change_head : constr * constr -> 'a clausenv -> 'a clausenv +i*) +val clenv_assign : metavariable -> constr -> 'a clausenv -> 'a clausenv +val clenv_instance_term : wc clausenv -> constr -> constr +val clenv_pose : name * metavariable * constr -> 'a clausenv -> 'a clausenv +val clenv_template : 'a clausenv -> constr freelisted +val clenv_template_type : 'a clausenv -> constr freelisted +val clenv_instance_type : wc clausenv -> metavariable -> constr +val clenv_instance_template : wc clausenv -> constr +val clenv_instance_template_type : wc clausenv -> constr +val clenv_type_of : wc clausenv -> constr -> constr +val clenv_fchain : metavariable -> 'a clausenv -> wc clausenv -> wc clausenv +val clenv_bchain : metavariable -> 'a clausenv -> wc clausenv -> wc clausenv + +(* Unification with clenv *) +type arg_bindings = (int * constr) list + +val unify_0 : + Reductionops.conv_pb -> wc -> constr -> constr + -> Termops.metamap * (constr * constr) list +val clenv_unify : + bool -> Reductionops.conv_pb -> constr -> constr -> + wc clausenv -> wc clausenv +val clenv_match_args : + constr Rawterm.explicit_bindings -> wc clausenv -> wc clausenv +val clenv_constrain_with_bindings : arg_bindings -> wc clausenv -> wc clausenv + +(* Bindings *) +val clenv_independent : wc clausenv -> metavariable list +val clenv_missing : 'a clausenv -> metavariable list +val clenv_constrain_missing_args : (* Used in user contrib Lannion *) + constr list -> wc clausenv -> wc clausenv +(* +val clenv_constrain_dep_args : constr list -> wc clausenv -> wc clausenv +*) +val clenv_lookup_name : 'a clausenv -> identifier -> metavariable +val clenv_unique_resolver : bool -> wc clausenv -> goal sigma -> wc clausenv + +val make_clenv_binding_apply : + wc -> int -> constr * constr -> types Rawterm.bindings -> wc clausenv +val make_clenv_binding : + wc -> constr * constr -> types Rawterm.bindings -> wc clausenv + +(* Tactics *) +val unify : constr -> tactic +val clenv_refine : (wc -> tactic) -> wc clausenv -> tactic +val res_pf : (wc -> tactic) -> wc clausenv -> tactic +val res_pf_cast : (wc -> tactic) -> wc clausenv -> tactic +val elim_res_pf : (wc -> tactic) -> wc clausenv -> bool -> tactic +val e_res_pf : (wc -> tactic) -> wc clausenv -> tactic +val elim_res_pf_THEN_i : + (wc -> tactic) -> wc clausenv -> (wc clausenv -> tactic array) -> tactic + +(* Pretty-print *) +val pr_clenv : 'a clausenv -> Pp.std_ppcmds + +(* Exported for debugging *) +val unify_to_subterm : + wc clausenv -> constr * constr -> wc clausenv * constr +val unify_to_subterm_list : + bool -> wc clausenv -> constr list -> constr -> wc clausenv * constr list +val clenv_typed_unify : + Reductionops.conv_pb -> constr -> constr -> wc clausenv -> wc clausenv + +(*i This should be in another module i*) + +(* [abstract_list_all env sigma t c l] *) +(* abstracts the terms in l over c to get a term of type t *) +val abstract_list_all : + Environ.env -> Evd.evar_map -> constr -> constr -> constr list -> constr diff --git a/proofs/doc.tex b/proofs/doc.tex new file mode 100644 index 00000000..431027ef --- /dev/null +++ b/proofs/doc.tex @@ -0,0 +1,14 @@ + +\newpage +\section*{The Proof Engine} + +\ocwsection \label{proofs} +This chapter describes the \Coq\ proof engine, which is also called +the ``refiner'', since it provides a way to build terms by successive +refining steps. Those steps are either primitive rules or higher-level +tactics. +The modules of the proof engine are organized as follows. + +\bigskip +\begin{center}\epsfig{file=proofs.dep.ps,width=\linewidth}\end{center} + diff --git a/proofs/evar_refiner.ml b/proofs/evar_refiner.ml new file mode 100644 index 00000000..d59ff835 --- /dev/null +++ b/proofs/evar_refiner.ml @@ -0,0 +1,187 @@ +(************************************************************************) +(* v * The Coq Proof Assistant / The Coq Development Team *) +(* named_context sigma + +let startWalk gls = + let evc = project_with_focus gls in + (evc, + (fun wc' gls' -> + if not !Options.debug or (gls.it = gls'.it) then +(* if Intset.equal (get_lc gls.it) (get_focus (ids_it wc')) then*) + tclIDTAC {it=gls'.it; sigma = (get_gc wc')} +(* else + (local_Constraints (get_focus (ids_it wc')) + {it=gls'.it; sigma = get_gc (ids_it wc')})*) + else error "Walking")) + +let extract_decl sp evc = + let evdmap = evc.sigma in + let evd = Evd.map evdmap sp in + { it = evd.evar_hyps; + sigma = Evd.rmv evdmap sp } + +let restore_decl sp evd evc = + (rc_add evc (sp,evd)) + + +(* [w_Focusing sp wt wc] + * + * Focuses the walking context WC onto the declaration SP, given that + * this declaration is UNDEFINED. Then, it runs the walking_tactic, + * WT, on this new context. When the result is returned, we recover + * the resulting focus (access list) and restore it to SP's declaration. + * + * It is an error to cause SP to change state while we are focused on it. *) + +(* let w_Focusing_THEN sp (wt : 'a result_w_tactic) (wt' : 'a -> w_tactic) + (wc : named_context sigma) = + let hyps = wc.it + and evd = Evd.map wc.sigma sp in + let (wc' : named_context sigma) = extract_decl sp wc in + let (wc'',rslt) = wt wc' in +(* if not (ids_eq wc wc'') then error "w_saving_focus"; *) + if wc'==wc'' then + wt' rslt wc + else + let wc''' = restore_decl sp evd wc'' in + wt' rslt {it = hyps; sigma = wc'''.sigma} *) + +let w_add_sign (id,t) (wc : named_context sigma) = + { it = Sign.add_named_decl (id,None,t) wc.it; + sigma = wc.sigma } + +let w_Focus sp wc = extract_decl sp wc + +let w_Underlying wc = wc.sigma +let w_whd wc c = Evarutil.whd_castappevar (w_Underlying wc) c +let w_type_of wc c = + type_of (Global.env_of_context wc.it) wc.sigma c +let w_env wc = get_env wc +let w_hyps wc = named_context (get_env wc) +let w_defined_evar wc k = Evd.is_defined (w_Underlying wc) k +let w_const_value wc = constant_value (w_env wc) +let w_conv_x wc m n = is_conv (w_env wc) (w_Underlying wc) m n +let w_whd_betadeltaiota wc c = whd_betadeltaiota (w_env wc) (w_Underlying wc) c +let w_hnf_constr wc c = hnf_constr (w_env wc) (w_Underlying wc) c + + +let w_Declare sp ty (wc : named_context sigma) = + let _ = w_type_of wc ty in (* Utile ?? *) + let sign = get_hyps wc in + let newdecl = mk_goal sign ty in + ((rc_add wc (sp,newdecl)): named_context sigma) + +let w_Define sp c wc = + let spdecl = Evd.map (w_Underlying wc) sp in + let cty = + try + w_type_of (w_Focus sp wc) (mkCast (c,spdecl.evar_concl)) + with + Not_found -> error "Instantiation contains unlegal variables" + | (Type_errors.TypeError (e, Type_errors.UnboundVar v))-> + errorlabstrm "w_Define" + (str "Cannot use variable " ++ pr_id v ++ str " to define " ++ + str (string_of_existential sp)) + in + match spdecl.evar_body with + | Evar_empty -> + let spdecl' = { evar_hyps = spdecl.evar_hyps; + evar_concl = spdecl.evar_concl; + evar_body = Evar_defined c } + in + Proof_trees.rc_add wc (sp,spdecl') + | _ -> error "define_evar" + + +(******************************************) +(* Instantiation of existential variables *) +(******************************************) + +(* The instantiate tactic *) + +let evars_of evc c = + let rec evrec acc c = + match kind_of_term c with + | Evar (n, _) when Evd.in_dom evc n -> c :: acc + | _ -> fold_constr evrec acc c + in + evrec [] c + +let instantiate n c ido gl = + let wc = Refiner.project_with_focus gl in + let evl = + match ido with + None -> evars_of wc.sigma gl.it.evar_concl + | Some (id,_,_) -> + let (_,_,typ)=Sign.lookup_named id gl.it.evar_hyps in + evars_of wc.sigma typ in + if List.length evl < n then error "not enough evars"; + let (n,_) as k = destEvar (List.nth evl (n-1)) in + if Evd.is_defined wc.sigma n then + error "Instantiate called on already-defined evar"; + let wc' = w_Define n c wc in + tclIDTAC {it = gl.it ; sigma = wc'.sigma} + +let pfic gls c = + let evc = gls.sigma in + Constrintern.interp_constr evc (Global.env_of_context gls.it.evar_hyps) c + +(* +let instantiate_tac = function + | [Integer n; Command com] -> + (fun gl -> instantiate n (pfic gl com) gl) + | [Integer n; Constr c] -> + (fun gl -> instantiate n c gl) + | _ -> invalid_arg "Instantiate called with bad arguments" +*) + +(* vernac command existential *) + +let instantiate_pf_com n com pfts = + let gls = top_goal_of_pftreestate pfts in + let wc = project_with_focus gls in + let sigma = (w_Underlying wc) in + let (sp,evd) = + try + List.nth (Evd.non_instantiated sigma) (n-1) + with Failure _ -> + error "not so many uninstantiated existential variables" + in + let c = Constrintern.interp_constr sigma (Evarutil.evar_env evd) com in + let wc' = w_Define sp c wc in + let newgc = (w_Underlying wc') in + change_constraints_pftreestate newgc pfts + + diff --git a/proofs/evar_refiner.mli b/proofs/evar_refiner.mli new file mode 100644 index 00000000..d7f393b3 --- /dev/null +++ b/proofs/evar_refiner.mli @@ -0,0 +1,57 @@ +(************************************************************************) +(* v * The Coq Proof Assistant / The Coq Development Team *) +(* wc +val rc_of_glsigma : goal sigma -> wc + +(* A [w_tactic] is a tactic which modifies the a set of evars of which + a goal depend, either by instantiating one, or by declaring a new + dependent goal *) +type w_tactic = wc -> wc + +val startWalk : goal sigma -> wc * (wc -> tactic) + +val extract_decl : evar -> w_tactic +val restore_decl : evar -> evar_info -> w_tactic +val w_Declare : evar -> types -> w_tactic +val w_Define : evar -> constr -> w_tactic + +val w_Underlying : wc -> evar_map +val w_env : wc -> env +val w_hyps : wc -> named_context +val w_whd : wc -> constr -> constr +val w_type_of : wc -> constr -> constr +val w_add_sign : (identifier * types) -> w_tactic + +val w_whd_betadeltaiota : wc -> constr -> constr +val w_hnf_constr : wc -> constr -> constr +val w_conv_x : wc -> constr -> constr -> bool +val w_const_value : wc -> constant -> constr +val w_defined_evar : wc -> existential_key -> bool + +val instantiate : int -> constr -> identifier Tacexpr.gsimple_clause -> tactic +(* +val instantiate_tac : tactic_arg list -> tactic +*) +val instantiate_pf_com : int -> Topconstr.constr_expr -> pftreestate -> pftreestate diff --git a/proofs/logic.ml b/proofs/logic.ml new file mode 100644 index 00000000..3cc44a0f --- /dev/null +++ b/proofs/logic.ml @@ -0,0 +1,786 @@ +(************************************************************************) +(* v * The Coq Proof Assistant / The Coq Development Team *) +(* true + | _ -> false + +let error_cannot_unify (m,n) = + raise (RefinerError (CannotUnify (m,n))) + +(* Tells if the refiner should check that the submitted rules do not + produce invalid subgoals *) +let check = ref false + +let without_check tac gl = + let c = !check in + check := false; + let r = tac gl in + check := c; + r + +let with_check tac gl = + let c = !check in + check := true; + let r = tac gl in + check := c; + r + +(************************************************************************) +(************************************************************************) +(* Implementation of the structural rules (moving and deleting + hypotheses around) *) + +let check_clear_forward cleared_ids used_ids whatfor = + if !check && cleared_ids<>[] then + Idset.iter + (fun id' -> + if List.mem id' cleared_ids then + error (string_of_id id'^" is used in "^whatfor)) + used_ids + +(* The Clear tactic: it scans the context for hypotheses to be removed + (instead of iterating on the list of identifier to be removed, which + forces the user to give them in order). *) +let clear_hyps ids gl = + let env = Global.env() in + let (nhyps,rmv) = + Sign.fold_named_context + (fun (id,c,ty as d) (hyps,rmv) -> + if List.mem id ids then + (hyps,id::rmv) + else begin + check_clear_forward rmv (global_vars_set_of_decl env d) + ("hypothesis "^string_of_id id); + (add_named_decl d hyps, rmv) + end) + gl.evar_hyps + ~init:(empty_named_context,[]) in + let ncl = gl.evar_concl in + check_clear_forward rmv (global_vars_set env ncl) "conclusion"; + mk_goal nhyps ncl + +(* The ClearBody tactic *) + +(* [apply_to_hyp sign id f] splits [sign] into [tail::[id,_,_]::head] and + returns [tail::(f head (id,_,_) tail)] *) +let apply_to_hyp sign id f = + let found = ref false in + let sign' = + fold_named_context_both_sides + (fun head (idc,c,ct as d) tail -> + if idc = id then begin + found := true; f head d tail + end else + add_named_decl d head) + sign ~init:empty_named_context + in + if (not !check) || !found then sign' else error "No such assumption" + +(* Same but with whole environment *) +let apply_to_hyp2 env id f = + let found = ref false in + let env' = + fold_named_context_both_sides + (fun env (idc,c,ct as d) tail -> + if idc = id then begin + found := true; f env d tail + end else + push_named d env) + (named_context env) ~init:(reset_context env) + in + if (not !check) || !found then env' else error "No such assumption" + +let apply_to_hyp_and_dependent_on sign id f g = + let found = ref false in + let sign = + Sign.fold_named_context + (fun (idc,_,_ as d) oldest -> + if idc = id then (found := true; add_named_decl (f d) oldest) + else if !found then add_named_decl (g d) oldest + else add_named_decl d oldest) + sign ~init:empty_named_context + in + if (not !check) || !found then sign else error "No such assumption" + +let check_typability env sigma c = + if !check then let _ = type_of env sigma c in () + +let recheck_typability (what,id) env sigma t = + try check_typability env sigma t + with _ -> + let s = match what with + | None -> "the conclusion" + | Some id -> "hypothesis "^(string_of_id id) in + error + ("The correctness of "^s^" relies on the body of "^(string_of_id id)) + +let remove_hyp_body env sigma id = + apply_to_hyp2 env id + (fun env (_,c,t) tail -> + match c with + | None -> error ((string_of_id id)^" is not a local definition") + | Some c -> + let env' = push_named (id,None,t) env in + if !check then + ignore + (Sign.fold_named_context + (fun (id',c,t as d) env'' -> + (match c with + | None -> + recheck_typability (Some id',id) env'' sigma t + | Some b -> + let b' = mkCast (b,t) in + recheck_typability (Some id',id) env'' sigma b'); + push_named d env'') + (List.rev tail) ~init:env'); + env') + + +(* Auxiliary functions for primitive MOVE tactic + * + * [move_after with_dep toleft (left,(hfrom,typfrom),right) hto] moves + * hyp [hfrom] just after the hyp [hto] which belongs to the hyps on the + * left side [left] of the full signature if [toleft=true] or to the hyps + * on the right side [right] if [toleft=false]. + * If [with_dep] then dependent hypotheses are moved accordingly. *) + +let split_sign hfrom hto l = + let rec splitrec left toleft = function + | [] -> error ("No such hypothesis : " ^ (string_of_id hfrom)) + | (hyp,c,typ) as d :: right -> + if hyp = hfrom then + (left,right,d,toleft) + else + splitrec (d::left) (toleft or (hyp = hto)) right + in + splitrec [] false l + +let move_after with_dep toleft (left,(idfrom,_,_ as declfrom),right) hto = + let env = Global.env() in + let test_dep (hyp,c,typ as d) (hyp2,c,typ2 as d2) = + if toleft + then occur_var_in_decl env hyp2 d + else occur_var_in_decl env hyp d2 + in + let rec moverec first middle = function + | [] -> error ("No such hypothesis : " ^ (string_of_id hto)) + | (hyp,_,_) as d :: right -> + let (first',middle') = + if List.exists (test_dep d) middle then + if with_dep & (hyp <> hto) then + (first, d::middle) + else + error + ("Cannot move "^(string_of_id idfrom)^" after " + ^(string_of_id hto) + ^(if toleft then ": it occurs in " else ": it depends on ") + ^(string_of_id hyp)) + else + (d::first, middle) + in + if hyp = hto then + (List.rev first')@(List.rev middle')@right + else + moverec first' middle' right + in + if toleft then + List.rev_append (moverec [] [declfrom] left) right + else + List.rev_append left (moverec [] [declfrom] right) + +let check_backward_dependencies sign d = + if not (Idset.for_all + (fun id -> mem_named_context id sign) + (global_vars_set_of_decl (Global.env()) d)) + then + error "Can't introduce at that location: free variable conflict" + + +let check_forward_dependencies id tail = + let env = Global.env() in + List.iter + (function (id',_,_ as decl) -> + if occur_var_in_decl env id decl then + error ((string_of_id id) ^ " is used in hypothesis " + ^ (string_of_id id'))) + tail + + +let rename_hyp id1 id2 sign = + apply_to_hyp_and_dependent_on sign id1 + (fun (_,b,t) -> (id2,b,t)) + (map_named_declaration (replace_vars [id1,mkVar id2])) + +let replace_hyp sign id d = + apply_to_hyp sign id + (fun sign _ tail -> + if !check then + (check_backward_dependencies sign d; + check_forward_dependencies id tail); + add_named_decl d sign) + +let insert_after_hyp sign id d = + apply_to_hyp sign id + (fun sign d' _ -> + if !check then check_backward_dependencies sign d; + add_named_decl d (add_named_decl d' sign)) + +(************************************************************************) +(************************************************************************) +(* Implementation of the logical rules *) + +(* Will only be used on terms given to the Refine rule which have meta +variables only in Application and Case *) + +let collect_meta_variables c = + let rec collrec acc c = match kind_of_term c with + | Meta mv -> mv::acc + | Cast(c,_) -> collrec acc c + | (App _| Case _) -> fold_constr collrec acc c + | _ -> acc + in + List.rev(collrec [] c) + +let check_conv_leq_goal env sigma arg ty conclty = + if !check & not (is_conv_leq env sigma ty conclty) then + raise (RefinerError (BadType (arg,ty,conclty))) + +let goal_type_of env sigma c = + (if !check then type_of else Retyping.get_type_of) env sigma c + +let rec mk_refgoals sigma goal goalacc conclty trm = + let env = evar_env goal in + let hyps = goal.evar_hyps in +(* + if not (occur_meta trm) then + let t'ty = (unsafe_machine env sigma trm).uj_type in + let _ = conv_leq_goal env sigma trm t'ty conclty in + (goalacc,t'ty) + else +*) + match kind_of_term trm with + | Meta _ -> + if occur_meta conclty then + raise (RefinerError (OccurMetaGoal conclty)); + (mk_goal hyps (nf_betaiota conclty))::goalacc, conclty + + | Cast (t,ty) -> + check_typability env sigma ty; + check_conv_leq_goal env sigma trm ty conclty; + mk_refgoals sigma goal goalacc ty t + + | App (f,l) -> + let (acc',hdty) = mk_hdgoals sigma goal goalacc f in + let (acc'',conclty') = + mk_arggoals sigma goal acc' hdty (Array.to_list l) in + check_conv_leq_goal env sigma trm conclty' conclty; + (acc'',conclty') + + | Case (_,p,c,lf) -> + let (acc',lbrty,conclty') = mk_casegoals sigma goal goalacc p c in + check_conv_leq_goal env sigma trm conclty' conclty; + let acc'' = + array_fold_left2 + (fun lacc ty fi -> fst (mk_refgoals sigma goal lacc ty fi)) + acc' lbrty lf + in + (acc'',conclty') + + | _ -> + if occur_meta trm then raise (RefinerError (OccurMeta trm)); + let t'ty = goal_type_of env sigma trm in + check_conv_leq_goal env sigma trm t'ty conclty; + (goalacc,t'ty) + +(* Same as mkREFGOALS but without knowing te type of the term. Therefore, + * Metas should be casted. *) + +and mk_hdgoals sigma goal goalacc trm = + let env = evar_env goal in + let hyps = goal.evar_hyps in + match kind_of_term trm with + | Cast (c,ty) when isMeta c -> + check_typability env sigma ty; + (mk_goal hyps (nf_betaiota ty))::goalacc,ty + + | App (f,l) -> + let (acc',hdty) = mk_hdgoals sigma goal goalacc f in + mk_arggoals sigma goal acc' hdty (Array.to_list l) + + | Case (_,p,c,lf) -> + let (acc',lbrty,conclty') = mk_casegoals sigma goal goalacc p c in + let acc'' = + array_fold_left2 + (fun lacc ty fi -> fst (mk_refgoals sigma goal lacc ty fi)) + acc' lbrty lf + in + (acc'',conclty') + + | _ -> goalacc, goal_type_of env sigma trm + +and mk_arggoals sigma goal goalacc funty = function + | [] -> goalacc,funty + | harg::tlargs as allargs -> + let t = whd_betadeltaiota (evar_env goal) sigma funty in + match kind_of_term t with + | Prod (_,c1,b) -> + let (acc',hargty) = mk_refgoals sigma goal goalacc c1 harg in + mk_arggoals sigma goal acc' (subst1 harg b) tlargs + | LetIn (_,c1,_,b) -> + mk_arggoals sigma goal goalacc (subst1 c1 b) allargs + | _ -> raise (RefinerError (CannotApply (t,harg))) + +and mk_casegoals sigma goal goalacc p c = + let env = evar_env goal in + let (acc',ct) = mk_hdgoals sigma goal goalacc c in + let (acc'',pt) = mk_hdgoals sigma goal acc' p in + let pj = {uj_val=p; uj_type=pt} in + let indspec = + try find_mrectype env sigma ct + with Not_found -> anomaly "mk_casegoals" in + let (lbrty,conclty) = + type_case_branches_with_names env indspec pj c in + (acc'',lbrty,conclty) + + +let error_use_instantiate () = + errorlabstrm "Logic.prim_refiner" + (str"cannot intro when there are open metavars in the domain type" ++ + spc () ++ str"- use Instantiate") + +let convert_hyp sign sigma (id,b,bt as d) = + apply_to_hyp sign id + (fun sign (_,c,ct) _ -> + let env = Global.env_of_context sign in + if !check && not (is_conv env sigma bt ct) && + not (option_compare (is_conv env sigma) b c) then + error "convert-hyp rule passed non-converting term"; + add_named_decl d sign) + + +(************************************************************************) +(************************************************************************) +(* Primitive tactics are handled here *) + +let prim_refiner r sigma goal = + let env = evar_env goal in + let sign = goal.evar_hyps in + let cl = goal.evar_concl in + match r with + (* Logical rules *) + | Intro id -> + if !check && mem_named_context id sign then + error "New variable is already declared"; + (match kind_of_term (strip_outer_cast cl) with + | Prod (_,c1,b) -> + if occur_meta c1 then error_use_instantiate(); + let sg = mk_goal (add_named_decl (id,None,c1) sign) + (subst1 (mkVar id) b) in + [sg] + | LetIn (_,c1,t1,b) -> + if occur_meta c1 or occur_meta t1 then error_use_instantiate(); + let sg = + mk_goal (add_named_decl (id,Some c1,t1) sign) + (subst1 (mkVar id) b) in + [sg] + | _ -> + raise (RefinerError IntroNeedsProduct)) + + | Intro_replacing id -> + (match kind_of_term (strip_outer_cast cl) with + | Prod (_,c1,b) -> + if occur_meta c1 then error_use_instantiate(); + let sign' = replace_hyp sign id (id,None,c1) in + let sg = mk_goal sign' (subst1 (mkVar id) b) in + [sg] + | LetIn (_,c1,t1,b) -> + if occur_meta c1 then error_use_instantiate(); + let sign' = replace_hyp sign id (id,Some c1,t1) in + let sg = mk_goal sign' (subst1 (mkVar id) b) in + [sg] + | _ -> + raise (RefinerError IntroNeedsProduct)) + + | Cut (b,id,t) -> + if !check && mem_named_context id sign then + error "New variable is already declared"; + if occur_meta t then error_use_instantiate(); + let sg1 = mk_goal sign (nf_betaiota t) in + let sg2 = mk_goal (add_named_decl (id,None,t) sign) cl in + if b then [sg1;sg2] else [sg2;sg1] + + | FixRule (f,n,rest) -> + let rec check_ind env k cl = + match kind_of_term (strip_outer_cast cl) with + | Prod (na,c1,b) -> + if k = 1 then + try + fst (find_inductive env sigma c1) + with Not_found -> + error "cannot do a fixpoint on a non inductive type" + else + check_ind (push_rel (na,None,c1) env) (k-1) b + | _ -> error "not enough products" + in + let (sp,_) = check_ind env n cl in + let all = (f,n,cl)::rest in + let rec mk_sign sign = function + | (f,n,ar)::oth -> + let (sp',_) = check_ind env n ar in + if not (sp=sp') then + error ("fixpoints should be on the same " ^ + "mutual inductive declaration"); + if !check && mem_named_context f sign then + error "name already used in the environment"; + mk_sign (add_named_decl (f,None,ar) sign) oth + | [] -> + List.map (fun (_,_,c) -> mk_goal sign c) all + in + mk_sign sign all + + | Cofix (f,others) -> + let rec check_is_coind env cl = + let b = whd_betadeltaiota env sigma cl in + match kind_of_term b with + | Prod (na,c1,b) -> check_is_coind (push_rel (na,None,c1) env) b + | _ -> + try + let _ = find_coinductive env sigma b in () + with Not_found -> + error ("All methods must construct elements " ^ + "in coinductive types") + in + let all = (f,cl)::others in + List.iter (fun (_,c) -> check_is_coind env c) all; + let rec mk_sign sign = function + | (f,ar)::oth -> + (try + (let _ = Sign.lookup_named f sign in + error "name already used in the environment") + with + | Not_found -> + mk_sign (add_named_decl (f,None,ar) sign) oth) + | [] -> List.map (fun (_,c) -> mk_goal sign c) all + in + mk_sign sign all + + | Refine c -> + if not (list_distinct (collect_meta_variables c)) then + raise (RefinerError (NonLinearProof c)); + let (sgl,cl') = mk_refgoals sigma goal [] cl c in + let sgl = List.rev sgl in + sgl + + (* Conversion rules *) + | Convert_concl cl' -> + check_typability env sigma cl'; + if (not !check) || is_conv_leq env sigma cl' cl then + let sg = mk_goal sign cl' in + [sg] + else + error "convert-concl rule passed non-converting term" + + | Convert_hyp (id,copt,ty) -> + [mk_goal (convert_hyp sign sigma (id,copt,ty)) cl] + + (* And now the structural rules *) + | Thin ids -> + [clear_hyps ids goal] + + | ThinBody ids -> + let clear_aux env id = + let env' = remove_hyp_body env sigma id in + if !check then recheck_typability (None,id) env' sigma cl; + env' + in + let sign' = named_context (List.fold_left clear_aux env ids) in + let sg = mk_goal sign' cl in + [sg] + + | Move (withdep, hfrom, hto) -> + let (left,right,declfrom,toleft) = split_sign hfrom hto sign in + let hyps' = + move_after withdep toleft (left,declfrom,right) hto in + [mk_goal hyps' cl] + + | Rename (id1,id2) -> + if !check & id1 <> id2 & List.mem id2 (ids_of_named_context sign) then + error ((string_of_id id2)^" is already used"); + let sign' = rename_hyp id1 id2 sign in + let cl' = replace_vars [id1,mkVar id2] cl in + [mk_goal sign' cl'] + +(************************************************************************) +(************************************************************************) +(* Extracting a proof term from the proof tree *) + +(* Util *) +let rec rebind id1 id2 = function + | [] -> [] + | id::l -> + if id = id1 then id2::l else + let l' = rebind id1 id2 l in + if id = id2 then + (* TODO: find a more elegant way to hide a variable *) + (id_of_string "_@")::l' + else id::l' + +let prim_extractor subfun vl pft = + let cl = pft.goal.evar_concl in + match pft.ref with + | Some (Prim (Intro id), [spf]) -> + (match kind_of_term (strip_outer_cast cl) with + | Prod (_,ty,_) -> + let cty = subst_vars vl ty in + mkLambda (Name id, cty, subfun (id::vl) spf) + | LetIn (_,b,ty,_) -> + let cb = subst_vars vl b in + let cty = subst_vars vl ty in + mkLetIn (Name id, cb, cty, subfun (id::vl) spf) + | _ -> error "incomplete proof!") + + | Some (Prim (Intro_replacing id),[spf]) -> + (match kind_of_term (strip_outer_cast cl) with + | Prod (_,ty,_) -> + let cty = subst_vars vl ty in + mkLambda (Name id, cty, subfun (id::vl) spf) + | LetIn (_,b,ty,_) -> + let cb = subst_vars vl b in + let cty = subst_vars vl ty in + mkLetIn (Name id, cb, cty, subfun (id::vl) spf) + | _ -> error "incomplete proof!") + + | Some (Prim (Cut (b,id,t)),[spf1;spf2]) -> + let spf1, spf2 = if b then spf1, spf2 else spf2, spf1 in + mkLetIn (Name id,subfun vl spf1,subst_vars vl t,subfun (id::vl) spf2) + + | Some (Prim (FixRule (f,n,others)),spfl) -> + let all = Array.of_list ((f,n,cl)::others) in + let lcty = Array.map (fun (_,_,ar) -> subst_vars vl ar) all in + let names = Array.map (fun (f,_,_) -> Name f) all in + let vn = Array.map (fun (_,n,_) -> n-1) all in + let newvl = List.fold_left (fun vl (id,_,_)->(id::vl)) (f::vl)others in + let lfix = Array.map (subfun newvl) (Array.of_list spfl) in + mkFix ((vn,0),(names,lcty,lfix)) + + | Some (Prim (Cofix (f,others)),spfl) -> + let all = Array.of_list ((f,cl)::others) in + let lcty = Array.map (fun (_,ar) -> subst_vars vl ar) all in + let names = Array.map (fun (f,_) -> Name f) all in + let newvl = List.fold_left (fun vl (id,_)->(id::vl)) (f::vl) others in + let lfix = Array.map (subfun newvl) (Array.of_list spfl) in + mkCoFix (0,(names,lcty,lfix)) + + | Some (Prim (Refine c),spfl) -> + let mvl = collect_meta_variables c in + let metamap = List.combine mvl (List.map (subfun vl) spfl) in + let cc = subst_vars vl c in + plain_instance metamap cc + + (* Structural and conversion rules do not produce any proof *) + | Some (Prim (Convert_concl _),[pf]) -> + subfun vl pf + + | Some (Prim (Convert_hyp _),[pf]) -> + subfun vl pf + + | Some (Prim (Thin _),[pf]) -> + (* No need to make ids Anonymous in vl: subst_vars take the more recent *) + subfun vl pf + + | Some (Prim (ThinBody _),[pf]) -> + subfun vl pf + + | Some (Prim (Move _),[pf]) -> + subfun vl pf + + | Some (Prim (Rename (id1,id2)),[pf]) -> + subfun (rebind id1 id2 vl) pf + + | Some _ -> anomaly "prim_extractor" + + | None-> error "prim_extractor handed incomplete proof" + +(* Pretty-printer *) + +open Printer + +let prterm x = prterm_env (Global.env()) x + +let pr_prim_rule_v7 = function + | Intro id -> + str"Intro " ++ pr_id id + + | Intro_replacing id -> + (str"intro replacing " ++ pr_id id) + + | Cut (b,id,t) -> + if b then + (str"Assert " ++ prterm t) + else + (str"Cut " ++ prterm t ++ str ";[Intro " ++ pr_id id ++ str "|Idtac]") + + | FixRule (f,n,[]) -> + (str"Fix " ++ pr_id f ++ str"/" ++ int n) + + | FixRule (f,n,others) -> + let rec print_mut = function + | (f,n,ar)::oth -> + pr_id f ++ str"/" ++ int n ++ str" : " ++ prterm ar ++ print_mut oth + | [] -> mt () in + (str"Fix " ++ pr_id f ++ str"/" ++ int n ++ + str" with " ++ print_mut others) + + | Cofix (f,[]) -> + (str"Cofix " ++ pr_id f) + + | Cofix (f,others) -> + let rec print_mut = function + | (f,ar)::oth -> + (pr_id f ++ str" : " ++ prterm ar ++ print_mut oth) + | [] -> mt () in + (str"Cofix " ++ pr_id f ++ str" with " ++ print_mut others) + + | Refine c -> + str(if occur_meta c then "Refine " else "Exact ") ++ + Constrextern.with_meta_as_hole prterm c + + | Convert_concl c -> + (str"Change " ++ prterm c) + + | Convert_hyp (id,None,t) -> + (str"Change " ++ prterm t ++ spc () ++ str"in " ++ pr_id id) + + | Convert_hyp (id,Some c,t) -> + (str"Change " ++ prterm c ++ spc () ++ str"in " + ++ pr_id id ++ str" (Type of " ++ pr_id id ++ str ")") + + | Thin ids -> + (str"Clear " ++ prlist_with_sep pr_spc pr_id ids) + + | ThinBody ids -> + (str"ClearBody " ++ prlist_with_sep pr_spc pr_id ids) + + | Move (withdep,id1,id2) -> + (str (if withdep then "Dependent " else "") ++ + str"Move " ++ pr_id id1 ++ str " after " ++ pr_id id2) + + | Rename (id1,id2) -> + (str "Rename " ++ pr_id id1 ++ str " into " ++ pr_id id2) + +let pr_prim_rule_v8 = function + | Intro id -> + str"intro " ++ pr_id id + + | Intro_replacing id -> + (str"intro replacing " ++ pr_id id) + + | Cut (b,id,t) -> + if b then + (str"assert " ++ prterm t) + else + (str"cut " ++ prterm t ++ str ";[intro " ++ pr_id id ++ str "|idtac]") + + | FixRule (f,n,[]) -> + (str"fix " ++ pr_id f ++ str"/" ++ int n) + + | FixRule (f,n,others) -> + let rec print_mut = function + | (f,n,ar)::oth -> + pr_id f ++ str"/" ++ int n ++ str" : " ++ prterm ar ++ print_mut oth + | [] -> mt () in + (str"fix " ++ pr_id f ++ str"/" ++ int n ++ + str" with " ++ print_mut others) + + | Cofix (f,[]) -> + (str"cofix " ++ pr_id f) + + | Cofix (f,others) -> + let rec print_mut = function + | (f,ar)::oth -> + (pr_id f ++ str" : " ++ prterm ar ++ print_mut oth) + | [] -> mt () in + (str"cofix " ++ pr_id f ++ str" with " ++ print_mut others) + + | Refine c -> + str(if occur_meta c then "refine " else "exact ") ++ + Constrextern.with_meta_as_hole prterm c + + | Convert_concl c -> + (str"change " ++ prterm c) + + | Convert_hyp (id,None,t) -> + (str"change " ++ prterm t ++ spc () ++ str"in " ++ pr_id id) + + | Convert_hyp (id,Some c,t) -> + (str"change " ++ prterm c ++ spc () ++ str"in " + ++ pr_id id ++ str" (type of " ++ pr_id id ++ str ")") + + | Thin ids -> + (str"clear " ++ prlist_with_sep pr_spc pr_id ids) + + | ThinBody ids -> + (str"clearbody " ++ prlist_with_sep pr_spc pr_id ids) + + | Move (withdep,id1,id2) -> + (str (if withdep then "dependent " else "") ++ + str"move " ++ pr_id id1 ++ str " after " ++ pr_id id2) + + | Rename (id1,id2) -> + (str "rename " ++ pr_id id1 ++ str " into " ++ pr_id id2) + +let pr_prim_rule t = + if! Options.v7 then pr_prim_rule_v7 t else pr_prim_rule_v8 t diff --git a/proofs/logic.mli b/proofs/logic.mli new file mode 100644 index 00000000..7eef22bd --- /dev/null +++ b/proofs/logic.mli @@ -0,0 +1,73 @@ +(************************************************************************) +(* v * The Coq Proof Assistant / The Coq Development Team *) +(* tactic +val with_check : tactic -> tactic + +(* [without_check] respectively means:\\ + [Intro]: no check that the name does not exist\\ + [Intro_after]: no check that the name does not exist and that variables in + its type does not escape their scope\\ + [Intro_replacing]: no check that the name does not exist and that + variables in its type does not escape their scope\\ + [Convert_hyp]: + no check that the name exist and that its type is convertible\\ +*) + +(* The primitive refiner. *) + +val prim_refiner : prim_rule -> evar_map -> goal -> goal list + +val prim_extractor : + (identifier list -> proof_tree -> constr) + -> identifier list -> proof_tree -> constr + +(*s Refiner errors. *) + +type refiner_error = + + (*i Errors raised by the refiner i*) + | BadType of constr * constr * constr + | OccurMeta of constr + | OccurMetaGoal of constr + | CannotApply of constr * constr + | NotWellTyped of constr + | NonLinearProof of constr + + (*i Errors raised by the tactics i*) + | CannotUnify of constr * constr + | CannotUnifyBindingType of constr * constr + | CannotGeneralize of constr + | IntroNeedsProduct + | DoesNotOccurIn of constr * identifier + | NoOccurrenceFound of constr + +exception RefinerError of refiner_error + +val error_cannot_unify : constr * constr -> 'a + +val catchable_exception : exn -> bool + + +(*s Pretty-printer. *) + +val pr_prim_rule : prim_rule -> Pp.std_ppcmds diff --git a/proofs/pfedit.ml b/proofs/pfedit.ml new file mode 100644 index 00000000..f53ea870 --- /dev/null +++ b/proofs/pfedit.ml @@ -0,0 +1,333 @@ +(************************************************************************) +(* v * The Coq Proof Assistant / The Coq Development Team *) +(* (spc () ++ str"(No proof-editing in progress).") + | l -> (str"." ++ fnl () ++ str"Proofs currently edited:" ++ spc () ++ + (prlist_with_sep pr_spc pr_id (get_all_proof_names ())) ++ + str"." ++ + (if use_resume then (fnl () ++ str"Use \"Resume\" first.") + else (mt ())) +) + +let undo_default = 50 +let undo_limit = ref undo_default + +(*********************************************************************) +(* Functions for decomposing and modifying the proof state *) +(*********************************************************************) + +let get_state () = + match Edit.read proof_edits with + | None -> errorlabstrm "Pfedit.get_state" + (str"No focused proof" ++ msg_proofs true) + | Some(_,pfs,ts) -> (pfs,ts) + +let get_topstate () = snd(get_state()) +let get_pftreestate () = fst(get_state()) + +let get_end_tac () = let ts = get_topstate () in ts.top_end_tac + +let get_goal_context n = + let pftree = get_pftreestate () in + let goal = nth_goal_of_pftreestate n pftree in + (project goal, pf_env goal) + +let get_current_goal_context () = get_goal_context 1 + +let set_current_proof = Edit.focus proof_edits + +let resume_proof (loc,id) = + try + Edit.focus proof_edits id + with Invalid_argument "Edit.focus" -> + user_err_loc(loc,"Pfedit.set_proof",str"No such proof" ++ msg_proofs false) + +let suspend_proof () = + try + Edit.unfocus proof_edits + with Invalid_argument "Edit.unfocus" -> + errorlabstrm "Pfedit.suspend_current_proof" + (str"No active proof" ++ (msg_proofs true)) + +let resume_last_proof () = + match (Edit.last_focused proof_edits) with + | None -> + errorlabstrm "resume_last" (str"No proof-editing in progress.") + | Some p -> + Edit.focus proof_edits p + +let get_current_proof_name () = + match Edit.read proof_edits with + | None -> + errorlabstrm "Pfedit.get_proof" + (str"No focused proof" ++ msg_proofs true) + | Some(na,_,_) -> na + +let add_proof (na,pfs,ts) = + Edit.create proof_edits (na,pfs,ts,!undo_limit+1) + +let delete_proof_gen = Edit.delete proof_edits + +let delete_proof (loc,id) = + try + delete_proof_gen id + with (UserError ("Edit.delete",_)) -> + user_err_loc + (loc,"Pfedit.delete_proof",str"No such proof" ++ msg_proofs false) + +let init_proofs () = Edit.clear proof_edits + +let mutate f = + try + Edit.mutate proof_edits (fun _ pfs -> f pfs) + with Invalid_argument "Edit.mutate" -> + errorlabstrm "Pfedit.mutate" + (str"No focused proof" ++ msg_proofs true) + +let start (na,ts) = + let pfs = mk_pftreestate ts.top_goal in + add_proof(na,pfs,ts) + +let restart_proof () = + match Edit.read proof_edits with + | None -> + errorlabstrm "Pfedit.restart" + (str"No focused proof to restart" ++ msg_proofs true) + | Some(na,_,ts) -> + delete_proof_gen na; + start (na,ts); + set_current_proof na + +let proof_term () = + extract_pftreestate (get_pftreestate()) + +(* Detect is one has completed a subtree of the initial goal *) +let subtree_solved () = + let pts = get_pftreestate () in + is_complete_proof (proof_of_pftreestate pts) & + not (is_top_pftreestate pts) + +(*********************************************************************) +(* Undo functions *) +(*********************************************************************) + +let set_undo = function + | None -> undo_limit := undo_default + | Some n -> + if n>=0 then + undo_limit := n + else + error "Cannot set a negative undo limit" + +let get_undo () = Some !undo_limit + +let undo n = + try + Edit.undo proof_edits n; + (* needed because the resolution of a subtree is done in 2 steps + then a sequence of undo can lead to a focus on a completely solved + subtree - this solution only works properly if undoing one step *) + if subtree_solved() then Edit.undo proof_edits 1 + with (Invalid_argument "Edit.undo") -> + errorlabstrm "Pfedit.undo" (str"No focused proof" ++ msg_proofs true) + +(*********************************************************************) +(* Proof cooking *) +(*********************************************************************) + +let xml_cook_proof = ref (fun _ -> ()) +let set_xml_cook_proof f = xml_cook_proof := f + +let cook_proof () = + let (pfs,ts) = get_state() + and ident = get_current_proof_name () in + let {evar_concl=concl} = ts.top_goal + and strength = ts.top_strength in + let pfterm = extract_pftreestate pfs in + !xml_cook_proof (strength,pfs); + (ident, + ({ const_entry_body = pfterm; + const_entry_type = Some concl; + const_entry_opaque = true }, + strength, ts.top_hook)) + +let current_proof_statement () = + let ts = get_topstate() in + (get_current_proof_name (), ts.top_strength, + ts.top_goal.evar_concl, ts.top_hook) + +(*********************************************************************) +(* Abort functions *) +(*********************************************************************) + +let refining () = [] <> (Edit.dom proof_edits) + +let check_no_pending_proofs () = + if refining () then + errorlabstrm "check_no_pending_proofs" + (str"Proof editing in progress" ++ (msg_proofs false) ++ fnl() ++ + str"Use \"Abort All\" first or complete proof(s).") + +let delete_current_proof () = delete_proof_gen (get_current_proof_name ()) + +let delete_all_proofs = init_proofs + +(*********************************************************************) +(* Modifying the end tactic of the current profftree *) +(*********************************************************************) +let set_end_tac tac = + let top = get_topstate () in + top.top_end_tac <- Some tac + +(*********************************************************************) +(* Modifying the current prooftree *) +(*********************************************************************) + +let start_proof na str sign concl hook = + let top_goal = mk_goal sign concl in + let ts = { + top_end_tac = None; + top_hyps = (sign,empty_named_context); + top_goal = top_goal; + top_strength = str; + top_hook = hook} + in + start(na,ts); + set_current_proof na + + +let solve_nth k tac = + let pft = get_pftreestate () in + if not (List.mem (-1) (cursor_of_pftreestate pft)) then + mutate (solve_nth_pftreestate k tac) + else + error "cannot apply a tactic when we are descended behind a tactic-node" + +let by tac = mutate (solve_pftreestate tac) + +let instantiate_nth_evar_com n c = + mutate (Evar_refiner.instantiate_pf_com n c) + +let traverse n = mutate (traverse n) + +(* [traverse_to path] + + Traverses the current proof to get to the location specified by + [path]. + + ALGORITHM: The algorithm works on reversed paths. One just has to remove + the common part on the reversed paths. + +*) + +let common_ancestor l1 l2 = + let rec common_aux l1 l2 = + match l1, l2 with + | a1::l1', a2::l2' when a1 = a2 -> common_aux l1' l2' + | _, _ -> List.rev l1, List.length l2 + in + common_aux (List.rev l1) (List.rev l2) + +let rec traverse_up = function + | 0 -> (function pf -> pf) + | n -> (function pf -> Tacmach.traverse 0 (traverse_up (n - 1) pf)) + +let rec traverse_down = function + | [] -> (function pf -> pf) + | n::l -> (function pf -> Tacmach.traverse n (traverse_down l pf)) + +let traverse_to path = + let up_and_down path pfs = + let cursor = cursor_of_pftreestate pfs in + let down_list, up_count = common_ancestor path cursor in + traverse_down down_list (traverse_up up_count pfs) + in + mutate (up_and_down path) + +(* traverse the proof tree until it reach the nth subgoal *) +let traverse_nth_goal n = mutate (nth_unproven n) + +let traverse_prev_unproven () = mutate prev_unproven + +let traverse_next_unproven () = mutate next_unproven + + +(* The goal focused on *) +let focus_n = ref 0 +let make_focus n = focus_n := n +let focus () = !focus_n +let focused_goal () = let n = !focus_n in if n=0 then 1 else n + +let reset_top_of_tree () = + let pts = get_pftreestate () in + if not (is_top_pftreestate pts) then mutate top_of_tree + +(** Printers *) + +let pr_subgoals_of_pfts pfts = + let gls = fst (Refiner.frontier (proof_of_pftreestate pfts)) in + let sigma = project (top_goal_of_pftreestate pfts) in + pr_subgoals_existential sigma gls + +let pr_open_subgoals () = + let pfts = get_pftreestate () in + match focus() with + | 0 -> + pr_subgoals_of_pfts pfts + | n -> + let pf = proof_of_pftreestate pfts in + let gls = fst (frontier pf) in + assert (n > List.length gls); + if List.length gls < 2 then + pr_subgoal n gls + else + v 0 (int(List.length gls) ++ str" subgoals" ++ cut () ++ + pr_subgoal n gls) + +let pr_nth_open_subgoal n = + let pf = proof_of_pftreestate (get_pftreestate ()) in + pr_subgoal n (fst (frontier pf)) diff --git a/proofs/pfedit.mli b/proofs/pfedit.mli new file mode 100644 index 00000000..e95881ba --- /dev/null +++ b/proofs/pfedit.mli @@ -0,0 +1,183 @@ +(************************************************************************) +(* v * The Coq Proof Assistant / The Coq Development Team *) +(* bool + +(* [check_no_pending_proofs ()] fails if there is still some proof in + progress *) + +val check_no_pending_proofs : unit -> unit + +(*s [delete_proof name] deletes proof of name [name] or fails if no proof + has this name *) + +val delete_proof : identifier located -> unit + +(* [delete_current_proof ()] deletes current focused proof or fails if + no proof is focused *) + +val delete_current_proof : unit -> unit + +(* [delete_all_proofs ()] deletes all open proofs if any *) + +val delete_all_proofs : unit -> unit + +(*s [undo n] undoes the effect of the last [n] tactics applied to the + current proof; it fails if no proof is focused or if the ``undo'' + stack is exhausted *) + +val undo : int -> unit + +(* [set_undo (Some n)] sets the size of the ``undo'' stack; [set_undo None] + sets the size to the default value (12) *) + +val set_undo : int option -> unit +val get_undo : unit -> int option + +(*s [start_proof s str env t hook] starts a proof of name [s] and conclusion + [t]; [hook] is optionally a function to be applied at proof end (e.g. to + declare the built constructions as a coercion or a setoid morphism) *) + +val start_proof : + identifier -> goal_kind -> named_context -> constr + -> declaration_hook -> unit + +(* [restart_proof ()] restarts the current focused proof from the beginning + or fails if no proof is focused *) + +val restart_proof : unit -> unit + +(*s [resume_last_proof ()] focus on the last unfocused proof or fails + if there is no suspended proofs *) + +val resume_last_proof : unit -> unit + +(* [resume_proof name] focuses on the proof of name [name] or + raises [UserError] if no proof has name [name] *) + +val resume_proof : identifier located -> unit + +(* [suspend_proof ()] unfocuses the current focused proof or + failed with [UserError] if no proof is currently focused *) + +val suspend_proof : unit -> unit + +(*s [cook_proof opacity] turns the current proof (assumed completed) into + a constant with its name, kind and possible hook (see [start_proof]); + it fails if there is no current proof of if it is not completed *) + +val cook_proof : unit -> + identifier * (Entries.definition_entry * goal_kind * declaration_hook) + +(* To export completed proofs to xml *) +val set_xml_cook_proof : (goal_kind * pftreestate -> unit) -> unit + +(*s [get_pftreestate ()] returns the current focused pending proof or + raises [UserError "no focused proof"] *) + +val get_pftreestate : unit -> pftreestate + +(* [get_end_tac ()] returns the current tactic to apply to all new subgoal *) + +val get_end_tac : unit -> tactic option + +(* [get_goal_context n] returns the context of the [n]th subgoal of + the current focused proof or raises a [UserError] if there is no + focused proof or if there is no more subgoals *) + +val get_goal_context : int -> Evd.evar_map * env + +(* [get_current_goal_context ()] works as [get_goal_context 1] *) + +val get_current_goal_context : unit -> Evd.evar_map * env + +(* [current_proof_statement] *) + +val current_proof_statement : + unit -> identifier * goal_kind * types * declaration_hook + +(*s [get_current_proof_name ()] return the name of the current focused + proof or failed if no proof is focused *) + +val get_current_proof_name : unit -> identifier + +(* [get_all_proof_names ()] returns the list of all pending proof names *) + +val get_all_proof_names : unit -> identifier list + +(*s [set_end_tac tac] applies tactic [tac] to all subgoal generate + by [solve_nth] *) + +val set_end_tac : tactic -> unit + +(*s [solve_nth n tac] applies tactic [tac] to the [n]th subgoal of the + current focused proof or raises a UserError if no proof is focused or + if there is no [n]th subgoal *) + +val solve_nth : int -> tactic -> unit + +(* [by tac] applies tactic [tac] to the 1st subgoal of the current + focused proof or raises a UserError if there is no focused proof or + if there is no more subgoals *) + +val by : tactic -> unit + +(* [instantiate_nth_evar_com n c] instantiate the [n]th undefined + existential variable of the current focused proof by [c] or raises a + UserError if no proof is focused or if there is no such [n]th + existential variable *) + +val instantiate_nth_evar_com : int -> Topconstr.constr_expr -> unit + +(*s To deal with subgoal focus *) + +val make_focus : int -> unit +val focus : unit -> int +val focused_goal : unit -> int +val subtree_solved : unit -> bool + +val reset_top_of_tree : unit -> unit +val traverse : int -> unit +val traverse_nth_goal : int -> unit +val traverse_next_unproven : unit -> unit +val traverse_prev_unproven : unit -> unit + + +(* These two functions make it possible to implement more elaborate + proof and goal management, as it is done, for instance in pcoq *) +val traverse_to : int list -> unit +val mutate : (pftreestate -> pftreestate) -> unit + +(** Printers *) + +val pr_open_subgoals : unit -> std_ppcmds +val pr_nth_open_subgoal : int -> std_ppcmds diff --git a/proofs/proof_trees.ml b/proofs/proof_trees.ml new file mode 100644 index 00000000..aaf54a36 --- /dev/null +++ b/proofs/proof_trees.ml @@ -0,0 +1,253 @@ +(************************************************************************) +(* v * The Coq Proof Assistant / The Coq Development Team *) +(* true + | _ -> false +*) + +(* Functions on goals *) + +let mk_goal hyps cl = + { evar_hyps = hyps; evar_concl = cl; + evar_body = Evar_empty} + +(* Functions on proof trees *) + +let ref_of_proof pf = + match pf.ref with + | None -> failwith "rule_of_proof" + | Some r -> r + +let rule_of_proof pf = + let (r,_) = ref_of_proof pf in r + +let children_of_proof pf = + let (_,cl) = ref_of_proof pf in cl + +let goal_of_proof pf = pf.goal + +let subproof_of_proof pf = match pf.ref with + | Some (Tactic (_,pf), _) -> pf + | _ -> failwith "subproof_of_proof" + +let status_of_proof pf = pf.open_subgoals + +let is_complete_proof pf = pf.open_subgoals = 0 + +let is_leaf_proof pf = (pf.ref = None) + +let is_tactic_proof pf = match pf.ref with + | Some (Tactic _, _) -> true + | _ -> false + + +(*******************************************************************) +(* Constraints for existential variables *) +(*******************************************************************) + +(* A readable constraint is a global constraint plus a focus set + of existential variables and a signature. *) + +(* Functions on readable constraints *) + +let mt_evcty gc = + { it = empty_named_context; sigma = gc } + +let rc_of_gc evds gl = + { it = gl.evar_hyps; sigma = evds } + +let rc_add evc (k,v) = + { it = evc.it; + sigma = Evd.add evc.sigma k v } + +let get_hyps evc = evc.it +let get_env evc = Global.env_of_context evc.it +let get_gc evc = evc.sigma + +let pf_lookup_name_as_renamed env ccl s = + Detyping.lookup_name_as_renamed env ccl s + +let pf_lookup_index_as_renamed env ccl n = + Detyping.lookup_index_as_renamed env ccl n + +(*********************************************************************) +(* Pretty printing functions *) +(*********************************************************************) + +open Pp +open Printer + +(* Il faudrait parametrer toutes les pr_term, term_env, etc. par la + strategie de renommage choisie pour Termast (en particulier, il + faudrait pouvoir etre sur que lookup_as_renamed qui est utilisé par + Intros Until fonctionne exactement comme on affiche le but avec + term_env *) + +let pf_lookup_name_as_renamed hyps ccl s = + Detyping.lookup_name_as_renamed hyps ccl s + +let pf_lookup_index_as_renamed ccl n = + Detyping.lookup_index_as_renamed ccl n + +let pr_idl idl = prlist_with_sep pr_spc pr_id idl + +let pr_goal g = + let env = evar_env g in + let penv = pr_context_of env in + let pc = prterm_env_at_top env g.evar_concl in + str" " ++ hv 0 (penv ++ fnl () ++ + str (emacs_str (String.make 1 (Char.chr 253))) ++ + str "============================" ++ fnl () ++ + str" " ++ pc) ++ fnl () + +let pr_concl n g = + let env = evar_env g in + let pc = prterm_env_at_top env g.evar_concl in + str (emacs_str (String.make 1 (Char.chr 253))) ++ + str "subgoal " ++ int n ++ str " is:" ++ cut () ++ str" " ++ pc + +(* print the subgoals but write Subtree proved! even in case some existential + variables remain unsolved, pr_subgoals_existential is a safer version + of pr_subgoals *) + +let pr_subgoals = function + | [] -> (str"Proof completed." ++ fnl ()) + | [g] -> + let pg = pr_goal g in v 0 (str ("1 "^"subgoal") ++cut () ++ pg) + | g1::rest -> + let rec pr_rec n = function + | [] -> (mt ()) + | g::rest -> + let pg = pr_concl n g in + let prest = pr_rec (n+1) rest in + (cut () ++ pg ++ prest) + in + let pg1 = pr_goal g1 in + let pgr = pr_rec 2 rest in + v 0 (int(List.length rest+1) ++ str" subgoals" ++ cut () ++ pg1 ++ pgr) + +let pr_subgoal n = + let rec prrec p = function + | [] -> error "No such goal" + | g::rest -> + if p = 1 then + let pg = pr_goal g in + v 0 (str "subgoal " ++ int n ++ str " is:" ++ cut () ++ pg) + else + prrec (p-1) rest + in + prrec n + +let pr_seq evd = + let env = evar_env evd + and cl = evd.evar_concl + in + let pdcl = pr_named_context_of env in + let pcl = prterm_env_at_top env cl in + hov 0 (pdcl ++ spc () ++ hov 0 (str"|- " ++ pcl)) + +let prgl gl = + let pgl = pr_seq gl in + (str"[" ++ pgl ++ str"]" ++ spc ()) + +let pr_evgl gl = + let phyps = pr_idl (List.rev (ids_of_named_context gl.evar_hyps)) in + let pc = prterm gl.evar_concl in + hov 0 (str"[" ++ phyps ++ spc () ++ str"|- " ++ pc ++ str"]") + +let pr_evgl_sign gl = + let ps = pr_named_context_of (evar_env gl) in + let pc = prterm gl.evar_concl in + hov 0 (str"[" ++ ps ++ spc () ++ str"|- " ++ pc ++ str"]") + +(* evd.evgoal.lc seems to be printed twice *) +let pr_decl evd = + let pevgl = pr_evgl evd in + let pb = + match evd.evar_body with + | Evar_empty -> (fnl ()) + | Evar_defined c -> let pc = prterm c in (str" => " ++ pc ++ fnl ()) + in + h 0 (pevgl ++ pb) + +let pr_evd evd = + prlist_with_sep pr_fnl + (fun (ev,evd) -> + let pe = pr_decl evd in + h 0 (str (string_of_existential ev) ++ str"==" ++ pe)) + (Evd.to_list evd) + +let pr_decls decls = pr_evd decls + +let pr_evc evc = + let pe = pr_evd evc.sigma in + (pe) + +let pr_evars = + prlist_with_sep pr_fnl + (fun (ev,evd) -> + let pegl = pr_evgl_sign evd in + (str (string_of_existential ev) ++ str " : " ++ pegl)) + +(* Print an enumerated list of existential variables *) +let rec pr_evars_int i = function + | [] -> (mt ()) + | (ev,evd)::rest -> + let pegl = pr_evgl_sign evd in + let pei = pr_evars_int (i+1) rest in + (hov 0 (str "Existential " ++ int i ++ str " =" ++ spc () ++ + str (string_of_existential ev) ++ str " : " ++ pegl)) ++ + fnl () ++ pei + +(* Equivalent to pr_subgoals but start from the prooftree and + check for uninstantiated existential variables *) + +let pr_subgoals_existential sigma = function + | [] -> + let exl = Evd.non_instantiated sigma in + if exl = [] then + (str"Proof completed." ++ fnl ()) + else + let pei = pr_evars_int 1 exl in + (str "No more subgoals but non-instantiated existential " ++ + str "variables :" ++fnl () ++ (hov 0 pei)) + | [g] -> + let pg = pr_goal g in + v 0 (str ("1 "^"subgoal") ++cut () ++ pg) + | g1::rest -> + let rec pr_rec n = function + | [] -> (mt ()) + | g::rest -> + let pc = pr_concl n g in + let prest = pr_rec (n+1) rest in + (cut () ++ pc ++ prest) + in + let pg1 = pr_goal g1 in + let prest = pr_rec 2 rest in + v 0 (int(List.length rest+1) ++ str" subgoals" ++ cut () + ++ pg1 ++ prest ++ fnl ()) diff --git a/proofs/proof_trees.mli b/proofs/proof_trees.mli new file mode 100644 index 00000000..c31d5207 --- /dev/null +++ b/proofs/proof_trees.mli @@ -0,0 +1,68 @@ +(************************************************************************) +(* v * The Coq Proof Assistant / The Coq Development Team *) +(* constr -> goal + +val rule_of_proof : proof_tree -> rule +val ref_of_proof : proof_tree -> (rule * proof_tree list) +val children_of_proof : proof_tree -> proof_tree list +val goal_of_proof : proof_tree -> goal +val subproof_of_proof : proof_tree -> proof_tree +val status_of_proof : proof_tree -> int +val is_complete_proof : proof_tree -> bool +val is_leaf_proof : proof_tree -> bool +val is_tactic_proof : proof_tree -> bool + +(*s A readable constraint is a global constraint plus a focus set + of existential variables and a signature. *) + +val rc_of_gc : evar_map -> goal -> named_context sigma +val rc_add : named_context sigma -> existential_key * goal -> + named_context sigma +val get_hyps : named_context sigma -> named_context +val get_env : named_context sigma -> env +val get_gc : named_context sigma -> evar_map + +val pf_lookup_name_as_renamed : env -> constr -> identifier -> int option +val pf_lookup_index_as_renamed : env -> constr -> int -> int option + + +(*s Pretty printing functions. *) + +(*i*) +open Pp +(*i*) + +val pr_goal : goal -> std_ppcmds +val pr_subgoals : goal list -> std_ppcmds +val pr_subgoal : int -> goal list -> std_ppcmds + +val pr_decl : goal -> std_ppcmds +val pr_decls : evar_map -> std_ppcmds +val pr_evc : named_context sigma -> std_ppcmds + +val prgl : goal -> std_ppcmds +val pr_seq : goal -> std_ppcmds +val pr_evars : (existential_key * goal) list -> std_ppcmds +val pr_evars_int : int -> (existential_key * goal) list -> std_ppcmds +val pr_subgoals_existential : evar_map -> goal list -> std_ppcmds diff --git a/proofs/proof_type.ml b/proofs/proof_type.ml new file mode 100644 index 00000000..cbed5e27 --- /dev/null +++ b/proofs/proof_type.ml @@ -0,0 +1,101 @@ +(************************************************************************) +(* v * The Coq Proof Assistant / The Coq Development Team *) +(* (goal list sigma * validation) + +and validation = (proof_tree list -> proof_tree) + +and tactic_expr = + (constr, + constr_pattern, + evaluable_global_reference, + inductive, + ltac_constant, + identifier, + glob_tactic_expr) + Tacexpr.gen_tactic_expr + +and atomic_tactic_expr = + (constr, + constr_pattern, + evaluable_global_reference, + inductive, + ltac_constant, + identifier, + glob_tactic_expr) + Tacexpr.gen_atomic_tactic_expr + +and tactic_arg = + (constr, + constr_pattern, + evaluable_global_reference, + inductive, + ltac_constant, + identifier, + glob_tactic_expr) + Tacexpr.gen_tactic_arg + +type hyp_location = identifier Tacexpr.raw_hyp_location + diff --git a/proofs/proof_type.mli b/proofs/proof_type.mli new file mode 100644 index 00000000..42606552 --- /dev/null +++ b/proofs/proof_type.mli @@ -0,0 +1,128 @@ +(************************************************************************) +(* v * The Coq Proof Assistant / The Coq Development Team *) +(* (goal list sigma * validation) + +and validation = (proof_tree list -> proof_tree) + +and tactic_expr = + (constr, + constr_pattern, + evaluable_global_reference, + inductive, + ltac_constant, + identifier, + glob_tactic_expr) + Tacexpr.gen_tactic_expr + +and atomic_tactic_expr = + (constr, + constr_pattern, + evaluable_global_reference, + inductive, + ltac_constant, + identifier, + glob_tactic_expr) + Tacexpr.gen_atomic_tactic_expr + +and tactic_arg = + (constr, + constr_pattern, + evaluable_global_reference, + inductive, + ltac_constant, + identifier, + glob_tactic_expr) + Tacexpr.gen_tactic_arg + +type hyp_location = identifier Tacexpr.raw_hyp_location diff --git a/proofs/refiner.ml b/proofs/refiner.ml new file mode 100644 index 00000000..55f11d52 --- /dev/null +++ b/proofs/refiner.ml @@ -0,0 +1,1030 @@ +(************************************************************************) +(* v * The Coq Proof Assistant / The Coq Development Team *) +(* (goal list * validation) + +let hypotheses gl = gl.evar_hyps +let conclusion gl = gl.evar_concl + +let sig_it x = x.it +let sig_sig x = x.sigma + + +let project_with_focus gls = rc_of_gc (gls.sigma) (gls.it) + +let pf_status pf = pf.open_subgoals + +let is_complete pf = (0 = (pf_status pf)) + +let on_open_proofs f pf = if is_complete pf then pf else f pf + +let and_status = List.fold_left (+) 0 + +(* Normalizing evars in a goal. Called by tactic Local_constraints + (i.e. when the sigma of the proof tree changes). Detect if the + goal is unchanged *) +let norm_goal sigma gl = + let red_fun = Evarutil.nf_evar sigma in + let ncl = red_fun gl.evar_concl in + let ngl = + { evar_concl = ncl; + evar_hyps = + Sign.fold_named_context + (fun (d,b,ty) sign -> + add_named_decl (d, option_app red_fun b, red_fun ty) sign) + gl.evar_hyps ~init:empty_named_context; + evar_body = gl.evar_body} in + if ngl = gl then None else Some ngl + + +(* [mapshape [ l1 ; ... ; lk ] [ v1 ; ... ; vk ] [ p_1 ; .... ; p_(l1+...+lk) ]] + gives + [ (v1 [p_1 ... p_l1]) ; (v2 [ p_(l1+1) ... p_(l1+l2) ]) ; ... ; + (vk [ p_(l1+...+l(k-1)+1) ... p_(l1+...lk) ]) ] + *) + +let rec mapshape nl (fl : (proof_tree list -> proof_tree) list) + (l : proof_tree list) = + match nl with + | [] -> [] + | h::t -> + let m,l = list_chop h l in + (List.hd fl m) :: (mapshape t (List.tl fl) l) + +(* [frontier : proof_tree -> goal list * validation] + given a proof [p], [frontier p] gives [(l,v)] where [l] is the list of goals + to be solved to complete the proof, and [v] is the corresponding + validation *) + +let rec frontier p = + match p.ref with + | None -> + ([p.goal], + (fun lp' -> + let p' = List.hd lp' in + if p'.goal = p.goal then + p' + else + errorlabstrm "Refiner.frontier" + (str"frontier was handed back a ill-formed proof."))) + | Some(r,pfl) -> + let gll,vl = List.split(List.map frontier pfl) in + (List.flatten gll, + (fun retpfl -> + let pfl' = mapshape (List.map List.length gll) vl retpfl in + { open_subgoals = and_status (List.map pf_status pfl'); + goal = p.goal; + ref = Some(r,pfl')})) + + +let rec frontier_map_rec f n p = + if n < 1 || n > p.open_subgoals then p else + match p.ref with + | None -> + let p' = f p in + if p'.goal == p.goal || p'.goal = p.goal then p' + else + errorlabstrm "Refiner.frontier_map" + (str"frontier_map was handed back a ill-formed proof.") + | Some(r,pfl) -> + let (_,rpfl') = + List.fold_left + (fun (n,acc) p -> (n-p.open_subgoals,frontier_map_rec f n p::acc)) + (n,[]) pfl in + let pfl' = List.rev rpfl' in + { open_subgoals = and_status (List.map pf_status pfl'); + goal = p.goal; + ref = Some(r,pfl')} + +let frontier_map f n p = + let nmax = p.open_subgoals in + let n = if n < 0 then nmax + n + 1 else n in + if n < 1 || n > nmax then + errorlabstrm "Refiner.frontier_map" (str "No such subgoal"); + frontier_map_rec f n p + +let rec frontier_mapi_rec f i p = + if p.open_subgoals = 0 then p else + match p.ref with + | None -> + let p' = f i p in + if p'.goal == p.goal || p'.goal = p.goal then p' + else + errorlabstrm "Refiner.frontier_mapi" + (str"frontier_mapi was handed back a ill-formed proof.") + | Some(r,pfl) -> + let (_,rpfl') = + List.fold_left + (fun (n,acc) p -> (n+p.open_subgoals,frontier_mapi_rec f n p::acc)) + (i,[]) pfl in + let pfl' = List.rev rpfl' in + { open_subgoals = and_status (List.map pf_status pfl'); + goal = p.goal; + ref = Some(r,pfl')} + +let frontier_mapi f p = frontier_mapi_rec f 1 p + +(* [list_pf p] is the lists of goals to be solved in order to complete the + proof [p] *) + +let list_pf p = fst (frontier p) + +let rec nb_unsolved_goals pf = pf.open_subgoals + +(* leaf g is the canonical incomplete proof of a goal g *) + +let leaf g = { + open_subgoals = 1; + goal = g; + ref = None } + +(* Tactics table. *) + +let tac_tab = Hashtbl.create 17 + +let add_tactic s t = + if Hashtbl.mem tac_tab s then + errorlabstrm ("Refiner.add_tactic: ") + (str ("Cannot redeclare tactic "^s)); + Hashtbl.add tac_tab s t + +let overwriting_add_tactic s t = + if Hashtbl.mem tac_tab s then begin + Hashtbl.remove tac_tab s; + warning ("Overwriting definition of tactic "^s) + end; + Hashtbl.add tac_tab s t + +let lookup_tactic s = + try + Hashtbl.find tac_tab s + with Not_found -> + errorlabstrm "Refiner.lookup_tactic" + (str"The tactic " ++ str s ++ str" is not installed") + + +(* refiner r is a tactic applying the rule r *) + +let bad_subproof () = + anomalylabstrm "Refiner.refiner" (str"Bad subproof in validation.") + +let check_subproof_connection gl spfl = + if not (list_for_all2eq (fun g pf -> g=pf.goal) gl spfl) + then (bad_subproof (); false) else true + +let abstract_tactic_expr te tacfun gls = + let (sgl_sigma,v) = tacfun gls in + let hidden_proof = v (List.map leaf sgl_sigma.it) in + (sgl_sigma, + fun spfl -> + assert (check_subproof_connection sgl_sigma.it spfl); + { open_subgoals = and_status (List.map pf_status spfl); + goal = gls.it; + ref = Some(Tactic(te,hidden_proof),spfl) }) + +let refiner = function + | Prim pr as r -> + let prim_fun = prim_refiner pr in + (fun goal_sigma -> + let sgl = prim_fun goal_sigma.sigma goal_sigma.it in + ({it=sgl; sigma = goal_sigma.sigma}, + (fun spfl -> + assert (check_subproof_connection sgl spfl); + { open_subgoals = and_status (List.map pf_status spfl); + goal = goal_sigma.it; + ref = Some(r,spfl) }))) + + | Tactic _ -> failwith "Refiner: should not occur" + + (* [Local_constraints lc] makes the local constraints be [lc] and + normalizes evars *) + + | Change_evars as r -> + (fun goal_sigma -> + let gl = goal_sigma.it in + (match norm_goal goal_sigma.sigma gl with + Some ngl -> + ({it=[ngl];sigma=goal_sigma.sigma}, + (fun spfl -> + assert (check_subproof_connection [ngl] spfl); + { open_subgoals = (List.hd spfl).open_subgoals; + goal = gl; + ref = Some(r,spfl) })) + (* if the evar change does not affect the goal, leave the + proof tree unchanged *) + | None -> ({it=[gl];sigma=goal_sigma.sigma}, + (fun spfl -> + assert (List.length spfl = 1); + List.hd spfl)))) + + +let local_Constraints gl = refiner Change_evars gl + +let norm_evar_tac = local_Constraints + +(* +let vernac_tactic (s,args) = + let tacfun = lookup_tactic s args in + abstract_extra_tactic s args tacfun +*) +let abstract_tactic te = abstract_tactic_expr (Tacexpr.TacAtom (dummy_loc,te)) + +let abstract_extended_tactic s args = + abstract_tactic (Tacexpr.TacExtend (dummy_loc, s, args)) + +let vernac_tactic (s,args) = + let tacfun = lookup_tactic s args in + abstract_extended_tactic s args tacfun + +(* [rc_of_pfsigma : proof sigma -> readable_constraints] *) +let rc_of_pfsigma sigma = rc_of_gc sigma.sigma sigma.it.goal + +(* [rc_of_glsigma : proof sigma -> readable_constraints] *) +let rc_of_glsigma sigma = rc_of_gc sigma.sigma sigma.it + +(* [extract_open_proof : proof_tree -> constr * (int * constr) list] + takes a (not necessarly complete) proof and gives a pair (pfterm,obl) + where pfterm is the constr corresponding to the proof + and [obl] is an [int*constr list] [ (m1,c1) ; ... ; (mn,cn)] + where the mi are metavariables numbers, and ci are their types. + Their proof should be completed in order to complete the initial proof *) + +let extract_open_proof sigma pf = + let next_meta = + let meta_cnt = ref 0 in + let rec f () = + incr meta_cnt; + if in_dom sigma (existential_of_int !meta_cnt) then f () + else !meta_cnt + in f + in + let open_obligations = ref [] in + let rec proof_extractor vl = function + | {ref=Some(Prim _,_)} as pf -> prim_extractor proof_extractor vl pf + + | {ref=Some(Tactic (_,hidden_proof),spfl)} -> + let sgl,v = frontier hidden_proof in + let flat_proof = v spfl in + proof_extractor vl flat_proof + + | {ref=Some(Change_evars,[pf])} -> (proof_extractor vl) pf + + | {ref=None;goal=goal} -> + let visible_rels = + map_succeed + (fun id -> + try let n = list_index id vl in (n,id) + with Not_found -> failwith "caught") + (ids_of_named_context goal.evar_hyps) in + let sorted_rels = + Sort.list (fun (n1,_) (n2,_) -> n1 > n2 ) visible_rels in + let sorted_env = + List.map (fun (n,id) -> (n,Sign.lookup_named id goal.evar_hyps)) + sorted_rels in + let abs_concl = + List.fold_right (fun (_,decl) c -> mkNamedProd_or_LetIn decl c) + sorted_env goal.evar_concl in + let inst = List.filter (fun (_,(_,b,_)) -> b = None) sorted_env in + let meta = next_meta () in + open_obligations := (meta,abs_concl):: !open_obligations; + applist (mkMeta meta, List.map (fun (n,_) -> mkRel n) inst) + + | _ -> anomaly "Bug : a case has been forgotten in proof_extractor" + in + let pfterm = proof_extractor [] pf in + (pfterm, List.rev !open_obligations) + +(*********************) +(* Tacticals *) +(*********************) + +(* unTAC : tactic -> goal sigma -> proof sigma *) + +let unTAC tac g = + let (gl_sigma,v) = tac g in + { it = v (List.map leaf gl_sigma.it); sigma = gl_sigma.sigma } + +let unpackage glsig = (ref (glsig.sigma)),glsig.it + +let repackage r v = {it=v;sigma = !r} + +let apply_sig_tac r tac g = + check_for_interrupt (); (* Breakpoint *) + let glsigma,v = tac (repackage r g) in + r := glsigma.sigma; + (glsigma.it,v) + +let idtac_valid = function + [pf] -> pf + | _ -> anomaly "Refiner.idtac_valid" + +(* [goal_goal_list : goal sigma -> goal list sigma] *) +let goal_goal_list gls = {it=[gls.it];sigma=gls.sigma} + +(* identity tactic without any message *) +let tclIDTAC gls = (goal_goal_list gls, idtac_valid) + +(* the message printing identity tactic *) +let tclIDTAC_MESSAGE s gls = + if s = "" then tclIDTAC gls + else + begin + msgnl (str ("Idtac says : "^s)); tclIDTAC gls + end + +(* General failure tactic *) +let tclFAIL_s s gls = errorlabstrm "Refiner.tclFAIL_s" (str s) + +(* A special exception for levels for the Fail tactic *) +exception FailError of int * string + +(* The Fail tactic *) +let tclFAIL lvl s g = raise (FailError (lvl,s)) + +let start_tac gls = + let (sigr,g) = unpackage gls in + (sigr,[g],idtac_valid) + +let finish_tac (sigr,gl,p) = (repackage sigr gl, p) + +(* Apply [taci.(i)] on the first n-th subgoals and [tac] on the others *) +let thensf_tac taci tac (sigr,gs,p) = + let n = Array.length taci in + let nsg = List.length gs in + if nsg apply_sig_tac sigr (if i apply_sig_tac sigr (if i<0 then tac else taci.(i))) + (n-nsg) gs) in + (sigr, List.flatten gll, + compose p (mapshape (List.map List.length gll) pl)) + +(* Apply [tac i] on the ith subgoal (no subgoals number check) *) +let thensi_tac tac (sigr,gs,p) = + let gll,pl = + List.split (list_map_i (fun i -> apply_sig_tac sigr (tac i)) 1 gs) in + (sigr, List.flatten gll, compose p (mapshape (List.map List.length gll) pl)) + +let then_tac tac = thensf_tac [||] tac + +let non_existent_goal n = + errorlabstrm ("No such goal: "^(string_of_int n)) + (str"Trying to apply a tactic to a non existent goal") + +(* Apply tac on the i-th goal (if i>0). If i<0, then start counting from + the last goal (i=-1). *) +let theni_tac i tac ((_,gl,_) as subgoals) = + let nsg = List.length gl in + let k = if i < 0 then nsg + i + 1 else i in + if nsg < 1 then errorlabstrm "theni_tac" (str"No more subgoals.") + else if k >= 1 & k <= nsg then + thensf_tac + (Array.init k (fun i -> if i+1 = k then tac else tclIDTAC)) tclIDTAC + subgoals + else non_existent_goal k + +(* [tclTHENSFIRSTn tac1 [|t1 ; ... ; tn|] tac2 gls] applies the tactic [tac1] + to [gls] and applies [t1], ..., [tn] to the [n] first resulting + subgoals, and [tac2] to the others subgoals. Raises an error if + the number of resulting subgoals is strictly less than [n] *) +let tclTHENSFIRSTn tac1 taci tac gls = + finish_tac (thensf_tac taci tac (then_tac tac1 (start_tac gls))) + +(* [tclTHENSLASTn tac1 tac2 [|t1 ;...; tn|] gls] applies the tactic [tac1] + to [gls] and applies [t1], ..., [tn] to the [n] last resulting + subgoals, and [tac2] to the other subgoals. Raises an error if the + number of resulting subgoals is strictly less than [n] *) +let tclTHENSLASTn tac1 tac taci gls = + finish_tac (thensl_tac tac taci (then_tac tac1 (start_tac gls))) + +(* [tclTHEN_i tac taci gls] applies the tactic [tac] to [gls] and applies + [(taci i)] to the i_th resulting subgoal (starting from 1), whatever the + number of subgoals is *) +let tclTHEN_i tac taci gls = + finish_tac (thensi_tac taci (then_tac tac (start_tac gls))) + +let tclTHENLASTn tac1 taci = tclTHENSLASTn tac1 tclIDTAC taci +let tclTHENFIRSTn tac1 taci = tclTHENSFIRSTn tac1 taci tclIDTAC + +(* [tclTHEN tac1 tac2 gls] applies the tactic [tac1] to [gls] and applies + [tac2] to every resulting subgoals *) +let tclTHEN tac1 tac2 = tclTHENSFIRSTn tac1 [||] tac2 + +(* [tclTHENSV tac1 [t1 ; ... ; tn] gls] applies the tactic [tac1] to + [gls] and applies [t1],..., [tn] to the [n] resulting subgoals. Raises + an error if the number of resulting subgoals is not [n] *) +let tclTHENSV tac1 tac2v = + tclTHENSFIRSTn tac1 tac2v (tclFAIL_s "Wrong number of tactics.") + +let tclTHENS tac1 tac2l = tclTHENSV tac1 (Array.of_list tac2l) + +(* [tclTHENLAST tac1 tac2 gls] applies the tactic [tac1] to [gls] and [tac2] + to the last resulting subgoal *) +let tclTHENLAST tac1 tac2 = tclTHENSLASTn tac1 tclIDTAC [|tac2|] + +(* [tclTHENFIRST tac1 tac2 gls] applies the tactic [tac1] to [gls] and [tac2] + to the first resulting subgoal *) +let tclTHENFIRST tac1 tac2 = tclTHENSFIRSTn tac1 [|tac2|] tclIDTAC + + +(* [tclTHENLIST [t1;..;tn]] applies [t1] then [t2] ... then [tn]. More + convenient than [tclTHEN] when [n] is large. *) +let rec tclTHENLIST = function + [] -> tclIDTAC + | t1::tacl -> tclTHEN t1 (tclTHENLIST tacl) + + + + +(* various progress criterions *) +let same_goal gl subgoal = + (hypotheses subgoal) = (hypotheses gl) & + eq_constr (conclusion subgoal) (conclusion gl) + + +let weak_progress gls ptree = + (List.length gls.it <> 1) or + (not (same_goal (List.hd gls.it) ptree.it)) + +(* Il y avait ici un ts_eq ........ *) +let progress gls ptree = + (weak_progress gls ptree) or + (not (ptree.sigma == gls.sigma)) + + +(* PROGRESS tac ptree applies tac to the goal ptree and fails if tac leaves +the goal unchanged *) +let tclPROGRESS tac ptree = + let rslt = tac ptree in + if progress (fst rslt) ptree then rslt + else errorlabstrm "Refiner.PROGRESS" (str"Failed to progress.") + +(* weak_PROGRESS tac ptree applies tac to the goal ptree and fails + if tac leaves the goal unchanged, possibly modifying sigma *) +let tclWEAK_PROGRESS tac ptree = + let rslt = tac ptree in + if weak_progress (fst rslt) ptree then rslt + else errorlabstrm "Refiner.tclWEAK_PROGRESS" (str"Failed to progress.") + + +(* Same as tclWEAK_PROGRESS but fails also if tactics generates several goals, + one of them being identical to the original goal *) +let tclNOTSAMEGOAL (tac : tactic) goal = + let rslt = tac goal in + let gls = (fst rslt).it in + if List.exists (same_goal goal.it) gls + then errorlabstrm "Refiner.tclNOTSAMEGOAL" + (str"Tactic generated a subgoal identical to the original goal.") + else rslt + + + +(* ORELSE0 t1 t2 tries to apply t1 and if it fails, applies t2 *) +let tclORELSE0 t1 t2 g = + try + t1 g + with (* Breakpoint *) + | e when catchable_exception e -> check_for_interrupt (); t2 g + | FailError (0,_) | Stdpp.Exc_located(_, FailError (0,_)) -> + check_for_interrupt (); t2 g + | FailError (lvl,s) -> raise (FailError (lvl - 1, s)) + | Stdpp.Exc_located (s,FailError (lvl,s')) -> + raise (Stdpp.Exc_located (s,FailError (lvl - 1, s'))) + +(* ORELSE t1 t2 tries to apply t1 and if it fails or does not progress, + then applies t2 *) +let tclORELSE t1 t2 = tclORELSE0 (tclPROGRESS t1) t2 + +(* TRY f tries to apply f, and if it fails, leave the goal unchanged *) +let tclTRY f = (tclORELSE0 f tclIDTAC) + +let tclTHENTRY f g = (tclTHEN f (tclTRY g)) + +(* Try the first tactic that does not fail in a list of tactics *) + +let rec tclFIRST = function + | [] -> tclFAIL_s "No applicable tactic." + | t::rest -> tclORELSE0 t (tclFIRST rest) + +let ite_gen tcal tac_if continue tac_else gl= + let success=ref false in + let tac_if0 gl= + let result=tac_if gl in + success:=true;result in + let tac_else0 e gl= + if !success then + raise e + else + tac_else gl in + try + tcal tac_if0 continue gl + with (* Breakpoint *) + | e when catchable_exception e -> + check_for_interrupt (); tac_else0 e gl + | (FailError (0,_) | Stdpp.Exc_located(_, FailError (0,_))) as e -> + check_for_interrupt (); tac_else0 e gl + | FailError (lvl,s) -> raise (FailError (lvl - 1, s)) + | Stdpp.Exc_located (s,FailError (lvl,s')) -> + raise (Stdpp.Exc_located (s,FailError (lvl - 1, s'))) + +(* Try the first tactic and, if it succeeds, continue with + the second one, and if it fails, use the third one *) + +let tclIFTHENELSE=ite_gen tclTHEN + +(* Idem with tclTHENS and tclTHENSV *) + +let tclIFTHENSELSE=ite_gen tclTHENS + +let tclIFTHENSVELSE=ite_gen tclTHENSV + + +(* Fails if a tactic did not solve the goal *) +let tclCOMPLETE tac = tclTHEN tac (tclFAIL_s "Proof is not complete.") + +(* Try the first thats solves the current goal *) +let tclSOLVE tacl = tclFIRST (List.map tclCOMPLETE tacl) + + +(* Iteration tacticals *) + +let tclDO n t = + let rec dorec k = + if k < 0 then errorlabstrm "Refiner.tclDO" + (str"Wrong argument : Do needs a positive integer."); + if k = 0 then tclIDTAC + else if k = 1 then t else (tclTHEN t (dorec (k-1))) + in + dorec n + +(* Beware: call by need of CAML, g is needed *) +let rec tclREPEAT t g = + (tclORELSE (tclTHEN t (tclREPEAT t)) tclIDTAC) g + +let tclAT_LEAST_ONCE t = (tclTHEN t (tclREPEAT t)) + +(* Repeat on the first subgoal (no failure if no more subgoal) *) +let rec tclREPEAT_MAIN t g = + (tclORELSE (tclTHEN_i t (fun i -> if i = 1 then (tclREPEAT_MAIN t) else + tclIDTAC)) tclIDTAC) g + +(*s Tactics handling a list of goals. *) + +type validation_list = proof_tree list -> proof_tree list + +type tactic_list = (goal list sigma) -> (goal list sigma) * validation_list + +(* Functions working on goal list for correct backtracking in Prolog *) + +let tclFIRSTLIST = tclFIRST +let tclIDTAC_list gls = (gls, fun x -> x) + +(* first_goal : goal list sigma -> goal sigma *) + +let first_goal gls = + let gl = gls.it and sig_0 = gls.sigma in + if gl = [] then error "first_goal"; + { it = List.hd gl; sigma = sig_0 } + +(* goal_goal_list : goal sigma -> goal list sigma *) + +let goal_goal_list gls = + let gl = gls.it and sig_0 = gls.sigma in { it = [gl]; sigma = sig_0 } + +(* tactic -> tactic_list : Apply a tactic to the first goal in the list *) + +let apply_tac_list tac glls = + let (sigr,lg) = unpackage glls in + match lg with + | (g1::rest) -> + let (gl,p) = apply_sig_tac sigr tac g1 in + let n = List.length gl in + (repackage sigr (gl@rest), + fun pfl -> let (pfg,pfrest) = list_chop n pfl in (p pfg)::pfrest) + | _ -> error "apply_tac_list" + +let then_tactic_list tacl1 tacl2 glls = + let (glls1,pl1) = tacl1 glls in + let (glls2,pl2) = tacl2 glls1 in + (glls2, compose pl1 pl2) + +(* Transform a tactic_list into a tactic *) + +let tactic_list_tactic tac gls = + let (glres,vl) = tac (goal_goal_list gls) in + (glres, compose idtac_valid vl) + + + + +(* The type of proof-trees state and a few utilities + A proof-tree state is built from a proof-tree, a set of global + constraints, and a stack which allows to navigate inside the + proof-tree remembering how to rebuild the global proof-tree + possibly after modification of one of the focused children proof-tree. + The number in the stack corresponds to + either the selected subtree and the validation is a function from a + proof-tree list consisting only of one proof-tree to the global + proof-tree + or -1 when the move is done behind a registered tactic in which + case the validation corresponds to a constant function giving back + the original proof-tree. *) + +type pftreestate = { + tpf : proof_tree ; + tpfsigma : evar_map; + tstack : (int * validation) list } + +let proof_of_pftreestate pts = pts.tpf +let is_top_pftreestate pts = pts.tstack = [] +let cursor_of_pftreestate pts = List.map fst pts.tstack +let evc_of_pftreestate pts = pts.tpfsigma + +let top_goal_of_pftreestate pts = + { it = goal_of_proof pts.tpf; sigma = pts.tpfsigma } + +let nth_goal_of_pftreestate n pts = + let goals = fst (frontier pts.tpf) in + try {it = List.nth goals (n-1); sigma = pts.tpfsigma } + with Invalid_argument _ | Failure _ -> non_existent_goal n + +let descend n p = + match p.ref with + | None -> error "It is a leaf." + | Some(r,pfl) -> + if List.length pfl >= n then + (match list_chop (n-1) pfl with + | left,(wanted::right) -> + (wanted, + (fun pfl' -> + if (List.length pfl' = 1) + & (List.hd pfl').goal = wanted.goal + then + let pf' = List.hd pfl' in + let spfl = left@(pf'::right) in + let newstatus = and_status (List.map pf_status spfl) in + { open_subgoals = newstatus; + goal = p.goal; + ref = Some(r,spfl) } + else + error "descend: validation")) + | _ -> assert false) + else + error "Too few subproofs" + +let traverse n pts = match n with + | 0 -> (* go to the parent *) + (match pts.tstack with + | [] -> error "traverse: no ancestors" + | (_,v)::tl -> + { tpf = v [pts.tpf]; + tstack = tl; + tpfsigma = pts.tpfsigma }) + | -1 -> (* go to the hidden tactic-proof, if any, otherwise fail *) + (match pts.tpf.ref with + | Some (Tactic (_,spf),_) -> + let v = (fun pfl -> pts.tpf) in + { tpf = spf; + tstack = (-1,v)::pts.tstack; + tpfsigma = pts.tpfsigma } + | _ -> error "traverse: not a tactic-node") + | n -> (* when n>0, go to the nth child *) + let (npf,v) = descend n pts.tpf in + { tpf = npf; + tpfsigma = pts.tpfsigma; + tstack = (n,v):: pts.tstack } + +let change_constraints_pftreestate newgc pts = { pts with tpfsigma = newgc } + +let app_tac sigr tac p = + let (gll,v) = tac {it=p.goal;sigma= !sigr} in + sigr := gll.sigma; + v (List.map leaf gll.it) + +(* solve the nth subgoal with tactic tac *) +let solve_nth_pftreestate n tac pts = + let sigr = ref pts.tpfsigma in + let tpf' = frontier_map (app_tac sigr tac) n pts.tpf in + let tpf'' = + if !sigr == pts.tpfsigma then tpf' + else frontier_mapi (fun _ g -> app_tac sigr norm_evar_tac g) tpf' in + { tpf = tpf''; + tpfsigma = !sigr; + tstack = pts.tstack } + +let solve_pftreestate = solve_nth_pftreestate 1 + +(* This function implements a poor man's undo at the current goal. + This is a gross approximation as it does not attempt to clean correctly + the global constraints given in tpfsigma. *) + +let weak_undo_pftreestate pts = + let pf = leaf pts.tpf.goal in + { tpf = pf; + tpfsigma = pts.tpfsigma; + tstack = pts.tstack } + +(* Gives a new proof (a leaf) of a goal gl *) +let mk_pftreestate g = + { tpf = leaf g; + tstack = []; + tpfsigma = Evd.empty } + +(* Extracts a constr from a proof-tree state ; raises an error if the + proof is not complete or the state does not correspond to the head + of the proof-tree *) + +let extract_open_pftreestate pts = + extract_open_proof pts.tpfsigma pts.tpf + +let extract_pftreestate pts = + if pts.tstack <> [] then + errorlabstrm "extract_pftreestate" + (str"Cannot extract from a proof-tree in which we have descended;" ++ + spc () ++ str"Please ascend to the root"); + let pfterm,subgoals = extract_open_pftreestate pts in + if subgoals <> [] then + errorlabstrm "extract_proof" + (str "Attempt to save an incomplete proof"); + let env = Global.env_of_context pts.tpf.goal.evar_hyps in + strong whd_betaiotaevar env pts.tpfsigma pfterm + (*** + local_strong (Evarutil.whd_ise (ts_it pts.tpfsigma)) pfterm + ***) +(* Focus on the first leaf proof in a proof-tree state *) + +let rec first_unproven pts = + let pf = (proof_of_pftreestate pts) in + if is_complete_proof pf then + errorlabstrm "first_unproven" (str"No unproven subgoals"); + if is_leaf_proof pf then + pts + else + let childnum = + list_try_find_i + (fun n pf -> + if not(is_complete_proof pf) then n else failwith "caught") + 1 (children_of_proof pf) + in + first_unproven (traverse childnum pts) + +(* Focus on the last leaf proof in a proof-tree state *) + +let rec last_unproven pts = + let pf = proof_of_pftreestate pts in + if is_complete_proof pf then + errorlabstrm "last_unproven" (str"No unproven subgoals"); + if is_leaf_proof pf then + pts + else + let children = (children_of_proof pf) in + let nchilds = List.length children in + let childnum = + list_try_find_i + (fun n pf -> + if not(is_complete_proof pf) then n else failwith "caught") + 1 (List.rev children) + in + last_unproven (traverse (nchilds-childnum+1) pts) + +let rec nth_unproven n pts = + let pf = proof_of_pftreestate pts in + if is_complete_proof pf then + errorlabstrm "nth_unproven" (str"No unproven subgoals"); + if is_leaf_proof pf then + if n = 1 then + pts + else + errorlabstrm "nth_unproven" (str"Not enough unproven subgoals") + else + let children = children_of_proof pf in + let rec process i k = function + | [] -> + errorlabstrm "nth_unproven" (str"Not enough unproven subgoals") + | pf1::rest -> + let k1 = nb_unsolved_goals pf1 in + if k1 < k then + process (i+1) (k-k1) rest + else + nth_unproven k (traverse i pts) + in + process 1 n children + +let rec node_prev_unproven loc pts = + let pf = proof_of_pftreestate pts in + match cursor_of_pftreestate pts with + | [] -> last_unproven pts + | n::l -> + if is_complete_proof pf or loc = 1 then + node_prev_unproven n (traverse 0 pts) + else + let child = List.nth (children_of_proof pf) (loc - 2) in + if is_complete_proof child then + node_prev_unproven (loc - 1) pts + else + first_unproven (traverse (loc - 1) pts) + +let rec node_next_unproven loc pts = + let pf = proof_of_pftreestate pts in + match cursor_of_pftreestate pts with + | [] -> first_unproven pts + | n::l -> + if is_complete_proof pf || + loc = (List.length (children_of_proof pf)) then + node_next_unproven n (traverse 0 pts) + else if is_complete_proof (List.nth (children_of_proof pf) loc) then + node_next_unproven (loc + 1) pts + else + last_unproven(traverse (loc + 1) pts) + +let next_unproven pts = + let pf = proof_of_pftreestate pts in + if is_leaf_proof pf then + match cursor_of_pftreestate pts with + | [] -> error "next_unproven" + | n::_ -> node_next_unproven n (traverse 0 pts) + else + node_next_unproven (List.length (children_of_proof pf)) pts + +let prev_unproven pts = + let pf = proof_of_pftreestate pts in + if is_leaf_proof pf then + match cursor_of_pftreestate pts with + | [] -> error "prev_unproven" + | n::_ -> node_prev_unproven n (traverse 0 pts) + else + node_prev_unproven 1 pts + +let rec top_of_tree pts = + if is_top_pftreestate pts then pts else top_of_tree(traverse 0 pts) + + +(* Pretty-printers. *) + +open Pp + +let pr_tactic = function + | Tacexpr.TacArg (Tacexpr.Tacexp t) -> + if !Options.v7 then + Pptactic.pr_glob_tactic t (*top tactic from tacinterp*) + else + Pptacticnew.pr_glob_tactic (Global.env()) t + | t -> + if !Options.v7 then + Pptactic.pr_tactic t + else + Pptacticnew.pr_tactic (Global.env()) t + +let pr_rule = function + | Prim r -> hov 0 (pr_prim_rule r) + | Tactic (texp,_) -> hov 0 (pr_tactic texp) + | Change_evars -> + (* This is internal tactic and cannot be replayed at user-level. + Function pr_rule_dot below is used when we want to hide + Change_evars *) + str "Evar change" + +(* Does not print change of evars *) +let pr_rule_dot = function + | Change_evars -> mt () + | r -> pr_rule r ++ str"." + +exception Different + +(* We remove from the var context of env what is already in osign *) +let thin_sign osign sign = + Sign.fold_named_context + (fun (id,c,ty as d) sign -> + try + if Sign.lookup_named id osign = (id,c,ty) then sign + else raise Different + with Not_found | Different -> add_named_decl d sign) + sign ~init:empty_named_context + +let rec print_proof sigma osign pf = + let {evar_hyps=hyps; evar_concl=cl; + evar_body=body} = pf.goal in + let hyps' = thin_sign osign hyps in + match pf.ref with + | None -> + hov 0 (pr_seq {evar_hyps=hyps'; evar_concl=cl; evar_body=body}) + | Some(r,spfl) -> + hov 0 + (hov 0 (pr_seq {evar_hyps=hyps'; evar_concl=cl; evar_body=body}) ++ + spc () ++ str" BY " ++ + hov 0 (pr_rule r) ++ fnl () ++ + str" " ++ + hov 0 (prlist_with_sep pr_fnl (print_proof sigma hyps) spfl) +) + +let pr_change gl = + (str"Change " ++ prterm_env (Global.env()) gl.evar_concl ++ str".") + +let rec print_script nochange sigma osign pf = + let {evar_hyps=sign; evar_concl=cl} = pf.goal in + match pf.ref with + | None -> + (if nochange then + (str"") + else + pr_change pf.goal) + ++ fnl () + | Some(r,spfl) -> + ((if nochange then (mt ()) else (pr_change pf.goal ++ fnl ())) ++ + pr_rule_dot r ++ fnl () ++ + prlist_with_sep pr_fnl + (print_script nochange sigma sign) spfl) + +let print_treescript nochange sigma _osign pf = + let rec aux top pf = + let {evar_hyps=sign; evar_concl=cl} = pf.goal in + match pf.ref with + | None -> + if nochange then + (str"") + else + (pr_change pf.goal) + | Some(r,spfl) -> + (if nochange then mt () else (pr_change pf.goal ++ fnl ())) ++ + pr_rule_dot r ++ + match spfl with + | [] -> mt () + | [spf] -> fnl () ++ (if top then mt () else str " ") ++ aux top spf + | _ -> fnl () ++ str " " ++ + hov 0 (prlist_with_sep fnl (aux false) spfl) + in hov 0 (aux true pf) + +let rec print_info_script sigma osign pf = + let {evar_hyps=sign; evar_concl=cl} = pf.goal in + match pf.ref with + | None -> (mt ()) + | Some(Change_evars,[spf]) -> + print_info_script sigma osign spf + | Some(r,spfl) -> + (pr_rule r ++ + match spfl with + | [pf1] -> + if pf1.ref = None then + (str "." ++ fnl ()) + else + (str";" ++ brk(1,3) ++ + print_info_script sigma sign pf1) + | _ -> (str"." ++ fnl () ++ + prlist_with_sep pr_fnl + (print_info_script sigma sign) spfl)) + +let format_print_info_script sigma osign pf = + hov 0 (print_info_script sigma osign pf) + +let print_subscript sigma sign pf = + if is_tactic_proof pf then + format_print_info_script sigma sign (subproof_of_proof pf) + else + format_print_info_script sigma sign pf + +let tclINFO (tac : tactic) gls = + let (sgl,v) as res = tac gls in + begin try + let pf = v (List.map leaf (sig_it sgl)) in + let sign = (sig_it gls).evar_hyps in + msgnl (hov 0 (str" == " ++ + print_subscript (sig_sig gls) sign pf)) + with e when catchable_exception e -> + msgnl (hov 0 (str "Info failed to apply validation")) + end; + res diff --git a/proofs/refiner.mli b/proofs/refiner.mli new file mode 100644 index 00000000..bed1158d --- /dev/null +++ b/proofs/refiner.mli @@ -0,0 +1,210 @@ + +(************************************************************************) +(* v * The Coq Proof Assistant / The Coq Development Team *) +(* 'a +val sig_sig : 'a sigma -> evar_map + +val project_with_focus : goal sigma -> named_context sigma + +val unpackage : 'a sigma -> evar_map ref * 'a +val repackage : evar_map ref -> 'a -> 'a sigma +val apply_sig_tac : + evar_map ref -> ('a sigma -> 'b sigma * 'c) -> 'a -> 'b * 'c + +type transformation_tactic = proof_tree -> (goal list * validation) + +val add_tactic : string -> (closed_generic_argument list -> tactic) -> unit +val overwriting_add_tactic : string -> (closed_generic_argument list -> tactic) -> unit +val lookup_tactic : string -> (closed_generic_argument list) -> tactic + +(*s Hiding the implementation of tactics. *) + +(* [abstract_tactic tac] hides the (partial) proof produced by [tac] under + a single proof node *) +val abstract_tactic : atomic_tactic_expr -> tactic -> tactic +val abstract_tactic_expr : tactic_expr -> tactic -> tactic +val abstract_extended_tactic : string -> closed_generic_argument list -> tactic -> tactic + +val refiner : rule -> tactic +val vernac_tactic : string * closed_generic_argument list -> tactic +val frontier : transformation_tactic +val list_pf : proof_tree -> goal list +val unTAC : tactic -> goal sigma -> proof_tree sigma + +val local_Constraints : tactic + +(* [frontier_map f n p] applies f on the n-th open subgoal of p and + rebuilds proof-tree. + n=1 for first goal, n negative counts from the right *) +val frontier_map : + (proof_tree -> proof_tree) -> int -> proof_tree -> proof_tree + +(* [frontier_mapi f p] applies (f i) on the i-th open subgoal of p. *) +val frontier_mapi : + (int -> proof_tree -> proof_tree) -> proof_tree -> proof_tree + +(*s Tacticals. *) + +(* [tclIDTAC] is the identity tactic without message printing*) +val tclIDTAC : tactic +val tclIDTAC_MESSAGE : string -> tactic + + +(* [tclTHEN tac1 tac2 gls] applies the tactic [tac1] to [gls] and applies + [tac2] to every resulting subgoals *) +val tclTHEN : tactic -> tactic -> tactic + +(* [tclTHENLIST [t1;..;tn]] applies [t1] THEN [t2] ... THEN [tn]. More + convenient than [tclTHEN] when [n] is large *) +val tclTHENLIST : tactic list -> tactic + +(* [tclTHEN_i tac1 tac2 gls] applies the tactic [tac1] to [gls] and applies + [(tac2 i)] to the [i]$^{th}$ resulting subgoal (starting from 1) *) +val tclTHEN_i : tactic -> (int -> tactic) -> tactic + +(* [tclTHENLAST tac1 tac2 gls] applies the tactic [tac1] to [gls] and [tac2] + to the last resulting subgoal (previously called [tclTHENL]) *) +val tclTHENLAST : tactic -> tactic -> tactic + +(* [tclTHENFIRST tac1 tac2 gls] applies the tactic [tac1] to [gls] and [tac2] + to the first resulting subgoal *) +val tclTHENFIRST : tactic -> tactic -> tactic + +(* [tclTHENS tac1 [|t1 ; ... ; tn|] gls] applies the tactic [tac1] to + [gls] and applies [t1],..., [tn] to the [n] resulting subgoals. Raises + an error if the number of resulting subgoals is not [n] *) +val tclTHENSV : tactic -> tactic array -> tactic + +(* Same with a list of tactics *) +val tclTHENS : tactic -> tactic list -> tactic + +(* [tclTHENST] is renamed [tclTHENSFIRSTn] +val tclTHENST : tactic -> tactic array -> tactic -> tactic +*) + +(* [tclTHENSLASTn tac1 [t1 ; ... ; tn] tac2 gls] applies [t1],...,[tn] on the + last [n] resulting subgoals and [tac2] on the remaining first subgoals *) +val tclTHENSLASTn : tactic -> tactic -> tactic array -> tactic + +(* [tclTHENSFIRSTn tac1 [t1 ; ... ; tn] tac2 gls] first applies [tac1], then + applies [t1],...,[tn] on the first [n] resulting subgoals and + [tac2] for the remaining last subgoals (previously called tclTHENST) *) +val tclTHENSFIRSTn : tactic -> tactic array -> tactic -> tactic + +(* [tclTHENLASTn tac1 [t1 ; ... ; tn] gls] first applies [tac1] then, + applies [t1],...,[tn] on the last [n] resulting subgoals and leaves + unchanged the other subgoals *) +val tclTHENLASTn : tactic -> tactic array -> tactic + +(* [tclTHENFIRSTn tac1 [t1 ; ... ; tn] gls] first applies [tac1] then, + applies [t1],...,[tn] on the first [n] resulting subgoals and leaves + unchanged the other subgoals (previously called [tclTHENSI]) *) +val tclTHENFIRSTn : tactic -> tactic array -> tactic + +(* A special exception for levels for the Fail tactic *) +exception FailError of int * string + +val tclORELSE : tactic -> tactic -> tactic +val tclREPEAT : tactic -> tactic +val tclREPEAT_MAIN : tactic -> tactic +val tclFIRST : tactic list -> tactic +val tclSOLVE : tactic list -> tactic +val tclTRY : tactic -> tactic +val tclTHENTRY : tactic -> tactic -> tactic +val tclCOMPLETE : tactic -> tactic +val tclAT_LEAST_ONCE : tactic -> tactic +val tclFAIL : int -> string -> tactic +val tclDO : int -> tactic -> tactic +val tclPROGRESS : tactic -> tactic +val tclWEAK_PROGRESS : tactic -> tactic +val tclNOTSAMEGOAL : tactic -> tactic +val tclINFO : tactic -> tactic + +(* [tclIFTHENELSE tac1 tac2 tac3 gls] first applies [tac1] to [gls] then, + if it succeeds, applies [tac2] to the resulting subgoals, + and if not applies [tac3] to the initial goal [gls] *) +val tclIFTHENELSE : tactic -> tactic -> tactic -> tactic +val tclIFTHENSELSE : tactic -> tactic list -> tactic ->tactic +val tclIFTHENSVELSE : tactic -> tactic array -> tactic ->tactic + +(*s Tactics handling a list of goals. *) + +type validation_list = proof_tree list -> proof_tree list + +type tactic_list = (goal list sigma) -> (goal list sigma) * validation_list + +val tclFIRSTLIST : tactic_list list -> tactic_list +val tclIDTAC_list : tactic_list +val first_goal : 'a list sigma -> 'a sigma +val apply_tac_list : tactic -> tactic_list +val then_tactic_list : tactic_list -> tactic_list -> tactic_list +val tactic_list_tactic : tactic_list -> tactic +val goal_goal_list : 'a sigma -> 'a list sigma + + +(*s Functions for handling the state of the proof editor. *) + +type pftreestate + +val proof_of_pftreestate : pftreestate -> proof_tree +val cursor_of_pftreestate : pftreestate -> int list +val is_top_pftreestate : pftreestate -> bool +val evc_of_pftreestate : pftreestate -> evar_map +val top_goal_of_pftreestate : pftreestate -> goal sigma +val nth_goal_of_pftreestate : int -> pftreestate -> goal sigma + +val traverse : int -> pftreestate -> pftreestate +val solve_nth_pftreestate : int -> tactic -> pftreestate -> pftreestate +val solve_pftreestate : tactic -> pftreestate -> pftreestate + +(* a weak version of logical undoing, that is really correct only *) +(* if there are no existential variables. *) +val weak_undo_pftreestate : pftreestate -> pftreestate + +val mk_pftreestate : goal -> pftreestate +val extract_open_pftreestate : pftreestate -> constr * Termops.metamap +val extract_pftreestate : pftreestate -> constr +val first_unproven : pftreestate -> pftreestate +val last_unproven : pftreestate -> pftreestate +val nth_unproven : int -> pftreestate -> pftreestate +val node_prev_unproven : int -> pftreestate -> pftreestate +val node_next_unproven : int -> pftreestate -> pftreestate +val next_unproven : pftreestate -> pftreestate +val prev_unproven : pftreestate -> pftreestate +val top_of_tree : pftreestate -> pftreestate +val change_constraints_pftreestate + : evar_map -> pftreestate -> pftreestate + + +(*s Pretty-printers. *) + +(*i*) +open Pp +(*i*) + +val print_proof : evar_map -> named_context -> proof_tree -> std_ppcmds +val pr_rule : rule -> std_ppcmds +val pr_tactic : tactic_expr -> std_ppcmds +val print_script : + bool -> evar_map -> named_context -> proof_tree -> std_ppcmds +val print_treescript : + bool -> evar_map -> named_context -> proof_tree -> std_ppcmds diff --git a/proofs/tacexpr.ml b/proofs/tacexpr.ml new file mode 100644 index 00000000..d8d7319d --- /dev/null +++ b/proofs/tacexpr.ml @@ -0,0 +1,314 @@ +(************************************************************************) +(* v * The Coq Proof Assistant / The Coq Development Team *) +(* red + | FBeta :: lf -> add_flag { red with rBeta = true } lf + | FIota :: lf -> add_flag { red with rIota = true } lf + | FZeta :: lf -> add_flag { red with rZeta = true } lf + | FConst l :: lf -> + if red.rDelta then + error + "Cannot set both constants to unfold and constants not to unfold"; + add_flag { red with rConst = list_union red.rConst l } lf + | FDeltaBut l :: lf -> + if red.rConst <> [] & not red.rDelta then + error + "Cannot set both constants to unfold and constants not to unfold"; + add_flag + { red with rConst = list_union red.rConst l; rDelta = true } + lf + in + add_flag + {rBeta = false; rIota = false; rZeta = false; rDelta = false; rConst = []} + +type hyp_location_flag = (* To distinguish body and type of local defs *) + | InHyp + | InHypTypeOnly + | InHypValueOnly + +type 'a raw_hyp_location = + 'a * int list * (hyp_location_flag * hyp_location_flag option ref) + +type 'a induction_arg = + | ElimOnConstr of 'a + | ElimOnIdent of identifier located + | ElimOnAnonHyp of int + +type inversion_kind = + | SimpleInversion + | FullInversion + | FullInversionClear + +type ('c,'id) inversion_strength = + | NonDepInversion of inversion_kind * 'id list * intro_pattern_expr option + | DepInversion of inversion_kind * 'c option * intro_pattern_expr option + | InversionUsing of 'c * 'id list + +type ('a,'b) location = HypLocation of 'a | ConclLocation of 'b + +type 'id gsimple_clause = ('id raw_hyp_location) option +(* onhyps: + [None] means *on every hypothesis* + [Some l] means on hypothesis belonging to l *) +type 'id gclause = + { onhyps : 'id raw_hyp_location list option; + onconcl : bool; + concl_occs :int list } + +let simple_clause_of = function + { onhyps = Some[scl]; onconcl = false } -> Some scl + | { onhyps = Some []; onconcl = true; concl_occs=[] } -> None + | _ -> error "not a simple clause (one hypothesis or conclusion)" + +type pattern_expr = constr_expr + +(* Type of patterns *) +type 'a match_pattern = + | Term of 'a + | Subterm of identifier option * 'a + +(* Type of hypotheses for a Match Context rule *) +type 'a match_context_hyps = + | Hyp of name located * 'a match_pattern + +(* Type of a Match rule for Match Context and Match *) +type ('a,'t) match_rule = + | Pat of 'a match_context_hyps list * 'a match_pattern * 't + | All of 't + +type ('constr,'pat,'cst,'ind,'ref,'id,'tac) gen_atomic_tactic_expr = + (* Basic tactics *) + | TacIntroPattern of intro_pattern_expr list + | TacIntrosUntil of quantified_hypothesis + | TacIntroMove of identifier option * identifier located option + | TacAssumption + | TacExact of 'constr + | TacApply of 'constr with_bindings + | TacElim of 'constr with_bindings * 'constr with_bindings option + | TacElimType of 'constr + | TacCase of 'constr with_bindings + | TacCaseType of 'constr + | TacFix of identifier option * int + | TacMutualFix of identifier * int * (identifier * int * 'constr) list + | TacCofix of identifier option + | TacMutualCofix of identifier * (identifier * 'constr) list + | TacCut of 'constr + | TacTrueCut of name * 'constr + | TacForward of bool * name * 'constr + | TacGeneralize of 'constr list + | TacGeneralizeDep of 'constr + | TacLetTac of name * 'constr * 'id gclause + | TacInstantiate of int * 'constr * 'id gclause + + (* Derived basic tactics *) + | TacSimpleInduction of (quantified_hypothesis * (bool ref * intro_pattern_expr list ref list) list ref) + | TacNewInduction of 'constr induction_arg * 'constr with_bindings option + * (intro_pattern_expr option * (bool ref * intro_pattern_expr list ref list) list ref) + | TacSimpleDestruct of quantified_hypothesis + | TacNewDestruct of 'constr induction_arg * 'constr with_bindings option + * (intro_pattern_expr option * (bool ref * intro_pattern_expr list ref list) list ref) + + | TacDoubleInduction of quantified_hypothesis * quantified_hypothesis + | TacDecomposeAnd of 'constr + | TacDecomposeOr of 'constr + | TacDecompose of 'ind list * 'constr + | TacSpecialize of int option * 'constr with_bindings + | TacLApply of 'constr + + (* Automation tactics *) + | TacTrivial of string list option + | TacAuto of int option * string list option + | TacAutoTDB of int option + | TacDestructHyp of (bool * identifier located) + | TacDestructConcl + | TacSuperAuto of (int option * reference list * bool * bool) + | TacDAuto of int option * int option + + (* Context management *) + | TacClear of 'id list + | TacClearBody of 'id list + | TacMove of bool * 'id * 'id + | TacRename of 'id * 'id + + (* Constructors *) + | TacLeft of 'constr bindings + | TacRight of 'constr bindings + | TacSplit of bool * 'constr bindings + | TacAnyConstructor of 'tac option + | TacConstructor of int or_metaid * 'constr bindings + + (* Conversion *) + | TacReduce of ('constr,'cst) red_expr_gen * 'id gclause + | TacChange of + 'constr occurrences option * 'constr * 'id gclause + + (* Equivalence relations *) + | TacReflexivity + | TacSymmetry of 'id gclause + | TacTransitivity of 'constr + + (* Equality and inversion *) + | TacInversion of ('constr,'id) inversion_strength * quantified_hypothesis + + (* For ML extensions *) + | TacExtend of loc * string * ('constr,'tac) generic_argument list + + (* For syntax extensions *) + | TacAlias of loc * string * + (identifier * ('constr,'tac) generic_argument) list + * (dir_path * 'tac) + +and ('constr,'pat,'cst,'ind,'ref,'id,'tac) gen_tactic_expr = + | TacAtom of loc * ('constr,'pat,'cst,'ind,'ref,'id,'tac) gen_atomic_tactic_expr + | TacThen of ('constr,'pat,'cst,'ind,'ref,'id,'tac) gen_tactic_expr * ('constr,'pat,'cst,'ind,'ref,'id,'tac) gen_tactic_expr + | TacThens of ('constr,'pat,'cst,'ind,'ref,'id,'tac) gen_tactic_expr * ('constr,'pat,'cst,'ind,'ref,'id,'tac) gen_tactic_expr list + | TacFirst of ('constr,'pat,'cst,'ind,'ref,'id,'tac) gen_tactic_expr list + | TacSolve of ('constr,'pat,'cst,'ind,'ref,'id,'tac) gen_tactic_expr list + | TacTry of ('constr,'pat,'cst,'ind,'ref,'id,'tac) gen_tactic_expr + | TacOrelse of ('constr,'pat,'cst,'ind,'ref,'id,'tac) gen_tactic_expr * ('constr,'pat,'cst,'ind,'ref,'id,'tac) gen_tactic_expr + | TacDo of int or_var * ('constr,'pat,'cst,'ind,'ref,'id,'tac) gen_tactic_expr + | TacRepeat of ('constr,'pat,'cst,'ind,'ref,'id,'tac) gen_tactic_expr + | TacProgress of ('constr,'pat,'cst,'ind,'ref,'id,'tac) gen_tactic_expr + | TacAbstract of ('constr,'pat,'cst,'ind,'ref,'id,'tac) gen_tactic_expr * identifier option + | TacId of string + | TacFail of int or_var * string + | TacInfo of ('constr,'pat,'cst,'ind,'ref,'id,'tac) gen_tactic_expr + + | TacLetRecIn of (identifier located * ('constr,'pat,'cst,'ind,'ref,'id,'tac) gen_tactic_fun_ast) list * ('constr,'pat,'cst,'ind,'ref,'id,'tac) gen_tactic_expr + | TacLetIn of (identifier located * ('constr,'pat,'cst,'ind,'ref,'id,'tac) gen_tactic_expr option * ('constr,'pat,'cst,'ind,'ref,'id,'tac) gen_tactic_arg) list * ('constr,'pat,'cst,'ind,'ref,'id,'tac) gen_tactic_expr + | TacMatch of ('constr,'pat,'cst,'ind,'ref,'id,'tac) gen_tactic_expr * ('pat,('constr,'pat,'cst,'ind,'ref,'id,'tac) gen_tactic_expr) match_rule list + | TacMatchContext of direction_flag * ('pat,('constr,'pat,'cst,'ind,'ref,'id,'tac) gen_tactic_expr) match_rule list + | TacFun of ('constr,'pat,'cst,'ind,'ref,'id,'tac) gen_tactic_fun_ast + | TacArg of ('constr,'pat,'cst,'ind,'ref,'id,'tac) gen_tactic_arg + +and ('constr,'pat,'cst,'ind,'ref,'id,'tac) gen_tactic_fun_ast = + identifier option list * ('constr,'pat,'cst,'ind,'ref,'id,'tac) gen_tactic_expr + + (* These are possible arguments of a tactic definition *) +and ('constr,'pat,'cst,'ind,'ref,'id,'tac) gen_tactic_arg = + | TacDynamic of loc * Dyn.t + | TacVoid + | MetaIdArg of loc * string + | ConstrMayEval of ('constr,'cst) may_eval + | IntroPattern of intro_pattern_expr + | Reference of 'ref + | Integer of int + | TacCall of loc * + 'ref * ('constr,'pat,'cst,'ind,'ref,'id,'tac) gen_tactic_arg list + | TacFreshId of string option + | Tacexp of 'tac + +type raw_tactic_expr = + (constr_expr, + pattern_expr, + reference, + reference, + reference, + identifier located or_metaid, + raw_tactic_expr) gen_tactic_expr + +type raw_atomic_tactic_expr = + (constr_expr, (* constr *) + pattern_expr, (* pattern *) + reference, (* evaluable reference *) + reference, (* inductive *) + reference, (* ltac reference *) + identifier located or_metaid, (* identifier *) + raw_tactic_expr) gen_atomic_tactic_expr + +type raw_tactic_arg = + (constr_expr, + pattern_expr, + reference, + reference, + reference, + identifier located or_metaid, + raw_tactic_expr) gen_tactic_arg + +type raw_generic_argument = + (constr_expr,raw_tactic_expr) generic_argument + +type raw_red_expr = (constr_expr, reference) red_expr_gen + +(* Globalized tactics *) +type glob_tactic_expr = + (rawconstr_and_expr, + constr_pattern, + evaluable_global_reference and_short_name or_var, + inductive or_var, + ltac_constant located or_var, + identifier located, + glob_tactic_expr) gen_tactic_expr + +type glob_atomic_tactic_expr = + (rawconstr_and_expr, + constr_pattern, + evaluable_global_reference and_short_name or_var, + inductive or_var, + ltac_constant located or_var, + identifier located, + glob_tactic_expr) gen_atomic_tactic_expr + +type glob_tactic_arg = + (rawconstr_and_expr, + constr_pattern, + evaluable_global_reference and_short_name or_var, + inductive or_var, + ltac_constant located, + identifier located or_var, + glob_tactic_expr) gen_tactic_arg + +type glob_generic_argument = + (rawconstr_and_expr,glob_tactic_expr) generic_argument + +type glob_red_expr = + (rawconstr_and_expr, evaluable_global_reference or_var) red_expr_gen + +type closed_raw_generic_argument = + (constr_expr,raw_tactic_expr) generic_argument + +type 'a raw_abstract_argument_type = + ('a,constr_expr,raw_tactic_expr) abstract_argument_type + +type 'a glob_abstract_argument_type = + ('a,rawconstr_and_expr,glob_tactic_expr) abstract_argument_type + +type open_generic_argument = + (Term.constr,glob_tactic_expr) generic_argument + +type closed_generic_argument = + (Term.constr,glob_tactic_expr) generic_argument + +type 'a closed_abstract_argument_type = + ('a,Term.constr,glob_tactic_expr) abstract_argument_type + +type declaration_hook = Decl_kinds.strength -> global_reference -> unit diff --git a/proofs/tacmach.ml b/proofs/tacmach.ml new file mode 100644 index 00000000..0e3a49b0 --- /dev/null +++ b/proofs/tacmach.ml @@ -0,0 +1,260 @@ +(************************************************************************) +(* v * The Coq Proof Assistant / The Coq Development Team *) +(* mt () + | a::l1 -> (f a) ++ pr_list f l1 + +let pr_gls gls = + hov 0 (pr_decls (sig_sig gls) ++ fnl () ++ pr_seq (sig_it gls)) + +let pr_glls glls = + hov 0 (pr_decls (sig_sig glls) ++ fnl () ++ + prlist_with_sep pr_fnl pr_seq (sig_it glls)) + diff --git a/proofs/tacmach.mli b/proofs/tacmach.mli new file mode 100644 index 00000000..59b48da2 --- /dev/null +++ b/proofs/tacmach.mli @@ -0,0 +1,183 @@ +(************************************************************************) +(* v * The Coq Proof Assistant / The Coq Development Team *) +(* 'a +val project : goal sigma -> evar_map + +val re_sig : 'a -> evar_map -> 'a sigma + +val unpackage : 'a sigma -> evar_map ref * 'a +val repackage : evar_map ref -> 'a -> 'a sigma +val apply_sig_tac : + evar_map ref -> ('a sigma -> 'b sigma * 'c) -> 'a -> 'b * 'c + +val pf_concl : goal sigma -> types +val pf_env : goal sigma -> env +val pf_hyps : goal sigma -> named_context +(*i val pf_untyped_hyps : goal sigma -> (identifier * constr) list i*) +val pf_hyps_types : goal sigma -> (identifier * types) list +val pf_nth_hyp_id : goal sigma -> int -> identifier +val pf_last_hyp : goal sigma -> named_declaration +val pf_ids_of_hyps : goal sigma -> identifier list +val pf_global : goal sigma -> identifier -> constr +val pf_parse_const : goal sigma -> string -> constr +val pf_type_of : goal sigma -> constr -> types +val pf_check_type : goal sigma -> constr -> types -> unit +val pf_execute : goal sigma -> constr -> unsafe_judgment +val hnf_type_of : goal sigma -> constr -> types + +val pf_interp_constr : goal sigma -> Topconstr.constr_expr -> constr +val pf_interp_type : goal sigma -> Topconstr.constr_expr -> types + +val pf_get_hyp : goal sigma -> identifier -> named_declaration +val pf_get_hyp_typ : goal sigma -> identifier -> types + +val pf_get_new_id : identifier -> goal sigma -> identifier +val pf_get_new_ids : identifier list -> goal sigma -> identifier list + +val pf_reduction_of_redexp : goal sigma -> red_expr -> constr -> constr + + +val pf_apply : (env -> evar_map -> 'a) -> goal sigma -> 'a +val pf_reduce : + (env -> evar_map -> constr -> constr) -> + goal sigma -> constr -> constr + +val pf_whd_betadeltaiota : goal sigma -> constr -> constr +val pf_whd_betadeltaiota_stack : goal sigma -> constr -> constr * constr list +val pf_hnf_constr : goal sigma -> constr -> constr +val pf_red_product : goal sigma -> constr -> constr +val pf_nf : goal sigma -> constr -> constr +val pf_nf_betaiota : goal sigma -> constr -> constr +val pf_reduce_to_quantified_ind : goal sigma -> types -> inductive * types +val pf_reduce_to_atomic_ind : goal sigma -> types -> inductive * types +val pf_compute : goal sigma -> constr -> constr +val pf_unfoldn : (int list * evaluable_global_reference) list + -> goal sigma -> constr -> constr + +val pf_const_value : goal sigma -> constant -> constr +val pf_conv_x : goal sigma -> constr -> constr -> bool +val pf_conv_x_leq : goal sigma -> constr -> constr -> bool + +type transformation_tactic = proof_tree -> (goal list * validation) + +val frontier : transformation_tactic + + +(*s Functions for handling the state of the proof editor. *) + +type pftreestate = Refiner.pftreestate + +val proof_of_pftreestate : pftreestate -> proof_tree +val cursor_of_pftreestate : pftreestate -> int list +val is_top_pftreestate : pftreestate -> bool +val evc_of_pftreestate : pftreestate -> evar_map +val top_goal_of_pftreestate : pftreestate -> goal sigma +val nth_goal_of_pftreestate : int -> pftreestate -> goal sigma +val traverse : int -> pftreestate -> pftreestate +val weak_undo_pftreestate : pftreestate -> pftreestate +val solve_nth_pftreestate : int -> tactic -> pftreestate -> pftreestate +val solve_pftreestate : tactic -> pftreestate -> pftreestate +val mk_pftreestate : goal -> pftreestate +val extract_open_pftreestate : pftreestate -> constr * Termops.metamap +val extract_pftreestate : pftreestate -> constr +val first_unproven : pftreestate -> pftreestate +val last_unproven : pftreestate -> pftreestate +val nth_unproven : int -> pftreestate -> pftreestate +val node_prev_unproven : int -> pftreestate -> pftreestate +val node_next_unproven : int -> pftreestate -> pftreestate +val next_unproven : pftreestate -> pftreestate +val prev_unproven : pftreestate -> pftreestate +val top_of_tree : pftreestate -> pftreestate +val change_constraints_pftreestate : + evar_map -> pftreestate -> pftreestate + +(* +val vernac_tactic : string * tactic_arg list -> tactic +*) +(*s The most primitive tactics. *) + +val refiner : rule -> tactic +val introduction_no_check : identifier -> tactic +val intro_replacing_no_check : identifier -> tactic +val internal_cut_no_check : identifier -> types -> tactic +val internal_cut_rev_no_check : identifier -> types -> tactic +val refine_no_check : constr -> tactic +val convert_concl_no_check : types -> tactic +val convert_hyp_no_check : named_declaration -> tactic +val thin_no_check : identifier list -> tactic +val thin_body_no_check : identifier list -> tactic +val move_hyp_no_check : bool -> identifier -> identifier -> tactic +val rename_hyp_no_check : identifier -> identifier -> tactic +val mutual_fix : + identifier -> int -> (identifier * int * constr) list -> tactic +val mutual_cofix : identifier -> (identifier * constr) list -> tactic +val rename_bound_var_goal : tactic + +(*s The most primitive tactics with consistency and type checking *) + +val introduction : identifier -> tactic +val intro_replacing : identifier -> tactic +val internal_cut : identifier -> types -> tactic +val internal_cut_rev : identifier -> types -> tactic +val refine : constr -> tactic +val convert_concl : constr -> tactic +val convert_hyp : named_declaration -> tactic +val thin : identifier list -> tactic +val convert_concl : types -> tactic +val convert_hyp : named_declaration -> tactic +val thin : identifier list -> tactic +val thin_body : identifier list -> tactic +val move_hyp : bool -> identifier -> identifier -> tactic +val rename_hyp : identifier -> identifier -> tactic + +(*s Tactics handling a list of goals. *) + +type validation_list = proof_tree list -> proof_tree list + +type tactic_list = (goal list sigma) -> (goal list sigma) * validation_list + +val first_goal : 'a list sigma -> 'a sigma +val goal_goal_list : 'a sigma -> 'a list sigma +val apply_tac_list : tactic -> tactic_list +val then_tactic_list : tactic_list -> tactic_list -> tactic_list +val tactic_list_tactic : tactic_list -> tactic +val tclFIRSTLIST : tactic_list list -> tactic_list +val tclIDTAC_list : tactic_list + +(*s Pretty-printing functions. *) + +(*i*) +open Pp +(*i*) + +val pr_gls : goal sigma -> std_ppcmds +val pr_glls : goal list sigma -> std_ppcmds diff --git a/proofs/tactic_debug.ml b/proofs/tactic_debug.ml new file mode 100644 index 00000000..1fa1101d --- /dev/null +++ b/proofs/tactic_debug.ml @@ -0,0 +1,179 @@ +(************************************************************************) +(* v * The Coq Proof Assistant / The Coq Development Team *) +(* mt()) + +(* Prints the goal *) +let db_pr_goal g = + msgnl (str "Goal:" ++ fnl () ++ Proof_trees.pr_goal (Tacmach.sig_it g)) + +(* Prints the commands *) +let help () = + msgnl (str "Commands: =Continue" ++ fnl() ++ + str " h/?=Help" ++ fnl() ++ + str " r=Run times" ++ fnl() ++ + str " s=Skip" ++ fnl() ++ + str " x=Exit") + +(* Prints the goal and the command to be executed *) +let goal_com g tac = + begin + db_pr_goal g; + msg (str "Going to execute:" ++ fnl () ++ pr_glob_tactic tac ++ fnl ()) + end + +(* Gives the number of a run command *) +let run_com inst = + if (String.get inst 0)='r' then + let num = int_of_string (String.sub inst 1 ((String.length inst)-1)) in + if num>0 then num + else raise (Invalid_argument "run_com") + else + raise (Invalid_argument "run_com") + +let allskip = ref 0 +let skip = ref 0 + +(* Prints the run counter *) +let run ini = + if not ini then + for i=1 to 2 do + print_char (Char.chr 8);print_char (Char.chr 13) + done; + msg (str "Executed expressions: " ++ int (!allskip - !skip) ++ + fnl() ++ fnl()) + +(* Prints the prompt *) +let rec prompt level = + begin + msg (fnl () ++ str "TcDebug (" ++ int level ++ str ") > "); + flush stdout; + let inst = read_line () in + match inst with + | "" -> true + | "s" -> false + | "x" -> print_char (Char.chr 8);skip:=0;allskip:=0;raise Sys.Break + | "h"| "?" -> + begin + help (); + prompt level + end + | _ -> + (try let ctr=run_com inst in skip:=ctr;allskip:=ctr;run true;true + with Failure _ | Invalid_argument _ -> prompt level) + end + +(* Prints the state and waits for an instruction *) +let debug_prompt lev g tac f = + (* What to print and to do next *) + let continue = + if !skip = 0 then (goal_com g tac; prompt lev) + else (decr skip; run false; if !skip=0 then allskip:=0; true) in + (* What to execute *) + try f (if continue then DebugOn (lev+1) else DebugOff) + with e -> + skip:=0; allskip:=0; + if Logic.catchable_exception e then + ppnl (str "Level " ++ int lev ++ str ": " ++ !explain_logic_error e); + raise e + +(* Prints a constr *) +let db_constr debug env c = + if debug <> DebugOff & !skip = 0 then + msgnl (str "Evaluated term: " ++ prterm_env env c) + +(* Prints the pattern rule *) +let db_pattern_rule debug num r = + if debug <> DebugOff & !skip = 0 then + begin + msgnl (str "Pattern rule " ++ int num ++ str ":"); + msgnl (str "|" ++ spc () ++ + pr_match_rule false Printer.pr_pattern pr_glob_tactic r) + end + +(* Prints the hypothesis pattern identifier if it exists *) +let hyp_bound = function + | Anonymous -> " (unbound)" + | Name id -> " (bound to "^(Names.string_of_id id)^")" + +(* Prints a matched hypothesis *) +let db_matched_hyp debug env (id,c) ido = + if debug <> DebugOff & !skip = 0 then + msgnl (str "Hypothesis " ++ + str ((Names.string_of_id id)^(hyp_bound ido)^ + " has been matched: ") ++ prterm_env env c) + +(* Prints the matched conclusion *) +let db_matched_concl debug env c = + if debug <> DebugOff & !skip = 0 then + msgnl (str "Conclusion has been matched: " ++ prterm_env env c) + +(* Prints a success message when the goal has been matched *) +let db_mc_pattern_success debug = + if debug <> DebugOff & !skip = 0 then + msgnl (str "The goal has been successfully matched!" ++ fnl() ++ + str "Let us execute the right-hand side part..." ++ fnl()) + +let pp_match_pattern env = function + | Term c -> Term (extern_pattern env (names_of_rel_context env) c) + | Subterm (o,c) -> + Subterm (o,(extern_pattern env (names_of_rel_context env) c)) + +(* Prints a failure message for an hypothesis pattern *) +let db_hyp_pattern_failure debug env (na,hyp) = + if debug <> DebugOff & !skip = 0 then + msgnl (str ("The pattern hypothesis"^(hyp_bound na)^ + " cannot match: ") ++ + pr_match_pattern + (Printer.pr_pattern_env env (names_of_rel_context env)) + hyp) + +(* Prints a matching failure message for a rule *) +let db_matching_failure debug = + if debug <> DebugOff & !skip = 0 then + msgnl (str "This rule has failed due to matching errors!" ++ fnl() ++ + str "Let us try the next one...") + +(* Prints an evaluation failure message for a rule *) +let db_eval_failure debug s = + if debug <> DebugOff & !skip = 0 then + let s = if s="" then "no message" else "message \""^s^"\"" in + msgnl + (str "This rule has failed due to \"Fail\" tactic (" ++ + str s ++ str ", level 0)!" ++ fnl() ++ str "Let us try the next one...") + +(* Prints a logic failure message for a rule *) +let db_logic_failure debug err = + if debug <> DebugOff & !skip = 0 then + begin + msgnl (!explain_logic_error err); + msgnl (str "This rule has failed due to a logic error!" ++ fnl() ++ + str "Let us try the next one...") + end diff --git a/proofs/tactic_debug.mli b/proofs/tactic_debug.mli new file mode 100644 index 00000000..9ab263c4 --- /dev/null +++ b/proofs/tactic_debug.mli @@ -0,0 +1,62 @@ +(************************************************************************) +(* v * The Coq Proof Assistant / The Coq Development Team *) +(* goal sigma -> glob_tactic_expr -> (debug_info -> 'a) -> 'a + +(* Prints a constr *) +val db_constr : debug_info -> env -> constr -> unit + +(* Prints the pattern rule *) +val db_pattern_rule : + debug_info -> int -> (constr_pattern,glob_tactic_expr) match_rule -> unit + +(* Prints a matched hypothesis *) +val db_matched_hyp : + debug_info -> env -> identifier * constr -> name -> unit + +(* Prints the matched conclusion *) +val db_matched_concl : debug_info -> env -> constr -> unit + +(* Prints a success message when the goal has been matched *) +val db_mc_pattern_success : debug_info -> unit + +(* Prints a failure message for an hypothesis pattern *) +val db_hyp_pattern_failure : + debug_info -> env -> name * constr_pattern match_pattern -> unit + +(* Prints a matching failure message for a rule *) +val db_matching_failure : debug_info -> unit + +(* Prints an evaluation failure message for a rule *) +val db_eval_failure : debug_info -> string -> unit + +(* An exception handler *) +val explain_logic_error: (exn -> Pp.std_ppcmds) ref + +(* Prints a logic failure message for a rule *) +val db_logic_failure : debug_info -> exn -> unit diff --git a/proofs/tmp-src b/proofs/tmp-src new file mode 100644 index 00000000..1da11fe0 --- /dev/null +++ b/proofs/tmp-src @@ -0,0 +1,56 @@ + +(********* INSTANTIATE ****************************************************) + +(* existential_type gives the type of an existential *) +let existential_type env k = + let (sp,args) = destConst k in + let evd = Evd.map (evar_map env) sp in + instantiate_constr + (ids_of_sign evd.evar_hyps) evd.evar_concl.body (Array.to_list args) + +(* existential_value gives the value of a defined existential *) +let existential_value env k = + let (sp,args) = destConst k in + if defined_const env k then + let evd = Evd.map (evar_map env) sp in + match evd.evar_body with + | EVAR_DEFINED c -> + instantiate_constr (ids_of_sign evd.evar_hyps) c (Array.to_list args) + | _ -> anomalylabstrm "termenv__existential_value" + [< 'sTR"The existential variable code just registered a" ; + 'sPC ; 'sTR"grave internal error." >] + else + failwith "undefined existential" + + +(******* REDUCTION ********************************************************) + + +(************ REDUCTION.MLI **********************************************) + +(*********** TYPEOPS *****************************************************) + + +(* Constants or existentials. *) + +let type_of_constant_or_existential env c = + if is_existential c then + type_of_existential env c + else + type_of_constant env c + + +(******** TYPING **********************************************************) + + | IsMeta n -> + let metaty = + try lookup_meta n env + with Not_found -> error "A variable remains non instanciated" + in + (match kind_of_term metaty with + | IsCast (typ,kind) -> + ({ uj_val = cstr; uj_type = typ; uj_kind = kind }, cst0) + | _ -> + let (jty,cst) = execute mf env metaty in + let k = whd_betadeltaiotaeta env jty.uj_type in + ({ uj_val = cstr; uj_type = metaty; uj_kind = k }, cst)) -- cgit v1.2.3 From 6497f27021fec4e01f2182014f2bb1989b4707f9 Mon Sep 17 00:00:00 2001 From: Samuel Mimram Date: Mon, 31 Jan 2005 14:34:14 +0000 Subject: Imported Upstream version 8.0pl2 --- .depend | 6183 ++++++++++++++++++------------------- .depend.coq | 2 +- CHANGES | 17 + Makefile | 33 +- configure | 6 +- contrib/funind/tacinv.ml4 | 61 +- contrib/funind/tacinvutils.ml | 7 +- contrib/interface/xlate.ml | 12 +- dev/top_printers.ml | 6 +- ide/command_windows.mli | 2 +- ide/coq.mli | 2 +- ide/coq_tactics.mli | 2 +- ide/coqide.ml | 4 +- ide/coqide.mli | 2 +- ide/find_phrase.mll | 10 +- ide/highlight.mll | 9 +- ide/ideutils.mli | 2 +- ide/preferences.mli | 2 +- ide/undo.mli | 2 +- interp/constrextern.mli | 2 +- interp/constrintern.ml | 28 +- interp/constrintern.mli | 4 +- interp/coqlib.mli | 4 +- interp/doc.tex | 6 +- interp/genarg.ml | 11 +- interp/genarg.mli | 35 +- interp/ppextend.mli | 2 +- interp/symbols.ml | 4 +- interp/symbols.mli | 14 +- interp/topconstr.ml | 16 +- interp/topconstr.mli | 8 +- kernel/conv_oracle.mli | 2 +- kernel/declarations.mli | 10 +- kernel/environ.mli | 4 +- kernel/esubst.mli | 2 +- kernel/inductive.mli | 4 +- kernel/mod_typing.mli | 2 +- kernel/modops.mli | 4 +- lib/bignat.mli | 4 +- lib/compat.ml4 | 11 +- lib/heap.mli | 2 +- lib/predicate.mli | 2 +- lib/profile.mli | 2 +- lib/rtree.mli | 4 +- lib/util.ml | 5 +- library/declaremods.mli | 6 +- library/lib.ml | 14 +- library/lib.mli | 9 +- library/libnames.mli | 8 +- library/libobject.mli | 4 +- library/library.ml | 14 +- library/nameops.ml | 6 +- library/nameops.mli | 4 +- library/nametab.mli | 9 +- parsing/argextend.ml4 | 19 +- parsing/coqast.mli | 6 +- parsing/doc.tex | 9 + parsing/egrammar.ml | 18 +- parsing/egrammar.mli | 13 +- parsing/esyntax.mli | 12 +- parsing/extend.mli | 7 +- parsing/g_constr.ml4 | 4 +- parsing/g_constrnew.ml4 | 4 +- parsing/g_natsyntax.ml | 4 +- parsing/g_tactic.ml4 | 11 +- parsing/g_tacticnew.ml4 | 14 +- parsing/g_vernac.ml4 | 6 +- parsing/g_vernacnew.ml4 | 5 +- parsing/g_zsyntax.ml | 13 +- parsing/pcoq.ml4 | 10 +- parsing/pcoq.mli | 5 +- parsing/ppconstr.ml | 5 +- parsing/ppconstr.mli | 2 +- parsing/pptactic.ml | 9 +- parsing/pptactic.mli | 2 +- parsing/printer.mli | 6 +- parsing/q_coqast.ml4 | 16 +- pretyping/cases.ml | 172 +- pretyping/evarconv.ml | 9 +- pretyping/evarutil.ml | 38 +- pretyping/inductiveops.ml | 6 +- pretyping/inductiveops.mli | 4 +- pretyping/matching.mli | 4 +- pretyping/pattern.ml | 5 +- pretyping/rawterm.ml | 6 +- pretyping/rawterm.mli | 10 +- pretyping/tacred.ml | 12 +- pretyping/tacred.mli | 4 +- pretyping/termops.mli | 4 +- proofs/clenv.ml | 4 +- proofs/clenv.mli | 6 +- proofs/evar_refiner.ml | 3 +- proofs/evar_refiner.mli | 6 +- proofs/refiner.mli | 3 +- proofs/tacexpr.ml | 2 +- proofs/tacmach.mli | 6 +- scripts/coqc.ml | 13 +- tactics/auto.ml | 70 +- tactics/auto.mli | 4 +- tactics/autorewrite.ml | 9 +- tactics/equality.ml | 83 +- tactics/extraargs.mli | 2 +- tactics/extratactics.ml4 | 12 +- tactics/extratactics.mli | 2 +- tactics/hiddentac.mli | 6 +- tactics/setoid_replace.mli | 2 +- tactics/tacinterp.ml | 69 +- tactics/tacticals.mli | 4 +- tactics/tactics.ml | 14 +- tactics/tactics.mli | 3 +- test-suite/check | 2 +- test-suite/success/RecTutorial.v8 | 1229 ++++++++ test-suite/success/univers.v | 21 + theories/Arith/Arith.v | 5 +- theories/Init/Notations.v | 6 +- theories/Logic/Berardi.v | 6 +- theories/Logic/ChoiceFacts.v | 8 +- theories/Logic/Diaconescu.v | 28 +- theories/Logic/JMeq.v | 13 +- theories/Logic/RelationalChoice.v | 4 +- theories/ZArith/ZArith.v | 3 +- tools/coq_makefile.ml4 | 12 +- tools/coqdoc/index.mll | 4 +- toplevel/class.ml | 12 +- toplevel/command.ml | 49 +- toplevel/coqtop.ml | 4 +- toplevel/himsg.ml | 50 +- toplevel/metasyntax.ml | 149 +- toplevel/recordobj.mli | 2 +- toplevel/usage.ml | 14 +- toplevel/vernacentries.mli | 6 +- toplevel/vernacexpr.ml | 2 +- translate/ppconstrnew.ml | 53 +- translate/ppconstrnew.mli | 2 +- translate/pptacticnew.mli | 4 +- translate/ppvernacnew.ml | 4 +- translate/ppvernacnew.mli | 2 +- 137 files changed, 5323 insertions(+), 3798 deletions(-) create mode 100644 parsing/doc.tex create mode 100644 test-suite/success/RecTutorial.v8 (limited to 'proofs') diff --git a/.depend b/.depend index 5ac89a4e..d158d8dc 100644 --- a/.depend +++ b/.depend @@ -1,743 +1,744 @@ ide/config_parser.cmi: lib/util.cmi -ide/coq.cmi: kernel/environ.cmi pretyping/evd.cmi kernel/names.cmi \ - kernel/term.cmi lib/util.cmi toplevel/vernacexpr.cmo -interp/constrextern.cmi: kernel/environ.cmi library/impargs.cmi \ - library/libnames.cmi kernel/names.cmi library/nametab.cmi \ - pretyping/pattern.cmi pretyping/rawterm.cmi kernel/sign.cmi \ - interp/symbols.cmi kernel/term.cmi pretyping/termops.cmi \ - interp/topconstr.cmi lib/util.cmi -interp/constrintern.cmi: parsing/coqast.cmi kernel/environ.cmi \ - pretyping/evd.cmi library/impargs.cmi library/libnames.cmi \ - kernel/names.cmi pretyping/pattern.cmi pretyping/rawterm.cmi \ - kernel/sign.cmi kernel/term.cmi pretyping/termops.cmi \ - interp/topconstr.cmi -interp/coqlib.cmi: library/libnames.cmi kernel/names.cmi library/nametab.cmi \ - pretyping/pattern.cmi kernel/term.cmi -interp/genarg.cmi: pretyping/evd.cmi library/libnames.cmi kernel/names.cmi \ - lib/pp.cmi pretyping/rawterm.cmi kernel/term.cmi interp/topconstr.cmi \ - lib/util.cmi -interp/modintern.cmi: kernel/declarations.cmi kernel/entries.cmi \ - kernel/environ.cmi interp/topconstr.cmi -interp/ppextend.cmi: kernel/names.cmi lib/pp.cmi -interp/reserve.cmi: kernel/names.cmi pretyping/rawterm.cmi lib/util.cmi -interp/symbols.cmi: lib/bignat.cmi pretyping/classops.cmi \ - library/libnames.cmi kernel/names.cmi library/nametab.cmi lib/pp.cmi \ - interp/ppextend.cmi pretyping/rawterm.cmi kernel/term.cmi \ - interp/topconstr.cmi lib/util.cmi -interp/syntax_def.cmi: kernel/names.cmi pretyping/rawterm.cmi \ - interp/topconstr.cmi lib/util.cmi -interp/topconstr.cmi: lib/bignat.cmi lib/dyn.cmi library/libnames.cmi \ - kernel/names.cmi lib/pp.cmi pretyping/rawterm.cmi kernel/term.cmi \ - lib/util.cmi -kernel/closure.cmi: kernel/environ.cmi kernel/esubst.cmi kernel/names.cmi \ - lib/pp.cmi kernel/term.cmi -kernel/conv_oracle.cmi: kernel/closure.cmi kernel/names.cmi -kernel/cooking.cmi: kernel/declarations.cmi kernel/environ.cmi \ - kernel/names.cmi kernel/term.cmi kernel/univ.cmi -kernel/declarations.cmi: kernel/names.cmi lib/rtree.cmi kernel/sign.cmi \ - kernel/term.cmi kernel/univ.cmi -kernel/entries.cmi: kernel/names.cmi kernel/sign.cmi kernel/term.cmi \ - kernel/univ.cmi -kernel/environ.cmi: kernel/declarations.cmi kernel/names.cmi kernel/sign.cmi \ - kernel/term.cmi kernel/univ.cmi +ide/coq.cmi: toplevel/vernacexpr.cmo lib/util.cmi kernel/term.cmi \ + kernel/names.cmi pretyping/evd.cmi kernel/environ.cmi +interp/constrextern.cmi: lib/util.cmi interp/topconstr.cmi \ + pretyping/termops.cmi kernel/term.cmi interp/symbols.cmi kernel/sign.cmi \ + pretyping/rawterm.cmi pretyping/pattern.cmi library/nametab.cmi \ + kernel/names.cmi library/libnames.cmi library/impargs.cmi \ + kernel/environ.cmi +interp/constrintern.cmi: interp/topconstr.cmi pretyping/termops.cmi \ + kernel/term.cmi kernel/sign.cmi pretyping/rawterm.cmi \ + pretyping/pattern.cmi kernel/names.cmi library/libnames.cmi \ + library/impargs.cmi pretyping/evd.cmi kernel/environ.cmi \ + parsing/coqast.cmi +interp/coqlib.cmi: kernel/term.cmi pretyping/pattern.cmi library/nametab.cmi \ + kernel/names.cmi library/libnames.cmi +interp/genarg.cmi: lib/util.cmi interp/topconstr.cmi kernel/term.cmi \ + pretyping/rawterm.cmi lib/pp.cmi kernel/names.cmi library/libnames.cmi \ + pretyping/evd.cmi +interp/modintern.cmi: interp/topconstr.cmi kernel/environ.cmi \ + kernel/entries.cmi kernel/declarations.cmi +interp/ppextend.cmi: lib/pp.cmi kernel/names.cmi +interp/reserve.cmi: lib/util.cmi pretyping/rawterm.cmi kernel/names.cmi +interp/symbols.cmi: lib/util.cmi interp/topconstr.cmi kernel/term.cmi \ + pretyping/rawterm.cmi interp/ppextend.cmi lib/pp.cmi library/nametab.cmi \ + kernel/names.cmi library/libnames.cmi pretyping/classops.cmi \ + lib/bignat.cmi +interp/syntax_def.cmi: lib/util.cmi interp/topconstr.cmi \ + pretyping/rawterm.cmi kernel/names.cmi +interp/topconstr.cmi: lib/util.cmi kernel/term.cmi pretyping/rawterm.cmi \ + lib/pp.cmi kernel/names.cmi library/libnames.cmi lib/dyn.cmi \ + lib/bignat.cmi +kernel/closure.cmi: kernel/term.cmi lib/pp.cmi kernel/names.cmi \ + kernel/esubst.cmi kernel/environ.cmi +kernel/conv_oracle.cmi: kernel/names.cmi kernel/closure.cmi +kernel/cooking.cmi: kernel/univ.cmi kernel/term.cmi kernel/names.cmi \ + kernel/environ.cmi kernel/declarations.cmi +kernel/declarations.cmi: kernel/univ.cmi kernel/term.cmi kernel/sign.cmi \ + lib/rtree.cmi kernel/names.cmi +kernel/entries.cmi: kernel/univ.cmi kernel/term.cmi kernel/sign.cmi \ + kernel/names.cmi +kernel/environ.cmi: kernel/univ.cmi kernel/term.cmi kernel/sign.cmi \ + kernel/names.cmi kernel/declarations.cmi kernel/esubst.cmi: lib/util.cmi -kernel/indtypes.cmi: kernel/declarations.cmi kernel/entries.cmi \ - kernel/environ.cmi kernel/names.cmi kernel/term.cmi kernel/typeops.cmi \ - kernel/univ.cmi -kernel/inductive.cmi: kernel/declarations.cmi kernel/environ.cmi \ - kernel/names.cmi kernel/term.cmi kernel/univ.cmi -kernel/modops.cmi: kernel/declarations.cmi kernel/entries.cmi \ - kernel/environ.cmi kernel/names.cmi kernel/univ.cmi lib/util.cmi -kernel/mod_typing.cmi: kernel/declarations.cmi kernel/entries.cmi \ +kernel/indtypes.cmi: kernel/univ.cmi kernel/typeops.cmi kernel/term.cmi \ + kernel/names.cmi kernel/environ.cmi kernel/entries.cmi \ + kernel/declarations.cmi +kernel/inductive.cmi: kernel/univ.cmi kernel/term.cmi kernel/names.cmi \ + kernel/environ.cmi kernel/declarations.cmi +kernel/mod_typing.cmi: kernel/environ.cmi kernel/entries.cmi \ + kernel/declarations.cmi +kernel/modops.cmi: lib/util.cmi kernel/univ.cmi kernel/names.cmi \ + kernel/environ.cmi kernel/entries.cmi kernel/declarations.cmi +kernel/names.cmi: lib/predicate.cmi lib/pp.cmi +kernel/reduction.cmi: kernel/univ.cmi kernel/term.cmi kernel/sign.cmi \ kernel/environ.cmi -kernel/names.cmi: lib/pp.cmi lib/predicate.cmi -kernel/reduction.cmi: kernel/environ.cmi kernel/sign.cmi kernel/term.cmi \ - kernel/univ.cmi -kernel/safe_typing.cmi: kernel/cooking.cmi kernel/declarations.cmi \ - kernel/entries.cmi kernel/environ.cmi kernel/names.cmi kernel/term.cmi \ - kernel/univ.cmi -kernel/sign.cmi: kernel/names.cmi kernel/term.cmi -kernel/subtyping.cmi: kernel/declarations.cmi kernel/environ.cmi \ - kernel/univ.cmi -kernel/term.cmi: kernel/esubst.cmi kernel/names.cmi kernel/univ.cmi -kernel/term_typing.cmi: kernel/cooking.cmi kernel/declarations.cmi \ - kernel/entries.cmi kernel/environ.cmi kernel/inductive.cmi \ - kernel/names.cmi kernel/term.cmi kernel/typeops.cmi kernel/univ.cmi -kernel/type_errors.cmi: kernel/environ.cmi kernel/names.cmi kernel/term.cmi -kernel/typeops.cmi: kernel/entries.cmi kernel/environ.cmi kernel/names.cmi \ - kernel/sign.cmi kernel/term.cmi kernel/univ.cmi -kernel/univ.cmi: kernel/names.cmi lib/pp.cmi +kernel/safe_typing.cmi: kernel/univ.cmi kernel/term.cmi kernel/names.cmi \ + kernel/environ.cmi kernel/entries.cmi kernel/declarations.cmi \ + kernel/cooking.cmi +kernel/sign.cmi: kernel/term.cmi kernel/names.cmi +kernel/subtyping.cmi: kernel/univ.cmi kernel/environ.cmi \ + kernel/declarations.cmi +kernel/term.cmi: kernel/univ.cmi kernel/names.cmi kernel/esubst.cmi +kernel/term_typing.cmi: kernel/univ.cmi kernel/typeops.cmi kernel/term.cmi \ + kernel/names.cmi kernel/inductive.cmi kernel/environ.cmi \ + kernel/entries.cmi kernel/declarations.cmi kernel/cooking.cmi +kernel/type_errors.cmi: kernel/term.cmi kernel/names.cmi kernel/environ.cmi +kernel/typeops.cmi: kernel/univ.cmi kernel/term.cmi kernel/sign.cmi \ + kernel/names.cmi kernel/environ.cmi kernel/entries.cmi +kernel/univ.cmi: lib/pp.cmi kernel/names.cmi lib/bignat.cmi: lib/pp.cmi lib/pp.cmi: lib/pp_control.cmi -library/declare.cmi: kernel/cooking.cmi library/decl_kinds.cmo \ - kernel/declarations.cmi library/dischargedhypsmap.cmi kernel/entries.cmi \ - kernel/indtypes.cmi library/libnames.cmi library/libobject.cmi \ - kernel/names.cmi library/nametab.cmi kernel/safe_typing.cmi \ - kernel/sign.cmi kernel/term.cmi kernel/univ.cmi -library/declaremods.cmi: kernel/entries.cmi kernel/environ.cmi \ - library/lib.cmi library/libnames.cmi library/libobject.cmi \ - kernel/names.cmi lib/pp.cmi kernel/safe_typing.cmi lib/util.cmi -library/dischargedhypsmap.cmi: kernel/environ.cmi library/libnames.cmi \ - library/nametab.cmi kernel/term.cmi -library/global.cmi: kernel/declarations.cmi kernel/entries.cmi \ - kernel/environ.cmi kernel/indtypes.cmi library/libnames.cmi \ - kernel/names.cmi kernel/safe_typing.cmi kernel/sign.cmi kernel/term.cmi \ - kernel/univ.cmi -library/goptions.cmi: library/libnames.cmi kernel/names.cmi \ - library/nametab.cmi lib/pp.cmi kernel/term.cmi lib/util.cmi -library/impargs.cmi: kernel/environ.cmi library/libnames.cmi kernel/names.cmi \ - library/nametab.cmi kernel/term.cmi interp/topconstr.cmi -library/lib.cmi: library/libnames.cmi library/libobject.cmi kernel/names.cmi \ - library/summary.cmi lib/util.cmi -library/libnames.cmi: kernel/names.cmi lib/pp.cmi lib/predicate.cmi \ - kernel/term.cmi lib/util.cmi -library/libobject.cmi: library/libnames.cmi kernel/names.cmi -library/library.cmi: library/libnames.cmi library/libobject.cmi \ - kernel/names.cmi lib/pp.cmi lib/system.cmi lib/util.cmi -library/nameops.cmi: kernel/names.cmi lib/pp.cmi kernel/term.cmi -library/nametab.cmi: library/libnames.cmi kernel/names.cmi lib/pp.cmi \ - lib/util.cmi lib/rtree.cmi: lib/pp.cmi lib/system.cmi: lib/pp.cmi -lib/util.cmi: lib/compat.cmo lib/pp.cmi -parsing/ast.cmi: parsing/coqast.cmi lib/dyn.cmi interp/genarg.cmi \ - library/libnames.cmi kernel/names.cmi lib/pp.cmi interp/topconstr.cmi \ - lib/util.cmi -parsing/coqast.cmi: lib/dyn.cmi library/libnames.cmi kernel/names.cmi \ - lib/util.cmi -parsing/egrammar.cmi: parsing/ast.cmi parsing/coqast.cmi parsing/extend.cmi \ - interp/genarg.cmi kernel/names.cmi pretyping/rawterm.cmi \ - proofs/tacexpr.cmo interp/topconstr.cmi lib/util.cmi \ - toplevel/vernacexpr.cmo -parsing/esyntax.cmi: parsing/ast.cmi parsing/coqast.cmi parsing/extend.cmi \ - lib/pp.cmi interp/ppextend.cmi interp/symbols.cmi interp/topconstr.cmi -parsing/extend.cmi: parsing/ast.cmi parsing/coqast.cmi interp/genarg.cmi \ - kernel/names.cmi lib/pp.cmi interp/ppextend.cmi interp/topconstr.cmi \ - lib/util.cmi -parsing/g_minicoq.cmi: kernel/environ.cmi kernel/names.cmi lib/pp.cmi \ - kernel/term.cmi -parsing/lexer.cmi: lib/pp.cmi lib/util.cmi -parsing/pcoq.cmi: parsing/ast.cmi lib/bignat.cmi parsing/coqast.cmi \ - library/decl_kinds.cmo parsing/extend.cmi interp/genarg.cmi \ - library/libnames.cmi kernel/names.cmi pretyping/rawterm.cmi \ - proofs/tacexpr.cmo interp/topconstr.cmi lib/util.cmi \ - toplevel/vernacexpr.cmo -parsing/ppconstr.cmi: parsing/coqast.cmi kernel/environ.cmi \ - parsing/extend.cmi library/libnames.cmi kernel/names.cmi parsing/pcoq.cmi \ - lib/pp.cmi pretyping/rawterm.cmi proofs/tacexpr.cmo kernel/term.cmi \ - interp/topconstr.cmi lib/util.cmi -parsing/pptactic.cmi: interp/genarg.cmi library/libnames.cmi lib/pp.cmi \ - pretyping/pretyping.cmi proofs/proof_type.cmi pretyping/rawterm.cmi \ - proofs/tacexpr.cmo kernel/term.cmi interp/topconstr.cmi lib/util.cmi -parsing/prettyp.cmi: pretyping/classops.cmi kernel/environ.cmi \ - library/impargs.cmi library/lib.cmi library/libnames.cmi kernel/names.cmi \ - library/nametab.cmi lib/pp.cmi pretyping/reductionops.cmi \ - kernel/safe_typing.cmi kernel/sign.cmi kernel/term.cmi \ - pretyping/termops.cmi lib/util.cmi -parsing/printer.cmi: kernel/environ.cmi library/libnames.cmi kernel/names.cmi \ - library/nametab.cmi pretyping/pattern.cmi lib/pp.cmi \ - pretyping/rawterm.cmi kernel/sign.cmi kernel/term.cmi \ - pretyping/termops.cmi -parsing/printmod.cmi: kernel/names.cmi lib/pp.cmi -parsing/search.cmi: kernel/environ.cmi library/libnames.cmi kernel/names.cmi \ - library/nametab.cmi pretyping/pattern.cmi lib/pp.cmi kernel/term.cmi -parsing/termast.cmi: parsing/coqast.cmi kernel/environ.cmi \ - library/libnames.cmi kernel/names.cmi library/nametab.cmi \ - pretyping/pattern.cmi pretyping/rawterm.cmi kernel/sign.cmi \ - kernel/term.cmi pretyping/termops.cmi -pretyping/cases.cmi: kernel/environ.cmi pretyping/evarutil.cmi \ - pretyping/evd.cmi pretyping/inductiveops.cmi kernel/names.cmi \ - pretyping/rawterm.cmi kernel/term.cmi lib/util.cmi -pretyping/cbv.cmi: kernel/closure.cmi kernel/environ.cmi kernel/esubst.cmi \ - kernel/names.cmi kernel/term.cmi -pretyping/classops.cmi: library/decl_kinds.cmo kernel/environ.cmi \ - pretyping/evd.cmi library/libnames.cmi library/libobject.cmi \ - kernel/names.cmi library/nametab.cmi lib/pp.cmi kernel/term.cmi -pretyping/coercion.cmi: kernel/environ.cmi pretyping/evarutil.cmi \ - pretyping/evd.cmi kernel/names.cmi pretyping/rawterm.cmi kernel/sign.cmi \ - kernel/term.cmi lib/util.cmi -pretyping/detyping.cmi: kernel/environ.cmi kernel/names.cmi \ - pretyping/rawterm.cmi kernel/sign.cmi kernel/term.cmi \ - pretyping/termops.cmi lib/util.cmi -pretyping/evarconv.cmi: kernel/environ.cmi pretyping/evarutil.cmi \ - pretyping/reductionops.cmi kernel/sign.cmi kernel/term.cmi -pretyping/evarutil.cmi: kernel/environ.cmi pretyping/evd.cmi kernel/names.cmi \ - pretyping/rawterm.cmi pretyping/reductionops.cmi kernel/sign.cmi \ - kernel/term.cmi lib/util.cmi -pretyping/evd.cmi: kernel/names.cmi kernel/sign.cmi kernel/term.cmi -pretyping/indrec.cmi: kernel/declarations.cmi kernel/environ.cmi \ - pretyping/evd.cmi pretyping/inductiveops.cmi kernel/names.cmi \ - kernel/term.cmi -pretyping/inductiveops.cmi: kernel/declarations.cmi kernel/environ.cmi \ - pretyping/evd.cmi kernel/names.cmi kernel/sign.cmi kernel/term.cmi -pretyping/instantiate.cmi: kernel/environ.cmi pretyping/evd.cmi \ - kernel/names.cmi kernel/sign.cmi kernel/term.cmi -pretyping/matching.cmi: kernel/environ.cmi pretyping/evd.cmi kernel/names.cmi \ - pretyping/pattern.cmi kernel/term.cmi pretyping/termops.cmi -pretyping/pattern.cmi: kernel/environ.cmi library/libnames.cmi \ - kernel/names.cmi library/nametab.cmi lib/pp.cmi pretyping/rawterm.cmi \ - kernel/sign.cmi kernel/term.cmi -pretyping/pretype_errors.cmi: kernel/environ.cmi pretyping/evd.cmi \ - pretyping/inductiveops.cmi kernel/names.cmi lib/pp.cmi \ - pretyping/rawterm.cmi kernel/sign.cmi kernel/term.cmi lib/util.cmi -pretyping/pretyping.cmi: lib/dyn.cmi kernel/environ.cmi \ - pretyping/evarutil.cmi pretyping/evd.cmi kernel/names.cmi \ - pretyping/rawterm.cmi kernel/sign.cmi kernel/term.cmi -pretyping/rawterm.cmi: lib/dyn.cmi library/libnames.cmi kernel/names.cmi \ - library/nametab.cmi kernel/sign.cmi kernel/term.cmi kernel/univ.cmi \ - lib/util.cmi -pretyping/recordops.cmi: pretyping/classops.cmi library/libnames.cmi \ - library/libobject.cmi library/library.cmi kernel/names.cmi \ - library/nametab.cmi kernel/term.cmi -pretyping/reductionops.cmi: kernel/closure.cmi kernel/environ.cmi \ - pretyping/evd.cmi kernel/names.cmi kernel/sign.cmi kernel/term.cmi \ - kernel/univ.cmi -pretyping/retyping.cmi: kernel/environ.cmi pretyping/evd.cmi kernel/names.cmi \ - pretyping/pattern.cmi kernel/term.cmi pretyping/termops.cmi -pretyping/tacred.cmi: kernel/closure.cmi kernel/environ.cmi pretyping/evd.cmi \ - library/libnames.cmi kernel/names.cmi pretyping/rawterm.cmi \ - pretyping/reductionops.cmi kernel/term.cmi -pretyping/termops.cmi: kernel/environ.cmi kernel/names.cmi lib/pp.cmi \ - kernel/sign.cmi kernel/term.cmi kernel/univ.cmi lib/util.cmi -pretyping/typing.cmi: kernel/environ.cmi pretyping/evd.cmi kernel/term.cmi -proofs/clenv.cmi: kernel/environ.cmi pretyping/evd.cmi kernel/names.cmi \ - lib/pp.cmi pretyping/pretyping.cmi proofs/proof_type.cmi \ - pretyping/rawterm.cmi pretyping/reductionops.cmi kernel/sign.cmi \ - kernel/term.cmi pretyping/termops.cmi lib/util.cmi -proofs/evar_refiner.cmi: kernel/environ.cmi pretyping/evd.cmi \ - kernel/names.cmi proofs/proof_type.cmi proofs/refiner.cmi kernel/sign.cmi \ - proofs/tacexpr.cmo kernel/term.cmi interp/topconstr.cmi -proofs/logic.cmi: kernel/environ.cmi pretyping/evd.cmi kernel/names.cmi \ - lib/pp.cmi proofs/proof_type.cmi kernel/sign.cmi kernel/term.cmi -proofs/pfedit.cmi: library/decl_kinds.cmo kernel/entries.cmi \ - kernel/environ.cmi pretyping/evd.cmi kernel/names.cmi lib/pp.cmi \ - kernel/sign.cmi proofs/tacexpr.cmo proofs/tacmach.cmi kernel/term.cmi \ - interp/topconstr.cmi lib/util.cmi -proofs/proof_trees.cmi: kernel/environ.cmi pretyping/evd.cmi kernel/names.cmi \ - lib/pp.cmi proofs/proof_type.cmi kernel/sign.cmi kernel/term.cmi \ - lib/util.cmi -proofs/proof_type.cmi: kernel/environ.cmi pretyping/evd.cmi interp/genarg.cmi \ - library/libnames.cmi kernel/names.cmi library/nametab.cmi \ - pretyping/pattern.cmi pretyping/rawterm.cmi proofs/tacexpr.cmo \ - kernel/term.cmi lib/util.cmi -proofs/refiner.cmi: pretyping/evd.cmi lib/pp.cmi proofs/proof_trees.cmi \ - proofs/proof_type.cmi kernel/sign.cmi proofs/tacexpr.cmo kernel/term.cmi \ - pretyping/termops.cmi -proofs/tacmach.cmi: kernel/environ.cmi pretyping/evd.cmi kernel/names.cmi \ - lib/pp.cmi proofs/proof_trees.cmi proofs/proof_type.cmi \ - pretyping/rawterm.cmi kernel/reduction.cmi proofs/refiner.cmi \ - kernel/sign.cmi proofs/tacexpr.cmo pretyping/tacred.cmi kernel/term.cmi \ - pretyping/termops.cmi interp/topconstr.cmi -proofs/tactic_debug.cmi: kernel/environ.cmi kernel/names.cmi \ - pretyping/pattern.cmi lib/pp.cmi proofs/proof_type.cmi proofs/tacexpr.cmo \ - kernel/term.cmi -tactics/auto.cmi: tactics/btermdn.cmi proofs/clenv.cmi kernel/environ.cmi \ - pretyping/evd.cmi library/libnames.cmi kernel/names.cmi \ - pretyping/pattern.cmi lib/pp.cmi proofs/proof_type.cmi \ - pretyping/rawterm.cmi kernel/sign.cmi proofs/tacexpr.cmo \ - proofs/tacmach.cmi kernel/term.cmi lib/util.cmi toplevel/vernacexpr.cmo -tactics/autorewrite.cmi: proofs/tacexpr.cmo proofs/tacmach.cmi \ - kernel/term.cmi -tactics/btermdn.cmi: pretyping/pattern.cmi kernel/term.cmi -tactics/contradiction.cmi: kernel/names.cmi proofs/proof_type.cmi \ - pretyping/rawterm.cmi kernel/term.cmi -tactics/dhyp.cmi: kernel/names.cmi proofs/tacexpr.cmo proofs/tacmach.cmi \ - interp/topconstr.cmi toplevel/vernacexpr.cmo -tactics/eauto.cmi: proofs/proof_type.cmi proofs/tacexpr.cmo kernel/term.cmi -tactics/elim.cmi: interp/genarg.cmi kernel/names.cmi proofs/proof_type.cmi \ - pretyping/rawterm.cmi proofs/tacmach.cmi tactics/tacticals.cmi \ - kernel/term.cmi -tactics/equality.cmi: kernel/environ.cmi pretyping/evd.cmi \ - tactics/hipattern.cmi kernel/names.cmi pretyping/pattern.cmi \ - proofs/proof_type.cmi pretyping/rawterm.cmi kernel/sign.cmi \ - proofs/tacexpr.cmo proofs/tacmach.cmi tactics/tacticals.cmi \ - tactics/tactics.cmi kernel/term.cmi -tactics/extraargs.cmi: parsing/pcoq.cmi proofs/proof_type.cmi \ - proofs/tacexpr.cmo kernel/term.cmi interp/topconstr.cmi -tactics/extratactics.cmi: interp/genarg.cmi kernel/names.cmi \ - proofs/proof_type.cmi pretyping/rawterm.cmi kernel/term.cmi -tactics/hiddentac.cmi: interp/genarg.cmi kernel/names.cmi \ - proofs/proof_type.cmi pretyping/rawterm.cmi proofs/tacexpr.cmo \ - proofs/tacmach.cmi pretyping/tacred.cmi tactics/tacticals.cmi \ - kernel/term.cmi -tactics/hipattern.cmi: interp/coqlib.cmi pretyping/evd.cmi kernel/names.cmi \ - pretyping/pattern.cmi proofs/proof_trees.cmi proofs/proof_type.cmi \ - kernel/sign.cmi proofs/tacmach.cmi kernel/term.cmi lib/util.cmi -tactics/inv.cmi: interp/genarg.cmi kernel/names.cmi pretyping/rawterm.cmi \ - proofs/tacexpr.cmo proofs/tacmach.cmi kernel/term.cmi -tactics/leminv.cmi: kernel/names.cmi proofs/proof_type.cmi \ - pretyping/rawterm.cmi kernel/term.cmi interp/topconstr.cmi -tactics/nbtermdn.cmi: tactics/btermdn.cmi pretyping/pattern.cmi \ - kernel/term.cmi -tactics/refine.cmi: pretyping/pretyping.cmi proofs/tacmach.cmi \ - kernel/term.cmi -tactics/setoid_replace.cmi: kernel/names.cmi proofs/proof_type.cmi \ - kernel/term.cmi interp/topconstr.cmi -tactics/tacinterp.cmi: parsing/coqast.cmi lib/dyn.cmi kernel/environ.cmi \ - pretyping/evd.cmi interp/genarg.cmi kernel/names.cmi library/nametab.cmi \ - lib/pp.cmi proofs/proof_type.cmi proofs/tacexpr.cmo proofs/tacmach.cmi \ - pretyping/tacred.cmi proofs/tactic_debug.cmi kernel/term.cmi \ - interp/topconstr.cmi lib/util.cmi -tactics/tacticals.cmi: proofs/clenv.cmi interp/genarg.cmi kernel/names.cmi \ - pretyping/pattern.cmi proofs/proof_type.cmi kernel/reduction.cmi \ - kernel/sign.cmi proofs/tacexpr.cmo proofs/tacmach.cmi kernel/term.cmi -tactics/tactics.cmi: proofs/clenv.cmi kernel/environ.cmi \ - proofs/evar_refiner.cmi pretyping/evd.cmi interp/genarg.cmi \ - library/libnames.cmi kernel/names.cmi library/nametab.cmi \ - proofs/proof_type.cmi pretyping/rawterm.cmi kernel/reduction.cmi \ - kernel/sign.cmi proofs/tacexpr.cmo proofs/tacmach.cmi \ - pretyping/tacred.cmi tactics/tacticals.cmi kernel/term.cmi \ - interp/topconstr.cmi -tactics/termdn.cmi: pretyping/pattern.cmi kernel/term.cmi -toplevel/cerrors.cmi: lib/pp.cmi lib/util.cmi -toplevel/class.cmi: pretyping/classops.cmi library/decl_kinds.cmo \ - library/declare.cmi library/libnames.cmi kernel/names.cmi \ - library/nametab.cmi proofs/tacexpr.cmo kernel/term.cmi -toplevel/command.cmi: library/decl_kinds.cmo library/declare.cmi \ - kernel/entries.cmi kernel/environ.cmi pretyping/evd.cmi \ - library/libnames.cmi library/library.cmi kernel/names.cmi \ - library/nametab.cmi pretyping/rawterm.cmi proofs/tacexpr.cmo \ - pretyping/tacred.cmi kernel/term.cmi interp/topconstr.cmi lib/util.cmi \ - toplevel/vernacexpr.cmo +lib/util.cmi: lib/pp.cmi lib/compat.cmo +library/declare.cmi: kernel/univ.cmi kernel/term.cmi kernel/sign.cmi \ + kernel/safe_typing.cmi library/nametab.cmi kernel/names.cmi \ + library/libobject.cmi library/libnames.cmi kernel/indtypes.cmi \ + kernel/entries.cmi library/dischargedhypsmap.cmi kernel/declarations.cmi \ + library/decl_kinds.cmo kernel/cooking.cmi +library/declaremods.cmi: lib/util.cmi kernel/safe_typing.cmi lib/pp.cmi \ + kernel/names.cmi library/libobject.cmi library/libnames.cmi \ + library/lib.cmi kernel/environ.cmi kernel/entries.cmi +library/dischargedhypsmap.cmi: kernel/term.cmi library/nametab.cmi \ + library/libnames.cmi kernel/environ.cmi +library/global.cmi: kernel/univ.cmi kernel/term.cmi kernel/sign.cmi \ + kernel/safe_typing.cmi kernel/names.cmi library/libnames.cmi \ + kernel/indtypes.cmi kernel/environ.cmi kernel/entries.cmi \ + kernel/declarations.cmi +library/goptions.cmi: lib/util.cmi kernel/term.cmi lib/pp.cmi \ + library/nametab.cmi kernel/names.cmi library/libnames.cmi +library/impargs.cmi: interp/topconstr.cmi kernel/term.cmi library/nametab.cmi \ + kernel/names.cmi library/libnames.cmi kernel/environ.cmi +library/lib.cmi: lib/util.cmi library/summary.cmi kernel/names.cmi \ + library/libobject.cmi library/libnames.cmi +library/libnames.cmi: lib/util.cmi kernel/term.cmi lib/predicate.cmi \ + lib/pp.cmi kernel/names.cmi +library/libobject.cmi: kernel/names.cmi library/libnames.cmi +library/library.cmi: lib/util.cmi lib/system.cmi lib/pp.cmi kernel/names.cmi \ + library/libobject.cmi library/libnames.cmi +library/nameops.cmi: kernel/term.cmi lib/pp.cmi kernel/names.cmi +library/nametab.cmi: lib/util.cmi lib/pp.cmi kernel/names.cmi \ + library/libnames.cmi +parsing/ast.cmi: lib/util.cmi interp/topconstr.cmi lib/pp.cmi \ + kernel/names.cmi library/libnames.cmi interp/genarg.cmi lib/dyn.cmi \ + parsing/coqast.cmi +parsing/coqast.cmi: lib/util.cmi kernel/names.cmi library/libnames.cmi \ + lib/dyn.cmi +parsing/egrammar.cmi: toplevel/vernacexpr.cmo lib/util.cmi \ + interp/topconstr.cmi proofs/tacexpr.cmo pretyping/rawterm.cmi \ + interp/ppextend.cmi kernel/names.cmi interp/genarg.cmi parsing/extend.cmi \ + parsing/coqast.cmi parsing/ast.cmi +parsing/esyntax.cmi: interp/topconstr.cmi interp/symbols.cmi \ + interp/ppextend.cmi lib/pp.cmi parsing/extend.cmi parsing/coqast.cmi \ + parsing/ast.cmi +parsing/extend.cmi: lib/util.cmi interp/topconstr.cmi interp/ppextend.cmi \ + lib/pp.cmi kernel/names.cmi interp/genarg.cmi parsing/coqast.cmi \ + parsing/ast.cmi +parsing/g_minicoq.cmi: kernel/term.cmi lib/pp.cmi kernel/names.cmi \ + kernel/environ.cmi +parsing/lexer.cmi: lib/util.cmi lib/pp.cmi +parsing/pcoq.cmi: toplevel/vernacexpr.cmo lib/util.cmi interp/topconstr.cmi \ + proofs/tacexpr.cmo pretyping/rawterm.cmi kernel/names.cmi \ + library/libnames.cmi interp/genarg.cmi parsing/extend.cmi \ + library/decl_kinds.cmo parsing/coqast.cmi lib/bignat.cmi parsing/ast.cmi +parsing/ppconstr.cmi: lib/util.cmi interp/topconstr.cmi kernel/term.cmi \ + proofs/tacexpr.cmo pretyping/rawterm.cmi lib/pp.cmi parsing/pcoq.cmi \ + kernel/names.cmi library/libnames.cmi parsing/extend.cmi \ + kernel/environ.cmi parsing/coqast.cmi +parsing/pptactic.cmi: lib/util.cmi interp/topconstr.cmi kernel/term.cmi \ + proofs/tacexpr.cmo pretyping/rawterm.cmi proofs/proof_type.cmi \ + pretyping/pretyping.cmi lib/pp.cmi library/libnames.cmi interp/genarg.cmi +parsing/prettyp.cmi: lib/util.cmi pretyping/termops.cmi kernel/term.cmi \ + kernel/sign.cmi kernel/safe_typing.cmi pretyping/reductionops.cmi \ + lib/pp.cmi library/nametab.cmi kernel/names.cmi library/libnames.cmi \ + library/lib.cmi library/impargs.cmi kernel/environ.cmi \ + pretyping/classops.cmi +parsing/printer.cmi: pretyping/termops.cmi kernel/term.cmi kernel/sign.cmi \ + pretyping/rawterm.cmi lib/pp.cmi pretyping/pattern.cmi \ + library/nametab.cmi kernel/names.cmi library/libnames.cmi \ + kernel/environ.cmi +parsing/printmod.cmi: lib/pp.cmi kernel/names.cmi +parsing/search.cmi: kernel/term.cmi lib/pp.cmi pretyping/pattern.cmi \ + library/nametab.cmi kernel/names.cmi library/libnames.cmi \ + kernel/environ.cmi +parsing/termast.cmi: pretyping/termops.cmi kernel/term.cmi kernel/sign.cmi \ + pretyping/rawterm.cmi pretyping/pattern.cmi library/nametab.cmi \ + kernel/names.cmi library/libnames.cmi kernel/environ.cmi \ + parsing/coqast.cmi +pretyping/cases.cmi: lib/util.cmi kernel/term.cmi pretyping/rawterm.cmi \ + kernel/names.cmi pretyping/inductiveops.cmi pretyping/evd.cmi \ + pretyping/evarutil.cmi kernel/environ.cmi +pretyping/cbv.cmi: kernel/term.cmi kernel/names.cmi kernel/esubst.cmi \ + kernel/environ.cmi kernel/closure.cmi +pretyping/classops.cmi: kernel/term.cmi lib/pp.cmi library/nametab.cmi \ + kernel/names.cmi library/libobject.cmi library/libnames.cmi \ + pretyping/evd.cmi kernel/environ.cmi library/decl_kinds.cmo +pretyping/coercion.cmi: lib/util.cmi kernel/term.cmi kernel/sign.cmi \ + pretyping/rawterm.cmi kernel/names.cmi pretyping/evd.cmi \ + pretyping/evarutil.cmi kernel/environ.cmi +pretyping/detyping.cmi: lib/util.cmi pretyping/termops.cmi kernel/term.cmi \ + kernel/sign.cmi pretyping/rawterm.cmi kernel/names.cmi kernel/environ.cmi +pretyping/evarconv.cmi: kernel/term.cmi kernel/sign.cmi \ + pretyping/reductionops.cmi pretyping/evarutil.cmi kernel/environ.cmi +pretyping/evarutil.cmi: lib/util.cmi kernel/term.cmi kernel/sign.cmi \ + pretyping/reductionops.cmi pretyping/rawterm.cmi kernel/names.cmi \ + pretyping/evd.cmi kernel/environ.cmi +pretyping/evd.cmi: kernel/term.cmi kernel/sign.cmi kernel/names.cmi +pretyping/indrec.cmi: kernel/term.cmi kernel/names.cmi \ + pretyping/inductiveops.cmi pretyping/evd.cmi kernel/environ.cmi \ + kernel/declarations.cmi +pretyping/inductiveops.cmi: kernel/term.cmi kernel/sign.cmi kernel/names.cmi \ + pretyping/evd.cmi kernel/environ.cmi kernel/declarations.cmi +pretyping/instantiate.cmi: kernel/term.cmi kernel/sign.cmi kernel/names.cmi \ + pretyping/evd.cmi kernel/environ.cmi +pretyping/matching.cmi: pretyping/termops.cmi kernel/term.cmi \ + pretyping/pattern.cmi kernel/names.cmi pretyping/evd.cmi \ + kernel/environ.cmi +pretyping/pattern.cmi: kernel/term.cmi kernel/sign.cmi pretyping/rawterm.cmi \ + lib/pp.cmi library/nametab.cmi kernel/names.cmi library/libnames.cmi \ + kernel/environ.cmi +pretyping/pretype_errors.cmi: lib/util.cmi kernel/term.cmi kernel/sign.cmi \ + pretyping/rawterm.cmi lib/pp.cmi kernel/names.cmi \ + pretyping/inductiveops.cmi pretyping/evd.cmi kernel/environ.cmi +pretyping/pretyping.cmi: kernel/term.cmi kernel/sign.cmi \ + pretyping/rawterm.cmi kernel/names.cmi pretyping/evd.cmi \ + pretyping/evarutil.cmi kernel/environ.cmi lib/dyn.cmi +pretyping/rawterm.cmi: lib/util.cmi kernel/univ.cmi kernel/term.cmi \ + kernel/sign.cmi library/nametab.cmi kernel/names.cmi library/libnames.cmi \ + lib/dyn.cmi +pretyping/recordops.cmi: kernel/term.cmi library/nametab.cmi kernel/names.cmi \ + library/library.cmi library/libobject.cmi library/libnames.cmi \ + pretyping/classops.cmi +pretyping/reductionops.cmi: kernel/univ.cmi kernel/term.cmi kernel/sign.cmi \ + kernel/names.cmi pretyping/evd.cmi kernel/environ.cmi kernel/closure.cmi +pretyping/retyping.cmi: pretyping/termops.cmi kernel/term.cmi \ + pretyping/pattern.cmi kernel/names.cmi pretyping/evd.cmi \ + kernel/environ.cmi +pretyping/tacred.cmi: kernel/term.cmi pretyping/reductionops.cmi \ + pretyping/rawterm.cmi kernel/names.cmi library/libnames.cmi \ + pretyping/evd.cmi kernel/environ.cmi kernel/closure.cmi +pretyping/termops.cmi: lib/util.cmi kernel/univ.cmi kernel/term.cmi \ + kernel/sign.cmi lib/pp.cmi kernel/names.cmi kernel/environ.cmi +pretyping/typing.cmi: kernel/term.cmi pretyping/evd.cmi kernel/environ.cmi +proofs/clenv.cmi: lib/util.cmi pretyping/termops.cmi kernel/term.cmi \ + kernel/sign.cmi pretyping/reductionops.cmi pretyping/rawterm.cmi \ + proofs/proof_type.cmi pretyping/pretyping.cmi lib/pp.cmi kernel/names.cmi \ + pretyping/evd.cmi kernel/environ.cmi +proofs/evar_refiner.cmi: interp/topconstr.cmi kernel/term.cmi \ + proofs/tacexpr.cmo kernel/sign.cmi proofs/refiner.cmi \ + proofs/proof_type.cmi kernel/names.cmi pretyping/evd.cmi \ + kernel/environ.cmi +proofs/logic.cmi: kernel/term.cmi kernel/sign.cmi proofs/proof_type.cmi \ + lib/pp.cmi kernel/names.cmi pretyping/evd.cmi kernel/environ.cmi +proofs/pfedit.cmi: lib/util.cmi interp/topconstr.cmi kernel/term.cmi \ + proofs/tacmach.cmi proofs/tacexpr.cmo kernel/sign.cmi lib/pp.cmi \ + kernel/names.cmi pretyping/evd.cmi kernel/environ.cmi kernel/entries.cmi \ + library/decl_kinds.cmo +proofs/proof_trees.cmi: lib/util.cmi kernel/term.cmi kernel/sign.cmi \ + proofs/proof_type.cmi lib/pp.cmi kernel/names.cmi pretyping/evd.cmi \ + kernel/environ.cmi +proofs/proof_type.cmi: lib/util.cmi kernel/term.cmi proofs/tacexpr.cmo \ + pretyping/rawterm.cmi pretyping/pattern.cmi library/nametab.cmi \ + kernel/names.cmi library/libnames.cmi interp/genarg.cmi pretyping/evd.cmi \ + kernel/environ.cmi +proofs/refiner.cmi: pretyping/termops.cmi kernel/term.cmi proofs/tacexpr.cmo \ + kernel/sign.cmi proofs/proof_type.cmi proofs/proof_trees.cmi lib/pp.cmi \ + pretyping/evd.cmi +proofs/tacmach.cmi: interp/topconstr.cmi pretyping/termops.cmi \ + kernel/term.cmi pretyping/tacred.cmi proofs/tacexpr.cmo kernel/sign.cmi \ + proofs/refiner.cmi kernel/reduction.cmi pretyping/rawterm.cmi \ + proofs/proof_type.cmi proofs/proof_trees.cmi lib/pp.cmi kernel/names.cmi \ + pretyping/evd.cmi kernel/environ.cmi +proofs/tactic_debug.cmi: kernel/term.cmi proofs/tacexpr.cmo \ + proofs/proof_type.cmi lib/pp.cmi pretyping/pattern.cmi kernel/names.cmi \ + kernel/environ.cmi +tactics/auto.cmi: toplevel/vernacexpr.cmo lib/util.cmi kernel/term.cmi \ + proofs/tacmach.cmi proofs/tacexpr.cmo kernel/sign.cmi \ + pretyping/rawterm.cmi proofs/proof_type.cmi lib/pp.cmi \ + pretyping/pattern.cmi kernel/names.cmi library/libnames.cmi \ + pretyping/evd.cmi kernel/environ.cmi proofs/clenv.cmi tactics/btermdn.cmi +tactics/autorewrite.cmi: kernel/term.cmi proofs/tacmach.cmi \ + proofs/tacexpr.cmo +tactics/btermdn.cmi: kernel/term.cmi pretyping/pattern.cmi +tactics/contradiction.cmi: kernel/term.cmi pretyping/rawterm.cmi \ + proofs/proof_type.cmi kernel/names.cmi +tactics/dhyp.cmi: toplevel/vernacexpr.cmo interp/topconstr.cmi \ + proofs/tacmach.cmi proofs/tacexpr.cmo kernel/names.cmi +tactics/eauto.cmi: kernel/term.cmi proofs/tacexpr.cmo proofs/proof_type.cmi +tactics/elim.cmi: kernel/term.cmi tactics/tacticals.cmi proofs/tacmach.cmi \ + pretyping/rawterm.cmi proofs/proof_type.cmi kernel/names.cmi \ + interp/genarg.cmi +tactics/equality.cmi: kernel/term.cmi tactics/tactics.cmi \ + tactics/tacticals.cmi proofs/tacmach.cmi proofs/tacexpr.cmo \ + kernel/sign.cmi pretyping/rawterm.cmi proofs/proof_type.cmi \ + pretyping/pattern.cmi kernel/names.cmi tactics/hipattern.cmi \ + pretyping/evd.cmi kernel/environ.cmi +tactics/extraargs.cmi: interp/topconstr.cmi kernel/term.cmi \ + proofs/tacexpr.cmo proofs/proof_type.cmi parsing/pcoq.cmi +tactics/extratactics.cmi: kernel/term.cmi pretyping/rawterm.cmi \ + proofs/proof_type.cmi kernel/names.cmi interp/genarg.cmi +tactics/hiddentac.cmi: kernel/term.cmi tactics/tacticals.cmi \ + pretyping/tacred.cmi proofs/tacmach.cmi proofs/tacexpr.cmo \ + pretyping/rawterm.cmi proofs/proof_type.cmi kernel/names.cmi \ + interp/genarg.cmi +tactics/hipattern.cmi: lib/util.cmi kernel/term.cmi proofs/tacmach.cmi \ + kernel/sign.cmi proofs/proof_type.cmi proofs/proof_trees.cmi \ + pretyping/pattern.cmi kernel/names.cmi pretyping/evd.cmi \ + interp/coqlib.cmi +tactics/inv.cmi: kernel/term.cmi proofs/tacmach.cmi proofs/tacexpr.cmo \ + pretyping/rawterm.cmi kernel/names.cmi interp/genarg.cmi +tactics/leminv.cmi: interp/topconstr.cmi kernel/term.cmi \ + pretyping/rawterm.cmi proofs/proof_type.cmi kernel/names.cmi +tactics/nbtermdn.cmi: kernel/term.cmi pretyping/pattern.cmi \ + tactics/btermdn.cmi +tactics/refine.cmi: kernel/term.cmi proofs/tacmach.cmi \ + pretyping/pretyping.cmi +tactics/setoid_replace.cmi: interp/topconstr.cmi kernel/term.cmi \ + proofs/proof_type.cmi kernel/names.cmi +tactics/tacinterp.cmi: lib/util.cmi interp/topconstr.cmi kernel/term.cmi \ + proofs/tactic_debug.cmi pretyping/tacred.cmi proofs/tacmach.cmi \ + proofs/tacexpr.cmo proofs/proof_type.cmi lib/pp.cmi library/nametab.cmi \ + kernel/names.cmi interp/genarg.cmi pretyping/evd.cmi kernel/environ.cmi \ + lib/dyn.cmi parsing/coqast.cmi +tactics/tacticals.cmi: kernel/term.cmi proofs/tacmach.cmi proofs/tacexpr.cmo \ + kernel/sign.cmi kernel/reduction.cmi proofs/proof_type.cmi \ + pretyping/pattern.cmi kernel/names.cmi interp/genarg.cmi proofs/clenv.cmi +tactics/tactics.cmi: interp/topconstr.cmi kernel/term.cmi \ + tactics/tacticals.cmi pretyping/tacred.cmi proofs/tacmach.cmi \ + proofs/tacexpr.cmo kernel/sign.cmi kernel/reduction.cmi \ + pretyping/rawterm.cmi proofs/proof_type.cmi library/nametab.cmi \ + kernel/names.cmi library/libnames.cmi interp/genarg.cmi pretyping/evd.cmi \ + proofs/evar_refiner.cmi kernel/environ.cmi proofs/clenv.cmi +tactics/termdn.cmi: kernel/term.cmi pretyping/pattern.cmi +toplevel/cerrors.cmi: lib/util.cmi lib/pp.cmi +toplevel/class.cmi: kernel/term.cmi proofs/tacexpr.cmo library/nametab.cmi \ + kernel/names.cmi library/libnames.cmi library/declare.cmi \ + library/decl_kinds.cmo pretyping/classops.cmi +toplevel/command.cmi: toplevel/vernacexpr.cmo lib/util.cmi \ + interp/topconstr.cmi kernel/term.cmi pretyping/tacred.cmi \ + proofs/tacexpr.cmo pretyping/rawterm.cmi library/nametab.cmi \ + kernel/names.cmi library/library.cmi library/libnames.cmi \ + pretyping/evd.cmi kernel/environ.cmi kernel/entries.cmi \ + library/declare.cmi library/decl_kinds.cmo toplevel/coqinit.cmi: kernel/names.cmi toplevel/discharge.cmi: kernel/names.cmi -toplevel/fhimsg.cmi: kernel/environ.cmi kernel/names.cmi lib/pp.cmi \ - kernel/sign.cmi kernel/term.cmi kernel/type_errors.cmi -toplevel/himsg.cmi: pretyping/cases.cmi kernel/environ.cmi \ - kernel/indtypes.cmi proofs/logic.cmi kernel/names.cmi lib/pp.cmi \ - pretyping/pretype_errors.cmi kernel/type_errors.cmi -toplevel/metasyntax.cmi: pretyping/classops.cmi interp/constrintern.cmi \ - parsing/extend.cmi library/libnames.cmi interp/ppextend.cmi \ - interp/symbols.cmi proofs/tacexpr.cmo interp/topconstr.cmi lib/util.cmi \ - toplevel/vernacexpr.cmo -toplevel/mltop.cmi: library/libobject.cmi kernel/names.cmi +toplevel/fhimsg.cmi: kernel/type_errors.cmi kernel/term.cmi kernel/sign.cmi \ + lib/pp.cmi kernel/names.cmi kernel/environ.cmi +toplevel/himsg.cmi: kernel/type_errors.cmi pretyping/pretype_errors.cmi \ + lib/pp.cmi kernel/names.cmi proofs/logic.cmi kernel/indtypes.cmi \ + kernel/environ.cmi pretyping/cases.cmi +toplevel/metasyntax.cmi: toplevel/vernacexpr.cmo lib/util.cmi \ + interp/topconstr.cmi proofs/tacexpr.cmo interp/symbols.cmi \ + interp/ppextend.cmi library/libnames.cmi parsing/extend.cmi \ + interp/constrintern.cmi pretyping/classops.cmi +toplevel/mltop.cmi: kernel/names.cmi library/libobject.cmi toplevel/protectedtoplevel.cmi: lib/pp.cmi -toplevel/record.cmi: kernel/names.cmi kernel/sign.cmi kernel/term.cmi \ - interp/topconstr.cmi toplevel/vernacexpr.cmo -toplevel/recordobj.cmi: library/libnames.cmi proofs/tacexpr.cmo -toplevel/searchisos.cmi: library/libobject.cmi kernel/names.cmi \ - kernel/term.cmi -toplevel/toplevel.cmi: parsing/pcoq.cmi lib/pp.cmi -toplevel/vernacentries.cmi: kernel/environ.cmi pretyping/evd.cmi \ - library/libnames.cmi kernel/names.cmi kernel/term.cmi \ - interp/topconstr.cmi toplevel/vernacexpr.cmo toplevel/vernacinterp.cmi +toplevel/record.cmi: toplevel/vernacexpr.cmo interp/topconstr.cmi \ + kernel/term.cmi kernel/sign.cmi kernel/names.cmi +toplevel/recordobj.cmi: proofs/tacexpr.cmo library/libnames.cmi +toplevel/searchisos.cmi: kernel/term.cmi kernel/names.cmi \ + library/libobject.cmi +toplevel/toplevel.cmi: lib/pp.cmi parsing/pcoq.cmi +toplevel/vernac.cmi: toplevel/vernacexpr.cmo lib/util.cmi parsing/pcoq.cmi +toplevel/vernacentries.cmi: toplevel/vernacinterp.cmi toplevel/vernacexpr.cmo \ + interp/topconstr.cmi kernel/term.cmi kernel/names.cmi \ + library/libnames.cmi pretyping/evd.cmi kernel/environ.cmi toplevel/vernacinterp.cmi: proofs/tacexpr.cmo -toplevel/vernac.cmi: parsing/pcoq.cmi lib/util.cmi toplevel/vernacexpr.cmo -translate/ppconstrnew.cmi: parsing/coqast.cmi kernel/environ.cmi \ - parsing/extend.cmi interp/genarg.cmi library/libnames.cmi \ - kernel/names.cmi pretyping/pattern.cmi parsing/pcoq.cmi lib/pp.cmi \ - interp/ppextend.cmi pretyping/rawterm.cmi proofs/tacexpr.cmo \ - kernel/term.cmi interp/topconstr.cmi lib/util.cmi -translate/pptacticnew.cmi: kernel/environ.cmi interp/genarg.cmi \ - kernel/names.cmi lib/pp.cmi proofs/proof_type.cmi proofs/tacexpr.cmo \ - interp/topconstr.cmi -translate/ppvernacnew.cmi: parsing/ast.cmi parsing/coqast.cmi \ - kernel/environ.cmi parsing/extend.cmi interp/genarg.cmi \ - library/libnames.cmi library/nameops.cmi kernel/names.cmi \ - library/nametab.cmi parsing/pcoq.cmi lib/pp.cmi parsing/ppconstr.cmi \ - interp/ppextend.cmi parsing/pptactic.cmi pretyping/rawterm.cmi \ - proofs/tacexpr.cmo interp/topconstr.cmi lib/util.cmi \ - toplevel/vernacexpr.cmo -contrib/cc/ccalgo.cmi: kernel/names.cmi kernel/term.cmi -contrib/cc/ccproof.cmi: contrib/cc/ccalgo.cmi kernel/names.cmi -contrib/correctness/past.cmi: kernel/names.cmi kernel/term.cmi \ - interp/topconstr.cmi lib/util.cmi -contrib/correctness/pcicenv.cmi: kernel/names.cmi kernel/sign.cmi \ - kernel/term.cmi +translate/ppconstrnew.cmi: lib/util.cmi interp/topconstr.cmi kernel/term.cmi \ + proofs/tacexpr.cmo pretyping/rawterm.cmi interp/ppextend.cmi lib/pp.cmi \ + parsing/pcoq.cmi pretyping/pattern.cmi kernel/names.cmi \ + library/libnames.cmi interp/genarg.cmi parsing/extend.cmi \ + kernel/environ.cmi parsing/coqast.cmi +translate/pptacticnew.cmi: interp/topconstr.cmi proofs/tacexpr.cmo \ + proofs/proof_type.cmi lib/pp.cmi kernel/names.cmi interp/genarg.cmi \ + kernel/environ.cmi +translate/ppvernacnew.cmi: toplevel/vernacexpr.cmo lib/util.cmi \ + interp/topconstr.cmi proofs/tacexpr.cmo pretyping/rawterm.cmi \ + parsing/pptactic.cmi interp/ppextend.cmi parsing/ppconstr.cmi lib/pp.cmi \ + parsing/pcoq.cmi library/nametab.cmi kernel/names.cmi library/nameops.cmi \ + library/libnames.cmi interp/genarg.cmi parsing/extend.cmi \ + kernel/environ.cmi parsing/coqast.cmi parsing/ast.cmi +contrib/cc/ccalgo.cmi: kernel/term.cmi kernel/names.cmi +contrib/cc/ccproof.cmi: kernel/names.cmi contrib/cc/ccalgo.cmi +contrib/correctness/past.cmi: lib/util.cmi interp/topconstr.cmi \ + kernel/term.cmi kernel/names.cmi contrib/correctness/pcic.cmi: pretyping/rawterm.cmi +contrib/correctness/pcicenv.cmi: kernel/term.cmi kernel/sign.cmi \ + kernel/names.cmi contrib/correctness/pdb.cmi: kernel/names.cmi -contrib/correctness/peffect.cmi: kernel/names.cmi lib/pp.cmi -contrib/correctness/penv.cmi: library/libnames.cmi kernel/names.cmi \ - kernel/term.cmi -contrib/correctness/perror.cmi: kernel/names.cmi lib/pp.cmi lib/util.cmi +contrib/correctness/peffect.cmi: lib/pp.cmi kernel/names.cmi +contrib/correctness/penv.cmi: kernel/term.cmi kernel/names.cmi \ + library/libnames.cmi +contrib/correctness/perror.cmi: lib/util.cmi lib/pp.cmi kernel/names.cmi contrib/correctness/pextract.cmi: kernel/names.cmi -contrib/correctness/pmisc.cmi: kernel/names.cmi lib/pp.cmi kernel/term.cmi \ - interp/topconstr.cmi lib/util.cmi +contrib/correctness/pmisc.cmi: lib/util.cmi interp/topconstr.cmi \ + kernel/term.cmi lib/pp.cmi kernel/names.cmi contrib/correctness/pmlize.cmi: kernel/names.cmi -contrib/correctness/pmonad.cmi: kernel/names.cmi kernel/term.cmi +contrib/correctness/pmonad.cmi: kernel/term.cmi kernel/names.cmi contrib/correctness/pred.cmi: kernel/term.cmi -contrib/correctness/prename.cmi: kernel/names.cmi lib/pp.cmi -contrib/correctness/psyntax.cmi: parsing/pcoq.cmi interp/topconstr.cmi +contrib/correctness/prename.cmi: lib/pp.cmi kernel/names.cmi +contrib/correctness/psyntax.cmi: interp/topconstr.cmi parsing/pcoq.cmi contrib/correctness/ptactic.cmi: proofs/tacmach.cmi -contrib/correctness/ptype.cmi: kernel/names.cmi kernel/term.cmi -contrib/correctness/ptyping.cmi: kernel/names.cmi kernel/term.cmi \ - interp/topconstr.cmi -contrib/correctness/putil.cmi: kernel/names.cmi lib/pp.cmi kernel/term.cmi +contrib/correctness/ptype.cmi: kernel/term.cmi kernel/names.cmi +contrib/correctness/ptyping.cmi: interp/topconstr.cmi kernel/term.cmi \ + kernel/names.cmi +contrib/correctness/putil.cmi: kernel/term.cmi lib/pp.cmi kernel/names.cmi contrib/correctness/pwp.cmi: kernel/term.cmi -contrib/extraction/common.cmi: contrib/extraction/miniml.cmi \ - contrib/extraction/mlutil.cmi kernel/names.cmi -contrib/extraction/extract_env.cmi: library/libnames.cmi kernel/names.cmi -contrib/extraction/extraction.cmi: kernel/declarations.cmi kernel/environ.cmi \ - library/libnames.cmi contrib/extraction/miniml.cmi kernel/names.cmi \ - kernel/term.cmi -contrib/extraction/haskell.cmi: contrib/extraction/miniml.cmi \ - kernel/names.cmi lib/pp.cmi -contrib/extraction/miniml.cmi: library/libnames.cmi kernel/names.cmi \ - lib/pp.cmi lib/util.cmi -contrib/extraction/mlutil.cmi: library/libnames.cmi \ - contrib/extraction/miniml.cmi kernel/names.cmi kernel/term.cmi \ - lib/util.cmi -contrib/extraction/modutil.cmi: kernel/declarations.cmi kernel/environ.cmi \ - library/libnames.cmi contrib/extraction/miniml.cmi kernel/names.cmi -contrib/extraction/ocaml.cmi: library/libnames.cmi \ - contrib/extraction/miniml.cmi kernel/names.cmi lib/pp.cmi -contrib/extraction/scheme.cmi: contrib/extraction/miniml.cmi kernel/names.cmi \ - lib/pp.cmi -contrib/extraction/table.cmi: kernel/environ.cmi library/libnames.cmi \ - contrib/extraction/miniml.cmi kernel/names.cmi kernel/term.cmi -contrib/first-order/formula.cmi: kernel/closure.cmi library/libnames.cmi \ - kernel/names.cmi proofs/proof_type.cmi kernel/sign.cmi proofs/tacmach.cmi \ - kernel/term.cmi -contrib/first-order/ground.cmi: proofs/proof_type.cmi \ - contrib/first-order/sequent.cmi proofs/tacmach.cmi -contrib/first-order/instances.cmi: contrib/first-order/formula.cmi \ - library/libnames.cmi kernel/names.cmi contrib/first-order/rules.cmi \ - contrib/first-order/sequent.cmi proofs/tacmach.cmi kernel/term.cmi \ - contrib/first-order/unify.cmi -contrib/first-order/rules.cmi: library/libnames.cmi kernel/names.cmi \ - contrib/first-order/sequent.cmi proofs/tacmach.cmi kernel/term.cmi -contrib/first-order/sequent.cmi: tactics/auto.cmi \ - contrib/first-order/formula.cmi lib/heap.cmi library/libnames.cmi \ - kernel/names.cmi proofs/proof_type.cmi proofs/tacmach.cmi kernel/term.cmi \ - lib/util.cmi +contrib/extraction/common.cmi: kernel/names.cmi contrib/extraction/mlutil.cmi \ + contrib/extraction/miniml.cmi +contrib/extraction/extract_env.cmi: kernel/names.cmi library/libnames.cmi +contrib/extraction/extraction.cmi: kernel/term.cmi kernel/names.cmi \ + contrib/extraction/miniml.cmi library/libnames.cmi kernel/environ.cmi \ + kernel/declarations.cmi +contrib/extraction/haskell.cmi: lib/pp.cmi kernel/names.cmi \ + contrib/extraction/miniml.cmi +contrib/extraction/miniml.cmi: lib/util.cmi lib/pp.cmi kernel/names.cmi \ + library/libnames.cmi +contrib/extraction/mlutil.cmi: lib/util.cmi kernel/term.cmi kernel/names.cmi \ + contrib/extraction/miniml.cmi library/libnames.cmi +contrib/extraction/modutil.cmi: kernel/names.cmi \ + contrib/extraction/miniml.cmi library/libnames.cmi kernel/environ.cmi \ + kernel/declarations.cmi +contrib/extraction/ocaml.cmi: lib/pp.cmi kernel/names.cmi \ + contrib/extraction/miniml.cmi library/libnames.cmi +contrib/extraction/scheme.cmi: lib/pp.cmi kernel/names.cmi \ + contrib/extraction/miniml.cmi +contrib/extraction/table.cmi: kernel/term.cmi kernel/names.cmi \ + contrib/extraction/miniml.cmi library/libnames.cmi kernel/environ.cmi +contrib/first-order/formula.cmi: kernel/term.cmi proofs/tacmach.cmi \ + kernel/sign.cmi proofs/proof_type.cmi kernel/names.cmi \ + library/libnames.cmi kernel/closure.cmi +contrib/first-order/ground.cmi: proofs/tacmach.cmi \ + contrib/first-order/sequent.cmi proofs/proof_type.cmi +contrib/first-order/instances.cmi: contrib/first-order/unify.cmi \ + kernel/term.cmi proofs/tacmach.cmi contrib/first-order/sequent.cmi \ + contrib/first-order/rules.cmi kernel/names.cmi library/libnames.cmi \ + contrib/first-order/formula.cmi +contrib/first-order/rules.cmi: kernel/term.cmi proofs/tacmach.cmi \ + contrib/first-order/sequent.cmi kernel/names.cmi library/libnames.cmi +contrib/first-order/sequent.cmi: lib/util.cmi kernel/term.cmi \ + proofs/tacmach.cmi proofs/proof_type.cmi kernel/names.cmi \ + library/libnames.cmi lib/heap.cmi contrib/first-order/formula.cmi \ + tactics/auto.cmi contrib/first-order/unify.cmi: kernel/term.cmi -contrib/funind/tacinvutils.cmi: interp/coqlib.cmi tactics/equality.cmi \ - pretyping/evd.cmi pretyping/inductiveops.cmi kernel/names.cmi lib/pp.cmi \ - parsing/printer.cmi proofs/proof_type.cmi pretyping/reductionops.cmi \ - tactics/refine.cmi tactics/tacinterp.cmi proofs/tacmach.cmi \ - tactics/tacticals.cmi tactics/tactics.cmi kernel/term.cmi \ - pretyping/termops.cmi lib/util.cmi -contrib/interface/blast.cmi: proofs/proof_type.cmi proofs/tacexpr.cmo \ - proofs/tacmach.cmi -contrib/interface/dad.cmi: proofs/proof_type.cmi proofs/tacexpr.cmo \ - proofs/tacmach.cmi interp/topconstr.cmi -contrib/interface/debug_tac.cmi: proofs/proof_type.cmi proofs/tacexpr.cmo \ - proofs/tacmach.cmi -contrib/interface/name_to_ast.cmi: parsing/coqast.cmi library/libnames.cmi \ - toplevel/vernacexpr.cmo -contrib/interface/pbp.cmi: kernel/names.cmi proofs/proof_type.cmi \ - proofs/tacexpr.cmo proofs/tacmach.cmi -contrib/interface/showproof.cmi: contrib/interface/ascent.cmi \ - proofs/clenv.cmi parsing/coqast.cmi kernel/declarations.cmi \ - kernel/environ.cmi pretyping/evd.cmi kernel/inductive.cmi \ - kernel/names.cmi proofs/pfedit.cmi lib/pp.cmi parsing/printer.cmi \ - proofs/proof_trees.cmi proofs/proof_type.cmi kernel/reduction.cmi \ - contrib/interface/showproof_ct.cmo kernel/sign.cmi kernel/term.cmi \ - contrib/interface/translate.cmi pretyping/typing.cmi lib/util.cmi \ - toplevel/vernacinterp.cmi -contrib/interface/translate.cmi: contrib/interface/ascent.cmi \ - kernel/environ.cmi pretyping/evd.cmi proofs/proof_type.cmi \ - kernel/term.cmi +contrib/funind/tacinvutils.cmi: lib/util.cmi pretyping/termops.cmi \ + kernel/term.cmi tactics/tactics.cmi tactics/tacticals.cmi \ + proofs/tacmach.cmi tactics/tacinterp.cmi tactics/refine.cmi \ + pretyping/reductionops.cmi proofs/proof_type.cmi parsing/printer.cmi \ + lib/pp.cmi kernel/names.cmi pretyping/inductiveops.cmi pretyping/evd.cmi \ + tactics/equality.cmi interp/coqlib.cmi +contrib/interface/blast.cmi: proofs/tacmach.cmi proofs/tacexpr.cmo \ + proofs/proof_type.cmi +contrib/interface/dad.cmi: interp/topconstr.cmi proofs/tacmach.cmi \ + proofs/tacexpr.cmo proofs/proof_type.cmi +contrib/interface/debug_tac.cmi: proofs/tacmach.cmi proofs/tacexpr.cmo \ + proofs/proof_type.cmi +contrib/interface/name_to_ast.cmi: toplevel/vernacexpr.cmo \ + library/libnames.cmi parsing/coqast.cmi +contrib/interface/pbp.cmi: proofs/tacmach.cmi proofs/tacexpr.cmo \ + proofs/proof_type.cmi kernel/names.cmi +contrib/interface/showproof.cmi: toplevel/vernacinterp.cmi lib/util.cmi \ + pretyping/typing.cmi contrib/interface/translate.cmi kernel/term.cmi \ + kernel/sign.cmi contrib/interface/showproof_ct.cmo kernel/reduction.cmi \ + proofs/proof_type.cmi proofs/proof_trees.cmi parsing/printer.cmi \ + lib/pp.cmi proofs/pfedit.cmi kernel/names.cmi kernel/inductive.cmi \ + pretyping/evd.cmi kernel/environ.cmi kernel/declarations.cmi \ + parsing/coqast.cmi proofs/clenv.cmi contrib/interface/ascent.cmi +contrib/interface/translate.cmi: kernel/term.cmi proofs/proof_type.cmi \ + pretyping/evd.cmi kernel/environ.cmi contrib/interface/ascent.cmi contrib/interface/vtp.cmi: contrib/interface/ascent.cmi -contrib/interface/xlate.cmi: contrib/interface/ascent.cmi kernel/names.cmi \ - proofs/tacexpr.cmo interp/topconstr.cmi toplevel/vernacexpr.cmo -contrib/jprover/jall.cmi: contrib/jprover/jlogic.cmi \ - contrib/jprover/jterm.cmi contrib/jprover/opname.cmi +contrib/interface/xlate.cmi: toplevel/vernacexpr.cmo interp/topconstr.cmi \ + proofs/tacexpr.cmo kernel/names.cmi contrib/interface/ascent.cmi +contrib/jprover/jall.cmi: contrib/jprover/opname.cmi \ + contrib/jprover/jterm.cmi contrib/jprover/jlogic.cmi contrib/jprover/jlogic.cmi: contrib/jprover/jterm.cmi contrib/jprover/jterm.cmi: contrib/jprover/opname.cmi -contrib/xml/doubleTypeInference.cmi: contrib/xml/acic.cmo kernel/environ.cmi \ - pretyping/evd.cmi kernel/names.cmi kernel/term.cmi -contrib/xml/xmlcommand.cmi: contrib/xml/acic.cmo pretyping/evd.cmi \ - library/libnames.cmi contrib/xml/proof2aproof.cmo proofs/proof_type.cmi \ - kernel/term.cmi contrib/xml/xml.cmi +contrib/xml/doubleTypeInference.cmi: kernel/term.cmi kernel/names.cmi \ + pretyping/evd.cmi kernel/environ.cmi contrib/xml/acic.cmo +contrib/xml/xmlcommand.cmi: contrib/xml/xml.cmi kernel/term.cmi \ + proofs/proof_type.cmi contrib/xml/proof2aproof.cmo library/libnames.cmi \ + pretyping/evd.cmi contrib/xml/acic.cmo ide/utils/configwin.cmi: ide/utils/uoptions.cmi tools/coqdoc/output.cmi: tools/coqdoc/index.cmi tools/coqdoc/pretty.cmi: tools/coqdoc/index.cmi config/coq_config.cmo: config/coq_config.cmi config/coq_config.cmx: config/coq_config.cmi -dev/db_printers.cmo: kernel/names.cmi lib/pp.cmi -dev/db_printers.cmx: kernel/names.cmx lib/pp.cmx -dev/top_printers.cmo: parsing/ast.cmi toplevel/cerrors.cmi proofs/clenv.cmi \ - kernel/closure.cmi interp/constrextern.cmi kernel/declarations.cmi \ - kernel/environ.cmi pretyping/evd.cmi library/libnames.cmi \ - library/libobject.cmi library/nameops.cmi kernel/names.cmi lib/pp.cmi \ - parsing/pptactic.cmi parsing/printer.cmi proofs/proof_trees.cmi \ - proofs/refiner.cmi kernel/sign.cmi lib/system.cmi proofs/tacmach.cmi \ - kernel/term.cmi pretyping/termops.cmi kernel/univ.cmi -dev/top_printers.cmx: parsing/ast.cmx toplevel/cerrors.cmx proofs/clenv.cmx \ - kernel/closure.cmx interp/constrextern.cmx kernel/declarations.cmx \ - kernel/environ.cmx pretyping/evd.cmx library/libnames.cmx \ - library/libobject.cmx library/nameops.cmx kernel/names.cmx lib/pp.cmx \ - parsing/pptactic.cmx parsing/printer.cmx proofs/proof_trees.cmx \ - proofs/refiner.cmx kernel/sign.cmx lib/system.cmx proofs/tacmach.cmx \ - kernel/term.cmx pretyping/termops.cmx kernel/univ.cmx +dev/db_printers.cmo: lib/pp.cmi kernel/names.cmi +dev/db_printers.cmx: lib/pp.cmx kernel/names.cmx +dev/top_printers.cmo: kernel/univ.cmi pretyping/termops.cmi kernel/term.cmi \ + proofs/tacmach.cmi lib/system.cmi kernel/sign.cmi proofs/refiner.cmi \ + proofs/proof_trees.cmi parsing/printer.cmi parsing/pptactic.cmi \ + lib/pp.cmi kernel/names.cmi library/nameops.cmi library/libobject.cmi \ + library/libnames.cmi pretyping/evd.cmi kernel/environ.cmi \ + kernel/declarations.cmi interp/constrintern.cmi interp/constrextern.cmi \ + kernel/closure.cmi proofs/clenv.cmi toplevel/cerrors.cmi parsing/ast.cmi +dev/top_printers.cmx: kernel/univ.cmx pretyping/termops.cmx kernel/term.cmx \ + proofs/tacmach.cmx lib/system.cmx kernel/sign.cmx proofs/refiner.cmx \ + proofs/proof_trees.cmx parsing/printer.cmx parsing/pptactic.cmx \ + lib/pp.cmx kernel/names.cmx library/nameops.cmx library/libobject.cmx \ + library/libnames.cmx pretyping/evd.cmx kernel/environ.cmx \ + kernel/declarations.cmx interp/constrintern.cmx interp/constrextern.cmx \ + kernel/closure.cmx proofs/clenv.cmx toplevel/cerrors.cmx parsing/ast.cmx doc/parse.cmo: parsing/ast.cmi doc/parse.cmx: parsing/ast.cmx -ide/blaster_window.cmo: ide/coq.cmi ide/ideutils.cmi -ide/blaster_window.cmx: ide/coq.cmx ide/ideutils.cmx -ide/command_windows.cmo: ide/coq.cmi ide/coq_commands.cmo ide/ideutils.cmi \ +ide/blaster_window.cmo: ide/ideutils.cmi ide/coq.cmi +ide/blaster_window.cmx: ide/ideutils.cmx ide/coq.cmx +ide/command_windows.cmo: ide/ideutils.cmi ide/coq_commands.cmo ide/coq.cmi \ ide/command_windows.cmi -ide/command_windows.cmx: ide/coq.cmx ide/coq_commands.cmx ide/ideutils.cmx \ +ide/command_windows.cmx: ide/ideutils.cmx ide/coq_commands.cmx ide/coq.cmx \ ide/command_windows.cmi -ide/config_lexer.cmo: ide/config_parser.cmi lib/util.cmi -ide/config_lexer.cmx: ide/config_parser.cmx lib/util.cmx +ide/config_lexer.cmo: lib/util.cmi ide/config_parser.cmi +ide/config_lexer.cmx: lib/util.cmx ide/config_parser.cmx ide/config_parser.cmo: lib/util.cmi ide/config_parser.cmi ide/config_parser.cmx: lib/util.cmx ide/config_parser.cmi -ide/coqide.cmo: ide/blaster_window.cmo ide/command_windows.cmi ide/coq.cmi \ - ide/coq_commands.cmo ide/find_phrase.cmo ide/highlight.cmo \ - ide/ideutils.cmi proofs/pfedit.cmi ide/preferences.cmi lib/system.cmi \ - ide/undo.cmi lib/util.cmi toplevel/vernacexpr.cmo ide/coqide.cmi -ide/coqide.cmx: ide/blaster_window.cmx ide/command_windows.cmx ide/coq.cmx \ - ide/coq_commands.cmx ide/find_phrase.cmx ide/highlight.cmx \ - ide/ideutils.cmx proofs/pfedit.cmx ide/preferences.cmx lib/system.cmx \ - ide/undo.cmx lib/util.cmx toplevel/vernacexpr.cmx ide/coqide.cmi -ide/coq.cmo: toplevel/cerrors.cmi config/coq_config.cmi toplevel/coqtop.cmi \ - kernel/declarations.cmi kernel/environ.cmi pretyping/evarutil.cmi \ - pretyping/evd.cmi library/global.cmi tactics/hipattern.cmi \ - ide/ideutils.cmi library/lib.cmi library/libnames.cmi library/library.cmi \ - toplevel/mltop.cmi kernel/names.cmi library/nametab.cmi lib/options.cmi \ - parsing/pcoq.cmi proofs/pfedit.cmi lib/pp.cmi parsing/printer.cmi \ - proofs/proof_trees.cmi pretyping/reductionops.cmi proofs/refiner.cmi \ - library/states.cmi tactics/tacinterp.cmi proofs/tacmach.cmi \ - kernel/term.cmi pretyping/termops.cmi lib/util.cmi toplevel/vernac.cmi \ - toplevel/vernacentries.cmi toplevel/vernacexpr.cmo ide/coq.cmi -ide/coq.cmx: toplevel/cerrors.cmx config/coq_config.cmx toplevel/coqtop.cmx \ - kernel/declarations.cmx kernel/environ.cmx pretyping/evarutil.cmx \ - pretyping/evd.cmx library/global.cmx tactics/hipattern.cmx \ - ide/ideutils.cmx library/lib.cmx library/libnames.cmx library/library.cmx \ - toplevel/mltop.cmx kernel/names.cmx library/nametab.cmx lib/options.cmx \ - parsing/pcoq.cmx proofs/pfedit.cmx lib/pp.cmx parsing/printer.cmx \ - proofs/proof_trees.cmx pretyping/reductionops.cmx proofs/refiner.cmx \ - library/states.cmx tactics/tacinterp.cmx proofs/tacmach.cmx \ - kernel/term.cmx pretyping/termops.cmx lib/util.cmx toplevel/vernac.cmx \ - toplevel/vernacentries.cmx toplevel/vernacexpr.cmx ide/coq.cmi +ide/coq.cmo: toplevel/vernacexpr.cmo toplevel/vernacentries.cmi \ + toplevel/vernac.cmi lib/util.cmi pretyping/termops.cmi kernel/term.cmi \ + proofs/tacmach.cmi tactics/tacinterp.cmi library/states.cmi \ + proofs/refiner.cmi pretyping/reductionops.cmi proofs/proof_trees.cmi \ + parsing/printer.cmi lib/pp.cmi proofs/pfedit.cmi parsing/pcoq.cmi \ + lib/options.cmi library/nametab.cmi kernel/names.cmi toplevel/mltop.cmi \ + library/library.cmi library/libnames.cmi library/lib.cmi ide/ideutils.cmi \ + tactics/hipattern.cmi library/global.cmi pretyping/evd.cmi \ + pretyping/evarutil.cmi kernel/environ.cmi kernel/declarations.cmi \ + toplevel/coqtop.cmi config/coq_config.cmi toplevel/cerrors.cmi \ + ide/coq.cmi +ide/coq.cmx: toplevel/vernacexpr.cmx toplevel/vernacentries.cmx \ + toplevel/vernac.cmx lib/util.cmx pretyping/termops.cmx kernel/term.cmx \ + proofs/tacmach.cmx tactics/tacinterp.cmx library/states.cmx \ + proofs/refiner.cmx pretyping/reductionops.cmx proofs/proof_trees.cmx \ + parsing/printer.cmx lib/pp.cmx proofs/pfedit.cmx parsing/pcoq.cmx \ + lib/options.cmx library/nametab.cmx kernel/names.cmx toplevel/mltop.cmx \ + library/library.cmx library/libnames.cmx library/lib.cmx ide/ideutils.cmx \ + tactics/hipattern.cmx library/global.cmx pretyping/evd.cmx \ + pretyping/evarutil.cmx kernel/environ.cmx kernel/declarations.cmx \ + toplevel/coqtop.cmx config/coq_config.cmx toplevel/cerrors.cmx \ + ide/coq.cmi ide/coq_tactics.cmo: ide/coq_tactics.cmi ide/coq_tactics.cmx: ide/coq_tactics.cmi +ide/coqide.cmo: toplevel/vernacexpr.cmo lib/util.cmi ide/undo.cmi \ + lib/system.cmi ide/preferences.cmi proofs/pfedit.cmi ide/ideutils.cmi \ + ide/highlight.cmo ide/find_phrase.cmo ide/coq_commands.cmo ide/coq.cmi \ + ide/command_windows.cmi ide/blaster_window.cmo ide/coqide.cmi +ide/coqide.cmx: toplevel/vernacexpr.cmx lib/util.cmx ide/undo.cmx \ + lib/system.cmx ide/preferences.cmx proofs/pfedit.cmx ide/ideutils.cmx \ + ide/highlight.cmx ide/find_phrase.cmx ide/coq_commands.cmx ide/coq.cmx \ + ide/command_windows.cmx ide/blaster_window.cmx ide/coqide.cmi ide/find_phrase.cmo: ide/ideutils.cmi ide/find_phrase.cmx: ide/ideutils.cmx ide/highlight.cmo: ide/ideutils.cmi ide/highlight.cmx: ide/ideutils.cmx -ide/ideutils.cmo: config/coq_config.cmi lib/options.cmi lib/pp_control.cmi \ - ide/preferences.cmi ide/utf8_convert.cmo ide/ideutils.cmi -ide/ideutils.cmx: config/coq_config.cmx lib/options.cmx lib/pp_control.cmx \ - ide/preferences.cmx ide/utf8_convert.cmx ide/ideutils.cmi -ide/preferences.cmo: ide/config_lexer.cmo ide/utils/configwin.cmi \ - lib/system.cmi lib/util.cmi ide/preferences.cmi -ide/preferences.cmx: ide/config_lexer.cmx ide/utils/configwin.cmx \ - lib/system.cmx lib/util.cmx ide/preferences.cmi +ide/ideutils.cmo: ide/utf8_convert.cmo ide/preferences.cmi lib/pp_control.cmi \ + lib/options.cmi config/coq_config.cmi ide/ideutils.cmi +ide/ideutils.cmx: ide/utf8_convert.cmx ide/preferences.cmx lib/pp_control.cmx \ + lib/options.cmx config/coq_config.cmx ide/ideutils.cmi +ide/preferences.cmo: lib/util.cmi lib/system.cmi ide/utils/configwin.cmi \ + ide/config_lexer.cmo ide/preferences.cmi +ide/preferences.cmx: lib/util.cmx lib/system.cmx ide/utils/configwin.cmx \ + ide/config_lexer.cmx ide/preferences.cmi ide/undo.cmo: ide/ideutils.cmi ide/undo.cmi ide/undo.cmx: ide/ideutils.cmx ide/undo.cmi -interp/constrextern.cmo: lib/bignat.cmi pretyping/classops.cmi \ - kernel/declarations.cmi pretyping/detyping.cmi kernel/environ.cmi \ - library/global.cmi library/impargs.cmi kernel/inductive.cmi \ - library/lib.cmi library/libnames.cmi library/nameops.cmi kernel/names.cmi \ - library/nametab.cmi lib/options.cmi pretyping/pattern.cmi lib/pp.cmi \ - pretyping/rawterm.cmi pretyping/recordops.cmi interp/reserve.cmi \ - kernel/sign.cmi interp/symbols.cmi kernel/term.cmi pretyping/termops.cmi \ - interp/topconstr.cmi kernel/univ.cmi lib/util.cmi interp/constrextern.cmi -interp/constrextern.cmx: lib/bignat.cmx pretyping/classops.cmx \ - kernel/declarations.cmx pretyping/detyping.cmx kernel/environ.cmx \ - library/global.cmx library/impargs.cmx kernel/inductive.cmx \ - library/lib.cmx library/libnames.cmx library/nameops.cmx kernel/names.cmx \ - library/nametab.cmx lib/options.cmx pretyping/pattern.cmx lib/pp.cmx \ - pretyping/rawterm.cmx pretyping/recordops.cmx interp/reserve.cmx \ - kernel/sign.cmx interp/symbols.cmx kernel/term.cmx pretyping/termops.cmx \ - interp/topconstr.cmx kernel/univ.cmx lib/util.cmx interp/constrextern.cmi -interp/constrintern.cmo: lib/bignat.cmi kernel/declarations.cmi \ - kernel/environ.cmi pretyping/evd.cmi library/global.cmi \ - library/impargs.cmi kernel/inductive.cmi parsing/lexer.cmi \ - library/lib.cmi library/libnames.cmi library/nameops.cmi kernel/names.cmi \ - library/nametab.cmi lib/options.cmi pretyping/pattern.cmi lib/pp.cmi \ - pretyping/pretype_errors.cmi pretyping/pretyping.cmi \ - pretyping/rawterm.cmi pretyping/recordops.cmi interp/reserve.cmi \ - pretyping/retyping.cmi kernel/sign.cmi interp/symbols.cmi \ - interp/syntax_def.cmi kernel/term.cmi pretyping/termops.cmi \ - interp/topconstr.cmi lib/util.cmi interp/constrintern.cmi -interp/constrintern.cmx: lib/bignat.cmx kernel/declarations.cmx \ - kernel/environ.cmx pretyping/evd.cmx library/global.cmx \ - library/impargs.cmx kernel/inductive.cmx parsing/lexer.cmx \ - library/lib.cmx library/libnames.cmx library/nameops.cmx kernel/names.cmx \ - library/nametab.cmx lib/options.cmx pretyping/pattern.cmx lib/pp.cmx \ - pretyping/pretype_errors.cmx pretyping/pretyping.cmx \ - pretyping/rawterm.cmx pretyping/recordops.cmx interp/reserve.cmx \ - pretyping/retyping.cmx kernel/sign.cmx interp/symbols.cmx \ - interp/syntax_def.cmx kernel/term.cmx pretyping/termops.cmx \ - interp/topconstr.cmx lib/util.cmx interp/constrintern.cmi -interp/coqlib.cmo: interp/constrextern.cmi library/libnames.cmi \ - kernel/names.cmi library/nametab.cmi lib/options.cmi \ - pretyping/pattern.cmi lib/pp.cmi kernel/term.cmi lib/util.cmi \ +interp/constrextern.cmo: lib/util.cmi kernel/univ.cmi interp/topconstr.cmi \ + pretyping/termops.cmi kernel/term.cmi interp/symbols.cmi kernel/sign.cmi \ + interp/reserve.cmi pretyping/recordops.cmi pretyping/rawterm.cmi \ + lib/pp.cmi pretyping/pattern.cmi lib/options.cmi library/nametab.cmi \ + kernel/names.cmi library/nameops.cmi library/libnames.cmi library/lib.cmi \ + kernel/inductive.cmi library/impargs.cmi library/global.cmi \ + kernel/environ.cmi pretyping/detyping.cmi kernel/declarations.cmi \ + pretyping/classops.cmi lib/bignat.cmi interp/constrextern.cmi +interp/constrextern.cmx: lib/util.cmx kernel/univ.cmx interp/topconstr.cmx \ + pretyping/termops.cmx kernel/term.cmx interp/symbols.cmx kernel/sign.cmx \ + interp/reserve.cmx pretyping/recordops.cmx pretyping/rawterm.cmx \ + lib/pp.cmx pretyping/pattern.cmx lib/options.cmx library/nametab.cmx \ + kernel/names.cmx library/nameops.cmx library/libnames.cmx library/lib.cmx \ + kernel/inductive.cmx library/impargs.cmx library/global.cmx \ + kernel/environ.cmx pretyping/detyping.cmx kernel/declarations.cmx \ + pretyping/classops.cmx lib/bignat.cmx interp/constrextern.cmi +interp/constrintern.cmo: lib/util.cmi interp/topconstr.cmi \ + pretyping/termops.cmi kernel/term.cmi interp/syntax_def.cmi \ + interp/symbols.cmi kernel/sign.cmi pretyping/retyping.cmi \ + interp/reserve.cmi pretyping/recordops.cmi pretyping/rawterm.cmi \ + pretyping/pretyping.cmi pretyping/pretype_errors.cmi lib/pp.cmi \ + pretyping/pattern.cmi lib/options.cmi library/nametab.cmi \ + kernel/names.cmi library/nameops.cmi library/libnames.cmi library/lib.cmi \ + parsing/lexer.cmi kernel/inductive.cmi library/impargs.cmi \ + library/global.cmi pretyping/evd.cmi kernel/environ.cmi \ + kernel/declarations.cmi lib/bignat.cmi interp/constrintern.cmi +interp/constrintern.cmx: lib/util.cmx interp/topconstr.cmx \ + pretyping/termops.cmx kernel/term.cmx interp/syntax_def.cmx \ + interp/symbols.cmx kernel/sign.cmx pretyping/retyping.cmx \ + interp/reserve.cmx pretyping/recordops.cmx pretyping/rawterm.cmx \ + pretyping/pretyping.cmx pretyping/pretype_errors.cmx lib/pp.cmx \ + pretyping/pattern.cmx lib/options.cmx library/nametab.cmx \ + kernel/names.cmx library/nameops.cmx library/libnames.cmx library/lib.cmx \ + parsing/lexer.cmx kernel/inductive.cmx library/impargs.cmx \ + library/global.cmx pretyping/evd.cmx kernel/environ.cmx \ + kernel/declarations.cmx lib/bignat.cmx interp/constrintern.cmi +interp/coqlib.cmo: lib/util.cmi kernel/term.cmi lib/pp.cmi \ + pretyping/pattern.cmi lib/options.cmi library/nametab.cmi \ + kernel/names.cmi library/libnames.cmi interp/constrextern.cmi \ interp/coqlib.cmi -interp/coqlib.cmx: interp/constrextern.cmx library/libnames.cmx \ - kernel/names.cmx library/nametab.cmx lib/options.cmx \ - pretyping/pattern.cmx lib/pp.cmx kernel/term.cmx lib/util.cmx \ +interp/coqlib.cmx: lib/util.cmx kernel/term.cmx lib/pp.cmx \ + pretyping/pattern.cmx lib/options.cmx library/nametab.cmx \ + kernel/names.cmx library/libnames.cmx interp/constrextern.cmx \ interp/coqlib.cmi -interp/genarg.cmo: pretyping/evd.cmi library/nameops.cmi kernel/names.cmi \ - library/nametab.cmi lib/pp.cmi pretyping/rawterm.cmi kernel/term.cmi \ - interp/topconstr.cmi lib/util.cmi interp/genarg.cmi -interp/genarg.cmx: pretyping/evd.cmx library/nameops.cmx kernel/names.cmx \ - library/nametab.cmx lib/pp.cmx pretyping/rawterm.cmx kernel/term.cmx \ - interp/topconstr.cmx lib/util.cmx interp/genarg.cmi -interp/modintern.cmo: interp/constrintern.cmi kernel/entries.cmi \ - pretyping/evd.cmi library/libnames.cmi kernel/modops.cmi kernel/names.cmi \ - library/nametab.cmi lib/pp.cmi interp/topconstr.cmi lib/util.cmi \ - interp/modintern.cmi -interp/modintern.cmx: interp/constrintern.cmx kernel/entries.cmx \ - pretyping/evd.cmx library/libnames.cmx kernel/modops.cmx kernel/names.cmx \ - library/nametab.cmx lib/pp.cmx interp/topconstr.cmx lib/util.cmx \ - interp/modintern.cmi -interp/ppextend.cmo: kernel/names.cmi lib/pp.cmi lib/util.cmi \ +interp/genarg.cmo: lib/util.cmi interp/topconstr.cmi kernel/term.cmi \ + pretyping/rawterm.cmi lib/pp.cmi library/nametab.cmi kernel/names.cmi \ + library/nameops.cmi pretyping/evd.cmi interp/genarg.cmi +interp/genarg.cmx: lib/util.cmx interp/topconstr.cmx kernel/term.cmx \ + pretyping/rawterm.cmx lib/pp.cmx library/nametab.cmx kernel/names.cmx \ + library/nameops.cmx pretyping/evd.cmx interp/genarg.cmi +interp/modintern.cmo: lib/util.cmi interp/topconstr.cmi lib/pp.cmi \ + library/nametab.cmi kernel/names.cmi kernel/modops.cmi \ + library/libnames.cmi pretyping/evd.cmi kernel/entries.cmi \ + interp/constrintern.cmi interp/modintern.cmi +interp/modintern.cmx: lib/util.cmx interp/topconstr.cmx lib/pp.cmx \ + library/nametab.cmx kernel/names.cmx kernel/modops.cmx \ + library/libnames.cmx pretyping/evd.cmx kernel/entries.cmx \ + interp/constrintern.cmx interp/modintern.cmi +interp/ppextend.cmo: lib/util.cmi lib/pp.cmi kernel/names.cmi \ interp/ppextend.cmi -interp/ppextend.cmx: kernel/names.cmx lib/pp.cmx lib/util.cmx \ +interp/ppextend.cmx: lib/util.cmx lib/pp.cmx kernel/names.cmx \ interp/ppextend.cmi -interp/reserve.cmo: library/lib.cmi library/libobject.cmi library/nameops.cmi \ - kernel/names.cmi lib/options.cmi lib/pp.cmi pretyping/rawterm.cmi \ - library/summary.cmi lib/util.cmi interp/reserve.cmi -interp/reserve.cmx: library/lib.cmx library/libobject.cmx library/nameops.cmx \ - kernel/names.cmx lib/options.cmx lib/pp.cmx pretyping/rawterm.cmx \ - library/summary.cmx lib/util.cmx interp/reserve.cmi -interp/symbols.cmo: lib/bignat.cmi pretyping/classops.cmi library/global.cmi \ - lib/gmap.cmi lib/gmapl.cmi library/lib.cmi library/libnames.cmi \ - library/libobject.cmi kernel/names.cmi library/nametab.cmi \ - lib/options.cmi lib/pp.cmi interp/ppextend.cmi pretyping/rawterm.cmi \ - pretyping/reductionops.cmi library/summary.cmi kernel/term.cmi \ - interp/topconstr.cmi lib/util.cmi interp/symbols.cmi -interp/symbols.cmx: lib/bignat.cmx pretyping/classops.cmx library/global.cmx \ - lib/gmap.cmx lib/gmapl.cmx library/lib.cmx library/libnames.cmx \ - library/libobject.cmx kernel/names.cmx library/nametab.cmx \ - lib/options.cmx lib/pp.cmx interp/ppextend.cmx pretyping/rawterm.cmx \ - pretyping/reductionops.cmx library/summary.cmx kernel/term.cmx \ - interp/topconstr.cmx lib/util.cmx interp/symbols.cmi -interp/syntax_def.cmo: library/lib.cmi library/libnames.cmi \ - library/libobject.cmi library/nameops.cmi kernel/names.cmi \ - library/nametab.cmi lib/pp.cmi library/summary.cmi interp/symbols.cmi \ - interp/topconstr.cmi lib/util.cmi interp/syntax_def.cmi -interp/syntax_def.cmx: library/lib.cmx library/libnames.cmx \ - library/libobject.cmx library/nameops.cmx kernel/names.cmx \ - library/nametab.cmx lib/pp.cmx library/summary.cmx interp/symbols.cmx \ - interp/topconstr.cmx lib/util.cmx interp/syntax_def.cmi -interp/topconstr.cmo: lib/bignat.cmi lib/dyn.cmi library/libnames.cmi \ - library/nameops.cmi kernel/names.cmi lib/options.cmi lib/pp.cmi \ - pretyping/rawterm.cmi kernel/term.cmi lib/util.cmi interp/topconstr.cmi -interp/topconstr.cmx: lib/bignat.cmx lib/dyn.cmx library/libnames.cmx \ - library/nameops.cmx kernel/names.cmx lib/options.cmx lib/pp.cmx \ - pretyping/rawterm.cmx kernel/term.cmx lib/util.cmx interp/topconstr.cmi -kernel/closure.cmo: kernel/declarations.cmi kernel/environ.cmi \ - kernel/esubst.cmi kernel/names.cmi lib/pp.cmi kernel/term.cmi \ - lib/util.cmi kernel/closure.cmi -kernel/closure.cmx: kernel/declarations.cmx kernel/environ.cmx \ - kernel/esubst.cmx kernel/names.cmx lib/pp.cmx kernel/term.cmx \ - lib/util.cmx kernel/closure.cmi -kernel/conv_oracle.cmo: kernel/closure.cmi kernel/names.cmi \ +interp/reserve.cmo: lib/util.cmi library/summary.cmi pretyping/rawterm.cmi \ + lib/pp.cmi lib/options.cmi kernel/names.cmi library/nameops.cmi \ + library/libobject.cmi library/lib.cmi interp/reserve.cmi +interp/reserve.cmx: lib/util.cmx library/summary.cmx pretyping/rawterm.cmx \ + lib/pp.cmx lib/options.cmx kernel/names.cmx library/nameops.cmx \ + library/libobject.cmx library/lib.cmx interp/reserve.cmi +interp/symbols.cmo: lib/util.cmi interp/topconstr.cmi kernel/term.cmi \ + library/summary.cmi pretyping/reductionops.cmi pretyping/rawterm.cmi \ + interp/ppextend.cmi lib/pp.cmi lib/options.cmi library/nametab.cmi \ + kernel/names.cmi library/libobject.cmi library/libnames.cmi \ + library/lib.cmi lib/gmapl.cmi lib/gmap.cmi library/global.cmi \ + pretyping/classops.cmi lib/bignat.cmi interp/symbols.cmi +interp/symbols.cmx: lib/util.cmx interp/topconstr.cmx kernel/term.cmx \ + library/summary.cmx pretyping/reductionops.cmx pretyping/rawterm.cmx \ + interp/ppextend.cmx lib/pp.cmx lib/options.cmx library/nametab.cmx \ + kernel/names.cmx library/libobject.cmx library/libnames.cmx \ + library/lib.cmx lib/gmapl.cmx lib/gmap.cmx library/global.cmx \ + pretyping/classops.cmx lib/bignat.cmx interp/symbols.cmi +interp/syntax_def.cmo: lib/util.cmi interp/topconstr.cmi interp/symbols.cmi \ + library/summary.cmi lib/pp.cmi library/nametab.cmi kernel/names.cmi \ + library/nameops.cmi library/libobject.cmi library/libnames.cmi \ + library/lib.cmi interp/syntax_def.cmi +interp/syntax_def.cmx: lib/util.cmx interp/topconstr.cmx interp/symbols.cmx \ + library/summary.cmx lib/pp.cmx library/nametab.cmx kernel/names.cmx \ + library/nameops.cmx library/libobject.cmx library/libnames.cmx \ + library/lib.cmx interp/syntax_def.cmi +interp/topconstr.cmo: lib/util.cmi kernel/term.cmi pretyping/rawterm.cmi \ + lib/pp.cmi lib/options.cmi kernel/names.cmi library/nameops.cmi \ + library/libnames.cmi lib/dyn.cmi lib/bignat.cmi interp/topconstr.cmi +interp/topconstr.cmx: lib/util.cmx kernel/term.cmx pretyping/rawterm.cmx \ + lib/pp.cmx lib/options.cmx kernel/names.cmx library/nameops.cmx \ + library/libnames.cmx lib/dyn.cmx lib/bignat.cmx interp/topconstr.cmi +kernel/closure.cmo: lib/util.cmi kernel/term.cmi lib/pp.cmi kernel/names.cmi \ + kernel/esubst.cmi kernel/environ.cmi kernel/declarations.cmi \ + kernel/closure.cmi +kernel/closure.cmx: lib/util.cmx kernel/term.cmx lib/pp.cmx kernel/names.cmx \ + kernel/esubst.cmx kernel/environ.cmx kernel/declarations.cmx \ + kernel/closure.cmi +kernel/conv_oracle.cmo: kernel/names.cmi kernel/closure.cmi \ kernel/conv_oracle.cmi -kernel/conv_oracle.cmx: kernel/closure.cmx kernel/names.cmx \ +kernel/conv_oracle.cmx: kernel/names.cmx kernel/closure.cmx \ kernel/conv_oracle.cmi -kernel/cooking.cmo: kernel/declarations.cmi kernel/environ.cmi \ - kernel/names.cmi lib/pp.cmi kernel/reduction.cmi kernel/sign.cmi \ - kernel/term.cmi lib/util.cmi kernel/cooking.cmi -kernel/cooking.cmx: kernel/declarations.cmx kernel/environ.cmx \ - kernel/names.cmx lib/pp.cmx kernel/reduction.cmx kernel/sign.cmx \ - kernel/term.cmx lib/util.cmx kernel/cooking.cmi -kernel/declarations.cmo: kernel/names.cmi lib/rtree.cmi kernel/sign.cmi \ - kernel/term.cmi kernel/univ.cmi lib/util.cmi kernel/declarations.cmi -kernel/declarations.cmx: kernel/names.cmx lib/rtree.cmx kernel/sign.cmx \ - kernel/term.cmx kernel/univ.cmx lib/util.cmx kernel/declarations.cmi -kernel/entries.cmo: kernel/names.cmi kernel/sign.cmi kernel/term.cmi \ - kernel/univ.cmi kernel/entries.cmi -kernel/entries.cmx: kernel/names.cmx kernel/sign.cmx kernel/term.cmx \ - kernel/univ.cmx kernel/entries.cmi -kernel/environ.cmo: kernel/declarations.cmi kernel/names.cmi kernel/sign.cmi \ - kernel/term.cmi kernel/univ.cmi lib/util.cmi kernel/environ.cmi -kernel/environ.cmx: kernel/declarations.cmx kernel/names.cmx kernel/sign.cmx \ - kernel/term.cmx kernel/univ.cmx lib/util.cmx kernel/environ.cmi +kernel/cooking.cmo: lib/util.cmi kernel/term.cmi kernel/sign.cmi \ + kernel/reduction.cmi lib/pp.cmi kernel/names.cmi kernel/environ.cmi \ + kernel/declarations.cmi kernel/cooking.cmi +kernel/cooking.cmx: lib/util.cmx kernel/term.cmx kernel/sign.cmx \ + kernel/reduction.cmx lib/pp.cmx kernel/names.cmx kernel/environ.cmx \ + kernel/declarations.cmx kernel/cooking.cmi +kernel/declarations.cmo: lib/util.cmi kernel/univ.cmi kernel/term.cmi \ + kernel/sign.cmi lib/rtree.cmi kernel/names.cmi kernel/declarations.cmi +kernel/declarations.cmx: lib/util.cmx kernel/univ.cmx kernel/term.cmx \ + kernel/sign.cmx lib/rtree.cmx kernel/names.cmx kernel/declarations.cmi +kernel/entries.cmo: kernel/univ.cmi kernel/term.cmi kernel/sign.cmi \ + kernel/names.cmi kernel/entries.cmi +kernel/entries.cmx: kernel/univ.cmx kernel/term.cmx kernel/sign.cmx \ + kernel/names.cmx kernel/entries.cmi +kernel/environ.cmo: lib/util.cmi kernel/univ.cmi kernel/term.cmi \ + kernel/sign.cmi kernel/names.cmi kernel/declarations.cmi \ + kernel/environ.cmi +kernel/environ.cmx: lib/util.cmx kernel/univ.cmx kernel/term.cmx \ + kernel/sign.cmx kernel/names.cmx kernel/declarations.cmx \ + kernel/environ.cmi kernel/esubst.cmo: lib/util.cmi kernel/esubst.cmi kernel/esubst.cmx: lib/util.cmx kernel/esubst.cmi -kernel/indtypes.cmo: kernel/declarations.cmi kernel/entries.cmi \ - kernel/environ.cmi kernel/inductive.cmi kernel/names.cmi \ - kernel/reduction.cmi lib/rtree.cmi kernel/sign.cmi kernel/term.cmi \ - kernel/typeops.cmi kernel/univ.cmi lib/util.cmi kernel/indtypes.cmi -kernel/indtypes.cmx: kernel/declarations.cmx kernel/entries.cmx \ - kernel/environ.cmx kernel/inductive.cmx kernel/names.cmx \ - kernel/reduction.cmx lib/rtree.cmx kernel/sign.cmx kernel/term.cmx \ - kernel/typeops.cmx kernel/univ.cmx lib/util.cmx kernel/indtypes.cmi -kernel/inductive.cmo: kernel/declarations.cmi kernel/environ.cmi \ - kernel/names.cmi kernel/reduction.cmi kernel/sign.cmi kernel/term.cmi \ - kernel/type_errors.cmi kernel/univ.cmi lib/util.cmi kernel/inductive.cmi -kernel/inductive.cmx: kernel/declarations.cmx kernel/environ.cmx \ - kernel/names.cmx kernel/reduction.cmx kernel/sign.cmx kernel/term.cmx \ - kernel/type_errors.cmx kernel/univ.cmx lib/util.cmx kernel/inductive.cmi -kernel/modops.cmo: kernel/declarations.cmi kernel/entries.cmi \ - kernel/environ.cmi kernel/names.cmi lib/pp.cmi kernel/term.cmi \ - kernel/univ.cmi lib/util.cmi kernel/modops.cmi -kernel/modops.cmx: kernel/declarations.cmx kernel/entries.cmx \ - kernel/environ.cmx kernel/names.cmx lib/pp.cmx kernel/term.cmx \ - kernel/univ.cmx lib/util.cmx kernel/modops.cmi -kernel/mod_typing.cmo: kernel/declarations.cmi kernel/entries.cmi \ - kernel/environ.cmi kernel/modops.cmi kernel/names.cmi \ - kernel/reduction.cmi kernel/subtyping.cmi kernel/term_typing.cmi \ - kernel/typeops.cmi kernel/univ.cmi lib/util.cmi kernel/mod_typing.cmi -kernel/mod_typing.cmx: kernel/declarations.cmx kernel/entries.cmx \ - kernel/environ.cmx kernel/modops.cmx kernel/names.cmx \ - kernel/reduction.cmx kernel/subtyping.cmx kernel/term_typing.cmx \ - kernel/typeops.cmx kernel/univ.cmx lib/util.cmx kernel/mod_typing.cmi -kernel/names.cmo: lib/hashcons.cmi lib/options.cmi lib/pp.cmi \ - lib/predicate.cmi lib/util.cmi kernel/names.cmi -kernel/names.cmx: lib/hashcons.cmx lib/options.cmx lib/pp.cmx \ - lib/predicate.cmx lib/util.cmx kernel/names.cmi -kernel/reduction.cmo: kernel/closure.cmi kernel/conv_oracle.cmi \ - kernel/declarations.cmi kernel/environ.cmi kernel/esubst.cmi \ - kernel/names.cmi kernel/sign.cmi kernel/term.cmi kernel/univ.cmi \ - lib/util.cmi kernel/reduction.cmi -kernel/reduction.cmx: kernel/closure.cmx kernel/conv_oracle.cmx \ - kernel/declarations.cmx kernel/environ.cmx kernel/esubst.cmx \ - kernel/names.cmx kernel/sign.cmx kernel/term.cmx kernel/univ.cmx \ - lib/util.cmx kernel/reduction.cmi -kernel/safe_typing.cmo: kernel/cooking.cmi kernel/declarations.cmi \ - kernel/entries.cmi kernel/environ.cmi kernel/indtypes.cmi \ - kernel/inductive.cmi kernel/mod_typing.cmi kernel/modops.cmi \ - kernel/names.cmi kernel/reduction.cmi kernel/sign.cmi \ - kernel/subtyping.cmi kernel/term.cmi kernel/term_typing.cmi \ - kernel/type_errors.cmi kernel/typeops.cmi kernel/univ.cmi lib/util.cmi \ +kernel/indtypes.cmo: lib/util.cmi kernel/univ.cmi kernel/typeops.cmi \ + kernel/term.cmi kernel/sign.cmi lib/rtree.cmi kernel/reduction.cmi \ + kernel/names.cmi kernel/inductive.cmi kernel/environ.cmi \ + kernel/entries.cmi kernel/declarations.cmi kernel/indtypes.cmi +kernel/indtypes.cmx: lib/util.cmx kernel/univ.cmx kernel/typeops.cmx \ + kernel/term.cmx kernel/sign.cmx lib/rtree.cmx kernel/reduction.cmx \ + kernel/names.cmx kernel/inductive.cmx kernel/environ.cmx \ + kernel/entries.cmx kernel/declarations.cmx kernel/indtypes.cmi +kernel/inductive.cmo: lib/util.cmi kernel/univ.cmi kernel/type_errors.cmi \ + kernel/term.cmi kernel/sign.cmi kernel/reduction.cmi kernel/names.cmi \ + kernel/environ.cmi kernel/declarations.cmi kernel/inductive.cmi +kernel/inductive.cmx: lib/util.cmx kernel/univ.cmx kernel/type_errors.cmx \ + kernel/term.cmx kernel/sign.cmx kernel/reduction.cmx kernel/names.cmx \ + kernel/environ.cmx kernel/declarations.cmx kernel/inductive.cmi +kernel/mod_typing.cmo: lib/util.cmi kernel/univ.cmi kernel/typeops.cmi \ + kernel/term_typing.cmi kernel/subtyping.cmi kernel/reduction.cmi \ + kernel/names.cmi kernel/modops.cmi kernel/environ.cmi kernel/entries.cmi \ + kernel/declarations.cmi kernel/mod_typing.cmi +kernel/mod_typing.cmx: lib/util.cmx kernel/univ.cmx kernel/typeops.cmx \ + kernel/term_typing.cmx kernel/subtyping.cmx kernel/reduction.cmx \ + kernel/names.cmx kernel/modops.cmx kernel/environ.cmx kernel/entries.cmx \ + kernel/declarations.cmx kernel/mod_typing.cmi +kernel/modops.cmo: lib/util.cmi kernel/univ.cmi kernel/term.cmi lib/pp.cmi \ + kernel/names.cmi kernel/environ.cmi kernel/entries.cmi \ + kernel/declarations.cmi kernel/modops.cmi +kernel/modops.cmx: lib/util.cmx kernel/univ.cmx kernel/term.cmx lib/pp.cmx \ + kernel/names.cmx kernel/environ.cmx kernel/entries.cmx \ + kernel/declarations.cmx kernel/modops.cmi +kernel/names.cmo: lib/util.cmi lib/predicate.cmi lib/pp.cmi lib/options.cmi \ + lib/hashcons.cmi kernel/names.cmi +kernel/names.cmx: lib/util.cmx lib/predicate.cmx lib/pp.cmx lib/options.cmx \ + lib/hashcons.cmx kernel/names.cmi +kernel/reduction.cmo: lib/util.cmi kernel/univ.cmi kernel/term.cmi \ + kernel/sign.cmi kernel/names.cmi kernel/esubst.cmi kernel/environ.cmi \ + kernel/declarations.cmi kernel/conv_oracle.cmi kernel/closure.cmi \ + kernel/reduction.cmi +kernel/reduction.cmx: lib/util.cmx kernel/univ.cmx kernel/term.cmx \ + kernel/sign.cmx kernel/names.cmx kernel/esubst.cmx kernel/environ.cmx \ + kernel/declarations.cmx kernel/conv_oracle.cmx kernel/closure.cmx \ + kernel/reduction.cmi +kernel/safe_typing.cmo: lib/util.cmi kernel/univ.cmi kernel/typeops.cmi \ + kernel/type_errors.cmi kernel/term_typing.cmi kernel/term.cmi \ + kernel/subtyping.cmi kernel/sign.cmi kernel/reduction.cmi \ + kernel/names.cmi kernel/modops.cmi kernel/mod_typing.cmi \ + kernel/inductive.cmi kernel/indtypes.cmi kernel/environ.cmi \ + kernel/entries.cmi kernel/declarations.cmi kernel/cooking.cmi \ kernel/safe_typing.cmi -kernel/safe_typing.cmx: kernel/cooking.cmx kernel/declarations.cmx \ - kernel/entries.cmx kernel/environ.cmx kernel/indtypes.cmx \ - kernel/inductive.cmx kernel/mod_typing.cmx kernel/modops.cmx \ - kernel/names.cmx kernel/reduction.cmx kernel/sign.cmx \ - kernel/subtyping.cmx kernel/term.cmx kernel/term_typing.cmx \ - kernel/type_errors.cmx kernel/typeops.cmx kernel/univ.cmx lib/util.cmx \ +kernel/safe_typing.cmx: lib/util.cmx kernel/univ.cmx kernel/typeops.cmx \ + kernel/type_errors.cmx kernel/term_typing.cmx kernel/term.cmx \ + kernel/subtyping.cmx kernel/sign.cmx kernel/reduction.cmx \ + kernel/names.cmx kernel/modops.cmx kernel/mod_typing.cmx \ + kernel/inductive.cmx kernel/indtypes.cmx kernel/environ.cmx \ + kernel/entries.cmx kernel/declarations.cmx kernel/cooking.cmx \ kernel/safe_typing.cmi -kernel/sign.cmo: kernel/names.cmi kernel/term.cmi lib/util.cmi \ +kernel/sign.cmo: lib/util.cmi kernel/term.cmi kernel/names.cmi \ kernel/sign.cmi -kernel/sign.cmx: kernel/names.cmx kernel/term.cmx lib/util.cmx \ +kernel/sign.cmx: lib/util.cmx kernel/term.cmx kernel/names.cmx \ kernel/sign.cmi -kernel/subtyping.cmo: kernel/declarations.cmi kernel/environ.cmi \ - kernel/inductive.cmi kernel/modops.cmi kernel/names.cmi \ - kernel/reduction.cmi kernel/term.cmi kernel/univ.cmi lib/util.cmi \ +kernel/subtyping.cmo: lib/util.cmi kernel/univ.cmi kernel/term.cmi \ + kernel/reduction.cmi kernel/names.cmi kernel/modops.cmi \ + kernel/inductive.cmi kernel/environ.cmi kernel/declarations.cmi \ kernel/subtyping.cmi -kernel/subtyping.cmx: kernel/declarations.cmx kernel/environ.cmx \ - kernel/inductive.cmx kernel/modops.cmx kernel/names.cmx \ - kernel/reduction.cmx kernel/term.cmx kernel/univ.cmx lib/util.cmx \ +kernel/subtyping.cmx: lib/util.cmx kernel/univ.cmx kernel/term.cmx \ + kernel/reduction.cmx kernel/names.cmx kernel/modops.cmx \ + kernel/inductive.cmx kernel/environ.cmx kernel/declarations.cmx \ kernel/subtyping.cmi -kernel/term.cmo: kernel/esubst.cmi lib/hashcons.cmi kernel/names.cmi \ - lib/pp.cmi kernel/univ.cmi lib/util.cmi kernel/term.cmi -kernel/term.cmx: kernel/esubst.cmx lib/hashcons.cmx kernel/names.cmx \ - lib/pp.cmx kernel/univ.cmx lib/util.cmx kernel/term.cmi -kernel/term_typing.cmo: kernel/cooking.cmi kernel/declarations.cmi \ - kernel/entries.cmi kernel/environ.cmi kernel/indtypes.cmi \ - kernel/inductive.cmi kernel/names.cmi kernel/reduction.cmi \ - kernel/sign.cmi kernel/term.cmi kernel/type_errors.cmi kernel/typeops.cmi \ - kernel/univ.cmi lib/util.cmi kernel/term_typing.cmi -kernel/term_typing.cmx: kernel/cooking.cmx kernel/declarations.cmx \ - kernel/entries.cmx kernel/environ.cmx kernel/indtypes.cmx \ - kernel/inductive.cmx kernel/names.cmx kernel/reduction.cmx \ - kernel/sign.cmx kernel/term.cmx kernel/type_errors.cmx kernel/typeops.cmx \ - kernel/univ.cmx lib/util.cmx kernel/term_typing.cmi -kernel/type_errors.cmo: kernel/environ.cmi kernel/names.cmi \ - kernel/reduction.cmi kernel/sign.cmi kernel/term.cmi \ - kernel/type_errors.cmi -kernel/type_errors.cmx: kernel/environ.cmx kernel/names.cmx \ - kernel/reduction.cmx kernel/sign.cmx kernel/term.cmx \ - kernel/type_errors.cmi -kernel/typeops.cmo: kernel/declarations.cmi kernel/entries.cmi \ - kernel/environ.cmi kernel/inductive.cmi kernel/names.cmi \ - kernel/reduction.cmi kernel/sign.cmi kernel/term.cmi \ - kernel/type_errors.cmi kernel/univ.cmi lib/util.cmi kernel/typeops.cmi -kernel/typeops.cmx: kernel/declarations.cmx kernel/entries.cmx \ - kernel/environ.cmx kernel/inductive.cmx kernel/names.cmx \ - kernel/reduction.cmx kernel/sign.cmx kernel/term.cmx \ - kernel/type_errors.cmx kernel/univ.cmx lib/util.cmx kernel/typeops.cmi -kernel/univ.cmo: lib/hashcons.cmi kernel/names.cmi lib/pp.cmi lib/util.cmi \ +kernel/term.cmo: lib/util.cmi kernel/univ.cmi lib/pp.cmi kernel/names.cmi \ + lib/hashcons.cmi kernel/esubst.cmi kernel/term.cmi +kernel/term.cmx: lib/util.cmx kernel/univ.cmx lib/pp.cmx kernel/names.cmx \ + lib/hashcons.cmx kernel/esubst.cmx kernel/term.cmi +kernel/term_typing.cmo: lib/util.cmi kernel/univ.cmi kernel/typeops.cmi \ + kernel/type_errors.cmi kernel/term.cmi kernel/sign.cmi \ + kernel/reduction.cmi kernel/names.cmi kernel/inductive.cmi \ + kernel/indtypes.cmi kernel/environ.cmi kernel/entries.cmi \ + kernel/declarations.cmi kernel/cooking.cmi kernel/term_typing.cmi +kernel/term_typing.cmx: lib/util.cmx kernel/univ.cmx kernel/typeops.cmx \ + kernel/type_errors.cmx kernel/term.cmx kernel/sign.cmx \ + kernel/reduction.cmx kernel/names.cmx kernel/inductive.cmx \ + kernel/indtypes.cmx kernel/environ.cmx kernel/entries.cmx \ + kernel/declarations.cmx kernel/cooking.cmx kernel/term_typing.cmi +kernel/type_errors.cmo: kernel/term.cmi kernel/sign.cmi kernel/reduction.cmi \ + kernel/names.cmi kernel/environ.cmi kernel/type_errors.cmi +kernel/type_errors.cmx: kernel/term.cmx kernel/sign.cmx kernel/reduction.cmx \ + kernel/names.cmx kernel/environ.cmx kernel/type_errors.cmi +kernel/typeops.cmo: lib/util.cmi kernel/univ.cmi kernel/type_errors.cmi \ + kernel/term.cmi kernel/sign.cmi kernel/reduction.cmi kernel/names.cmi \ + kernel/inductive.cmi kernel/environ.cmi kernel/entries.cmi \ + kernel/declarations.cmi kernel/typeops.cmi +kernel/typeops.cmx: lib/util.cmx kernel/univ.cmx kernel/type_errors.cmx \ + kernel/term.cmx kernel/sign.cmx kernel/reduction.cmx kernel/names.cmx \ + kernel/inductive.cmx kernel/environ.cmx kernel/entries.cmx \ + kernel/declarations.cmx kernel/typeops.cmi +kernel/univ.cmo: lib/util.cmi lib/pp.cmi kernel/names.cmi lib/hashcons.cmi \ kernel/univ.cmi -kernel/univ.cmx: lib/hashcons.cmx kernel/names.cmx lib/pp.cmx lib/util.cmx \ +kernel/univ.cmx: lib/util.cmx lib/pp.cmx kernel/names.cmx lib/hashcons.cmx \ kernel/univ.cmi lib/bignat.cmo: lib/pp.cmi lib/bignat.cmi lib/bignat.cmx: lib/pp.cmx lib/bignat.cmi @@ -745,14 +746,14 @@ lib/bstack.cmo: lib/util.cmi lib/bstack.cmi lib/bstack.cmx: lib/util.cmx lib/bstack.cmi lib/dyn.cmo: lib/util.cmi lib/dyn.cmi lib/dyn.cmx: lib/util.cmx lib/dyn.cmi -lib/edit.cmo: lib/bstack.cmi lib/pp.cmi lib/util.cmi lib/edit.cmi -lib/edit.cmx: lib/bstack.cmx lib/pp.cmx lib/util.cmx lib/edit.cmi +lib/edit.cmo: lib/util.cmi lib/pp.cmi lib/bstack.cmi lib/edit.cmi +lib/edit.cmx: lib/util.cmx lib/pp.cmx lib/bstack.cmx lib/edit.cmi lib/explore.cmo: lib/explore.cmi lib/explore.cmx: lib/explore.cmi -lib/gmapl.cmo: lib/gmap.cmi lib/util.cmi lib/gmapl.cmi -lib/gmapl.cmx: lib/gmap.cmx lib/util.cmx lib/gmapl.cmi lib/gmap.cmo: lib/gmap.cmi lib/gmap.cmx: lib/gmap.cmi +lib/gmapl.cmo: lib/util.cmi lib/gmap.cmi lib/gmapl.cmi +lib/gmapl.cmx: lib/util.cmx lib/gmap.cmx lib/gmapl.cmi lib/gset.cmo: lib/gset.cmi lib/gset.cmx: lib/gset.cmi lib/hashcons.cmo: lib/hashcons.cmi @@ -761,2280 +762,2276 @@ lib/heap.cmo: lib/heap.cmi lib/heap.cmx: lib/heap.cmi lib/options.cmo: lib/util.cmi lib/options.cmi lib/options.cmx: lib/util.cmx lib/options.cmi -lib/pp_control.cmo: lib/pp_control.cmi -lib/pp_control.cmx: lib/pp_control.cmi lib/pp.cmo: lib/pp_control.cmi lib/pp.cmi lib/pp.cmx: lib/pp_control.cmx lib/pp.cmi +lib/pp_control.cmo: lib/pp_control.cmi +lib/pp_control.cmx: lib/pp_control.cmi lib/predicate.cmo: lib/predicate.cmi lib/predicate.cmx: lib/predicate.cmi lib/profile.cmo: lib/profile.cmi lib/profile.cmx: lib/profile.cmi -library/declare.cmo: library/decl_kinds.cmo kernel/declarations.cmi \ - library/dischargedhypsmap.cmi kernel/entries.cmi kernel/environ.cmi \ - library/global.cmi library/impargs.cmi kernel/indtypes.cmi \ - kernel/inductive.cmi library/lib.cmi library/libnames.cmi \ - library/libobject.cmi library/nameops.cmi kernel/names.cmi \ - library/nametab.cmi lib/options.cmi lib/pp.cmi kernel/reduction.cmi \ - kernel/safe_typing.cmi kernel/sign.cmi library/summary.cmi \ - interp/symbols.cmi kernel/term.cmi kernel/type_errors.cmi \ - kernel/typeops.cmi kernel/univ.cmi lib/util.cmi library/declare.cmi -library/declare.cmx: library/decl_kinds.cmx kernel/declarations.cmx \ - library/dischargedhypsmap.cmx kernel/entries.cmx kernel/environ.cmx \ - library/global.cmx library/impargs.cmx kernel/indtypes.cmx \ - kernel/inductive.cmx library/lib.cmx library/libnames.cmx \ - library/libobject.cmx library/nameops.cmx kernel/names.cmx \ - library/nametab.cmx lib/options.cmx lib/pp.cmx kernel/reduction.cmx \ - kernel/safe_typing.cmx kernel/sign.cmx library/summary.cmx \ - interp/symbols.cmx kernel/term.cmx kernel/type_errors.cmx \ - kernel/typeops.cmx kernel/univ.cmx lib/util.cmx library/declare.cmi -library/declaremods.cmo: kernel/declarations.cmi kernel/entries.cmi \ - kernel/environ.cmi library/global.cmi library/lib.cmi \ - library/libnames.cmi library/libobject.cmi kernel/mod_typing.cmi \ - kernel/modops.cmi kernel/names.cmi library/nametab.cmi lib/pp.cmi \ - kernel/subtyping.cmi library/summary.cmi lib/util.cmi \ +lib/rtree.cmo: lib/util.cmi lib/pp.cmi lib/rtree.cmi +lib/rtree.cmx: lib/util.cmx lib/pp.cmx lib/rtree.cmi +lib/stamps.cmo: lib/stamps.cmi +lib/stamps.cmx: lib/stamps.cmi +lib/system.cmo: lib/util.cmi lib/pp.cmi config/coq_config.cmi lib/system.cmi +lib/system.cmx: lib/util.cmx lib/pp.cmx config/coq_config.cmx lib/system.cmi +lib/tlm.cmo: lib/gset.cmi lib/gmap.cmi lib/tlm.cmi +lib/tlm.cmx: lib/gset.cmx lib/gmap.cmx lib/tlm.cmi +lib/util.cmo: lib/pp.cmi lib/compat.cmo lib/util.cmi +lib/util.cmx: lib/pp.cmx lib/compat.cmx lib/util.cmi +library/declare.cmo: lib/util.cmi kernel/univ.cmi kernel/typeops.cmi \ + kernel/type_errors.cmi kernel/term.cmi interp/symbols.cmi \ + library/summary.cmi kernel/sign.cmi kernel/safe_typing.cmi \ + kernel/reduction.cmi lib/pp.cmi lib/options.cmi library/nametab.cmi \ + kernel/names.cmi library/nameops.cmi library/libobject.cmi \ + library/libnames.cmi library/lib.cmi kernel/inductive.cmi \ + kernel/indtypes.cmi library/impargs.cmi library/global.cmi \ + kernel/environ.cmi kernel/entries.cmi library/dischargedhypsmap.cmi \ + kernel/declarations.cmi library/decl_kinds.cmo library/declare.cmi +library/declare.cmx: lib/util.cmx kernel/univ.cmx kernel/typeops.cmx \ + kernel/type_errors.cmx kernel/term.cmx interp/symbols.cmx \ + library/summary.cmx kernel/sign.cmx kernel/safe_typing.cmx \ + kernel/reduction.cmx lib/pp.cmx lib/options.cmx library/nametab.cmx \ + kernel/names.cmx library/nameops.cmx library/libobject.cmx \ + library/libnames.cmx library/lib.cmx kernel/inductive.cmx \ + kernel/indtypes.cmx library/impargs.cmx library/global.cmx \ + kernel/environ.cmx kernel/entries.cmx library/dischargedhypsmap.cmx \ + kernel/declarations.cmx library/decl_kinds.cmx library/declare.cmi +library/declaremods.cmo: lib/util.cmi library/summary.cmi \ + kernel/subtyping.cmi lib/pp.cmi library/nametab.cmi kernel/names.cmi \ + kernel/modops.cmi kernel/mod_typing.cmi library/libobject.cmi \ + library/libnames.cmi library/lib.cmi library/global.cmi \ + kernel/environ.cmi kernel/entries.cmi kernel/declarations.cmi \ library/declaremods.cmi -library/declaremods.cmx: kernel/declarations.cmx kernel/entries.cmx \ - kernel/environ.cmx library/global.cmx library/lib.cmx \ - library/libnames.cmx library/libobject.cmx kernel/mod_typing.cmx \ - kernel/modops.cmx kernel/names.cmx library/nametab.cmx lib/pp.cmx \ - kernel/subtyping.cmx library/summary.cmx lib/util.cmx \ +library/declaremods.cmx: lib/util.cmx library/summary.cmx \ + kernel/subtyping.cmx lib/pp.cmx library/nametab.cmx kernel/names.cmx \ + kernel/modops.cmx kernel/mod_typing.cmx library/libobject.cmx \ + library/libnames.cmx library/lib.cmx library/global.cmx \ + kernel/environ.cmx kernel/entries.cmx kernel/declarations.cmx \ library/declaremods.cmi -library/dischargedhypsmap.cmo: kernel/declarations.cmi kernel/environ.cmi \ - kernel/inductive.cmi library/lib.cmi library/libnames.cmi \ - library/libobject.cmi kernel/names.cmi library/nametab.cmi \ - kernel/reduction.cmi library/summary.cmi kernel/term.cmi lib/util.cmi \ - library/dischargedhypsmap.cmi -library/dischargedhypsmap.cmx: kernel/declarations.cmx kernel/environ.cmx \ - kernel/inductive.cmx library/lib.cmx library/libnames.cmx \ - library/libobject.cmx kernel/names.cmx library/nametab.cmx \ - kernel/reduction.cmx library/summary.cmx kernel/term.cmx lib/util.cmx \ - library/dischargedhypsmap.cmi -library/global.cmo: kernel/environ.cmi kernel/inductive.cmi \ - library/libnames.cmi kernel/names.cmi kernel/safe_typing.cmi \ - kernel/sign.cmi library/summary.cmi kernel/term.cmi lib/util.cmi \ +library/dischargedhypsmap.cmo: lib/util.cmi kernel/term.cmi \ + library/summary.cmi kernel/reduction.cmi library/nametab.cmi \ + kernel/names.cmi library/libobject.cmi library/libnames.cmi \ + library/lib.cmi kernel/inductive.cmi kernel/environ.cmi \ + kernel/declarations.cmi library/dischargedhypsmap.cmi +library/dischargedhypsmap.cmx: lib/util.cmx kernel/term.cmx \ + library/summary.cmx kernel/reduction.cmx library/nametab.cmx \ + kernel/names.cmx library/libobject.cmx library/libnames.cmx \ + library/lib.cmx kernel/inductive.cmx kernel/environ.cmx \ + kernel/declarations.cmx library/dischargedhypsmap.cmi +library/global.cmo: lib/util.cmi kernel/term.cmi library/summary.cmi \ + kernel/sign.cmi kernel/safe_typing.cmi kernel/names.cmi \ + library/libnames.cmi kernel/inductive.cmi kernel/environ.cmi \ library/global.cmi -library/global.cmx: kernel/environ.cmx kernel/inductive.cmx \ - library/libnames.cmx kernel/names.cmx kernel/safe_typing.cmx \ - kernel/sign.cmx library/summary.cmx kernel/term.cmx lib/util.cmx \ +library/global.cmx: lib/util.cmx kernel/term.cmx library/summary.cmx \ + kernel/sign.cmx kernel/safe_typing.cmx kernel/names.cmx \ + library/libnames.cmx kernel/inductive.cmx kernel/environ.cmx \ library/global.cmi -library/goptions.cmo: library/lib.cmi library/libnames.cmi \ - library/libobject.cmi kernel/names.cmi library/nametab.cmi lib/pp.cmi \ - library/summary.cmi kernel/term.cmi lib/util.cmi library/goptions.cmi -library/goptions.cmx: library/lib.cmx library/libnames.cmx \ - library/libobject.cmx kernel/names.cmx library/nametab.cmx lib/pp.cmx \ - library/summary.cmx kernel/term.cmx lib/util.cmx library/goptions.cmi -library/impargs.cmo: kernel/declarations.cmi kernel/environ.cmi \ - library/global.cmi kernel/inductive.cmi library/lib.cmi \ - library/libnames.cmi library/libobject.cmi kernel/names.cmi \ - library/nametab.cmi lib/options.cmi lib/pp.cmi kernel/reduction.cmi \ - library/summary.cmi kernel/term.cmi pretyping/termops.cmi \ - interp/topconstr.cmi lib/util.cmi library/impargs.cmi -library/impargs.cmx: kernel/declarations.cmx kernel/environ.cmx \ - library/global.cmx kernel/inductive.cmx library/lib.cmx \ - library/libnames.cmx library/libobject.cmx kernel/names.cmx \ - library/nametab.cmx lib/options.cmx lib/pp.cmx kernel/reduction.cmx \ - library/summary.cmx kernel/term.cmx pretyping/termops.cmx \ - interp/topconstr.cmx lib/util.cmx library/impargs.cmi -library/lib.cmo: library/libnames.cmi library/libobject.cmi \ - library/nameops.cmi kernel/names.cmi library/nametab.cmi lib/options.cmi \ - lib/pp.cmi library/summary.cmi lib/util.cmi library/lib.cmi -library/lib.cmx: library/libnames.cmx library/libobject.cmx \ - library/nameops.cmx kernel/names.cmx library/nametab.cmx lib/options.cmx \ - lib/pp.cmx library/summary.cmx lib/util.cmx library/lib.cmi -library/libnames.cmo: library/nameops.cmi kernel/names.cmi lib/pp.cmi \ - lib/predicate.cmi kernel/term.cmi lib/util.cmi library/libnames.cmi -library/libnames.cmx: library/nameops.cmx kernel/names.cmx lib/pp.cmx \ - lib/predicate.cmx kernel/term.cmx lib/util.cmx library/libnames.cmi -library/libobject.cmo: lib/dyn.cmi library/libnames.cmi kernel/names.cmi \ - lib/util.cmi library/libobject.cmi -library/libobject.cmx: lib/dyn.cmx library/libnames.cmx kernel/names.cmx \ - lib/util.cmx library/libobject.cmi -library/library.cmo: library/declaremods.cmi library/lib.cmi \ - library/libnames.cmi library/libobject.cmi library/nameops.cmi \ - kernel/names.cmi library/nametab.cmi lib/options.cmi lib/pp.cmi \ - kernel/safe_typing.cmi library/summary.cmi lib/system.cmi lib/util.cmi \ +library/goptions.cmo: lib/util.cmi kernel/term.cmi library/summary.cmi \ + lib/pp.cmi library/nametab.cmi kernel/names.cmi library/libobject.cmi \ + library/libnames.cmi library/lib.cmi library/goptions.cmi +library/goptions.cmx: lib/util.cmx kernel/term.cmx library/summary.cmx \ + lib/pp.cmx library/nametab.cmx kernel/names.cmx library/libobject.cmx \ + library/libnames.cmx library/lib.cmx library/goptions.cmi +library/impargs.cmo: lib/util.cmi interp/topconstr.cmi pretyping/termops.cmi \ + kernel/term.cmi library/summary.cmi kernel/reduction.cmi lib/pp.cmi \ + lib/options.cmi library/nametab.cmi kernel/names.cmi \ + library/libobject.cmi library/libnames.cmi library/lib.cmi \ + kernel/inductive.cmi library/global.cmi kernel/environ.cmi \ + kernel/declarations.cmi library/impargs.cmi +library/impargs.cmx: lib/util.cmx interp/topconstr.cmx pretyping/termops.cmx \ + kernel/term.cmx library/summary.cmx kernel/reduction.cmx lib/pp.cmx \ + lib/options.cmx library/nametab.cmx kernel/names.cmx \ + library/libobject.cmx library/libnames.cmx library/lib.cmx \ + kernel/inductive.cmx library/global.cmx kernel/environ.cmx \ + kernel/declarations.cmx library/impargs.cmi +library/lib.cmo: lib/util.cmi library/summary.cmi lib/pp.cmi lib/options.cmi \ + library/nametab.cmi kernel/names.cmi library/nameops.cmi \ + library/libobject.cmi library/libnames.cmi library/lib.cmi +library/lib.cmx: lib/util.cmx library/summary.cmx lib/pp.cmx lib/options.cmx \ + library/nametab.cmx kernel/names.cmx library/nameops.cmx \ + library/libobject.cmx library/libnames.cmx library/lib.cmi +library/libnames.cmo: lib/util.cmi kernel/term.cmi lib/predicate.cmi \ + lib/pp.cmi kernel/names.cmi library/nameops.cmi library/libnames.cmi +library/libnames.cmx: lib/util.cmx kernel/term.cmx lib/predicate.cmx \ + lib/pp.cmx kernel/names.cmx library/nameops.cmx library/libnames.cmi +library/libobject.cmo: lib/util.cmi kernel/names.cmi library/libnames.cmi \ + lib/dyn.cmi library/libobject.cmi +library/libobject.cmx: lib/util.cmx kernel/names.cmx library/libnames.cmx \ + lib/dyn.cmx library/libobject.cmi +library/library.cmo: lib/util.cmi lib/system.cmi library/summary.cmi \ + kernel/safe_typing.cmi lib/pp.cmi lib/options.cmi library/nametab.cmi \ + kernel/names.cmi library/nameops.cmi library/libobject.cmi \ + library/libnames.cmi library/lib.cmi library/declaremods.cmi \ library/library.cmi -library/library.cmx: library/declaremods.cmx library/lib.cmx \ - library/libnames.cmx library/libobject.cmx library/nameops.cmx \ - kernel/names.cmx library/nametab.cmx lib/options.cmx lib/pp.cmx \ - kernel/safe_typing.cmx library/summary.cmx lib/system.cmx lib/util.cmx \ +library/library.cmx: lib/util.cmx lib/system.cmx library/summary.cmx \ + kernel/safe_typing.cmx lib/pp.cmx lib/options.cmx library/nametab.cmx \ + kernel/names.cmx library/nameops.cmx library/libobject.cmx \ + library/libnames.cmx library/lib.cmx library/declaremods.cmx \ library/library.cmi -library/nameops.cmo: kernel/names.cmi lib/pp.cmi lib/util.cmi \ +library/nameops.cmo: lib/util.cmi lib/pp.cmi kernel/names.cmi \ library/nameops.cmi -library/nameops.cmx: kernel/names.cmx lib/pp.cmx lib/util.cmx \ +library/nameops.cmx: lib/util.cmx lib/pp.cmx kernel/names.cmx \ library/nameops.cmi -library/nametab.cmo: kernel/declarations.cmi library/libnames.cmi \ - library/nameops.cmi kernel/names.cmi lib/pp.cmi library/summary.cmi \ - lib/util.cmi library/nametab.cmi -library/nametab.cmx: kernel/declarations.cmx library/libnames.cmx \ - library/nameops.cmx kernel/names.cmx lib/pp.cmx library/summary.cmx \ - lib/util.cmx library/nametab.cmi -library/states.cmo: library/lib.cmi library/library.cmi library/summary.cmi \ - lib/system.cmi library/states.cmi -library/states.cmx: library/lib.cmx library/library.cmx library/summary.cmx \ - lib/system.cmx library/states.cmi -library/summary.cmo: lib/dyn.cmi lib/pp.cmi lib/util.cmi library/summary.cmi -library/summary.cmx: lib/dyn.cmx lib/pp.cmx lib/util.cmx library/summary.cmi -lib/rtree.cmo: lib/pp.cmi lib/util.cmi lib/rtree.cmi -lib/rtree.cmx: lib/pp.cmx lib/util.cmx lib/rtree.cmi -lib/stamps.cmo: lib/stamps.cmi -lib/stamps.cmx: lib/stamps.cmi -lib/system.cmo: config/coq_config.cmi lib/pp.cmi lib/util.cmi lib/system.cmi -lib/system.cmx: config/coq_config.cmx lib/pp.cmx lib/util.cmx lib/system.cmi -lib/tlm.cmo: lib/gmap.cmi lib/gset.cmi lib/tlm.cmi -lib/tlm.cmx: lib/gmap.cmx lib/gset.cmx lib/tlm.cmi -lib/util.cmo: lib/compat.cmo lib/pp.cmi lib/util.cmi -lib/util.cmx: lib/compat.cmx lib/pp.cmx lib/util.cmi -parsing/argextend.cmo: parsing/ast.cmi interp/genarg.cmi parsing/pcoq.cmi \ - parsing/q_coqast.cmo parsing/q_util.cmi lib/util.cmi \ - toplevel/vernacexpr.cmo -parsing/argextend.cmx: parsing/ast.cmx interp/genarg.cmx parsing/pcoq.cmx \ - parsing/q_coqast.cmx parsing/q_util.cmx lib/util.cmx \ - toplevel/vernacexpr.cmx -parsing/ast.cmo: parsing/coqast.cmi lib/dyn.cmi interp/genarg.cmi \ - library/libnames.cmi kernel/names.cmi lib/pp.cmi interp/topconstr.cmi \ - lib/util.cmi parsing/ast.cmi -parsing/ast.cmx: parsing/coqast.cmx lib/dyn.cmx interp/genarg.cmx \ - library/libnames.cmx kernel/names.cmx lib/pp.cmx interp/topconstr.cmx \ - lib/util.cmx parsing/ast.cmi -parsing/coqast.cmo: lib/dyn.cmi lib/hashcons.cmi library/libnames.cmi \ - kernel/names.cmi lib/util.cmi parsing/coqast.cmi -parsing/coqast.cmx: lib/dyn.cmx lib/hashcons.cmx library/libnames.cmx \ - kernel/names.cmx lib/util.cmx parsing/coqast.cmi -parsing/egrammar.cmo: parsing/ast.cmi lib/bignat.cmi parsing/extend.cmi \ - interp/genarg.cmi parsing/lexer.cmi library/libnames.cmi \ - library/nameops.cmi kernel/names.cmi lib/options.cmi parsing/pcoq.cmi \ - lib/pp.cmi library/summary.cmi proofs/tacexpr.cmo interp/topconstr.cmi \ - lib/util.cmi toplevel/vernacexpr.cmo parsing/egrammar.cmi -parsing/egrammar.cmx: parsing/ast.cmx lib/bignat.cmx parsing/extend.cmx \ - interp/genarg.cmx parsing/lexer.cmx library/libnames.cmx \ - library/nameops.cmx kernel/names.cmx lib/options.cmx parsing/pcoq.cmx \ - lib/pp.cmx library/summary.cmx proofs/tacexpr.cmx interp/topconstr.cmx \ - lib/util.cmx toplevel/vernacexpr.cmx parsing/egrammar.cmi -parsing/esyntax.cmo: parsing/ast.cmi parsing/coqast.cmi parsing/extend.cmi \ - lib/gmap.cmi lib/gmapl.cmi library/libnames.cmi kernel/names.cmi \ - library/nametab.cmi lib/options.cmi lib/pp.cmi interp/ppextend.cmi \ - interp/symbols.cmi interp/topconstr.cmi lib/util.cmi parsing/esyntax.cmi -parsing/esyntax.cmx: parsing/ast.cmx parsing/coqast.cmx parsing/extend.cmx \ - lib/gmap.cmx lib/gmapl.cmx library/libnames.cmx kernel/names.cmx \ - library/nametab.cmx lib/options.cmx lib/pp.cmx interp/ppextend.cmx \ - interp/symbols.cmx interp/topconstr.cmx lib/util.cmx parsing/esyntax.cmi -parsing/extend.cmo: parsing/ast.cmi parsing/coqast.cmi interp/genarg.cmi \ - parsing/lexer.cmi library/libnames.cmi kernel/names.cmi lib/options.cmi \ - lib/pp.cmi interp/ppextend.cmi pretyping/rawterm.cmi interp/topconstr.cmi \ - lib/util.cmi parsing/extend.cmi -parsing/extend.cmx: parsing/ast.cmx parsing/coqast.cmx interp/genarg.cmx \ - parsing/lexer.cmx library/libnames.cmx kernel/names.cmx lib/options.cmx \ - lib/pp.cmx interp/ppextend.cmx pretyping/rawterm.cmx interp/topconstr.cmx \ - lib/util.cmx parsing/extend.cmi -parsing/g_basevernac.cmo: parsing/ast.cmi interp/constrintern.cmi \ - parsing/coqast.cmi pretyping/evd.cmi parsing/extend.cmi \ - library/global.cmi library/goptions.cmi parsing/lexer.cmi \ - toplevel/metasyntax.cmi kernel/names.cmi lib/options.cmi parsing/pcoq.cmi \ - lib/pp.cmi interp/ppextend.cmi parsing/termast.cmi lib/util.cmi \ - toplevel/vernacexpr.cmo -parsing/g_basevernac.cmx: parsing/ast.cmx interp/constrintern.cmx \ - parsing/coqast.cmx pretyping/evd.cmx parsing/extend.cmx \ - library/global.cmx library/goptions.cmx parsing/lexer.cmx \ - toplevel/metasyntax.cmx kernel/names.cmx lib/options.cmx parsing/pcoq.cmx \ - lib/pp.cmx interp/ppextend.cmx parsing/termast.cmx lib/util.cmx \ - toplevel/vernacexpr.cmx -parsing/g_cases.cmo: parsing/g_constr.cmo library/libnames.cmi \ - lib/options.cmi parsing/pcoq.cmi lib/pp.cmi kernel/term.cmi \ - interp/topconstr.cmi lib/util.cmi -parsing/g_cases.cmx: parsing/g_constr.cmx library/libnames.cmx \ - lib/options.cmx parsing/pcoq.cmx lib/pp.cmx kernel/term.cmx \ - interp/topconstr.cmx lib/util.cmx -parsing/g_constr.cmo: parsing/lexer.cmi library/libnames.cmi kernel/names.cmi \ - lib/options.cmi pretyping/pattern.cmi parsing/pcoq.cmi lib/pp.cmi \ - pretyping/rawterm.cmi kernel/term.cmi interp/topconstr.cmi lib/util.cmi -parsing/g_constr.cmx: parsing/lexer.cmx library/libnames.cmx kernel/names.cmx \ - lib/options.cmx pretyping/pattern.cmx parsing/pcoq.cmx lib/pp.cmx \ - pretyping/rawterm.cmx kernel/term.cmx interp/topconstr.cmx lib/util.cmx -parsing/g_constrnew.cmo: lib/bignat.cmi parsing/coqast.cmi parsing/lexer.cmi \ - library/libnames.cmi kernel/names.cmi lib/options.cmi parsing/pcoq.cmi \ - lib/pp.cmi pretyping/rawterm.cmi kernel/term.cmi interp/topconstr.cmi \ - lib/util.cmi -parsing/g_constrnew.cmx: lib/bignat.cmx parsing/coqast.cmx parsing/lexer.cmx \ - library/libnames.cmx kernel/names.cmx lib/options.cmx parsing/pcoq.cmx \ - lib/pp.cmx pretyping/rawterm.cmx kernel/term.cmx interp/topconstr.cmx \ - lib/util.cmx -parsing/g_ltac.cmo: parsing/ast.cmi interp/genarg.cmi library/libnames.cmi \ - kernel/names.cmi lib/options.cmi pretyping/pattern.cmi parsing/pcoq.cmi \ - lib/pp.cmi pretyping/rawterm.cmi proofs/tacexpr.cmo interp/topconstr.cmi \ - lib/util.cmi toplevel/vernacexpr.cmo -parsing/g_ltac.cmx: parsing/ast.cmx interp/genarg.cmx library/libnames.cmx \ - kernel/names.cmx lib/options.cmx pretyping/pattern.cmx parsing/pcoq.cmx \ - lib/pp.cmx pretyping/rawterm.cmx proofs/tacexpr.cmx interp/topconstr.cmx \ - lib/util.cmx toplevel/vernacexpr.cmx -parsing/g_ltacnew.cmo: parsing/ast.cmi interp/genarg.cmi kernel/names.cmi \ - lib/options.cmi parsing/pcoq.cmi lib/pp.cmi pretyping/rawterm.cmi \ - proofs/tacexpr.cmo interp/topconstr.cmi lib/util.cmi \ - toplevel/vernacexpr.cmo -parsing/g_ltacnew.cmx: parsing/ast.cmx interp/genarg.cmx kernel/names.cmx \ - lib/options.cmx parsing/pcoq.cmx lib/pp.cmx pretyping/rawterm.cmx \ - proofs/tacexpr.cmx interp/topconstr.cmx lib/util.cmx \ - toplevel/vernacexpr.cmx -parsing/g_minicoq.cmo: kernel/environ.cmi parsing/lexer.cmi kernel/names.cmi \ - lib/pp.cmi kernel/term.cmi kernel/univ.cmi lib/util.cmi \ +library/nametab.cmo: lib/util.cmi library/summary.cmi lib/pp.cmi \ + kernel/names.cmi library/nameops.cmi library/libnames.cmi \ + kernel/declarations.cmi library/nametab.cmi +library/nametab.cmx: lib/util.cmx library/summary.cmx lib/pp.cmx \ + kernel/names.cmx library/nameops.cmx library/libnames.cmx \ + kernel/declarations.cmx library/nametab.cmi +library/states.cmo: lib/system.cmi library/summary.cmi library/library.cmi \ + library/lib.cmi library/states.cmi +library/states.cmx: lib/system.cmx library/summary.cmx library/library.cmx \ + library/lib.cmx library/states.cmi +library/summary.cmo: lib/util.cmi lib/pp.cmi lib/dyn.cmi library/summary.cmi +library/summary.cmx: lib/util.cmx lib/pp.cmx lib/dyn.cmx library/summary.cmi +parsing/argextend.cmo: toplevel/vernacexpr.cmo lib/util.cmi \ + parsing/q_util.cmi parsing/q_coqast.cmo parsing/pcoq.cmi \ + interp/genarg.cmi parsing/ast.cmi +parsing/argextend.cmx: toplevel/vernacexpr.cmx lib/util.cmx \ + parsing/q_util.cmx parsing/q_coqast.cmx parsing/pcoq.cmx \ + interp/genarg.cmx parsing/ast.cmx +parsing/ast.cmo: lib/util.cmi interp/topconstr.cmi lib/pp.cmi \ + kernel/names.cmi library/libnames.cmi interp/genarg.cmi lib/dyn.cmi \ + parsing/coqast.cmi parsing/ast.cmi +parsing/ast.cmx: lib/util.cmx interp/topconstr.cmx lib/pp.cmx \ + kernel/names.cmx library/libnames.cmx interp/genarg.cmx lib/dyn.cmx \ + parsing/coqast.cmx parsing/ast.cmi +parsing/coqast.cmo: lib/util.cmi kernel/names.cmi library/libnames.cmi \ + lib/hashcons.cmi lib/dyn.cmi parsing/coqast.cmi +parsing/coqast.cmx: lib/util.cmx kernel/names.cmx library/libnames.cmx \ + lib/hashcons.cmx lib/dyn.cmx parsing/coqast.cmi +parsing/egrammar.cmo: toplevel/vernacexpr.cmo lib/util.cmi \ + interp/topconstr.cmi proofs/tacexpr.cmo library/summary.cmi \ + interp/ppextend.cmi lib/pp.cmi parsing/pcoq.cmi lib/options.cmi \ + kernel/names.cmi library/nameops.cmi library/libnames.cmi \ + parsing/lexer.cmi interp/genarg.cmi parsing/extend.cmi lib/bignat.cmi \ + parsing/ast.cmi parsing/egrammar.cmi +parsing/egrammar.cmx: toplevel/vernacexpr.cmx lib/util.cmx \ + interp/topconstr.cmx proofs/tacexpr.cmx library/summary.cmx \ + interp/ppextend.cmx lib/pp.cmx parsing/pcoq.cmx lib/options.cmx \ + kernel/names.cmx library/nameops.cmx library/libnames.cmx \ + parsing/lexer.cmx interp/genarg.cmx parsing/extend.cmx lib/bignat.cmx \ + parsing/ast.cmx parsing/egrammar.cmi +parsing/esyntax.cmo: lib/util.cmi interp/topconstr.cmi interp/symbols.cmi \ + interp/ppextend.cmi lib/pp.cmi lib/options.cmi library/nametab.cmi \ + kernel/names.cmi library/libnames.cmi lib/gmapl.cmi lib/gmap.cmi \ + parsing/extend.cmi parsing/coqast.cmi parsing/ast.cmi parsing/esyntax.cmi +parsing/esyntax.cmx: lib/util.cmx interp/topconstr.cmx interp/symbols.cmx \ + interp/ppextend.cmx lib/pp.cmx lib/options.cmx library/nametab.cmx \ + kernel/names.cmx library/libnames.cmx lib/gmapl.cmx lib/gmap.cmx \ + parsing/extend.cmx parsing/coqast.cmx parsing/ast.cmx parsing/esyntax.cmi +parsing/extend.cmo: lib/util.cmi interp/topconstr.cmi pretyping/rawterm.cmi \ + interp/ppextend.cmi lib/pp.cmi lib/options.cmi kernel/names.cmi \ + library/libnames.cmi parsing/lexer.cmi interp/genarg.cmi \ + parsing/coqast.cmi parsing/ast.cmi parsing/extend.cmi +parsing/extend.cmx: lib/util.cmx interp/topconstr.cmx pretyping/rawterm.cmx \ + interp/ppextend.cmx lib/pp.cmx lib/options.cmx kernel/names.cmx \ + library/libnames.cmx parsing/lexer.cmx interp/genarg.cmx \ + parsing/coqast.cmx parsing/ast.cmx parsing/extend.cmi +parsing/g_basevernac.cmo: toplevel/vernacexpr.cmo lib/util.cmi \ + parsing/termast.cmi interp/ppextend.cmi lib/pp.cmi parsing/pcoq.cmi \ + lib/options.cmi kernel/names.cmi toplevel/metasyntax.cmi \ + parsing/lexer.cmi library/goptions.cmi library/global.cmi \ + parsing/extend.cmi pretyping/evd.cmi parsing/coqast.cmi \ + interp/constrintern.cmi parsing/ast.cmi +parsing/g_basevernac.cmx: toplevel/vernacexpr.cmx lib/util.cmx \ + parsing/termast.cmx interp/ppextend.cmx lib/pp.cmx parsing/pcoq.cmx \ + lib/options.cmx kernel/names.cmx toplevel/metasyntax.cmx \ + parsing/lexer.cmx library/goptions.cmx library/global.cmx \ + parsing/extend.cmx pretyping/evd.cmx parsing/coqast.cmx \ + interp/constrintern.cmx parsing/ast.cmx +parsing/g_cases.cmo: lib/util.cmi interp/topconstr.cmi kernel/term.cmi \ + lib/pp.cmi parsing/pcoq.cmi lib/options.cmi library/libnames.cmi \ + parsing/g_constr.cmo +parsing/g_cases.cmx: lib/util.cmx interp/topconstr.cmx kernel/term.cmx \ + lib/pp.cmx parsing/pcoq.cmx lib/options.cmx library/libnames.cmx \ + parsing/g_constr.cmx +parsing/g_constr.cmo: lib/util.cmi interp/topconstr.cmi kernel/term.cmi \ + pretyping/rawterm.cmi lib/pp.cmi parsing/pcoq.cmi pretyping/pattern.cmi \ + lib/options.cmi kernel/names.cmi library/libnames.cmi parsing/lexer.cmi +parsing/g_constr.cmx: lib/util.cmx interp/topconstr.cmx kernel/term.cmx \ + pretyping/rawterm.cmx lib/pp.cmx parsing/pcoq.cmx pretyping/pattern.cmx \ + lib/options.cmx kernel/names.cmx library/libnames.cmx parsing/lexer.cmx +parsing/g_constrnew.cmo: lib/util.cmi interp/topconstr.cmi kernel/term.cmi \ + pretyping/rawterm.cmi lib/pp.cmi parsing/pcoq.cmi lib/options.cmi \ + kernel/names.cmi library/libnames.cmi parsing/lexer.cmi \ + parsing/coqast.cmi lib/bignat.cmi +parsing/g_constrnew.cmx: lib/util.cmx interp/topconstr.cmx kernel/term.cmx \ + pretyping/rawterm.cmx lib/pp.cmx parsing/pcoq.cmx lib/options.cmx \ + kernel/names.cmx library/libnames.cmx parsing/lexer.cmx \ + parsing/coqast.cmx lib/bignat.cmx +parsing/g_ltac.cmo: toplevel/vernacexpr.cmo lib/util.cmi interp/topconstr.cmi \ + proofs/tacexpr.cmo pretyping/rawterm.cmi lib/pp.cmi parsing/pcoq.cmi \ + pretyping/pattern.cmi lib/options.cmi kernel/names.cmi \ + library/libnames.cmi interp/genarg.cmi parsing/ast.cmi +parsing/g_ltac.cmx: toplevel/vernacexpr.cmx lib/util.cmx interp/topconstr.cmx \ + proofs/tacexpr.cmx pretyping/rawterm.cmx lib/pp.cmx parsing/pcoq.cmx \ + pretyping/pattern.cmx lib/options.cmx kernel/names.cmx \ + library/libnames.cmx interp/genarg.cmx parsing/ast.cmx +parsing/g_ltacnew.cmo: toplevel/vernacexpr.cmo lib/util.cmi \ + interp/topconstr.cmi proofs/tacexpr.cmo pretyping/rawterm.cmi lib/pp.cmi \ + parsing/pcoq.cmi lib/options.cmi kernel/names.cmi interp/genarg.cmi \ + parsing/ast.cmi +parsing/g_ltacnew.cmx: toplevel/vernacexpr.cmx lib/util.cmx \ + interp/topconstr.cmx proofs/tacexpr.cmx pretyping/rawterm.cmx lib/pp.cmx \ + parsing/pcoq.cmx lib/options.cmx kernel/names.cmx interp/genarg.cmx \ + parsing/ast.cmx +parsing/g_minicoq.cmo: lib/util.cmi kernel/univ.cmi kernel/term.cmi \ + lib/pp.cmi kernel/names.cmi parsing/lexer.cmi kernel/environ.cmi \ parsing/g_minicoq.cmi -parsing/g_minicoq.cmx: kernel/environ.cmx parsing/lexer.cmx kernel/names.cmx \ - lib/pp.cmx kernel/term.cmx kernel/univ.cmx lib/util.cmx \ +parsing/g_minicoq.cmx: lib/util.cmx kernel/univ.cmx kernel/term.cmx \ + lib/pp.cmx kernel/names.cmx parsing/lexer.cmx kernel/environ.cmx \ parsing/g_minicoq.cmi -parsing/g_module.cmo: parsing/ast.cmi lib/options.cmi parsing/pcoq.cmi \ - lib/pp.cmi interp/topconstr.cmi lib/util.cmi -parsing/g_module.cmx: parsing/ast.cmx lib/options.cmx parsing/pcoq.cmx \ - lib/pp.cmx interp/topconstr.cmx lib/util.cmx -parsing/g_natsyntax.cmo: parsing/ast.cmi lib/bignat.cmi parsing/coqast.cmi \ - interp/coqlib.cmi parsing/esyntax.cmi parsing/extend.cmi \ - library/libnames.cmi kernel/names.cmi lib/options.cmi parsing/pcoq.cmi \ - lib/pp.cmi pretyping/rawterm.cmi interp/symbols.cmi parsing/termast.cmi \ - lib/util.cmi parsing/g_natsyntax.cmi -parsing/g_natsyntax.cmx: parsing/ast.cmx lib/bignat.cmx parsing/coqast.cmx \ - interp/coqlib.cmx parsing/esyntax.cmx parsing/extend.cmx \ - library/libnames.cmx kernel/names.cmx lib/options.cmx parsing/pcoq.cmx \ - lib/pp.cmx pretyping/rawterm.cmx interp/symbols.cmx parsing/termast.cmx \ - lib/util.cmx parsing/g_natsyntax.cmi -parsing/g_prim.cmo: lib/bignat.cmi parsing/coqast.cmi library/libnames.cmi \ - kernel/names.cmi library/nametab.cmi parsing/pcoq.cmi \ - interp/topconstr.cmi -parsing/g_prim.cmx: lib/bignat.cmx parsing/coqast.cmx library/libnames.cmx \ - kernel/names.cmx library/nametab.cmx parsing/pcoq.cmx \ - interp/topconstr.cmx -parsing/g_primnew.cmo: lib/bignat.cmi parsing/coqast.cmi parsing/lexer.cmi \ - library/libnames.cmi kernel/names.cmi library/nametab.cmi lib/options.cmi \ - parsing/pcoq.cmi lib/pp.cmi interp/topconstr.cmi lib/util.cmi -parsing/g_primnew.cmx: lib/bignat.cmx parsing/coqast.cmx parsing/lexer.cmx \ - library/libnames.cmx kernel/names.cmx library/nametab.cmx lib/options.cmx \ - parsing/pcoq.cmx lib/pp.cmx interp/topconstr.cmx lib/util.cmx -parsing/g_proofs.cmo: interp/genarg.cmi lib/options.cmi parsing/pcoq.cmi \ - lib/pp.cmi proofs/tacexpr.cmo interp/topconstr.cmi lib/util.cmi \ - toplevel/vernacexpr.cmo -parsing/g_proofs.cmx: interp/genarg.cmx lib/options.cmx parsing/pcoq.cmx \ - lib/pp.cmx proofs/tacexpr.cmx interp/topconstr.cmx lib/util.cmx \ - toplevel/vernacexpr.cmx -parsing/g_proofsnew.cmo: parsing/g_vernacnew.cmo interp/genarg.cmi \ - lib/options.cmi parsing/pcoq.cmi lib/pp.cmi proofs/tacexpr.cmo \ - interp/topconstr.cmi lib/util.cmi toplevel/vernacexpr.cmo -parsing/g_proofsnew.cmx: parsing/g_vernacnew.cmx interp/genarg.cmx \ - lib/options.cmx parsing/pcoq.cmx lib/pp.cmx proofs/tacexpr.cmx \ - interp/topconstr.cmx lib/util.cmx toplevel/vernacexpr.cmx -parsing/g_rsyntax.cmo: parsing/ast.cmi lib/bignat.cmi parsing/coqast.cmi \ - parsing/esyntax.cmi parsing/extend.cmi library/libnames.cmi \ - kernel/names.cmi library/nametab.cmi lib/options.cmi parsing/pcoq.cmi \ - lib/pp.cmi pretyping/rawterm.cmi interp/symbols.cmi parsing/termast.cmi \ - interp/topconstr.cmi lib/util.cmi -parsing/g_rsyntax.cmx: parsing/ast.cmx lib/bignat.cmx parsing/coqast.cmx \ - parsing/esyntax.cmx parsing/extend.cmx library/libnames.cmx \ - kernel/names.cmx library/nametab.cmx lib/options.cmx parsing/pcoq.cmx \ - lib/pp.cmx pretyping/rawterm.cmx interp/symbols.cmx parsing/termast.cmx \ - interp/topconstr.cmx lib/util.cmx -parsing/g_tactic.cmo: parsing/ast.cmi interp/genarg.cmi parsing/lexer.cmi \ - library/libnames.cmi kernel/names.cmi lib/options.cmi \ - pretyping/pattern.cmi parsing/pcoq.cmi lib/pp.cmi pretyping/rawterm.cmi \ - proofs/tacexpr.cmo interp/topconstr.cmi lib/util.cmi -parsing/g_tactic.cmx: parsing/ast.cmx interp/genarg.cmx parsing/lexer.cmx \ - library/libnames.cmx kernel/names.cmx lib/options.cmx \ - pretyping/pattern.cmx parsing/pcoq.cmx lib/pp.cmx pretyping/rawterm.cmx \ - proofs/tacexpr.cmx interp/topconstr.cmx lib/util.cmx -parsing/g_tacticnew.cmo: parsing/ast.cmi interp/genarg.cmi parsing/lexer.cmi \ - kernel/names.cmi lib/options.cmi parsing/pcoq.cmi lib/pp.cmi \ - pretyping/rawterm.cmi proofs/tacexpr.cmo interp/topconstr.cmi \ - lib/util.cmi -parsing/g_tacticnew.cmx: parsing/ast.cmx interp/genarg.cmx parsing/lexer.cmx \ - kernel/names.cmx lib/options.cmx parsing/pcoq.cmx lib/pp.cmx \ - pretyping/rawterm.cmx proofs/tacexpr.cmx interp/topconstr.cmx \ - lib/util.cmx -parsing/g_vernac.cmo: parsing/ast.cmi toplevel/class.cmi \ - library/decl_kinds.cmo parsing/g_basevernac.cmo parsing/g_proofs.cmo \ - interp/genarg.cmi library/goptions.cmi kernel/names.cmi lib/options.cmi \ - parsing/pcoq.cmi lib/pp.cmi toplevel/recordobj.cmi interp/topconstr.cmi \ - lib/util.cmi toplevel/vernacexpr.cmo -parsing/g_vernac.cmx: parsing/ast.cmx toplevel/class.cmx \ - library/decl_kinds.cmx parsing/g_basevernac.cmx parsing/g_proofs.cmx \ - interp/genarg.cmx library/goptions.cmx kernel/names.cmx lib/options.cmx \ - parsing/pcoq.cmx lib/pp.cmx toplevel/recordobj.cmx interp/topconstr.cmx \ - lib/util.cmx toplevel/vernacexpr.cmx -parsing/g_vernacnew.cmo: parsing/ast.cmi toplevel/class.cmi \ - parsing/coqast.cmi library/decl_kinds.cmo parsing/egrammar.cmi \ - parsing/extend.cmi parsing/g_constrnew.cmo interp/genarg.cmi \ - library/goptions.cmi parsing/lexer.cmi library/nameops.cmi \ - kernel/names.cmi lib/options.cmi parsing/pcoq.cmi lib/pp.cmi \ - interp/ppextend.cmi toplevel/recordobj.cmi interp/topconstr.cmi \ - lib/util.cmi toplevel/vernacexpr.cmo -parsing/g_vernacnew.cmx: parsing/ast.cmx toplevel/class.cmx \ - parsing/coqast.cmx library/decl_kinds.cmx parsing/egrammar.cmx \ - parsing/extend.cmx parsing/g_constrnew.cmx interp/genarg.cmx \ - library/goptions.cmx parsing/lexer.cmx library/nameops.cmx \ - kernel/names.cmx lib/options.cmx parsing/pcoq.cmx lib/pp.cmx \ - interp/ppextend.cmx toplevel/recordobj.cmx interp/topconstr.cmx \ - lib/util.cmx toplevel/vernacexpr.cmx -parsing/g_zsyntax.cmo: parsing/ast.cmi lib/bignat.cmi parsing/coqast.cmi \ - interp/coqlib.cmi parsing/esyntax.cmi parsing/extend.cmi \ - library/libnames.cmi kernel/names.cmi lib/options.cmi parsing/pcoq.cmi \ - lib/pp.cmi pretyping/rawterm.cmi interp/symbols.cmi parsing/termast.cmi \ - interp/topconstr.cmi lib/util.cmi parsing/g_zsyntax.cmi -parsing/g_zsyntax.cmx: parsing/ast.cmx lib/bignat.cmx parsing/coqast.cmx \ - interp/coqlib.cmx parsing/esyntax.cmx parsing/extend.cmx \ - library/libnames.cmx kernel/names.cmx lib/options.cmx parsing/pcoq.cmx \ - lib/pp.cmx pretyping/rawterm.cmx interp/symbols.cmx parsing/termast.cmx \ - interp/topconstr.cmx lib/util.cmx parsing/g_zsyntax.cmi -parsing/lexer.cmo: lib/options.cmi lib/pp.cmi lib/util.cmi parsing/lexer.cmi -parsing/lexer.cmx: lib/options.cmx lib/pp.cmx lib/util.cmx parsing/lexer.cmi -parsing/pcoq.cmo: parsing/ast.cmi parsing/coqast.cmi library/decl_kinds.cmo \ - parsing/extend.cmi interp/genarg.cmi parsing/lexer.cmi \ - library/libnames.cmi kernel/names.cmi lib/options.cmi lib/pp.cmi \ - interp/ppextend.cmi pretyping/rawterm.cmi proofs/tacexpr.cmo \ - interp/topconstr.cmi lib/util.cmi parsing/pcoq.cmi -parsing/pcoq.cmx: parsing/ast.cmx parsing/coqast.cmx library/decl_kinds.cmx \ - parsing/extend.cmx interp/genarg.cmx parsing/lexer.cmx \ - library/libnames.cmx kernel/names.cmx lib/options.cmx lib/pp.cmx \ - interp/ppextend.cmx pretyping/rawterm.cmx proofs/tacexpr.cmx \ - interp/topconstr.cmx lib/util.cmx parsing/pcoq.cmi -parsing/ppconstr.cmo: parsing/ast.cmi lib/bignat.cmi interp/constrextern.cmi \ - parsing/coqast.cmi pretyping/evd.cmi interp/genarg.cmi \ - library/libnames.cmi library/nameops.cmi kernel/names.cmi \ - library/nametab.cmi pretyping/pattern.cmi lib/pp.cmi interp/ppextend.cmi \ - pretyping/rawterm.cmi interp/symbols.cmi kernel/term.cmi \ - interp/topconstr.cmi lib/util.cmi parsing/ppconstr.cmi -parsing/ppconstr.cmx: parsing/ast.cmx lib/bignat.cmx interp/constrextern.cmx \ - parsing/coqast.cmx pretyping/evd.cmx interp/genarg.cmx \ - library/libnames.cmx library/nameops.cmx kernel/names.cmx \ - library/nametab.cmx pretyping/pattern.cmx lib/pp.cmx interp/ppextend.cmx \ - pretyping/rawterm.cmx interp/symbols.cmx kernel/term.cmx \ - interp/topconstr.cmx lib/util.cmx parsing/ppconstr.cmi -parsing/pptactic.cmo: kernel/closure.cmi interp/constrextern.cmi lib/dyn.cmi \ - parsing/extend.cmi interp/genarg.cmi library/libnames.cmi \ - library/nameops.cmi kernel/names.cmi library/nametab.cmi lib/options.cmi \ - pretyping/pattern.cmi lib/pp.cmi parsing/ppconstr.cmi \ - translate/ppconstrnew.cmi parsing/printer.cmi pretyping/rawterm.cmi \ - proofs/tacexpr.cmo kernel/term.cmi interp/topconstr.cmi lib/util.cmi \ - parsing/pptactic.cmi -parsing/pptactic.cmx: kernel/closure.cmx interp/constrextern.cmx lib/dyn.cmx \ - parsing/extend.cmx interp/genarg.cmx library/libnames.cmx \ - library/nameops.cmx kernel/names.cmx library/nametab.cmx lib/options.cmx \ - pretyping/pattern.cmx lib/pp.cmx parsing/ppconstr.cmx \ - translate/ppconstrnew.cmx parsing/printer.cmx pretyping/rawterm.cmx \ - proofs/tacexpr.cmx kernel/term.cmx interp/topconstr.cmx lib/util.cmx \ - parsing/pptactic.cmi -parsing/prettyp.cmo: pretyping/classops.cmi interp/constrextern.cmi \ - kernel/declarations.cmi library/declare.cmi kernel/environ.cmi \ - pretyping/evd.cmi library/global.cmi library/impargs.cmi \ - kernel/inductive.cmi pretyping/inductiveops.cmi pretyping/instantiate.cmi \ - library/lib.cmi library/libnames.cmi library/libobject.cmi \ - library/nameops.cmi kernel/names.cmi library/nametab.cmi lib/options.cmi \ - lib/pp.cmi parsing/printer.cmi parsing/printmod.cmi kernel/reduction.cmi \ - pretyping/reductionops.cmi kernel/safe_typing.cmi kernel/sign.cmi \ - interp/symbols.cmi interp/syntax_def.cmi kernel/term.cmi \ - pretyping/termops.cmi lib/util.cmi parsing/prettyp.cmi -parsing/prettyp.cmx: pretyping/classops.cmx interp/constrextern.cmx \ - kernel/declarations.cmx library/declare.cmx kernel/environ.cmx \ - pretyping/evd.cmx library/global.cmx library/impargs.cmx \ - kernel/inductive.cmx pretyping/inductiveops.cmx pretyping/instantiate.cmx \ - library/lib.cmx library/libnames.cmx library/libobject.cmx \ - library/nameops.cmx kernel/names.cmx library/nametab.cmx lib/options.cmx \ - lib/pp.cmx parsing/printer.cmx parsing/printmod.cmx kernel/reduction.cmx \ - pretyping/reductionops.cmx kernel/safe_typing.cmx kernel/sign.cmx \ - interp/symbols.cmx interp/syntax_def.cmx kernel/term.cmx \ - pretyping/termops.cmx lib/util.cmx parsing/prettyp.cmi -parsing/printer.cmo: parsing/ast.cmi interp/constrextern.cmi \ - parsing/coqast.cmi library/declare.cmi lib/dyn.cmi kernel/environ.cmi \ - parsing/esyntax.cmi parsing/extend.cmi library/global.cmi \ - library/libnames.cmi library/nameops.cmi kernel/names.cmi \ - library/nametab.cmi lib/options.cmi pretyping/pattern.cmi lib/pp.cmi \ - parsing/ppconstr.cmi translate/ppconstrnew.cmi interp/ppextend.cmi \ - kernel/sign.cmi kernel/term.cmi parsing/termast.cmi pretyping/termops.cmi \ - lib/util.cmi parsing/printer.cmi -parsing/printer.cmx: parsing/ast.cmx interp/constrextern.cmx \ - parsing/coqast.cmx library/declare.cmx lib/dyn.cmx kernel/environ.cmx \ - parsing/esyntax.cmx parsing/extend.cmx library/global.cmx \ - library/libnames.cmx library/nameops.cmx kernel/names.cmx \ - library/nametab.cmx lib/options.cmx pretyping/pattern.cmx lib/pp.cmx \ - parsing/ppconstr.cmx translate/ppconstrnew.cmx interp/ppextend.cmx \ - kernel/sign.cmx kernel/term.cmx parsing/termast.cmx pretyping/termops.cmx \ - lib/util.cmx parsing/printer.cmi -parsing/printmod.cmo: kernel/declarations.cmi library/global.cmi \ - library/libnames.cmi library/nameops.cmi kernel/names.cmi \ - library/nametab.cmi lib/pp.cmi lib/util.cmi parsing/printmod.cmi -parsing/printmod.cmx: kernel/declarations.cmx library/global.cmx \ - library/libnames.cmx library/nameops.cmx kernel/names.cmx \ - library/nametab.cmx lib/pp.cmx lib/util.cmx parsing/printmod.cmi -parsing/q_coqast.cmo: parsing/coqast.cmi interp/genarg.cmi \ - library/libnames.cmi kernel/names.cmi parsing/pcoq.cmi parsing/q_util.cmi \ - pretyping/rawterm.cmi proofs/tacexpr.cmo interp/topconstr.cmi \ - lib/util.cmi -parsing/q_coqast.cmx: parsing/coqast.cmx interp/genarg.cmx \ - library/libnames.cmx kernel/names.cmx parsing/pcoq.cmx parsing/q_util.cmx \ - pretyping/rawterm.cmx proofs/tacexpr.cmx interp/topconstr.cmx \ - lib/util.cmx +parsing/g_module.cmo: lib/util.cmi interp/topconstr.cmi lib/pp.cmi \ + parsing/pcoq.cmi lib/options.cmi parsing/ast.cmi +parsing/g_module.cmx: lib/util.cmx interp/topconstr.cmx lib/pp.cmx \ + parsing/pcoq.cmx lib/options.cmx parsing/ast.cmx +parsing/g_natsyntax.cmo: lib/util.cmi parsing/termast.cmi interp/symbols.cmi \ + pretyping/rawterm.cmi lib/pp.cmi parsing/pcoq.cmi lib/options.cmi \ + kernel/names.cmi library/libnames.cmi parsing/extend.cmi \ + parsing/esyntax.cmi interp/coqlib.cmi parsing/coqast.cmi lib/bignat.cmi \ + parsing/ast.cmi parsing/g_natsyntax.cmi +parsing/g_natsyntax.cmx: lib/util.cmx parsing/termast.cmx interp/symbols.cmx \ + pretyping/rawterm.cmx lib/pp.cmx parsing/pcoq.cmx lib/options.cmx \ + kernel/names.cmx library/libnames.cmx parsing/extend.cmx \ + parsing/esyntax.cmx interp/coqlib.cmx parsing/coqast.cmx lib/bignat.cmx \ + parsing/ast.cmx parsing/g_natsyntax.cmi +parsing/g_prim.cmo: interp/topconstr.cmi parsing/pcoq.cmi library/nametab.cmi \ + kernel/names.cmi library/libnames.cmi parsing/coqast.cmi lib/bignat.cmi +parsing/g_prim.cmx: interp/topconstr.cmx parsing/pcoq.cmx library/nametab.cmx \ + kernel/names.cmx library/libnames.cmx parsing/coqast.cmx lib/bignat.cmx +parsing/g_primnew.cmo: lib/util.cmi interp/topconstr.cmi lib/pp.cmi \ + parsing/pcoq.cmi lib/options.cmi library/nametab.cmi kernel/names.cmi \ + library/libnames.cmi parsing/lexer.cmi parsing/coqast.cmi lib/bignat.cmi +parsing/g_primnew.cmx: lib/util.cmx interp/topconstr.cmx lib/pp.cmx \ + parsing/pcoq.cmx lib/options.cmx library/nametab.cmx kernel/names.cmx \ + library/libnames.cmx parsing/lexer.cmx parsing/coqast.cmx lib/bignat.cmx +parsing/g_proofs.cmo: toplevel/vernacexpr.cmo lib/util.cmi \ + interp/topconstr.cmi proofs/tacexpr.cmo lib/pp.cmi parsing/pcoq.cmi \ + lib/options.cmi interp/genarg.cmi +parsing/g_proofs.cmx: toplevel/vernacexpr.cmx lib/util.cmx \ + interp/topconstr.cmx proofs/tacexpr.cmx lib/pp.cmx parsing/pcoq.cmx \ + lib/options.cmx interp/genarg.cmx +parsing/g_proofsnew.cmo: toplevel/vernacexpr.cmo lib/util.cmi \ + interp/topconstr.cmi proofs/tacexpr.cmo lib/pp.cmi parsing/pcoq.cmi \ + lib/options.cmi interp/genarg.cmi parsing/g_vernacnew.cmo +parsing/g_proofsnew.cmx: toplevel/vernacexpr.cmx lib/util.cmx \ + interp/topconstr.cmx proofs/tacexpr.cmx lib/pp.cmx parsing/pcoq.cmx \ + lib/options.cmx interp/genarg.cmx parsing/g_vernacnew.cmx +parsing/g_rsyntax.cmo: lib/util.cmi interp/topconstr.cmi parsing/termast.cmi \ + interp/symbols.cmi pretyping/rawterm.cmi lib/pp.cmi parsing/pcoq.cmi \ + lib/options.cmi library/nametab.cmi kernel/names.cmi library/libnames.cmi \ + parsing/extend.cmi parsing/esyntax.cmi parsing/coqast.cmi lib/bignat.cmi \ + parsing/ast.cmi +parsing/g_rsyntax.cmx: lib/util.cmx interp/topconstr.cmx parsing/termast.cmx \ + interp/symbols.cmx pretyping/rawterm.cmx lib/pp.cmx parsing/pcoq.cmx \ + lib/options.cmx library/nametab.cmx kernel/names.cmx library/libnames.cmx \ + parsing/extend.cmx parsing/esyntax.cmx parsing/coqast.cmx lib/bignat.cmx \ + parsing/ast.cmx +parsing/g_tactic.cmo: lib/util.cmi interp/topconstr.cmi proofs/tacexpr.cmo \ + pretyping/rawterm.cmi lib/pp.cmi parsing/pcoq.cmi pretyping/pattern.cmi \ + lib/options.cmi kernel/names.cmi library/libnames.cmi parsing/lexer.cmi \ + interp/genarg.cmi parsing/ast.cmi +parsing/g_tactic.cmx: lib/util.cmx interp/topconstr.cmx proofs/tacexpr.cmx \ + pretyping/rawterm.cmx lib/pp.cmx parsing/pcoq.cmx pretyping/pattern.cmx \ + lib/options.cmx kernel/names.cmx library/libnames.cmx parsing/lexer.cmx \ + interp/genarg.cmx parsing/ast.cmx +parsing/g_tacticnew.cmo: lib/util.cmi interp/topconstr.cmi proofs/tacexpr.cmo \ + pretyping/rawterm.cmi lib/pp.cmi parsing/pcoq.cmi lib/options.cmi \ + kernel/names.cmi parsing/lexer.cmi interp/genarg.cmi parsing/ast.cmi +parsing/g_tacticnew.cmx: lib/util.cmx interp/topconstr.cmx proofs/tacexpr.cmx \ + pretyping/rawterm.cmx lib/pp.cmx parsing/pcoq.cmx lib/options.cmx \ + kernel/names.cmx parsing/lexer.cmx interp/genarg.cmx parsing/ast.cmx +parsing/g_vernac.cmo: toplevel/vernacexpr.cmo lib/util.cmi \ + interp/topconstr.cmi toplevel/recordobj.cmi lib/pp.cmi parsing/pcoq.cmi \ + lib/options.cmi kernel/names.cmi library/goptions.cmi interp/genarg.cmi \ + parsing/g_proofs.cmo parsing/g_basevernac.cmo library/decl_kinds.cmo \ + toplevel/class.cmi parsing/ast.cmi +parsing/g_vernac.cmx: toplevel/vernacexpr.cmx lib/util.cmx \ + interp/topconstr.cmx toplevel/recordobj.cmx lib/pp.cmx parsing/pcoq.cmx \ + lib/options.cmx kernel/names.cmx library/goptions.cmx interp/genarg.cmx \ + parsing/g_proofs.cmx parsing/g_basevernac.cmx library/decl_kinds.cmx \ + toplevel/class.cmx parsing/ast.cmx +parsing/g_vernacnew.cmo: toplevel/vernacexpr.cmo lib/util.cmi \ + interp/topconstr.cmi toplevel/recordobj.cmi interp/ppextend.cmi \ + lib/pp.cmi parsing/pcoq.cmi lib/options.cmi kernel/names.cmi \ + library/nameops.cmi parsing/lexer.cmi library/goptions.cmi \ + interp/genarg.cmi parsing/g_constrnew.cmo parsing/extend.cmi \ + parsing/egrammar.cmi library/decl_kinds.cmo parsing/coqast.cmi \ + toplevel/class.cmi parsing/ast.cmi +parsing/g_vernacnew.cmx: toplevel/vernacexpr.cmx lib/util.cmx \ + interp/topconstr.cmx toplevel/recordobj.cmx interp/ppextend.cmx \ + lib/pp.cmx parsing/pcoq.cmx lib/options.cmx kernel/names.cmx \ + library/nameops.cmx parsing/lexer.cmx library/goptions.cmx \ + interp/genarg.cmx parsing/g_constrnew.cmx parsing/extend.cmx \ + parsing/egrammar.cmx library/decl_kinds.cmx parsing/coqast.cmx \ + toplevel/class.cmx parsing/ast.cmx +parsing/g_zsyntax.cmo: lib/util.cmi interp/topconstr.cmi parsing/termast.cmi \ + interp/symbols.cmi pretyping/rawterm.cmi lib/pp.cmi parsing/pcoq.cmi \ + lib/options.cmi kernel/names.cmi library/libnames.cmi parsing/extend.cmi \ + parsing/esyntax.cmi interp/coqlib.cmi parsing/coqast.cmi lib/bignat.cmi \ + parsing/ast.cmi parsing/g_zsyntax.cmi +parsing/g_zsyntax.cmx: lib/util.cmx interp/topconstr.cmx parsing/termast.cmx \ + interp/symbols.cmx pretyping/rawterm.cmx lib/pp.cmx parsing/pcoq.cmx \ + lib/options.cmx kernel/names.cmx library/libnames.cmx parsing/extend.cmx \ + parsing/esyntax.cmx interp/coqlib.cmx parsing/coqast.cmx lib/bignat.cmx \ + parsing/ast.cmx parsing/g_zsyntax.cmi +parsing/lexer.cmo: lib/util.cmi lib/pp.cmi lib/options.cmi parsing/lexer.cmi +parsing/lexer.cmx: lib/util.cmx lib/pp.cmx lib/options.cmx parsing/lexer.cmi +parsing/pcoq.cmo: lib/util.cmi interp/topconstr.cmi proofs/tacexpr.cmo \ + pretyping/rawterm.cmi interp/ppextend.cmi lib/pp.cmi lib/options.cmi \ + kernel/names.cmi library/libnames.cmi parsing/lexer.cmi interp/genarg.cmi \ + parsing/extend.cmi library/decl_kinds.cmo parsing/coqast.cmi \ + parsing/ast.cmi parsing/pcoq.cmi +parsing/pcoq.cmx: lib/util.cmx interp/topconstr.cmx proofs/tacexpr.cmx \ + pretyping/rawterm.cmx interp/ppextend.cmx lib/pp.cmx lib/options.cmx \ + kernel/names.cmx library/libnames.cmx parsing/lexer.cmx interp/genarg.cmx \ + parsing/extend.cmx library/decl_kinds.cmx parsing/coqast.cmx \ + parsing/ast.cmx parsing/pcoq.cmi +parsing/ppconstr.cmo: lib/util.cmi interp/topconstr.cmi kernel/term.cmi \ + interp/symbols.cmi pretyping/rawterm.cmi interp/ppextend.cmi lib/pp.cmi \ + pretyping/pattern.cmi library/nametab.cmi kernel/names.cmi \ + library/nameops.cmi library/libnames.cmi interp/genarg.cmi \ + pretyping/evd.cmi parsing/coqast.cmi interp/constrextern.cmi \ + lib/bignat.cmi parsing/ast.cmi parsing/ppconstr.cmi +parsing/ppconstr.cmx: lib/util.cmx interp/topconstr.cmx kernel/term.cmx \ + interp/symbols.cmx pretyping/rawterm.cmx interp/ppextend.cmx lib/pp.cmx \ + pretyping/pattern.cmx library/nametab.cmx kernel/names.cmx \ + library/nameops.cmx library/libnames.cmx interp/genarg.cmx \ + pretyping/evd.cmx parsing/coqast.cmx interp/constrextern.cmx \ + lib/bignat.cmx parsing/ast.cmx parsing/ppconstr.cmi +parsing/pptactic.cmo: lib/util.cmi interp/topconstr.cmi kernel/term.cmi \ + proofs/tacexpr.cmo pretyping/rawterm.cmi parsing/printer.cmi \ + translate/ppconstrnew.cmi parsing/ppconstr.cmi lib/pp.cmi \ + pretyping/pattern.cmi lib/options.cmi library/nametab.cmi \ + kernel/names.cmi library/nameops.cmi library/libnames.cmi \ + interp/genarg.cmi parsing/extend.cmi lib/dyn.cmi interp/constrextern.cmi \ + kernel/closure.cmi parsing/pptactic.cmi +parsing/pptactic.cmx: lib/util.cmx interp/topconstr.cmx kernel/term.cmx \ + proofs/tacexpr.cmx pretyping/rawterm.cmx parsing/printer.cmx \ + translate/ppconstrnew.cmx parsing/ppconstr.cmx lib/pp.cmx \ + pretyping/pattern.cmx lib/options.cmx library/nametab.cmx \ + kernel/names.cmx library/nameops.cmx library/libnames.cmx \ + interp/genarg.cmx parsing/extend.cmx lib/dyn.cmx interp/constrextern.cmx \ + kernel/closure.cmx parsing/pptactic.cmi +parsing/prettyp.cmo: lib/util.cmi pretyping/termops.cmi kernel/term.cmi \ + interp/syntax_def.cmi interp/symbols.cmi kernel/sign.cmi \ + kernel/safe_typing.cmi pretyping/reductionops.cmi kernel/reduction.cmi \ + parsing/printmod.cmi parsing/printer.cmi lib/pp.cmi lib/options.cmi \ + library/nametab.cmi kernel/names.cmi library/nameops.cmi \ + library/libobject.cmi library/libnames.cmi library/lib.cmi \ + pretyping/instantiate.cmi pretyping/inductiveops.cmi kernel/inductive.cmi \ + library/impargs.cmi library/global.cmi pretyping/evd.cmi \ + kernel/environ.cmi library/declare.cmi kernel/declarations.cmi \ + interp/constrextern.cmi pretyping/classops.cmi parsing/prettyp.cmi +parsing/prettyp.cmx: lib/util.cmx pretyping/termops.cmx kernel/term.cmx \ + interp/syntax_def.cmx interp/symbols.cmx kernel/sign.cmx \ + kernel/safe_typing.cmx pretyping/reductionops.cmx kernel/reduction.cmx \ + parsing/printmod.cmx parsing/printer.cmx lib/pp.cmx lib/options.cmx \ + library/nametab.cmx kernel/names.cmx library/nameops.cmx \ + library/libobject.cmx library/libnames.cmx library/lib.cmx \ + pretyping/instantiate.cmx pretyping/inductiveops.cmx kernel/inductive.cmx \ + library/impargs.cmx library/global.cmx pretyping/evd.cmx \ + kernel/environ.cmx library/declare.cmx kernel/declarations.cmx \ + interp/constrextern.cmx pretyping/classops.cmx parsing/prettyp.cmi +parsing/printer.cmo: lib/util.cmi pretyping/termops.cmi parsing/termast.cmi \ + kernel/term.cmi kernel/sign.cmi interp/ppextend.cmi \ + translate/ppconstrnew.cmi parsing/ppconstr.cmi lib/pp.cmi \ + pretyping/pattern.cmi lib/options.cmi library/nametab.cmi \ + kernel/names.cmi library/nameops.cmi library/libnames.cmi \ + library/global.cmi parsing/extend.cmi parsing/esyntax.cmi \ + kernel/environ.cmi lib/dyn.cmi library/declare.cmi parsing/coqast.cmi \ + interp/constrextern.cmi parsing/ast.cmi parsing/printer.cmi +parsing/printer.cmx: lib/util.cmx pretyping/termops.cmx parsing/termast.cmx \ + kernel/term.cmx kernel/sign.cmx interp/ppextend.cmx \ + translate/ppconstrnew.cmx parsing/ppconstr.cmx lib/pp.cmx \ + pretyping/pattern.cmx lib/options.cmx library/nametab.cmx \ + kernel/names.cmx library/nameops.cmx library/libnames.cmx \ + library/global.cmx parsing/extend.cmx parsing/esyntax.cmx \ + kernel/environ.cmx lib/dyn.cmx library/declare.cmx parsing/coqast.cmx \ + interp/constrextern.cmx parsing/ast.cmx parsing/printer.cmi +parsing/printmod.cmo: lib/util.cmi lib/pp.cmi library/nametab.cmi \ + kernel/names.cmi library/nameops.cmi library/libnames.cmi \ + library/global.cmi kernel/declarations.cmi parsing/printmod.cmi +parsing/printmod.cmx: lib/util.cmx lib/pp.cmx library/nametab.cmx \ + kernel/names.cmx library/nameops.cmx library/libnames.cmx \ + library/global.cmx kernel/declarations.cmx parsing/printmod.cmi +parsing/q_coqast.cmo: lib/util.cmi interp/topconstr.cmi proofs/tacexpr.cmo \ + pretyping/rawterm.cmi parsing/q_util.cmi parsing/pcoq.cmi \ + kernel/names.cmi library/libnames.cmi interp/genarg.cmi \ + parsing/coqast.cmi +parsing/q_coqast.cmx: lib/util.cmx interp/topconstr.cmx proofs/tacexpr.cmx \ + pretyping/rawterm.cmx parsing/q_util.cmx parsing/pcoq.cmx \ + kernel/names.cmx library/libnames.cmx interp/genarg.cmx \ + parsing/coqast.cmx parsing/q_util.cmo: lib/util.cmi parsing/q_util.cmi parsing/q_util.cmx: lib/util.cmx parsing/q_util.cmi -parsing/search.cmo: parsing/coqast.cmi interp/coqlib.cmi \ - kernel/declarations.cmi library/declare.cmi library/declaremods.cmi \ - kernel/environ.cmi pretyping/evd.cmi library/global.cmi \ - kernel/inductive.cmi library/libnames.cmi library/libobject.cmi \ - library/library.cmi pretyping/matching.cmi library/nameops.cmi \ - kernel/names.cmi library/nametab.cmi pretyping/pattern.cmi lib/pp.cmi \ - parsing/printer.cmi pretyping/rawterm.cmi kernel/term.cmi \ - pretyping/termops.cmi pretyping/typing.cmi lib/util.cmi \ - parsing/search.cmi -parsing/search.cmx: parsing/coqast.cmx interp/coqlib.cmx \ - kernel/declarations.cmx library/declare.cmx library/declaremods.cmx \ - kernel/environ.cmx pretyping/evd.cmx library/global.cmx \ - kernel/inductive.cmx library/libnames.cmx library/libobject.cmx \ - library/library.cmx pretyping/matching.cmx library/nameops.cmx \ - kernel/names.cmx library/nametab.cmx pretyping/pattern.cmx lib/pp.cmx \ - parsing/printer.cmx pretyping/rawterm.cmx kernel/term.cmx \ - pretyping/termops.cmx pretyping/typing.cmx lib/util.cmx \ - parsing/search.cmi -parsing/tacextend.cmo: parsing/argextend.cmo interp/genarg.cmi \ - parsing/pcoq.cmi lib/pp.cmi lib/pp_control.cmi parsing/q_coqast.cmo \ - parsing/q_util.cmi lib/util.cmi toplevel/vernacexpr.cmo -parsing/tacextend.cmx: parsing/argextend.cmx interp/genarg.cmx \ - parsing/pcoq.cmx lib/pp.cmx lib/pp_control.cmx parsing/q_coqast.cmx \ - parsing/q_util.cmx lib/util.cmx toplevel/vernacexpr.cmx -parsing/termast.cmo: parsing/ast.cmi pretyping/classops.cmi \ - interp/constrextern.cmi parsing/coqast.cmi library/declare.cmi \ - pretyping/detyping.cmi kernel/environ.cmi library/impargs.cmi \ - kernel/inductive.cmi library/libnames.cmi library/nameops.cmi \ - kernel/names.cmi library/nametab.cmi pretyping/pattern.cmi lib/pp.cmi \ - pretyping/rawterm.cmi pretyping/reductionops.cmi kernel/sign.cmi \ - kernel/term.cmi pretyping/termops.cmi kernel/univ.cmi lib/util.cmi \ - parsing/termast.cmi -parsing/termast.cmx: parsing/ast.cmx pretyping/classops.cmx \ - interp/constrextern.cmx parsing/coqast.cmx library/declare.cmx \ - pretyping/detyping.cmx kernel/environ.cmx library/impargs.cmx \ - kernel/inductive.cmx library/libnames.cmx library/nameops.cmx \ - kernel/names.cmx library/nametab.cmx pretyping/pattern.cmx lib/pp.cmx \ - pretyping/rawterm.cmx pretyping/reductionops.cmx kernel/sign.cmx \ - kernel/term.cmx pretyping/termops.cmx kernel/univ.cmx lib/util.cmx \ - parsing/termast.cmi -parsing/vernacextend.cmo: parsing/argextend.cmo parsing/ast.cmi \ - interp/genarg.cmi parsing/pcoq.cmi lib/pp.cmi lib/pp_control.cmi \ - parsing/q_coqast.cmo parsing/q_util.cmi lib/util.cmi \ - toplevel/vernacexpr.cmo -parsing/vernacextend.cmx: parsing/argextend.cmx parsing/ast.cmx \ - interp/genarg.cmx parsing/pcoq.cmx lib/pp.cmx lib/pp_control.cmx \ - parsing/q_coqast.cmx parsing/q_util.cmx lib/util.cmx \ - toplevel/vernacexpr.cmx -pretyping/cases.cmo: pretyping/coercion.cmi kernel/declarations.cmi \ - kernel/environ.cmi pretyping/evarconv.cmi pretyping/evarutil.cmi \ - library/global.cmi kernel/inductive.cmi pretyping/inductiveops.cmi \ - library/nameops.cmi kernel/names.cmi lib/pp.cmi \ - pretyping/pretype_errors.cmi pretyping/rawterm.cmi \ - pretyping/reductionops.cmi pretyping/retyping.cmi kernel/sign.cmi \ - kernel/term.cmi pretyping/termops.cmi kernel/type_errors.cmi \ - kernel/typeops.cmi lib/util.cmi pretyping/cases.cmi -pretyping/cases.cmx: pretyping/coercion.cmx kernel/declarations.cmx \ - kernel/environ.cmx pretyping/evarconv.cmx pretyping/evarutil.cmx \ - library/global.cmx kernel/inductive.cmx pretyping/inductiveops.cmx \ - library/nameops.cmx kernel/names.cmx lib/pp.cmx \ - pretyping/pretype_errors.cmx pretyping/rawterm.cmx \ - pretyping/reductionops.cmx pretyping/retyping.cmx kernel/sign.cmx \ - kernel/term.cmx pretyping/termops.cmx kernel/type_errors.cmx \ - kernel/typeops.cmx lib/util.cmx pretyping/cases.cmi -pretyping/cbv.cmo: kernel/closure.cmi kernel/environ.cmi kernel/esubst.cmi \ - pretyping/evd.cmi pretyping/instantiate.cmi kernel/names.cmi lib/pp.cmi \ - kernel/term.cmi kernel/univ.cmi lib/util.cmi pretyping/cbv.cmi -pretyping/cbv.cmx: kernel/closure.cmx kernel/environ.cmx kernel/esubst.cmx \ - pretyping/evd.cmx pretyping/instantiate.cmx kernel/names.cmx lib/pp.cmx \ - kernel/term.cmx kernel/univ.cmx lib/util.cmx pretyping/cbv.cmi -pretyping/classops.cmo: library/decl_kinds.cmo kernel/environ.cmi \ - pretyping/evd.cmi library/global.cmi lib/gmap.cmi library/goptions.cmi \ - library/lib.cmi library/libnames.cmi library/libobject.cmi \ - library/library.cmi kernel/names.cmi library/nametab.cmi lib/options.cmi \ - lib/pp.cmi pretyping/rawterm.cmi pretyping/reductionops.cmi \ - library/summary.cmi pretyping/tacred.cmi kernel/term.cmi \ - pretyping/termops.cmi lib/util.cmi pretyping/classops.cmi -pretyping/classops.cmx: library/decl_kinds.cmx kernel/environ.cmx \ - pretyping/evd.cmx library/global.cmx lib/gmap.cmx library/goptions.cmx \ - library/lib.cmx library/libnames.cmx library/libobject.cmx \ - library/library.cmx kernel/names.cmx library/nametab.cmx lib/options.cmx \ - lib/pp.cmx pretyping/rawterm.cmx pretyping/reductionops.cmx \ - library/summary.cmx pretyping/tacred.cmx kernel/term.cmx \ - pretyping/termops.cmx lib/util.cmx pretyping/classops.cmi -pretyping/coercion.cmo: pretyping/classops.cmi kernel/environ.cmi \ - pretyping/evarconv.cmi pretyping/evarutil.cmi pretyping/evd.cmi \ - kernel/names.cmi pretyping/pretype_errors.cmi pretyping/rawterm.cmi \ - pretyping/recordops.cmi pretyping/reductionops.cmi pretyping/retyping.cmi \ - kernel/term.cmi kernel/typeops.cmi lib/util.cmi pretyping/coercion.cmi -pretyping/coercion.cmx: pretyping/classops.cmx kernel/environ.cmx \ - pretyping/evarconv.cmx pretyping/evarutil.cmx pretyping/evd.cmx \ - kernel/names.cmx pretyping/pretype_errors.cmx pretyping/rawterm.cmx \ - pretyping/recordops.cmx pretyping/reductionops.cmx pretyping/retyping.cmx \ - kernel/term.cmx kernel/typeops.cmx lib/util.cmx pretyping/coercion.cmi -pretyping/detyping.cmo: kernel/declarations.cmi kernel/environ.cmi \ - library/global.cmi library/goptions.cmi kernel/inductive.cmi \ - pretyping/inductiveops.cmi library/libnames.cmi library/nameops.cmi \ - kernel/names.cmi library/nametab.cmi lib/options.cmi lib/pp.cmi \ - pretyping/rawterm.cmi kernel/sign.cmi kernel/term.cmi \ - pretyping/termops.cmi kernel/univ.cmi lib/util.cmi pretyping/detyping.cmi -pretyping/detyping.cmx: kernel/declarations.cmx kernel/environ.cmx \ - library/global.cmx library/goptions.cmx kernel/inductive.cmx \ - pretyping/inductiveops.cmx library/libnames.cmx library/nameops.cmx \ - kernel/names.cmx library/nametab.cmx lib/options.cmx lib/pp.cmx \ - pretyping/rawterm.cmx kernel/sign.cmx kernel/term.cmx \ - pretyping/termops.cmx kernel/univ.cmx lib/util.cmx pretyping/detyping.cmi -pretyping/evarconv.cmo: pretyping/classops.cmi kernel/closure.cmi \ - kernel/environ.cmi pretyping/evarutil.cmi pretyping/evd.cmi \ - pretyping/instantiate.cmi library/libnames.cmi kernel/names.cmi \ - pretyping/rawterm.cmi pretyping/recordops.cmi pretyping/reductionops.cmi \ - kernel/term.cmi pretyping/typing.cmi lib/util.cmi pretyping/evarconv.cmi -pretyping/evarconv.cmx: pretyping/classops.cmx kernel/closure.cmx \ - kernel/environ.cmx pretyping/evarutil.cmx pretyping/evd.cmx \ - pretyping/instantiate.cmx library/libnames.cmx kernel/names.cmx \ - pretyping/rawterm.cmx pretyping/recordops.cmx pretyping/reductionops.cmx \ - kernel/term.cmx pretyping/typing.cmx lib/util.cmx pretyping/evarconv.cmi -pretyping/evarutil.cmo: kernel/environ.cmi pretyping/evd.cmi \ - library/global.cmi pretyping/indrec.cmi pretyping/instantiate.cmi \ - library/nameops.cmi kernel/names.cmi lib/pp.cmi \ - pretyping/pretype_errors.cmi pretyping/rawterm.cmi \ - pretyping/reductionops.cmi kernel/sign.cmi kernel/term.cmi \ - pretyping/termops.cmi kernel/typeops.cmi kernel/univ.cmi lib/util.cmi \ +parsing/search.cmo: lib/util.cmi pretyping/typing.cmi pretyping/termops.cmi \ + kernel/term.cmi pretyping/rawterm.cmi parsing/printer.cmi lib/pp.cmi \ + pretyping/pattern.cmi library/nametab.cmi kernel/names.cmi \ + library/nameops.cmi pretyping/matching.cmi library/library.cmi \ + library/libobject.cmi library/libnames.cmi kernel/inductive.cmi \ + library/global.cmi pretyping/evd.cmi kernel/environ.cmi \ + library/declaremods.cmi library/declare.cmi kernel/declarations.cmi \ + interp/coqlib.cmi parsing/coqast.cmi parsing/search.cmi +parsing/search.cmx: lib/util.cmx pretyping/typing.cmx pretyping/termops.cmx \ + kernel/term.cmx pretyping/rawterm.cmx parsing/printer.cmx lib/pp.cmx \ + pretyping/pattern.cmx library/nametab.cmx kernel/names.cmx \ + library/nameops.cmx pretyping/matching.cmx library/library.cmx \ + library/libobject.cmx library/libnames.cmx kernel/inductive.cmx \ + library/global.cmx pretyping/evd.cmx kernel/environ.cmx \ + library/declaremods.cmx library/declare.cmx kernel/declarations.cmx \ + interp/coqlib.cmx parsing/coqast.cmx parsing/search.cmi +parsing/tacextend.cmo: toplevel/vernacexpr.cmo lib/util.cmi \ + parsing/q_util.cmi parsing/q_coqast.cmo lib/pp_control.cmi lib/pp.cmi \ + parsing/pcoq.cmi interp/genarg.cmi parsing/argextend.cmo +parsing/tacextend.cmx: toplevel/vernacexpr.cmx lib/util.cmx \ + parsing/q_util.cmx parsing/q_coqast.cmx lib/pp_control.cmx lib/pp.cmx \ + parsing/pcoq.cmx interp/genarg.cmx parsing/argextend.cmx +parsing/termast.cmo: lib/util.cmi kernel/univ.cmi pretyping/termops.cmi \ + kernel/term.cmi kernel/sign.cmi pretyping/reductionops.cmi \ + pretyping/rawterm.cmi lib/pp.cmi pretyping/pattern.cmi \ + library/nametab.cmi kernel/names.cmi library/nameops.cmi \ + library/libnames.cmi kernel/inductive.cmi library/impargs.cmi \ + kernel/environ.cmi pretyping/detyping.cmi library/declare.cmi \ + parsing/coqast.cmi interp/constrextern.cmi pretyping/classops.cmi \ + parsing/ast.cmi parsing/termast.cmi +parsing/termast.cmx: lib/util.cmx kernel/univ.cmx pretyping/termops.cmx \ + kernel/term.cmx kernel/sign.cmx pretyping/reductionops.cmx \ + pretyping/rawterm.cmx lib/pp.cmx pretyping/pattern.cmx \ + library/nametab.cmx kernel/names.cmx library/nameops.cmx \ + library/libnames.cmx kernel/inductive.cmx library/impargs.cmx \ + kernel/environ.cmx pretyping/detyping.cmx library/declare.cmx \ + parsing/coqast.cmx interp/constrextern.cmx pretyping/classops.cmx \ + parsing/ast.cmx parsing/termast.cmi +parsing/vernacextend.cmo: toplevel/vernacexpr.cmo lib/util.cmi \ + parsing/q_util.cmi parsing/q_coqast.cmo lib/pp_control.cmi lib/pp.cmi \ + parsing/pcoq.cmi interp/genarg.cmi parsing/ast.cmi parsing/argextend.cmo +parsing/vernacextend.cmx: toplevel/vernacexpr.cmx lib/util.cmx \ + parsing/q_util.cmx parsing/q_coqast.cmx lib/pp_control.cmx lib/pp.cmx \ + parsing/pcoq.cmx interp/genarg.cmx parsing/ast.cmx parsing/argextend.cmx +pretyping/cases.cmo: lib/util.cmi kernel/typeops.cmi kernel/type_errors.cmi \ + pretyping/termops.cmi kernel/term.cmi kernel/sign.cmi \ + pretyping/retyping.cmi pretyping/reductionops.cmi pretyping/rawterm.cmi \ + pretyping/pretype_errors.cmi lib/pp.cmi kernel/names.cmi \ + library/nameops.cmi pretyping/inductiveops.cmi kernel/inductive.cmi \ + library/global.cmi pretyping/evarutil.cmi pretyping/evarconv.cmi \ + kernel/environ.cmi kernel/declarations.cmi pretyping/coercion.cmi \ + pretyping/cases.cmi +pretyping/cases.cmx: lib/util.cmx kernel/typeops.cmx kernel/type_errors.cmx \ + pretyping/termops.cmx kernel/term.cmx kernel/sign.cmx \ + pretyping/retyping.cmx pretyping/reductionops.cmx pretyping/rawterm.cmx \ + pretyping/pretype_errors.cmx lib/pp.cmx kernel/names.cmx \ + library/nameops.cmx pretyping/inductiveops.cmx kernel/inductive.cmx \ + library/global.cmx pretyping/evarutil.cmx pretyping/evarconv.cmx \ + kernel/environ.cmx kernel/declarations.cmx pretyping/coercion.cmx \ + pretyping/cases.cmi +pretyping/cbv.cmo: lib/util.cmi kernel/univ.cmi kernel/term.cmi lib/pp.cmi \ + kernel/names.cmi pretyping/instantiate.cmi pretyping/evd.cmi \ + kernel/esubst.cmi kernel/environ.cmi kernel/closure.cmi pretyping/cbv.cmi +pretyping/cbv.cmx: lib/util.cmx kernel/univ.cmx kernel/term.cmx lib/pp.cmx \ + kernel/names.cmx pretyping/instantiate.cmx pretyping/evd.cmx \ + kernel/esubst.cmx kernel/environ.cmx kernel/closure.cmx pretyping/cbv.cmi +pretyping/classops.cmo: lib/util.cmi pretyping/termops.cmi kernel/term.cmi \ + pretyping/tacred.cmi library/summary.cmi pretyping/reductionops.cmi \ + pretyping/rawterm.cmi lib/pp.cmi lib/options.cmi library/nametab.cmi \ + kernel/names.cmi library/library.cmi library/libobject.cmi \ + library/libnames.cmi library/lib.cmi library/goptions.cmi lib/gmap.cmi \ + library/global.cmi pretyping/evd.cmi kernel/environ.cmi \ + library/decl_kinds.cmo pretyping/classops.cmi +pretyping/classops.cmx: lib/util.cmx pretyping/termops.cmx kernel/term.cmx \ + pretyping/tacred.cmx library/summary.cmx pretyping/reductionops.cmx \ + pretyping/rawterm.cmx lib/pp.cmx lib/options.cmx library/nametab.cmx \ + kernel/names.cmx library/library.cmx library/libobject.cmx \ + library/libnames.cmx library/lib.cmx library/goptions.cmx lib/gmap.cmx \ + library/global.cmx pretyping/evd.cmx kernel/environ.cmx \ + library/decl_kinds.cmx pretyping/classops.cmi +pretyping/coercion.cmo: lib/util.cmi kernel/typeops.cmi kernel/term.cmi \ + pretyping/retyping.cmi pretyping/reductionops.cmi pretyping/recordops.cmi \ + pretyping/rawterm.cmi pretyping/pretype_errors.cmi kernel/names.cmi \ + pretyping/evd.cmi pretyping/evarutil.cmi pretyping/evarconv.cmi \ + kernel/environ.cmi pretyping/classops.cmi pretyping/coercion.cmi +pretyping/coercion.cmx: lib/util.cmx kernel/typeops.cmx kernel/term.cmx \ + pretyping/retyping.cmx pretyping/reductionops.cmx pretyping/recordops.cmx \ + pretyping/rawterm.cmx pretyping/pretype_errors.cmx kernel/names.cmx \ + pretyping/evd.cmx pretyping/evarutil.cmx pretyping/evarconv.cmx \ + kernel/environ.cmx pretyping/classops.cmx pretyping/coercion.cmi +pretyping/detyping.cmo: lib/util.cmi kernel/univ.cmi pretyping/termops.cmi \ + kernel/term.cmi kernel/sign.cmi pretyping/rawterm.cmi lib/pp.cmi \ + lib/options.cmi library/nametab.cmi kernel/names.cmi library/nameops.cmi \ + library/libnames.cmi pretyping/inductiveops.cmi kernel/inductive.cmi \ + library/goptions.cmi library/global.cmi kernel/environ.cmi \ + kernel/declarations.cmi pretyping/detyping.cmi +pretyping/detyping.cmx: lib/util.cmx kernel/univ.cmx pretyping/termops.cmx \ + kernel/term.cmx kernel/sign.cmx pretyping/rawterm.cmx lib/pp.cmx \ + lib/options.cmx library/nametab.cmx kernel/names.cmx library/nameops.cmx \ + library/libnames.cmx pretyping/inductiveops.cmx kernel/inductive.cmx \ + library/goptions.cmx library/global.cmx kernel/environ.cmx \ + kernel/declarations.cmx pretyping/detyping.cmi +pretyping/evarconv.cmo: lib/util.cmi pretyping/typing.cmi kernel/term.cmi \ + pretyping/reductionops.cmi pretyping/recordops.cmi pretyping/rawterm.cmi \ + kernel/names.cmi library/libnames.cmi pretyping/instantiate.cmi \ + pretyping/evd.cmi pretyping/evarutil.cmi kernel/environ.cmi \ + kernel/closure.cmi pretyping/classops.cmi pretyping/evarconv.cmi +pretyping/evarconv.cmx: lib/util.cmx pretyping/typing.cmx kernel/term.cmx \ + pretyping/reductionops.cmx pretyping/recordops.cmx pretyping/rawterm.cmx \ + kernel/names.cmx library/libnames.cmx pretyping/instantiate.cmx \ + pretyping/evd.cmx pretyping/evarutil.cmx kernel/environ.cmx \ + kernel/closure.cmx pretyping/classops.cmx pretyping/evarconv.cmi +pretyping/evarutil.cmo: lib/util.cmi kernel/univ.cmi kernel/typeops.cmi \ + pretyping/termops.cmi kernel/term.cmi kernel/sign.cmi \ + pretyping/reductionops.cmi pretyping/rawterm.cmi \ + pretyping/pretype_errors.cmi lib/pp.cmi kernel/names.cmi \ + library/nameops.cmi pretyping/instantiate.cmi pretyping/indrec.cmi \ + library/global.cmi pretyping/evd.cmi kernel/environ.cmi \ pretyping/evarutil.cmi -pretyping/evarutil.cmx: kernel/environ.cmx pretyping/evd.cmx \ - library/global.cmx pretyping/indrec.cmx pretyping/instantiate.cmx \ - library/nameops.cmx kernel/names.cmx lib/pp.cmx \ - pretyping/pretype_errors.cmx pretyping/rawterm.cmx \ - pretyping/reductionops.cmx kernel/sign.cmx kernel/term.cmx \ - pretyping/termops.cmx kernel/typeops.cmx kernel/univ.cmx lib/util.cmx \ +pretyping/evarutil.cmx: lib/util.cmx kernel/univ.cmx kernel/typeops.cmx \ + pretyping/termops.cmx kernel/term.cmx kernel/sign.cmx \ + pretyping/reductionops.cmx pretyping/rawterm.cmx \ + pretyping/pretype_errors.cmx lib/pp.cmx kernel/names.cmx \ + library/nameops.cmx pretyping/instantiate.cmx pretyping/indrec.cmx \ + library/global.cmx pretyping/evd.cmx kernel/environ.cmx \ pretyping/evarutil.cmi -pretyping/evd.cmo: kernel/names.cmi kernel/sign.cmi kernel/term.cmi \ - lib/util.cmi pretyping/evd.cmi -pretyping/evd.cmx: kernel/names.cmx kernel/sign.cmx kernel/term.cmx \ - lib/util.cmx pretyping/evd.cmi -pretyping/indrec.cmo: kernel/declarations.cmi kernel/entries.cmi \ - kernel/environ.cmi library/global.cmi kernel/indtypes.cmi \ - kernel/inductive.cmi pretyping/inductiveops.cmi pretyping/instantiate.cmi \ - library/libnames.cmi library/nameops.cmi kernel/names.cmi \ - library/nametab.cmi lib/options.cmi lib/pp.cmi kernel/reduction.cmi \ - pretyping/reductionops.cmi kernel/safe_typing.cmi kernel/term.cmi \ - pretyping/termops.cmi kernel/type_errors.cmi kernel/typeops.cmi \ - lib/util.cmi pretyping/indrec.cmi -pretyping/indrec.cmx: kernel/declarations.cmx kernel/entries.cmx \ - kernel/environ.cmx library/global.cmx kernel/indtypes.cmx \ - kernel/inductive.cmx pretyping/inductiveops.cmx pretyping/instantiate.cmx \ - library/libnames.cmx library/nameops.cmx kernel/names.cmx \ - library/nametab.cmx lib/options.cmx lib/pp.cmx kernel/reduction.cmx \ - pretyping/reductionops.cmx kernel/safe_typing.cmx kernel/term.cmx \ - pretyping/termops.cmx kernel/type_errors.cmx kernel/typeops.cmx \ - lib/util.cmx pretyping/indrec.cmi -pretyping/inductiveops.cmo: kernel/declarations.cmi kernel/environ.cmi \ - pretyping/evd.cmi library/global.cmi kernel/inductive.cmi \ - kernel/names.cmi pretyping/reductionops.cmi kernel/sign.cmi \ - kernel/term.cmi pretyping/termops.cmi kernel/univ.cmi lib/util.cmi \ - pretyping/inductiveops.cmi -pretyping/inductiveops.cmx: kernel/declarations.cmx kernel/environ.cmx \ - pretyping/evd.cmx library/global.cmx kernel/inductive.cmx \ - kernel/names.cmx pretyping/reductionops.cmx kernel/sign.cmx \ - kernel/term.cmx pretyping/termops.cmx kernel/univ.cmx lib/util.cmx \ - pretyping/inductiveops.cmi -pretyping/instantiate.cmo: kernel/declarations.cmi kernel/environ.cmi \ - pretyping/evd.cmi kernel/names.cmi lib/pp.cmi kernel/sign.cmi \ - kernel/term.cmi lib/util.cmi pretyping/instantiate.cmi -pretyping/instantiate.cmx: kernel/declarations.cmx kernel/environ.cmx \ - pretyping/evd.cmx kernel/names.cmx lib/pp.cmx kernel/sign.cmx \ - kernel/term.cmx lib/util.cmx pretyping/instantiate.cmi -pretyping/matching.cmo: kernel/environ.cmi library/libnames.cmi \ - library/nameops.cmi kernel/names.cmi pretyping/pattern.cmi \ - pretyping/rawterm.cmi pretyping/reductionops.cmi kernel/term.cmi \ - pretyping/termops.cmi lib/util.cmi pretyping/matching.cmi -pretyping/matching.cmx: kernel/environ.cmx library/libnames.cmx \ - library/nameops.cmx kernel/names.cmx pretyping/pattern.cmx \ - pretyping/rawterm.cmx pretyping/reductionops.cmx kernel/term.cmx \ - pretyping/termops.cmx lib/util.cmx pretyping/matching.cmi -pretyping/pattern.cmo: kernel/environ.cmi library/libnames.cmi \ - library/nameops.cmi kernel/names.cmi library/nametab.cmi lib/options.cmi \ - lib/pp.cmi pretyping/rawterm.cmi kernel/term.cmi lib/util.cmi \ +pretyping/evd.cmo: lib/util.cmi kernel/term.cmi kernel/sign.cmi \ + kernel/names.cmi pretyping/evd.cmi +pretyping/evd.cmx: lib/util.cmx kernel/term.cmx kernel/sign.cmx \ + kernel/names.cmx pretyping/evd.cmi +pretyping/indrec.cmo: lib/util.cmi kernel/typeops.cmi kernel/type_errors.cmi \ + pretyping/termops.cmi kernel/term.cmi kernel/safe_typing.cmi \ + pretyping/reductionops.cmi kernel/reduction.cmi lib/pp.cmi \ + lib/options.cmi library/nametab.cmi kernel/names.cmi library/nameops.cmi \ + library/libnames.cmi pretyping/instantiate.cmi pretyping/inductiveops.cmi \ + kernel/inductive.cmi kernel/indtypes.cmi library/global.cmi \ + kernel/environ.cmi kernel/entries.cmi kernel/declarations.cmi \ + pretyping/indrec.cmi +pretyping/indrec.cmx: lib/util.cmx kernel/typeops.cmx kernel/type_errors.cmx \ + pretyping/termops.cmx kernel/term.cmx kernel/safe_typing.cmx \ + pretyping/reductionops.cmx kernel/reduction.cmx lib/pp.cmx \ + lib/options.cmx library/nametab.cmx kernel/names.cmx library/nameops.cmx \ + library/libnames.cmx pretyping/instantiate.cmx pretyping/inductiveops.cmx \ + kernel/inductive.cmx kernel/indtypes.cmx library/global.cmx \ + kernel/environ.cmx kernel/entries.cmx kernel/declarations.cmx \ + pretyping/indrec.cmi +pretyping/inductiveops.cmo: lib/util.cmi kernel/univ.cmi \ + pretyping/termops.cmi kernel/term.cmi kernel/sign.cmi \ + pretyping/reductionops.cmi kernel/names.cmi kernel/inductive.cmi \ + library/global.cmi pretyping/evd.cmi kernel/environ.cmi \ + kernel/declarations.cmi pretyping/inductiveops.cmi +pretyping/inductiveops.cmx: lib/util.cmx kernel/univ.cmx \ + pretyping/termops.cmx kernel/term.cmx kernel/sign.cmx \ + pretyping/reductionops.cmx kernel/names.cmx kernel/inductive.cmx \ + library/global.cmx pretyping/evd.cmx kernel/environ.cmx \ + kernel/declarations.cmx pretyping/inductiveops.cmi +pretyping/instantiate.cmo: lib/util.cmi kernel/term.cmi kernel/sign.cmi \ + lib/pp.cmi kernel/names.cmi pretyping/evd.cmi kernel/environ.cmi \ + kernel/declarations.cmi pretyping/instantiate.cmi +pretyping/instantiate.cmx: lib/util.cmx kernel/term.cmx kernel/sign.cmx \ + lib/pp.cmx kernel/names.cmx pretyping/evd.cmx kernel/environ.cmx \ + kernel/declarations.cmx pretyping/instantiate.cmi +pretyping/matching.cmo: lib/util.cmi pretyping/termops.cmi kernel/term.cmi \ + pretyping/reductionops.cmi pretyping/rawterm.cmi pretyping/pattern.cmi \ + kernel/names.cmi library/nameops.cmi library/libnames.cmi \ + kernel/environ.cmi pretyping/matching.cmi +pretyping/matching.cmx: lib/util.cmx pretyping/termops.cmx kernel/term.cmx \ + pretyping/reductionops.cmx pretyping/rawterm.cmx pretyping/pattern.cmx \ + kernel/names.cmx library/nameops.cmx library/libnames.cmx \ + kernel/environ.cmx pretyping/matching.cmi +pretyping/pattern.cmo: lib/util.cmi kernel/term.cmi pretyping/rawterm.cmi \ + lib/pp.cmi lib/options.cmi library/nametab.cmi kernel/names.cmi \ + library/nameops.cmi library/libnames.cmi kernel/environ.cmi \ pretyping/pattern.cmi -pretyping/pattern.cmx: kernel/environ.cmx library/libnames.cmx \ - library/nameops.cmx kernel/names.cmx library/nametab.cmx lib/options.cmx \ - lib/pp.cmx pretyping/rawterm.cmx kernel/term.cmx lib/util.cmx \ +pretyping/pattern.cmx: lib/util.cmx kernel/term.cmx pretyping/rawterm.cmx \ + lib/pp.cmx lib/options.cmx library/nametab.cmx kernel/names.cmx \ + library/nameops.cmx library/libnames.cmx kernel/environ.cmx \ pretyping/pattern.cmi -pretyping/pretype_errors.cmo: kernel/environ.cmi pretyping/evd.cmi \ - pretyping/inductiveops.cmi kernel/names.cmi pretyping/rawterm.cmi \ - kernel/reduction.cmi pretyping/reductionops.cmi kernel/sign.cmi \ - kernel/term.cmi pretyping/termops.cmi kernel/type_errors.cmi lib/util.cmi \ - pretyping/pretype_errors.cmi -pretyping/pretype_errors.cmx: kernel/environ.cmx pretyping/evd.cmx \ - pretyping/inductiveops.cmx kernel/names.cmx pretyping/rawterm.cmx \ - kernel/reduction.cmx pretyping/reductionops.cmx kernel/sign.cmx \ - kernel/term.cmx pretyping/termops.cmx kernel/type_errors.cmx lib/util.cmx \ - pretyping/pretype_errors.cmi -pretyping/pretyping.cmo: pretyping/cases.cmi pretyping/classops.cmi \ - pretyping/coercion.cmi kernel/declarations.cmi pretyping/detyping.cmi \ - lib/dyn.cmi kernel/environ.cmi pretyping/evarconv.cmi \ - pretyping/evarutil.cmi pretyping/evd.cmi library/global.cmi \ - pretyping/indrec.cmi kernel/inductive.cmi pretyping/inductiveops.cmi \ - pretyping/instantiate.cmi library/libnames.cmi library/nameops.cmi \ - kernel/names.cmi lib/options.cmi pretyping/pattern.cmi lib/pp.cmi \ - pretyping/pretype_errors.cmi pretyping/rawterm.cmi \ - pretyping/recordops.cmi pretyping/reductionops.cmi pretyping/retyping.cmi \ - kernel/sign.cmi kernel/term.cmi pretyping/termops.cmi \ - kernel/type_errors.cmi kernel/typeops.cmi lib/util.cmi \ +pretyping/pretype_errors.cmo: lib/util.cmi kernel/type_errors.cmi \ + pretyping/termops.cmi kernel/term.cmi kernel/sign.cmi \ + pretyping/reductionops.cmi kernel/reduction.cmi pretyping/rawterm.cmi \ + kernel/names.cmi pretyping/inductiveops.cmi pretyping/evd.cmi \ + kernel/environ.cmi pretyping/pretype_errors.cmi +pretyping/pretype_errors.cmx: lib/util.cmx kernel/type_errors.cmx \ + pretyping/termops.cmx kernel/term.cmx kernel/sign.cmx \ + pretyping/reductionops.cmx kernel/reduction.cmx pretyping/rawterm.cmx \ + kernel/names.cmx pretyping/inductiveops.cmx pretyping/evd.cmx \ + kernel/environ.cmx pretyping/pretype_errors.cmi +pretyping/pretyping.cmo: lib/util.cmi kernel/typeops.cmi \ + kernel/type_errors.cmi pretyping/termops.cmi kernel/term.cmi \ + kernel/sign.cmi pretyping/retyping.cmi pretyping/reductionops.cmi \ + pretyping/recordops.cmi pretyping/rawterm.cmi \ + pretyping/pretype_errors.cmi lib/pp.cmi pretyping/pattern.cmi \ + lib/options.cmi kernel/names.cmi library/nameops.cmi library/libnames.cmi \ + pretyping/instantiate.cmi pretyping/inductiveops.cmi kernel/inductive.cmi \ + pretyping/indrec.cmi library/global.cmi pretyping/evd.cmi \ + pretyping/evarutil.cmi pretyping/evarconv.cmi kernel/environ.cmi \ + lib/dyn.cmi pretyping/detyping.cmi kernel/declarations.cmi \ + pretyping/coercion.cmi pretyping/classops.cmi pretyping/cases.cmi \ pretyping/pretyping.cmi -pretyping/pretyping.cmx: pretyping/cases.cmx pretyping/classops.cmx \ - pretyping/coercion.cmx kernel/declarations.cmx pretyping/detyping.cmx \ - lib/dyn.cmx kernel/environ.cmx pretyping/evarconv.cmx \ - pretyping/evarutil.cmx pretyping/evd.cmx library/global.cmx \ - pretyping/indrec.cmx kernel/inductive.cmx pretyping/inductiveops.cmx \ - pretyping/instantiate.cmx library/libnames.cmx library/nameops.cmx \ - kernel/names.cmx lib/options.cmx pretyping/pattern.cmx lib/pp.cmx \ - pretyping/pretype_errors.cmx pretyping/rawterm.cmx \ - pretyping/recordops.cmx pretyping/reductionops.cmx pretyping/retyping.cmx \ - kernel/sign.cmx kernel/term.cmx pretyping/termops.cmx \ - kernel/type_errors.cmx kernel/typeops.cmx lib/util.cmx \ +pretyping/pretyping.cmx: lib/util.cmx kernel/typeops.cmx \ + kernel/type_errors.cmx pretyping/termops.cmx kernel/term.cmx \ + kernel/sign.cmx pretyping/retyping.cmx pretyping/reductionops.cmx \ + pretyping/recordops.cmx pretyping/rawterm.cmx \ + pretyping/pretype_errors.cmx lib/pp.cmx pretyping/pattern.cmx \ + lib/options.cmx kernel/names.cmx library/nameops.cmx library/libnames.cmx \ + pretyping/instantiate.cmx pretyping/inductiveops.cmx kernel/inductive.cmx \ + pretyping/indrec.cmx library/global.cmx pretyping/evd.cmx \ + pretyping/evarutil.cmx pretyping/evarconv.cmx kernel/environ.cmx \ + lib/dyn.cmx pretyping/detyping.cmx kernel/declarations.cmx \ + pretyping/coercion.cmx pretyping/classops.cmx pretyping/cases.cmx \ pretyping/pretyping.cmi -pretyping/rawterm.cmo: lib/dyn.cmi library/libnames.cmi kernel/names.cmi \ - library/nametab.cmi kernel/sign.cmi kernel/term.cmi kernel/univ.cmi \ - lib/util.cmi pretyping/rawterm.cmi -pretyping/rawterm.cmx: lib/dyn.cmx library/libnames.cmx kernel/names.cmx \ - library/nametab.cmx kernel/sign.cmx kernel/term.cmx kernel/univ.cmx \ - lib/util.cmx pretyping/rawterm.cmi -pretyping/recordops.cmo: pretyping/classops.cmi library/lib.cmi \ - library/libnames.cmi library/libobject.cmi library/library.cmi \ - kernel/names.cmi library/nametab.cmi lib/pp.cmi library/summary.cmi \ - kernel/term.cmi pretyping/termops.cmi kernel/typeops.cmi lib/util.cmi \ - pretyping/recordops.cmi -pretyping/recordops.cmx: pretyping/classops.cmx library/lib.cmx \ - library/libnames.cmx library/libobject.cmx library/library.cmx \ - kernel/names.cmx library/nametab.cmx lib/pp.cmx library/summary.cmx \ - kernel/term.cmx pretyping/termops.cmx kernel/typeops.cmx lib/util.cmx \ - pretyping/recordops.cmi -pretyping/reductionops.cmo: kernel/closure.cmi kernel/declarations.cmi \ - kernel/environ.cmi kernel/esubst.cmi pretyping/evd.cmi \ - pretyping/instantiate.cmi kernel/names.cmi lib/pp.cmi \ - kernel/reduction.cmi kernel/sign.cmi kernel/term.cmi \ - pretyping/termops.cmi kernel/univ.cmi lib/util.cmi \ +pretyping/rawterm.cmo: lib/util.cmi kernel/univ.cmi kernel/term.cmi \ + kernel/sign.cmi library/nametab.cmi kernel/names.cmi library/libnames.cmi \ + lib/dyn.cmi pretyping/rawterm.cmi +pretyping/rawterm.cmx: lib/util.cmx kernel/univ.cmx kernel/term.cmx \ + kernel/sign.cmx library/nametab.cmx kernel/names.cmx library/libnames.cmx \ + lib/dyn.cmx pretyping/rawterm.cmi +pretyping/recordops.cmo: lib/util.cmi kernel/typeops.cmi \ + pretyping/termops.cmi kernel/term.cmi library/summary.cmi lib/pp.cmi \ + library/nametab.cmi kernel/names.cmi library/library.cmi \ + library/libobject.cmi library/libnames.cmi library/lib.cmi \ + pretyping/classops.cmi pretyping/recordops.cmi +pretyping/recordops.cmx: lib/util.cmx kernel/typeops.cmx \ + pretyping/termops.cmx kernel/term.cmx library/summary.cmx lib/pp.cmx \ + library/nametab.cmx kernel/names.cmx library/library.cmx \ + library/libobject.cmx library/libnames.cmx library/lib.cmx \ + pretyping/classops.cmx pretyping/recordops.cmi +pretyping/reductionops.cmo: lib/util.cmi kernel/univ.cmi \ + pretyping/termops.cmi kernel/term.cmi kernel/sign.cmi \ + kernel/reduction.cmi lib/pp.cmi kernel/names.cmi \ + pretyping/instantiate.cmi pretyping/evd.cmi kernel/esubst.cmi \ + kernel/environ.cmi kernel/declarations.cmi kernel/closure.cmi \ pretyping/reductionops.cmi -pretyping/reductionops.cmx: kernel/closure.cmx kernel/declarations.cmx \ - kernel/environ.cmx kernel/esubst.cmx pretyping/evd.cmx \ - pretyping/instantiate.cmx kernel/names.cmx lib/pp.cmx \ - kernel/reduction.cmx kernel/sign.cmx kernel/term.cmx \ - pretyping/termops.cmx kernel/univ.cmx lib/util.cmx \ +pretyping/reductionops.cmx: lib/util.cmx kernel/univ.cmx \ + pretyping/termops.cmx kernel/term.cmx kernel/sign.cmx \ + kernel/reduction.cmx lib/pp.cmx kernel/names.cmx \ + pretyping/instantiate.cmx pretyping/evd.cmx kernel/esubst.cmx \ + kernel/environ.cmx kernel/declarations.cmx kernel/closure.cmx \ pretyping/reductionops.cmi -pretyping/retyping.cmo: kernel/declarations.cmi kernel/environ.cmi \ - kernel/inductive.cmi pretyping/inductiveops.cmi pretyping/instantiate.cmi \ - kernel/names.cmi pretyping/reductionops.cmi kernel/term.cmi \ - kernel/typeops.cmi kernel/univ.cmi lib/util.cmi pretyping/retyping.cmi -pretyping/retyping.cmx: kernel/declarations.cmx kernel/environ.cmx \ - kernel/inductive.cmx pretyping/inductiveops.cmx pretyping/instantiate.cmx \ - kernel/names.cmx pretyping/reductionops.cmx kernel/term.cmx \ - kernel/typeops.cmx kernel/univ.cmx lib/util.cmx pretyping/retyping.cmi -pretyping/tacred.cmo: pretyping/cbv.cmi kernel/closure.cmi \ - kernel/conv_oracle.cmi kernel/declarations.cmi kernel/environ.cmi \ - pretyping/evd.cmi library/global.cmi kernel/inductive.cmi \ - pretyping/instantiate.cmi library/libnames.cmi library/nameops.cmi \ - kernel/names.cmi library/nametab.cmi lib/pp.cmi pretyping/rawterm.cmi \ - pretyping/reductionops.cmi pretyping/retyping.cmi library/summary.cmi \ - kernel/term.cmi pretyping/termops.cmi lib/util.cmi pretyping/tacred.cmi -pretyping/tacred.cmx: pretyping/cbv.cmx kernel/closure.cmx \ - kernel/conv_oracle.cmx kernel/declarations.cmx kernel/environ.cmx \ - pretyping/evd.cmx library/global.cmx kernel/inductive.cmx \ - pretyping/instantiate.cmx library/libnames.cmx library/nameops.cmx \ - kernel/names.cmx library/nametab.cmx lib/pp.cmx pretyping/rawterm.cmx \ - pretyping/reductionops.cmx pretyping/retyping.cmx library/summary.cmx \ - kernel/term.cmx pretyping/termops.cmx lib/util.cmx pretyping/tacred.cmi -pretyping/termops.cmo: kernel/environ.cmi library/global.cmi library/lib.cmi \ - library/libnames.cmi library/nameops.cmi kernel/names.cmi \ - library/nametab.cmi lib/pp.cmi kernel/sign.cmi kernel/term.cmi \ - kernel/univ.cmi lib/util.cmi pretyping/termops.cmi -pretyping/termops.cmx: kernel/environ.cmx library/global.cmx library/lib.cmx \ - library/libnames.cmx library/nameops.cmx kernel/names.cmx \ - library/nametab.cmx lib/pp.cmx kernel/sign.cmx kernel/term.cmx \ - kernel/univ.cmx lib/util.cmx pretyping/termops.cmi -pretyping/typing.cmo: kernel/environ.cmi kernel/inductive.cmi \ - pretyping/instantiate.cmi kernel/names.cmi pretyping/pretype_errors.cmi \ - pretyping/reductionops.cmi kernel/term.cmi kernel/type_errors.cmi \ - kernel/typeops.cmi lib/util.cmi pretyping/typing.cmi -pretyping/typing.cmx: kernel/environ.cmx kernel/inductive.cmx \ - pretyping/instantiate.cmx kernel/names.cmx pretyping/pretype_errors.cmx \ - pretyping/reductionops.cmx kernel/term.cmx kernel/type_errors.cmx \ - kernel/typeops.cmx lib/util.cmx pretyping/typing.cmi -proofs/clenv.cmo: pretyping/coercion.cmi kernel/environ.cmi \ - proofs/evar_refiner.cmi pretyping/evarutil.cmi pretyping/evd.cmi \ - library/global.cmi pretyping/instantiate.cmi proofs/logic.cmi \ - library/nameops.cmi kernel/names.cmi pretyping/pattern.cmi lib/pp.cmi \ - parsing/printer.cmi proofs/proof_trees.cmi proofs/proof_type.cmi \ - pretyping/rawterm.cmi pretyping/reductionops.cmi proofs/refiner.cmi \ - pretyping/retyping.cmi kernel/sign.cmi proofs/tacexpr.cmo \ - proofs/tacmach.cmi kernel/term.cmi pretyping/termops.cmi \ - pretyping/typing.cmi lib/util.cmi proofs/clenv.cmi -proofs/clenv.cmx: pretyping/coercion.cmx kernel/environ.cmx \ - proofs/evar_refiner.cmx pretyping/evarutil.cmx pretyping/evd.cmx \ - library/global.cmx pretyping/instantiate.cmx proofs/logic.cmx \ - library/nameops.cmx kernel/names.cmx pretyping/pattern.cmx lib/pp.cmx \ - parsing/printer.cmx proofs/proof_trees.cmx proofs/proof_type.cmx \ - pretyping/rawterm.cmx pretyping/reductionops.cmx proofs/refiner.cmx \ - pretyping/retyping.cmx kernel/sign.cmx proofs/tacexpr.cmx \ - proofs/tacmach.cmx kernel/term.cmx pretyping/termops.cmx \ - pretyping/typing.cmx lib/util.cmx proofs/clenv.cmi -proofs/evar_refiner.cmo: interp/constrintern.cmi kernel/environ.cmi \ - pretyping/evarutil.cmi pretyping/evd.cmi library/global.cmi \ - pretyping/instantiate.cmi proofs/logic.cmi library/nameops.cmi \ - kernel/names.cmi lib/options.cmi lib/pp.cmi proofs/proof_trees.cmi \ - proofs/proof_type.cmi pretyping/reductionops.cmi proofs/refiner.cmi \ - kernel/sign.cmi proofs/tacexpr.cmo pretyping/tacred.cmi kernel/term.cmi \ - kernel/type_errors.cmi pretyping/typing.cmi lib/util.cmi \ - proofs/evar_refiner.cmi -proofs/evar_refiner.cmx: interp/constrintern.cmx kernel/environ.cmx \ - pretyping/evarutil.cmx pretyping/evd.cmx library/global.cmx \ - pretyping/instantiate.cmx proofs/logic.cmx library/nameops.cmx \ - kernel/names.cmx lib/options.cmx lib/pp.cmx proofs/proof_trees.cmx \ - proofs/proof_type.cmx pretyping/reductionops.cmx proofs/refiner.cmx \ - kernel/sign.cmx proofs/tacexpr.cmx pretyping/tacred.cmx kernel/term.cmx \ - kernel/type_errors.cmx pretyping/typing.cmx lib/util.cmx \ - proofs/evar_refiner.cmi -proofs/logic.cmo: interp/constrextern.cmi parsing/coqast.cmi \ - kernel/environ.cmi pretyping/evarutil.cmi pretyping/evd.cmi \ - library/global.cmi kernel/inductive.cmi pretyping/inductiveops.cmi \ - library/nameops.cmi kernel/names.cmi library/nametab.cmi lib/options.cmi \ - lib/pp.cmi pretyping/pretype_errors.cmi parsing/printer.cmi \ - proofs/proof_trees.cmi proofs/proof_type.cmi pretyping/reductionops.cmi \ - pretyping/retyping.cmi kernel/sign.cmi kernel/term.cmi \ - pretyping/termops.cmi kernel/type_errors.cmi kernel/typeops.cmi \ - pretyping/typing.cmi lib/util.cmi proofs/logic.cmi -proofs/logic.cmx: interp/constrextern.cmx parsing/coqast.cmx \ - kernel/environ.cmx pretyping/evarutil.cmx pretyping/evd.cmx \ - library/global.cmx kernel/inductive.cmx pretyping/inductiveops.cmx \ - library/nameops.cmx kernel/names.cmx library/nametab.cmx lib/options.cmx \ - lib/pp.cmx pretyping/pretype_errors.cmx parsing/printer.cmx \ - proofs/proof_trees.cmx proofs/proof_type.cmx pretyping/reductionops.cmx \ - pretyping/retyping.cmx kernel/sign.cmx kernel/term.cmx \ - pretyping/termops.cmx kernel/type_errors.cmx kernel/typeops.cmx \ - pretyping/typing.cmx lib/util.cmx proofs/logic.cmi -proofs/pfedit.cmo: library/decl_kinds.cmo kernel/declarations.cmi \ - lib/edit.cmi kernel/entries.cmi kernel/environ.cmi \ - proofs/evar_refiner.cmi pretyping/evd.cmi library/lib.cmi \ - library/nameops.cmi kernel/names.cmi lib/pp.cmi proofs/proof_trees.cmi \ - proofs/proof_type.cmi proofs/refiner.cmi kernel/safe_typing.cmi \ - kernel/sign.cmi proofs/tacexpr.cmo proofs/tacmach.cmi kernel/term.cmi \ - pretyping/typing.cmi lib/util.cmi proofs/pfedit.cmi -proofs/pfedit.cmx: library/decl_kinds.cmx kernel/declarations.cmx \ - lib/edit.cmx kernel/entries.cmx kernel/environ.cmx \ - proofs/evar_refiner.cmx pretyping/evd.cmx library/lib.cmx \ - library/nameops.cmx kernel/names.cmx lib/pp.cmx proofs/proof_trees.cmx \ - proofs/proof_type.cmx proofs/refiner.cmx kernel/safe_typing.cmx \ - kernel/sign.cmx proofs/tacexpr.cmx proofs/tacmach.cmx kernel/term.cmx \ - pretyping/typing.cmx lib/util.cmx proofs/pfedit.cmi -proofs/proof_trees.cmo: kernel/closure.cmi pretyping/detyping.cmi \ - kernel/environ.cmi pretyping/evarutil.cmi pretyping/evd.cmi \ - library/global.cmi library/libnames.cmi library/nameops.cmi \ - kernel/names.cmi library/nametab.cmi lib/pp.cmi parsing/printer.cmi \ - proofs/proof_type.cmi kernel/sign.cmi pretyping/tacred.cmi \ - kernel/term.cmi pretyping/termops.cmi pretyping/typing.cmi lib/util.cmi \ - proofs/proof_trees.cmi -proofs/proof_trees.cmx: kernel/closure.cmx pretyping/detyping.cmx \ - kernel/environ.cmx pretyping/evarutil.cmx pretyping/evd.cmx \ - library/global.cmx library/libnames.cmx library/nameops.cmx \ - kernel/names.cmx library/nametab.cmx lib/pp.cmx parsing/printer.cmx \ - proofs/proof_type.cmx kernel/sign.cmx pretyping/tacred.cmx \ - kernel/term.cmx pretyping/termops.cmx pretyping/typing.cmx lib/util.cmx \ - proofs/proof_trees.cmi -proofs/proof_type.cmo: kernel/environ.cmi pretyping/evd.cmi interp/genarg.cmi \ - library/libnames.cmi kernel/names.cmi library/nametab.cmi \ - pretyping/pattern.cmi pretyping/rawterm.cmi proofs/tacexpr.cmo \ - kernel/term.cmi lib/util.cmi proofs/proof_type.cmi -proofs/proof_type.cmx: kernel/environ.cmx pretyping/evd.cmx interp/genarg.cmx \ - library/libnames.cmx kernel/names.cmx library/nametab.cmx \ - pretyping/pattern.cmx pretyping/rawterm.cmx proofs/tacexpr.cmx \ - kernel/term.cmx lib/util.cmx proofs/proof_type.cmi -proofs/refiner.cmo: kernel/environ.cmi pretyping/evarutil.cmi \ - pretyping/evd.cmi library/global.cmi pretyping/instantiate.cmi \ - proofs/logic.cmi lib/options.cmi lib/pp.cmi parsing/pptactic.cmi \ - translate/pptacticnew.cmi parsing/printer.cmi proofs/proof_trees.cmi \ - proofs/proof_type.cmi pretyping/reductionops.cmi kernel/sign.cmi \ - proofs/tacexpr.cmo kernel/term.cmi pretyping/termops.cmi \ - kernel/type_errors.cmi lib/util.cmi proofs/refiner.cmi -proofs/refiner.cmx: kernel/environ.cmx pretyping/evarutil.cmx \ - pretyping/evd.cmx library/global.cmx pretyping/instantiate.cmx \ - proofs/logic.cmx lib/options.cmx lib/pp.cmx parsing/pptactic.cmx \ - translate/pptacticnew.cmx parsing/printer.cmx proofs/proof_trees.cmx \ - proofs/proof_type.cmx pretyping/reductionops.cmx kernel/sign.cmx \ - proofs/tacexpr.cmx kernel/term.cmx pretyping/termops.cmx \ - kernel/type_errors.cmx lib/util.cmx proofs/refiner.cmi -proofs/tacexpr.cmo: library/decl_kinds.cmo lib/dyn.cmi interp/genarg.cmi \ - library/libnames.cmi kernel/names.cmi library/nametab.cmi \ - pretyping/pattern.cmi pretyping/rawterm.cmi kernel/term.cmi \ - interp/topconstr.cmi lib/util.cmi -proofs/tacexpr.cmx: library/decl_kinds.cmx lib/dyn.cmx interp/genarg.cmx \ - library/libnames.cmx kernel/names.cmx library/nametab.cmx \ - pretyping/pattern.cmx pretyping/rawterm.cmx kernel/term.cmx \ - interp/topconstr.cmx lib/util.cmx -proofs/tacmach.cmo: interp/constrintern.cmi kernel/environ.cmi \ - pretyping/evd.cmi library/global.cmi pretyping/instantiate.cmi \ - proofs/logic.cmi library/nameops.cmi kernel/names.cmi lib/pp.cmi \ - parsing/printer.cmi proofs/proof_trees.cmi proofs/proof_type.cmi \ - pretyping/rawterm.cmi pretyping/reductionops.cmi proofs/refiner.cmi \ - kernel/sign.cmi proofs/tacexpr.cmo pretyping/tacred.cmi kernel/term.cmi \ - pretyping/termops.cmi pretyping/typing.cmi lib/util.cmi \ - proofs/tacmach.cmi -proofs/tacmach.cmx: interp/constrintern.cmx kernel/environ.cmx \ - pretyping/evd.cmx library/global.cmx pretyping/instantiate.cmx \ - proofs/logic.cmx library/nameops.cmx kernel/names.cmx lib/pp.cmx \ - parsing/printer.cmx proofs/proof_trees.cmx proofs/proof_type.cmx \ - pretyping/rawterm.cmx pretyping/reductionops.cmx proofs/refiner.cmx \ - kernel/sign.cmx proofs/tacexpr.cmx pretyping/tacred.cmx kernel/term.cmx \ - pretyping/termops.cmx pretyping/typing.cmx lib/util.cmx \ - proofs/tacmach.cmi -proofs/tactic_debug.cmo: parsing/ast.cmi interp/constrextern.cmi \ - library/global.cmi proofs/logic.cmi kernel/names.cmi lib/options.cmi \ - lib/pp.cmi parsing/pptactic.cmi translate/pptacticnew.cmi \ - parsing/printer.cmi proofs/proof_trees.cmi proofs/tacexpr.cmo \ - proofs/tacmach.cmi pretyping/termops.cmi proofs/tactic_debug.cmi -proofs/tactic_debug.cmx: parsing/ast.cmx interp/constrextern.cmx \ - library/global.cmx proofs/logic.cmx kernel/names.cmx lib/options.cmx \ - lib/pp.cmx parsing/pptactic.cmx translate/pptacticnew.cmx \ - parsing/printer.cmx proofs/proof_trees.cmx proofs/tacexpr.cmx \ - proofs/tacmach.cmx pretyping/termops.cmx proofs/tactic_debug.cmi -scripts/coqc.cmo: config/coq_config.cmi toplevel/usage.cmi -scripts/coqc.cmx: config/coq_config.cmx toplevel/usage.cmx -scripts/coqmktop.cmo: config/coq_config.cmi scripts/tolink.cmo -scripts/coqmktop.cmx: config/coq_config.cmx scripts/tolink.cmx -tactics/auto.cmo: tactics/btermdn.cmi proofs/clenv.cmi \ - interp/constrintern.cmi kernel/declarations.cmi tactics/dhyp.cmi \ - proofs/evar_refiner.cmi pretyping/evd.cmi library/global.cmi \ - tactics/hiddentac.cmi tactics/hipattern.cmi kernel/inductive.cmi \ - library/lib.cmi library/libnames.cmi library/libobject.cmi \ - library/library.cmi proofs/logic.cmi pretyping/matching.cmi \ - library/nameops.cmi kernel/names.cmi library/nametab.cmi lib/options.cmi \ - pretyping/pattern.cmi proofs/pfedit.cmi lib/pp.cmi parsing/pptactic.cmi \ - parsing/printer.cmi proofs/proof_type.cmi pretyping/rawterm.cmi \ - kernel/reduction.cmi proofs/refiner.cmi kernel/sign.cmi \ - library/summary.cmi proofs/tacexpr.cmo proofs/tacmach.cmi \ - pretyping/tacred.cmi tactics/tacticals.cmi tactics/tactics.cmi \ - kernel/term.cmi pretyping/termops.cmi pretyping/typing.cmi lib/util.cmi \ - toplevel/vernacexpr.cmo tactics/auto.cmi -tactics/auto.cmx: tactics/btermdn.cmx proofs/clenv.cmx \ - interp/constrintern.cmx kernel/declarations.cmx tactics/dhyp.cmx \ - proofs/evar_refiner.cmx pretyping/evd.cmx library/global.cmx \ - tactics/hiddentac.cmx tactics/hipattern.cmx kernel/inductive.cmx \ - library/lib.cmx library/libnames.cmx library/libobject.cmx \ - library/library.cmx proofs/logic.cmx pretyping/matching.cmx \ - library/nameops.cmx kernel/names.cmx library/nametab.cmx lib/options.cmx \ - pretyping/pattern.cmx proofs/pfedit.cmx lib/pp.cmx parsing/pptactic.cmx \ - parsing/printer.cmx proofs/proof_type.cmx pretyping/rawterm.cmx \ - kernel/reduction.cmx proofs/refiner.cmx kernel/sign.cmx \ - library/summary.cmx proofs/tacexpr.cmx proofs/tacmach.cmx \ - pretyping/tacred.cmx tactics/tacticals.cmx tactics/tactics.cmx \ - kernel/term.cmx pretyping/termops.cmx pretyping/typing.cmx lib/util.cmx \ - toplevel/vernacexpr.cmx tactics/auto.cmi -tactics/autorewrite.cmo: parsing/ast.cmi parsing/coqast.cmi \ - tactics/equality.cmi tactics/hipattern.cmi library/lib.cmi \ - library/libobject.cmi kernel/names.cmi lib/pp.cmi proofs/proof_type.cmi \ - library/summary.cmi proofs/tacexpr.cmo tactics/tacinterp.cmi \ - tactics/tacticals.cmi tactics/tactics.cmi kernel/term.cmi lib/util.cmi \ - toplevel/vernacinterp.cmi tactics/autorewrite.cmi -tactics/autorewrite.cmx: parsing/ast.cmx parsing/coqast.cmx \ - tactics/equality.cmx tactics/hipattern.cmx library/lib.cmx \ - library/libobject.cmx kernel/names.cmx lib/pp.cmx proofs/proof_type.cmx \ - library/summary.cmx proofs/tacexpr.cmx tactics/tacinterp.cmx \ - tactics/tacticals.cmx tactics/tactics.cmx kernel/term.cmx lib/util.cmx \ - toplevel/vernacinterp.cmx tactics/autorewrite.cmi -tactics/btermdn.cmo: tactics/dn.cmi pretyping/pattern.cmi kernel/term.cmi \ - tactics/termdn.cmi tactics/btermdn.cmi -tactics/btermdn.cmx: tactics/dn.cmx pretyping/pattern.cmx kernel/term.cmx \ - tactics/termdn.cmx tactics/btermdn.cmi -tactics/contradiction.cmo: interp/coqlib.cmi tactics/hipattern.cmi \ - proofs/proof_type.cmi pretyping/rawterm.cmi pretyping/reductionops.cmi \ - proofs/tacmach.cmi tactics/tacticals.cmi tactics/tactics.cmi \ - kernel/term.cmi lib/util.cmi tactics/contradiction.cmi -tactics/contradiction.cmx: interp/coqlib.cmx tactics/hipattern.cmx \ - proofs/proof_type.cmx pretyping/rawterm.cmx pretyping/reductionops.cmx \ - proofs/tacmach.cmx tactics/tacticals.cmx tactics/tactics.cmx \ - kernel/term.cmx lib/util.cmx tactics/contradiction.cmi -tactics/dhyp.cmo: parsing/ast.cmi proofs/clenv.cmi interp/constrintern.cmi \ - kernel/environ.cmi pretyping/evd.cmi library/global.cmi library/lib.cmi \ - library/libnames.cmi library/libobject.cmi library/library.cmi \ - pretyping/matching.cmi kernel/names.cmi tactics/nbtermdn.cmi \ - pretyping/pattern.cmi parsing/pcoq.cmi lib/pp.cmi proofs/proof_type.cmi \ - pretyping/rawterm.cmi kernel/reduction.cmi proofs/refiner.cmi \ - library/summary.cmi proofs/tacexpr.cmo proofs/tacmach.cmi \ - tactics/tacticals.cmi tactics/tactics.cmi kernel/term.cmi lib/util.cmi \ - tactics/dhyp.cmi -tactics/dhyp.cmx: parsing/ast.cmx proofs/clenv.cmx interp/constrintern.cmx \ - kernel/environ.cmx pretyping/evd.cmx library/global.cmx library/lib.cmx \ - library/libnames.cmx library/libobject.cmx library/library.cmx \ - pretyping/matching.cmx kernel/names.cmx tactics/nbtermdn.cmx \ - pretyping/pattern.cmx parsing/pcoq.cmx lib/pp.cmx proofs/proof_type.cmx \ - pretyping/rawterm.cmx kernel/reduction.cmx proofs/refiner.cmx \ - library/summary.cmx proofs/tacexpr.cmx proofs/tacmach.cmx \ - tactics/tacticals.cmx tactics/tactics.cmx kernel/term.cmx lib/util.cmx \ - tactics/dhyp.cmi +pretyping/retyping.cmo: lib/util.cmi kernel/univ.cmi kernel/typeops.cmi \ + kernel/term.cmi pretyping/reductionops.cmi kernel/names.cmi \ + pretyping/instantiate.cmi pretyping/inductiveops.cmi kernel/inductive.cmi \ + kernel/environ.cmi kernel/declarations.cmi pretyping/retyping.cmi +pretyping/retyping.cmx: lib/util.cmx kernel/univ.cmx kernel/typeops.cmx \ + kernel/term.cmx pretyping/reductionops.cmx kernel/names.cmx \ + pretyping/instantiate.cmx pretyping/inductiveops.cmx kernel/inductive.cmx \ + kernel/environ.cmx kernel/declarations.cmx pretyping/retyping.cmi +pretyping/tacred.cmo: lib/util.cmi pretyping/typing.cmi pretyping/termops.cmi \ + kernel/term.cmi library/summary.cmi pretyping/retyping.cmi \ + pretyping/reductionops.cmi pretyping/rawterm.cmi lib/pp.cmi \ + library/nametab.cmi kernel/names.cmi library/nameops.cmi \ + library/libnames.cmi pretyping/instantiate.cmi kernel/inductive.cmi \ + library/global.cmi pretyping/evd.cmi kernel/environ.cmi \ + kernel/declarations.cmi kernel/conv_oracle.cmi kernel/closure.cmi \ + pretyping/cbv.cmi pretyping/tacred.cmi +pretyping/tacred.cmx: lib/util.cmx pretyping/typing.cmx pretyping/termops.cmx \ + kernel/term.cmx library/summary.cmx pretyping/retyping.cmx \ + pretyping/reductionops.cmx pretyping/rawterm.cmx lib/pp.cmx \ + library/nametab.cmx kernel/names.cmx library/nameops.cmx \ + library/libnames.cmx pretyping/instantiate.cmx kernel/inductive.cmx \ + library/global.cmx pretyping/evd.cmx kernel/environ.cmx \ + kernel/declarations.cmx kernel/conv_oracle.cmx kernel/closure.cmx \ + pretyping/cbv.cmx pretyping/tacred.cmi +pretyping/termops.cmo: lib/util.cmi kernel/univ.cmi kernel/term.cmi \ + kernel/sign.cmi lib/pp.cmi library/nametab.cmi kernel/names.cmi \ + library/nameops.cmi library/libnames.cmi library/lib.cmi \ + library/global.cmi kernel/environ.cmi pretyping/termops.cmi +pretyping/termops.cmx: lib/util.cmx kernel/univ.cmx kernel/term.cmx \ + kernel/sign.cmx lib/pp.cmx library/nametab.cmx kernel/names.cmx \ + library/nameops.cmx library/libnames.cmx library/lib.cmx \ + library/global.cmx kernel/environ.cmx pretyping/termops.cmi +pretyping/typing.cmo: lib/util.cmi kernel/typeops.cmi kernel/type_errors.cmi \ + kernel/term.cmi pretyping/reductionops.cmi pretyping/pretype_errors.cmi \ + kernel/names.cmi pretyping/instantiate.cmi kernel/inductive.cmi \ + kernel/environ.cmi pretyping/typing.cmi +pretyping/typing.cmx: lib/util.cmx kernel/typeops.cmx kernel/type_errors.cmx \ + kernel/term.cmx pretyping/reductionops.cmx pretyping/pretype_errors.cmx \ + kernel/names.cmx pretyping/instantiate.cmx kernel/inductive.cmx \ + kernel/environ.cmx pretyping/typing.cmi +proofs/clenv.cmo: lib/util.cmi pretyping/typing.cmi pretyping/termops.cmi \ + kernel/term.cmi proofs/tacmach.cmi proofs/tacexpr.cmo kernel/sign.cmi \ + pretyping/retyping.cmi proofs/refiner.cmi pretyping/reductionops.cmi \ + pretyping/rawterm.cmi proofs/proof_type.cmi proofs/proof_trees.cmi \ + parsing/printer.cmi lib/pp.cmi pretyping/pattern.cmi kernel/names.cmi \ + library/nameops.cmi proofs/logic.cmi pretyping/instantiate.cmi \ + library/global.cmi pretyping/evd.cmi pretyping/evarutil.cmi \ + proofs/evar_refiner.cmi kernel/environ.cmi pretyping/coercion.cmi \ + proofs/clenv.cmi +proofs/clenv.cmx: lib/util.cmx pretyping/typing.cmx pretyping/termops.cmx \ + kernel/term.cmx proofs/tacmach.cmx proofs/tacexpr.cmx kernel/sign.cmx \ + pretyping/retyping.cmx proofs/refiner.cmx pretyping/reductionops.cmx \ + pretyping/rawterm.cmx proofs/proof_type.cmx proofs/proof_trees.cmx \ + parsing/printer.cmx lib/pp.cmx pretyping/pattern.cmx kernel/names.cmx \ + library/nameops.cmx proofs/logic.cmx pretyping/instantiate.cmx \ + library/global.cmx pretyping/evd.cmx pretyping/evarutil.cmx \ + proofs/evar_refiner.cmx kernel/environ.cmx pretyping/coercion.cmx \ + proofs/clenv.cmi +proofs/evar_refiner.cmo: lib/util.cmi pretyping/typing.cmi \ + kernel/type_errors.cmi kernel/term.cmi pretyping/tacred.cmi \ + proofs/tacexpr.cmo kernel/sign.cmi proofs/refiner.cmi \ + pretyping/reductionops.cmi proofs/proof_type.cmi proofs/proof_trees.cmi \ + lib/pp.cmi lib/options.cmi kernel/names.cmi library/nameops.cmi \ + proofs/logic.cmi pretyping/instantiate.cmi library/global.cmi \ + pretyping/evd.cmi pretyping/evarutil.cmi kernel/environ.cmi \ + interp/constrintern.cmi proofs/evar_refiner.cmi +proofs/evar_refiner.cmx: lib/util.cmx pretyping/typing.cmx \ + kernel/type_errors.cmx kernel/term.cmx pretyping/tacred.cmx \ + proofs/tacexpr.cmx kernel/sign.cmx proofs/refiner.cmx \ + pretyping/reductionops.cmx proofs/proof_type.cmx proofs/proof_trees.cmx \ + lib/pp.cmx lib/options.cmx kernel/names.cmx library/nameops.cmx \ + proofs/logic.cmx pretyping/instantiate.cmx library/global.cmx \ + pretyping/evd.cmx pretyping/evarutil.cmx kernel/environ.cmx \ + interp/constrintern.cmx proofs/evar_refiner.cmi +proofs/logic.cmo: lib/util.cmi pretyping/typing.cmi kernel/typeops.cmi \ + kernel/type_errors.cmi pretyping/termops.cmi kernel/term.cmi \ + kernel/sign.cmi pretyping/retyping.cmi pretyping/reductionops.cmi \ + proofs/proof_type.cmi proofs/proof_trees.cmi parsing/printer.cmi \ + pretyping/pretype_errors.cmi lib/pp.cmi lib/options.cmi \ + library/nametab.cmi kernel/names.cmi library/nameops.cmi \ + pretyping/inductiveops.cmi kernel/inductive.cmi library/global.cmi \ + pretyping/evd.cmi pretyping/evarutil.cmi kernel/environ.cmi \ + parsing/coqast.cmi interp/constrextern.cmi proofs/logic.cmi +proofs/logic.cmx: lib/util.cmx pretyping/typing.cmx kernel/typeops.cmx \ + kernel/type_errors.cmx pretyping/termops.cmx kernel/term.cmx \ + kernel/sign.cmx pretyping/retyping.cmx pretyping/reductionops.cmx \ + proofs/proof_type.cmx proofs/proof_trees.cmx parsing/printer.cmx \ + pretyping/pretype_errors.cmx lib/pp.cmx lib/options.cmx \ + library/nametab.cmx kernel/names.cmx library/nameops.cmx \ + pretyping/inductiveops.cmx kernel/inductive.cmx library/global.cmx \ + pretyping/evd.cmx pretyping/evarutil.cmx kernel/environ.cmx \ + parsing/coqast.cmx interp/constrextern.cmx proofs/logic.cmi +proofs/pfedit.cmo: lib/util.cmi pretyping/typing.cmi kernel/term.cmi \ + proofs/tacmach.cmi proofs/tacexpr.cmo kernel/sign.cmi \ + kernel/safe_typing.cmi proofs/refiner.cmi proofs/proof_type.cmi \ + proofs/proof_trees.cmi lib/pp.cmi kernel/names.cmi library/nameops.cmi \ + library/lib.cmi pretyping/evd.cmi proofs/evar_refiner.cmi \ + kernel/environ.cmi kernel/entries.cmi lib/edit.cmi \ + kernel/declarations.cmi library/decl_kinds.cmo proofs/pfedit.cmi +proofs/pfedit.cmx: lib/util.cmx pretyping/typing.cmx kernel/term.cmx \ + proofs/tacmach.cmx proofs/tacexpr.cmx kernel/sign.cmx \ + kernel/safe_typing.cmx proofs/refiner.cmx proofs/proof_type.cmx \ + proofs/proof_trees.cmx lib/pp.cmx kernel/names.cmx library/nameops.cmx \ + library/lib.cmx pretyping/evd.cmx proofs/evar_refiner.cmx \ + kernel/environ.cmx kernel/entries.cmx lib/edit.cmx \ + kernel/declarations.cmx library/decl_kinds.cmx proofs/pfedit.cmi +proofs/proof_trees.cmo: lib/util.cmi pretyping/typing.cmi \ + pretyping/termops.cmi kernel/term.cmi pretyping/tacred.cmi \ + kernel/sign.cmi proofs/proof_type.cmi parsing/printer.cmi lib/pp.cmi \ + library/nametab.cmi kernel/names.cmi library/nameops.cmi \ + library/libnames.cmi library/global.cmi pretyping/evd.cmi \ + pretyping/evarutil.cmi kernel/environ.cmi pretyping/detyping.cmi \ + kernel/closure.cmi proofs/proof_trees.cmi +proofs/proof_trees.cmx: lib/util.cmx pretyping/typing.cmx \ + pretyping/termops.cmx kernel/term.cmx pretyping/tacred.cmx \ + kernel/sign.cmx proofs/proof_type.cmx parsing/printer.cmx lib/pp.cmx \ + library/nametab.cmx kernel/names.cmx library/nameops.cmx \ + library/libnames.cmx library/global.cmx pretyping/evd.cmx \ + pretyping/evarutil.cmx kernel/environ.cmx pretyping/detyping.cmx \ + kernel/closure.cmx proofs/proof_trees.cmi +proofs/proof_type.cmo: lib/util.cmi kernel/term.cmi proofs/tacexpr.cmo \ + pretyping/rawterm.cmi pretyping/pattern.cmi library/nametab.cmi \ + kernel/names.cmi library/libnames.cmi interp/genarg.cmi pretyping/evd.cmi \ + kernel/environ.cmi proofs/proof_type.cmi +proofs/proof_type.cmx: lib/util.cmx kernel/term.cmx proofs/tacexpr.cmx \ + pretyping/rawterm.cmx pretyping/pattern.cmx library/nametab.cmx \ + kernel/names.cmx library/libnames.cmx interp/genarg.cmx pretyping/evd.cmx \ + kernel/environ.cmx proofs/proof_type.cmi +proofs/refiner.cmo: lib/util.cmi kernel/type_errors.cmi pretyping/termops.cmi \ + kernel/term.cmi proofs/tacexpr.cmo kernel/sign.cmi \ + pretyping/reductionops.cmi proofs/proof_type.cmi proofs/proof_trees.cmi \ + parsing/printer.cmi translate/pptacticnew.cmi parsing/pptactic.cmi \ + lib/pp.cmi lib/options.cmi proofs/logic.cmi pretyping/instantiate.cmi \ + library/global.cmi pretyping/evd.cmi pretyping/evarutil.cmi \ + kernel/environ.cmi proofs/refiner.cmi +proofs/refiner.cmx: lib/util.cmx kernel/type_errors.cmx pretyping/termops.cmx \ + kernel/term.cmx proofs/tacexpr.cmx kernel/sign.cmx \ + pretyping/reductionops.cmx proofs/proof_type.cmx proofs/proof_trees.cmx \ + parsing/printer.cmx translate/pptacticnew.cmx parsing/pptactic.cmx \ + lib/pp.cmx lib/options.cmx proofs/logic.cmx pretyping/instantiate.cmx \ + library/global.cmx pretyping/evd.cmx pretyping/evarutil.cmx \ + kernel/environ.cmx proofs/refiner.cmi +proofs/tacexpr.cmo: lib/util.cmi interp/topconstr.cmi kernel/term.cmi \ + pretyping/rawterm.cmi pretyping/pattern.cmi library/nametab.cmi \ + kernel/names.cmi library/libnames.cmi interp/genarg.cmi lib/dyn.cmi \ + library/decl_kinds.cmo +proofs/tacexpr.cmx: lib/util.cmx interp/topconstr.cmx kernel/term.cmx \ + pretyping/rawterm.cmx pretyping/pattern.cmx library/nametab.cmx \ + kernel/names.cmx library/libnames.cmx interp/genarg.cmx lib/dyn.cmx \ + library/decl_kinds.cmx +proofs/tacmach.cmo: lib/util.cmi pretyping/typing.cmi pretyping/termops.cmi \ + kernel/term.cmi pretyping/tacred.cmi proofs/tacexpr.cmo kernel/sign.cmi \ + proofs/refiner.cmi pretyping/reductionops.cmi pretyping/rawterm.cmi \ + proofs/proof_type.cmi proofs/proof_trees.cmi parsing/printer.cmi \ + lib/pp.cmi kernel/names.cmi library/nameops.cmi proofs/logic.cmi \ + pretyping/instantiate.cmi library/global.cmi pretyping/evd.cmi \ + kernel/environ.cmi interp/constrintern.cmi proofs/tacmach.cmi +proofs/tacmach.cmx: lib/util.cmx pretyping/typing.cmx pretyping/termops.cmx \ + kernel/term.cmx pretyping/tacred.cmx proofs/tacexpr.cmx kernel/sign.cmx \ + proofs/refiner.cmx pretyping/reductionops.cmx pretyping/rawterm.cmx \ + proofs/proof_type.cmx proofs/proof_trees.cmx parsing/printer.cmx \ + lib/pp.cmx kernel/names.cmx library/nameops.cmx proofs/logic.cmx \ + pretyping/instantiate.cmx library/global.cmx pretyping/evd.cmx \ + kernel/environ.cmx interp/constrintern.cmx proofs/tacmach.cmi +proofs/tactic_debug.cmo: pretyping/termops.cmi proofs/tacmach.cmi \ + proofs/tacexpr.cmo proofs/proof_trees.cmi parsing/printer.cmi \ + translate/pptacticnew.cmi parsing/pptactic.cmi lib/pp.cmi lib/options.cmi \ + kernel/names.cmi proofs/logic.cmi library/global.cmi \ + interp/constrextern.cmi parsing/ast.cmi proofs/tactic_debug.cmi +proofs/tactic_debug.cmx: pretyping/termops.cmx proofs/tacmach.cmx \ + proofs/tacexpr.cmx proofs/proof_trees.cmx parsing/printer.cmx \ + translate/pptacticnew.cmx parsing/pptactic.cmx lib/pp.cmx lib/options.cmx \ + kernel/names.cmx proofs/logic.cmx library/global.cmx \ + interp/constrextern.cmx parsing/ast.cmx proofs/tactic_debug.cmi +scripts/coqc.cmo: toplevel/usage.cmi config/coq_config.cmi +scripts/coqc.cmx: toplevel/usage.cmx config/coq_config.cmx +scripts/coqmktop.cmo: scripts/tolink.cmo config/coq_config.cmi +scripts/coqmktop.cmx: scripts/tolink.cmx config/coq_config.cmx +tactics/auto.cmo: toplevel/vernacexpr.cmo lib/util.cmi pretyping/typing.cmi \ + pretyping/termops.cmi kernel/term.cmi tactics/tactics.cmi \ + tactics/tacticals.cmi pretyping/tacred.cmi proofs/tacmach.cmi \ + proofs/tacexpr.cmo library/summary.cmi kernel/sign.cmi proofs/refiner.cmi \ + kernel/reduction.cmi pretyping/rawterm.cmi proofs/proof_type.cmi \ + parsing/printer.cmi translate/pptacticnew.cmi parsing/pptactic.cmi \ + lib/pp.cmi proofs/pfedit.cmi pretyping/pattern.cmi lib/options.cmi \ + library/nametab.cmi kernel/names.cmi library/nameops.cmi \ + pretyping/matching.cmi proofs/logic.cmi library/library.cmi \ + library/libobject.cmi library/libnames.cmi library/lib.cmi \ + kernel/inductive.cmi tactics/hipattern.cmi tactics/hiddentac.cmi \ + library/global.cmi pretyping/evd.cmi proofs/evar_refiner.cmi \ + tactics/dhyp.cmi kernel/declarations.cmi interp/constrintern.cmi \ + proofs/clenv.cmi tactics/btermdn.cmi tactics/auto.cmi +tactics/auto.cmx: toplevel/vernacexpr.cmx lib/util.cmx pretyping/typing.cmx \ + pretyping/termops.cmx kernel/term.cmx tactics/tactics.cmx \ + tactics/tacticals.cmx pretyping/tacred.cmx proofs/tacmach.cmx \ + proofs/tacexpr.cmx library/summary.cmx kernel/sign.cmx proofs/refiner.cmx \ + kernel/reduction.cmx pretyping/rawterm.cmx proofs/proof_type.cmx \ + parsing/printer.cmx translate/pptacticnew.cmx parsing/pptactic.cmx \ + lib/pp.cmx proofs/pfedit.cmx pretyping/pattern.cmx lib/options.cmx \ + library/nametab.cmx kernel/names.cmx library/nameops.cmx \ + pretyping/matching.cmx proofs/logic.cmx library/library.cmx \ + library/libobject.cmx library/libnames.cmx library/lib.cmx \ + kernel/inductive.cmx tactics/hipattern.cmx tactics/hiddentac.cmx \ + library/global.cmx pretyping/evd.cmx proofs/evar_refiner.cmx \ + tactics/dhyp.cmx kernel/declarations.cmx interp/constrintern.cmx \ + proofs/clenv.cmx tactics/btermdn.cmx tactics/auto.cmi +tactics/autorewrite.cmo: toplevel/vernacinterp.cmi lib/util.cmi \ + kernel/term.cmi tactics/tactics.cmi tactics/tacticals.cmi \ + tactics/tacinterp.cmi proofs/tacexpr.cmo library/summary.cmi \ + proofs/proof_type.cmi lib/pp.cmi kernel/names.cmi library/libobject.cmi \ + library/lib.cmi tactics/hipattern.cmi tactics/equality.cmi \ + parsing/coqast.cmi parsing/ast.cmi tactics/autorewrite.cmi +tactics/autorewrite.cmx: toplevel/vernacinterp.cmx lib/util.cmx \ + kernel/term.cmx tactics/tactics.cmx tactics/tacticals.cmx \ + tactics/tacinterp.cmx proofs/tacexpr.cmx library/summary.cmx \ + proofs/proof_type.cmx lib/pp.cmx kernel/names.cmx library/libobject.cmx \ + library/lib.cmx tactics/hipattern.cmx tactics/equality.cmx \ + parsing/coqast.cmx parsing/ast.cmx tactics/autorewrite.cmi +tactics/btermdn.cmo: tactics/termdn.cmi kernel/term.cmi pretyping/pattern.cmi \ + tactics/dn.cmi tactics/btermdn.cmi +tactics/btermdn.cmx: tactics/termdn.cmx kernel/term.cmx pretyping/pattern.cmx \ + tactics/dn.cmx tactics/btermdn.cmi +tactics/contradiction.cmo: lib/util.cmi kernel/term.cmi tactics/tactics.cmi \ + tactics/tacticals.cmi proofs/tacmach.cmi pretyping/reductionops.cmi \ + pretyping/rawterm.cmi proofs/proof_type.cmi tactics/hipattern.cmi \ + interp/coqlib.cmi tactics/contradiction.cmi +tactics/contradiction.cmx: lib/util.cmx kernel/term.cmx tactics/tactics.cmx \ + tactics/tacticals.cmx proofs/tacmach.cmx pretyping/reductionops.cmx \ + pretyping/rawterm.cmx proofs/proof_type.cmx tactics/hipattern.cmx \ + interp/coqlib.cmx tactics/contradiction.cmi +tactics/dhyp.cmo: lib/util.cmi kernel/term.cmi tactics/tactics.cmi \ + tactics/tacticals.cmi proofs/tacmach.cmi proofs/tacexpr.cmo \ + library/summary.cmi proofs/refiner.cmi kernel/reduction.cmi \ + pretyping/rawterm.cmi proofs/proof_type.cmi lib/pp.cmi parsing/pcoq.cmi \ + pretyping/pattern.cmi tactics/nbtermdn.cmi kernel/names.cmi \ + pretyping/matching.cmi library/library.cmi library/libobject.cmi \ + library/libnames.cmi library/lib.cmi library/global.cmi pretyping/evd.cmi \ + kernel/environ.cmi interp/constrintern.cmi proofs/clenv.cmi \ + parsing/ast.cmi tactics/dhyp.cmi +tactics/dhyp.cmx: lib/util.cmx kernel/term.cmx tactics/tactics.cmx \ + tactics/tacticals.cmx proofs/tacmach.cmx proofs/tacexpr.cmx \ + library/summary.cmx proofs/refiner.cmx kernel/reduction.cmx \ + pretyping/rawterm.cmx proofs/proof_type.cmx lib/pp.cmx parsing/pcoq.cmx \ + pretyping/pattern.cmx tactics/nbtermdn.cmx kernel/names.cmx \ + pretyping/matching.cmx library/library.cmx library/libobject.cmx \ + library/libnames.cmx library/lib.cmx library/global.cmx pretyping/evd.cmx \ + kernel/environ.cmx interp/constrintern.cmx proofs/clenv.cmx \ + parsing/ast.cmx tactics/dhyp.cmi tactics/dn.cmo: lib/tlm.cmi tactics/dn.cmi tactics/dn.cmx: lib/tlm.cmx tactics/dn.cmi -tactics/eauto.cmo: tactics/auto.cmi toplevel/cerrors.cmi proofs/clenv.cmi \ - kernel/declarations.cmi parsing/egrammar.cmi proofs/evar_refiner.cmi \ - lib/explore.cmi parsing/extend.cmi interp/genarg.cmi library/global.cmi \ - proofs/logic.cmi library/nameops.cmi kernel/names.cmi lib/options.cmi \ - pretyping/pattern.cmi parsing/pcoq.cmi lib/pp.cmi parsing/pptactic.cmi \ - proofs/proof_trees.cmi proofs/proof_type.cmi pretyping/rawterm.cmi \ - kernel/reduction.cmi proofs/refiner.cmi kernel/sign.cmi \ - proofs/tacexpr.cmo tactics/tacinterp.cmi proofs/tacmach.cmi \ - tactics/tacticals.cmi tactics/tactics.cmi kernel/term.cmi \ - pretyping/termops.cmi lib/util.cmi tactics/eauto.cmi -tactics/eauto.cmx: tactics/auto.cmx toplevel/cerrors.cmx proofs/clenv.cmx \ - kernel/declarations.cmx parsing/egrammar.cmx proofs/evar_refiner.cmx \ - lib/explore.cmx parsing/extend.cmx interp/genarg.cmx library/global.cmx \ - proofs/logic.cmx library/nameops.cmx kernel/names.cmx lib/options.cmx \ - pretyping/pattern.cmx parsing/pcoq.cmx lib/pp.cmx parsing/pptactic.cmx \ - proofs/proof_trees.cmx proofs/proof_type.cmx pretyping/rawterm.cmx \ - kernel/reduction.cmx proofs/refiner.cmx kernel/sign.cmx \ - proofs/tacexpr.cmx tactics/tacinterp.cmx proofs/tacmach.cmx \ - tactics/tacticals.cmx tactics/tactics.cmx kernel/term.cmx \ - pretyping/termops.cmx lib/util.cmx tactics/eauto.cmi -tactics/elim.cmo: proofs/clenv.cmi kernel/environ.cmi interp/genarg.cmi \ - tactics/hiddentac.cmi tactics/hipattern.cmi pretyping/inductiveops.cmi \ - library/libnames.cmi kernel/names.cmi lib/pp.cmi parsing/printer.cmi \ - proofs/proof_type.cmi kernel/reduction.cmi proofs/refiner.cmi \ - proofs/tacexpr.cmo proofs/tacmach.cmi tactics/tacticals.cmi \ - tactics/tactics.cmi kernel/term.cmi pretyping/termops.cmi lib/util.cmi \ - tactics/elim.cmi -tactics/elim.cmx: proofs/clenv.cmx kernel/environ.cmx interp/genarg.cmx \ - tactics/hiddentac.cmx tactics/hipattern.cmx pretyping/inductiveops.cmx \ - library/libnames.cmx kernel/names.cmx lib/pp.cmx parsing/printer.cmx \ - proofs/proof_type.cmx kernel/reduction.cmx proofs/refiner.cmx \ - proofs/tacexpr.cmx proofs/tacmach.cmx tactics/tacticals.cmx \ - tactics/tactics.cmx kernel/term.cmx pretyping/termops.cmx lib/util.cmx \ - tactics/elim.cmi -tactics/eqdecide.cmo: tactics/auto.cmi toplevel/cerrors.cmi interp/coqlib.cmi \ - kernel/declarations.cmi parsing/egrammar.cmi tactics/equality.cmi \ - tactics/extratactics.cmi interp/genarg.cmi library/global.cmi \ - tactics/hiddentac.cmi tactics/hipattern.cmi pretyping/matching.cmi \ - library/nameops.cmi kernel/names.cmi lib/options.cmi \ - pretyping/pattern.cmi parsing/pcoq.cmi lib/pp.cmi parsing/pptactic.cmi \ - proofs/proof_trees.cmi proofs/proof_type.cmi pretyping/rawterm.cmi \ - proofs/refiner.cmi proofs/tacexpr.cmo tactics/tacinterp.cmi \ - proofs/tacmach.cmi tactics/tacticals.cmi tactics/tactics.cmi \ - kernel/term.cmi lib/util.cmi -tactics/eqdecide.cmx: tactics/auto.cmx toplevel/cerrors.cmx interp/coqlib.cmx \ - kernel/declarations.cmx parsing/egrammar.cmx tactics/equality.cmx \ - tactics/extratactics.cmx interp/genarg.cmx library/global.cmx \ - tactics/hiddentac.cmx tactics/hipattern.cmx pretyping/matching.cmx \ - library/nameops.cmx kernel/names.cmx lib/options.cmx \ - pretyping/pattern.cmx parsing/pcoq.cmx lib/pp.cmx parsing/pptactic.cmx \ - proofs/proof_trees.cmx proofs/proof_type.cmx pretyping/rawterm.cmx \ - proofs/refiner.cmx proofs/tacexpr.cmx tactics/tacinterp.cmx \ - proofs/tacmach.cmx tactics/tacticals.cmx tactics/tactics.cmx \ - kernel/term.cmx lib/util.cmx -tactics/equality.cmo: proofs/clenv.cmi interp/coqlib.cmi \ - kernel/declarations.cmi kernel/environ.cmi proofs/evar_refiner.cmi \ - pretyping/evarconv.cmi pretyping/evarutil.cmi tactics/hipattern.cmi \ - pretyping/indrec.cmi kernel/inductive.cmi pretyping/inductiveops.cmi \ - pretyping/instantiate.cmi proofs/logic.cmi pretyping/matching.cmi \ - library/nameops.cmi kernel/names.cmi pretyping/pattern.cmi lib/pp.cmi \ - proofs/proof_type.cmi pretyping/rawterm.cmi pretyping/reductionops.cmi \ - pretyping/retyping.cmi tactics/setoid_replace.cmi kernel/sign.cmi \ - proofs/tacexpr.cmo proofs/tacmach.cmi pretyping/tacred.cmi \ - tactics/tacticals.cmi tactics/tactics.cmi kernel/term.cmi \ - pretyping/termops.cmi kernel/typeops.cmi pretyping/typing.cmi \ - kernel/univ.cmi lib/util.cmi toplevel/vernacexpr.cmo tactics/equality.cmi -tactics/equality.cmx: proofs/clenv.cmx interp/coqlib.cmx \ - kernel/declarations.cmx kernel/environ.cmx proofs/evar_refiner.cmx \ - pretyping/evarconv.cmx pretyping/evarutil.cmx tactics/hipattern.cmx \ - pretyping/indrec.cmx kernel/inductive.cmx pretyping/inductiveops.cmx \ - pretyping/instantiate.cmx proofs/logic.cmx pretyping/matching.cmx \ - library/nameops.cmx kernel/names.cmx pretyping/pattern.cmx lib/pp.cmx \ - proofs/proof_type.cmx pretyping/rawterm.cmx pretyping/reductionops.cmx \ - pretyping/retyping.cmx tactics/setoid_replace.cmx kernel/sign.cmx \ - proofs/tacexpr.cmx proofs/tacmach.cmx pretyping/tacred.cmx \ - tactics/tacticals.cmx tactics/tactics.cmx kernel/term.cmx \ - pretyping/termops.cmx kernel/typeops.cmx pretyping/typing.cmx \ - kernel/univ.cmx lib/util.cmx toplevel/vernacexpr.cmx tactics/equality.cmi -tactics/extraargs.cmo: parsing/extend.cmi interp/genarg.cmi \ - toplevel/metasyntax.cmi parsing/pcoq.cmi lib/pp.cmi parsing/pptactic.cmi \ - tactics/tacinterp.cmi tactics/extraargs.cmi -tactics/extraargs.cmx: parsing/extend.cmx interp/genarg.cmx \ - toplevel/metasyntax.cmx parsing/pcoq.cmx lib/pp.cmx parsing/pptactic.cmx \ - tactics/tacinterp.cmx tactics/extraargs.cmi -tactics/extratactics.cmo: tactics/autorewrite.cmi toplevel/cerrors.cmi \ - interp/constrintern.cmi tactics/contradiction.cmi parsing/egrammar.cmi \ - tactics/equality.cmi pretyping/evd.cmi tactics/extraargs.cmi \ - interp/genarg.cmi library/global.cmi tactics/inv.cmi tactics/leminv.cmi \ - library/lib.cmi library/libnames.cmi library/libobject.cmi \ - library/nametab.cmi lib/options.cmi parsing/pcoq.cmi lib/pp.cmi \ - parsing/pptactic.cmi pretyping/rawterm.cmi tactics/refine.cmi \ - proofs/refiner.cmi tactics/setoid_replace.cmi library/summary.cmi \ - proofs/tacexpr.cmo tactics/tacinterp.cmi tactics/tacticals.cmi \ - tactics/tactics.cmi kernel/term.cmi lib/util.cmi \ - toplevel/vernacinterp.cmi tactics/extratactics.cmi -tactics/extratactics.cmx: tactics/autorewrite.cmx toplevel/cerrors.cmx \ - interp/constrintern.cmx tactics/contradiction.cmx parsing/egrammar.cmx \ - tactics/equality.cmx pretyping/evd.cmx tactics/extraargs.cmx \ - interp/genarg.cmx library/global.cmx tactics/inv.cmx tactics/leminv.cmx \ - library/lib.cmx library/libnames.cmx library/libobject.cmx \ - library/nametab.cmx lib/options.cmx parsing/pcoq.cmx lib/pp.cmx \ - parsing/pptactic.cmx pretyping/rawterm.cmx tactics/refine.cmx \ - proofs/refiner.cmx tactics/setoid_replace.cmx library/summary.cmx \ - proofs/tacexpr.cmx tactics/tacinterp.cmx tactics/tacticals.cmx \ - tactics/tactics.cmx kernel/term.cmx lib/util.cmx \ - toplevel/vernacinterp.cmx tactics/extratactics.cmi -tactics/hiddentac.cmo: proofs/evar_refiner.cmi interp/genarg.cmi \ - proofs/proof_type.cmi pretyping/rawterm.cmi proofs/refiner.cmi \ - proofs/tacexpr.cmo proofs/tacmach.cmi tactics/tactics.cmi kernel/term.cmi \ - lib/util.cmi tactics/hiddentac.cmi -tactics/hiddentac.cmx: proofs/evar_refiner.cmx interp/genarg.cmx \ - proofs/proof_type.cmx pretyping/rawterm.cmx proofs/refiner.cmx \ - proofs/tacexpr.cmx proofs/tacmach.cmx tactics/tactics.cmx kernel/term.cmx \ - lib/util.cmx tactics/hiddentac.cmi -tactics/hipattern.cmo: proofs/clenv.cmi interp/coqlib.cmi \ - kernel/declarations.cmi kernel/environ.cmi pretyping/evd.cmi \ - library/global.cmi pretyping/inductiveops.cmi pretyping/matching.cmi \ - library/nameops.cmi kernel/names.cmi pretyping/pattern.cmi lib/pp.cmi \ - proofs/proof_trees.cmi pretyping/reductionops.cmi proofs/tacmach.cmi \ - tactics/tacticals.cmi kernel/term.cmi pretyping/termops.cmi lib/util.cmi \ +tactics/eauto.cmo: lib/util.cmi pretyping/termops.cmi kernel/term.cmi \ + tactics/tactics.cmi tactics/tacticals.cmi proofs/tacmach.cmi \ + tactics/tacinterp.cmi proofs/tacexpr.cmo kernel/sign.cmi \ + proofs/refiner.cmi kernel/reduction.cmi pretyping/rawterm.cmi \ + proofs/proof_type.cmi proofs/proof_trees.cmi parsing/pptactic.cmi \ + lib/pp.cmi parsing/pcoq.cmi pretyping/pattern.cmi lib/options.cmi \ + kernel/names.cmi library/nameops.cmi proofs/logic.cmi library/global.cmi \ + interp/genarg.cmi parsing/extend.cmi lib/explore.cmi \ + proofs/evar_refiner.cmi parsing/egrammar.cmi kernel/declarations.cmi \ + proofs/clenv.cmi toplevel/cerrors.cmi tactics/auto.cmi tactics/eauto.cmi +tactics/eauto.cmx: lib/util.cmx pretyping/termops.cmx kernel/term.cmx \ + tactics/tactics.cmx tactics/tacticals.cmx proofs/tacmach.cmx \ + tactics/tacinterp.cmx proofs/tacexpr.cmx kernel/sign.cmx \ + proofs/refiner.cmx kernel/reduction.cmx pretyping/rawterm.cmx \ + proofs/proof_type.cmx proofs/proof_trees.cmx parsing/pptactic.cmx \ + lib/pp.cmx parsing/pcoq.cmx pretyping/pattern.cmx lib/options.cmx \ + kernel/names.cmx library/nameops.cmx proofs/logic.cmx library/global.cmx \ + interp/genarg.cmx parsing/extend.cmx lib/explore.cmx \ + proofs/evar_refiner.cmx parsing/egrammar.cmx kernel/declarations.cmx \ + proofs/clenv.cmx toplevel/cerrors.cmx tactics/auto.cmx tactics/eauto.cmi +tactics/elim.cmo: lib/util.cmi pretyping/termops.cmi kernel/term.cmi \ + tactics/tactics.cmi tactics/tacticals.cmi proofs/tacmach.cmi \ + proofs/tacexpr.cmo proofs/refiner.cmi kernel/reduction.cmi \ + proofs/proof_type.cmi parsing/printer.cmi lib/pp.cmi kernel/names.cmi \ + library/libnames.cmi pretyping/inductiveops.cmi tactics/hipattern.cmi \ + tactics/hiddentac.cmi interp/genarg.cmi kernel/environ.cmi \ + proofs/clenv.cmi tactics/elim.cmi +tactics/elim.cmx: lib/util.cmx pretyping/termops.cmx kernel/term.cmx \ + tactics/tactics.cmx tactics/tacticals.cmx proofs/tacmach.cmx \ + proofs/tacexpr.cmx proofs/refiner.cmx kernel/reduction.cmx \ + proofs/proof_type.cmx parsing/printer.cmx lib/pp.cmx kernel/names.cmx \ + library/libnames.cmx pretyping/inductiveops.cmx tactics/hipattern.cmx \ + tactics/hiddentac.cmx interp/genarg.cmx kernel/environ.cmx \ + proofs/clenv.cmx tactics/elim.cmi +tactics/eqdecide.cmo: lib/util.cmi kernel/term.cmi tactics/tactics.cmi \ + tactics/tacticals.cmi proofs/tacmach.cmi tactics/tacinterp.cmi \ + proofs/tacexpr.cmo proofs/refiner.cmi pretyping/rawterm.cmi \ + proofs/proof_type.cmi proofs/proof_trees.cmi parsing/pptactic.cmi \ + lib/pp.cmi parsing/pcoq.cmi pretyping/pattern.cmi lib/options.cmi \ + kernel/names.cmi library/nameops.cmi pretyping/matching.cmi \ + tactics/hipattern.cmi tactics/hiddentac.cmi library/global.cmi \ + interp/genarg.cmi tactics/extratactics.cmi tactics/equality.cmi \ + parsing/egrammar.cmi kernel/declarations.cmi interp/coqlib.cmi \ + toplevel/cerrors.cmi tactics/auto.cmi +tactics/eqdecide.cmx: lib/util.cmx kernel/term.cmx tactics/tactics.cmx \ + tactics/tacticals.cmx proofs/tacmach.cmx tactics/tacinterp.cmx \ + proofs/tacexpr.cmx proofs/refiner.cmx pretyping/rawterm.cmx \ + proofs/proof_type.cmx proofs/proof_trees.cmx parsing/pptactic.cmx \ + lib/pp.cmx parsing/pcoq.cmx pretyping/pattern.cmx lib/options.cmx \ + kernel/names.cmx library/nameops.cmx pretyping/matching.cmx \ + tactics/hipattern.cmx tactics/hiddentac.cmx library/global.cmx \ + interp/genarg.cmx tactics/extratactics.cmx tactics/equality.cmx \ + parsing/egrammar.cmx kernel/declarations.cmx interp/coqlib.cmx \ + toplevel/cerrors.cmx tactics/auto.cmx +tactics/equality.cmo: toplevel/vernacexpr.cmo lib/util.cmi kernel/univ.cmi \ + pretyping/typing.cmi kernel/typeops.cmi pretyping/termops.cmi \ + kernel/term.cmi tactics/tactics.cmi tactics/tacticals.cmi \ + pretyping/tacred.cmi proofs/tacmach.cmi proofs/tacexpr.cmo \ + kernel/sign.cmi tactics/setoid_replace.cmi pretyping/retyping.cmi \ + pretyping/reductionops.cmi pretyping/rawterm.cmi proofs/proof_type.cmi \ + lib/pp.cmi pretyping/pattern.cmi kernel/names.cmi library/nameops.cmi \ + pretyping/matching.cmi proofs/logic.cmi library/libnames.cmi \ + pretyping/instantiate.cmi pretyping/inductiveops.cmi kernel/inductive.cmi \ + pretyping/indrec.cmi tactics/hipattern.cmi pretyping/evarutil.cmi \ + pretyping/evarconv.cmi proofs/evar_refiner.cmi kernel/environ.cmi \ + kernel/declarations.cmi interp/coqlib.cmi proofs/clenv.cmi \ + tactics/equality.cmi +tactics/equality.cmx: toplevel/vernacexpr.cmx lib/util.cmx kernel/univ.cmx \ + pretyping/typing.cmx kernel/typeops.cmx pretyping/termops.cmx \ + kernel/term.cmx tactics/tactics.cmx tactics/tacticals.cmx \ + pretyping/tacred.cmx proofs/tacmach.cmx proofs/tacexpr.cmx \ + kernel/sign.cmx tactics/setoid_replace.cmx pretyping/retyping.cmx \ + pretyping/reductionops.cmx pretyping/rawterm.cmx proofs/proof_type.cmx \ + lib/pp.cmx pretyping/pattern.cmx kernel/names.cmx library/nameops.cmx \ + pretyping/matching.cmx proofs/logic.cmx library/libnames.cmx \ + pretyping/instantiate.cmx pretyping/inductiveops.cmx kernel/inductive.cmx \ + pretyping/indrec.cmx tactics/hipattern.cmx pretyping/evarutil.cmx \ + pretyping/evarconv.cmx proofs/evar_refiner.cmx kernel/environ.cmx \ + kernel/declarations.cmx interp/coqlib.cmx proofs/clenv.cmx \ + tactics/equality.cmi +tactics/extraargs.cmo: tactics/tacinterp.cmi parsing/pptactic.cmi lib/pp.cmi \ + parsing/pcoq.cmi toplevel/metasyntax.cmi interp/genarg.cmi \ + parsing/extend.cmi tactics/extraargs.cmi +tactics/extraargs.cmx: tactics/tacinterp.cmx parsing/pptactic.cmx lib/pp.cmx \ + parsing/pcoq.cmx toplevel/metasyntax.cmx interp/genarg.cmx \ + parsing/extend.cmx tactics/extraargs.cmi +tactics/extratactics.cmo: toplevel/vernacinterp.cmi lib/util.cmi \ + kernel/term.cmi tactics/tactics.cmi tactics/tacticals.cmi \ + tactics/tacinterp.cmi proofs/tacexpr.cmo library/summary.cmi \ + tactics/setoid_replace.cmi proofs/refiner.cmi tactics/refine.cmi \ + pretyping/rawterm.cmi parsing/pptactic.cmi lib/pp.cmi parsing/pcoq.cmi \ + lib/options.cmi library/nametab.cmi library/libobject.cmi \ + library/libnames.cmi library/lib.cmi tactics/leminv.cmi tactics/inv.cmi \ + library/global.cmi interp/genarg.cmi tactics/extraargs.cmi \ + pretyping/evd.cmi tactics/equality.cmi parsing/egrammar.cmi \ + tactics/contradiction.cmi interp/constrintern.cmi toplevel/cerrors.cmi \ + tactics/autorewrite.cmi tactics/extratactics.cmi +tactics/extratactics.cmx: toplevel/vernacinterp.cmx lib/util.cmx \ + kernel/term.cmx tactics/tactics.cmx tactics/tacticals.cmx \ + tactics/tacinterp.cmx proofs/tacexpr.cmx library/summary.cmx \ + tactics/setoid_replace.cmx proofs/refiner.cmx tactics/refine.cmx \ + pretyping/rawterm.cmx parsing/pptactic.cmx lib/pp.cmx parsing/pcoq.cmx \ + lib/options.cmx library/nametab.cmx library/libobject.cmx \ + library/libnames.cmx library/lib.cmx tactics/leminv.cmx tactics/inv.cmx \ + library/global.cmx interp/genarg.cmx tactics/extraargs.cmx \ + pretyping/evd.cmx tactics/equality.cmx parsing/egrammar.cmx \ + tactics/contradiction.cmx interp/constrintern.cmx toplevel/cerrors.cmx \ + tactics/autorewrite.cmx tactics/extratactics.cmi +tactics/hiddentac.cmo: lib/util.cmi kernel/term.cmi tactics/tactics.cmi \ + proofs/tacmach.cmi proofs/tacexpr.cmo proofs/refiner.cmi \ + pretyping/rawterm.cmi proofs/proof_type.cmi interp/genarg.cmi \ + proofs/evar_refiner.cmi tactics/hiddentac.cmi +tactics/hiddentac.cmx: lib/util.cmx kernel/term.cmx tactics/tactics.cmx \ + proofs/tacmach.cmx proofs/tacexpr.cmx proofs/refiner.cmx \ + pretyping/rawterm.cmx proofs/proof_type.cmx interp/genarg.cmx \ + proofs/evar_refiner.cmx tactics/hiddentac.cmi +tactics/hipattern.cmo: lib/util.cmi pretyping/termops.cmi kernel/term.cmi \ + tactics/tacticals.cmi proofs/tacmach.cmi pretyping/reductionops.cmi \ + proofs/proof_trees.cmi lib/pp.cmi pretyping/pattern.cmi kernel/names.cmi \ + library/nameops.cmi pretyping/matching.cmi pretyping/inductiveops.cmi \ + library/global.cmi pretyping/evd.cmi kernel/environ.cmi \ + kernel/declarations.cmi interp/coqlib.cmi proofs/clenv.cmi \ tactics/hipattern.cmi -tactics/hipattern.cmx: proofs/clenv.cmx interp/coqlib.cmx \ - kernel/declarations.cmx kernel/environ.cmx pretyping/evd.cmx \ - library/global.cmx pretyping/inductiveops.cmx pretyping/matching.cmx \ - library/nameops.cmx kernel/names.cmx pretyping/pattern.cmx lib/pp.cmx \ - proofs/proof_trees.cmx pretyping/reductionops.cmx proofs/tacmach.cmx \ - tactics/tacticals.cmx kernel/term.cmx pretyping/termops.cmx lib/util.cmx \ +tactics/hipattern.cmx: lib/util.cmx pretyping/termops.cmx kernel/term.cmx \ + tactics/tacticals.cmx proofs/tacmach.cmx pretyping/reductionops.cmx \ + proofs/proof_trees.cmx lib/pp.cmx pretyping/pattern.cmx kernel/names.cmx \ + library/nameops.cmx pretyping/matching.cmx pretyping/inductiveops.cmx \ + library/global.cmx pretyping/evd.cmx kernel/environ.cmx \ + kernel/declarations.cmx interp/coqlib.cmx proofs/clenv.cmx \ tactics/hipattern.cmi -tactics/inv.cmo: proofs/clenv.cmi interp/coqlib.cmi tactics/elim.cmi \ - kernel/environ.cmi tactics/equality.cmi proofs/evar_refiner.cmi \ - interp/genarg.cmi library/global.cmi tactics/hipattern.cmi \ - pretyping/inductiveops.cmi pretyping/matching.cmi library/nameops.cmi \ - kernel/names.cmi pretyping/pattern.cmi lib/pp.cmi parsing/printer.cmi \ - proofs/proof_type.cmi pretyping/rawterm.cmi kernel/reduction.cmi \ - pretyping/reductionops.cmi pretyping/retyping.cmi kernel/sign.cmi \ - proofs/tacexpr.cmo proofs/tacmach.cmi tactics/tacticals.cmi \ - tactics/tactics.cmi kernel/term.cmi pretyping/termops.cmi \ - pretyping/typing.cmi lib/util.cmi tactics/inv.cmi -tactics/inv.cmx: proofs/clenv.cmx interp/coqlib.cmx tactics/elim.cmx \ - kernel/environ.cmx tactics/equality.cmx proofs/evar_refiner.cmx \ - interp/genarg.cmx library/global.cmx tactics/hipattern.cmx \ - pretyping/inductiveops.cmx pretyping/matching.cmx library/nameops.cmx \ - kernel/names.cmx pretyping/pattern.cmx lib/pp.cmx parsing/printer.cmx \ - proofs/proof_type.cmx pretyping/rawterm.cmx kernel/reduction.cmx \ - pretyping/reductionops.cmx pretyping/retyping.cmx kernel/sign.cmx \ - proofs/tacexpr.cmx proofs/tacmach.cmx tactics/tacticals.cmx \ - tactics/tactics.cmx kernel/term.cmx pretyping/termops.cmx \ - pretyping/typing.cmx lib/util.cmx tactics/inv.cmi -tactics/leminv.cmo: proofs/clenv.cmi interp/constrintern.cmi \ - library/decl_kinds.cmo kernel/declarations.cmi library/declare.cmi \ - kernel/entries.cmi kernel/environ.cmi proofs/evar_refiner.cmi \ - pretyping/evd.cmi library/global.cmi pretyping/inductiveops.cmi \ - tactics/inv.cmi library/nameops.cmi kernel/names.cmi proofs/pfedit.cmi \ - lib/pp.cmi pretyping/pretyping.cmi parsing/printer.cmi \ - proofs/proof_trees.cmi proofs/proof_type.cmi pretyping/reductionops.cmi \ - kernel/safe_typing.cmi kernel/sign.cmi proofs/tacmach.cmi \ - tactics/tacticals.cmi tactics/tactics.cmi kernel/term.cmi \ - pretyping/termops.cmi lib/util.cmi toplevel/vernacexpr.cmo \ +tactics/inv.cmo: lib/util.cmi pretyping/typing.cmi pretyping/termops.cmi \ + kernel/term.cmi tactics/tactics.cmi tactics/tacticals.cmi \ + proofs/tacmach.cmi proofs/tacexpr.cmo kernel/sign.cmi \ + pretyping/retyping.cmi pretyping/reductionops.cmi kernel/reduction.cmi \ + pretyping/rawterm.cmi proofs/proof_type.cmi parsing/printer.cmi \ + lib/pp.cmi pretyping/pattern.cmi kernel/names.cmi library/nameops.cmi \ + pretyping/matching.cmi pretyping/inductiveops.cmi tactics/hipattern.cmi \ + library/global.cmi interp/genarg.cmi proofs/evar_refiner.cmi \ + tactics/equality.cmi kernel/environ.cmi tactics/elim.cmi \ + interp/coqlib.cmi proofs/clenv.cmi tactics/inv.cmi +tactics/inv.cmx: lib/util.cmx pretyping/typing.cmx pretyping/termops.cmx \ + kernel/term.cmx tactics/tactics.cmx tactics/tacticals.cmx \ + proofs/tacmach.cmx proofs/tacexpr.cmx kernel/sign.cmx \ + pretyping/retyping.cmx pretyping/reductionops.cmx kernel/reduction.cmx \ + pretyping/rawterm.cmx proofs/proof_type.cmx parsing/printer.cmx \ + lib/pp.cmx pretyping/pattern.cmx kernel/names.cmx library/nameops.cmx \ + pretyping/matching.cmx pretyping/inductiveops.cmx tactics/hipattern.cmx \ + library/global.cmx interp/genarg.cmx proofs/evar_refiner.cmx \ + tactics/equality.cmx kernel/environ.cmx tactics/elim.cmx \ + interp/coqlib.cmx proofs/clenv.cmx tactics/inv.cmi +tactics/leminv.cmo: toplevel/vernacexpr.cmo lib/util.cmi \ + pretyping/termops.cmi kernel/term.cmi tactics/tactics.cmi \ + tactics/tacticals.cmi proofs/tacmach.cmi kernel/sign.cmi \ + kernel/safe_typing.cmi pretyping/reductionops.cmi proofs/proof_type.cmi \ + proofs/proof_trees.cmi parsing/printer.cmi pretyping/pretyping.cmi \ + lib/pp.cmi proofs/pfedit.cmi kernel/names.cmi library/nameops.cmi \ + tactics/inv.cmi pretyping/inductiveops.cmi library/global.cmi \ + pretyping/evd.cmi proofs/evar_refiner.cmi kernel/environ.cmi \ + kernel/entries.cmi library/declare.cmi kernel/declarations.cmi \ + library/decl_kinds.cmo interp/constrintern.cmi proofs/clenv.cmi \ tactics/leminv.cmi -tactics/leminv.cmx: proofs/clenv.cmx interp/constrintern.cmx \ - library/decl_kinds.cmx kernel/declarations.cmx library/declare.cmx \ - kernel/entries.cmx kernel/environ.cmx proofs/evar_refiner.cmx \ - pretyping/evd.cmx library/global.cmx pretyping/inductiveops.cmx \ - tactics/inv.cmx library/nameops.cmx kernel/names.cmx proofs/pfedit.cmx \ - lib/pp.cmx pretyping/pretyping.cmx parsing/printer.cmx \ - proofs/proof_trees.cmx proofs/proof_type.cmx pretyping/reductionops.cmx \ - kernel/safe_typing.cmx kernel/sign.cmx proofs/tacmach.cmx \ - tactics/tacticals.cmx tactics/tactics.cmx kernel/term.cmx \ - pretyping/termops.cmx lib/util.cmx toplevel/vernacexpr.cmx \ +tactics/leminv.cmx: toplevel/vernacexpr.cmx lib/util.cmx \ + pretyping/termops.cmx kernel/term.cmx tactics/tactics.cmx \ + tactics/tacticals.cmx proofs/tacmach.cmx kernel/sign.cmx \ + kernel/safe_typing.cmx pretyping/reductionops.cmx proofs/proof_type.cmx \ + proofs/proof_trees.cmx parsing/printer.cmx pretyping/pretyping.cmx \ + lib/pp.cmx proofs/pfedit.cmx kernel/names.cmx library/nameops.cmx \ + tactics/inv.cmx pretyping/inductiveops.cmx library/global.cmx \ + pretyping/evd.cmx proofs/evar_refiner.cmx kernel/environ.cmx \ + kernel/entries.cmx library/declare.cmx kernel/declarations.cmx \ + library/decl_kinds.cmx interp/constrintern.cmx proofs/clenv.cmx \ tactics/leminv.cmi -tactics/nbtermdn.cmo: tactics/btermdn.cmi lib/gmap.cmi library/libobject.cmi \ - library/library.cmi kernel/names.cmi pretyping/pattern.cmi \ - kernel/term.cmi tactics/termdn.cmi lib/util.cmi tactics/nbtermdn.cmi -tactics/nbtermdn.cmx: tactics/btermdn.cmx lib/gmap.cmx library/libobject.cmx \ - library/library.cmx kernel/names.cmx pretyping/pattern.cmx \ - kernel/term.cmx tactics/termdn.cmx lib/util.cmx tactics/nbtermdn.cmi -tactics/refine.cmo: proofs/clenv.cmi kernel/environ.cmi pretyping/evd.cmi \ - kernel/names.cmi lib/pp.cmi parsing/printer.cmi kernel/reduction.cmi \ - pretyping/retyping.cmi kernel/sign.cmi proofs/tacmach.cmi \ - tactics/tacticals.cmi tactics/tactics.cmi kernel/term.cmi \ - pretyping/termops.cmi pretyping/typing.cmi lib/util.cmi \ - tactics/refine.cmi -tactics/refine.cmx: proofs/clenv.cmx kernel/environ.cmx pretyping/evd.cmx \ - kernel/names.cmx lib/pp.cmx parsing/printer.cmx kernel/reduction.cmx \ - pretyping/retyping.cmx kernel/sign.cmx proofs/tacmach.cmx \ - tactics/tacticals.cmx tactics/tactics.cmx kernel/term.cmx \ - pretyping/termops.cmx pretyping/typing.cmx lib/util.cmx \ - tactics/refine.cmi -tactics/setoid_replace.cmo: tactics/auto.cmi interp/constrintern.cmi \ - interp/coqlib.cmi library/decl_kinds.cmo library/declare.cmi \ - kernel/entries.cmi kernel/environ.cmi pretyping/evd.cmi \ - library/global.cmi lib/gmap.cmi library/lib.cmi library/libnames.cmi \ - library/libobject.cmi library/nameops.cmi kernel/names.cmi \ - library/nametab.cmi lib/options.cmi proofs/pfedit.cmi lib/pp.cmi \ - parsing/printer.cmi proofs/proof_type.cmi pretyping/reductionops.cmi \ - kernel/safe_typing.cmi library/summary.cmi proofs/tacmach.cmi \ - tactics/tacticals.cmi tactics/tactics.cmi kernel/term.cmi \ - pretyping/termops.cmi pretyping/typing.cmi lib/util.cmi \ - toplevel/vernacexpr.cmo tactics/setoid_replace.cmi -tactics/setoid_replace.cmx: tactics/auto.cmx interp/constrintern.cmx \ - interp/coqlib.cmx library/decl_kinds.cmx library/declare.cmx \ - kernel/entries.cmx kernel/environ.cmx pretyping/evd.cmx \ - library/global.cmx lib/gmap.cmx library/lib.cmx library/libnames.cmx \ - library/libobject.cmx library/nameops.cmx kernel/names.cmx \ - library/nametab.cmx lib/options.cmx proofs/pfedit.cmx lib/pp.cmx \ - parsing/printer.cmx proofs/proof_type.cmx pretyping/reductionops.cmx \ - kernel/safe_typing.cmx library/summary.cmx proofs/tacmach.cmx \ - tactics/tacticals.cmx tactics/tactics.cmx kernel/term.cmx \ - pretyping/termops.cmx pretyping/typing.cmx lib/util.cmx \ - toplevel/vernacexpr.cmx tactics/setoid_replace.cmi -tactics/tacinterp.cmo: parsing/ast.cmi tactics/auto.cmi kernel/closure.cmi \ - interp/constrintern.cmi parsing/coqast.cmi library/decl_kinds.cmo \ - kernel/declarations.cmi tactics/dhyp.cmi lib/dyn.cmi tactics/elim.cmi \ - kernel/entries.cmi kernel/environ.cmi pretyping/evd.cmi interp/genarg.cmi \ - library/global.cmi lib/gmap.cmi tactics/hiddentac.cmi tactics/inv.cmi \ - tactics/leminv.cmi library/lib.cmi library/libnames.cmi \ - library/libobject.cmi proofs/logic.cmi pretyping/matching.cmi \ - library/nameops.cmi kernel/names.cmi library/nametab.cmi lib/options.cmi \ - pretyping/pattern.cmi proofs/pfedit.cmi lib/pp.cmi \ - pretyping/pretype_errors.cmi pretyping/pretyping.cmi parsing/printer.cmi \ - proofs/proof_type.cmi pretyping/rawterm.cmi proofs/refiner.cmi \ - pretyping/retyping.cmi kernel/safe_typing.cmi kernel/sign.cmi \ - library/summary.cmi interp/syntax_def.cmi proofs/tacexpr.cmo \ - proofs/tacmach.cmi pretyping/tacred.cmi proofs/tactic_debug.cmi \ - tactics/tactics.cmi kernel/term.cmi pretyping/termops.cmi \ - interp/topconstr.cmi pretyping/typing.cmi lib/util.cmi \ - tactics/tacinterp.cmi -tactics/tacinterp.cmx: parsing/ast.cmx tactics/auto.cmx kernel/closure.cmx \ - interp/constrintern.cmx parsing/coqast.cmx library/decl_kinds.cmx \ - kernel/declarations.cmx tactics/dhyp.cmx lib/dyn.cmx tactics/elim.cmx \ - kernel/entries.cmx kernel/environ.cmx pretyping/evd.cmx interp/genarg.cmx \ - library/global.cmx lib/gmap.cmx tactics/hiddentac.cmx tactics/inv.cmx \ - tactics/leminv.cmx library/lib.cmx library/libnames.cmx \ - library/libobject.cmx proofs/logic.cmx pretyping/matching.cmx \ - library/nameops.cmx kernel/names.cmx library/nametab.cmx lib/options.cmx \ - pretyping/pattern.cmx proofs/pfedit.cmx lib/pp.cmx \ - pretyping/pretype_errors.cmx pretyping/pretyping.cmx parsing/printer.cmx \ - proofs/proof_type.cmx pretyping/rawterm.cmx proofs/refiner.cmx \ - pretyping/retyping.cmx kernel/safe_typing.cmx kernel/sign.cmx \ - library/summary.cmx interp/syntax_def.cmx proofs/tacexpr.cmx \ - proofs/tacmach.cmx pretyping/tacred.cmx proofs/tactic_debug.cmx \ - tactics/tactics.cmx kernel/term.cmx pretyping/termops.cmx \ - interp/topconstr.cmx pretyping/typing.cmx lib/util.cmx \ - tactics/tacinterp.cmi -tactics/tacticals.cmo: proofs/clenv.cmi kernel/declarations.cmi \ - kernel/environ.cmi proofs/evar_refiner.cmi interp/genarg.cmi \ - library/global.cmi pretyping/indrec.cmi kernel/inductive.cmi \ - library/libnames.cmi pretyping/matching.cmi kernel/names.cmi \ - pretyping/pattern.cmi lib/pp.cmi kernel/reduction.cmi proofs/refiner.cmi \ - kernel/sign.cmi proofs/tacexpr.cmo proofs/tacmach.cmi kernel/term.cmi \ - pretyping/termops.cmi lib/util.cmi tactics/tacticals.cmi -tactics/tacticals.cmx: proofs/clenv.cmx kernel/declarations.cmx \ - kernel/environ.cmx proofs/evar_refiner.cmx interp/genarg.cmx \ - library/global.cmx pretyping/indrec.cmx kernel/inductive.cmx \ - library/libnames.cmx pretyping/matching.cmx kernel/names.cmx \ - pretyping/pattern.cmx lib/pp.cmx kernel/reduction.cmx proofs/refiner.cmx \ - kernel/sign.cmx proofs/tacexpr.cmx proofs/tacmach.cmx kernel/term.cmx \ - pretyping/termops.cmx lib/util.cmx tactics/tacticals.cmi -tactics/tactics.cmo: proofs/clenv.cmi interp/constrintern.cmi \ - interp/coqlib.cmi library/decl_kinds.cmo kernel/declarations.cmi \ - library/declare.cmi kernel/entries.cmi kernel/environ.cmi \ - proofs/evar_refiner.cmi pretyping/evd.cmi interp/genarg.cmi \ - library/global.cmi tactics/hipattern.cmi pretyping/indrec.cmi \ - kernel/inductive.cmi pretyping/inductiveops.cmi library/libnames.cmi \ - proofs/logic.cmi library/nameops.cmi kernel/names.cmi library/nametab.cmi \ - lib/options.cmi proofs/pfedit.cmi lib/pp.cmi proofs/proof_trees.cmi \ - proofs/proof_type.cmi pretyping/rawterm.cmi pretyping/reductionops.cmi \ - proofs/refiner.cmi kernel/sign.cmi proofs/tacexpr.cmo proofs/tacmach.cmi \ - pretyping/tacred.cmi tactics/tacticals.cmi kernel/term.cmi \ - pretyping/termops.cmi lib/util.cmi tactics/tactics.cmi -tactics/tactics.cmx: proofs/clenv.cmx interp/constrintern.cmx \ - interp/coqlib.cmx library/decl_kinds.cmx kernel/declarations.cmx \ - library/declare.cmx kernel/entries.cmx kernel/environ.cmx \ - proofs/evar_refiner.cmx pretyping/evd.cmx interp/genarg.cmx \ - library/global.cmx tactics/hipattern.cmx pretyping/indrec.cmx \ - kernel/inductive.cmx pretyping/inductiveops.cmx library/libnames.cmx \ - proofs/logic.cmx library/nameops.cmx kernel/names.cmx library/nametab.cmx \ - lib/options.cmx proofs/pfedit.cmx lib/pp.cmx proofs/proof_trees.cmx \ - proofs/proof_type.cmx pretyping/rawterm.cmx pretyping/reductionops.cmx \ - proofs/refiner.cmx kernel/sign.cmx proofs/tacexpr.cmx proofs/tacmach.cmx \ - pretyping/tacred.cmx tactics/tacticals.cmx kernel/term.cmx \ - pretyping/termops.cmx lib/util.cmx tactics/tactics.cmi -tactics/tauto.cmo: parsing/ast.cmi toplevel/cerrors.cmi parsing/coqast.cmi \ - parsing/egrammar.cmi interp/genarg.cmi tactics/hipattern.cmi \ - library/libnames.cmi kernel/names.cmi lib/options.cmi parsing/pcoq.cmi \ - lib/pp.cmi parsing/pptactic.cmi proofs/proof_type.cmi \ - pretyping/rawterm.cmi proofs/refiner.cmi proofs/tacexpr.cmo \ - tactics/tacinterp.cmi tactics/tacticals.cmi tactics/tactics.cmi \ - interp/topconstr.cmi lib/util.cmi -tactics/tauto.cmx: parsing/ast.cmx toplevel/cerrors.cmx parsing/coqast.cmx \ - parsing/egrammar.cmx interp/genarg.cmx tactics/hipattern.cmx \ - library/libnames.cmx kernel/names.cmx lib/options.cmx parsing/pcoq.cmx \ - lib/pp.cmx parsing/pptactic.cmx proofs/proof_type.cmx \ - pretyping/rawterm.cmx proofs/refiner.cmx proofs/tacexpr.cmx \ - tactics/tacinterp.cmx tactics/tacticals.cmx tactics/tactics.cmx \ - interp/topconstr.cmx lib/util.cmx -tactics/termdn.cmo: tactics/dn.cmi library/libnames.cmi library/nameops.cmi \ - kernel/names.cmi library/nametab.cmi pretyping/pattern.cmi \ - pretyping/rawterm.cmi kernel/term.cmi lib/util.cmi tactics/termdn.cmi -tactics/termdn.cmx: tactics/dn.cmx library/libnames.cmx library/nameops.cmx \ - kernel/names.cmx library/nametab.cmx pretyping/pattern.cmx \ - pretyping/rawterm.cmx kernel/term.cmx lib/util.cmx tactics/termdn.cmi -tools/coqdep.cmo: config/coq_config.cmi tools/coqdep_lexer.cmo -tools/coqdep.cmx: config/coq_config.cmx tools/coqdep_lexer.cmx +tactics/nbtermdn.cmo: lib/util.cmi tactics/termdn.cmi kernel/term.cmi \ + pretyping/pattern.cmi kernel/names.cmi library/library.cmi \ + library/libobject.cmi lib/gmap.cmi tactics/btermdn.cmi \ + tactics/nbtermdn.cmi +tactics/nbtermdn.cmx: lib/util.cmx tactics/termdn.cmx kernel/term.cmx \ + pretyping/pattern.cmx kernel/names.cmx library/library.cmx \ + library/libobject.cmx lib/gmap.cmx tactics/btermdn.cmx \ + tactics/nbtermdn.cmi +tactics/refine.cmo: lib/util.cmi pretyping/typing.cmi pretyping/termops.cmi \ + kernel/term.cmi tactics/tactics.cmi tactics/tacticals.cmi \ + proofs/tacmach.cmi kernel/sign.cmi pretyping/retyping.cmi \ + kernel/reduction.cmi parsing/printer.cmi lib/pp.cmi kernel/names.cmi \ + pretyping/evd.cmi kernel/environ.cmi proofs/clenv.cmi tactics/refine.cmi +tactics/refine.cmx: lib/util.cmx pretyping/typing.cmx pretyping/termops.cmx \ + kernel/term.cmx tactics/tactics.cmx tactics/tacticals.cmx \ + proofs/tacmach.cmx kernel/sign.cmx pretyping/retyping.cmx \ + kernel/reduction.cmx parsing/printer.cmx lib/pp.cmx kernel/names.cmx \ + pretyping/evd.cmx kernel/environ.cmx proofs/clenv.cmx tactics/refine.cmi +tactics/setoid_replace.cmo: toplevel/vernacexpr.cmo lib/util.cmi \ + pretyping/typing.cmi pretyping/termops.cmi kernel/term.cmi \ + tactics/tactics.cmi tactics/tacticals.cmi proofs/tacmach.cmi \ + library/summary.cmi kernel/safe_typing.cmi pretyping/reductionops.cmi \ + proofs/proof_type.cmi parsing/printer.cmi lib/pp.cmi proofs/pfedit.cmi \ + lib/options.cmi library/nametab.cmi kernel/names.cmi library/nameops.cmi \ + library/libobject.cmi library/libnames.cmi library/lib.cmi lib/gmap.cmi \ + library/global.cmi pretyping/evd.cmi kernel/environ.cmi \ + kernel/entries.cmi library/declare.cmi library/decl_kinds.cmo \ + interp/coqlib.cmi interp/constrintern.cmi tactics/auto.cmi \ + tactics/setoid_replace.cmi +tactics/setoid_replace.cmx: toplevel/vernacexpr.cmx lib/util.cmx \ + pretyping/typing.cmx pretyping/termops.cmx kernel/term.cmx \ + tactics/tactics.cmx tactics/tacticals.cmx proofs/tacmach.cmx \ + library/summary.cmx kernel/safe_typing.cmx pretyping/reductionops.cmx \ + proofs/proof_type.cmx parsing/printer.cmx lib/pp.cmx proofs/pfedit.cmx \ + lib/options.cmx library/nametab.cmx kernel/names.cmx library/nameops.cmx \ + library/libobject.cmx library/libnames.cmx library/lib.cmx lib/gmap.cmx \ + library/global.cmx pretyping/evd.cmx kernel/environ.cmx \ + kernel/entries.cmx library/declare.cmx library/decl_kinds.cmx \ + interp/coqlib.cmx interp/constrintern.cmx tactics/auto.cmx \ + tactics/setoid_replace.cmi +tactics/tacinterp.cmo: lib/util.cmi pretyping/typing.cmi interp/topconstr.cmi \ + pretyping/termops.cmi kernel/term.cmi tactics/tactics.cmi \ + proofs/tactic_debug.cmi pretyping/tacred.cmi proofs/tacmach.cmi \ + proofs/tacexpr.cmo interp/syntax_def.cmi library/summary.cmi \ + kernel/sign.cmi kernel/safe_typing.cmi pretyping/retyping.cmi \ + proofs/refiner.cmi pretyping/rawterm.cmi proofs/proof_type.cmi \ + parsing/printer.cmi pretyping/pretyping.cmi pretyping/pretype_errors.cmi \ + lib/pp.cmi proofs/pfedit.cmi pretyping/pattern.cmi lib/options.cmi \ + library/nametab.cmi kernel/names.cmi library/nameops.cmi \ + pretyping/matching.cmi proofs/logic.cmi library/libobject.cmi \ + library/libnames.cmi library/lib.cmi tactics/leminv.cmi tactics/inv.cmi \ + tactics/hiddentac.cmi lib/gmap.cmi library/global.cmi interp/genarg.cmi \ + pretyping/evd.cmi kernel/environ.cmi kernel/entries.cmi tactics/elim.cmi \ + lib/dyn.cmi tactics/dhyp.cmi kernel/declarations.cmi \ + library/decl_kinds.cmo parsing/coqast.cmi interp/constrintern.cmi \ + kernel/closure.cmi tactics/auto.cmi parsing/ast.cmi tactics/tacinterp.cmi +tactics/tacinterp.cmx: lib/util.cmx pretyping/typing.cmx interp/topconstr.cmx \ + pretyping/termops.cmx kernel/term.cmx tactics/tactics.cmx \ + proofs/tactic_debug.cmx pretyping/tacred.cmx proofs/tacmach.cmx \ + proofs/tacexpr.cmx interp/syntax_def.cmx library/summary.cmx \ + kernel/sign.cmx kernel/safe_typing.cmx pretyping/retyping.cmx \ + proofs/refiner.cmx pretyping/rawterm.cmx proofs/proof_type.cmx \ + parsing/printer.cmx pretyping/pretyping.cmx pretyping/pretype_errors.cmx \ + lib/pp.cmx proofs/pfedit.cmx pretyping/pattern.cmx lib/options.cmx \ + library/nametab.cmx kernel/names.cmx library/nameops.cmx \ + pretyping/matching.cmx proofs/logic.cmx library/libobject.cmx \ + library/libnames.cmx library/lib.cmx tactics/leminv.cmx tactics/inv.cmx \ + tactics/hiddentac.cmx lib/gmap.cmx library/global.cmx interp/genarg.cmx \ + pretyping/evd.cmx kernel/environ.cmx kernel/entries.cmx tactics/elim.cmx \ + lib/dyn.cmx tactics/dhyp.cmx kernel/declarations.cmx \ + library/decl_kinds.cmx parsing/coqast.cmx interp/constrintern.cmx \ + kernel/closure.cmx tactics/auto.cmx parsing/ast.cmx tactics/tacinterp.cmi +tactics/tacticals.cmo: lib/util.cmi pretyping/termops.cmi kernel/term.cmi \ + proofs/tacmach.cmi proofs/tacexpr.cmo kernel/sign.cmi proofs/refiner.cmi \ + kernel/reduction.cmi lib/pp.cmi pretyping/pattern.cmi kernel/names.cmi \ + pretyping/matching.cmi library/libnames.cmi kernel/inductive.cmi \ + pretyping/indrec.cmi library/global.cmi interp/genarg.cmi \ + proofs/evar_refiner.cmi kernel/environ.cmi kernel/declarations.cmi \ + proofs/clenv.cmi tactics/tacticals.cmi +tactics/tacticals.cmx: lib/util.cmx pretyping/termops.cmx kernel/term.cmx \ + proofs/tacmach.cmx proofs/tacexpr.cmx kernel/sign.cmx proofs/refiner.cmx \ + kernel/reduction.cmx lib/pp.cmx pretyping/pattern.cmx kernel/names.cmx \ + pretyping/matching.cmx library/libnames.cmx kernel/inductive.cmx \ + pretyping/indrec.cmx library/global.cmx interp/genarg.cmx \ + proofs/evar_refiner.cmx kernel/environ.cmx kernel/declarations.cmx \ + proofs/clenv.cmx tactics/tacticals.cmi +tactics/tactics.cmo: lib/util.cmi pretyping/termops.cmi kernel/term.cmi \ + tactics/tacticals.cmi pretyping/tacred.cmi proofs/tacmach.cmi \ + proofs/tacexpr.cmo kernel/sign.cmi proofs/refiner.cmi \ + pretyping/reductionops.cmi pretyping/rawterm.cmi proofs/proof_type.cmi \ + proofs/proof_trees.cmi lib/pp.cmi proofs/pfedit.cmi lib/options.cmi \ + library/nametab.cmi kernel/names.cmi library/nameops.cmi proofs/logic.cmi \ + library/libnames.cmi pretyping/inductiveops.cmi kernel/inductive.cmi \ + pretyping/indrec.cmi tactics/hipattern.cmi library/global.cmi \ + interp/genarg.cmi pretyping/evd.cmi proofs/evar_refiner.cmi \ + kernel/environ.cmi kernel/entries.cmi library/declare.cmi \ + kernel/declarations.cmi library/decl_kinds.cmo interp/coqlib.cmi \ + interp/constrintern.cmi proofs/clenv.cmi tactics/tactics.cmi +tactics/tactics.cmx: lib/util.cmx pretyping/termops.cmx kernel/term.cmx \ + tactics/tacticals.cmx pretyping/tacred.cmx proofs/tacmach.cmx \ + proofs/tacexpr.cmx kernel/sign.cmx proofs/refiner.cmx \ + pretyping/reductionops.cmx pretyping/rawterm.cmx proofs/proof_type.cmx \ + proofs/proof_trees.cmx lib/pp.cmx proofs/pfedit.cmx lib/options.cmx \ + library/nametab.cmx kernel/names.cmx library/nameops.cmx proofs/logic.cmx \ + library/libnames.cmx pretyping/inductiveops.cmx kernel/inductive.cmx \ + pretyping/indrec.cmx tactics/hipattern.cmx library/global.cmx \ + interp/genarg.cmx pretyping/evd.cmx proofs/evar_refiner.cmx \ + kernel/environ.cmx kernel/entries.cmx library/declare.cmx \ + kernel/declarations.cmx library/decl_kinds.cmx interp/coqlib.cmx \ + interp/constrintern.cmx proofs/clenv.cmx tactics/tactics.cmi +tactics/tauto.cmo: lib/util.cmi interp/topconstr.cmi tactics/tactics.cmi \ + tactics/tacticals.cmi tactics/tacinterp.cmi proofs/tacexpr.cmo \ + proofs/refiner.cmi pretyping/rawterm.cmi proofs/proof_type.cmi \ + parsing/pptactic.cmi lib/pp.cmi parsing/pcoq.cmi lib/options.cmi \ + kernel/names.cmi library/libnames.cmi tactics/hipattern.cmi \ + interp/genarg.cmi parsing/egrammar.cmi parsing/coqast.cmi \ + toplevel/cerrors.cmi parsing/ast.cmi +tactics/tauto.cmx: lib/util.cmx interp/topconstr.cmx tactics/tactics.cmx \ + tactics/tacticals.cmx tactics/tacinterp.cmx proofs/tacexpr.cmx \ + proofs/refiner.cmx pretyping/rawterm.cmx proofs/proof_type.cmx \ + parsing/pptactic.cmx lib/pp.cmx parsing/pcoq.cmx lib/options.cmx \ + kernel/names.cmx library/libnames.cmx tactics/hipattern.cmx \ + interp/genarg.cmx parsing/egrammar.cmx parsing/coqast.cmx \ + toplevel/cerrors.cmx parsing/ast.cmx +tactics/termdn.cmo: lib/util.cmi kernel/term.cmi pretyping/rawterm.cmi \ + pretyping/pattern.cmi library/nametab.cmi kernel/names.cmi \ + library/nameops.cmi library/libnames.cmi tactics/dn.cmi \ + tactics/termdn.cmi +tactics/termdn.cmx: lib/util.cmx kernel/term.cmx pretyping/rawterm.cmx \ + pretyping/pattern.cmx library/nametab.cmx kernel/names.cmx \ + library/nameops.cmx library/libnames.cmx tactics/dn.cmx \ + tactics/termdn.cmi +tools/coqdep.cmo: tools/coqdep_lexer.cmo config/coq_config.cmi +tools/coqdep.cmx: tools/coqdep_lexer.cmx config/coq_config.cmx tools/gallina.cmo: tools/gallina_lexer.cmo tools/gallina.cmx: tools/gallina_lexer.cmx -toplevel/cerrors.cmo: parsing/ast.cmi pretyping/cases.cmi toplevel/himsg.cmi \ - kernel/indtypes.cmi parsing/lexer.cmi library/libnames.cmi \ - proofs/logic.cmi library/nametab.cmi lib/options.cmi lib/pp.cmi \ - pretyping/pretype_errors.cmi proofs/refiner.cmi proofs/tactic_debug.cmi \ - kernel/type_errors.cmi kernel/univ.cmi lib/util.cmi toplevel/cerrors.cmi -toplevel/cerrors.cmx: parsing/ast.cmx pretyping/cases.cmx toplevel/himsg.cmx \ - kernel/indtypes.cmx parsing/lexer.cmx library/libnames.cmx \ - proofs/logic.cmx library/nametab.cmx lib/options.cmx lib/pp.cmx \ - pretyping/pretype_errors.cmx proofs/refiner.cmx proofs/tactic_debug.cmx \ - kernel/type_errors.cmx kernel/univ.cmx lib/util.cmx toplevel/cerrors.cmi -toplevel/class.cmo: pretyping/classops.cmi library/decl_kinds.cmo \ - kernel/declarations.cmi library/declare.cmi kernel/entries.cmi \ - kernel/environ.cmi pretyping/evd.cmi library/global.cmi \ - kernel/inductive.cmi library/lib.cmi library/libnames.cmi \ - library/nameops.cmi kernel/names.cmi library/nametab.cmi lib/options.cmi \ - lib/pp.cmi parsing/printer.cmi pretyping/reductionops.cmi \ - pretyping/retyping.cmi kernel/safe_typing.cmi kernel/sign.cmi \ - kernel/term.cmi pretyping/termops.cmi pretyping/typing.cmi lib/util.cmi \ +toplevel/cerrors.cmo: lib/util.cmi kernel/univ.cmi kernel/type_errors.cmi \ + proofs/tactic_debug.cmi proofs/refiner.cmi pretyping/pretype_errors.cmi \ + lib/pp.cmi lib/options.cmi library/nametab.cmi proofs/logic.cmi \ + library/libnames.cmi parsing/lexer.cmi kernel/indtypes.cmi \ + toplevel/himsg.cmi pretyping/cases.cmi parsing/ast.cmi \ + toplevel/cerrors.cmi +toplevel/cerrors.cmx: lib/util.cmx kernel/univ.cmx kernel/type_errors.cmx \ + proofs/tactic_debug.cmx proofs/refiner.cmx pretyping/pretype_errors.cmx \ + lib/pp.cmx lib/options.cmx library/nametab.cmx proofs/logic.cmx \ + library/libnames.cmx parsing/lexer.cmx kernel/indtypes.cmx \ + toplevel/himsg.cmx pretyping/cases.cmx parsing/ast.cmx \ + toplevel/cerrors.cmi +toplevel/class.cmo: lib/util.cmi pretyping/typing.cmi pretyping/termops.cmi \ + kernel/term.cmi kernel/sign.cmi kernel/safe_typing.cmi \ + pretyping/retyping.cmi pretyping/reductionops.cmi parsing/printer.cmi \ + lib/pp.cmi lib/options.cmi library/nametab.cmi kernel/names.cmi \ + library/nameops.cmi library/libnames.cmi library/lib.cmi \ + kernel/inductive.cmi library/global.cmi pretyping/evd.cmi \ + kernel/environ.cmi kernel/entries.cmi library/declare.cmi \ + kernel/declarations.cmi library/decl_kinds.cmo pretyping/classops.cmi \ toplevel/class.cmi -toplevel/class.cmx: pretyping/classops.cmx library/decl_kinds.cmx \ - kernel/declarations.cmx library/declare.cmx kernel/entries.cmx \ - kernel/environ.cmx pretyping/evd.cmx library/global.cmx \ - kernel/inductive.cmx library/lib.cmx library/libnames.cmx \ - library/nameops.cmx kernel/names.cmx library/nametab.cmx lib/options.cmx \ - lib/pp.cmx parsing/printer.cmx pretyping/reductionops.cmx \ - pretyping/retyping.cmx kernel/safe_typing.cmx kernel/sign.cmx \ - kernel/term.cmx pretyping/termops.cmx pretyping/typing.cmx lib/util.cmx \ +toplevel/class.cmx: lib/util.cmx pretyping/typing.cmx pretyping/termops.cmx \ + kernel/term.cmx kernel/sign.cmx kernel/safe_typing.cmx \ + pretyping/retyping.cmx pretyping/reductionops.cmx parsing/printer.cmx \ + lib/pp.cmx lib/options.cmx library/nametab.cmx kernel/names.cmx \ + library/nameops.cmx library/libnames.cmx library/lib.cmx \ + kernel/inductive.cmx library/global.cmx pretyping/evd.cmx \ + kernel/environ.cmx kernel/entries.cmx library/declare.cmx \ + kernel/declarations.cmx library/decl_kinds.cmx pretyping/classops.cmx \ toplevel/class.cmi -toplevel/command.cmo: toplevel/class.cmi interp/constrextern.cmi \ - interp/constrintern.cmi library/decl_kinds.cmo kernel/declarations.cmi \ - library/declare.cmi kernel/entries.cmi kernel/environ.cmi \ - pretyping/evarutil.cmi pretyping/evd.cmi library/global.cmi \ - library/impargs.cmi pretyping/indrec.cmi kernel/indtypes.cmi \ - kernel/inductive.cmi library/lib.cmi library/libnames.cmi \ - library/libobject.cmi library/library.cmi proofs/logic.cmi \ - toplevel/metasyntax.cmi library/nameops.cmi kernel/names.cmi \ - library/nametab.cmi lib/options.cmi proofs/pfedit.cmi lib/pp.cmi \ - pretyping/pretyping.cmi parsing/printer.cmi proofs/proof_type.cmi \ - kernel/reduction.cmi pretyping/reductionops.cmi pretyping/retyping.cmi \ - kernel/safe_typing.cmi library/states.cmi interp/symbols.cmi \ - interp/syntax_def.cmi proofs/tacmach.cmi pretyping/tacred.cmi \ - kernel/term.cmi pretyping/termops.cmi interp/topconstr.cmi \ - kernel/typeops.cmi lib/util.cmi toplevel/vernacexpr.cmo \ - toplevel/command.cmi -toplevel/command.cmx: toplevel/class.cmx interp/constrextern.cmx \ - interp/constrintern.cmx library/decl_kinds.cmx kernel/declarations.cmx \ - library/declare.cmx kernel/entries.cmx kernel/environ.cmx \ - pretyping/evarutil.cmx pretyping/evd.cmx library/global.cmx \ - library/impargs.cmx pretyping/indrec.cmx kernel/indtypes.cmx \ - kernel/inductive.cmx library/lib.cmx library/libnames.cmx \ - library/libobject.cmx library/library.cmx proofs/logic.cmx \ - toplevel/metasyntax.cmx library/nameops.cmx kernel/names.cmx \ - library/nametab.cmx lib/options.cmx proofs/pfedit.cmx lib/pp.cmx \ - pretyping/pretyping.cmx parsing/printer.cmx proofs/proof_type.cmx \ - kernel/reduction.cmx pretyping/reductionops.cmx pretyping/retyping.cmx \ - kernel/safe_typing.cmx library/states.cmx interp/symbols.cmx \ - interp/syntax_def.cmx proofs/tacmach.cmx pretyping/tacred.cmx \ - kernel/term.cmx pretyping/termops.cmx interp/topconstr.cmx \ - kernel/typeops.cmx lib/util.cmx toplevel/vernacexpr.cmx \ - toplevel/command.cmi -toplevel/coqinit.cmo: config/coq_config.cmi toplevel/mltop.cmi \ - library/nameops.cmi kernel/names.cmi lib/options.cmi lib/pp.cmi \ - lib/system.cmi toplevel/toplevel.cmi toplevel/vernac.cmi \ +toplevel/command.cmo: toplevel/vernacexpr.cmo lib/util.cmi kernel/typeops.cmi \ + interp/topconstr.cmi pretyping/termops.cmi kernel/term.cmi \ + pretyping/tacred.cmi proofs/tacmach.cmi interp/syntax_def.cmi \ + interp/symbols.cmi library/states.cmi kernel/safe_typing.cmi \ + pretyping/retyping.cmi pretyping/reductionops.cmi kernel/reduction.cmi \ + proofs/proof_type.cmi parsing/printer.cmi pretyping/pretyping.cmi \ + lib/pp.cmi proofs/pfedit.cmi lib/options.cmi library/nametab.cmi \ + kernel/names.cmi library/nameops.cmi toplevel/metasyntax.cmi \ + proofs/logic.cmi library/library.cmi library/libobject.cmi \ + library/libnames.cmi library/lib.cmi kernel/inductive.cmi \ + kernel/indtypes.cmi pretyping/indrec.cmi library/impargs.cmi \ + library/global.cmi pretyping/evd.cmi pretyping/evarutil.cmi \ + kernel/environ.cmi kernel/entries.cmi library/declare.cmi \ + kernel/declarations.cmi library/decl_kinds.cmo interp/constrintern.cmi \ + interp/constrextern.cmi toplevel/class.cmi toplevel/command.cmi +toplevel/command.cmx: toplevel/vernacexpr.cmx lib/util.cmx kernel/typeops.cmx \ + interp/topconstr.cmx pretyping/termops.cmx kernel/term.cmx \ + pretyping/tacred.cmx proofs/tacmach.cmx interp/syntax_def.cmx \ + interp/symbols.cmx library/states.cmx kernel/safe_typing.cmx \ + pretyping/retyping.cmx pretyping/reductionops.cmx kernel/reduction.cmx \ + proofs/proof_type.cmx parsing/printer.cmx pretyping/pretyping.cmx \ + lib/pp.cmx proofs/pfedit.cmx lib/options.cmx library/nametab.cmx \ + kernel/names.cmx library/nameops.cmx toplevel/metasyntax.cmx \ + proofs/logic.cmx library/library.cmx library/libobject.cmx \ + library/libnames.cmx library/lib.cmx kernel/inductive.cmx \ + kernel/indtypes.cmx pretyping/indrec.cmx library/impargs.cmx \ + library/global.cmx pretyping/evd.cmx pretyping/evarutil.cmx \ + kernel/environ.cmx kernel/entries.cmx library/declare.cmx \ + kernel/declarations.cmx library/decl_kinds.cmx interp/constrintern.cmx \ + interp/constrextern.cmx toplevel/class.cmx toplevel/command.cmi +toplevel/coqinit.cmo: toplevel/vernac.cmi toplevel/toplevel.cmi \ + lib/system.cmi lib/pp.cmi lib/options.cmi kernel/names.cmi \ + library/nameops.cmi toplevel/mltop.cmi config/coq_config.cmi \ toplevel/coqinit.cmi -toplevel/coqinit.cmx: config/coq_config.cmx toplevel/mltop.cmx \ - library/nameops.cmx kernel/names.cmx lib/options.cmx lib/pp.cmx \ - lib/system.cmx toplevel/toplevel.cmx toplevel/vernac.cmx \ +toplevel/coqinit.cmx: toplevel/vernac.cmx toplevel/toplevel.cmx \ + lib/system.cmx lib/pp.cmx lib/options.cmx kernel/names.cmx \ + library/nameops.cmx toplevel/mltop.cmx config/coq_config.cmx \ toplevel/coqinit.cmi -toplevel/coqtop.cmo: toplevel/cerrors.cmi config/coq_config.cmi \ - toplevel/coqinit.cmi library/declaremods.cmi kernel/environ.cmi \ - library/global.cmi library/lib.cmi library/libnames.cmi \ - library/library.cmi toplevel/mltop.cmi library/nameops.cmi \ - kernel/names.cmi lib/options.cmi lib/pp.cmi lib/profile.cmi \ - library/states.cmi lib/system.cmi toplevel/toplevel.cmi \ - toplevel/usage.cmi lib/util.cmi toplevel/vernac.cmi toplevel/coqtop.cmi -toplevel/coqtop.cmx: toplevel/cerrors.cmx config/coq_config.cmx \ - toplevel/coqinit.cmx library/declaremods.cmx kernel/environ.cmx \ - library/global.cmx library/lib.cmx library/libnames.cmx \ - library/library.cmx toplevel/mltop.cmx library/nameops.cmx \ - kernel/names.cmx lib/options.cmx lib/pp.cmx lib/profile.cmx \ - library/states.cmx lib/system.cmx toplevel/toplevel.cmx \ - toplevel/usage.cmx lib/util.cmx toplevel/vernac.cmx toplevel/coqtop.cmi -toplevel/discharge.cmo: toplevel/class.cmi pretyping/classops.cmi \ - kernel/cooking.cmi library/decl_kinds.cmo kernel/declarations.cmi \ - library/declare.cmi library/dischargedhypsmap.cmi kernel/entries.cmi \ - kernel/environ.cmi library/global.cmi library/impargs.cmi \ - kernel/indtypes.cmi kernel/inductive.cmi pretyping/instantiate.cmi \ - library/lib.cmi library/libnames.cmi library/libobject.cmi \ - library/library.cmi library/nameops.cmi kernel/names.cmi \ - library/nametab.cmi lib/options.cmi lib/pp.cmi toplevel/recordobj.cmi \ - pretyping/recordops.cmi kernel/reduction.cmi kernel/sign.cmi \ - library/summary.cmi kernel/term.cmi kernel/typeops.cmi kernel/univ.cmi \ - lib/util.cmi toplevel/discharge.cmi -toplevel/discharge.cmx: toplevel/class.cmx pretyping/classops.cmx \ - kernel/cooking.cmx library/decl_kinds.cmx kernel/declarations.cmx \ - library/declare.cmx library/dischargedhypsmap.cmx kernel/entries.cmx \ - kernel/environ.cmx library/global.cmx library/impargs.cmx \ - kernel/indtypes.cmx kernel/inductive.cmx pretyping/instantiate.cmx \ - library/lib.cmx library/libnames.cmx library/libobject.cmx \ - library/library.cmx library/nameops.cmx kernel/names.cmx \ - library/nametab.cmx lib/options.cmx lib/pp.cmx toplevel/recordobj.cmx \ - pretyping/recordops.cmx kernel/reduction.cmx kernel/sign.cmx \ - library/summary.cmx kernel/term.cmx kernel/typeops.cmx kernel/univ.cmx \ - lib/util.cmx toplevel/discharge.cmi -toplevel/fhimsg.cmo: kernel/environ.cmi parsing/g_minicoq.cmi \ - kernel/names.cmi lib/pp.cmi kernel/reduction.cmi kernel/sign.cmi \ - kernel/term.cmi kernel/type_errors.cmi lib/util.cmi toplevel/fhimsg.cmi -toplevel/fhimsg.cmx: kernel/environ.cmx parsing/g_minicoq.cmx \ - kernel/names.cmx lib/pp.cmx kernel/reduction.cmx kernel/sign.cmx \ - kernel/term.cmx kernel/type_errors.cmx lib/util.cmx toplevel/fhimsg.cmi -toplevel/himsg.cmo: parsing/ast.cmi pretyping/cases.cmi kernel/environ.cmi \ - pretyping/evd.cmi library/global.cmi library/impargs.cmi \ - kernel/indtypes.cmi kernel/inductive.cmi proofs/logic.cmi \ - library/nameops.cmi kernel/names.cmi library/nametab.cmi lib/options.cmi \ - lib/pp.cmi pretyping/pretype_errors.cmi parsing/printer.cmi \ - pretyping/rawterm.cmi kernel/reduction.cmi kernel/sign.cmi \ - kernel/term.cmi pretyping/termops.cmi kernel/type_errors.cmi lib/util.cmi \ - toplevel/himsg.cmi -toplevel/himsg.cmx: parsing/ast.cmx pretyping/cases.cmx kernel/environ.cmx \ - pretyping/evd.cmx library/global.cmx library/impargs.cmx \ - kernel/indtypes.cmx kernel/inductive.cmx proofs/logic.cmx \ - library/nameops.cmx kernel/names.cmx library/nametab.cmx lib/options.cmx \ - lib/pp.cmx pretyping/pretype_errors.cmx parsing/printer.cmx \ - pretyping/rawterm.cmx kernel/reduction.cmx kernel/sign.cmx \ - kernel/term.cmx pretyping/termops.cmx kernel/type_errors.cmx lib/util.cmx \ - toplevel/himsg.cmi +toplevel/coqtop.cmo: toplevel/vernac.cmi lib/util.cmi toplevel/usage.cmi \ + toplevel/toplevel.cmi lib/system.cmi library/states.cmi lib/profile.cmi \ + lib/pp.cmi lib/options.cmi kernel/names.cmi library/nameops.cmi \ + toplevel/mltop.cmi library/library.cmi library/libnames.cmi \ + library/lib.cmi library/global.cmi kernel/environ.cmi \ + library/declaremods.cmi toplevel/coqinit.cmi config/coq_config.cmi \ + toplevel/cerrors.cmi toplevel/coqtop.cmi +toplevel/coqtop.cmx: toplevel/vernac.cmx lib/util.cmx toplevel/usage.cmx \ + toplevel/toplevel.cmx lib/system.cmx library/states.cmx lib/profile.cmx \ + lib/pp.cmx lib/options.cmx kernel/names.cmx library/nameops.cmx \ + toplevel/mltop.cmx library/library.cmx library/libnames.cmx \ + library/lib.cmx library/global.cmx kernel/environ.cmx \ + library/declaremods.cmx toplevel/coqinit.cmx config/coq_config.cmx \ + toplevel/cerrors.cmx toplevel/coqtop.cmi +toplevel/discharge.cmo: lib/util.cmi kernel/univ.cmi kernel/typeops.cmi \ + kernel/term.cmi library/summary.cmi kernel/sign.cmi kernel/reduction.cmi \ + pretyping/recordops.cmi toplevel/recordobj.cmi lib/pp.cmi lib/options.cmi \ + library/nametab.cmi kernel/names.cmi library/nameops.cmi \ + library/library.cmi library/libobject.cmi library/libnames.cmi \ + library/lib.cmi pretyping/instantiate.cmi kernel/inductive.cmi \ + kernel/indtypes.cmi library/impargs.cmi library/global.cmi \ + kernel/environ.cmi kernel/entries.cmi library/dischargedhypsmap.cmi \ + library/declare.cmi kernel/declarations.cmi library/decl_kinds.cmo \ + kernel/cooking.cmi pretyping/classops.cmi toplevel/class.cmi \ + toplevel/discharge.cmi +toplevel/discharge.cmx: lib/util.cmx kernel/univ.cmx kernel/typeops.cmx \ + kernel/term.cmx library/summary.cmx kernel/sign.cmx kernel/reduction.cmx \ + pretyping/recordops.cmx toplevel/recordobj.cmx lib/pp.cmx lib/options.cmx \ + library/nametab.cmx kernel/names.cmx library/nameops.cmx \ + library/library.cmx library/libobject.cmx library/libnames.cmx \ + library/lib.cmx pretyping/instantiate.cmx kernel/inductive.cmx \ + kernel/indtypes.cmx library/impargs.cmx library/global.cmx \ + kernel/environ.cmx kernel/entries.cmx library/dischargedhypsmap.cmx \ + library/declare.cmx kernel/declarations.cmx library/decl_kinds.cmx \ + kernel/cooking.cmx pretyping/classops.cmx toplevel/class.cmx \ + toplevel/discharge.cmi +toplevel/fhimsg.cmo: lib/util.cmi kernel/type_errors.cmi kernel/term.cmi \ + kernel/sign.cmi kernel/reduction.cmi lib/pp.cmi kernel/names.cmi \ + parsing/g_minicoq.cmi kernel/environ.cmi toplevel/fhimsg.cmi +toplevel/fhimsg.cmx: lib/util.cmx kernel/type_errors.cmx kernel/term.cmx \ + kernel/sign.cmx kernel/reduction.cmx lib/pp.cmx kernel/names.cmx \ + parsing/g_minicoq.cmx kernel/environ.cmx toplevel/fhimsg.cmi +toplevel/himsg.cmo: lib/util.cmi kernel/type_errors.cmi pretyping/termops.cmi \ + kernel/term.cmi kernel/sign.cmi kernel/reduction.cmi \ + pretyping/rawterm.cmi parsing/printer.cmi pretyping/pretype_errors.cmi \ + lib/pp.cmi lib/options.cmi library/nametab.cmi kernel/names.cmi \ + library/nameops.cmi proofs/logic.cmi kernel/inductive.cmi \ + kernel/indtypes.cmi library/global.cmi pretyping/evd.cmi \ + kernel/environ.cmi pretyping/cases.cmi parsing/ast.cmi toplevel/himsg.cmi +toplevel/himsg.cmx: lib/util.cmx kernel/type_errors.cmx pretyping/termops.cmx \ + kernel/term.cmx kernel/sign.cmx kernel/reduction.cmx \ + pretyping/rawterm.cmx parsing/printer.cmx pretyping/pretype_errors.cmx \ + lib/pp.cmx lib/options.cmx library/nametab.cmx kernel/names.cmx \ + library/nameops.cmx proofs/logic.cmx kernel/inductive.cmx \ + kernel/indtypes.cmx library/global.cmx pretyping/evd.cmx \ + kernel/environ.cmx pretyping/cases.cmx parsing/ast.cmx toplevel/himsg.cmi toplevel/line_oriented_parser.cmo: toplevel/line_oriented_parser.cmi toplevel/line_oriented_parser.cmx: toplevel/line_oriented_parser.cmi -toplevel/metasyntax.cmo: parsing/ast.cmi pretyping/classops.cmi \ - interp/constrextern.cmi interp/constrintern.cmi parsing/coqast.cmi \ - parsing/egrammar.cmi parsing/esyntax.cmi pretyping/evd.cmi \ - parsing/extend.cmi interp/genarg.cmi library/global.cmi parsing/lexer.cmi \ - library/lib.cmi library/libnames.cmi library/libobject.cmi \ - library/library.cmi kernel/names.cmi library/nametab.cmi lib/options.cmi \ - parsing/pcoq.cmi lib/pp.cmi interp/ppextend.cmi parsing/pptactic.cmi \ - pretyping/rawterm.cmi library/summary.cmi interp/symbols.cmi \ - parsing/termast.cmi interp/topconstr.cmi lib/util.cmi \ - toplevel/vernacexpr.cmo toplevel/metasyntax.cmi -toplevel/metasyntax.cmx: parsing/ast.cmx pretyping/classops.cmx \ - interp/constrextern.cmx interp/constrintern.cmx parsing/coqast.cmx \ - parsing/egrammar.cmx parsing/esyntax.cmx pretyping/evd.cmx \ - parsing/extend.cmx interp/genarg.cmx library/global.cmx parsing/lexer.cmx \ - library/lib.cmx library/libnames.cmx library/libobject.cmx \ - library/library.cmx kernel/names.cmx library/nametab.cmx lib/options.cmx \ - parsing/pcoq.cmx lib/pp.cmx interp/ppextend.cmx parsing/pptactic.cmx \ - pretyping/rawterm.cmx library/summary.cmx interp/symbols.cmx \ - parsing/termast.cmx interp/topconstr.cmx lib/util.cmx \ - toplevel/vernacexpr.cmx toplevel/metasyntax.cmi -toplevel/minicoq.cmo: kernel/declarations.cmi toplevel/fhimsg.cmi \ - parsing/g_minicoq.cmi kernel/inductive.cmi kernel/names.cmi lib/pp.cmi \ - kernel/safe_typing.cmi kernel/sign.cmi kernel/term.cmi \ - kernel/type_errors.cmi lib/util.cmi -toplevel/minicoq.cmx: kernel/declarations.cmx toplevel/fhimsg.cmx \ - parsing/g_minicoq.cmx kernel/inductive.cmx kernel/names.cmx lib/pp.cmx \ - kernel/safe_typing.cmx kernel/sign.cmx kernel/term.cmx \ - kernel/type_errors.cmx lib/util.cmx -toplevel/mltop.cmo: library/lib.cmi library/libobject.cmi library/library.cmi \ - kernel/names.cmi lib/options.cmi lib/pp.cmi library/summary.cmi \ - lib/system.cmi lib/util.cmi toplevel/vernacinterp.cmi toplevel/mltop.cmi -toplevel/mltop.cmx: library/lib.cmx library/libobject.cmx library/library.cmx \ - kernel/names.cmx lib/options.cmx lib/pp.cmx library/summary.cmx \ - lib/system.cmx lib/util.cmx toplevel/vernacinterp.cmx toplevel/mltop.cmi -toplevel/protectedtoplevel.cmo: toplevel/cerrors.cmi \ - toplevel/line_oriented_parser.cmi parsing/pcoq.cmi lib/pp.cmi \ - toplevel/vernac.cmi toplevel/vernacexpr.cmo \ - toplevel/protectedtoplevel.cmi -toplevel/protectedtoplevel.cmx: toplevel/cerrors.cmx \ - toplevel/line_oriented_parser.cmx parsing/pcoq.cmx lib/pp.cmx \ - toplevel/vernac.cmx toplevel/vernacexpr.cmx \ - toplevel/protectedtoplevel.cmi -toplevel/record.cmo: toplevel/class.cmi toplevel/command.cmi \ - interp/constrintern.cmi parsing/coqast.cmi library/decl_kinds.cmo \ - kernel/declarations.cmi library/declare.cmi kernel/entries.cmi \ - kernel/environ.cmi pretyping/evd.cmi library/global.cmi \ - kernel/indtypes.cmi kernel/inductive.cmi pretyping/inductiveops.cmi \ - library/libnames.cmi library/nameops.cmi kernel/names.cmi \ - library/nametab.cmi lib/options.cmi lib/pp.cmi parsing/printer.cmi \ - pretyping/recordops.cmi kernel/safe_typing.cmi kernel/term.cmi \ - pretyping/termops.cmi interp/topconstr.cmi kernel/type_errors.cmi \ - lib/util.cmi toplevel/vernacexpr.cmo toplevel/record.cmi -toplevel/record.cmx: toplevel/class.cmx toplevel/command.cmx \ - interp/constrintern.cmx parsing/coqast.cmx library/decl_kinds.cmx \ - kernel/declarations.cmx library/declare.cmx kernel/entries.cmx \ - kernel/environ.cmx pretyping/evd.cmx library/global.cmx \ - kernel/indtypes.cmx kernel/inductive.cmx pretyping/inductiveops.cmx \ - library/libnames.cmx library/nameops.cmx kernel/names.cmx \ - library/nametab.cmx lib/options.cmx lib/pp.cmx parsing/printer.cmx \ - pretyping/recordops.cmx kernel/safe_typing.cmx kernel/term.cmx \ - pretyping/termops.cmx interp/topconstr.cmx kernel/type_errors.cmx \ - lib/util.cmx toplevel/vernacexpr.cmx toplevel/record.cmi -toplevel/recordobj.cmo: pretyping/classops.cmi library/declare.cmi \ - kernel/environ.cmi library/global.cmi pretyping/instantiate.cmi \ - library/lib.cmi library/libnames.cmi library/nameops.cmi kernel/names.cmi \ - library/nametab.cmi lib/pp.cmi pretyping/recordops.cmi kernel/term.cmi \ - lib/util.cmi toplevel/recordobj.cmi -toplevel/recordobj.cmx: pretyping/classops.cmx library/declare.cmx \ - kernel/environ.cmx library/global.cmx pretyping/instantiate.cmx \ - library/lib.cmx library/libnames.cmx library/nameops.cmx kernel/names.cmx \ - library/nametab.cmx lib/pp.cmx pretyping/recordops.cmx kernel/term.cmx \ - lib/util.cmx toplevel/recordobj.cmi -toplevel/toplevel.cmo: toplevel/cerrors.cmi library/lib.cmi \ - toplevel/mltop.cmi kernel/names.cmi lib/options.cmi parsing/pcoq.cmi \ - proofs/pfedit.cmi lib/pp.cmi toplevel/protectedtoplevel.cmi lib/util.cmi \ - toplevel/vernac.cmi toplevel/vernacexpr.cmo toplevel/toplevel.cmi -toplevel/toplevel.cmx: toplevel/cerrors.cmx library/lib.cmx \ - toplevel/mltop.cmx kernel/names.cmx lib/options.cmx parsing/pcoq.cmx \ - proofs/pfedit.cmx lib/pp.cmx toplevel/protectedtoplevel.cmx lib/util.cmx \ - toplevel/vernac.cmx toplevel/vernacexpr.cmx toplevel/toplevel.cmi +toplevel/metasyntax.cmo: toplevel/vernacexpr.cmo lib/util.cmi \ + interp/topconstr.cmi parsing/termast.cmi interp/symbols.cmi \ + library/summary.cmi pretyping/rawterm.cmi parsing/pptactic.cmi \ + interp/ppextend.cmi lib/pp.cmi parsing/pcoq.cmi lib/options.cmi \ + library/nametab.cmi kernel/names.cmi library/library.cmi \ + library/libobject.cmi library/libnames.cmi library/lib.cmi \ + parsing/lexer.cmi library/global.cmi interp/genarg.cmi parsing/extend.cmi \ + pretyping/evd.cmi parsing/esyntax.cmi parsing/egrammar.cmi \ + parsing/coqast.cmi interp/constrintern.cmi interp/constrextern.cmi \ + pretyping/classops.cmi parsing/ast.cmi toplevel/metasyntax.cmi +toplevel/metasyntax.cmx: toplevel/vernacexpr.cmx lib/util.cmx \ + interp/topconstr.cmx parsing/termast.cmx interp/symbols.cmx \ + library/summary.cmx pretyping/rawterm.cmx parsing/pptactic.cmx \ + interp/ppextend.cmx lib/pp.cmx parsing/pcoq.cmx lib/options.cmx \ + library/nametab.cmx kernel/names.cmx library/library.cmx \ + library/libobject.cmx library/libnames.cmx library/lib.cmx \ + parsing/lexer.cmx library/global.cmx interp/genarg.cmx parsing/extend.cmx \ + pretyping/evd.cmx parsing/esyntax.cmx parsing/egrammar.cmx \ + parsing/coqast.cmx interp/constrintern.cmx interp/constrextern.cmx \ + pretyping/classops.cmx parsing/ast.cmx toplevel/metasyntax.cmi +toplevel/minicoq.cmo: lib/util.cmi kernel/type_errors.cmi kernel/term.cmi \ + kernel/sign.cmi kernel/safe_typing.cmi lib/pp.cmi kernel/names.cmi \ + kernel/inductive.cmi parsing/g_minicoq.cmi toplevel/fhimsg.cmi \ + kernel/declarations.cmi +toplevel/minicoq.cmx: lib/util.cmx kernel/type_errors.cmx kernel/term.cmx \ + kernel/sign.cmx kernel/safe_typing.cmx lib/pp.cmx kernel/names.cmx \ + kernel/inductive.cmx parsing/g_minicoq.cmx toplevel/fhimsg.cmx \ + kernel/declarations.cmx +toplevel/mltop.cmo: toplevel/vernacinterp.cmi lib/util.cmi lib/system.cmi \ + library/summary.cmi lib/pp.cmi lib/options.cmi kernel/names.cmi \ + library/library.cmi library/libobject.cmi library/lib.cmi \ + toplevel/mltop.cmi +toplevel/mltop.cmx: toplevel/vernacinterp.cmx lib/util.cmx lib/system.cmx \ + library/summary.cmx lib/pp.cmx lib/options.cmx kernel/names.cmx \ + library/library.cmx library/libobject.cmx library/lib.cmx \ + toplevel/mltop.cmi +toplevel/protectedtoplevel.cmo: toplevel/vernacexpr.cmo toplevel/vernac.cmi \ + lib/pp.cmi parsing/pcoq.cmi toplevel/line_oriented_parser.cmi \ + toplevel/cerrors.cmi toplevel/protectedtoplevel.cmi +toplevel/protectedtoplevel.cmx: toplevel/vernacexpr.cmx toplevel/vernac.cmx \ + lib/pp.cmx parsing/pcoq.cmx toplevel/line_oriented_parser.cmx \ + toplevel/cerrors.cmx toplevel/protectedtoplevel.cmi +toplevel/record.cmo: toplevel/vernacexpr.cmo lib/util.cmi \ + kernel/type_errors.cmi interp/topconstr.cmi pretyping/termops.cmi \ + kernel/term.cmi kernel/safe_typing.cmi pretyping/recordops.cmi \ + parsing/printer.cmi lib/pp.cmi lib/options.cmi library/nametab.cmi \ + kernel/names.cmi library/nameops.cmi library/libnames.cmi \ + pretyping/inductiveops.cmi kernel/inductive.cmi kernel/indtypes.cmi \ + library/global.cmi pretyping/evd.cmi kernel/environ.cmi \ + kernel/entries.cmi library/declare.cmi kernel/declarations.cmi \ + library/decl_kinds.cmo parsing/coqast.cmi interp/constrintern.cmi \ + toplevel/command.cmi toplevel/class.cmi toplevel/record.cmi +toplevel/record.cmx: toplevel/vernacexpr.cmx lib/util.cmx \ + kernel/type_errors.cmx interp/topconstr.cmx pretyping/termops.cmx \ + kernel/term.cmx kernel/safe_typing.cmx pretyping/recordops.cmx \ + parsing/printer.cmx lib/pp.cmx lib/options.cmx library/nametab.cmx \ + kernel/names.cmx library/nameops.cmx library/libnames.cmx \ + pretyping/inductiveops.cmx kernel/inductive.cmx kernel/indtypes.cmx \ + library/global.cmx pretyping/evd.cmx kernel/environ.cmx \ + kernel/entries.cmx library/declare.cmx kernel/declarations.cmx \ + library/decl_kinds.cmx parsing/coqast.cmx interp/constrintern.cmx \ + toplevel/command.cmx toplevel/class.cmx toplevel/record.cmi +toplevel/recordobj.cmo: lib/util.cmi kernel/term.cmi pretyping/recordops.cmi \ + lib/pp.cmi library/nametab.cmi kernel/names.cmi library/nameops.cmi \ + library/libnames.cmi library/lib.cmi pretyping/instantiate.cmi \ + library/global.cmi kernel/environ.cmi library/declare.cmi \ + pretyping/classops.cmi toplevel/recordobj.cmi +toplevel/recordobj.cmx: lib/util.cmx kernel/term.cmx pretyping/recordops.cmx \ + lib/pp.cmx library/nametab.cmx kernel/names.cmx library/nameops.cmx \ + library/libnames.cmx library/lib.cmx pretyping/instantiate.cmx \ + library/global.cmx kernel/environ.cmx library/declare.cmx \ + pretyping/classops.cmx toplevel/recordobj.cmi +toplevel/toplevel.cmo: toplevel/vernacexpr.cmo toplevel/vernac.cmi \ + lib/util.cmi toplevel/protectedtoplevel.cmi lib/pp.cmi proofs/pfedit.cmi \ + parsing/pcoq.cmi lib/options.cmi kernel/names.cmi toplevel/mltop.cmi \ + library/lib.cmi toplevel/cerrors.cmi toplevel/toplevel.cmi +toplevel/toplevel.cmx: toplevel/vernacexpr.cmx toplevel/vernac.cmx \ + lib/util.cmx toplevel/protectedtoplevel.cmx lib/pp.cmx proofs/pfedit.cmx \ + parsing/pcoq.cmx lib/options.cmx kernel/names.cmx toplevel/mltop.cmx \ + library/lib.cmx toplevel/cerrors.cmx toplevel/toplevel.cmi toplevel/usage.cmo: config/coq_config.cmi toplevel/usage.cmi toplevel/usage.cmx: config/coq_config.cmx toplevel/usage.cmi -toplevel/vernacentries.cmo: tactics/auto.cmi toplevel/class.cmi \ - pretyping/classops.cmi toplevel/command.cmi interp/constrextern.cmi \ - interp/constrintern.cmi library/decl_kinds.cmo library/declaremods.cmi \ - pretyping/detyping.cmi toplevel/discharge.cmi kernel/entries.cmi \ - kernel/environ.cmi pretyping/evarutil.cmi pretyping/evd.cmi \ - library/global.cmi library/goptions.cmi library/impargs.cmi \ - pretyping/inductiveops.cmi library/lib.cmi library/libnames.cmi \ - library/library.cmi toplevel/metasyntax.cmi toplevel/mltop.cmi \ - interp/modintern.cmi library/nameops.cmi kernel/names.cmi \ - library/nametab.cmi lib/options.cmi proofs/pfedit.cmi lib/pp.cmi \ - lib/pp_control.cmi parsing/prettyp.cmi pretyping/pretyping.cmi \ - parsing/printer.cmi parsing/printmod.cmi proofs/proof_trees.cmi \ - proofs/proof_type.cmi pretyping/rawterm.cmi toplevel/record.cmi \ - toplevel/recordobj.cmi pretyping/reductionops.cmi proofs/refiner.cmi \ - interp/reserve.cmi kernel/safe_typing.cmi parsing/search.cmi \ - library/states.cmi interp/symbols.cmi interp/syntax_def.cmi \ - lib/system.cmi proofs/tacexpr.cmo tactics/tacinterp.cmi \ - proofs/tacmach.cmi pretyping/tacred.cmi proofs/tactic_debug.cmi \ - tactics/tactics.cmi kernel/term.cmi interp/topconstr.cmi \ - kernel/typeops.cmi kernel/univ.cmi lib/util.cmi toplevel/vernacexpr.cmo \ - toplevel/vernacinterp.cmi toplevel/vernacentries.cmi -toplevel/vernacentries.cmx: tactics/auto.cmx toplevel/class.cmx \ - pretyping/classops.cmx toplevel/command.cmx interp/constrextern.cmx \ - interp/constrintern.cmx library/decl_kinds.cmx library/declaremods.cmx \ - pretyping/detyping.cmx toplevel/discharge.cmx kernel/entries.cmx \ - kernel/environ.cmx pretyping/evarutil.cmx pretyping/evd.cmx \ - library/global.cmx library/goptions.cmx library/impargs.cmx \ - pretyping/inductiveops.cmx library/lib.cmx library/libnames.cmx \ - library/library.cmx toplevel/metasyntax.cmx toplevel/mltop.cmx \ - interp/modintern.cmx library/nameops.cmx kernel/names.cmx \ - library/nametab.cmx lib/options.cmx proofs/pfedit.cmx lib/pp.cmx \ - lib/pp_control.cmx parsing/prettyp.cmx pretyping/pretyping.cmx \ - parsing/printer.cmx parsing/printmod.cmx proofs/proof_trees.cmx \ - proofs/proof_type.cmx pretyping/rawterm.cmx toplevel/record.cmx \ - toplevel/recordobj.cmx pretyping/reductionops.cmx proofs/refiner.cmx \ - interp/reserve.cmx kernel/safe_typing.cmx parsing/search.cmx \ - library/states.cmx interp/symbols.cmx interp/syntax_def.cmx \ - lib/system.cmx proofs/tacexpr.cmx tactics/tacinterp.cmx \ - proofs/tacmach.cmx pretyping/tacred.cmx proofs/tactic_debug.cmx \ - tactics/tactics.cmx kernel/term.cmx interp/topconstr.cmx \ - kernel/typeops.cmx kernel/univ.cmx lib/util.cmx toplevel/vernacexpr.cmx \ - toplevel/vernacinterp.cmx toplevel/vernacentries.cmi -toplevel/vernacexpr.cmo: library/decl_kinds.cmo parsing/extend.cmi \ - interp/genarg.cmi library/goptions.cmi library/libnames.cmi \ - kernel/names.cmi library/nametab.cmi interp/ppextend.cmi \ - pretyping/rawterm.cmi proofs/tacexpr.cmo interp/topconstr.cmi \ - lib/util.cmi -toplevel/vernacexpr.cmx: library/decl_kinds.cmx parsing/extend.cmx \ - interp/genarg.cmx library/goptions.cmx library/libnames.cmx \ - kernel/names.cmx library/nametab.cmx interp/ppextend.cmx \ - pretyping/rawterm.cmx proofs/tacexpr.cmx interp/topconstr.cmx \ - lib/util.cmx -toplevel/vernacinterp.cmo: parsing/ast.cmi parsing/coqast.cmi \ - parsing/extend.cmi toplevel/himsg.cmi library/libnames.cmi \ - kernel/names.cmi lib/options.cmi lib/pp.cmi proofs/proof_type.cmi \ - proofs/tacexpr.cmo tactics/tacinterp.cmi lib/util.cmi \ - toplevel/vernacexpr.cmo toplevel/vernacinterp.cmi -toplevel/vernacinterp.cmx: parsing/ast.cmx parsing/coqast.cmx \ - parsing/extend.cmx toplevel/himsg.cmx library/libnames.cmx \ - kernel/names.cmx lib/options.cmx lib/pp.cmx proofs/proof_type.cmx \ - proofs/tacexpr.cmx tactics/tacinterp.cmx lib/util.cmx \ - toplevel/vernacexpr.cmx toplevel/vernacinterp.cmi -toplevel/vernac.cmo: interp/constrextern.cmi interp/constrintern.cmi \ - parsing/coqast.cmi parsing/lexer.cmi library/lib.cmi library/library.cmi \ - kernel/names.cmi lib/options.cmi parsing/pcoq.cmi proofs/pfedit.cmi \ - lib/pp.cmi translate/ppvernacnew.cmi proofs/refiner.cmi \ - library/states.cmi lib/system.cmi tactics/tacinterp.cmi \ - proofs/tacmach.cmi lib/util.cmi toplevel/vernacentries.cmi \ - toplevel/vernacexpr.cmo toplevel/vernacinterp.cmi toplevel/vernac.cmi -toplevel/vernac.cmx: interp/constrextern.cmx interp/constrintern.cmx \ - parsing/coqast.cmx parsing/lexer.cmx library/lib.cmx library/library.cmx \ - kernel/names.cmx lib/options.cmx parsing/pcoq.cmx proofs/pfedit.cmx \ - lib/pp.cmx translate/ppvernacnew.cmx proofs/refiner.cmx \ - library/states.cmx lib/system.cmx tactics/tacinterp.cmx \ - proofs/tacmach.cmx lib/util.cmx toplevel/vernacentries.cmx \ - toplevel/vernacexpr.cmx toplevel/vernacinterp.cmx toplevel/vernac.cmi -translate/ppconstrnew.cmo: parsing/ast.cmi lib/bignat.cmi \ - interp/constrextern.cmi interp/constrintern.cmi parsing/coqast.cmi \ - pretyping/evd.cmi interp/genarg.cmi library/global.cmi library/lib.cmi \ - library/libnames.cmi library/nameops.cmi kernel/names.cmi \ - library/nametab.cmi lib/options.cmi pretyping/pattern.cmi lib/pp.cmi \ - interp/ppextend.cmi pretyping/pretyping.cmi pretyping/rawterm.cmi \ - pretyping/retyping.cmi interp/symbols.cmi interp/syntax_def.cmi \ - kernel/term.cmi pretyping/termops.cmi interp/topconstr.cmi lib/util.cmi \ - translate/ppconstrnew.cmi -translate/ppconstrnew.cmx: parsing/ast.cmx lib/bignat.cmx \ - interp/constrextern.cmx interp/constrintern.cmx parsing/coqast.cmx \ - pretyping/evd.cmx interp/genarg.cmx library/global.cmx library/lib.cmx \ - library/libnames.cmx library/nameops.cmx kernel/names.cmx \ - library/nametab.cmx lib/options.cmx pretyping/pattern.cmx lib/pp.cmx \ - interp/ppextend.cmx pretyping/pretyping.cmx pretyping/rawterm.cmx \ - pretyping/retyping.cmx interp/symbols.cmx interp/syntax_def.cmx \ - kernel/term.cmx pretyping/termops.cmx interp/topconstr.cmx lib/util.cmx \ - translate/ppconstrnew.cmi -translate/pptacticnew.cmo: kernel/closure.cmi interp/constrextern.cmi \ - lib/dyn.cmi parsing/egrammar.cmi kernel/environ.cmi parsing/extend.cmi \ - interp/genarg.cmi library/global.cmi library/libnames.cmi \ - library/nameops.cmi kernel/names.cmi library/nametab.cmi lib/options.cmi \ - lib/pp.cmi translate/ppconstrnew.cmi interp/ppextend.cmi \ - parsing/pptactic.cmi pretyping/rawterm.cmi proofs/tacexpr.cmo \ - kernel/term.cmi pretyping/termops.cmi interp/topconstr.cmi lib/util.cmi \ - translate/pptacticnew.cmi -translate/pptacticnew.cmx: kernel/closure.cmx interp/constrextern.cmx \ - lib/dyn.cmx parsing/egrammar.cmx kernel/environ.cmx parsing/extend.cmx \ - interp/genarg.cmx library/global.cmx library/libnames.cmx \ - library/nameops.cmx kernel/names.cmx library/nametab.cmx lib/options.cmx \ - lib/pp.cmx translate/ppconstrnew.cmx interp/ppextend.cmx \ - parsing/pptactic.cmx pretyping/rawterm.cmx proofs/tacexpr.cmx \ - kernel/term.cmx pretyping/termops.cmx interp/topconstr.cmx lib/util.cmx \ - translate/pptacticnew.cmi -translate/ppvernacnew.cmo: parsing/ast.cmi interp/constrextern.cmi \ - interp/constrintern.cmi parsing/coqast.cmi library/decl_kinds.cmo \ - library/declaremods.cmi parsing/egrammar.cmi kernel/environ.cmi \ - pretyping/evd.cmi parsing/extend.cmi interp/genarg.cmi library/global.cmi \ - library/goptions.cmi library/impargs.cmi library/lib.cmi \ - library/libnames.cmi library/library.cmi toplevel/metasyntax.cmi \ - interp/modintern.cmi library/nameops.cmi kernel/names.cmi \ - library/nametab.cmi lib/options.cmi parsing/pcoq.cmi proofs/pfedit.cmi \ - lib/pp.cmi translate/ppconstrnew.cmi interp/ppextend.cmi \ - parsing/pptactic.cmi translate/pptacticnew.cmi pretyping/rawterm.cmi \ - proofs/tacexpr.cmo tactics/tacinterp.cmi kernel/term.cmi \ - pretyping/termops.cmi interp/topconstr.cmi lib/util.cmi \ - toplevel/vernacexpr.cmo translate/ppvernacnew.cmi -translate/ppvernacnew.cmx: parsing/ast.cmx interp/constrextern.cmx \ - interp/constrintern.cmx parsing/coqast.cmx library/decl_kinds.cmx \ - library/declaremods.cmx parsing/egrammar.cmx kernel/environ.cmx \ - pretyping/evd.cmx parsing/extend.cmx interp/genarg.cmx library/global.cmx \ - library/goptions.cmx library/impargs.cmx library/lib.cmx \ - library/libnames.cmx library/library.cmx toplevel/metasyntax.cmx \ - interp/modintern.cmx library/nameops.cmx kernel/names.cmx \ - library/nametab.cmx lib/options.cmx parsing/pcoq.cmx proofs/pfedit.cmx \ - lib/pp.cmx translate/ppconstrnew.cmx interp/ppextend.cmx \ - parsing/pptactic.cmx translate/pptacticnew.cmx pretyping/rawterm.cmx \ - proofs/tacexpr.cmx tactics/tacinterp.cmx kernel/term.cmx \ - pretyping/termops.cmx interp/topconstr.cmx lib/util.cmx \ - toplevel/vernacexpr.cmx translate/ppvernacnew.cmi -contrib/cc/ccalgo.cmo: kernel/names.cmi kernel/term.cmi lib/util.cmi \ +toplevel/vernac.cmo: toplevel/vernacinterp.cmi toplevel/vernacexpr.cmo \ + toplevel/vernacentries.cmi lib/util.cmi proofs/tacmach.cmi \ + tactics/tacinterp.cmi lib/system.cmi library/states.cmi \ + proofs/refiner.cmi translate/ppvernacnew.cmi lib/pp.cmi proofs/pfedit.cmi \ + parsing/pcoq.cmi lib/options.cmi kernel/names.cmi library/library.cmi \ + library/lib.cmi parsing/lexer.cmi parsing/coqast.cmi \ + interp/constrintern.cmi interp/constrextern.cmi toplevel/vernac.cmi +toplevel/vernac.cmx: toplevel/vernacinterp.cmx toplevel/vernacexpr.cmx \ + toplevel/vernacentries.cmx lib/util.cmx proofs/tacmach.cmx \ + tactics/tacinterp.cmx lib/system.cmx library/states.cmx \ + proofs/refiner.cmx translate/ppvernacnew.cmx lib/pp.cmx proofs/pfedit.cmx \ + parsing/pcoq.cmx lib/options.cmx kernel/names.cmx library/library.cmx \ + library/lib.cmx parsing/lexer.cmx parsing/coqast.cmx \ + interp/constrintern.cmx interp/constrextern.cmx toplevel/vernac.cmi +toplevel/vernacentries.cmo: toplevel/vernacinterp.cmi toplevel/vernacexpr.cmo \ + lib/util.cmi kernel/univ.cmi kernel/typeops.cmi interp/topconstr.cmi \ + kernel/term.cmi tactics/tactics.cmi proofs/tactic_debug.cmi \ + pretyping/tacred.cmi proofs/tacmach.cmi tactics/tacinterp.cmi \ + proofs/tacexpr.cmo lib/system.cmi interp/syntax_def.cmi \ + interp/symbols.cmi library/states.cmi parsing/search.cmi \ + kernel/safe_typing.cmi interp/reserve.cmi proofs/refiner.cmi \ + pretyping/reductionops.cmi toplevel/recordobj.cmi toplevel/record.cmi \ + pretyping/rawterm.cmi proofs/proof_type.cmi proofs/proof_trees.cmi \ + parsing/printmod.cmi parsing/printer.cmi pretyping/pretyping.cmi \ + parsing/prettyp.cmi lib/pp_control.cmi lib/pp.cmi proofs/pfedit.cmi \ + lib/options.cmi library/nametab.cmi kernel/names.cmi library/nameops.cmi \ + interp/modintern.cmi toplevel/mltop.cmi toplevel/metasyntax.cmi \ + library/library.cmi library/libnames.cmi library/lib.cmi \ + pretyping/inductiveops.cmi library/impargs.cmi library/goptions.cmi \ + library/global.cmi pretyping/evd.cmi pretyping/evarutil.cmi \ + kernel/environ.cmi kernel/entries.cmi toplevel/discharge.cmi \ + pretyping/detyping.cmi library/declaremods.cmi library/decl_kinds.cmo \ + interp/constrintern.cmi interp/constrextern.cmi toplevel/command.cmi \ + pretyping/classops.cmi toplevel/class.cmi tactics/auto.cmi \ + toplevel/vernacentries.cmi +toplevel/vernacentries.cmx: toplevel/vernacinterp.cmx toplevel/vernacexpr.cmx \ + lib/util.cmx kernel/univ.cmx kernel/typeops.cmx interp/topconstr.cmx \ + kernel/term.cmx tactics/tactics.cmx proofs/tactic_debug.cmx \ + pretyping/tacred.cmx proofs/tacmach.cmx tactics/tacinterp.cmx \ + proofs/tacexpr.cmx lib/system.cmx interp/syntax_def.cmx \ + interp/symbols.cmx library/states.cmx parsing/search.cmx \ + kernel/safe_typing.cmx interp/reserve.cmx proofs/refiner.cmx \ + pretyping/reductionops.cmx toplevel/recordobj.cmx toplevel/record.cmx \ + pretyping/rawterm.cmx proofs/proof_type.cmx proofs/proof_trees.cmx \ + parsing/printmod.cmx parsing/printer.cmx pretyping/pretyping.cmx \ + parsing/prettyp.cmx lib/pp_control.cmx lib/pp.cmx proofs/pfedit.cmx \ + lib/options.cmx library/nametab.cmx kernel/names.cmx library/nameops.cmx \ + interp/modintern.cmx toplevel/mltop.cmx toplevel/metasyntax.cmx \ + library/library.cmx library/libnames.cmx library/lib.cmx \ + pretyping/inductiveops.cmx library/impargs.cmx library/goptions.cmx \ + library/global.cmx pretyping/evd.cmx pretyping/evarutil.cmx \ + kernel/environ.cmx kernel/entries.cmx toplevel/discharge.cmx \ + pretyping/detyping.cmx library/declaremods.cmx library/decl_kinds.cmx \ + interp/constrintern.cmx interp/constrextern.cmx toplevel/command.cmx \ + pretyping/classops.cmx toplevel/class.cmx tactics/auto.cmx \ + toplevel/vernacentries.cmi +toplevel/vernacexpr.cmo: lib/util.cmi interp/topconstr.cmi proofs/tacexpr.cmo \ + pretyping/rawterm.cmi interp/ppextend.cmi library/nametab.cmi \ + kernel/names.cmi library/libnames.cmi library/goptions.cmi \ + interp/genarg.cmi parsing/extend.cmi library/decl_kinds.cmo +toplevel/vernacexpr.cmx: lib/util.cmx interp/topconstr.cmx proofs/tacexpr.cmx \ + pretyping/rawterm.cmx interp/ppextend.cmx library/nametab.cmx \ + kernel/names.cmx library/libnames.cmx library/goptions.cmx \ + interp/genarg.cmx parsing/extend.cmx library/decl_kinds.cmx +toplevel/vernacinterp.cmo: toplevel/vernacexpr.cmo lib/util.cmi \ + tactics/tacinterp.cmi proofs/tacexpr.cmo proofs/proof_type.cmi lib/pp.cmi \ + lib/options.cmi kernel/names.cmi library/libnames.cmi toplevel/himsg.cmi \ + parsing/extend.cmi parsing/coqast.cmi parsing/ast.cmi \ + toplevel/vernacinterp.cmi +toplevel/vernacinterp.cmx: toplevel/vernacexpr.cmx lib/util.cmx \ + tactics/tacinterp.cmx proofs/tacexpr.cmx proofs/proof_type.cmx lib/pp.cmx \ + lib/options.cmx kernel/names.cmx library/libnames.cmx toplevel/himsg.cmx \ + parsing/extend.cmx parsing/coqast.cmx parsing/ast.cmx \ + toplevel/vernacinterp.cmi +translate/ppconstrnew.cmo: lib/util.cmi interp/topconstr.cmi \ + pretyping/termops.cmi kernel/term.cmi interp/syntax_def.cmi \ + interp/symbols.cmi pretyping/retyping.cmi pretyping/rawterm.cmi \ + pretyping/pretyping.cmi interp/ppextend.cmi lib/pp.cmi \ + pretyping/pattern.cmi lib/options.cmi library/nametab.cmi \ + kernel/names.cmi library/nameops.cmi library/libnames.cmi library/lib.cmi \ + library/global.cmi interp/genarg.cmi pretyping/evd.cmi parsing/coqast.cmi \ + interp/constrintern.cmi interp/constrextern.cmi lib/bignat.cmi \ + parsing/ast.cmi translate/ppconstrnew.cmi +translate/ppconstrnew.cmx: lib/util.cmx interp/topconstr.cmx \ + pretyping/termops.cmx kernel/term.cmx interp/syntax_def.cmx \ + interp/symbols.cmx pretyping/retyping.cmx pretyping/rawterm.cmx \ + pretyping/pretyping.cmx interp/ppextend.cmx lib/pp.cmx \ + pretyping/pattern.cmx lib/options.cmx library/nametab.cmx \ + kernel/names.cmx library/nameops.cmx library/libnames.cmx library/lib.cmx \ + library/global.cmx interp/genarg.cmx pretyping/evd.cmx parsing/coqast.cmx \ + interp/constrintern.cmx interp/constrextern.cmx lib/bignat.cmx \ + parsing/ast.cmx translate/ppconstrnew.cmi +translate/pptacticnew.cmo: lib/util.cmi interp/topconstr.cmi \ + pretyping/termops.cmi kernel/term.cmi proofs/tacexpr.cmo \ + pretyping/rawterm.cmi parsing/pptactic.cmi interp/ppextend.cmi \ + translate/ppconstrnew.cmi lib/pp.cmi lib/options.cmi library/nametab.cmi \ + kernel/names.cmi library/nameops.cmi library/libnames.cmi \ + library/global.cmi interp/genarg.cmi parsing/extend.cmi \ + kernel/environ.cmi parsing/egrammar.cmi lib/dyn.cmi \ + interp/constrextern.cmi kernel/closure.cmi translate/pptacticnew.cmi +translate/pptacticnew.cmx: lib/util.cmx interp/topconstr.cmx \ + pretyping/termops.cmx kernel/term.cmx proofs/tacexpr.cmx \ + pretyping/rawterm.cmx parsing/pptactic.cmx interp/ppextend.cmx \ + translate/ppconstrnew.cmx lib/pp.cmx lib/options.cmx library/nametab.cmx \ + kernel/names.cmx library/nameops.cmx library/libnames.cmx \ + library/global.cmx interp/genarg.cmx parsing/extend.cmx \ + kernel/environ.cmx parsing/egrammar.cmx lib/dyn.cmx \ + interp/constrextern.cmx kernel/closure.cmx translate/pptacticnew.cmi +translate/ppvernacnew.cmo: toplevel/vernacexpr.cmo lib/util.cmi \ + interp/topconstr.cmi pretyping/termops.cmi kernel/term.cmi \ + tactics/tacinterp.cmi proofs/tacexpr.cmo pretyping/rawterm.cmi \ + translate/pptacticnew.cmi parsing/pptactic.cmi interp/ppextend.cmi \ + translate/ppconstrnew.cmi lib/pp.cmi proofs/pfedit.cmi parsing/pcoq.cmi \ + lib/options.cmi library/nametab.cmi kernel/names.cmi library/nameops.cmi \ + interp/modintern.cmi toplevel/metasyntax.cmi library/library.cmi \ + library/libnames.cmi library/lib.cmi library/impargs.cmi \ + library/goptions.cmi library/global.cmi interp/genarg.cmi \ + parsing/extend.cmi pretyping/evd.cmi kernel/environ.cmi \ + parsing/egrammar.cmi library/declaremods.cmi library/decl_kinds.cmo \ + parsing/coqast.cmi interp/constrintern.cmi interp/constrextern.cmi \ + parsing/ast.cmi translate/ppvernacnew.cmi +translate/ppvernacnew.cmx: toplevel/vernacexpr.cmx lib/util.cmx \ + interp/topconstr.cmx pretyping/termops.cmx kernel/term.cmx \ + tactics/tacinterp.cmx proofs/tacexpr.cmx pretyping/rawterm.cmx \ + translate/pptacticnew.cmx parsing/pptactic.cmx interp/ppextend.cmx \ + translate/ppconstrnew.cmx lib/pp.cmx proofs/pfedit.cmx parsing/pcoq.cmx \ + lib/options.cmx library/nametab.cmx kernel/names.cmx library/nameops.cmx \ + interp/modintern.cmx toplevel/metasyntax.cmx library/library.cmx \ + library/libnames.cmx library/lib.cmx library/impargs.cmx \ + library/goptions.cmx library/global.cmx interp/genarg.cmx \ + parsing/extend.cmx pretyping/evd.cmx kernel/environ.cmx \ + parsing/egrammar.cmx library/declaremods.cmx library/decl_kinds.cmx \ + parsing/coqast.cmx interp/constrintern.cmx interp/constrextern.cmx \ + parsing/ast.cmx translate/ppvernacnew.cmi +contrib/cc/ccalgo.cmo: lib/util.cmi kernel/term.cmi kernel/names.cmi \ contrib/cc/ccalgo.cmi -contrib/cc/ccalgo.cmx: kernel/names.cmx kernel/term.cmx lib/util.cmx \ +contrib/cc/ccalgo.cmx: lib/util.cmx kernel/term.cmx kernel/names.cmx \ contrib/cc/ccalgo.cmi -contrib/cc/ccproof.cmo: contrib/cc/ccalgo.cmi kernel/names.cmi lib/pp.cmi \ - lib/util.cmi contrib/cc/ccproof.cmi -contrib/cc/ccproof.cmx: contrib/cc/ccalgo.cmx kernel/names.cmx lib/pp.cmx \ - lib/util.cmx contrib/cc/ccproof.cmi -contrib/cc/cctac.cmo: contrib/cc/ccalgo.cmi contrib/cc/ccproof.cmi \ - toplevel/cerrors.cmi interp/coqlib.cmi kernel/declarations.cmi \ - parsing/egrammar.cmi pretyping/evd.cmi library/global.cmi \ - kernel/inductive.cmi pretyping/inductiveops.cmi library/libnames.cmi \ - library/library.cmi library/nameops.cmi kernel/names.cmi lib/options.cmi \ - parsing/pcoq.cmi lib/pp.cmi parsing/pptactic.cmi proofs/proof_type.cmi \ - proofs/refiner.cmi kernel/sign.cmi proofs/tacexpr.cmo \ - tactics/tacinterp.cmi proofs/tacmach.cmi tactics/tacticals.cmi \ - tactics/tactics.cmi kernel/term.cmi pretyping/termops.cmi lib/util.cmi -contrib/cc/cctac.cmx: contrib/cc/ccalgo.cmx contrib/cc/ccproof.cmx \ - toplevel/cerrors.cmx interp/coqlib.cmx kernel/declarations.cmx \ - parsing/egrammar.cmx pretyping/evd.cmx library/global.cmx \ - kernel/inductive.cmx pretyping/inductiveops.cmx library/libnames.cmx \ - library/library.cmx library/nameops.cmx kernel/names.cmx lib/options.cmx \ - parsing/pcoq.cmx lib/pp.cmx parsing/pptactic.cmx proofs/proof_type.cmx \ - proofs/refiner.cmx kernel/sign.cmx proofs/tacexpr.cmx \ - tactics/tacinterp.cmx proofs/tacmach.cmx tactics/tacticals.cmx \ - tactics/tactics.cmx kernel/term.cmx pretyping/termops.cmx lib/util.cmx -contrib/correctness/pcicenv.cmo: library/global.cmi kernel/names.cmi \ - kernel/sign.cmi kernel/term.cmi kernel/univ.cmi \ +contrib/cc/ccproof.cmo: lib/util.cmi lib/pp.cmi kernel/names.cmi \ + contrib/cc/ccalgo.cmi contrib/cc/ccproof.cmi +contrib/cc/ccproof.cmx: lib/util.cmx lib/pp.cmx kernel/names.cmx \ + contrib/cc/ccalgo.cmx contrib/cc/ccproof.cmi +contrib/cc/cctac.cmo: lib/util.cmi pretyping/termops.cmi kernel/term.cmi \ + tactics/tactics.cmi tactics/tacticals.cmi proofs/tacmach.cmi \ + tactics/tacinterp.cmi proofs/tacexpr.cmo kernel/sign.cmi \ + proofs/refiner.cmi proofs/proof_type.cmi parsing/pptactic.cmi lib/pp.cmi \ + parsing/pcoq.cmi lib/options.cmi kernel/names.cmi library/nameops.cmi \ + library/library.cmi library/libnames.cmi pretyping/inductiveops.cmi \ + kernel/inductive.cmi library/global.cmi pretyping/evd.cmi \ + parsing/egrammar.cmi kernel/declarations.cmi interp/coqlib.cmi \ + toplevel/cerrors.cmi contrib/cc/ccproof.cmi contrib/cc/ccalgo.cmi +contrib/cc/cctac.cmx: lib/util.cmx pretyping/termops.cmx kernel/term.cmx \ + tactics/tactics.cmx tactics/tacticals.cmx proofs/tacmach.cmx \ + tactics/tacinterp.cmx proofs/tacexpr.cmx kernel/sign.cmx \ + proofs/refiner.cmx proofs/proof_type.cmx parsing/pptactic.cmx lib/pp.cmx \ + parsing/pcoq.cmx lib/options.cmx kernel/names.cmx library/nameops.cmx \ + library/library.cmx library/libnames.cmx pretyping/inductiveops.cmx \ + kernel/inductive.cmx library/global.cmx pretyping/evd.cmx \ + parsing/egrammar.cmx kernel/declarations.cmx interp/coqlib.cmx \ + toplevel/cerrors.cmx contrib/cc/ccproof.cmx contrib/cc/ccalgo.cmx +contrib/correctness/pcic.cmo: toplevel/vernacexpr.cmo lib/util.cmi \ + kernel/typeops.cmi interp/topconstr.cmi pretyping/termops.cmi \ + kernel/term.cmi kernel/sign.cmi toplevel/record.cmi pretyping/rawterm.cmi \ + library/nametab.cmi kernel/names.cmi library/nameops.cmi \ + library/libnames.cmi kernel/indtypes.cmi library/global.cmi \ + kernel/entries.cmi pretyping/detyping.cmi library/declare.cmi \ + kernel/declarations.cmi contrib/correctness/pcic.cmi +contrib/correctness/pcic.cmx: toplevel/vernacexpr.cmx lib/util.cmx \ + kernel/typeops.cmx interp/topconstr.cmx pretyping/termops.cmx \ + kernel/term.cmx kernel/sign.cmx toplevel/record.cmx pretyping/rawterm.cmx \ + library/nametab.cmx kernel/names.cmx library/nameops.cmx \ + library/libnames.cmx kernel/indtypes.cmx library/global.cmx \ + kernel/entries.cmx pretyping/detyping.cmx library/declare.cmx \ + kernel/declarations.cmx contrib/correctness/pcic.cmi +contrib/correctness/pcicenv.cmo: kernel/univ.cmi kernel/term.cmi \ + kernel/sign.cmi kernel/names.cmi library/global.cmi \ contrib/correctness/pcicenv.cmi -contrib/correctness/pcicenv.cmx: library/global.cmx kernel/names.cmx \ - kernel/sign.cmx kernel/term.cmx kernel/univ.cmx \ +contrib/correctness/pcicenv.cmx: kernel/univ.cmx kernel/term.cmx \ + kernel/sign.cmx kernel/names.cmx library/global.cmx \ contrib/correctness/pcicenv.cmi -contrib/correctness/pcic.cmo: kernel/declarations.cmi library/declare.cmi \ - pretyping/detyping.cmi kernel/entries.cmi library/global.cmi \ - kernel/indtypes.cmi library/libnames.cmi library/nameops.cmi \ - kernel/names.cmi library/nametab.cmi pretyping/rawterm.cmi \ - toplevel/record.cmi kernel/sign.cmi kernel/term.cmi pretyping/termops.cmi \ - interp/topconstr.cmi kernel/typeops.cmi lib/util.cmi \ - toplevel/vernacexpr.cmo contrib/correctness/pcic.cmi -contrib/correctness/pcic.cmx: kernel/declarations.cmx library/declare.cmx \ - pretyping/detyping.cmx kernel/entries.cmx library/global.cmx \ - kernel/indtypes.cmx library/libnames.cmx library/nameops.cmx \ - kernel/names.cmx library/nametab.cmx pretyping/rawterm.cmx \ - toplevel/record.cmx kernel/sign.cmx kernel/term.cmx pretyping/termops.cmx \ - interp/topconstr.cmx kernel/typeops.cmx lib/util.cmx \ - toplevel/vernacexpr.cmx contrib/correctness/pcic.cmi -contrib/correctness/pdb.cmo: interp/constrintern.cmi library/global.cmi \ - kernel/names.cmi library/nametab.cmi kernel/term.cmi \ - pretyping/termops.cmi contrib/correctness/pdb.cmi -contrib/correctness/pdb.cmx: interp/constrintern.cmx library/global.cmx \ - kernel/names.cmx library/nametab.cmx kernel/term.cmx \ - pretyping/termops.cmx contrib/correctness/pdb.cmi -contrib/correctness/peffect.cmo: toplevel/himsg.cmi library/nameops.cmi \ - kernel/names.cmi lib/pp.cmi lib/util.cmi contrib/correctness/peffect.cmi -contrib/correctness/peffect.cmx: toplevel/himsg.cmx library/nameops.cmx \ - kernel/names.cmx lib/pp.cmx lib/util.cmx contrib/correctness/peffect.cmi -contrib/correctness/penv.cmo: toplevel/himsg.cmi library/lib.cmi \ - library/libobject.cmi library/library.cmi library/nameops.cmi \ - kernel/names.cmi lib/options.cmi lib/pp.cmi library/summary.cmi \ - kernel/term.cmi contrib/correctness/penv.cmi -contrib/correctness/penv.cmx: toplevel/himsg.cmx library/lib.cmx \ - library/libobject.cmx library/library.cmx library/nameops.cmx \ - kernel/names.cmx lib/options.cmx lib/pp.cmx library/summary.cmx \ - kernel/term.cmx contrib/correctness/penv.cmi -contrib/correctness/perror.cmo: interp/constrintern.cmi pretyping/evd.cmi \ - library/global.cmi toplevel/himsg.cmi library/nameops.cmi \ - kernel/names.cmi lib/pp.cmi pretyping/reductionops.cmi kernel/term.cmi \ - lib/util.cmi contrib/correctness/perror.cmi -contrib/correctness/perror.cmx: interp/constrintern.cmx pretyping/evd.cmx \ - library/global.cmx toplevel/himsg.cmx library/nameops.cmx \ - kernel/names.cmx lib/pp.cmx pretyping/reductionops.cmx kernel/term.cmx \ - lib/util.cmx contrib/correctness/perror.cmi -contrib/correctness/pextract.cmo: parsing/ast.cmi pretyping/evd.cmi \ - toplevel/himsg.cmi library/library.cmi kernel/names.cmi \ - library/nametab.cmi contrib/extraction/ocaml.cmi lib/pp.cmi \ - lib/pp_control.cmi kernel/reduction.cmi pretyping/reductionops.cmi \ - lib/system.cmi kernel/term.cmi lib/util.cmi toplevel/vernacinterp.cmi \ +contrib/correctness/pdb.cmo: pretyping/termops.cmi kernel/term.cmi \ + library/nametab.cmi kernel/names.cmi library/global.cmi \ + interp/constrintern.cmi contrib/correctness/pdb.cmi +contrib/correctness/pdb.cmx: pretyping/termops.cmx kernel/term.cmx \ + library/nametab.cmx kernel/names.cmx library/global.cmx \ + interp/constrintern.cmx contrib/correctness/pdb.cmi +contrib/correctness/peffect.cmo: lib/util.cmi lib/pp.cmi kernel/names.cmi \ + library/nameops.cmi toplevel/himsg.cmi contrib/correctness/peffect.cmi +contrib/correctness/peffect.cmx: lib/util.cmx lib/pp.cmx kernel/names.cmx \ + library/nameops.cmx toplevel/himsg.cmx contrib/correctness/peffect.cmi +contrib/correctness/penv.cmo: kernel/term.cmi library/summary.cmi lib/pp.cmi \ + lib/options.cmi kernel/names.cmi library/nameops.cmi library/library.cmi \ + library/libobject.cmi library/lib.cmi toplevel/himsg.cmi \ + contrib/correctness/penv.cmi +contrib/correctness/penv.cmx: kernel/term.cmx library/summary.cmx lib/pp.cmx \ + lib/options.cmx kernel/names.cmx library/nameops.cmx library/library.cmx \ + library/libobject.cmx library/lib.cmx toplevel/himsg.cmx \ + contrib/correctness/penv.cmi +contrib/correctness/perror.cmo: lib/util.cmi kernel/term.cmi \ + pretyping/reductionops.cmi lib/pp.cmi kernel/names.cmi \ + library/nameops.cmi toplevel/himsg.cmi library/global.cmi \ + pretyping/evd.cmi interp/constrintern.cmi contrib/correctness/perror.cmi +contrib/correctness/perror.cmx: lib/util.cmx kernel/term.cmx \ + pretyping/reductionops.cmx lib/pp.cmx kernel/names.cmx \ + library/nameops.cmx toplevel/himsg.cmx library/global.cmx \ + pretyping/evd.cmx interp/constrintern.cmx contrib/correctness/perror.cmi +contrib/correctness/pextract.cmo: toplevel/vernacinterp.cmi lib/util.cmi \ + kernel/term.cmi lib/system.cmi pretyping/reductionops.cmi \ + kernel/reduction.cmi lib/pp_control.cmi lib/pp.cmi \ + contrib/extraction/ocaml.cmi library/nametab.cmi kernel/names.cmi \ + library/library.cmi toplevel/himsg.cmi pretyping/evd.cmi parsing/ast.cmi \ contrib/correctness/pextract.cmi -contrib/correctness/pextract.cmx: parsing/ast.cmx pretyping/evd.cmx \ - toplevel/himsg.cmx library/library.cmx kernel/names.cmx \ - library/nametab.cmx contrib/extraction/ocaml.cmx lib/pp.cmx \ - lib/pp_control.cmx kernel/reduction.cmx pretyping/reductionops.cmx \ - lib/system.cmx kernel/term.cmx lib/util.cmx toplevel/vernacinterp.cmx \ +contrib/correctness/pextract.cmx: toplevel/vernacinterp.cmx lib/util.cmx \ + kernel/term.cmx lib/system.cmx pretyping/reductionops.cmx \ + kernel/reduction.cmx lib/pp_control.cmx lib/pp.cmx \ + contrib/extraction/ocaml.cmx library/nametab.cmx kernel/names.cmx \ + library/library.cmx toplevel/himsg.cmx pretyping/evd.cmx parsing/ast.cmx \ contrib/correctness/pextract.cmi -contrib/correctness/pmisc.cmo: interp/constrextern.cmi \ - interp/constrintern.cmi pretyping/evarutil.cmi library/global.cmi \ - library/libnames.cmi library/nameops.cmi kernel/names.cmi lib/options.cmi \ - lib/pp.cmi kernel/term.cmi interp/topconstr.cmi lib/util.cmi \ +contrib/correctness/pmisc.cmo: lib/util.cmi interp/topconstr.cmi \ + kernel/term.cmi lib/pp.cmi lib/options.cmi kernel/names.cmi \ + library/nameops.cmi library/libnames.cmi library/global.cmi \ + pretyping/evarutil.cmi interp/constrintern.cmi interp/constrextern.cmi \ contrib/correctness/pmisc.cmi -contrib/correctness/pmisc.cmx: interp/constrextern.cmx \ - interp/constrintern.cmx pretyping/evarutil.cmx library/global.cmx \ - library/libnames.cmx library/nameops.cmx kernel/names.cmx lib/options.cmx \ - lib/pp.cmx kernel/term.cmx interp/topconstr.cmx lib/util.cmx \ +contrib/correctness/pmisc.cmx: lib/util.cmx interp/topconstr.cmx \ + kernel/term.cmx lib/pp.cmx lib/options.cmx kernel/names.cmx \ + library/nameops.cmx library/libnames.cmx library/global.cmx \ + pretyping/evarutil.cmx interp/constrintern.cmx interp/constrextern.cmx \ contrib/correctness/pmisc.cmi -contrib/correctness/pmlize.cmo: pretyping/evd.cmi library/global.cmi \ - tactics/hipattern.cmi pretyping/matching.cmi kernel/names.cmi \ - pretyping/pattern.cmi pretyping/reductionops.cmi kernel/term.cmi \ - parsing/termast.cmi pretyping/typing.cmi lib/util.cmi \ +contrib/correctness/pmlize.cmo: lib/util.cmi pretyping/typing.cmi \ + parsing/termast.cmi kernel/term.cmi pretyping/reductionops.cmi \ + pretyping/pattern.cmi kernel/names.cmi pretyping/matching.cmi \ + tactics/hipattern.cmi library/global.cmi pretyping/evd.cmi \ contrib/correctness/pmlize.cmi -contrib/correctness/pmlize.cmx: pretyping/evd.cmx library/global.cmx \ - tactics/hipattern.cmx pretyping/matching.cmx kernel/names.cmx \ - pretyping/pattern.cmx pretyping/reductionops.cmx kernel/term.cmx \ - parsing/termast.cmx pretyping/typing.cmx lib/util.cmx \ +contrib/correctness/pmlize.cmx: lib/util.cmx pretyping/typing.cmx \ + parsing/termast.cmx kernel/term.cmx pretyping/reductionops.cmx \ + pretyping/pattern.cmx kernel/names.cmx pretyping/matching.cmx \ + tactics/hipattern.cmx library/global.cmx pretyping/evd.cmx \ contrib/correctness/pmlize.cmi -contrib/correctness/pmonad.cmo: kernel/names.cmi kernel/term.cmi \ - parsing/termast.cmi lib/util.cmi contrib/correctness/pmonad.cmi -contrib/correctness/pmonad.cmx: kernel/names.cmx kernel/term.cmx \ - parsing/termast.cmx lib/util.cmx contrib/correctness/pmonad.cmi -contrib/correctness/pred.cmo: pretyping/evd.cmi library/global.cmi lib/pp.cmi \ - pretyping/reductionops.cmi kernel/term.cmi contrib/correctness/pred.cmi -contrib/correctness/pred.cmx: pretyping/evd.cmx library/global.cmx lib/pp.cmx \ - pretyping/reductionops.cmx kernel/term.cmx contrib/correctness/pred.cmi -contrib/correctness/prename.cmo: toplevel/himsg.cmi library/nameops.cmi \ - kernel/names.cmi lib/pp.cmi lib/util.cmi contrib/correctness/prename.cmi -contrib/correctness/prename.cmx: toplevel/himsg.cmx library/nameops.cmx \ - kernel/names.cmx lib/pp.cmx lib/util.cmx contrib/correctness/prename.cmi -contrib/correctness/ptactic.cmo: library/decl_kinds.cmo tactics/equality.cmi \ - pretyping/evd.cmi tactics/extratactics.cmi library/global.cmi \ - library/libnames.cmi library/library.cmi library/nameops.cmi \ - kernel/names.cmi library/nametab.cmi lib/options.cmi \ - pretyping/pattern.cmi proofs/pfedit.cmi lib/pp.cmi \ - pretyping/pretyping.cmi parsing/printer.cmi kernel/reduction.cmi \ - proofs/tacmach.cmi tactics/tacticals.cmi tactics/tactics.cmi \ - kernel/term.cmi pretyping/termops.cmi lib/util.cmi \ - toplevel/vernacentries.cmi contrib/correctness/ptactic.cmi -contrib/correctness/ptactic.cmx: library/decl_kinds.cmx tactics/equality.cmx \ - pretyping/evd.cmx tactics/extratactics.cmx library/global.cmx \ - library/libnames.cmx library/library.cmx library/nameops.cmx \ - kernel/names.cmx library/nametab.cmx lib/options.cmx \ - pretyping/pattern.cmx proofs/pfedit.cmx lib/pp.cmx \ - pretyping/pretyping.cmx parsing/printer.cmx kernel/reduction.cmx \ - proofs/tacmach.cmx tactics/tacticals.cmx tactics/tactics.cmx \ - kernel/term.cmx pretyping/termops.cmx lib/util.cmx \ - toplevel/vernacentries.cmx contrib/correctness/ptactic.cmi -contrib/correctness/ptyping.cmo: interp/constrintern.cmi kernel/environ.cmi \ - pretyping/evd.cmi library/global.cmi toplevel/himsg.cmi kernel/names.cmi \ - lib/pp.cmi proofs/proof_trees.cmi pretyping/reductionops.cmi \ - kernel/term.cmi pretyping/termops.cmi interp/topconstr.cmi \ - pretyping/typing.cmi lib/util.cmi contrib/correctness/ptyping.cmi -contrib/correctness/ptyping.cmx: interp/constrintern.cmx kernel/environ.cmx \ - pretyping/evd.cmx library/global.cmx toplevel/himsg.cmx kernel/names.cmx \ - lib/pp.cmx proofs/proof_trees.cmx pretyping/reductionops.cmx \ - kernel/term.cmx pretyping/termops.cmx interp/topconstr.cmx \ - pretyping/typing.cmx lib/util.cmx contrib/correctness/ptyping.cmi -contrib/correctness/putil.cmo: kernel/environ.cmi library/global.cmi \ - tactics/hipattern.cmi pretyping/matching.cmi library/nameops.cmi \ - kernel/names.cmi pretyping/pattern.cmi lib/pp.cmi parsing/printer.cmi \ - kernel/term.cmi pretyping/termops.cmi lib/util.cmi \ +contrib/correctness/pmonad.cmo: lib/util.cmi parsing/termast.cmi \ + kernel/term.cmi kernel/names.cmi contrib/correctness/pmonad.cmi +contrib/correctness/pmonad.cmx: lib/util.cmx parsing/termast.cmx \ + kernel/term.cmx kernel/names.cmx contrib/correctness/pmonad.cmi +contrib/correctness/pred.cmo: kernel/term.cmi pretyping/reductionops.cmi \ + lib/pp.cmi library/global.cmi pretyping/evd.cmi \ + contrib/correctness/pred.cmi +contrib/correctness/pred.cmx: kernel/term.cmx pretyping/reductionops.cmx \ + lib/pp.cmx library/global.cmx pretyping/evd.cmx \ + contrib/correctness/pred.cmi +contrib/correctness/prename.cmo: lib/util.cmi lib/pp.cmi kernel/names.cmi \ + library/nameops.cmi toplevel/himsg.cmi contrib/correctness/prename.cmi +contrib/correctness/prename.cmx: lib/util.cmx lib/pp.cmx kernel/names.cmx \ + library/nameops.cmx toplevel/himsg.cmx contrib/correctness/prename.cmi +contrib/correctness/ptactic.cmo: toplevel/vernacentries.cmi lib/util.cmi \ + pretyping/termops.cmi kernel/term.cmi tactics/tactics.cmi \ + tactics/tacticals.cmi proofs/tacmach.cmi kernel/reduction.cmi \ + parsing/printer.cmi pretyping/pretyping.cmi lib/pp.cmi proofs/pfedit.cmi \ + pretyping/pattern.cmi lib/options.cmi library/nametab.cmi \ + kernel/names.cmi library/nameops.cmi library/library.cmi \ + library/libnames.cmi library/global.cmi tactics/extratactics.cmi \ + pretyping/evd.cmi tactics/equality.cmi library/decl_kinds.cmo \ + contrib/correctness/ptactic.cmi +contrib/correctness/ptactic.cmx: toplevel/vernacentries.cmx lib/util.cmx \ + pretyping/termops.cmx kernel/term.cmx tactics/tactics.cmx \ + tactics/tacticals.cmx proofs/tacmach.cmx kernel/reduction.cmx \ + parsing/printer.cmx pretyping/pretyping.cmx lib/pp.cmx proofs/pfedit.cmx \ + pretyping/pattern.cmx lib/options.cmx library/nametab.cmx \ + kernel/names.cmx library/nameops.cmx library/library.cmx \ + library/libnames.cmx library/global.cmx tactics/extratactics.cmx \ + pretyping/evd.cmx tactics/equality.cmx library/decl_kinds.cmx \ + contrib/correctness/ptactic.cmi +contrib/correctness/ptyping.cmo: lib/util.cmi pretyping/typing.cmi \ + interp/topconstr.cmi pretyping/termops.cmi kernel/term.cmi \ + pretyping/reductionops.cmi proofs/proof_trees.cmi lib/pp.cmi \ + kernel/names.cmi toplevel/himsg.cmi library/global.cmi pretyping/evd.cmi \ + kernel/environ.cmi interp/constrintern.cmi \ + contrib/correctness/ptyping.cmi +contrib/correctness/ptyping.cmx: lib/util.cmx pretyping/typing.cmx \ + interp/topconstr.cmx pretyping/termops.cmx kernel/term.cmx \ + pretyping/reductionops.cmx proofs/proof_trees.cmx lib/pp.cmx \ + kernel/names.cmx toplevel/himsg.cmx library/global.cmx pretyping/evd.cmx \ + kernel/environ.cmx interp/constrintern.cmx \ + contrib/correctness/ptyping.cmi +contrib/correctness/putil.cmo: lib/util.cmi pretyping/termops.cmi \ + kernel/term.cmi parsing/printer.cmi lib/pp.cmi pretyping/pattern.cmi \ + kernel/names.cmi library/nameops.cmi pretyping/matching.cmi \ + tactics/hipattern.cmi library/global.cmi kernel/environ.cmi \ contrib/correctness/putil.cmi -contrib/correctness/putil.cmx: kernel/environ.cmx library/global.cmx \ - tactics/hipattern.cmx pretyping/matching.cmx library/nameops.cmx \ - kernel/names.cmx pretyping/pattern.cmx lib/pp.cmx parsing/printer.cmx \ - kernel/term.cmx pretyping/termops.cmx lib/util.cmx \ +contrib/correctness/putil.cmx: lib/util.cmx pretyping/termops.cmx \ + kernel/term.cmx parsing/printer.cmx lib/pp.cmx pretyping/pattern.cmx \ + kernel/names.cmx library/nameops.cmx pretyping/matching.cmx \ + tactics/hipattern.cmx library/global.cmx kernel/environ.cmx \ contrib/correctness/putil.cmi -contrib/correctness/pwp.cmo: kernel/environ.cmi library/global.cmi \ - tactics/hipattern.cmi library/libnames.cmi kernel/names.cmi \ - library/nametab.cmi kernel/reduction.cmi pretyping/reductionops.cmi \ - kernel/term.cmi pretyping/termops.cmi lib/util.cmi \ +contrib/correctness/pwp.cmo: lib/util.cmi pretyping/termops.cmi \ + kernel/term.cmi pretyping/reductionops.cmi kernel/reduction.cmi \ + library/nametab.cmi kernel/names.cmi library/libnames.cmi \ + tactics/hipattern.cmi library/global.cmi kernel/environ.cmi \ contrib/correctness/pwp.cmi -contrib/correctness/pwp.cmx: kernel/environ.cmx library/global.cmx \ - tactics/hipattern.cmx library/libnames.cmx kernel/names.cmx \ - library/nametab.cmx kernel/reduction.cmx pretyping/reductionops.cmx \ - kernel/term.cmx pretyping/termops.cmx lib/util.cmx \ +contrib/correctness/pwp.cmx: lib/util.cmx pretyping/termops.cmx \ + kernel/term.cmx pretyping/reductionops.cmx kernel/reduction.cmx \ + library/nametab.cmx kernel/names.cmx library/libnames.cmx \ + tactics/hipattern.cmx library/global.cmx kernel/environ.cmx \ contrib/correctness/pwp.cmi -contrib/extraction/common.cmo: kernel/declarations.cmi \ - contrib/extraction/extraction.cmi library/global.cmi lib/gset.cmi \ - contrib/extraction/haskell.cmi library/libnames.cmi \ - contrib/extraction/miniml.cmi kernel/modops.cmi \ - contrib/extraction/modutil.cmi library/nameops.cmi kernel/names.cmi \ - contrib/extraction/ocaml.cmi lib/options.cmi lib/pp.cmi \ - lib/pp_control.cmi contrib/extraction/scheme.cmi \ - contrib/extraction/table.cmi kernel/term.cmi lib/util.cmi \ +contrib/extraction/common.cmo: lib/util.cmi kernel/term.cmi \ + contrib/extraction/table.cmi contrib/extraction/scheme.cmi \ + lib/pp_control.cmi lib/pp.cmi lib/options.cmi \ + contrib/extraction/ocaml.cmi kernel/names.cmi library/nameops.cmi \ + contrib/extraction/modutil.cmi kernel/modops.cmi \ + contrib/extraction/miniml.cmi library/libnames.cmi \ + contrib/extraction/haskell.cmi lib/gset.cmi library/global.cmi \ + contrib/extraction/extraction.cmi kernel/declarations.cmi \ contrib/extraction/common.cmi -contrib/extraction/common.cmx: kernel/declarations.cmx \ - contrib/extraction/extraction.cmx library/global.cmx lib/gset.cmx \ - contrib/extraction/haskell.cmx library/libnames.cmx \ - contrib/extraction/miniml.cmi kernel/modops.cmx \ - contrib/extraction/modutil.cmx library/nameops.cmx kernel/names.cmx \ - contrib/extraction/ocaml.cmx lib/options.cmx lib/pp.cmx \ - lib/pp_control.cmx contrib/extraction/scheme.cmx \ - contrib/extraction/table.cmx kernel/term.cmx lib/util.cmx \ +contrib/extraction/common.cmx: lib/util.cmx kernel/term.cmx \ + contrib/extraction/table.cmx contrib/extraction/scheme.cmx \ + lib/pp_control.cmx lib/pp.cmx lib/options.cmx \ + contrib/extraction/ocaml.cmx kernel/names.cmx library/nameops.cmx \ + contrib/extraction/modutil.cmx kernel/modops.cmx \ + contrib/extraction/miniml.cmi library/libnames.cmx \ + contrib/extraction/haskell.cmx lib/gset.cmx library/global.cmx \ + contrib/extraction/extraction.cmx kernel/declarations.cmx \ contrib/extraction/common.cmi -contrib/extraction/extract_env.cmo: contrib/extraction/common.cmi \ - kernel/declarations.cmi contrib/extraction/extraction.cmi \ - library/global.cmi library/lib.cmi library/libnames.cmi \ - library/libobject.cmi library/library.cmi contrib/extraction/miniml.cmi \ - kernel/modops.cmi contrib/extraction/modutil.cmi kernel/names.cmi \ - library/nametab.cmi lib/pp.cmi kernel/reduction.cmi \ - contrib/extraction/table.cmi kernel/term.cmi lib/util.cmi \ +contrib/extraction/extract_env.cmo: lib/util.cmi kernel/term.cmi \ + contrib/extraction/table.cmi kernel/reduction.cmi lib/pp.cmi \ + library/nametab.cmi kernel/names.cmi contrib/extraction/modutil.cmi \ + kernel/modops.cmi contrib/extraction/miniml.cmi library/library.cmi \ + library/libobject.cmi library/libnames.cmi library/lib.cmi \ + library/global.cmi contrib/extraction/extraction.cmi \ + kernel/declarations.cmi contrib/extraction/common.cmi \ contrib/extraction/extract_env.cmi -contrib/extraction/extract_env.cmx: contrib/extraction/common.cmx \ - kernel/declarations.cmx contrib/extraction/extraction.cmx \ - library/global.cmx library/lib.cmx library/libnames.cmx \ - library/libobject.cmx library/library.cmx contrib/extraction/miniml.cmi \ - kernel/modops.cmx contrib/extraction/modutil.cmx kernel/names.cmx \ - library/nametab.cmx lib/pp.cmx kernel/reduction.cmx \ - contrib/extraction/table.cmx kernel/term.cmx lib/util.cmx \ +contrib/extraction/extract_env.cmx: lib/util.cmx kernel/term.cmx \ + contrib/extraction/table.cmx kernel/reduction.cmx lib/pp.cmx \ + library/nametab.cmx kernel/names.cmx contrib/extraction/modutil.cmx \ + kernel/modops.cmx contrib/extraction/miniml.cmi library/library.cmx \ + library/libobject.cmx library/libnames.cmx library/lib.cmx \ + library/global.cmx contrib/extraction/extraction.cmx \ + kernel/declarations.cmx contrib/extraction/common.cmx \ contrib/extraction/extract_env.cmi -contrib/extraction/extraction.cmo: kernel/declarations.cmi kernel/environ.cmi \ - pretyping/evd.cmi kernel/inductive.cmi pretyping/inductiveops.cmi \ - library/libnames.cmi contrib/extraction/miniml.cmi \ - contrib/extraction/mlutil.cmi library/nameops.cmi kernel/names.cmi \ - library/nametab.cmi pretyping/recordops.cmi kernel/reduction.cmi \ - pretyping/reductionops.cmi pretyping/retyping.cmi kernel/sign.cmi \ - library/summary.cmi contrib/extraction/table.cmi kernel/term.cmi \ - pretyping/termops.cmi lib/util.cmi contrib/extraction/extraction.cmi -contrib/extraction/extraction.cmx: kernel/declarations.cmx kernel/environ.cmx \ - pretyping/evd.cmx kernel/inductive.cmx pretyping/inductiveops.cmx \ - library/libnames.cmx contrib/extraction/miniml.cmi \ - contrib/extraction/mlutil.cmx library/nameops.cmx kernel/names.cmx \ - library/nametab.cmx pretyping/recordops.cmx kernel/reduction.cmx \ - pretyping/reductionops.cmx pretyping/retyping.cmx kernel/sign.cmx \ - library/summary.cmx contrib/extraction/table.cmx kernel/term.cmx \ - pretyping/termops.cmx lib/util.cmx contrib/extraction/extraction.cmi -contrib/extraction/g_extraction.cmo: toplevel/cerrors.cmi \ - parsing/egrammar.cmi parsing/extend.cmi \ - contrib/extraction/extract_env.cmi interp/genarg.cmi lib/options.cmi \ - parsing/pcoq.cmi lib/pp.cmi parsing/pptactic.cmi \ - translate/pptacticnew.cmi contrib/extraction/table.cmi \ - tactics/tacinterp.cmi lib/util.cmi toplevel/vernacexpr.cmo \ - toplevel/vernacinterp.cmi -contrib/extraction/g_extraction.cmx: toplevel/cerrors.cmx \ - parsing/egrammar.cmx parsing/extend.cmx \ - contrib/extraction/extract_env.cmx interp/genarg.cmx lib/options.cmx \ - parsing/pcoq.cmx lib/pp.cmx parsing/pptactic.cmx \ - translate/pptacticnew.cmx contrib/extraction/table.cmx \ - tactics/tacinterp.cmx lib/util.cmx toplevel/vernacexpr.cmx \ - toplevel/vernacinterp.cmx -contrib/extraction/haskell.cmo: library/libnames.cmi \ - contrib/extraction/miniml.cmi contrib/extraction/mlutil.cmi \ - library/nameops.cmi kernel/names.cmi contrib/extraction/ocaml.cmi \ - lib/pp.cmi contrib/extraction/table.cmi lib/util.cmi \ +contrib/extraction/extraction.cmo: lib/util.cmi pretyping/termops.cmi \ + kernel/term.cmi contrib/extraction/table.cmi library/summary.cmi \ + kernel/sign.cmi pretyping/retyping.cmi pretyping/reductionops.cmi \ + kernel/reduction.cmi pretyping/recordops.cmi library/nametab.cmi \ + kernel/names.cmi library/nameops.cmi contrib/extraction/mlutil.cmi \ + contrib/extraction/miniml.cmi library/libnames.cmi \ + pretyping/inductiveops.cmi kernel/inductive.cmi pretyping/evd.cmi \ + kernel/environ.cmi kernel/declarations.cmi \ + contrib/extraction/extraction.cmi +contrib/extraction/extraction.cmx: lib/util.cmx pretyping/termops.cmx \ + kernel/term.cmx contrib/extraction/table.cmx library/summary.cmx \ + kernel/sign.cmx pretyping/retyping.cmx pretyping/reductionops.cmx \ + kernel/reduction.cmx pretyping/recordops.cmx library/nametab.cmx \ + kernel/names.cmx library/nameops.cmx contrib/extraction/mlutil.cmx \ + contrib/extraction/miniml.cmi library/libnames.cmx \ + pretyping/inductiveops.cmx kernel/inductive.cmx pretyping/evd.cmx \ + kernel/environ.cmx kernel/declarations.cmx \ + contrib/extraction/extraction.cmi +contrib/extraction/g_extraction.cmo: toplevel/vernacinterp.cmi \ + toplevel/vernacexpr.cmo lib/util.cmi tactics/tacinterp.cmi \ + contrib/extraction/table.cmi translate/pptacticnew.cmi \ + parsing/pptactic.cmi lib/pp.cmi parsing/pcoq.cmi lib/options.cmi \ + interp/genarg.cmi contrib/extraction/extract_env.cmi parsing/extend.cmi \ + parsing/egrammar.cmi toplevel/cerrors.cmi +contrib/extraction/g_extraction.cmx: toplevel/vernacinterp.cmx \ + toplevel/vernacexpr.cmx lib/util.cmx tactics/tacinterp.cmx \ + contrib/extraction/table.cmx translate/pptacticnew.cmx \ + parsing/pptactic.cmx lib/pp.cmx parsing/pcoq.cmx lib/options.cmx \ + interp/genarg.cmx contrib/extraction/extract_env.cmx parsing/extend.cmx \ + parsing/egrammar.cmx toplevel/cerrors.cmx +contrib/extraction/haskell.cmo: lib/util.cmi contrib/extraction/table.cmi \ + lib/pp.cmi contrib/extraction/ocaml.cmi kernel/names.cmi \ + library/nameops.cmi contrib/extraction/mlutil.cmi \ + contrib/extraction/miniml.cmi library/libnames.cmi \ contrib/extraction/haskell.cmi -contrib/extraction/haskell.cmx: library/libnames.cmx \ - contrib/extraction/miniml.cmi contrib/extraction/mlutil.cmx \ - library/nameops.cmx kernel/names.cmx contrib/extraction/ocaml.cmx \ - lib/pp.cmx contrib/extraction/table.cmx lib/util.cmx \ +contrib/extraction/haskell.cmx: lib/util.cmx contrib/extraction/table.cmx \ + lib/pp.cmx contrib/extraction/ocaml.cmx kernel/names.cmx \ + library/nameops.cmx contrib/extraction/mlutil.cmx \ + contrib/extraction/miniml.cmi library/libnames.cmx \ contrib/extraction/haskell.cmi -contrib/extraction/mlutil.cmo: library/libnames.cmi \ - contrib/extraction/miniml.cmi kernel/names.cmi library/nametab.cmi \ - lib/pp.cmi contrib/extraction/table.cmi lib/util.cmi \ +contrib/extraction/mlutil.cmo: lib/util.cmi contrib/extraction/table.cmi \ + lib/pp.cmi library/nametab.cmi kernel/names.cmi \ + contrib/extraction/miniml.cmi library/libnames.cmi \ contrib/extraction/mlutil.cmi -contrib/extraction/mlutil.cmx: library/libnames.cmx \ - contrib/extraction/miniml.cmi kernel/names.cmx library/nametab.cmx \ - lib/pp.cmx contrib/extraction/table.cmx lib/util.cmx \ +contrib/extraction/mlutil.cmx: lib/util.cmx contrib/extraction/table.cmx \ + lib/pp.cmx library/nametab.cmx kernel/names.cmx \ + contrib/extraction/miniml.cmi library/libnames.cmx \ contrib/extraction/mlutil.cmi -contrib/extraction/modutil.cmo: kernel/declarations.cmi kernel/environ.cmi \ - library/libnames.cmi contrib/extraction/miniml.cmi \ - contrib/extraction/mlutil.cmi kernel/modops.cmi kernel/names.cmi \ - contrib/extraction/table.cmi lib/util.cmi contrib/extraction/modutil.cmi -contrib/extraction/modutil.cmx: kernel/declarations.cmx kernel/environ.cmx \ - library/libnames.cmx contrib/extraction/miniml.cmi \ - contrib/extraction/mlutil.cmx kernel/modops.cmx kernel/names.cmx \ - contrib/extraction/table.cmx lib/util.cmx contrib/extraction/modutil.cmi -contrib/extraction/ocaml.cmo: library/libnames.cmi \ - contrib/extraction/miniml.cmi contrib/extraction/mlutil.cmi \ - contrib/extraction/modutil.cmi library/nameops.cmi kernel/names.cmi \ - lib/pp.cmi contrib/extraction/table.cmi lib/util.cmi \ +contrib/extraction/modutil.cmo: lib/util.cmi contrib/extraction/table.cmi \ + kernel/names.cmi kernel/modops.cmi contrib/extraction/mlutil.cmi \ + contrib/extraction/miniml.cmi library/libnames.cmi kernel/environ.cmi \ + kernel/declarations.cmi contrib/extraction/modutil.cmi +contrib/extraction/modutil.cmx: lib/util.cmx contrib/extraction/table.cmx \ + kernel/names.cmx kernel/modops.cmx contrib/extraction/mlutil.cmx \ + contrib/extraction/miniml.cmi library/libnames.cmx kernel/environ.cmx \ + kernel/declarations.cmx contrib/extraction/modutil.cmi +contrib/extraction/ocaml.cmo: lib/util.cmi contrib/extraction/table.cmi \ + lib/pp.cmi kernel/names.cmi library/nameops.cmi \ + contrib/extraction/modutil.cmi contrib/extraction/mlutil.cmi \ + contrib/extraction/miniml.cmi library/libnames.cmi \ contrib/extraction/ocaml.cmi -contrib/extraction/ocaml.cmx: library/libnames.cmx \ - contrib/extraction/miniml.cmi contrib/extraction/mlutil.cmx \ - contrib/extraction/modutil.cmx library/nameops.cmx kernel/names.cmx \ - lib/pp.cmx contrib/extraction/table.cmx lib/util.cmx \ +contrib/extraction/ocaml.cmx: lib/util.cmx contrib/extraction/table.cmx \ + lib/pp.cmx kernel/names.cmx library/nameops.cmx \ + contrib/extraction/modutil.cmx contrib/extraction/mlutil.cmx \ + contrib/extraction/miniml.cmi library/libnames.cmx \ contrib/extraction/ocaml.cmi -contrib/extraction/scheme.cmo: library/libnames.cmi \ - contrib/extraction/miniml.cmi contrib/extraction/mlutil.cmi \ - library/nameops.cmi kernel/names.cmi contrib/extraction/ocaml.cmi \ - lib/pp.cmi contrib/extraction/table.cmi lib/util.cmi \ +contrib/extraction/scheme.cmo: lib/util.cmi contrib/extraction/table.cmi \ + lib/pp.cmi contrib/extraction/ocaml.cmi kernel/names.cmi \ + library/nameops.cmi contrib/extraction/mlutil.cmi \ + contrib/extraction/miniml.cmi library/libnames.cmi \ contrib/extraction/scheme.cmi -contrib/extraction/scheme.cmx: library/libnames.cmx \ - contrib/extraction/miniml.cmi contrib/extraction/mlutil.cmx \ - library/nameops.cmx kernel/names.cmx contrib/extraction/ocaml.cmx \ - lib/pp.cmx contrib/extraction/table.cmx lib/util.cmx \ +contrib/extraction/scheme.cmx: lib/util.cmx contrib/extraction/table.cmx \ + lib/pp.cmx contrib/extraction/ocaml.cmx kernel/names.cmx \ + library/nameops.cmx contrib/extraction/mlutil.cmx \ + contrib/extraction/miniml.cmi library/libnames.cmx \ contrib/extraction/scheme.cmi -contrib/extraction/table.cmo: kernel/declarations.cmi kernel/environ.cmi \ - library/global.cmi library/goptions.cmi library/lib.cmi \ - library/libnames.cmi library/libobject.cmi contrib/extraction/miniml.cmi \ - library/nameops.cmi kernel/names.cmi library/nametab.cmi lib/options.cmi \ - lib/pp.cmi parsing/printer.cmi kernel/reduction.cmi library/summary.cmi \ - kernel/term.cmi lib/util.cmi contrib/extraction/table.cmi -contrib/extraction/table.cmx: kernel/declarations.cmx kernel/environ.cmx \ - library/global.cmx library/goptions.cmx library/lib.cmx \ - library/libnames.cmx library/libobject.cmx contrib/extraction/miniml.cmi \ - library/nameops.cmx kernel/names.cmx library/nametab.cmx lib/options.cmx \ - lib/pp.cmx parsing/printer.cmx kernel/reduction.cmx library/summary.cmx \ - kernel/term.cmx lib/util.cmx contrib/extraction/table.cmi -contrib/field/field.cmo: toplevel/cerrors.cmi interp/constrintern.cmi \ - interp/coqlib.cmi parsing/egrammar.cmi pretyping/evd.cmi \ - parsing/extend.cmi interp/genarg.cmi library/global.cmi lib/gmap.cmi \ - tactics/hipattern.cmi library/lib.cmi library/libnames.cmi \ - library/libobject.cmi library/library.cmi kernel/names.cmi \ - lib/options.cmi parsing/pcoq.cmi lib/pp.cmi translate/ppconstrnew.cmi \ - parsing/pptactic.cmi parsing/printer.cmi proofs/proof_type.cmi \ - contrib/ring/quote.cmo pretyping/reductionops.cmi proofs/refiner.cmi \ - contrib/ring/ring.cmo library/summary.cmi proofs/tacexpr.cmo \ - tactics/tacinterp.cmi proofs/tacmach.cmi tactics/tacticals.cmi \ - kernel/term.cmi interp/topconstr.cmi pretyping/typing.cmi lib/util.cmi \ - toplevel/vernacexpr.cmo toplevel/vernacinterp.cmi -contrib/field/field.cmx: toplevel/cerrors.cmx interp/constrintern.cmx \ - interp/coqlib.cmx parsing/egrammar.cmx pretyping/evd.cmx \ - parsing/extend.cmx interp/genarg.cmx library/global.cmx lib/gmap.cmx \ - tactics/hipattern.cmx library/lib.cmx library/libnames.cmx \ - library/libobject.cmx library/library.cmx kernel/names.cmx \ - lib/options.cmx parsing/pcoq.cmx lib/pp.cmx translate/ppconstrnew.cmx \ - parsing/pptactic.cmx parsing/printer.cmx proofs/proof_type.cmx \ - contrib/ring/quote.cmx pretyping/reductionops.cmx proofs/refiner.cmx \ - contrib/ring/ring.cmx library/summary.cmx proofs/tacexpr.cmx \ - tactics/tacinterp.cmx proofs/tacmach.cmx tactics/tacticals.cmx \ - kernel/term.cmx interp/topconstr.cmx pretyping/typing.cmx lib/util.cmx \ - toplevel/vernacexpr.cmx toplevel/vernacinterp.cmx -contrib/first-order/formula.cmo: kernel/closure.cmi kernel/declarations.cmi \ - library/global.cmi tactics/hipattern.cmi kernel/inductive.cmi \ - pretyping/inductiveops.cmi library/libnames.cmi kernel/names.cmi \ - pretyping/reductionops.cmi kernel/sign.cmi proofs/tacmach.cmi \ - kernel/term.cmi pretyping/termops.cmi lib/util.cmi \ +contrib/extraction/table.cmo: lib/util.cmi kernel/term.cmi \ + library/summary.cmi kernel/reduction.cmi parsing/printer.cmi lib/pp.cmi \ + lib/options.cmi library/nametab.cmi kernel/names.cmi library/nameops.cmi \ + contrib/extraction/miniml.cmi library/libobject.cmi library/libnames.cmi \ + library/lib.cmi library/goptions.cmi library/global.cmi \ + kernel/environ.cmi kernel/declarations.cmi contrib/extraction/table.cmi +contrib/extraction/table.cmx: lib/util.cmx kernel/term.cmx \ + library/summary.cmx kernel/reduction.cmx parsing/printer.cmx lib/pp.cmx \ + lib/options.cmx library/nametab.cmx kernel/names.cmx library/nameops.cmx \ + contrib/extraction/miniml.cmi library/libobject.cmx library/libnames.cmx \ + library/lib.cmx library/goptions.cmx library/global.cmx \ + kernel/environ.cmx kernel/declarations.cmx contrib/extraction/table.cmi +contrib/field/field.cmo: toplevel/vernacinterp.cmi toplevel/vernacexpr.cmo \ + lib/util.cmi pretyping/typing.cmi interp/topconstr.cmi kernel/term.cmi \ + tactics/tacticals.cmi proofs/tacmach.cmi tactics/tacinterp.cmi \ + proofs/tacexpr.cmo library/summary.cmi contrib/ring/ring.cmo \ + proofs/refiner.cmi pretyping/reductionops.cmi contrib/ring/quote.cmo \ + proofs/proof_type.cmi parsing/printer.cmi parsing/pptactic.cmi \ + translate/ppconstrnew.cmi lib/pp.cmi parsing/pcoq.cmi lib/options.cmi \ + kernel/names.cmi library/library.cmi library/libobject.cmi \ + library/libnames.cmi library/lib.cmi tactics/hipattern.cmi lib/gmap.cmi \ + library/global.cmi interp/genarg.cmi parsing/extend.cmi pretyping/evd.cmi \ + parsing/egrammar.cmi interp/coqlib.cmi interp/constrintern.cmi \ + toplevel/cerrors.cmi +contrib/field/field.cmx: toplevel/vernacinterp.cmx toplevel/vernacexpr.cmx \ + lib/util.cmx pretyping/typing.cmx interp/topconstr.cmx kernel/term.cmx \ + tactics/tacticals.cmx proofs/tacmach.cmx tactics/tacinterp.cmx \ + proofs/tacexpr.cmx library/summary.cmx contrib/ring/ring.cmx \ + proofs/refiner.cmx pretyping/reductionops.cmx contrib/ring/quote.cmx \ + proofs/proof_type.cmx parsing/printer.cmx parsing/pptactic.cmx \ + translate/ppconstrnew.cmx lib/pp.cmx parsing/pcoq.cmx lib/options.cmx \ + kernel/names.cmx library/library.cmx library/libobject.cmx \ + library/libnames.cmx library/lib.cmx tactics/hipattern.cmx lib/gmap.cmx \ + library/global.cmx interp/genarg.cmx parsing/extend.cmx pretyping/evd.cmx \ + parsing/egrammar.cmx interp/coqlib.cmx interp/constrintern.cmx \ + toplevel/cerrors.cmx +contrib/first-order/formula.cmo: lib/util.cmi pretyping/termops.cmi \ + kernel/term.cmi proofs/tacmach.cmi kernel/sign.cmi \ + pretyping/reductionops.cmi kernel/names.cmi library/libnames.cmi \ + pretyping/inductiveops.cmi kernel/inductive.cmi tactics/hipattern.cmi \ + library/global.cmi kernel/declarations.cmi kernel/closure.cmi \ contrib/first-order/formula.cmi -contrib/first-order/formula.cmx: kernel/closure.cmx kernel/declarations.cmx \ - library/global.cmx tactics/hipattern.cmx kernel/inductive.cmx \ - pretyping/inductiveops.cmx library/libnames.cmx kernel/names.cmx \ - pretyping/reductionops.cmx kernel/sign.cmx proofs/tacmach.cmx \ - kernel/term.cmx pretyping/termops.cmx lib/util.cmx \ +contrib/first-order/formula.cmx: lib/util.cmx pretyping/termops.cmx \ + kernel/term.cmx proofs/tacmach.cmx kernel/sign.cmx \ + pretyping/reductionops.cmx kernel/names.cmx library/libnames.cmx \ + pretyping/inductiveops.cmx kernel/inductive.cmx tactics/hipattern.cmx \ + library/global.cmx kernel/declarations.cmx kernel/closure.cmx \ contrib/first-order/formula.cmi -contrib/first-order/g_ground.cmo: tactics/auto.cmi toplevel/cerrors.cmi \ - parsing/egrammar.cmi contrib/first-order/formula.cmi interp/genarg.cmi \ - library/goptions.cmi contrib/first-order/ground.cmi library/libnames.cmi \ - kernel/names.cmi lib/options.cmi parsing/pcoq.cmi lib/pp.cmi \ - parsing/pptactic.cmi proofs/refiner.cmi contrib/first-order/sequent.cmi \ - proofs/tacexpr.cmo tactics/tacinterp.cmi tactics/tacticals.cmi \ - tactics/tactics.cmi kernel/term.cmi lib/util.cmi -contrib/first-order/g_ground.cmx: tactics/auto.cmx toplevel/cerrors.cmx \ - parsing/egrammar.cmx contrib/first-order/formula.cmx interp/genarg.cmx \ - library/goptions.cmx contrib/first-order/ground.cmx library/libnames.cmx \ - kernel/names.cmx lib/options.cmx parsing/pcoq.cmx lib/pp.cmx \ - parsing/pptactic.cmx proofs/refiner.cmx contrib/first-order/sequent.cmx \ - proofs/tacexpr.cmx tactics/tacinterp.cmx tactics/tacticals.cmx \ - tactics/tactics.cmx kernel/term.cmx lib/util.cmx -contrib/first-order/ground.cmo: pretyping/classops.cmi kernel/closure.cmi \ - contrib/first-order/formula.cmi lib/heap.cmi \ - contrib/first-order/instances.cmi library/libnames.cmi kernel/names.cmi \ - lib/pp.cmi proofs/proof_trees.cmi contrib/first-order/rules.cmi \ - contrib/first-order/sequent.cmi tactics/tacinterp.cmi proofs/tacmach.cmi \ - proofs/tactic_debug.cmi tactics/tacticals.cmi tactics/tactics.cmi \ - kernel/term.cmi contrib/first-order/ground.cmi -contrib/first-order/ground.cmx: pretyping/classops.cmx kernel/closure.cmx \ - contrib/first-order/formula.cmx lib/heap.cmx \ - contrib/first-order/instances.cmx library/libnames.cmx kernel/names.cmx \ - lib/pp.cmx proofs/proof_trees.cmx contrib/first-order/rules.cmx \ - contrib/first-order/sequent.cmx tactics/tacinterp.cmx proofs/tacmach.cmx \ - proofs/tactic_debug.cmx tactics/tacticals.cmx tactics/tactics.cmx \ - kernel/term.cmx contrib/first-order/ground.cmi -contrib/first-order/instances.cmo: kernel/declarations.cmi \ - pretyping/detyping.cmi contrib/first-order/formula.cmi lib/heap.cmi \ - library/libnames.cmi kernel/names.cmi pretyping/pretyping.cmi \ - pretyping/rawterm.cmi pretyping/reductionops.cmi proofs/refiner.cmi \ - contrib/first-order/rules.cmi contrib/first-order/sequent.cmi \ - kernel/sign.cmi proofs/tacmach.cmi tactics/tacticals.cmi \ - tactics/tactics.cmi kernel/term.cmi pretyping/termops.cmi \ - contrib/first-order/unify.cmi lib/util.cmi \ - contrib/first-order/instances.cmi -contrib/first-order/instances.cmx: kernel/declarations.cmx \ - pretyping/detyping.cmx contrib/first-order/formula.cmx lib/heap.cmx \ - library/libnames.cmx kernel/names.cmx pretyping/pretyping.cmx \ - pretyping/rawterm.cmx pretyping/reductionops.cmx proofs/refiner.cmx \ - contrib/first-order/rules.cmx contrib/first-order/sequent.cmx \ - kernel/sign.cmx proofs/tacmach.cmx tactics/tacticals.cmx \ - tactics/tactics.cmx kernel/term.cmx pretyping/termops.cmx \ - contrib/first-order/unify.cmx lib/util.cmx \ - contrib/first-order/instances.cmi -contrib/first-order/rules.cmo: interp/coqlib.cmi kernel/declarations.cmi \ - contrib/first-order/formula.cmi library/libnames.cmi kernel/names.cmi \ - contrib/first-order/sequent.cmi kernel/sign.cmi proofs/tacexpr.cmo \ - proofs/tacmach.cmi tactics/tacticals.cmi tactics/tactics.cmi \ - kernel/term.cmi pretyping/termops.cmi lib/util.cmi \ +contrib/first-order/g_ground.cmo: lib/util.cmi kernel/term.cmi \ + tactics/tactics.cmi tactics/tacticals.cmi tactics/tacinterp.cmi \ + proofs/tacexpr.cmo contrib/first-order/sequent.cmi proofs/refiner.cmi \ + parsing/pptactic.cmi lib/pp.cmi parsing/pcoq.cmi lib/options.cmi \ + kernel/names.cmi library/libnames.cmi contrib/first-order/ground.cmi \ + library/goptions.cmi interp/genarg.cmi contrib/first-order/formula.cmi \ + parsing/egrammar.cmi toplevel/cerrors.cmi tactics/auto.cmi +contrib/first-order/g_ground.cmx: lib/util.cmx kernel/term.cmx \ + tactics/tactics.cmx tactics/tacticals.cmx tactics/tacinterp.cmx \ + proofs/tacexpr.cmx contrib/first-order/sequent.cmx proofs/refiner.cmx \ + parsing/pptactic.cmx lib/pp.cmx parsing/pcoq.cmx lib/options.cmx \ + kernel/names.cmx library/libnames.cmx contrib/first-order/ground.cmx \ + library/goptions.cmx interp/genarg.cmx contrib/first-order/formula.cmx \ + parsing/egrammar.cmx toplevel/cerrors.cmx tactics/auto.cmx +contrib/first-order/ground.cmo: kernel/term.cmi tactics/tactics.cmi \ + tactics/tacticals.cmi proofs/tactic_debug.cmi proofs/tacmach.cmi \ + tactics/tacinterp.cmi contrib/first-order/sequent.cmi \ + contrib/first-order/rules.cmi proofs/proof_trees.cmi lib/pp.cmi \ + kernel/names.cmi library/libnames.cmi contrib/first-order/instances.cmi \ + lib/heap.cmi contrib/first-order/formula.cmi kernel/closure.cmi \ + pretyping/classops.cmi contrib/first-order/ground.cmi +contrib/first-order/ground.cmx: kernel/term.cmx tactics/tactics.cmx \ + tactics/tacticals.cmx proofs/tactic_debug.cmx proofs/tacmach.cmx \ + tactics/tacinterp.cmx contrib/first-order/sequent.cmx \ + contrib/first-order/rules.cmx proofs/proof_trees.cmx lib/pp.cmx \ + kernel/names.cmx library/libnames.cmx contrib/first-order/instances.cmx \ + lib/heap.cmx contrib/first-order/formula.cmx kernel/closure.cmx \ + pretyping/classops.cmx contrib/first-order/ground.cmi +contrib/first-order/instances.cmo: lib/util.cmi contrib/first-order/unify.cmi \ + pretyping/termops.cmi kernel/term.cmi tactics/tactics.cmi \ + tactics/tacticals.cmi proofs/tacmach.cmi kernel/sign.cmi \ + contrib/first-order/sequent.cmi contrib/first-order/rules.cmi \ + proofs/refiner.cmi pretyping/reductionops.cmi pretyping/rawterm.cmi \ + pretyping/pretyping.cmi kernel/names.cmi library/libnames.cmi \ + lib/heap.cmi contrib/first-order/formula.cmi pretyping/detyping.cmi \ + kernel/declarations.cmi contrib/first-order/instances.cmi +contrib/first-order/instances.cmx: lib/util.cmx contrib/first-order/unify.cmx \ + pretyping/termops.cmx kernel/term.cmx tactics/tactics.cmx \ + tactics/tacticals.cmx proofs/tacmach.cmx kernel/sign.cmx \ + contrib/first-order/sequent.cmx contrib/first-order/rules.cmx \ + proofs/refiner.cmx pretyping/reductionops.cmx pretyping/rawterm.cmx \ + pretyping/pretyping.cmx kernel/names.cmx library/libnames.cmx \ + lib/heap.cmx contrib/first-order/formula.cmx pretyping/detyping.cmx \ + kernel/declarations.cmx contrib/first-order/instances.cmi +contrib/first-order/rules.cmo: lib/util.cmi pretyping/termops.cmi \ + kernel/term.cmi tactics/tactics.cmi tactics/tacticals.cmi \ + proofs/tacmach.cmi proofs/tacexpr.cmo kernel/sign.cmi \ + contrib/first-order/sequent.cmi kernel/names.cmi library/libnames.cmi \ + contrib/first-order/formula.cmi kernel/declarations.cmi interp/coqlib.cmi \ contrib/first-order/rules.cmi -contrib/first-order/rules.cmx: interp/coqlib.cmx kernel/declarations.cmx \ - contrib/first-order/formula.cmx library/libnames.cmx kernel/names.cmx \ - contrib/first-order/sequent.cmx kernel/sign.cmx proofs/tacexpr.cmx \ - proofs/tacmach.cmx tactics/tacticals.cmx tactics/tactics.cmx \ - kernel/term.cmx pretyping/termops.cmx lib/util.cmx \ +contrib/first-order/rules.cmx: lib/util.cmx pretyping/termops.cmx \ + kernel/term.cmx tactics/tactics.cmx tactics/tacticals.cmx \ + proofs/tacmach.cmx proofs/tacexpr.cmx kernel/sign.cmx \ + contrib/first-order/sequent.cmx kernel/names.cmx library/libnames.cmx \ + contrib/first-order/formula.cmx kernel/declarations.cmx interp/coqlib.cmx \ contrib/first-order/rules.cmi -contrib/first-order/sequent.cmo: tactics/auto.cmi interp/constrextern.cmi \ - contrib/first-order/formula.cmi library/global.cmi lib/heap.cmi \ - library/libnames.cmi kernel/names.cmi lib/pp.cmi parsing/ppconstr.cmi \ - proofs/tacmach.cmi kernel/term.cmi contrib/first-order/unify.cmi \ - lib/util.cmi contrib/first-order/sequent.cmi -contrib/first-order/sequent.cmx: tactics/auto.cmx interp/constrextern.cmx \ - contrib/first-order/formula.cmx library/global.cmx lib/heap.cmx \ - library/libnames.cmx kernel/names.cmx lib/pp.cmx parsing/ppconstr.cmx \ - proofs/tacmach.cmx kernel/term.cmx contrib/first-order/unify.cmx \ - lib/util.cmx contrib/first-order/sequent.cmi -contrib/first-order/unify.cmo: contrib/first-order/formula.cmi \ - kernel/names.cmi pretyping/reductionops.cmi proofs/tacmach.cmi \ - kernel/term.cmi pretyping/termops.cmi lib/util.cmi \ +contrib/first-order/sequent.cmo: lib/util.cmi contrib/first-order/unify.cmi \ + kernel/term.cmi proofs/tacmach.cmi parsing/ppconstr.cmi lib/pp.cmi \ + kernel/names.cmi library/libnames.cmi lib/heap.cmi library/global.cmi \ + contrib/first-order/formula.cmi interp/constrextern.cmi tactics/auto.cmi \ + contrib/first-order/sequent.cmi +contrib/first-order/sequent.cmx: lib/util.cmx contrib/first-order/unify.cmx \ + kernel/term.cmx proofs/tacmach.cmx parsing/ppconstr.cmx lib/pp.cmx \ + kernel/names.cmx library/libnames.cmx lib/heap.cmx library/global.cmx \ + contrib/first-order/formula.cmx interp/constrextern.cmx tactics/auto.cmx \ + contrib/first-order/sequent.cmi +contrib/first-order/unify.cmo: lib/util.cmi pretyping/termops.cmi \ + kernel/term.cmi proofs/tacmach.cmi pretyping/reductionops.cmi \ + kernel/names.cmi contrib/first-order/formula.cmi \ contrib/first-order/unify.cmi -contrib/first-order/unify.cmx: contrib/first-order/formula.cmx \ - kernel/names.cmx pretyping/reductionops.cmx proofs/tacmach.cmx \ - kernel/term.cmx pretyping/termops.cmx lib/util.cmx \ +contrib/first-order/unify.cmx: lib/util.cmx pretyping/termops.cmx \ + kernel/term.cmx proofs/tacmach.cmx pretyping/reductionops.cmx \ + kernel/names.cmx contrib/first-order/formula.cmx \ contrib/first-order/unify.cmi -contrib/fourier/fourierR.cmo: proofs/clenv.cmi tactics/contradiction.cmi \ - interp/coqlib.cmi tactics/equality.cmi contrib/fourier/fourier.cmo \ - library/libnames.cmi library/library.cmi kernel/names.cmi \ - contrib/ring/ring.cmo proofs/tacmach.cmi tactics/tacticals.cmi \ - tactics/tactics.cmi kernel/term.cmi lib/util.cmi toplevel/vernacexpr.cmo -contrib/fourier/fourierR.cmx: proofs/clenv.cmx tactics/contradiction.cmx \ - interp/coqlib.cmx tactics/equality.cmx contrib/fourier/fourier.cmx \ - library/libnames.cmx library/library.cmx kernel/names.cmx \ - contrib/ring/ring.cmx proofs/tacmach.cmx tactics/tacticals.cmx \ - tactics/tactics.cmx kernel/term.cmx lib/util.cmx toplevel/vernacexpr.cmx -contrib/fourier/g_fourier.cmo: toplevel/cerrors.cmi parsing/egrammar.cmi \ - contrib/fourier/fourierR.cmo lib/options.cmi parsing/pcoq.cmi lib/pp.cmi \ - parsing/pptactic.cmi proofs/refiner.cmi proofs/tacexpr.cmo \ - tactics/tacinterp.cmi lib/util.cmi -contrib/fourier/g_fourier.cmx: toplevel/cerrors.cmx parsing/egrammar.cmx \ - contrib/fourier/fourierR.cmx lib/options.cmx parsing/pcoq.cmx lib/pp.cmx \ - parsing/pptactic.cmx proofs/refiner.cmx proofs/tacexpr.cmx \ - tactics/tacinterp.cmx lib/util.cmx -contrib/funind/tacinv.cmo: toplevel/cerrors.cmi interp/constrintern.cmi \ - interp/coqlib.cmi library/decl_kinds.cmo library/declare.cmi \ - parsing/egrammar.cmi kernel/entries.cmi kernel/environ.cmi \ - tactics/equality.cmi pretyping/evd.cmi interp/genarg.cmi \ - library/global.cmi pretyping/inductiveops.cmi kernel/names.cmi \ - lib/options.cmi parsing/pcoq.cmi lib/pp.cmi parsing/pptactic.cmi \ - parsing/printer.cmi proofs/proof_type.cmi pretyping/reductionops.cmi \ - tactics/refine.cmi proofs/refiner.cmi kernel/safe_typing.cmi \ - tactics/setoid_replace.cmi proofs/tacexpr.cmo tactics/tacinterp.cmi \ - contrib/funind/tacinvutils.cmi proofs/tacmach.cmi pretyping/tacred.cmi \ - tactics/tacticals.cmi tactics/tactics.cmi kernel/term.cmi \ - pretyping/termops.cmi pretyping/typing.cmi lib/util.cmi \ - toplevel/vernacinterp.cmi -contrib/funind/tacinv.cmx: toplevel/cerrors.cmx interp/constrintern.cmx \ - interp/coqlib.cmx library/decl_kinds.cmx library/declare.cmx \ - parsing/egrammar.cmx kernel/entries.cmx kernel/environ.cmx \ - tactics/equality.cmx pretyping/evd.cmx interp/genarg.cmx \ - library/global.cmx pretyping/inductiveops.cmx kernel/names.cmx \ - lib/options.cmx parsing/pcoq.cmx lib/pp.cmx parsing/pptactic.cmx \ - parsing/printer.cmx proofs/proof_type.cmx pretyping/reductionops.cmx \ - tactics/refine.cmx proofs/refiner.cmx kernel/safe_typing.cmx \ - tactics/setoid_replace.cmx proofs/tacexpr.cmx tactics/tacinterp.cmx \ - contrib/funind/tacinvutils.cmx proofs/tacmach.cmx pretyping/tacred.cmx \ - tactics/tacticals.cmx tactics/tactics.cmx kernel/term.cmx \ - pretyping/termops.cmx pretyping/typing.cmx lib/util.cmx \ - toplevel/vernacinterp.cmx -contrib/funind/tacinvutils.cmo: interp/coqlib.cmi kernel/declarations.cmi \ - kernel/environ.cmi pretyping/evd.cmi library/global.cmi \ - pretyping/inductiveops.cmi library/nameops.cmi kernel/names.cmi \ - lib/pp.cmi parsing/printer.cmi pretyping/reductionops.cmi kernel/sign.cmi \ - kernel/term.cmi pretyping/termops.cmi lib/util.cmi \ +contrib/fourier/fourierR.cmo: toplevel/vernacexpr.cmo lib/util.cmi \ + kernel/term.cmi tactics/tactics.cmi tactics/tacticals.cmi \ + proofs/tacmach.cmi contrib/ring/ring.cmo kernel/names.cmi \ + library/library.cmi library/libnames.cmi contrib/fourier/fourier.cmo \ + tactics/equality.cmi interp/coqlib.cmi tactics/contradiction.cmi \ + proofs/clenv.cmi +contrib/fourier/fourierR.cmx: toplevel/vernacexpr.cmx lib/util.cmx \ + kernel/term.cmx tactics/tactics.cmx tactics/tacticals.cmx \ + proofs/tacmach.cmx contrib/ring/ring.cmx kernel/names.cmx \ + library/library.cmx library/libnames.cmx contrib/fourier/fourier.cmx \ + tactics/equality.cmx interp/coqlib.cmx tactics/contradiction.cmx \ + proofs/clenv.cmx +contrib/fourier/g_fourier.cmo: lib/util.cmi tactics/tacinterp.cmi \ + proofs/tacexpr.cmo proofs/refiner.cmi parsing/pptactic.cmi lib/pp.cmi \ + parsing/pcoq.cmi lib/options.cmi contrib/fourier/fourierR.cmo \ + parsing/egrammar.cmi toplevel/cerrors.cmi +contrib/fourier/g_fourier.cmx: lib/util.cmx tactics/tacinterp.cmx \ + proofs/tacexpr.cmx proofs/refiner.cmx parsing/pptactic.cmx lib/pp.cmx \ + parsing/pcoq.cmx lib/options.cmx contrib/fourier/fourierR.cmx \ + parsing/egrammar.cmx toplevel/cerrors.cmx +contrib/funind/tacinv.cmo: toplevel/vernacinterp.cmi lib/util.cmi \ + pretyping/typing.cmi pretyping/termops.cmi kernel/term.cmi \ + tactics/tactics.cmi tactics/tacticals.cmi pretyping/tacred.cmi \ + proofs/tacmach.cmi contrib/funind/tacinvutils.cmi tactics/tacinterp.cmi \ + proofs/tacexpr.cmo tactics/setoid_replace.cmi kernel/safe_typing.cmi \ + proofs/refiner.cmi tactics/refine.cmi pretyping/reductionops.cmi \ + proofs/proof_type.cmi parsing/printer.cmi parsing/pptactic.cmi lib/pp.cmi \ + parsing/pcoq.cmi lib/options.cmi kernel/names.cmi \ + pretyping/inductiveops.cmi library/global.cmi interp/genarg.cmi \ + pretyping/evd.cmi tactics/equality.cmi kernel/environ.cmi \ + kernel/entries.cmi parsing/egrammar.cmi library/declare.cmi \ + library/decl_kinds.cmo interp/coqlib.cmi interp/constrintern.cmi \ + toplevel/cerrors.cmi +contrib/funind/tacinv.cmx: toplevel/vernacinterp.cmx lib/util.cmx \ + pretyping/typing.cmx pretyping/termops.cmx kernel/term.cmx \ + tactics/tactics.cmx tactics/tacticals.cmx pretyping/tacred.cmx \ + proofs/tacmach.cmx contrib/funind/tacinvutils.cmx tactics/tacinterp.cmx \ + proofs/tacexpr.cmx tactics/setoid_replace.cmx kernel/safe_typing.cmx \ + proofs/refiner.cmx tactics/refine.cmx pretyping/reductionops.cmx \ + proofs/proof_type.cmx parsing/printer.cmx parsing/pptactic.cmx lib/pp.cmx \ + parsing/pcoq.cmx lib/options.cmx kernel/names.cmx \ + pretyping/inductiveops.cmx library/global.cmx interp/genarg.cmx \ + pretyping/evd.cmx tactics/equality.cmx kernel/environ.cmx \ + kernel/entries.cmx parsing/egrammar.cmx library/declare.cmx \ + library/decl_kinds.cmx interp/coqlib.cmx interp/constrintern.cmx \ + toplevel/cerrors.cmx +contrib/funind/tacinvutils.cmo: lib/util.cmi pretyping/termops.cmi \ + kernel/term.cmi kernel/sign.cmi pretyping/reductionops.cmi \ + parsing/printer.cmi lib/pp.cmi kernel/names.cmi library/nameops.cmi \ + pretyping/inductiveops.cmi library/global.cmi pretyping/evd.cmi \ + kernel/environ.cmi kernel/declarations.cmi interp/coqlib.cmi \ contrib/funind/tacinvutils.cmi -contrib/funind/tacinvutils.cmx: interp/coqlib.cmx kernel/declarations.cmx \ - kernel/environ.cmx pretyping/evd.cmx library/global.cmx \ - pretyping/inductiveops.cmx library/nameops.cmx kernel/names.cmx \ - lib/pp.cmx parsing/printer.cmx pretyping/reductionops.cmx kernel/sign.cmx \ - kernel/term.cmx pretyping/termops.cmx lib/util.cmx \ +contrib/funind/tacinvutils.cmx: lib/util.cmx pretyping/termops.cmx \ + kernel/term.cmx kernel/sign.cmx pretyping/reductionops.cmx \ + parsing/printer.cmx lib/pp.cmx kernel/names.cmx library/nameops.cmx \ + pretyping/inductiveops.cmx library/global.cmx pretyping/evd.cmx \ + kernel/environ.cmx kernel/declarations.cmx interp/coqlib.cmx \ contrib/funind/tacinvutils.cmi -contrib/interface/blast.cmo: tactics/auto.cmi proofs/clenv.cmi \ - toplevel/command.cmi contrib/interface/ctast.cmo kernel/declarations.cmi \ - library/declare.cmi tactics/eauto.cmi kernel/environ.cmi \ - tactics/equality.cmi proofs/evar_refiner.cmi pretyping/evd.cmi \ - lib/explore.cmi library/global.cmi tactics/hipattern.cmi \ - kernel/inductive.cmi proofs/logic.cmi library/nameops.cmi \ - kernel/names.cmi pretyping/pattern.cmi contrib/interface/pbp.cmi \ - parsing/pcoq.cmi proofs/pfedit.cmi lib/pp.cmi parsing/pptactic.cmi \ - parsing/printer.cmi proofs/proof_trees.cmi proofs/proof_type.cmi \ - pretyping/rawterm.cmi kernel/reduction.cmi proofs/refiner.cmi \ - kernel/sign.cmi tactics/tacinterp.cmi proofs/tacmach.cmi \ - pretyping/tacred.cmi tactics/tacticals.cmi tactics/tactics.cmi \ - kernel/term.cmi pretyping/termops.cmi pretyping/typing.cmi lib/util.cmi \ - toplevel/vernacentries.cmi toplevel/vernacinterp.cmi \ - contrib/interface/blast.cmi -contrib/interface/blast.cmx: tactics/auto.cmx proofs/clenv.cmx \ - toplevel/command.cmx contrib/interface/ctast.cmx kernel/declarations.cmx \ - library/declare.cmx tactics/eauto.cmx kernel/environ.cmx \ - tactics/equality.cmx proofs/evar_refiner.cmx pretyping/evd.cmx \ - lib/explore.cmx library/global.cmx tactics/hipattern.cmx \ - kernel/inductive.cmx proofs/logic.cmx library/nameops.cmx \ - kernel/names.cmx pretyping/pattern.cmx contrib/interface/pbp.cmx \ - parsing/pcoq.cmx proofs/pfedit.cmx lib/pp.cmx parsing/pptactic.cmx \ - parsing/printer.cmx proofs/proof_trees.cmx proofs/proof_type.cmx \ - pretyping/rawterm.cmx kernel/reduction.cmx proofs/refiner.cmx \ - kernel/sign.cmx tactics/tacinterp.cmx proofs/tacmach.cmx \ - pretyping/tacred.cmx tactics/tacticals.cmx tactics/tactics.cmx \ - kernel/term.cmx pretyping/termops.cmx pretyping/typing.cmx lib/util.cmx \ - toplevel/vernacentries.cmx toplevel/vernacinterp.cmx \ - contrib/interface/blast.cmi -contrib/interface/centaur.cmo: contrib/interface/ascent.cmi parsing/ast.cmi \ - contrib/interface/blast.cmi toplevel/cerrors.cmi pretyping/classops.cmi \ - toplevel/command.cmi interp/constrintern.cmi parsing/coqast.cmi \ - contrib/interface/debug_tac.cmi kernel/declarations.cmi \ - library/declare.cmi parsing/egrammar.cmi kernel/environ.cmi \ - pretyping/evd.cmi parsing/extend.cmi interp/genarg.cmi library/global.cmi \ - contrib/interface/history.cmi library/lib.cmi library/libnames.cmi \ - library/libobject.cmi library/library.cmi \ - toplevel/line_oriented_parser.cmi pretyping/matching.cmi \ - contrib/interface/name_to_ast.cmi library/nameops.cmi kernel/names.cmi \ - library/nametab.cmi lib/options.cmi contrib/interface/pbp.cmi \ - parsing/pcoq.cmi proofs/pfedit.cmi lib/pp.cmi parsing/pptactic.cmi \ - pretyping/pretyping.cmi proofs/proof_trees.cmi proofs/proof_type.cmi \ - toplevel/protectedtoplevel.cmi pretyping/rawterm.cmi kernel/reduction.cmi \ - proofs/refiner.cmi parsing/search.cmi contrib/interface/showproof.cmi \ - contrib/interface/showproof_ct.cmo proofs/tacexpr.cmo \ - tactics/tacinterp.cmi proofs/tacmach.cmi kernel/term.cmi \ - parsing/termast.cmi contrib/interface/translate.cmi lib/util.cmi \ - toplevel/vernac.cmi toplevel/vernacentries.cmi toplevel/vernacexpr.cmo \ - toplevel/vernacinterp.cmi contrib/interface/vtp.cmi \ - contrib/interface/xlate.cmi -contrib/interface/centaur.cmx: contrib/interface/ascent.cmi parsing/ast.cmx \ - contrib/interface/blast.cmx toplevel/cerrors.cmx pretyping/classops.cmx \ - toplevel/command.cmx interp/constrintern.cmx parsing/coqast.cmx \ - contrib/interface/debug_tac.cmx kernel/declarations.cmx \ - library/declare.cmx parsing/egrammar.cmx kernel/environ.cmx \ - pretyping/evd.cmx parsing/extend.cmx interp/genarg.cmx library/global.cmx \ - contrib/interface/history.cmx library/lib.cmx library/libnames.cmx \ - library/libobject.cmx library/library.cmx \ - toplevel/line_oriented_parser.cmx pretyping/matching.cmx \ - contrib/interface/name_to_ast.cmx library/nameops.cmx kernel/names.cmx \ - library/nametab.cmx lib/options.cmx contrib/interface/pbp.cmx \ - parsing/pcoq.cmx proofs/pfedit.cmx lib/pp.cmx parsing/pptactic.cmx \ - pretyping/pretyping.cmx proofs/proof_trees.cmx proofs/proof_type.cmx \ - toplevel/protectedtoplevel.cmx pretyping/rawterm.cmx kernel/reduction.cmx \ - proofs/refiner.cmx parsing/search.cmx contrib/interface/showproof.cmx \ - contrib/interface/showproof_ct.cmx proofs/tacexpr.cmx \ - tactics/tacinterp.cmx proofs/tacmach.cmx kernel/term.cmx \ - parsing/termast.cmx contrib/interface/translate.cmx lib/util.cmx \ - toplevel/vernac.cmx toplevel/vernacentries.cmx toplevel/vernacexpr.cmx \ - toplevel/vernacinterp.cmx contrib/interface/vtp.cmx \ - contrib/interface/xlate.cmx -contrib/interface/ctast.cmo: parsing/coqast.cmi lib/dyn.cmi \ - library/libnames.cmi kernel/names.cmi lib/util.cmi -contrib/interface/ctast.cmx: parsing/coqast.cmx lib/dyn.cmx \ - library/libnames.cmx kernel/names.cmx lib/util.cmx -contrib/interface/dad.cmo: interp/constrextern.cmi interp/constrintern.cmi \ - kernel/environ.cmi pretyping/evd.cmi interp/genarg.cmi library/global.cmi \ - library/libnames.cmi pretyping/matching.cmi library/nameops.cmi \ - kernel/names.cmi library/nametab.cmi contrib/interface/paths.cmi \ - pretyping/pattern.cmi lib/pp.cmi proofs/proof_trees.cmi \ - proofs/proof_type.cmi pretyping/rawterm.cmi kernel/reduction.cmi \ - proofs/tacexpr.cmo proofs/tacmach.cmi tactics/tacticals.cmi \ - tactics/tactics.cmi kernel/term.cmi interp/topconstr.cmi \ - pretyping/typing.cmi lib/util.cmi toplevel/vernacexpr.cmo \ - toplevel/vernacinterp.cmi contrib/interface/dad.cmi -contrib/interface/dad.cmx: interp/constrextern.cmx interp/constrintern.cmx \ - kernel/environ.cmx pretyping/evd.cmx interp/genarg.cmx library/global.cmx \ - library/libnames.cmx pretyping/matching.cmx library/nameops.cmx \ - kernel/names.cmx library/nametab.cmx contrib/interface/paths.cmx \ - pretyping/pattern.cmx lib/pp.cmx proofs/proof_trees.cmx \ - proofs/proof_type.cmx pretyping/rawterm.cmx kernel/reduction.cmx \ - proofs/tacexpr.cmx proofs/tacmach.cmx tactics/tacticals.cmx \ - tactics/tactics.cmx kernel/term.cmx interp/topconstr.cmx \ - pretyping/typing.cmx lib/util.cmx toplevel/vernacexpr.cmx \ - toplevel/vernacinterp.cmx contrib/interface/dad.cmi -contrib/interface/debug_tac.cmo: parsing/ast.cmi toplevel/cerrors.cmi \ - parsing/coqast.cmi interp/genarg.cmi lib/pp.cmi parsing/pptactic.cmi \ - proofs/proof_trees.cmi proofs/proof_type.cmi proofs/refiner.cmi \ - proofs/tacexpr.cmo tactics/tacinterp.cmi proofs/tacmach.cmi \ - tactics/tacticals.cmi lib/util.cmi contrib/interface/debug_tac.cmi -contrib/interface/debug_tac.cmx: parsing/ast.cmx toplevel/cerrors.cmx \ - parsing/coqast.cmx interp/genarg.cmx lib/pp.cmx parsing/pptactic.cmx \ - proofs/proof_trees.cmx proofs/proof_type.cmx proofs/refiner.cmx \ - proofs/tacexpr.cmx tactics/tacinterp.cmx proofs/tacmach.cmx \ - tactics/tacticals.cmx lib/util.cmx contrib/interface/debug_tac.cmi +contrib/interface/blast.cmo: toplevel/vernacinterp.cmi \ + toplevel/vernacentries.cmi lib/util.cmi pretyping/typing.cmi \ + pretyping/termops.cmi kernel/term.cmi tactics/tactics.cmi \ + tactics/tacticals.cmi pretyping/tacred.cmi proofs/tacmach.cmi \ + tactics/tacinterp.cmi kernel/sign.cmi proofs/refiner.cmi \ + kernel/reduction.cmi pretyping/rawterm.cmi proofs/proof_type.cmi \ + proofs/proof_trees.cmi parsing/printer.cmi parsing/pptactic.cmi \ + lib/pp.cmi proofs/pfedit.cmi parsing/pcoq.cmi contrib/interface/pbp.cmi \ + pretyping/pattern.cmi kernel/names.cmi library/nameops.cmi \ + proofs/logic.cmi kernel/inductive.cmi tactics/hipattern.cmi \ + library/global.cmi lib/explore.cmi pretyping/evd.cmi \ + proofs/evar_refiner.cmi tactics/equality.cmi kernel/environ.cmi \ + tactics/eauto.cmi library/declare.cmi kernel/declarations.cmi \ + contrib/interface/ctast.cmo toplevel/command.cmi proofs/clenv.cmi \ + tactics/auto.cmi contrib/interface/blast.cmi +contrib/interface/blast.cmx: toplevel/vernacinterp.cmx \ + toplevel/vernacentries.cmx lib/util.cmx pretyping/typing.cmx \ + pretyping/termops.cmx kernel/term.cmx tactics/tactics.cmx \ + tactics/tacticals.cmx pretyping/tacred.cmx proofs/tacmach.cmx \ + tactics/tacinterp.cmx kernel/sign.cmx proofs/refiner.cmx \ + kernel/reduction.cmx pretyping/rawterm.cmx proofs/proof_type.cmx \ + proofs/proof_trees.cmx parsing/printer.cmx parsing/pptactic.cmx \ + lib/pp.cmx proofs/pfedit.cmx parsing/pcoq.cmx contrib/interface/pbp.cmx \ + pretyping/pattern.cmx kernel/names.cmx library/nameops.cmx \ + proofs/logic.cmx kernel/inductive.cmx tactics/hipattern.cmx \ + library/global.cmx lib/explore.cmx pretyping/evd.cmx \ + proofs/evar_refiner.cmx tactics/equality.cmx kernel/environ.cmx \ + tactics/eauto.cmx library/declare.cmx kernel/declarations.cmx \ + contrib/interface/ctast.cmx toplevel/command.cmx proofs/clenv.cmx \ + tactics/auto.cmx contrib/interface/blast.cmi +contrib/interface/centaur.cmo: contrib/interface/xlate.cmi \ + contrib/interface/vtp.cmi toplevel/vernacinterp.cmi \ + toplevel/vernacexpr.cmo toplevel/vernacentries.cmi toplevel/vernac.cmi \ + lib/util.cmi contrib/interface/translate.cmi parsing/termast.cmi \ + kernel/term.cmi proofs/tacmach.cmi tactics/tacinterp.cmi \ + proofs/tacexpr.cmo contrib/interface/showproof_ct.cmo \ + contrib/interface/showproof.cmi parsing/search.cmi proofs/refiner.cmi \ + kernel/reduction.cmi pretyping/rawterm.cmi toplevel/protectedtoplevel.cmi \ + proofs/proof_type.cmi proofs/proof_trees.cmi pretyping/pretyping.cmi \ + parsing/pptactic.cmi lib/pp.cmi proofs/pfedit.cmi parsing/pcoq.cmi \ + contrib/interface/pbp.cmi lib/options.cmi library/nametab.cmi \ + kernel/names.cmi library/nameops.cmi contrib/interface/name_to_ast.cmi \ + pretyping/matching.cmi toplevel/line_oriented_parser.cmi \ + library/library.cmi library/libobject.cmi library/libnames.cmi \ + library/lib.cmi contrib/interface/history.cmi library/global.cmi \ + interp/genarg.cmi parsing/extend.cmi pretyping/evd.cmi kernel/environ.cmi \ + parsing/egrammar.cmi library/declare.cmi kernel/declarations.cmi \ + contrib/interface/debug_tac.cmi parsing/coqast.cmi \ + interp/constrintern.cmi toplevel/command.cmi pretyping/classops.cmi \ + toplevel/cerrors.cmi contrib/interface/blast.cmi parsing/ast.cmi \ + contrib/interface/ascent.cmi +contrib/interface/centaur.cmx: contrib/interface/xlate.cmx \ + contrib/interface/vtp.cmx toplevel/vernacinterp.cmx \ + toplevel/vernacexpr.cmx toplevel/vernacentries.cmx toplevel/vernac.cmx \ + lib/util.cmx contrib/interface/translate.cmx parsing/termast.cmx \ + kernel/term.cmx proofs/tacmach.cmx tactics/tacinterp.cmx \ + proofs/tacexpr.cmx contrib/interface/showproof_ct.cmx \ + contrib/interface/showproof.cmx parsing/search.cmx proofs/refiner.cmx \ + kernel/reduction.cmx pretyping/rawterm.cmx toplevel/protectedtoplevel.cmx \ + proofs/proof_type.cmx proofs/proof_trees.cmx pretyping/pretyping.cmx \ + parsing/pptactic.cmx lib/pp.cmx proofs/pfedit.cmx parsing/pcoq.cmx \ + contrib/interface/pbp.cmx lib/options.cmx library/nametab.cmx \ + kernel/names.cmx library/nameops.cmx contrib/interface/name_to_ast.cmx \ + pretyping/matching.cmx toplevel/line_oriented_parser.cmx \ + library/library.cmx library/libobject.cmx library/libnames.cmx \ + library/lib.cmx contrib/interface/history.cmx library/global.cmx \ + interp/genarg.cmx parsing/extend.cmx pretyping/evd.cmx kernel/environ.cmx \ + parsing/egrammar.cmx library/declare.cmx kernel/declarations.cmx \ + contrib/interface/debug_tac.cmx parsing/coqast.cmx \ + interp/constrintern.cmx toplevel/command.cmx pretyping/classops.cmx \ + toplevel/cerrors.cmx contrib/interface/blast.cmx parsing/ast.cmx \ + contrib/interface/ascent.cmi +contrib/interface/ctast.cmo: lib/util.cmi kernel/names.cmi \ + library/libnames.cmi lib/dyn.cmi parsing/coqast.cmi +contrib/interface/ctast.cmx: lib/util.cmx kernel/names.cmx \ + library/libnames.cmx lib/dyn.cmx parsing/coqast.cmx +contrib/interface/dad.cmo: toplevel/vernacinterp.cmi toplevel/vernacexpr.cmo \ + lib/util.cmi pretyping/typing.cmi interp/topconstr.cmi kernel/term.cmi \ + tactics/tactics.cmi tactics/tacticals.cmi proofs/tacmach.cmi \ + proofs/tacexpr.cmo kernel/reduction.cmi pretyping/rawterm.cmi \ + proofs/proof_type.cmi proofs/proof_trees.cmi lib/pp.cmi \ + pretyping/pattern.cmi contrib/interface/paths.cmi library/nametab.cmi \ + kernel/names.cmi library/nameops.cmi pretyping/matching.cmi \ + library/libnames.cmi library/global.cmi interp/genarg.cmi \ + pretyping/evd.cmi kernel/environ.cmi interp/constrintern.cmi \ + interp/constrextern.cmi contrib/interface/dad.cmi +contrib/interface/dad.cmx: toplevel/vernacinterp.cmx toplevel/vernacexpr.cmx \ + lib/util.cmx pretyping/typing.cmx interp/topconstr.cmx kernel/term.cmx \ + tactics/tactics.cmx tactics/tacticals.cmx proofs/tacmach.cmx \ + proofs/tacexpr.cmx kernel/reduction.cmx pretyping/rawterm.cmx \ + proofs/proof_type.cmx proofs/proof_trees.cmx lib/pp.cmx \ + pretyping/pattern.cmx contrib/interface/paths.cmx library/nametab.cmx \ + kernel/names.cmx library/nameops.cmx pretyping/matching.cmx \ + library/libnames.cmx library/global.cmx interp/genarg.cmx \ + pretyping/evd.cmx kernel/environ.cmx interp/constrintern.cmx \ + interp/constrextern.cmx contrib/interface/dad.cmi +contrib/interface/debug_tac.cmo: lib/util.cmi tactics/tacticals.cmi \ + proofs/tacmach.cmi tactics/tacinterp.cmi proofs/tacexpr.cmo \ + proofs/refiner.cmi proofs/proof_type.cmi proofs/proof_trees.cmi \ + parsing/pptactic.cmi lib/pp.cmi interp/genarg.cmi parsing/coqast.cmi \ + toplevel/cerrors.cmi parsing/ast.cmi contrib/interface/debug_tac.cmi +contrib/interface/debug_tac.cmx: lib/util.cmx tactics/tacticals.cmx \ + proofs/tacmach.cmx tactics/tacinterp.cmx proofs/tacexpr.cmx \ + proofs/refiner.cmx proofs/proof_type.cmx proofs/proof_trees.cmx \ + parsing/pptactic.cmx lib/pp.cmx interp/genarg.cmx parsing/coqast.cmx \ + toplevel/cerrors.cmx parsing/ast.cmx contrib/interface/debug_tac.cmi contrib/interface/history.cmo: contrib/interface/paths.cmi \ contrib/interface/history.cmi contrib/interface/history.cmx: contrib/interface/paths.cmx \ contrib/interface/history.cmi contrib/interface/line_parser.cmo: contrib/interface/line_parser.cmi contrib/interface/line_parser.cmx: contrib/interface/line_parser.cmi -contrib/interface/name_to_ast.cmo: parsing/ast.cmi pretyping/classops.cmi \ - interp/constrextern.cmi parsing/coqast.cmi library/decl_kinds.cmo \ - kernel/declarations.cmi library/declare.cmi kernel/environ.cmi \ - library/global.cmi library/impargs.cmi kernel/inductive.cmi \ - library/lib.cmi library/libnames.cmi library/libobject.cmi \ - library/nameops.cmi kernel/names.cmi library/nametab.cmi lib/pp.cmi \ - parsing/prettyp.cmi kernel/reduction.cmi kernel/sign.cmi kernel/term.cmi \ - parsing/termast.cmi interp/topconstr.cmi lib/util.cmi \ - toplevel/vernacexpr.cmo contrib/interface/name_to_ast.cmi -contrib/interface/name_to_ast.cmx: parsing/ast.cmx pretyping/classops.cmx \ - interp/constrextern.cmx parsing/coqast.cmx library/decl_kinds.cmx \ - kernel/declarations.cmx library/declare.cmx kernel/environ.cmx \ - library/global.cmx library/impargs.cmx kernel/inductive.cmx \ - library/lib.cmx library/libnames.cmx library/libobject.cmx \ - library/nameops.cmx kernel/names.cmx library/nametab.cmx lib/pp.cmx \ - parsing/prettyp.cmx kernel/reduction.cmx kernel/sign.cmx kernel/term.cmx \ - parsing/termast.cmx interp/topconstr.cmx lib/util.cmx \ - toplevel/vernacexpr.cmx contrib/interface/name_to_ast.cmi -contrib/interface/parse.cmo: contrib/interface/ascent.cmi \ - toplevel/cerrors.cmi config/coq_config.cmi library/declaremods.cmi \ - parsing/esyntax.cmi library/libnames.cmi library/libobject.cmi \ - library/library.cmi contrib/interface/line_parser.cmi toplevel/mltop.cmi \ - library/nameops.cmi kernel/names.cmi library/nametab.cmi parsing/pcoq.cmi \ - lib/pp.cmi lib/system.cmi lib/util.cmi toplevel/vernacentries.cmi \ - toplevel/vernacexpr.cmo contrib/interface/vtp.cmi \ - contrib/interface/xlate.cmi -contrib/interface/parse.cmx: contrib/interface/ascent.cmi \ - toplevel/cerrors.cmx config/coq_config.cmx library/declaremods.cmx \ - parsing/esyntax.cmx library/libnames.cmx library/libobject.cmx \ - library/library.cmx contrib/interface/line_parser.cmx toplevel/mltop.cmx \ - library/nameops.cmx kernel/names.cmx library/nametab.cmx parsing/pcoq.cmx \ - lib/pp.cmx lib/system.cmx lib/util.cmx toplevel/vernacentries.cmx \ - toplevel/vernacexpr.cmx contrib/interface/vtp.cmx \ - contrib/interface/xlate.cmx +contrib/interface/name_to_ast.cmo: toplevel/vernacexpr.cmo lib/util.cmi \ + interp/topconstr.cmi parsing/termast.cmi kernel/term.cmi kernel/sign.cmi \ + kernel/reduction.cmi parsing/prettyp.cmi lib/pp.cmi library/nametab.cmi \ + kernel/names.cmi library/nameops.cmi library/libobject.cmi \ + library/libnames.cmi library/lib.cmi kernel/inductive.cmi \ + library/impargs.cmi library/global.cmi kernel/environ.cmi \ + library/declare.cmi kernel/declarations.cmi library/decl_kinds.cmo \ + parsing/coqast.cmi interp/constrextern.cmi pretyping/classops.cmi \ + parsing/ast.cmi contrib/interface/name_to_ast.cmi +contrib/interface/name_to_ast.cmx: toplevel/vernacexpr.cmx lib/util.cmx \ + interp/topconstr.cmx parsing/termast.cmx kernel/term.cmx kernel/sign.cmx \ + kernel/reduction.cmx parsing/prettyp.cmx lib/pp.cmx library/nametab.cmx \ + kernel/names.cmx library/nameops.cmx library/libobject.cmx \ + library/libnames.cmx library/lib.cmx kernel/inductive.cmx \ + library/impargs.cmx library/global.cmx kernel/environ.cmx \ + library/declare.cmx kernel/declarations.cmx library/decl_kinds.cmx \ + parsing/coqast.cmx interp/constrextern.cmx pretyping/classops.cmx \ + parsing/ast.cmx contrib/interface/name_to_ast.cmi +contrib/interface/parse.cmo: contrib/interface/xlate.cmi \ + contrib/interface/vtp.cmi toplevel/vernacexpr.cmo \ + toplevel/vernacentries.cmi lib/util.cmi lib/system.cmi lib/pp.cmi \ + parsing/pcoq.cmi library/nametab.cmi kernel/names.cmi library/nameops.cmi \ + toplevel/mltop.cmi contrib/interface/line_parser.cmi library/library.cmi \ + library/libobject.cmi library/libnames.cmi parsing/esyntax.cmi \ + library/declaremods.cmi config/coq_config.cmi toplevel/cerrors.cmi \ + contrib/interface/ascent.cmi +contrib/interface/parse.cmx: contrib/interface/xlate.cmx \ + contrib/interface/vtp.cmx toplevel/vernacexpr.cmx \ + toplevel/vernacentries.cmx lib/util.cmx lib/system.cmx lib/pp.cmx \ + parsing/pcoq.cmx library/nametab.cmx kernel/names.cmx library/nameops.cmx \ + toplevel/mltop.cmx contrib/interface/line_parser.cmx library/library.cmx \ + library/libobject.cmx library/libnames.cmx parsing/esyntax.cmx \ + library/declaremods.cmx config/coq_config.cmx toplevel/cerrors.cmx \ + contrib/interface/ascent.cmi contrib/interface/paths.cmo: contrib/interface/paths.cmi contrib/interface/paths.cmx: contrib/interface/paths.cmi -contrib/interface/pbp.cmo: interp/coqlib.cmi kernel/environ.cmi \ - pretyping/evd.cmi interp/genarg.cmi library/global.cmi \ - tactics/hipattern.cmi library/libnames.cmi proofs/logic.cmi \ - pretyping/matching.cmi kernel/names.cmi library/nametab.cmi \ - pretyping/pattern.cmi lib/pp.cmi pretyping/pretyping.cmi \ - proofs/proof_trees.cmi proofs/proof_type.cmi pretyping/rawterm.cmi \ - kernel/reduction.cmi proofs/tacexpr.cmo tactics/tacinterp.cmi \ - proofs/tacmach.cmi tactics/tacticals.cmi tactics/tactics.cmi \ - kernel/term.cmi pretyping/termops.cmi interp/topconstr.cmi \ - pretyping/typing.cmi lib/util.cmi contrib/interface/pbp.cmi -contrib/interface/pbp.cmx: interp/coqlib.cmx kernel/environ.cmx \ - pretyping/evd.cmx interp/genarg.cmx library/global.cmx \ - tactics/hipattern.cmx library/libnames.cmx proofs/logic.cmx \ - pretyping/matching.cmx kernel/names.cmx library/nametab.cmx \ - pretyping/pattern.cmx lib/pp.cmx pretyping/pretyping.cmx \ - proofs/proof_trees.cmx proofs/proof_type.cmx pretyping/rawterm.cmx \ - kernel/reduction.cmx proofs/tacexpr.cmx tactics/tacinterp.cmx \ - proofs/tacmach.cmx tactics/tacticals.cmx tactics/tactics.cmx \ - kernel/term.cmx pretyping/termops.cmx interp/topconstr.cmx \ - pretyping/typing.cmx lib/util.cmx contrib/interface/pbp.cmi -contrib/interface/showproof_ct.cmo: contrib/interface/ascent.cmi \ - parsing/esyntax.cmi library/global.cmi toplevel/metasyntax.cmi lib/pp.cmi \ - parsing/printer.cmi contrib/interface/translate.cmi \ - contrib/interface/vtp.cmi contrib/interface/xlate.cmi -contrib/interface/showproof_ct.cmx: contrib/interface/ascent.cmi \ - parsing/esyntax.cmx library/global.cmx toplevel/metasyntax.cmx lib/pp.cmx \ - parsing/printer.cmx contrib/interface/translate.cmx \ - contrib/interface/vtp.cmx contrib/interface/xlate.cmx -contrib/interface/showproof.cmo: proofs/clenv.cmi interp/constrintern.cmi \ - parsing/coqast.cmi kernel/declarations.cmi kernel/environ.cmi \ - pretyping/evd.cmi interp/genarg.cmi library/global.cmi \ - kernel/inductive.cmi pretyping/inductiveops.cmi library/libnames.cmi \ - library/nameops.cmi kernel/names.cmi proofs/pfedit.cmi lib/pp.cmi \ - parsing/printer.cmi proofs/proof_trees.cmi proofs/proof_type.cmi \ - pretyping/rawterm.cmi pretyping/reductionops.cmi \ - contrib/interface/showproof_ct.cmo kernel/sign.cmi proofs/tacexpr.cmo \ - proofs/tacmach.cmi kernel/term.cmi parsing/termast.cmi \ - pretyping/termops.cmi contrib/interface/translate.cmi \ - pretyping/typing.cmi lib/util.cmi toplevel/vernacinterp.cmi \ +contrib/interface/pbp.cmo: lib/util.cmi pretyping/typing.cmi \ + interp/topconstr.cmi pretyping/termops.cmi kernel/term.cmi \ + tactics/tactics.cmi tactics/tacticals.cmi proofs/tacmach.cmi \ + tactics/tacinterp.cmi proofs/tacexpr.cmo kernel/reduction.cmi \ + pretyping/rawterm.cmi proofs/proof_type.cmi proofs/proof_trees.cmi \ + pretyping/pretyping.cmi lib/pp.cmi pretyping/pattern.cmi \ + library/nametab.cmi kernel/names.cmi pretyping/matching.cmi \ + proofs/logic.cmi library/libnames.cmi tactics/hipattern.cmi \ + library/global.cmi interp/genarg.cmi pretyping/evd.cmi kernel/environ.cmi \ + interp/coqlib.cmi contrib/interface/pbp.cmi +contrib/interface/pbp.cmx: lib/util.cmx pretyping/typing.cmx \ + interp/topconstr.cmx pretyping/termops.cmx kernel/term.cmx \ + tactics/tactics.cmx tactics/tacticals.cmx proofs/tacmach.cmx \ + tactics/tacinterp.cmx proofs/tacexpr.cmx kernel/reduction.cmx \ + pretyping/rawterm.cmx proofs/proof_type.cmx proofs/proof_trees.cmx \ + pretyping/pretyping.cmx lib/pp.cmx pretyping/pattern.cmx \ + library/nametab.cmx kernel/names.cmx pretyping/matching.cmx \ + proofs/logic.cmx library/libnames.cmx tactics/hipattern.cmx \ + library/global.cmx interp/genarg.cmx pretyping/evd.cmx kernel/environ.cmx \ + interp/coqlib.cmx contrib/interface/pbp.cmi +contrib/interface/showproof.cmo: toplevel/vernacinterp.cmi lib/util.cmi \ + pretyping/typing.cmi contrib/interface/translate.cmi \ + pretyping/termops.cmi parsing/termast.cmi kernel/term.cmi \ + proofs/tacmach.cmi proofs/tacexpr.cmo kernel/sign.cmi \ + contrib/interface/showproof_ct.cmo pretyping/reductionops.cmi \ + pretyping/rawterm.cmi proofs/proof_type.cmi proofs/proof_trees.cmi \ + parsing/printer.cmi lib/pp.cmi proofs/pfedit.cmi kernel/names.cmi \ + library/nameops.cmi library/libnames.cmi pretyping/inductiveops.cmi \ + kernel/inductive.cmi library/global.cmi interp/genarg.cmi \ + pretyping/evd.cmi kernel/environ.cmi kernel/declarations.cmi \ + parsing/coqast.cmi interp/constrintern.cmi proofs/clenv.cmi \ contrib/interface/showproof.cmi -contrib/interface/showproof.cmx: proofs/clenv.cmx interp/constrintern.cmx \ - parsing/coqast.cmx kernel/declarations.cmx kernel/environ.cmx \ - pretyping/evd.cmx interp/genarg.cmx library/global.cmx \ - kernel/inductive.cmx pretyping/inductiveops.cmx library/libnames.cmx \ - library/nameops.cmx kernel/names.cmx proofs/pfedit.cmx lib/pp.cmx \ - parsing/printer.cmx proofs/proof_trees.cmx proofs/proof_type.cmx \ - pretyping/rawterm.cmx pretyping/reductionops.cmx \ - contrib/interface/showproof_ct.cmx kernel/sign.cmx proofs/tacexpr.cmx \ - proofs/tacmach.cmx kernel/term.cmx parsing/termast.cmx \ - pretyping/termops.cmx contrib/interface/translate.cmx \ - pretyping/typing.cmx lib/util.cmx toplevel/vernacinterp.cmx \ +contrib/interface/showproof.cmx: toplevel/vernacinterp.cmx lib/util.cmx \ + pretyping/typing.cmx contrib/interface/translate.cmx \ + pretyping/termops.cmx parsing/termast.cmx kernel/term.cmx \ + proofs/tacmach.cmx proofs/tacexpr.cmx kernel/sign.cmx \ + contrib/interface/showproof_ct.cmx pretyping/reductionops.cmx \ + pretyping/rawterm.cmx proofs/proof_type.cmx proofs/proof_trees.cmx \ + parsing/printer.cmx lib/pp.cmx proofs/pfedit.cmx kernel/names.cmx \ + library/nameops.cmx library/libnames.cmx pretyping/inductiveops.cmx \ + kernel/inductive.cmx library/global.cmx interp/genarg.cmx \ + pretyping/evd.cmx kernel/environ.cmx kernel/declarations.cmx \ + parsing/coqast.cmx interp/constrintern.cmx proofs/clenv.cmx \ contrib/interface/showproof.cmi -contrib/interface/translate.cmo: contrib/interface/ascent.cmi parsing/ast.cmi \ - interp/constrextern.cmi contrib/interface/ctast.cmo kernel/environ.cmi \ - pretyping/evarutil.cmi pretyping/evd.cmi library/libobject.cmi \ - library/library.cmi kernel/names.cmi proofs/pfedit.cmi lib/pp.cmi \ - proofs/proof_type.cmi kernel/sign.cmi proofs/tacmach.cmi kernel/term.cmi \ - parsing/termast.cmi lib/util.cmi toplevel/vernacinterp.cmi \ - contrib/interface/vtp.cmi contrib/interface/xlate.cmi \ +contrib/interface/showproof_ct.cmo: contrib/interface/xlate.cmi \ + contrib/interface/vtp.cmi contrib/interface/translate.cmi \ + parsing/printer.cmi lib/pp.cmi toplevel/metasyntax.cmi library/global.cmi \ + parsing/esyntax.cmi contrib/interface/ascent.cmi +contrib/interface/showproof_ct.cmx: contrib/interface/xlate.cmx \ + contrib/interface/vtp.cmx contrib/interface/translate.cmx \ + parsing/printer.cmx lib/pp.cmx toplevel/metasyntax.cmx library/global.cmx \ + parsing/esyntax.cmx contrib/interface/ascent.cmi +contrib/interface/translate.cmo: contrib/interface/xlate.cmi \ + contrib/interface/vtp.cmi toplevel/vernacinterp.cmi lib/util.cmi \ + parsing/termast.cmi kernel/term.cmi proofs/tacmach.cmi kernel/sign.cmi \ + proofs/proof_type.cmi lib/pp.cmi proofs/pfedit.cmi kernel/names.cmi \ + library/library.cmi library/libobject.cmi pretyping/evd.cmi \ + pretyping/evarutil.cmi kernel/environ.cmi contrib/interface/ctast.cmo \ + interp/constrextern.cmi parsing/ast.cmi contrib/interface/ascent.cmi \ contrib/interface/translate.cmi -contrib/interface/translate.cmx: contrib/interface/ascent.cmi parsing/ast.cmx \ - interp/constrextern.cmx contrib/interface/ctast.cmx kernel/environ.cmx \ - pretyping/evarutil.cmx pretyping/evd.cmx library/libobject.cmx \ - library/library.cmx kernel/names.cmx proofs/pfedit.cmx lib/pp.cmx \ - proofs/proof_type.cmx kernel/sign.cmx proofs/tacmach.cmx kernel/term.cmx \ - parsing/termast.cmx lib/util.cmx toplevel/vernacinterp.cmx \ - contrib/interface/vtp.cmx contrib/interface/xlate.cmx \ +contrib/interface/translate.cmx: contrib/interface/xlate.cmx \ + contrib/interface/vtp.cmx toplevel/vernacinterp.cmx lib/util.cmx \ + parsing/termast.cmx kernel/term.cmx proofs/tacmach.cmx kernel/sign.cmx \ + proofs/proof_type.cmx lib/pp.cmx proofs/pfedit.cmx kernel/names.cmx \ + library/library.cmx library/libobject.cmx pretyping/evd.cmx \ + pretyping/evarutil.cmx kernel/environ.cmx contrib/interface/ctast.cmx \ + interp/constrextern.cmx parsing/ast.cmx contrib/interface/ascent.cmi \ contrib/interface/translate.cmi contrib/interface/vtp.cmo: contrib/interface/ascent.cmi \ contrib/interface/vtp.cmi contrib/interface/vtp.cmx: contrib/interface/ascent.cmi \ contrib/interface/vtp.cmi -contrib/interface/xlate.cmo: contrib/interface/ascent.cmi parsing/ast.cmi \ - lib/bignat.cmi library/decl_kinds.cmo tactics/eauto.cmi \ - parsing/extend.cmi tactics/extraargs.cmi contrib/field/field.cmo \ - interp/genarg.cmi library/goptions.cmi library/libnames.cmi \ - kernel/names.cmi lib/options.cmi parsing/ppconstr.cmi \ - pretyping/rawterm.cmi proofs/tacexpr.cmo kernel/term.cmi \ - interp/topconstr.cmi lib/util.cmi toplevel/vernacexpr.cmo \ +contrib/interface/xlate.cmo: toplevel/vernacexpr.cmo lib/util.cmi \ + interp/topconstr.cmi kernel/term.cmi proofs/tacexpr.cmo \ + pretyping/rawterm.cmi parsing/ppconstr.cmi lib/options.cmi \ + kernel/names.cmi library/libnames.cmi library/goptions.cmi \ + interp/genarg.cmi contrib/field/field.cmo tactics/extraargs.cmi \ + parsing/extend.cmi tactics/eauto.cmi library/decl_kinds.cmo \ + lib/bignat.cmi parsing/ast.cmi contrib/interface/ascent.cmi \ contrib/interface/xlate.cmi -contrib/interface/xlate.cmx: contrib/interface/ascent.cmi parsing/ast.cmx \ - lib/bignat.cmx library/decl_kinds.cmx tactics/eauto.cmx \ - parsing/extend.cmx tactics/extraargs.cmx contrib/field/field.cmx \ - interp/genarg.cmx library/goptions.cmx library/libnames.cmx \ - kernel/names.cmx lib/options.cmx parsing/ppconstr.cmx \ - pretyping/rawterm.cmx proofs/tacexpr.cmx kernel/term.cmx \ - interp/topconstr.cmx lib/util.cmx toplevel/vernacexpr.cmx \ +contrib/interface/xlate.cmx: toplevel/vernacexpr.cmx lib/util.cmx \ + interp/topconstr.cmx kernel/term.cmx proofs/tacexpr.cmx \ + pretyping/rawterm.cmx parsing/ppconstr.cmx lib/options.cmx \ + kernel/names.cmx library/libnames.cmx library/goptions.cmx \ + interp/genarg.cmx contrib/field/field.cmx tactics/extraargs.cmx \ + parsing/extend.cmx tactics/eauto.cmx library/decl_kinds.cmx \ + lib/bignat.cmx parsing/ast.cmx contrib/interface/ascent.cmi \ contrib/interface/xlate.cmi -contrib/jprover/jall.cmo: contrib/jprover/jlogic.cmi \ - contrib/jprover/jterm.cmi contrib/jprover/jtunify.cmi \ - contrib/jprover/opname.cmi lib/pp.cmi contrib/jprover/jall.cmi -contrib/jprover/jall.cmx: contrib/jprover/jlogic.cmx \ - contrib/jprover/jterm.cmx contrib/jprover/jtunify.cmx \ - contrib/jprover/opname.cmx lib/pp.cmx contrib/jprover/jall.cmi -contrib/jprover/jlogic.cmo: contrib/jprover/jterm.cmi \ - contrib/jprover/opname.cmi contrib/jprover/jlogic.cmi -contrib/jprover/jlogic.cmx: contrib/jprover/jterm.cmx \ - contrib/jprover/opname.cmx contrib/jprover/jlogic.cmi -contrib/jprover/jprover.cmo: toplevel/cerrors.cmi proofs/clenv.cmi \ - parsing/egrammar.cmi interp/genarg.cmi library/global.cmi \ - tactics/hiddentac.cmi tactics/hipattern.cmi contrib/jprover/jall.cmi \ - contrib/jprover/jlogic.cmi contrib/jprover/jterm.cmi kernel/names.cmi \ - lib/options.cmi pretyping/pattern.cmi parsing/pcoq.cmi lib/pp.cmi \ - parsing/pptactic.cmi parsing/printer.cmi proofs/proof_type.cmi \ - pretyping/rawterm.cmi kernel/reduction.cmi pretyping/reductionops.cmi \ - proofs/refiner.cmi proofs/tacexpr.cmo tactics/tacinterp.cmi \ - proofs/tacmach.cmi tactics/tacticals.cmi tactics/tactics.cmi \ - kernel/term.cmi pretyping/termops.cmi lib/util.cmi -contrib/jprover/jprover.cmx: toplevel/cerrors.cmx proofs/clenv.cmx \ - parsing/egrammar.cmx interp/genarg.cmx library/global.cmx \ - tactics/hiddentac.cmx tactics/hipattern.cmx contrib/jprover/jall.cmx \ - contrib/jprover/jlogic.cmx contrib/jprover/jterm.cmx kernel/names.cmx \ - lib/options.cmx pretyping/pattern.cmx parsing/pcoq.cmx lib/pp.cmx \ - parsing/pptactic.cmx parsing/printer.cmx proofs/proof_type.cmx \ - pretyping/rawterm.cmx kernel/reduction.cmx pretyping/reductionops.cmx \ - proofs/refiner.cmx proofs/tacexpr.cmx tactics/tacinterp.cmx \ - proofs/tacmach.cmx tactics/tacticals.cmx tactics/tactics.cmx \ - kernel/term.cmx pretyping/termops.cmx lib/util.cmx +contrib/jprover/jall.cmo: lib/pp.cmi contrib/jprover/opname.cmi \ + contrib/jprover/jtunify.cmi contrib/jprover/jterm.cmi \ + contrib/jprover/jlogic.cmi contrib/jprover/jall.cmi +contrib/jprover/jall.cmx: lib/pp.cmx contrib/jprover/opname.cmx \ + contrib/jprover/jtunify.cmx contrib/jprover/jterm.cmx \ + contrib/jprover/jlogic.cmx contrib/jprover/jall.cmi +contrib/jprover/jlogic.cmo: contrib/jprover/opname.cmi \ + contrib/jprover/jterm.cmi contrib/jprover/jlogic.cmi +contrib/jprover/jlogic.cmx: contrib/jprover/opname.cmx \ + contrib/jprover/jterm.cmx contrib/jprover/jlogic.cmi +contrib/jprover/jprover.cmo: lib/util.cmi pretyping/termops.cmi \ + kernel/term.cmi tactics/tactics.cmi tactics/tacticals.cmi \ + proofs/tacmach.cmi tactics/tacinterp.cmi proofs/tacexpr.cmo \ + proofs/refiner.cmi pretyping/reductionops.cmi kernel/reduction.cmi \ + pretyping/rawterm.cmi proofs/proof_type.cmi parsing/printer.cmi \ + parsing/pptactic.cmi lib/pp.cmi parsing/pcoq.cmi pretyping/pattern.cmi \ + lib/options.cmi kernel/names.cmi contrib/jprover/jterm.cmi \ + contrib/jprover/jlogic.cmi contrib/jprover/jall.cmi tactics/hipattern.cmi \ + tactics/hiddentac.cmi library/global.cmi interp/genarg.cmi \ + parsing/egrammar.cmi proofs/clenv.cmi toplevel/cerrors.cmi +contrib/jprover/jprover.cmx: lib/util.cmx pretyping/termops.cmx \ + kernel/term.cmx tactics/tactics.cmx tactics/tacticals.cmx \ + proofs/tacmach.cmx tactics/tacinterp.cmx proofs/tacexpr.cmx \ + proofs/refiner.cmx pretyping/reductionops.cmx kernel/reduction.cmx \ + pretyping/rawterm.cmx proofs/proof_type.cmx parsing/printer.cmx \ + parsing/pptactic.cmx lib/pp.cmx parsing/pcoq.cmx pretyping/pattern.cmx \ + lib/options.cmx kernel/names.cmx contrib/jprover/jterm.cmx \ + contrib/jprover/jlogic.cmx contrib/jprover/jall.cmx tactics/hipattern.cmx \ + tactics/hiddentac.cmx library/global.cmx interp/genarg.cmx \ + parsing/egrammar.cmx proofs/clenv.cmx toplevel/cerrors.cmx contrib/jprover/jterm.cmo: contrib/jprover/opname.cmi \ contrib/jprover/jterm.cmi contrib/jprover/jterm.cmx: contrib/jprover/opname.cmx \ @@ -3043,228 +3040,230 @@ contrib/jprover/jtunify.cmo: contrib/jprover/jtunify.cmi contrib/jprover/jtunify.cmx: contrib/jprover/jtunify.cmi contrib/jprover/opname.cmo: contrib/jprover/opname.cmi contrib/jprover/opname.cmx: contrib/jprover/opname.cmi -contrib/omega/coq_omega.cmo: parsing/ast.cmi proofs/clenv.cmi \ - kernel/closure.cmi tactics/contradiction.cmi interp/coqlib.cmi \ - kernel/declarations.cmi kernel/environ.cmi tactics/equality.cmi \ - proofs/evar_refiner.cmi library/global.cmi library/goptions.cmi \ - kernel/inductive.cmi library/libnames.cmi library/library.cmi \ - proofs/logic.cmi library/nameops.cmi kernel/names.cmi library/nametab.cmi \ - contrib/omega/omega.cmo lib/options.cmi lib/pp.cmi parsing/printer.cmi \ - proofs/proof_type.cmi pretyping/rawterm.cmi kernel/reduction.cmi \ - kernel/sign.cmi proofs/tacmach.cmi pretyping/tacred.cmi \ - tactics/tacticals.cmi tactics/tactics.cmi kernel/term.cmi \ - pretyping/termops.cmi lib/util.cmi -contrib/omega/coq_omega.cmx: parsing/ast.cmx proofs/clenv.cmx \ - kernel/closure.cmx tactics/contradiction.cmx interp/coqlib.cmx \ - kernel/declarations.cmx kernel/environ.cmx tactics/equality.cmx \ - proofs/evar_refiner.cmx library/global.cmx library/goptions.cmx \ - kernel/inductive.cmx library/libnames.cmx library/library.cmx \ - proofs/logic.cmx library/nameops.cmx kernel/names.cmx library/nametab.cmx \ - contrib/omega/omega.cmx lib/options.cmx lib/pp.cmx parsing/printer.cmx \ - proofs/proof_type.cmx pretyping/rawterm.cmx kernel/reduction.cmx \ - kernel/sign.cmx proofs/tacmach.cmx pretyping/tacred.cmx \ - tactics/tacticals.cmx tactics/tactics.cmx kernel/term.cmx \ - pretyping/termops.cmx lib/util.cmx -contrib/omega/g_omega.cmo: toplevel/cerrors.cmi contrib/omega/coq_omega.cmo \ - parsing/egrammar.cmi lib/options.cmi parsing/pcoq.cmi lib/pp.cmi \ - parsing/pptactic.cmi proofs/refiner.cmi proofs/tacexpr.cmo \ - tactics/tacinterp.cmi lib/util.cmi -contrib/omega/g_omega.cmx: toplevel/cerrors.cmx contrib/omega/coq_omega.cmx \ - parsing/egrammar.cmx lib/options.cmx parsing/pcoq.cmx lib/pp.cmx \ - parsing/pptactic.cmx proofs/refiner.cmx proofs/tacexpr.cmx \ - tactics/tacinterp.cmx lib/util.cmx -contrib/omega/omega.cmo: library/nameops.cmi kernel/names.cmi lib/util.cmi -contrib/omega/omega.cmx: library/nameops.cmx kernel/names.cmx lib/util.cmx -contrib/ring/g_quote.cmo: toplevel/cerrors.cmi parsing/egrammar.cmi \ - interp/genarg.cmi lib/options.cmi parsing/pcoq.cmi lib/pp.cmi \ - parsing/pptactic.cmi contrib/ring/quote.cmo proofs/refiner.cmi \ - proofs/tacexpr.cmo tactics/tacinterp.cmi lib/util.cmi -contrib/ring/g_quote.cmx: toplevel/cerrors.cmx parsing/egrammar.cmx \ - interp/genarg.cmx lib/options.cmx parsing/pcoq.cmx lib/pp.cmx \ - parsing/pptactic.cmx contrib/ring/quote.cmx proofs/refiner.cmx \ - proofs/tacexpr.cmx tactics/tacinterp.cmx lib/util.cmx -contrib/ring/g_ring.cmo: toplevel/cerrors.cmi parsing/egrammar.cmi \ - interp/genarg.cmi lib/options.cmi parsing/pcoq.cmi lib/pp.cmi \ - parsing/pptactic.cmi contrib/ring/quote.cmo proofs/refiner.cmi \ - contrib/ring/ring.cmo proofs/tacexpr.cmo tactics/tacinterp.cmi \ - lib/util.cmi toplevel/vernacinterp.cmi -contrib/ring/g_ring.cmx: toplevel/cerrors.cmx parsing/egrammar.cmx \ - interp/genarg.cmx lib/options.cmx parsing/pcoq.cmx lib/pp.cmx \ - parsing/pptactic.cmx contrib/ring/quote.cmx proofs/refiner.cmx \ - contrib/ring/ring.cmx proofs/tacexpr.cmx tactics/tacinterp.cmx \ - lib/util.cmx toplevel/vernacinterp.cmx -contrib/ring/quote.cmo: interp/coqlib.cmi kernel/environ.cmi \ - library/global.cmi pretyping/instantiate.cmi library/library.cmi \ - pretyping/matching.cmi kernel/names.cmi pretyping/pattern.cmi lib/pp.cmi \ - proofs/proof_trees.cmi proofs/tacexpr.cmo proofs/tacmach.cmi \ - tactics/tactics.cmi kernel/term.cmi pretyping/termops.cmi lib/util.cmi -contrib/ring/quote.cmx: interp/coqlib.cmx kernel/environ.cmx \ - library/global.cmx pretyping/instantiate.cmx library/library.cmx \ - pretyping/matching.cmx kernel/names.cmx pretyping/pattern.cmx lib/pp.cmx \ - proofs/proof_trees.cmx proofs/tacexpr.cmx proofs/tacmach.cmx \ - tactics/tactics.cmx kernel/term.cmx pretyping/termops.cmx lib/util.cmx -contrib/ring/ring.cmo: kernel/closure.cmi interp/constrintern.cmi \ - interp/coqlib.cmi tactics/equality.cmi pretyping/evd.cmi \ - library/global.cmi tactics/hiddentac.cmi tactics/hipattern.cmi \ - library/lib.cmi library/libnames.cmi library/libobject.cmi \ - library/library.cmi library/nameops.cmi kernel/names.cmi \ - library/nametab.cmi lib/options.cmi pretyping/pattern.cmi lib/pp.cmi \ - parsing/printer.cmi proofs/proof_trees.cmi contrib/ring/quote.cmo \ - pretyping/reductionops.cmi tactics/setoid_replace.cmi library/summary.cmi \ - proofs/tacexpr.cmo proofs/tacmach.cmi pretyping/tacred.cmi \ - tactics/tacticals.cmi tactics/tactics.cmi kernel/term.cmi \ - pretyping/typing.cmi lib/util.cmi toplevel/vernacexpr.cmo \ - toplevel/vernacinterp.cmi -contrib/ring/ring.cmx: kernel/closure.cmx interp/constrintern.cmx \ - interp/coqlib.cmx tactics/equality.cmx pretyping/evd.cmx \ - library/global.cmx tactics/hiddentac.cmx tactics/hipattern.cmx \ - library/lib.cmx library/libnames.cmx library/libobject.cmx \ - library/library.cmx library/nameops.cmx kernel/names.cmx \ - library/nametab.cmx lib/options.cmx pretyping/pattern.cmx lib/pp.cmx \ - parsing/printer.cmx proofs/proof_trees.cmx contrib/ring/quote.cmx \ - pretyping/reductionops.cmx tactics/setoid_replace.cmx library/summary.cmx \ - proofs/tacexpr.cmx proofs/tacmach.cmx pretyping/tacred.cmx \ - tactics/tacticals.cmx tactics/tactics.cmx kernel/term.cmx \ - pretyping/typing.cmx lib/util.cmx toplevel/vernacexpr.cmx \ - toplevel/vernacinterp.cmx -contrib/romega/const_omega.cmo: interp/coqlib.cmi library/global.cmi \ - library/libnames.cmi kernel/names.cmi library/nametab.cmi lib/options.cmi \ - kernel/term.cmi lib/util.cmi -contrib/romega/const_omega.cmx: interp/coqlib.cmx library/global.cmx \ - library/libnames.cmx kernel/names.cmx library/nametab.cmx lib/options.cmx \ - kernel/term.cmx lib/util.cmx -contrib/romega/g_romega.cmo: toplevel/cerrors.cmi parsing/egrammar.cmi \ - lib/options.cmi parsing/pcoq.cmi lib/pp.cmi parsing/pptactic.cmi \ - proofs/refiner.cmi contrib/romega/refl_omega.cmo proofs/tacexpr.cmo \ - tactics/tacinterp.cmi lib/util.cmi -contrib/romega/g_romega.cmx: toplevel/cerrors.cmx parsing/egrammar.cmx \ - lib/options.cmx parsing/pcoq.cmx lib/pp.cmx parsing/pptactic.cmx \ - proofs/refiner.cmx contrib/romega/refl_omega.cmx proofs/tacexpr.cmx \ - tactics/tacinterp.cmx lib/util.cmx -contrib/romega/omega2.cmo: kernel/names.cmi lib/util.cmi -contrib/romega/omega2.cmx: kernel/names.cmx lib/util.cmx -contrib/romega/refl_omega.cmo: contrib/romega/const_omega.cmo \ - proofs/logic.cmi kernel/names.cmi contrib/romega/omega2.cmo \ - lib/options.cmi lib/pp.cmi parsing/printer.cmi proofs/tacmach.cmi \ - tactics/tacticals.cmi tactics/tactics.cmi kernel/term.cmi lib/util.cmi -contrib/romega/refl_omega.cmx: contrib/romega/const_omega.cmx \ - proofs/logic.cmx kernel/names.cmx contrib/romega/omega2.cmx \ - lib/options.cmx lib/pp.cmx parsing/printer.cmx proofs/tacmach.cmx \ - tactics/tacticals.cmx tactics/tactics.cmx kernel/term.cmx lib/util.cmx -contrib/xml/acic2Xml.cmo: contrib/xml/acic.cmo contrib/xml/cic2acic.cmo \ - kernel/names.cmi kernel/term.cmi lib/util.cmi contrib/xml/xml.cmi -contrib/xml/acic2Xml.cmx: contrib/xml/acic.cmx contrib/xml/cic2acic.cmx \ - kernel/names.cmx kernel/term.cmx lib/util.cmx contrib/xml/xml.cmx -contrib/xml/acic.cmo: kernel/names.cmi kernel/term.cmi -contrib/xml/acic.cmx: kernel/names.cmx kernel/term.cmx -contrib/xml/cic2acic.cmo: contrib/xml/acic.cmo kernel/declarations.cmi \ - library/declare.cmi library/dischargedhypsmap.cmi \ - contrib/xml/doubleTypeInference.cmi kernel/environ.cmi \ - pretyping/evarutil.cmi pretyping/evd.cmi library/global.cmi \ - kernel/inductive.cmi pretyping/inductiveops.cmi pretyping/instantiate.cmi \ - library/lib.cmi library/libnames.cmi library/library.cmi \ - library/nameops.cmi kernel/names.cmi library/nametab.cmi lib/pp.cmi \ - parsing/printer.cmi pretyping/reductionops.cmi kernel/term.cmi \ - pretyping/termops.cmi kernel/univ.cmi contrib/xml/unshare.cmi \ - lib/util.cmi -contrib/xml/cic2acic.cmx: contrib/xml/acic.cmx kernel/declarations.cmx \ - library/declare.cmx library/dischargedhypsmap.cmx \ - contrib/xml/doubleTypeInference.cmx kernel/environ.cmx \ - pretyping/evarutil.cmx pretyping/evd.cmx library/global.cmx \ - kernel/inductive.cmx pretyping/inductiveops.cmx pretyping/instantiate.cmx \ - library/lib.cmx library/libnames.cmx library/library.cmx \ - library/nameops.cmx kernel/names.cmx library/nametab.cmx lib/pp.cmx \ - parsing/printer.cmx pretyping/reductionops.cmx kernel/term.cmx \ - pretyping/termops.cmx kernel/univ.cmx contrib/xml/unshare.cmx \ - lib/util.cmx -contrib/xml/doubleTypeInference.cmo: contrib/xml/acic.cmo \ - kernel/conv_oracle.cmi kernel/environ.cmi pretyping/evarutil.cmi \ - pretyping/evd.cmi kernel/inductive.cmi pretyping/instantiate.cmi \ - library/libnames.cmi kernel/names.cmi lib/pp.cmi parsing/printer.cmi \ - pretyping/rawterm.cmi kernel/reduction.cmi pretyping/reductionops.cmi \ - pretyping/retyping.cmi pretyping/tacred.cmi kernel/term.cmi \ - pretyping/termops.cmi kernel/typeops.cmi contrib/xml/unshare.cmi \ - lib/util.cmi contrib/xml/doubleTypeInference.cmi -contrib/xml/doubleTypeInference.cmx: contrib/xml/acic.cmx \ - kernel/conv_oracle.cmx kernel/environ.cmx pretyping/evarutil.cmx \ - pretyping/evd.cmx kernel/inductive.cmx pretyping/instantiate.cmx \ - library/libnames.cmx kernel/names.cmx lib/pp.cmx parsing/printer.cmx \ - pretyping/rawterm.cmx kernel/reduction.cmx pretyping/reductionops.cmx \ - pretyping/retyping.cmx pretyping/tacred.cmx kernel/term.cmx \ - pretyping/termops.cmx kernel/typeops.cmx contrib/xml/unshare.cmx \ - lib/util.cmx contrib/xml/doubleTypeInference.cmi -contrib/xml/proof2aproof.cmo: pretyping/evarutil.cmi pretyping/evd.cmi \ - library/global.cmi pretyping/instantiate.cmi proofs/logic.cmi lib/pp.cmi \ - proofs/proof_type.cmi proofs/refiner.cmi kernel/sign.cmi \ - proofs/tacmach.cmi kernel/term.cmi pretyping/termops.cmi \ - contrib/xml/unshare.cmi lib/util.cmi -contrib/xml/proof2aproof.cmx: pretyping/evarutil.cmx pretyping/evd.cmx \ - library/global.cmx pretyping/instantiate.cmx proofs/logic.cmx lib/pp.cmx \ - proofs/proof_type.cmx proofs/refiner.cmx kernel/sign.cmx \ - proofs/tacmach.cmx kernel/term.cmx pretyping/termops.cmx \ - contrib/xml/unshare.cmx lib/util.cmx -contrib/xml/proofTree2Xml.cmo: contrib/xml/acic.cmo contrib/xml/acic2Xml.cmo \ - contrib/xml/cic2acic.cmo kernel/environ.cmi pretyping/evd.cmi \ - library/global.cmi proofs/logic.cmi kernel/names.cmi lib/options.cmi \ - lib/pp.cmi parsing/pptactic.cmi translate/pptacticnew.cmi \ - parsing/printer.cmi contrib/xml/proof2aproof.cmo proofs/proof_trees.cmi \ - proofs/proof_type.cmi kernel/sign.cmi proofs/tacexpr.cmo kernel/term.cmi \ - contrib/xml/unshare.cmi lib/util.cmi contrib/xml/xml.cmi -contrib/xml/proofTree2Xml.cmx: contrib/xml/acic.cmx contrib/xml/acic2Xml.cmx \ - contrib/xml/cic2acic.cmx kernel/environ.cmx pretyping/evd.cmx \ - library/global.cmx proofs/logic.cmx kernel/names.cmx lib/options.cmx \ - lib/pp.cmx parsing/pptactic.cmx translate/pptacticnew.cmx \ - parsing/printer.cmx contrib/xml/proof2aproof.cmx proofs/proof_trees.cmx \ - proofs/proof_type.cmx kernel/sign.cmx proofs/tacexpr.cmx kernel/term.cmx \ - contrib/xml/unshare.cmx lib/util.cmx contrib/xml/xml.cmx +contrib/omega/coq_omega.cmo: lib/util.cmi pretyping/termops.cmi \ + kernel/term.cmi tactics/tactics.cmi tactics/tacticals.cmi \ + pretyping/tacred.cmi proofs/tacmach.cmi kernel/sign.cmi \ + kernel/reduction.cmi pretyping/rawterm.cmi proofs/proof_type.cmi \ + parsing/printer.cmi lib/pp.cmi lib/options.cmi contrib/omega/omega.cmo \ + library/nametab.cmi kernel/names.cmi library/nameops.cmi proofs/logic.cmi \ + library/library.cmi library/libnames.cmi kernel/inductive.cmi \ + library/goptions.cmi library/global.cmi proofs/evar_refiner.cmi \ + tactics/equality.cmi kernel/environ.cmi kernel/declarations.cmi \ + interp/coqlib.cmi tactics/contradiction.cmi kernel/closure.cmi \ + proofs/clenv.cmi parsing/ast.cmi +contrib/omega/coq_omega.cmx: lib/util.cmx pretyping/termops.cmx \ + kernel/term.cmx tactics/tactics.cmx tactics/tacticals.cmx \ + pretyping/tacred.cmx proofs/tacmach.cmx kernel/sign.cmx \ + kernel/reduction.cmx pretyping/rawterm.cmx proofs/proof_type.cmx \ + parsing/printer.cmx lib/pp.cmx lib/options.cmx contrib/omega/omega.cmx \ + library/nametab.cmx kernel/names.cmx library/nameops.cmx proofs/logic.cmx \ + library/library.cmx library/libnames.cmx kernel/inductive.cmx \ + library/goptions.cmx library/global.cmx proofs/evar_refiner.cmx \ + tactics/equality.cmx kernel/environ.cmx kernel/declarations.cmx \ + interp/coqlib.cmx tactics/contradiction.cmx kernel/closure.cmx \ + proofs/clenv.cmx parsing/ast.cmx +contrib/omega/g_omega.cmo: lib/util.cmi tactics/tacinterp.cmi \ + proofs/tacexpr.cmo proofs/refiner.cmi parsing/pptactic.cmi lib/pp.cmi \ + parsing/pcoq.cmi lib/options.cmi parsing/egrammar.cmi \ + contrib/omega/coq_omega.cmo toplevel/cerrors.cmi +contrib/omega/g_omega.cmx: lib/util.cmx tactics/tacinterp.cmx \ + proofs/tacexpr.cmx proofs/refiner.cmx parsing/pptactic.cmx lib/pp.cmx \ + parsing/pcoq.cmx lib/options.cmx parsing/egrammar.cmx \ + contrib/omega/coq_omega.cmx toplevel/cerrors.cmx +contrib/omega/omega.cmo: lib/util.cmi kernel/names.cmi library/nameops.cmi +contrib/omega/omega.cmx: lib/util.cmx kernel/names.cmx library/nameops.cmx +contrib/ring/g_quote.cmo: lib/util.cmi tactics/tacinterp.cmi \ + proofs/tacexpr.cmo proofs/refiner.cmi contrib/ring/quote.cmo \ + parsing/pptactic.cmi lib/pp.cmi parsing/pcoq.cmi lib/options.cmi \ + interp/genarg.cmi parsing/egrammar.cmi toplevel/cerrors.cmi +contrib/ring/g_quote.cmx: lib/util.cmx tactics/tacinterp.cmx \ + proofs/tacexpr.cmx proofs/refiner.cmx contrib/ring/quote.cmx \ + parsing/pptactic.cmx lib/pp.cmx parsing/pcoq.cmx lib/options.cmx \ + interp/genarg.cmx parsing/egrammar.cmx toplevel/cerrors.cmx +contrib/ring/g_ring.cmo: toplevel/vernacinterp.cmi lib/util.cmi \ + tactics/tacinterp.cmi proofs/tacexpr.cmo contrib/ring/ring.cmo \ + proofs/refiner.cmi contrib/ring/quote.cmo parsing/pptactic.cmi lib/pp.cmi \ + parsing/pcoq.cmi lib/options.cmi interp/genarg.cmi parsing/egrammar.cmi \ + toplevel/cerrors.cmi +contrib/ring/g_ring.cmx: toplevel/vernacinterp.cmx lib/util.cmx \ + tactics/tacinterp.cmx proofs/tacexpr.cmx contrib/ring/ring.cmx \ + proofs/refiner.cmx contrib/ring/quote.cmx parsing/pptactic.cmx lib/pp.cmx \ + parsing/pcoq.cmx lib/options.cmx interp/genarg.cmx parsing/egrammar.cmx \ + toplevel/cerrors.cmx +contrib/ring/quote.cmo: lib/util.cmi pretyping/termops.cmi kernel/term.cmi \ + tactics/tactics.cmi proofs/tacmach.cmi proofs/tacexpr.cmo \ + proofs/proof_trees.cmi lib/pp.cmi pretyping/pattern.cmi kernel/names.cmi \ + pretyping/matching.cmi library/library.cmi pretyping/instantiate.cmi \ + library/global.cmi kernel/environ.cmi interp/coqlib.cmi +contrib/ring/quote.cmx: lib/util.cmx pretyping/termops.cmx kernel/term.cmx \ + tactics/tactics.cmx proofs/tacmach.cmx proofs/tacexpr.cmx \ + proofs/proof_trees.cmx lib/pp.cmx pretyping/pattern.cmx kernel/names.cmx \ + pretyping/matching.cmx library/library.cmx pretyping/instantiate.cmx \ + library/global.cmx kernel/environ.cmx interp/coqlib.cmx +contrib/ring/ring.cmo: toplevel/vernacinterp.cmi toplevel/vernacexpr.cmo \ + lib/util.cmi pretyping/typing.cmi kernel/term.cmi tactics/tactics.cmi \ + tactics/tacticals.cmi pretyping/tacred.cmi proofs/tacmach.cmi \ + proofs/tacexpr.cmo library/summary.cmi tactics/setoid_replace.cmi \ + pretyping/reductionops.cmi contrib/ring/quote.cmo proofs/proof_trees.cmi \ + parsing/printer.cmi lib/pp.cmi pretyping/pattern.cmi lib/options.cmi \ + library/nametab.cmi kernel/names.cmi library/nameops.cmi \ + library/library.cmi library/libobject.cmi library/libnames.cmi \ + library/lib.cmi tactics/hipattern.cmi tactics/hiddentac.cmi \ + library/global.cmi pretyping/evd.cmi tactics/equality.cmi \ + interp/coqlib.cmi interp/constrintern.cmi kernel/closure.cmi +contrib/ring/ring.cmx: toplevel/vernacinterp.cmx toplevel/vernacexpr.cmx \ + lib/util.cmx pretyping/typing.cmx kernel/term.cmx tactics/tactics.cmx \ + tactics/tacticals.cmx pretyping/tacred.cmx proofs/tacmach.cmx \ + proofs/tacexpr.cmx library/summary.cmx tactics/setoid_replace.cmx \ + pretyping/reductionops.cmx contrib/ring/quote.cmx proofs/proof_trees.cmx \ + parsing/printer.cmx lib/pp.cmx pretyping/pattern.cmx lib/options.cmx \ + library/nametab.cmx kernel/names.cmx library/nameops.cmx \ + library/library.cmx library/libobject.cmx library/libnames.cmx \ + library/lib.cmx tactics/hipattern.cmx tactics/hiddentac.cmx \ + library/global.cmx pretyping/evd.cmx tactics/equality.cmx \ + interp/coqlib.cmx interp/constrintern.cmx kernel/closure.cmx +contrib/romega/const_omega.cmo: lib/util.cmi kernel/term.cmi lib/options.cmi \ + library/nametab.cmi kernel/names.cmi library/libnames.cmi \ + library/global.cmi interp/coqlib.cmi +contrib/romega/const_omega.cmx: lib/util.cmx kernel/term.cmx lib/options.cmx \ + library/nametab.cmx kernel/names.cmx library/libnames.cmx \ + library/global.cmx interp/coqlib.cmx +contrib/romega/g_romega.cmo: lib/util.cmi tactics/tacinterp.cmi \ + proofs/tacexpr.cmo contrib/romega/refl_omega.cmo proofs/refiner.cmi \ + parsing/pptactic.cmi lib/pp.cmi parsing/pcoq.cmi lib/options.cmi \ + parsing/egrammar.cmi toplevel/cerrors.cmi +contrib/romega/g_romega.cmx: lib/util.cmx tactics/tacinterp.cmx \ + proofs/tacexpr.cmx contrib/romega/refl_omega.cmx proofs/refiner.cmx \ + parsing/pptactic.cmx lib/pp.cmx parsing/pcoq.cmx lib/options.cmx \ + parsing/egrammar.cmx toplevel/cerrors.cmx +contrib/romega/omega2.cmo: lib/util.cmi kernel/names.cmi +contrib/romega/omega2.cmx: lib/util.cmx kernel/names.cmx +contrib/romega/refl_omega.cmo: lib/util.cmi kernel/term.cmi \ + tactics/tactics.cmi tactics/tacticals.cmi proofs/tacmach.cmi \ + parsing/printer.cmi lib/pp.cmi lib/options.cmi contrib/romega/omega2.cmo \ + kernel/names.cmi proofs/logic.cmi contrib/romega/const_omega.cmo +contrib/romega/refl_omega.cmx: lib/util.cmx kernel/term.cmx \ + tactics/tactics.cmx tactics/tacticals.cmx proofs/tacmach.cmx \ + parsing/printer.cmx lib/pp.cmx lib/options.cmx contrib/romega/omega2.cmx \ + kernel/names.cmx proofs/logic.cmx contrib/romega/const_omega.cmx +contrib/xml/acic.cmo: kernel/term.cmi kernel/names.cmi +contrib/xml/acic.cmx: kernel/term.cmx kernel/names.cmx +contrib/xml/acic2Xml.cmo: contrib/xml/xml.cmi lib/util.cmi kernel/term.cmi \ + kernel/names.cmi contrib/xml/cic2acic.cmo contrib/xml/acic.cmo +contrib/xml/acic2Xml.cmx: contrib/xml/xml.cmx lib/util.cmx kernel/term.cmx \ + kernel/names.cmx contrib/xml/cic2acic.cmx contrib/xml/acic.cmx +contrib/xml/cic2acic.cmo: lib/util.cmi contrib/xml/unshare.cmi \ + kernel/univ.cmi pretyping/termops.cmi kernel/term.cmi \ + pretyping/reductionops.cmi parsing/printer.cmi lib/pp.cmi \ + library/nametab.cmi kernel/names.cmi library/nameops.cmi \ + library/library.cmi library/libnames.cmi library/lib.cmi \ + pretyping/instantiate.cmi pretyping/inductiveops.cmi kernel/inductive.cmi \ + library/global.cmi pretyping/evd.cmi pretyping/evarutil.cmi \ + kernel/environ.cmi contrib/xml/doubleTypeInference.cmi \ + library/dischargedhypsmap.cmi library/declare.cmi kernel/declarations.cmi \ + contrib/xml/acic.cmo +contrib/xml/cic2acic.cmx: lib/util.cmx contrib/xml/unshare.cmx \ + kernel/univ.cmx pretyping/termops.cmx kernel/term.cmx \ + pretyping/reductionops.cmx parsing/printer.cmx lib/pp.cmx \ + library/nametab.cmx kernel/names.cmx library/nameops.cmx \ + library/library.cmx library/libnames.cmx library/lib.cmx \ + pretyping/instantiate.cmx pretyping/inductiveops.cmx kernel/inductive.cmx \ + library/global.cmx pretyping/evd.cmx pretyping/evarutil.cmx \ + kernel/environ.cmx contrib/xml/doubleTypeInference.cmx \ + library/dischargedhypsmap.cmx library/declare.cmx kernel/declarations.cmx \ + contrib/xml/acic.cmx +contrib/xml/doubleTypeInference.cmo: lib/util.cmi contrib/xml/unshare.cmi \ + kernel/typeops.cmi pretyping/termops.cmi kernel/term.cmi \ + pretyping/tacred.cmi pretyping/retyping.cmi pretyping/reductionops.cmi \ + kernel/reduction.cmi pretyping/rawterm.cmi parsing/printer.cmi lib/pp.cmi \ + kernel/names.cmi library/libnames.cmi pretyping/instantiate.cmi \ + kernel/inductive.cmi pretyping/evd.cmi pretyping/evarutil.cmi \ + kernel/environ.cmi kernel/conv_oracle.cmi contrib/xml/acic.cmo \ + contrib/xml/doubleTypeInference.cmi +contrib/xml/doubleTypeInference.cmx: lib/util.cmx contrib/xml/unshare.cmx \ + kernel/typeops.cmx pretyping/termops.cmx kernel/term.cmx \ + pretyping/tacred.cmx pretyping/retyping.cmx pretyping/reductionops.cmx \ + kernel/reduction.cmx pretyping/rawterm.cmx parsing/printer.cmx lib/pp.cmx \ + kernel/names.cmx library/libnames.cmx pretyping/instantiate.cmx \ + kernel/inductive.cmx pretyping/evd.cmx pretyping/evarutil.cmx \ + kernel/environ.cmx kernel/conv_oracle.cmx contrib/xml/acic.cmx \ + contrib/xml/doubleTypeInference.cmi +contrib/xml/proof2aproof.cmo: lib/util.cmi contrib/xml/unshare.cmi \ + pretyping/termops.cmi kernel/term.cmi proofs/tacmach.cmi kernel/sign.cmi \ + proofs/refiner.cmi proofs/proof_type.cmi lib/pp.cmi proofs/logic.cmi \ + pretyping/instantiate.cmi library/global.cmi pretyping/evd.cmi \ + pretyping/evarutil.cmi +contrib/xml/proof2aproof.cmx: lib/util.cmx contrib/xml/unshare.cmx \ + pretyping/termops.cmx kernel/term.cmx proofs/tacmach.cmx kernel/sign.cmx \ + proofs/refiner.cmx proofs/proof_type.cmx lib/pp.cmx proofs/logic.cmx \ + pretyping/instantiate.cmx library/global.cmx pretyping/evd.cmx \ + pretyping/evarutil.cmx +contrib/xml/proofTree2Xml.cmo: contrib/xml/xml.cmi lib/util.cmi \ + contrib/xml/unshare.cmi kernel/term.cmi proofs/tacexpr.cmo \ + kernel/sign.cmi proofs/proof_type.cmi proofs/proof_trees.cmi \ + contrib/xml/proof2aproof.cmo parsing/printer.cmi \ + translate/pptacticnew.cmi parsing/pptactic.cmi lib/pp.cmi lib/options.cmi \ + kernel/names.cmi proofs/logic.cmi library/global.cmi pretyping/evd.cmi \ + kernel/environ.cmi contrib/xml/cic2acic.cmo contrib/xml/acic2Xml.cmo \ + contrib/xml/acic.cmo +contrib/xml/proofTree2Xml.cmx: contrib/xml/xml.cmx lib/util.cmx \ + contrib/xml/unshare.cmx kernel/term.cmx proofs/tacexpr.cmx \ + kernel/sign.cmx proofs/proof_type.cmx proofs/proof_trees.cmx \ + contrib/xml/proof2aproof.cmx parsing/printer.cmx \ + translate/pptacticnew.cmx parsing/pptactic.cmx lib/pp.cmx lib/options.cmx \ + kernel/names.cmx proofs/logic.cmx library/global.cmx pretyping/evd.cmx \ + kernel/environ.cmx contrib/xml/cic2acic.cmx contrib/xml/acic2Xml.cmx \ + contrib/xml/acic.cmx contrib/xml/unshare.cmo: contrib/xml/unshare.cmi contrib/xml/unshare.cmx: contrib/xml/unshare.cmi -contrib/xml/xmlcommand.cmo: contrib/xml/acic.cmo contrib/xml/acic2Xml.cmo \ - contrib/xml/cic2acic.cmo config/coq_config.cmi library/decl_kinds.cmo \ - kernel/declarations.cmi library/declare.cmi kernel/environ.cmi \ - pretyping/evd.cmi library/global.cmi kernel/inductive.cmi \ - parsing/lexer.cmi library/lib.cmi library/libnames.cmi \ - library/libobject.cmi library/library.cmi kernel/names.cmi \ - library/nametab.cmi proofs/pfedit.cmi contrib/xml/proof2aproof.cmo \ - proofs/proof_trees.cmi pretyping/recordops.cmi kernel/sign.cmi \ - proofs/tacmach.cmi kernel/term.cmi contrib/xml/unshare.cmi lib/util.cmi \ - toplevel/vernac.cmi contrib/xml/xml.cmi contrib/xml/xmlcommand.cmi -contrib/xml/xmlcommand.cmx: contrib/xml/acic.cmx contrib/xml/acic2Xml.cmx \ - contrib/xml/cic2acic.cmx config/coq_config.cmx library/decl_kinds.cmx \ - kernel/declarations.cmx library/declare.cmx kernel/environ.cmx \ - pretyping/evd.cmx library/global.cmx kernel/inductive.cmx \ - parsing/lexer.cmx library/lib.cmx library/libnames.cmx \ - library/libobject.cmx library/library.cmx kernel/names.cmx \ - library/nametab.cmx proofs/pfedit.cmx contrib/xml/proof2aproof.cmx \ - proofs/proof_trees.cmx pretyping/recordops.cmx kernel/sign.cmx \ - proofs/tacmach.cmx kernel/term.cmx contrib/xml/unshare.cmx lib/util.cmx \ - toplevel/vernac.cmx contrib/xml/xml.cmx contrib/xml/xmlcommand.cmi -contrib/xml/xmlentries.cmo: toplevel/cerrors.cmi parsing/egrammar.cmi \ - parsing/extend.cmi interp/genarg.cmi parsing/pcoq.cmi lib/pp.cmi \ - lib/util.cmi toplevel/vernacinterp.cmi contrib/xml/xmlcommand.cmi -contrib/xml/xmlentries.cmx: toplevel/cerrors.cmx parsing/egrammar.cmx \ - parsing/extend.cmx interp/genarg.cmx parsing/pcoq.cmx lib/pp.cmx \ - lib/util.cmx toplevel/vernacinterp.cmx contrib/xml/xmlcommand.cmx contrib/xml/xml.cmo: contrib/xml/xml.cmi contrib/xml/xml.cmx: contrib/xml/xml.cmi -ide/utils/configwin_html_config.cmo: ide/utils/configwin_ihm.cmo \ - ide/utils/configwin_messages.cmo ide/utils/configwin_types.cmo \ - ide/utils/uoptions.cmi -ide/utils/configwin_html_config.cmx: ide/utils/configwin_ihm.cmx \ - ide/utils/configwin_messages.cmx ide/utils/configwin_types.cmx \ - ide/utils/uoptions.cmx -ide/utils/configwin_ihm.cmo: ide/utils/configwin_messages.cmo \ - ide/utils/configwin_types.cmo ide/utils/okey.cmi ide/utils/uoptions.cmi -ide/utils/configwin_ihm.cmx: ide/utils/configwin_messages.cmx \ - ide/utils/configwin_types.cmx ide/utils/okey.cmx ide/utils/uoptions.cmx -ide/utils/configwin.cmo: ide/utils/configwin_ihm.cmo \ - ide/utils/configwin_types.cmo ide/utils/configwin.cmi -ide/utils/configwin.cmx: ide/utils/configwin_ihm.cmx \ - ide/utils/configwin_types.cmx ide/utils/configwin.cmi -ide/utils/configwin_types.cmo: ide/utils/configwin_keys.cmo \ - ide/utils/uoptions.cmi -ide/utils/configwin_types.cmx: ide/utils/configwin_keys.cmx \ - ide/utils/uoptions.cmx +contrib/xml/xmlcommand.cmo: contrib/xml/xml.cmi toplevel/vernac.cmi \ + lib/util.cmi contrib/xml/unshare.cmi kernel/term.cmi proofs/tacmach.cmi \ + kernel/sign.cmi pretyping/recordops.cmi proofs/proof_trees.cmi \ + contrib/xml/proof2aproof.cmo proofs/pfedit.cmi library/nametab.cmi \ + kernel/names.cmi library/library.cmi library/libobject.cmi \ + library/libnames.cmi library/lib.cmi parsing/lexer.cmi \ + kernel/inductive.cmi library/global.cmi pretyping/evd.cmi \ + kernel/environ.cmi library/declare.cmi kernel/declarations.cmi \ + library/decl_kinds.cmo config/coq_config.cmi contrib/xml/cic2acic.cmo \ + contrib/xml/acic2Xml.cmo contrib/xml/acic.cmo contrib/xml/xmlcommand.cmi +contrib/xml/xmlcommand.cmx: contrib/xml/xml.cmx toplevel/vernac.cmx \ + lib/util.cmx contrib/xml/unshare.cmx kernel/term.cmx proofs/tacmach.cmx \ + kernel/sign.cmx pretyping/recordops.cmx proofs/proof_trees.cmx \ + contrib/xml/proof2aproof.cmx proofs/pfedit.cmx library/nametab.cmx \ + kernel/names.cmx library/library.cmx library/libobject.cmx \ + library/libnames.cmx library/lib.cmx parsing/lexer.cmx \ + kernel/inductive.cmx library/global.cmx pretyping/evd.cmx \ + kernel/environ.cmx library/declare.cmx kernel/declarations.cmx \ + library/decl_kinds.cmx config/coq_config.cmx contrib/xml/cic2acic.cmx \ + contrib/xml/acic2Xml.cmx contrib/xml/acic.cmx contrib/xml/xmlcommand.cmi +contrib/xml/xmlentries.cmo: contrib/xml/xmlcommand.cmi \ + toplevel/vernacinterp.cmi lib/util.cmi lib/pp.cmi parsing/pcoq.cmi \ + interp/genarg.cmi parsing/extend.cmi parsing/egrammar.cmi \ + toplevel/cerrors.cmi +contrib/xml/xmlentries.cmx: contrib/xml/xmlcommand.cmx \ + toplevel/vernacinterp.cmx lib/util.cmx lib/pp.cmx parsing/pcoq.cmx \ + interp/genarg.cmx parsing/extend.cmx parsing/egrammar.cmx \ + toplevel/cerrors.cmx +ide/utils/configwin.cmo: ide/utils/configwin_types.cmo \ + ide/utils/configwin_ihm.cmo ide/utils/configwin.cmi +ide/utils/configwin.cmx: ide/utils/configwin_types.cmx \ + ide/utils/configwin_ihm.cmx ide/utils/configwin.cmi +ide/utils/configwin_html_config.cmo: ide/utils/uoptions.cmi \ + ide/utils/configwin_types.cmo ide/utils/configwin_messages.cmo \ + ide/utils/configwin_ihm.cmo +ide/utils/configwin_html_config.cmx: ide/utils/uoptions.cmx \ + ide/utils/configwin_types.cmx ide/utils/configwin_messages.cmx \ + ide/utils/configwin_ihm.cmx +ide/utils/configwin_ihm.cmo: ide/utils/uoptions.cmi ide/utils/okey.cmi \ + ide/utils/configwin_types.cmo ide/utils/configwin_messages.cmo +ide/utils/configwin_ihm.cmx: ide/utils/uoptions.cmx ide/utils/okey.cmx \ + ide/utils/configwin_types.cmx ide/utils/configwin_messages.cmx +ide/utils/configwin_types.cmo: ide/utils/uoptions.cmi \ + ide/utils/configwin_keys.cmo +ide/utils/configwin_types.cmx: ide/utils/uoptions.cmx \ + ide/utils/configwin_keys.cmx ide/utils/okey.cmo: ide/utils/okey.cmi ide/utils/okey.cmx: ide/utils/okey.cmi ide/utils/uoptions.cmo: ide/utils/uoptions.cmi @@ -3273,15 +3272,15 @@ tools/coqdoc/alpha.cmo: tools/coqdoc/alpha.cmi tools/coqdoc/alpha.cmx: tools/coqdoc/alpha.cmi tools/coqdoc/index.cmo: tools/coqdoc/alpha.cmi tools/coqdoc/index.cmi tools/coqdoc/index.cmx: tools/coqdoc/alpha.cmx tools/coqdoc/index.cmi -tools/coqdoc/main.cmo: config/coq_config.cmi tools/coqdoc/index.cmi \ - tools/coqdoc/output.cmi tools/coqdoc/pretty.cmi -tools/coqdoc/main.cmx: config/coq_config.cmx tools/coqdoc/index.cmx \ - tools/coqdoc/output.cmx tools/coqdoc/pretty.cmx +tools/coqdoc/main.cmo: tools/coqdoc/pretty.cmi tools/coqdoc/output.cmi \ + tools/coqdoc/index.cmi config/coq_config.cmi +tools/coqdoc/main.cmx: tools/coqdoc/pretty.cmx tools/coqdoc/output.cmx \ + tools/coqdoc/index.cmx config/coq_config.cmx tools/coqdoc/output.cmo: tools/coqdoc/index.cmi tools/coqdoc/output.cmi tools/coqdoc/output.cmx: tools/coqdoc/index.cmx tools/coqdoc/output.cmi -tools/coqdoc/pretty.cmo: tools/coqdoc/index.cmi tools/coqdoc/output.cmi \ +tools/coqdoc/pretty.cmo: tools/coqdoc/output.cmi tools/coqdoc/index.cmi \ tools/coqdoc/pretty.cmi -tools/coqdoc/pretty.cmx: tools/coqdoc/index.cmx tools/coqdoc/output.cmx \ +tools/coqdoc/pretty.cmx: tools/coqdoc/output.cmx tools/coqdoc/index.cmx \ tools/coqdoc/pretty.cmi tactics/tauto.cmo: parsing/grammar.cma tactics/tauto.cmx: parsing/grammar.cma diff --git a/.depend.coq b/.depend.coq index 95233f2e..1b20c607 100644 --- a/.depend.coq +++ b/.depend.coq @@ -118,7 +118,7 @@ theories/NArith/BinNat.vo: theories/NArith/BinNat.v theories/NArith/BinPos.vo theories/NArith/NArith.vo: theories/NArith/NArith.v theories/NArith/BinPos.vo theories/NArith/BinNat.vo theories/ZArith/BinInt.vo: theories/ZArith/BinInt.v theories/NArith/BinPos.vo theories/NArith/Pnat.vo theories/NArith/BinNat.vo theories/Arith/Plus.vo theories/Arith/Mult.vo theories/ZArith/Wf_Z.vo: theories/ZArith/Wf_Z.v theories/ZArith/BinInt.vo theories/ZArith/Zcompare.vo theories/ZArith/Zorder.vo theories/ZArith/Znat.vo theories/ZArith/Zmisc.vo theories/Arith/Wf_nat.vo -theories/ZArith/ZArith.vo: theories/ZArith/ZArith.v theories/ZArith/ZArith_base.vo theories/ZArith/Zcomplements.vo theories/ZArith/Zsqrt.vo theories/ZArith/Zpower.vo theories/ZArith/Zdiv.vo theories/ZArith/Zlogarithm.vo theories/ZArith/Zbool.vo +theories/ZArith/ZArith.vo: theories/ZArith/ZArith.v theories/ZArith/ZArith_base.vo theories/ZArith/Zcomplements.vo theories/ZArith/Zsqrt.vo theories/ZArith/Zpower.vo theories/ZArith/Zdiv.vo theories/ZArith/Zlogarithm.vo theories/ZArith/ZArith_dec.vo: theories/ZArith/ZArith_dec.v theories/Bool/Sumbool.vo theories/ZArith/BinInt.vo theories/ZArith/Zorder.vo theories/ZArith/Zcompare.vo theories/ZArith/auxiliary.vo: theories/ZArith/auxiliary.v theories/Arith/Arith.vo theories/ZArith/BinInt.vo theories/ZArith/Zorder.vo theories/Logic/Decidable.vo theories/Arith/Peano_dec.vo theories/Arith/Compare_dec.vo theories/ZArith/Zmisc.vo: theories/ZArith/Zmisc.v theories/ZArith/BinInt.vo theories/ZArith/Zcompare.vo theories/ZArith/Zorder.vo theories/Bool/Bool.vo diff --git a/CHANGES b/CHANGES index 2daeded1..7b0a41d0 100644 --- a/CHANGES +++ b/CHANGES @@ -1,3 +1,20 @@ +Changes from V8.0pl1 to V8.0pl2 +=============================== + +Notations + +- Option "format" now aware of recursive notations + +Bug fixes + +- Tactic "fail n" for n<>0 now works (notice that each "match term with" + block decreases the failure level, in accordance with the intuition but + not in conformity with the reference manual) +- Option -dump-glob now strips module segment as expected by coqdoc (which + is still not aware of modules) +- See coq-bugs web page for a full list of fixed bugs (look for + fixes committed before Jan 2005 to cvs version V8-0-bugfix) + Changes from V8.0 to V8.0pl1 ============================ diff --git a/Makefile b/Makefile index af8a8c07..d04bc6ca 100644 --- a/Makefile +++ b/Makefile @@ -6,7 +6,7 @@ # # GNU Lesser General Public License Version 2.1 # ######################################################################## -# $Id: Makefile,v 1.459.2.10 2004/07/19 09:37:31 herbelin Exp $ +# $Id: Makefile,v 1.459.2.13 2005/01/21 17:15:12 herbelin Exp $ # Makefile for Coq @@ -135,8 +135,8 @@ PRETYPING=\ pretyping/reductionops.cmo pretyping/inductiveops.cmo \ pretyping/rawterm.cmo pretyping/pattern.cmo \ pretyping/detyping.cmo pretyping/retyping.cmo \ - pretyping/cbv.cmo pretyping/tacred.cmo \ - pretyping/pretype_errors.cmo pretyping/typing.cmo \ + pretyping/cbv.cmo pretyping/pretype_errors.cmo pretyping/typing.cmo \ + pretyping/tacred.cmo \ pretyping/classops.cmo pretyping/recordops.cmo pretyping/indrec.cmo \ pretyping/evarutil.cmo pretyping/evarconv.cmo \ pretyping/coercion.cmo pretyping/cases.cmo pretyping/pretyping.cmo \ @@ -1235,21 +1235,14 @@ install-latex: doc: doc/coq.tex $(MAKE) -C doc coq.ps minicoq.dvi -LPLIB = lib/doc.tex $(LIBREP:.cmo=.mli) -LPKERNEL = kernel/doc.tex $(KERNEL:.cmo=.mli) -LPLIBRARY = library/doc.tex $(LIBRARY:.cmo=.mli) -LPPRETYPING = pretyping/doc.tex pretyping/rawterm.mli $(PRETYPING:.cmo=.mli) -LPINTERP = $(INTERP:.cmo=.mli) -LPPARSING = $(PARSING:.cmo=.mli) $(HIGHPARSING:.cmo=.mli) -LPPROOFS = proofs/doc.tex $(PROOFS:.cmo=.mli) -LPTACTICS = tactics/doc.tex $(TACTICS:.cmo=.mli) $(HIGHTACTICS:.cmo=.mli) -LPTOPLEVEL = toplevel/doc.tex $(TOPLEVEL:.cmo=.mli) -LPFILES = doc/macros.tex doc/intro.tex $(LPLIB) $(LPKERNEL) $(LPLIBRARY) \ - $(LPPRETYPING) $(LPPROOFS) $(LPTACTICS) $(LPTOPLEVEL) - -doc/coq.tex: $(LPFILES) - ocamlweb -p "\usepackage{epsfig}" $(LPFILES) -o doc/coq.tex -# ocamlweb $(LPFILES) -o doc/coq.tex +doc/coq.tex: + ocamlweb -p "\usepackage{epsfig}" \ + doc/macros.tex doc/intro.tex \ + lib/{doc.tex,*.mli} kernel/{doc.tex,*.mli} library/{doc.tex,*.mli} \ + pretyping/{doc.tex,*.mli} interp/{doc.tex,*.mli} \ + parsing/{doc.tex,*.mli} proofs/{doc.tex,tacexpr.ml,*.mli} \ + tactics/{doc.tex,*.mli} toplevel/{doc.tex,vernacexpr.ml,*.mli} \ + -o doc/coq.tex clean:: rm -f doc/coq.tex @@ -1398,11 +1391,11 @@ proofs/tacexpr.cmx: proofs/tacexpr.ml lib/compat.cmo: lib/compat.ml4 $(SHOW)'OCAMLC4 $<' - $(HIDE)$(OCAMLC) $(BYTEFLAGS) -pp "$(CAMLP4O) $(CAMLP4EXTENDFLAGS) -D$(CAMLVERSION) -impl" -c -impl $< + $(HIDE)$(OCAMLC) $(BYTEFLAGS) -pp "$(CAMLP4O) $(CAMLP4EXTENDFLAGS) -impl" -c -impl $< lib/compat.cmx: lib/compat.ml4 $(SHOW)'OCAMLOPT $<' - $(HIDE)$(OCAMLOPT) $(OPTFLAGS) -pp "$(CAMLP4O) $(CAMLP4EXTENDFLAGS) -D$(CAMLVERSION) -impl" -c -impl $< + $(HIDE)$(OCAMLOPT) $(OPTFLAGS) -pp "$(CAMLP4O) $(CAMLP4EXTENDFLAGS) -impl" -c -impl $< # files compiled with camlp4 because of streams syntax diff --git a/configure b/configure index 923eee76..0891b262 100755 --- a/configure +++ b/configure @@ -6,8 +6,8 @@ # ################################## -VERSION=8.0pl1 -DATE="Jul 2004" +VERSION=8.0pl2 +DATE="Jan 2005" # a local which command for sh which () { @@ -539,4 +539,4 @@ echo echo "*Warning* To compile the system for a new architecture" echo " don't forget to do a 'make archclean' before './configure'." -# $Id: configure,v 1.74.2.5 2004/07/17 17:06:51 herbelin Exp $ +# $Id: configure,v 1.74.2.7 2005/01/21 17:27:32 herbelin Exp $ diff --git a/contrib/funind/tacinv.ml4 b/contrib/funind/tacinv.ml4 index d2ae12d6..b358ff39 100644 --- a/contrib/funind/tacinv.ml4 +++ b/contrib/funind/tacinv.ml4 @@ -68,6 +68,7 @@ let id_of_name = function let string_of_name nme = string_of_id (id_of_name nme) (*end debugging *) +(* Interpretation of constr's *) let constr_of c = Constrintern.interp_constr Evd.empty (Global.env()) c let rec collect_cases l = @@ -163,6 +164,8 @@ let rec npatternify ltypes c = (* let _ = prconstr res in *) res +(* fait une application (c m1 m2...mn, où mi est une evar, on rend également + la liste des evar munies de leur type) *) let rec apply_levars c lmetav = match lmetav with | [] -> [],c @@ -373,7 +376,8 @@ let rec proofPrinc mi lst_vars lst_eqs lst_recs: let anme = Array.of_list lnme' in let aappel_rec = Array.of_list lappel_rec in (* llevar are put outside the fix, so one level of rel must be removed *) - mkFix((iarr,i),(anme, pisarr,aappel_rec)),(pop1_levar llevar),llposeq,evararr,pisarr,[] + mkFix((iarr,i),(anme, pisarr,aappel_rec)) + , (pop1_levar llevar) , llposeq,evararr,pisarr,[] (* Cases b of arrPt end.*) | Case(cinfo, pcase, b, arrPt) -> @@ -495,7 +499,7 @@ let rec proofPrinc mi lst_vars lst_eqs lst_recs: let metav = mknewmeta() in let substmeta t = popn 1 (substitterm 0 (mkRel 1) metav t) in let newrec_call = substmeta rec_call in - let newlevar = List.map (fun ev,tev -> ev, substmeta tev) levar in + let newlevar = List.map (fun (ev,tev) -> ev, substmeta tev) levar in let newabsc = Array.map substmeta absc in newrec_call,newlevar,lposeq,evararr,newabsc,((metav,nme, typ)::parms) @@ -510,7 +514,8 @@ let rec proofPrinc mi lst_vars lst_eqs lst_recs: let nb_eqs = (List.length lst_eqs) in let eqrels = List.map fst lst_eqs in (* [terms_recs]: appel rec du fixpoint, On concatène les appels recs - trouvés dans les let in et les Cases. *) + trouvés dans les let in et les Cases avec ceux trouves dans u (ie + mi.mimick). *) (* TODO: il faudra gérer plusieurs pt fixes imbriqués ? *) let terms_recs = lst_recs @ (hdMatchSub_cpl mi.mimick mi.fonc) in @@ -539,9 +544,6 @@ let rec proofPrinc mi lst_vars lst_eqs lst_recs: let mkevarmap_aux ex = let x,y = ex in (mkevarmap_from_listex x),y -(* Interpretation of constr's *) -let constr_of_Constr c = Constrintern.interp_constr Evd.empty (Global.env()) c - (* TODO: deal with any term, not only a constant. *) let interp_fonc_tacarg fonctac gl = @@ -619,7 +621,7 @@ let invfun_basic open_princ_proof_applied listargs_ids gl dorew lposeq = (tclTHEN (* Refine on the right term (following the sheme of the given function) *) - (fun gl -> refine open_princ_proof_applied gl) + (fun gl -> refine open_princ_proof_applied gl) (* Clear the hypothesis given as arguments of the tactic (because they are generalized) *) (tclTHEN simpl_in_concl (tclTRY (clear listargs_ids)))) @@ -689,20 +691,17 @@ let invfun c l dorew gl = let _ = resetmeta() in let princ_proof,levar, lposeq,evararr,_,parms = invfun_proof [|fonc|] def_fonc [||] pis (pf_env gl) (project gl) in - (* Generalize the goal. [[x1:T1][x2:T2]... g[arg1 <- x1 ...]]. *) let gl_abstr' = add_lambdas (pf_concl gl) gl listargs' in (* apply parameters immediately *) - let gl_abstr = applistc gl_abstr' (List.map (fun x,y,z -> x) (List.rev parms)) in - + let gl_abstr = + applistc gl_abstr' (List.map (fun (x,y,z) -> x) (List.rev parms)) in (* we apply args of the fix now, the parameters will be applied later *) let princ_proof_applied_args = applistc princ_proof (listsuf (List.length parms) listargs') in - (* parameters are still there so patternify must not take them -> lift *) let princ_proof_applied_lift = lift (List.length levar) princ_proof_applied_args in - let princ_applied_hyps'' = patternify (List.rev levar) princ_proof_applied_lift (Name (id_of_string "Hyp")) in (* if there was a fix, we will not add "Q" as in funscheme, so we make a pop, @@ -710,14 +709,20 @@ let invfun c l dorew gl = and add lift in funscheme. *) let princ_applied_hyps' = if Array.length evararr > 0 then popn 1 princ_applied_hyps'' - else princ_applied_hyps'' in - + else princ_applied_hyps'' in + (* if there is was fix, we have to replace the meta representing the + predicate of the goal by the abstracted goal itself. *) let princ_applied_hyps = if Array.length evararr > 0 then (* mutual Fixpoint not treated in the tactic *) - (substit_red 0 (evararr.(0)) gl_abstr princ_applied_hyps') + (substit_red 0 (evararr.(0)) gl_abstr princ_applied_hyps') else princ_applied_hyps' (* No Fixpoint *) in let _ = prNamedConstr "princ_applied_hyps" princ_applied_hyps in - + (* Same thing inside levar *) + let newlevar' = + if Array.length evararr > 0 then (* mutual Fixpoint not treated in the tactic *) + List.map (fun (x,y) -> x,substit_red 0 (evararr.(0)) gl_abstr y) levar + else levar + in (* replace params metavar by real args *) let rec replace_parms lparms largs t = match lparms, largs with @@ -725,8 +730,12 @@ let invfun c l dorew gl = | ((p,_,_)::lp), (a::la) -> let t'= substitterm 0 p a t in replace_parms lp la t' | _, _ -> error "problem with number of args." in let princ_proof_applied = replace_parms parms listargs' princ_applied_hyps in - - + let _ = prNamedLConstr "levar:" (List.map fst newlevar') in + let _ = prNamedLConstr "levar types:" (List.map snd newlevar') in + let _ = prNamedConstr "princ_proof_applied" princ_proof_applied in + (* replace also in levar *) + let newlevar = + List.rev (List.map (fun (x,y) -> x, replace_parms parms listargs' y) newlevar') in (* (* replace params metavar by abstracted variables *) let princ_proof_params = npatternify (List.rev parms) princ_applied_hyps in @@ -734,12 +743,15 @@ let invfun c l dorew gl = let princ_proof_applied = applistc princ_proof_params (listpref (List.length parms) listargs') in *) - - - - let princ_applied_evars = apply_levars princ_proof_applied levar in + let princ_applied_evars = apply_levars princ_proof_applied newlevar in let open_princ_proof_applied = princ_applied_evars in + let _ = prNamedConstr "princ_applied_evars" (snd princ_applied_evars) in + let _ = prNamedLConstr "evars" (List.map snd (fst princ_applied_evars)) in let listargs_ids = List.map destVar (List.filter isVar listargs') in + (* debug: impression du but*) +(* let lgl = Evd.to_list (sig_sig gl) in *) +(* let _ = prNamedLConstr "\ngl= " (List.map (fun x -> (snd x).evar_concl) lgl) in *) +(* let _ = prstr "fin gl \n\n" in *) invfun_basic (mkevarmap_aux open_princ_proof_applied) listargs_ids gl dorew lposeq @@ -750,8 +762,7 @@ let invfun_verif c l dorew gl = let x,_ = decompose_prod (pf_type_of gl c) in if List.length x = List.length l then try invfun c l dorew gl - with - UserError (x,y) -> raise (UserError (x,y)) + with UserError (x,y) -> raise (UserError (x,y)) else error "wrong number of arguments for the function" @@ -790,7 +801,7 @@ let buildFunscheme fonc mutflist = in let rec princ_replace_params params t = List.fold_left ( - fun acc ev,nam,typ -> + fun acc (ev,nam,typ) -> mkLambda (Name (id_of_name nam) , typ, substitterm 0 ev (mkRel 1) (lift 0 acc))) t (List.rev params) in diff --git a/contrib/funind/tacinvutils.ml b/contrib/funind/tacinvutils.ml index 758071ba..6e086d95 100644 --- a/contrib/funind/tacinvutils.ml +++ b/contrib/funind/tacinvutils.ml @@ -20,7 +20,8 @@ open Reductionops (*s printing of constr -- debugging *) -let msg x = () ;; let prterm c = str "" (* comment this to see debug msgs *) +(* comment this line to see debug msgs *) +let msg x = () ;; let prterm c = str "" (* uncomment this to see debugging *) let prconstr c = msg (str" " ++ prterm c ++ str"\n") let prlistconstr lc = List.iter prconstr lc @@ -67,6 +68,10 @@ let rec mkevarmap_from_listex lex = match lex with | [] -> Evd.empty | ((ex,_),typ)::lex' -> +(* let _ = prstr "mkevarmap" in + let _ = prstr ("evar n. " ^ string_of_int ex ^ " ") in + let _ = prstr "OF TYPE: " in + let _ = prconstr typ in*) let info ={ evar_concl = typ; evar_hyps = empty_named_context; diff --git a/contrib/interface/xlate.ml b/contrib/interface/xlate.ml index ed51b9cb..50f5b947 100644 --- a/contrib/interface/xlate.ml +++ b/contrib/interface/xlate.ml @@ -884,7 +884,7 @@ and xlate_tac = | _ -> assert false) | _ -> assert false) | TacExtend (_, "refine", [c]) -> - CT_refine (xlate_formula (out_gen rawwit_casted_open_constr c)) + CT_refine (xlate_formula (snd (out_gen rawwit_casted_open_constr c))) | TacExtend (_,"absurd",[c]) -> CT_absurd (xlate_formula (out_gen rawwit_constr c)) | TacExtend (_,"contradiction",[opt_c]) -> @@ -1230,11 +1230,16 @@ and coerce_genarg_to_TARG x = | TacticArgType -> let t = xlate_tactic (out_gen rawwit_tactic x) in CT_coerce_TACTIC_COM_to_TARG t + | OpenConstrArgType -> + CT_coerce_SCOMMENT_CONTENT_to_TARG + (CT_coerce_FORMULA_to_SCOMMENT_CONTENT(xlate_formula + (snd (out_gen + rawwit_open_constr x)))) | CastedOpenConstrArgType -> CT_coerce_SCOMMENT_CONTENT_to_TARG (CT_coerce_FORMULA_to_SCOMMENT_CONTENT(xlate_formula - (out_gen - rawwit_casted_open_constr x))) + (snd (out_gen + rawwit_casted_open_constr x)))) | ConstrWithBindingsArgType -> xlate_error "TODO: generic constr with bindings" | BindingsArgType -> xlate_error "TODO: generic with bindings" | RedExprArgType -> xlate_error "TODO: generic red expr" @@ -1324,6 +1329,7 @@ let coerce_genarg_to_VARG x = | TacticArgType -> let t = xlate_tactic (out_gen rawwit_tactic x) in CT_coerce_TACTIC_OPT_to_VARG (CT_coerce_TACTIC_COM_to_TACTIC_OPT t) + | OpenConstrArgType -> xlate_error "TODO: generic open constr" | CastedOpenConstrArgType -> xlate_error "TODO: generic open constr" | ConstrWithBindingsArgType -> xlate_error "TODO: generic constr with bindings" | BindingsArgType -> xlate_error "TODO: generic with bindings" diff --git a/dev/top_printers.ml b/dev/top_printers.ml index 7f92d64c..1e314929 100644 --- a/dev/top_printers.ml +++ b/dev/top_printers.ml @@ -25,6 +25,8 @@ open Term open Termops open Clenv open Cerrors +open Constrextern +open Constrintern let _ = Constrextern.print_evar_arguments := true @@ -233,7 +235,7 @@ let print_pure_constr csr = print_cut(); open_vbox 0; let rec print_fix () = - for k = 0 to Array.length tl do + for k = 0 to Array.length tl - 1 do open_vbox 0; name_display lna.(k); print_string "/"; print_int t.(k); print_cut(); print_string ":"; @@ -247,7 +249,7 @@ let print_pure_constr csr = print_cut(); open_vbox 0; let rec print_fix () = - for k = 0 to Array.length tl do + for k = 0 to Array.length tl - 1 do open_vbox 1; name_display lna.(k); print_cut(); print_string ":"; box_display tl.(k) ; print_cut(); print_string ":="; diff --git a/ide/command_windows.mli b/ide/command_windows.mli index 014be777..6028c818 100644 --- a/ide/command_windows.mli +++ b/ide/command_windows.mli @@ -6,7 +6,7 @@ (* * GNU Lesser General Public License Version 2.1 *) (************************************************************************) -(* $Id: command_windows.mli,v 1.1.2.1 2004/07/16 19:30:19 herbelin Exp $ *) +(*i $Id: command_windows.mli,v 1.1.2.2 2005/01/21 17:21:33 herbelin Exp $ i*) class command_window : unit -> diff --git a/ide/coq.mli b/ide/coq.mli index bcebd4e6..c1dfd847 100644 --- a/ide/coq.mli +++ b/ide/coq.mli @@ -6,7 +6,7 @@ (* * GNU Lesser General Public License Version 2.1 *) (************************************************************************) -(* $Id: coq.mli,v 1.14.2.2 2004/07/18 11:20:15 herbelin Exp $ *) +(*i $Id: coq.mli,v 1.14.2.3 2005/01/21 17:21:33 herbelin Exp $ i*) open Names open Term diff --git a/ide/coq_tactics.mli b/ide/coq_tactics.mli index 8d603346..962b4d27 100644 --- a/ide/coq_tactics.mli +++ b/ide/coq_tactics.mli @@ -6,7 +6,7 @@ (* * GNU Lesser General Public License Version 2.1 *) (************************************************************************) -(* $Id: coq_tactics.mli,v 1.1.2.1 2004/07/16 19:30:20 herbelin Exp $ *) +(*i $Id: coq_tactics.mli,v 1.1.2.2 2005/01/21 17:21:33 herbelin Exp $ i*) val tactics : string list diff --git a/ide/coqide.ml b/ide/coqide.ml index 2169862e..08994010 100644 --- a/ide/coqide.ml +++ b/ide/coqide.ml @@ -6,7 +6,7 @@ (* * GNU Lesser General Public License Version 2.1 *) (************************************************************************) -(* $Id: coqide.ml,v 1.99.2.2 2004/07/18 11:20:15 herbelin Exp $ *) +(* $Id: coqide.ml,v 1.99.2.3 2004/10/15 14:50:12 coq Exp $ *) open Preferences open Vernacexpr @@ -1030,6 +1030,7 @@ object(self) end_iter#nocopy#set_offset (start#offset + !Find_phrase.length); Some (start,end_iter) with +(* | Find_phrase.EOF s -> (* Phrase is at the end of the buffer*) let si = start#offset in @@ -1038,6 +1039,7 @@ object(self) input_buffer#insert ~iter:end_iter "\n"; Some (input_buffer#get_iter (`OFFSET si), input_buffer#get_iter (`OFFSET ei)) +*) | _ -> None method complete_at_offset (offset:int) = diff --git a/ide/coqide.mli b/ide/coqide.mli index 15e28fea..553426f1 100644 --- a/ide/coqide.mli +++ b/ide/coqide.mli @@ -6,7 +6,7 @@ (* * GNU Lesser General Public License Version 2.1 *) (************************************************************************) -(* $Id: coqide.mli,v 1.1.2.1 2004/07/16 19:30:20 herbelin Exp $ *) +(*i $Id: coqide.mli,v 1.1.2.2 2005/01/21 17:21:33 herbelin Exp $ i*) (* The CoqIde main module. The following function [start] will parse the command line, initialize the load path, load the input diff --git a/ide/find_phrase.mll b/ide/find_phrase.mll index 8081474f..7b65bd94 100644 --- a/ide/find_phrase.mll +++ b/ide/find_phrase.mll @@ -6,13 +6,12 @@ (* * GNU Lesser General Public License Version 2.1 *) (************************************************************************) -(* $Id: find_phrase.mll,v 1.8.2.1 2004/07/16 19:30:20 herbelin Exp $ *) +(* $Id: find_phrase.mll,v 1.8.2.2 2004/10/15 14:50:13 coq Exp $ *) { exception Lex_error of string let length = ref 0 let buff = Buffer.create 513 - exception EOF of string } @@ -34,10 +33,13 @@ rule next_phrase = parse Buffer.contents buff} | phrase_sep eof{ + length := !length + 1; + Buffer.add_string buff (Lexing.lexeme lexbuf); + Buffer.contents buff} + | phrase_sep phrase_sep { length := !length + 2; Buffer.add_string buff (Lexing.lexeme lexbuf); - Buffer.add_char buff '\n'; - raise (EOF(Buffer.contents buff))} + next_phrase lexbuf} | _ { let c = Lexing.lexeme_char lexbuf 0 in diff --git a/ide/highlight.mll b/ide/highlight.mll index 21063459..e2a1d0cd 100644 --- a/ide/highlight.mll +++ b/ide/highlight.mll @@ -6,7 +6,7 @@ (* * GNU Lesser General Public License Version 2.1 *) (************************************************************************) -(* $Id: highlight.mll,v 1.14.2.1 2004/07/16 19:30:20 herbelin Exp $ *) +(* $Id: highlight.mll,v 1.14.2.2 2004/11/27 14:41:43 herbelin Exp $ *) { @@ -29,18 +29,21 @@ let identchar = let ident = firstchar identchar* let keyword = - "Add" | "CoInductive" | "Defined" | + "Add" | "Defined" | "End" | "Export" | "Extraction" | "Hint" | "Implicits" | "Import" | "Infix" | "Load" | "match" | "Module" | "Module Type" | "Proof" | "Qed" | - "Record" | "Require" | "Save" | "Scheme" | + "Require" | "Save" | "Scheme" | "Section" | "Unset" | "Set" let declaration = "Lemma" | "Axiom" | "CoFixpoint" | "Definition" | "Fixpoint" | "Hypothesis" | + "Hypotheses" | "Axioms" | "Parameters" | "Subclass" | + "Remark" | "Fact" | "Conjecture" | "Let" | + "CoInductive" | "Record" | "Structure" | "Inductive" | "Parameter" | "Theorem" | "Variable" | "Variables" diff --git a/ide/ideutils.mli b/ide/ideutils.mli index 7c225e0e..d91faff4 100644 --- a/ide/ideutils.mli +++ b/ide/ideutils.mli @@ -6,7 +6,7 @@ (* * GNU Lesser General Public License Version 2.1 *) (************************************************************************) -(* $Id: ideutils.mli,v 1.6.2.1 2004/07/16 19:30:20 herbelin Exp $ *) +(*i $Id: ideutils.mli,v 1.6.2.2 2005/01/21 17:21:33 herbelin Exp $ i*) val async : ('a -> unit) -> 'a -> unit val browse : (string -> unit) -> string -> unit diff --git a/ide/preferences.mli b/ide/preferences.mli index b4be283d..048707a3 100644 --- a/ide/preferences.mli +++ b/ide/preferences.mli @@ -6,7 +6,7 @@ (* * GNU Lesser General Public License Version 2.1 *) (************************************************************************) -(* $Id: preferences.mli,v 1.8.2.1 2004/07/16 19:30:21 herbelin Exp $ *) +(*i $Id: preferences.mli,v 1.8.2.2 2005/01/21 17:21:33 herbelin Exp $ i*) type pref = { diff --git a/ide/undo.mli b/ide/undo.mli index 6c7492ab..11613fdb 100644 --- a/ide/undo.mli +++ b/ide/undo.mli @@ -6,7 +6,7 @@ (* * GNU Lesser General Public License Version 2.1 *) (************************************************************************) -(* $Id: undo.mli,v 1.4.2.1 2004/07/16 19:30:21 herbelin Exp $ *) +(*i $Id: undo.mli,v 1.4.2.2 2005/01/21 17:21:33 herbelin Exp $ i*) (* An undoable view class *) diff --git a/interp/constrextern.mli b/interp/constrextern.mli index ad1c4391..0dcdffeb 100644 --- a/interp/constrextern.mli +++ b/interp/constrextern.mli @@ -6,7 +6,7 @@ (* * GNU Lesser General Public License Version 2.1 *) (************************************************************************) -(*i $Id: constrextern.mli,v 1.11.2.2 2004/07/16 20:51:12 herbelin Exp $ *) +(*i $Id: constrextern.mli,v 1.11.2.3 2005/01/21 16:41:50 herbelin Exp $ i*) (*i*) open Util diff --git a/interp/constrintern.ml b/interp/constrintern.ml index e1b916e1..222ea23b 100644 --- a/interp/constrintern.ml +++ b/interp/constrintern.ml @@ -6,7 +6,7 @@ (* * GNU Lesser General Public License Version 2.1 *) (************************************************************************) -(* $Id: constrintern.ml,v 1.58.2.2 2004/07/16 20:51:12 herbelin Exp $ *) +(* $Id: constrintern.ml,v 1.58.2.6 2004/11/22 14:21:23 herbelin Exp $ *) open Pp open Util @@ -154,8 +154,10 @@ let add_glob loc ref = i*) let sp = Nametab.sp_of_global ref in let id = let _,id = repr_path sp in string_of_id id in - let dp = string_of_dirpath (Lib.library_part ref) in - dump_string (Printf.sprintf "R%d %s.%s\n" (fst (unloc loc)) dp id) + let dir = Lib.file_part ref in + if dir <> None then + let dp = string_of_dirpath (out_some dir) in + dump_string (Printf.sprintf "R%d %s.%s\n" (fst (unloc loc)) dp id) let loc_of_notation f loc args ntn = if args=[] or ntn.[0] <> '_' then fst (unloc loc) @@ -630,6 +632,10 @@ let check_projection isproj nargs r = | _, Some _ -> user_err_loc (loc_of_rawconstr r, "", str "Not a projection") | _, None -> () +let get_implicit_name n imps = + if !Options.v7 then None + else Some (Impargs.name_of_implicit (List.nth imps (n-1))) + let set_hole_implicit i = function | RRef (loc,r) -> (loc,ImplicitArg (r,i)) | RVar (loc,id) -> (loc,ImplicitArg (VarRef id,i)) @@ -680,8 +686,14 @@ let coerce_to_id = function str"This expression should be a simple identifier") let traverse_binder subst id (ids,tmpsc,scopes as env) = - let id = try coerce_to_id (fst (List.assoc id subst)) with Not_found -> id in - id,(Idset.add id ids,tmpsc,scopes) + try + (* Binders bound in the notation are consider first-order object *) + (* and binders not bound in the notation do not capture variables *) + (* outside the notation *) + let id' = coerce_to_id (fst (List.assoc id subst)) in + id', (Idset.add id' ids,tmpsc,scopes) + with Not_found -> + id, env let decode_constrlist_value = function | CAppExpl (_,_,l) -> l @@ -895,7 +907,9 @@ let internalise sigma env allow_soapp lvar c = and intern_local_binder ((ids,ts,sc as env),bl) = function LocalRawAssum(nal,ty) -> - let ty = intern_type env ty in + let (loc,na) = List.hd nal in + (* TODO: fail if several names with different implicit types *) + let ty = locate_if_isevar loc na (intern_type env ty) in List.fold_left (fun ((ids,ts,sc),bl) (_,na) -> ((name_fold Idset.add na ids,ts,sc), (na,None,ty)::bl)) @@ -980,7 +994,7 @@ let internalise sigma env allow_soapp lvar c = (* with implicit arguments *) [] else - RHole (set_hole_implicit n c) :: + RHole (set_hole_implicit (n,get_implicit_name n l) c) :: aux (n+1) impl' subscopes' eargs rargs end | (imp::impl', a::rargs') -> diff --git a/interp/constrintern.mli b/interp/constrintern.mli index a65ab6a7..06039da7 100644 --- a/interp/constrintern.mli +++ b/interp/constrintern.mli @@ -6,7 +6,7 @@ (* * GNU Lesser General Public License Version 2.1 *) (************************************************************************) -(*i $Id: constrintern.mli,v 1.15.2.1 2004/07/16 19:30:22 herbelin Exp $ *) +(*i $Id: constrintern.mli,v 1.15.2.2 2005/01/21 16:41:50 herbelin Exp $ i*) (*i*) open Names @@ -64,7 +64,7 @@ val interp_casted_openconstr : (* [interp_type_with_implicits] extends [interp_type] by allowing implicits arguments in the ``rel'' part of [env]; the extra argument associates a list of implicit positions to identifiers - declared in the rel_context of [env] *) + declared in the [rel_context] of [env] *) val interp_type_with_implicits : evar_map -> env -> full_implicits_env -> constr_expr -> types diff --git a/interp/coqlib.mli b/interp/coqlib.mli index 7ac2a5c9..3b377f29 100644 --- a/interp/coqlib.mli +++ b/interp/coqlib.mli @@ -6,7 +6,7 @@ (* * GNU Lesser General Public License Version 2.1 *) (************************************************************************) -(* $Id: coqlib.mli,v 1.5.2.1 2004/07/16 19:30:22 herbelin Exp $ *) +(*i $Id: coqlib.mli,v 1.5.2.3 2005/01/21 17:14:10 herbelin Exp $ i*) (*i*) open Names @@ -80,7 +80,7 @@ val build_coq_eq_data : coq_leibniz_eq_data delayed val build_coq_eqT_data : coq_leibniz_eq_data delayed val build_coq_idT_data : coq_leibniz_eq_data delayed -val build_coq_eq : constr delayed (* = (build_coq_eq_data()).eq *) +val build_coq_eq : constr delayed (* = [(build_coq_eq_data()).eq] *) val build_coq_f_equal2 : constr delayed val build_coq_eqT : constr delayed val build_coq_sym_eqT : constr delayed diff --git a/interp/doc.tex b/interp/doc.tex index 4d60ec34..5bd92fbd 100644 --- a/interp/doc.tex +++ b/interp/doc.tex @@ -2,13 +2,13 @@ \newpage \section*{The interpretation of Coq front abstract syntax of terms} -\ocwsection \label{library} +\ocwsection \label{interp} This chapter describes the translation from \Coq\ context-dependent -front abstract syntax of terms (\verb=front=} to and from the +front abstract syntax of terms (\verb=front=) to and from the context-free, untyped, raw form of constructions (\verb=rawconstr=). The modules translating back and forth the front abstract syntax are organized as follows. \bigskip -\begin{center}\epsfig{file=library.dep.ps}\end{center} +\begin{center}\epsfig{file=interp.dep.ps}\end{center} diff --git a/interp/genarg.ml b/interp/genarg.ml index af3d805a..7facebcc 100644 --- a/interp/genarg.ml +++ b/interp/genarg.ml @@ -6,7 +6,7 @@ (* * GNU Lesser General Public License Version 2.1 *) (************************************************************************) -(* $Id: genarg.ml,v 1.9.2.1 2004/07/16 19:30:22 herbelin Exp $ *) +(* $Id: genarg.ml,v 1.9.2.2 2005/01/15 14:56:54 herbelin Exp $ *) open Pp open Util @@ -34,6 +34,7 @@ type argument_type = | ConstrMayEvalArgType | QuantHypArgType | TacticArgType + | OpenConstrArgType | CastedOpenConstrArgType | ConstrWithBindingsArgType | BindingsArgType @@ -85,8 +86,8 @@ and pr_case_intro_pattern = function ++ str "]" type open_constr = Evd.evar_map * Term.constr -type open_constr_expr = constr_expr -type open_rawconstr = rawconstr_and_expr +type open_constr_expr = unit * constr_expr +type open_rawconstr = unit * rawconstr_and_expr let rawwit_bool = BoolArgType let globwit_bool = BoolArgType @@ -144,6 +145,10 @@ let rawwit_tactic = TacticArgType let globwit_tactic = TacticArgType let wit_tactic = TacticArgType +let rawwit_open_constr = OpenConstrArgType +let globwit_open_constr = OpenConstrArgType +let wit_open_constr = OpenConstrArgType + let rawwit_casted_open_constr = CastedOpenConstrArgType let globwit_casted_open_constr = CastedOpenConstrArgType let wit_casted_open_constr = CastedOpenConstrArgType diff --git a/interp/genarg.mli b/interp/genarg.mli index 59b6e10d..967d5050 100644 --- a/interp/genarg.mli +++ b/interp/genarg.mli @@ -6,7 +6,7 @@ (* * GNU Lesser General Public License Version 2.1 *) (************************************************************************) -(* $Id: genarg.mli,v 1.9.2.1 2004/07/16 19:30:22 herbelin Exp $ *) +(*i $Id: genarg.mli,v 1.9.2.4 2005/01/21 17:14:10 herbelin Exp $ i*) open Util open Names @@ -19,14 +19,14 @@ open Term type 'a or_var = ArgArg of 'a | ArgVar of identifier located type 'a and_short_name = 'a * identifier located option -(* In globalize tactics, we need to keep the initial constr_expr to recompute*) +(* In globalize tactics, we need to keep the initial [constr_expr] to recompute*) (* in the environment by the effective calls to Intro, Inversion, etc *) -(* The constr_expr field is None in TacDef though *) +(* The [constr_expr] field is [None] in TacDef though *) type rawconstr_and_expr = rawconstr * constr_expr option type open_constr = Evd.evar_map * Term.constr -type open_constr_expr = constr_expr -type open_rawconstr = rawconstr_and_expr +type open_constr_expr = unit * constr_expr +type open_rawconstr = unit * rawconstr_and_expr type intro_pattern_expr = | IntroOrAndPattern of case_intro_pattern_expr @@ -39,6 +39,7 @@ val pr_case_intro_pattern : case_intro_pattern_expr -> Pp.std_ppcmds (* The route of a generic argument, from parsing to evaluation +\begin{verbatim} parsing in_raw out_raw char stream ----> rawtype ----> rawconstr generic_argument ----> | @@ -46,16 +47,18 @@ val pr_case_intro_pattern : case_intro_pattern_expr -> Pp.std_ppcmds V type <---- constr generic_argument <---- out in +\end{verbatim} To distinguish between the uninterpreted (raw) and the interpreted -worlds, we annotate the type generic_argument by a phantom argument -which is either constr_expr or constr (actually we add also a second -argument raw_tactic_expr and tactic, but this is only for technical +worlds, we annotate the type [generic_argument] by a phantom argument +which is either [constr_expr] or [constr] (actually we add also a second +argument [raw_tactic_expr] and [tactic], but this is only for technical reasons, because these types are undefined at the type of compilation -of Genarg). +of [Genarg]). Transformation for each type : -tag f raw open type cooked closed type +\begin{verbatim} +tag raw open type cooked closed type BoolArgType bool bool IntArgType int int @@ -70,12 +73,13 @@ ConstrArgType constr_expr constr ConstrMayEvalArgType constr_expr may_eval constr QuantHypArgType quantified_hypothesis quantified_hypothesis TacticArgType raw_tactic_expr tactic -CastedOpenConstrArgType constr_expr open_constr +OpenConstrArgType constr_expr open_constr ConstrBindingsArgType constr_expr with_bindings constr with_bindings List0ArgType of argument_type List1ArgType of argument_type OptArgType of argument_type ExtraArgType of string '_a '_b +\end{verbatim} *) type ('a,'co,'ta) abstract_argument_type @@ -132,6 +136,10 @@ val rawwit_constr_may_eval : ((constr_expr,reference) may_eval,constr_expr,'ta) val globwit_constr_may_eval : ((rawconstr_and_expr,evaluable_global_reference and_short_name or_var) may_eval,rawconstr_and_expr,'ta) abstract_argument_type val wit_constr_may_eval : (constr,constr,'ta) abstract_argument_type +val rawwit_open_constr : (open_constr_expr,constr_expr,'ta) abstract_argument_type +val globwit_open_constr : (open_rawconstr,rawconstr_and_expr,'ta) abstract_argument_type +val wit_open_constr : (open_constr,constr,'ta) abstract_argument_type + val rawwit_casted_open_constr : (open_constr_expr,constr_expr,'ta) abstract_argument_type val globwit_casted_open_constr : (open_rawconstr,rawconstr_and_expr,'ta) abstract_argument_type val wit_casted_open_constr : (open_constr,constr,'ta) abstract_argument_type @@ -167,7 +175,7 @@ val wit_pair : ('b,'co,'ta) abstract_argument_type -> ('a * 'b,'co,'ta) abstract_argument_type -(* 'a generic_argument = (Sigma t:type. t[constr/'a]) *) +(* ['a generic_argument] = (Sigma t:type. t[[constr/'a]]) *) type ('a,'b) generic_argument val fold_list0 : @@ -227,6 +235,7 @@ type argument_type = | ConstrMayEvalArgType | QuantHypArgType | TacticArgType + | OpenConstrArgType | CastedOpenConstrArgType | ConstrWithBindingsArgType | BindingsArgType @@ -247,7 +256,7 @@ val unquote : ('a,'co,'ta) abstract_argument_type -> argument_type with f a = b if a is Constr, f a = c if a is Tactic, otherwise f a = |a| - in_generic is not typable; we replace the second argument by an absurd + [in_generic] is not typable; we replace the second argument by an absurd type (with no introduction rule) *) type an_arg_of_this_type diff --git a/interp/ppextend.mli b/interp/ppextend.mli index 056b7a42..bc0a83ec 100644 --- a/interp/ppextend.mli +++ b/interp/ppextend.mli @@ -6,7 +6,7 @@ (* * GNU Lesser General Public License Version 2.1 *) (************************************************************************) -(*i $Id: ppextend.mli,v 1.4.2.1 2004/07/16 19:30:22 herbelin Exp $ *) +(*i $Id: ppextend.mli,v 1.4.2.2 2005/01/21 16:41:50 herbelin Exp $ i*) (*i*) open Pp diff --git a/interp/symbols.ml b/interp/symbols.ml index ed151d8e..d1abb084 100644 --- a/interp/symbols.ml +++ b/interp/symbols.ml @@ -6,7 +6,7 @@ (* * GNU Lesser General Public License Version 2.1 *) (************************************************************************) -(* $Id: symbols.ml,v 1.31.2.1 2004/07/16 19:30:23 herbelin Exp $ *) +(* $Id: symbols.ml,v 1.31.2.2 2004/11/17 09:33:38 herbelin Exp $ *) (*i*) open Util @@ -270,7 +270,7 @@ let declare_notation_interpretation ntn scopt pat df pp8only = let scope = match scopt with Some s -> s | None -> default_scope in let sc = find_scope scope in if Stringmap.mem ntn sc.notations && Options.is_verbose () then - warning ("Notation "^ntn^" is already used"^ + warning ("Notation "^ntn^" was already used"^ (if scopt = None then "" else " in scope "^scope)); let sc = { sc with notations = Stringmap.add ntn (pat,df,pp8only) sc.notations } in scope_map := Stringmap.add scope sc !scope_map; diff --git a/interp/symbols.mli b/interp/symbols.mli index 00d8e5ff..5401ae77 100644 --- a/interp/symbols.mli +++ b/interp/symbols.mli @@ -6,7 +6,7 @@ (* * GNU Lesser General Public License Version 2.1 *) (************************************************************************) -(* $Id: symbols.mli,v 1.22.2.1 2004/07/16 19:30:23 herbelin Exp $ *) +(*i $Id: symbols.mli,v 1.22.2.3 2005/01/21 17:14:10 herbelin Exp $ i*) (*i*) open Util @@ -30,7 +30,7 @@ open Ppextend type level = precedence * tolerability list type delimiters = string type scope -type scopes (* = scope_name list*) +type scopes (* = [scope_name list] *) val type_scope : scope_name val declare_scope : scope_name -> unit @@ -52,7 +52,7 @@ val find_delimiters_scope : loc -> delimiters -> scope_name (*s Declare and uses back and forth a numeral interpretation *) -(* A numeral interpreter is the pair of an interpreter for _integer_ +(* A numeral interpreter is the pair of an interpreter for **integer** numbers in terms and an optional interpreter in pattern, if negative numbers are not supported, the interpreter must fail with an appropriate error message *) @@ -69,12 +69,12 @@ type required_module = global_reference * string list val declare_numeral_interpreter : scope_name -> required_module -> num_interpreter -> num_uninterpreter -> unit -(* Returns the term/cases_pattern bound to a numeral in a given scope context*) +(* Return the [term]/[cases_pattern] bound to a numeral in a given scope context*) val interp_numeral : loc -> bigint -> scope_name list -> rawconstr val interp_numeral_as_pattern : loc -> bigint -> name -> scope_name list -> cases_pattern -(* Returns the numeral bound to a term/cases_pattern; raises No_match if no *) +(* Return the numeral bound to a [term]/[cases_pattern]; raise [No_match] if no *) (* such numeral *) val uninterp_numeral : rawconstr -> scope_name * bigint val uninterp_cases_numeral : cases_pattern -> scope_name * bigint @@ -92,11 +92,11 @@ val declare_notation_interpretation : notation -> scope_name option -> val declare_uninterpretation : interp_rule -> interpretation -> unit -(* Returns the interpretation bound to a notation *) +(* Return the interpretation bound to a notation *) val interp_notation : loc -> notation -> scope_name list -> interpretation * ((dir_path * string) * scope_name option) -(* Returns the possible notations for a given term *) +(* Return the possible notations for a given term *) val uninterp_notations : rawconstr -> (interp_rule * interpretation * int option) list val uninterp_cases_pattern_notations : cases_pattern -> diff --git a/interp/topconstr.ml b/interp/topconstr.ml index 3ee3285b..a2b6e8b7 100644 --- a/interp/topconstr.ml +++ b/interp/topconstr.ml @@ -6,7 +6,7 @@ (* * GNU Lesser General Public License Version 2.1 *) (************************************************************************) -(* $Id: topconstr.ml,v 1.35.2.2 2004/07/16 19:30:23 herbelin Exp $ *) +(* $Id: topconstr.ml,v 1.35.2.3 2004/11/17 09:51:41 herbelin Exp $ *) (*i*) open Pp @@ -89,8 +89,11 @@ let rawconstr_of_aconstr_with_binders loc g f e = function | AOrderedCase (b,tyopt,tm,bv) -> ROrderedCase (loc,b,option_app (f e) tyopt,f e tm,Array.map (f e) bv,ref None) | ALetTuple (nal,(na,po),b,c) -> + let e,nal = list_fold_map (fun e na -> let (na,e) = name_app g e na in e,na) e nal in + let na,e = name_app g e na in RLetTuple (loc,nal,(na,option_app (f e) po),f e b,f e c) | AIf (c,(na,po),b1,b2) -> + let na,e = name_app g e na in RIf (loc,f e c,(na,option_app (f e) po),f e b1,f e b2) | ACast (c,t) -> RCast (loc,f e c,f e t) | ASort x -> RSort (loc,x) @@ -271,8 +274,11 @@ let aconstr_and_vars_of_rawconstr a = | ROrderedCase (_,b,tyopt,tm,bv,_) -> AOrderedCase (b,option_app aux tyopt,aux tm, Array.map aux bv) | RLetTuple (loc,nal,(na,po),b,c) -> + add_name bound_binders na; + List.iter (add_name bound_binders) nal; ALetTuple (nal,(na,option_app aux po),aux b,aux c) | RIf (loc,c,(na,po),b1,b2) -> + add_name bound_binders na; AIf (aux c,(na,option_app aux po),aux b1,aux b2) | RCast (_,c,t) -> ACast (aux c,aux t) | RSort (_,s) -> ASort s @@ -349,17 +355,19 @@ let rec alpha_var id1 id2 = function let alpha_eq_val (x,y) = x = y -let bind_env sigma var v = +let bind_env alp sigma var v = try let vvar = List.assoc var sigma in if alpha_eq_val (v,vvar) then sigma else raise No_match with Not_found -> + (* Check that no capture of binding variables occur *) + if List.exists (fun (id,_) ->occur_rawconstr id v) alp then raise No_match; (* TODO: handle the case of multiple occs in different scopes *) (var,v)::sigma let rec match_ alp metas sigma a1 a2 = match (a1,a2) with - | r1, AVar id2 when List.mem id2 metas -> bind_env sigma id2 r1 + | r1, AVar id2 when List.mem id2 metas -> bind_env alp sigma id2 r1 | RVar (_,id1), AVar id2 when alpha_var id1 id2 alp -> sigma | RRef (_,r1), ARef r2 when r1 = r2 -> sigma | RPatVar (_,(_,n1)), APatVar n2 when n1=n2 -> sigma @@ -417,7 +425,7 @@ and match_alist alp metas sigma l1 l2 x iter termin lassoc = and match_binders alp metas sigma b1 b2 na1 na2 = match (na1,na2) with | (Name id1,Name id2) when List.mem id2 metas -> - let sigma = bind_env sigma id2 (RVar (dummy_loc,id1)) in + let sigma = bind_env alp sigma id2 (RVar (dummy_loc,id1)) in match_ alp metas sigma b1 b2 | (Name id1,Name id2) -> match_ ((id1,id2)::alp) metas sigma b1 b2 | (Anonymous,Anonymous) -> match_ alp metas sigma b1 b2 diff --git a/interp/topconstr.mli b/interp/topconstr.mli index f4a82a3a..54547352 100644 --- a/interp/topconstr.mli +++ b/interp/topconstr.mli @@ -6,7 +6,7 @@ (* * GNU Lesser General Public License Version 2.1 *) (************************************************************************) -(* $Id: topconstr.mli,v 1.23.2.1 2004/07/16 19:30:23 herbelin Exp $ *) +(*i $Id: topconstr.mli,v 1.23.2.3 2005/01/21 17:14:10 herbelin Exp $ i*) (*i*) open Pp @@ -23,12 +23,12 @@ open Term (* non global expressions such as existential variables also *) type aconstr = - (* Part common to rawconstr and cases_pattern *) + (* Part common to [rawconstr] and [cases_pattern] *) | ARef of global_reference | AVar of identifier | AApp of aconstr * aconstr list | AList of identifier * identifier * aconstr * aconstr * bool - (* Part only in rawconstr *) + (* Part only in [rawconstr] *) | ALambda of name * aconstr * aconstr | AProd of name * aconstr * aconstr | ALetIn of name * aconstr * aconstr @@ -59,7 +59,7 @@ type scope_name = string type interpretation = (identifier * (scope_name option * scope_name list)) list * aconstr -val match_aconstr : (* scope_name option -> *) rawconstr -> interpretation -> +val match_aconstr : (*i scope_name option -> i*) rawconstr -> interpretation -> (rawconstr * (scope_name option * scope_name list)) list (*s Concrete syntax for terms *) diff --git a/kernel/conv_oracle.mli b/kernel/conv_oracle.mli index 77de9b8a..8d0c12bb 100644 --- a/kernel/conv_oracle.mli +++ b/kernel/conv_oracle.mli @@ -6,7 +6,7 @@ (* * GNU Lesser General Public License Version 2.1 *) (************************************************************************) -(* $Id: conv_oracle.mli,v 1.3.8.2 2004/07/16 19:30:24 herbelin Exp $ *) +(*i $Id: conv_oracle.mli,v 1.3.8.3 2005/01/21 17:14:10 herbelin Exp $ i*) open Names open Closure diff --git a/kernel/declarations.mli b/kernel/declarations.mli index 3252ddee..c670fe9a 100644 --- a/kernel/declarations.mli +++ b/kernel/declarations.mli @@ -6,7 +6,7 @@ (* * GNU Lesser General Public License Version 2.1 *) (************************************************************************) -(*i $Id: declarations.mli,v 1.33.2.1 2004/07/16 19:30:24 herbelin Exp $ i*) +(*i $Id: declarations.mli,v 1.33.2.2 2005/01/21 16:41:49 herbelin Exp $ i*) (*i*) open Names @@ -109,8 +109,8 @@ and module_specification_body = { msb_modtype : module_type_body; msb_equiv : module_path option; msb_constraints : constraints } - (* type_of(equiv) <: modtype (if given) - + substyping of past With_Module mergers *) + (* [type_of](equiv) <: modtype (if given) + + substyping of past [With_Module] mergers *) type structure_elem_body = @@ -126,7 +126,7 @@ and module_expr_body = | MEBfunctor of mod_bound_id * module_type_body * module_expr_body | MEBstruct of mod_self_id * module_structure_body | MEBapply of module_expr_body * module_expr_body (* (F A) *) - * constraints (* type_of(A) <: input_type_of(F) *) + * constraints (* [type_of](A) <: [input_type_of](F) *) and module_body = { mod_expr : module_expr_body option; @@ -134,7 +134,7 @@ and module_body = mod_type : module_type_body; mod_equiv : module_path option; mod_constraints : constraints } - (* type_of(mod_expr) <: mod_user_type (if given) *) + (* [type_of(mod_expr)] <: [mod_user_type] (if given) *) (* if equiv given then constraints are empty *) diff --git a/kernel/environ.mli b/kernel/environ.mli index 4e54761b..a2a66cb7 100644 --- a/kernel/environ.mli +++ b/kernel/environ.mli @@ -6,7 +6,7 @@ (* * GNU Lesser General Public License Version 2.1 *) (************************************************************************) -(*i $Id: environ.mli,v 1.66.2.1 2004/07/16 19:30:25 herbelin Exp $ i*) +(*i $Id: environ.mli,v 1.66.2.2 2005/01/21 16:41:49 herbelin Exp $ i*) (*i*) open Names @@ -44,7 +44,7 @@ val engagement : env -> engagement option val empty_context : env -> bool (************************************************************************) -(*s Context of de Bruijn variables (rel_context) *) +(*s Context of de Bruijn variables ([rel_context]) *) val push_rel : rel_declaration -> env -> env val push_rel_context : rel_context -> env -> env val push_rec_types : rec_declaration -> env -> env diff --git a/kernel/esubst.mli b/kernel/esubst.mli index b02d747b..2fe981f7 100644 --- a/kernel/esubst.mli +++ b/kernel/esubst.mli @@ -6,7 +6,7 @@ (* * GNU Lesser General Public License Version 2.1 *) (************************************************************************) -(* $Id: esubst.mli,v 1.3.2.1 2004/07/16 19:30:25 herbelin Exp $ *) +(*i $Id: esubst.mli,v 1.3.2.2 2005/01/21 17:14:10 herbelin Exp $ i*) (*s Compact representation of explicit relocations. \\ [ELSHFT(l,n)] == lift of [n], then apply [lift l]. diff --git a/kernel/inductive.mli b/kernel/inductive.mli index ad44fa64..04345621 100644 --- a/kernel/inductive.mli +++ b/kernel/inductive.mli @@ -6,7 +6,7 @@ (* * GNU Lesser General Public License Version 2.1 *) (************************************************************************) -(*i $Id: inductive.mli,v 1.57.8.1 2004/07/16 19:30:25 herbelin Exp $ i*) +(*i $Id: inductive.mli,v 1.57.8.2 2005/01/21 16:41:49 herbelin Exp $ i*) (*i*) open Names @@ -62,7 +62,7 @@ val type_case_branches : given inductive type. *) val check_case_info : env -> inductive -> case_info -> unit -(* Find the ultimate inductive in the mind_equiv chain *) +(* Find the ultimate inductive in the [mind_equiv] chain *) val scrape_mind : env -> mutual_inductive -> mutual_inductive diff --git a/kernel/mod_typing.mli b/kernel/mod_typing.mli index 0ea98bf0..fdf39c56 100644 --- a/kernel/mod_typing.mli +++ b/kernel/mod_typing.mli @@ -6,7 +6,7 @@ (* * GNU Lesser General Public License Version 2.1 *) (************************************************************************) -(* $Id: mod_typing.mli,v 1.2.8.1 2004/07/16 19:30:26 herbelin Exp $ *) +(*i $Id: mod_typing.mli,v 1.2.8.2 2005/01/21 17:14:10 herbelin Exp $ i*) (*i*) open Declarations diff --git a/kernel/modops.mli b/kernel/modops.mli index 5433fa3e..cca2d315 100644 --- a/kernel/modops.mli +++ b/kernel/modops.mli @@ -6,7 +6,7 @@ (* * GNU Lesser General Public License Version 2.1 *) (************************************************************************) -(*i $Id: modops.mli,v 1.7.6.1 2004/07/16 19:30:26 herbelin Exp $ i*) +(*i $Id: modops.mli,v 1.7.6.2 2005/01/21 16:41:50 herbelin Exp $ i*) (*i*) open Util @@ -41,7 +41,7 @@ val subst_signature_msid : module_signature_body -> module_signature_body (* [add_signature mp sign env] assumes that the substitution [msid] - \mapsto [mp] has already been performed (or is not necessary, like + $\mapsto$ [mp] has already been performed (or is not necessary, like when [mp = MPself msid]) *) val add_signature : module_path -> module_signature_body -> env -> env diff --git a/lib/bignat.mli b/lib/bignat.mli index f08ccc39..860bcf29 100644 --- a/lib/bignat.mli +++ b/lib/bignat.mli @@ -6,7 +6,7 @@ (* * GNU Lesser General Public License Version 2.1 *) (************************************************************************) -(* $Id: bignat.mli,v 1.4.6.1 2004/07/16 19:30:29 herbelin Exp $ *) +(*i $Id: bignat.mli,v 1.4.6.3 2005/01/21 17:14:11 herbelin Exp $ i*) (*i*) open Pp @@ -26,7 +26,7 @@ val is_one : bignat -> bool val div2_with_rest : bignat -> bignat * bool (* true=odd; false=even *) val add_1 : bignat -> bignat -val sub_1 : bignat -> bignat (* Remark: (sub_1 0)=0 *) +val sub_1 : bignat -> bignat (* Remark: [sub_1 0]=0 *) val mult_2 : bignat -> bignat val less_than : bignat -> bignat -> bool diff --git a/lib/compat.ml4 b/lib/compat.ml4 index 5e1c65b4..0947f5fb 100644 --- a/lib/compat.ml4 +++ b/lib/compat.ml4 @@ -11,19 +11,24 @@ (* IFDEF not available in 3.06; use ifdef instead *) (* type loc is different in 3.08 *) -ifdef OCAML308 then +ifdef OCAML_308 then module M = struct type loc = Token.flocation let dummy_loc = Token.dummy_loc -let unloc (b,e) = (b.Lexing.pos_cnum,e.Lexing.pos_cnum) let make_loc loc = Token.make_loc loc +let unloc (b,e) = + let loc = (b.Lexing.pos_cnum,e.Lexing.pos_cnum) in + (* Ensure that we unpack a char location that was encoded as a line-col + location by make_loc *) + assert (dummy_loc = (b,e) or make_loc loc = (b,e)); + loc end else module M = struct type loc = int * int let dummy_loc = (0,0) -let unloc x = x let make_loc x = x +let unloc x = x end type loc = M.loc diff --git a/lib/heap.mli b/lib/heap.mli index c865461e..46e72728 100644 --- a/lib/heap.mli +++ b/lib/heap.mli @@ -6,7 +6,7 @@ (* * GNU Lesser General Public License Version 2.1 *) (************************************************************************) -(* $Id: heap.mli,v 1.1.2.1 2004/07/16 19:30:30 herbelin Exp $ *) +(*i $Id: heap.mli,v 1.1.2.2 2005/01/21 17:14:11 herbelin Exp $ i*) (* Heaps *) diff --git a/lib/predicate.mli b/lib/predicate.mli index 160fa648..2dc7d85c 100644 --- a/lib/predicate.mli +++ b/lib/predicate.mli @@ -1,5 +1,5 @@ -(* $Id: predicate.mli,v 1.1 2001/09/20 18:10:43 barras Exp $ *) +(*i $Id: predicate.mli,v 1.1.14.1 2005/01/21 17:14:11 herbelin Exp $ i*) (* Module [Pred]: sets over infinite ordered types with complement. *) diff --git a/lib/profile.mli b/lib/profile.mli index e0488de3..e8ce8994 100644 --- a/lib/profile.mli +++ b/lib/profile.mli @@ -6,7 +6,7 @@ (* * GNU Lesser General Public License Version 2.1 *) (************************************************************************) -(* $Id: profile.mli,v 1.7.16.1 2004/07/16 19:30:31 herbelin Exp $ *) +(*i $Id: profile.mli,v 1.7.16.2 2005/01/21 17:14:11 herbelin Exp $ i*) (*s This program is a small time and allocation profiler for Objective Caml *) diff --git a/lib/rtree.mli b/lib/rtree.mli index 0f854bc0..79b57586 100644 --- a/lib/rtree.mli +++ b/lib/rtree.mli @@ -6,7 +6,7 @@ (* * GNU Lesser General Public License Version 2.1 *) (************************************************************************) -(*i $Id: rtree.mli,v 1.2.8.1 2004/07/16 19:30:31 herbelin Exp $ i*) +(*i $Id: rtree.mli,v 1.2.8.2 2005/01/21 16:41:52 herbelin Exp $ i*) (* Type of regular tree with nodes labelled by values of type 'a *) type 'a t @@ -20,7 +20,7 @@ val mk_node : 'a -> 'a t array -> 'a t val mk_rec : 'a t array -> 'a t array (* [lift k t] increases of [k] the free parameters of [t]. Needed - to avoid captures when a tree appears under mk_rec *) + to avoid captures when a tree appears under [mk_rec] *) val lift : int -> 'a t -> 'a t val map : ('a -> 'b) -> 'a t -> 'b t diff --git a/lib/util.ml b/lib/util.ml index 37568f9b..b5470e58 100644 --- a/lib/util.ml +++ b/lib/util.ml @@ -6,7 +6,7 @@ (* * GNU Lesser General Public License Version 2.1 *) (************************************************************************) -(* $Id: util.ml,v 1.84.2.2 2004/07/16 20:43:46 herbelin Exp $ *) +(* $Id: util.ml,v 1.84.2.3 2004/07/29 15:00:04 herbelin Exp $ *) open Pp @@ -32,7 +32,8 @@ type 'a located = loc * 'a let anomaly_loc (loc,s,strm) = Stdpp.raise_with_loc loc (Anomaly (s,strm)) let user_err_loc (loc,s,strm) = Stdpp.raise_with_loc loc (UserError (s,strm)) let invalid_arg_loc (loc,s) = Stdpp.raise_with_loc loc (Invalid_argument s) -let join_loc (deb1,_) (_,fin2) = (deb1,fin2) +let join_loc (deb1,_ as loc1) (_,fin2 as loc2) = + if loc1 = dummy_loc or loc2 = dummy_loc then dummy_loc else (deb1,fin2) (* Like Exc_located, but specifies the outermost file read, the filename associated to the location of the error, and the error itself. *) diff --git a/library/declaremods.mli b/library/declaremods.mli index f229da1e..f896310a 100644 --- a/library/declaremods.mli +++ b/library/declaremods.mli @@ -6,7 +6,7 @@ (* * GNU Lesser General Public License Version 2.1 *) (************************************************************************) -(*i $Id: declaremods.mli,v 1.8.2.1 2004/07/16 19:30:35 herbelin Exp $ i*) +(*i $Id: declaremods.mli,v 1.8.2.2 2005/01/21 16:41:50 herbelin Exp $ i*) (*i*) open Util @@ -85,7 +85,7 @@ val end_library : (* [really_import_module mp] opens the module [mp] (in a Caml sense). - It modifies Nametab and performs the "open_object" function for + It modifies Nametab and performs the [open_object] function for every object of the module. *) val really_import_module : module_path -> unit @@ -109,7 +109,7 @@ val iter_all_segments : bool -> (object_name -> obj -> unit) -> unit val debug_print_modtab : unit -> Pp.std_ppcmds -(*val debug_print_modtypetab : unit -> Pp.std_ppcmds*) +(*i val debug_print_modtypetab : unit -> Pp.std_ppcmds i*) (* For translator *) val process_module_bindings : module_ident list -> diff --git a/library/lib.ml b/library/lib.ml index b9da6dea..a9f864ef 100644 --- a/library/lib.ml +++ b/library/lib.ml @@ -6,7 +6,7 @@ (* * GNU Lesser General Public License Version 2.1 *) (************************************************************************) -(* $Id: lib.ml,v 1.63.2.2 2004/07/16 19:30:35 herbelin Exp $ *) +(* $Id: lib.ml,v 1.63.2.3 2004/11/22 14:21:23 herbelin Exp $ *) open Pp open Util @@ -564,3 +564,15 @@ let library_part ref = else (* Theorem/Lemma outside its outer section of definition *) dir + + +let rec file_of_mp = function + | MPfile dir -> Some dir + | MPself _ -> Some (library_dp ()) + | MPbound _ -> None + | MPdot (mp,_) -> file_of_mp mp + +let file_part = function + | VarRef id -> anomaly "TODO"; + | ConstRef kn | ConstructRef ((kn,_),_) | IndRef (kn,_) -> + file_of_mp (modpath kn) diff --git a/library/lib.mli b/library/lib.mli index 8981754e..aa874470 100644 --- a/library/lib.mli +++ b/library/lib.mli @@ -6,7 +6,7 @@ (* * GNU Lesser General Public License Version 2.1 *) (************************************************************************) -(*i $Id: lib.mli,v 1.41.2.1 2004/07/16 19:30:35 herbelin Exp $ i*) +(*i $Id: lib.mli,v 1.41.2.3 2005/01/21 16:41:50 herbelin Exp $ i*) (*i*) open Util @@ -59,7 +59,7 @@ val add_leaf : identifier -> obj -> object_name val add_absolutely_named_leaf : object_name -> obj -> unit val add_anonymous_leaf : obj -> unit -(* this operation adds all objects with the same name and calls load_object +(* this operation adds all objects with the same name and calls [load_object] for each of them *) val add_leaves : identifier -> obj list -> object_name @@ -107,7 +107,7 @@ val start_modtype : module_ident -> module_path -> Summary.frozen -> object_prefix val end_modtype : module_ident -> object_name * object_prefix * Summary.frozen * library_segment -(* Lib.add_frozen_state must be called after each of the above functions *) +(* [Lib.add_frozen_state] must be called after each of the above functions *) (*s Compilation units *) @@ -121,6 +121,9 @@ val library_dp : unit -> dir_path (* Extract the library part of a name even if in a section *) val library_part : global_reference -> dir_path +(* Extract the library part of a name if not in a functor *) +val file_part : global_reference -> dir_path option + (*s Sections *) val open_section : identifier -> object_prefix diff --git a/library/libnames.mli b/library/libnames.mli index 6f05333c..a6055428 100644 --- a/library/libnames.mli +++ b/library/libnames.mli @@ -6,7 +6,7 @@ (* * GNU Lesser General Public License Version 2.1 *) (************************************************************************) -(*i $Id: libnames.mli,v 1.8.2.1 2004/07/16 19:30:35 herbelin Exp $ i*) +(*i $Id: libnames.mli,v 1.8.2.2 2005/01/21 16:41:51 herbelin Exp $ i*) (*i*) open Pp @@ -111,8 +111,8 @@ val qualid_of_dirpath : dir_path -> qualid val make_short_qualid : identifier -> qualid -(* Both names are passed to objects: a "semantic" kernel_name, which - can be substituted and a "syntactic" section_path which can be printed +(* Both names are passed to objects: a "semantic" [kernel_name], which + can be substituted and a "syntactic" [section_path] which can be printed *) type object_name = section_path * kernel_name @@ -121,7 +121,7 @@ type object_prefix = dir_path * (module_path * dir_path) val make_oname : object_prefix -> identifier -> object_name -(* to this type are mapped dir_path's in the nametab *) +(* to this type are mapped [dir_path]'s in the nametab *) type global_dir_reference = | DirOpenModule of object_prefix | DirOpenModtype of object_prefix diff --git a/library/libobject.mli b/library/libobject.mli index 8a3811e1..b9070f5d 100644 --- a/library/libobject.mli +++ b/library/libobject.mli @@ -6,7 +6,7 @@ (* * GNU Lesser General Public License Version 2.1 *) (************************************************************************) -(*i $Id: libobject.mli,v 1.9.8.1 2004/07/16 19:30:35 herbelin Exp $ i*) +(*i $Id: libobject.mli,v 1.9.8.2 2005/01/21 16:41:51 herbelin Exp $ i*) (*i*) open Names @@ -39,7 +39,7 @@ open Libnames Keep - the object is not substitutive, but survives module closing Anticipate - this is for objects which have to be explicitely - managed by the end_module function (like Require + managed by the [end_module] function (like Require and Read markers) The classification function is also an occasion for a cleanup diff --git a/library/library.ml b/library/library.ml index 0477a8f3..cbc8874a 100644 --- a/library/library.ml +++ b/library/library.ml @@ -6,7 +6,7 @@ (* * GNU Lesser General Public License Version 2.1 *) (************************************************************************) -(* $Id: library.ml,v 1.79.2.1 2004/07/16 19:30:36 herbelin Exp $ *) +(* $Id: library.ml,v 1.79.2.2 2004/11/17 14:01:26 herbelin Exp $ *) open Pp open Util @@ -169,8 +169,10 @@ let _ = Summary.survive_section = false } let find_library s = - try - CompilingLibraryMap.find s !libraries_table + CompilingLibraryMap.find s !libraries_table + +let try_find_library s = + try find_library s with Not_found -> error ("Unknown library " ^ (string_of_dirpath s)) @@ -250,7 +252,7 @@ let open_libraries export modl = (fun l m -> let subimport = List.fold_left - (fun l m -> remember_last_of_each l (find_library m)) + (fun l m -> remember_last_of_each l (try_find_library m)) l m.library_imports in remember_last_of_each subimport m) [] modl in @@ -261,7 +263,7 @@ let open_libraries export modl = (* import and export - synchronous operations*) let cache_import (_,(dir,export)) = - open_libraries export [find_library dir] + open_libraries export [try_find_library dir] let open_import i (_,(dir,_) as obj) = if i=1 then @@ -698,7 +700,7 @@ let check_required_library d = open Printf let mem s = - let m = find_library s in + let m = try_find_library s in h 0 (str (sprintf "%dk (cenv = %dk / seg = %dk)" (size_kb m) (size_kb m.library_compiled) (size_kb m.library_objects))) diff --git a/library/nameops.ml b/library/nameops.ml index ea40aae5..35b707a7 100644 --- a/library/nameops.ml +++ b/library/nameops.ml @@ -6,7 +6,7 @@ (* * GNU Lesser General Public License Version 2.1 *) (************************************************************************) -(* $Id: nameops.ml,v 1.21.2.1 2004/07/16 19:30:36 herbelin Exp $ *) +(* $Id: nameops.ml,v 1.21.2.2 2004/10/12 10:12:31 herbelin Exp $ *) open Pp open Util @@ -29,8 +29,8 @@ let cut_ident skip_quote s = (* [n'] is the position of the first non nullary digit *) let rec numpart n n' = if n = 0 then - error - ("The string " ^ s ^ " is not an identifier: it contains only digits or _") + (* ident made of _ and digits only [and ' if skip_quote]: don't cut it *) + slen else let c = Char.code (String.get s (n-1)) in if c = code_of_0 && n <> slen then diff --git a/library/nameops.mli b/library/nameops.mli index 4b7cecda..71dbf040 100644 --- a/library/nameops.mli +++ b/library/nameops.mli @@ -6,7 +6,7 @@ (* * GNU Lesser General Public License Version 2.1 *) (************************************************************************) -(* $Id: nameops.mli,v 1.12.2.1 2004/07/16 19:30:36 herbelin Exp $ *) +(*i $Id: nameops.mli,v 1.12.2.3 2005/01/21 17:14:10 herbelin Exp $ i*) open Names @@ -18,7 +18,7 @@ val make_ident : string -> int option -> identifier val repr_ident : identifier -> string * int option val atompart_of_id : identifier -> string (* remove trailing digits *) -val root_of_id : identifier -> identifier (* remove trailing digits, ' and _ *) +val root_of_id : identifier -> identifier (* remove trailing digits, $'$ and $\_$ *) val add_suffix : identifier -> string -> identifier val add_prefix : string -> identifier -> identifier diff --git a/library/nametab.mli b/library/nametab.mli index 3a0bd670..08a9d1bb 100755 --- a/library/nametab.mli +++ b/library/nametab.mli @@ -6,7 +6,7 @@ (* * GNU Lesser General Public License Version 2.1 *) (************************************************************************) -(*i $Id: nametab.mli,v 1.43.2.1 2004/07/16 19:30:36 herbelin Exp $ i*) +(*i $Id: nametab.mli,v 1.43.2.2 2005/01/21 16:41:51 herbelin Exp $ i*) (*i*) open Util @@ -33,13 +33,14 @@ open Libnames \item [locate : qualid -> object_reference] - Finds the object referred to by [qualid] or raises Not_found + Finds the object referred to by [qualid] or raises [Not_found] - \item [name_of] : object_reference -> user_name + \item [name_of : object_reference -> user_name] The [user_name] can be for example the shortest non ambiguous [qualid] or the [full_user_name] or [identifier]. Such a function can also have a local context argument. + \end{itemize} *) @@ -155,7 +156,7 @@ val id_of_global : global_reference -> identifier val pr_global_env : Idset.t -> global_reference -> std_ppcmds -(* The [shortest_qualid] functions given an object with user_name +(* The [shortest_qualid] functions given an object with [user_name] Coq.A.B.x, try to find the shortest among x, B.x, A.B.x and Coq.A.B.x that denotes the same object. *) diff --git a/parsing/argextend.ml4 b/parsing/argextend.ml4 index 5fa781ad..e6d9f99d 100644 --- a/parsing/argextend.ml4 +++ b/parsing/argextend.ml4 @@ -6,7 +6,7 @@ (* * GNU Lesser General Public License Version 2.1 *) (************************************************************************) -(* $Id: argextend.ml4,v 1.9.2.2 2004/07/16 19:30:37 herbelin Exp $ *) +(* $Id: argextend.ml4,v 1.9.2.4 2005/01/15 14:56:53 herbelin Exp $ *) open Genarg open Q_util @@ -33,6 +33,7 @@ let rec make_rawwit loc = function | QuantHypArgType -> <:expr< Genarg.rawwit_quant_hyp >> | TacticArgType -> <:expr< Genarg.rawwit_tactic >> | RedExprArgType -> <:expr< Genarg.rawwit_red_expr >> + | OpenConstrArgType -> <:expr< Genarg.rawwit_open_constr >> | CastedOpenConstrArgType -> <:expr< Genarg.rawwit_casted_open_constr >> | ConstrWithBindingsArgType -> <:expr< Genarg.rawwit_constr_with_bindings >> | BindingsArgType -> <:expr< Genarg.rawwit_bindings >> @@ -59,6 +60,7 @@ let rec make_globwit loc = function | ConstrMayEvalArgType -> <:expr< Genarg.globwit_constr_may_eval >> | TacticArgType -> <:expr< Genarg.globwit_tactic >> | RedExprArgType -> <:expr< Genarg.globwit_red_expr >> + | OpenConstrArgType -> <:expr< Genarg.globwit_open_constr >> | CastedOpenConstrArgType -> <:expr< Genarg.globwit_casted_open_constr >> | ConstrWithBindingsArgType -> <:expr< Genarg.globwit_constr_with_bindings >> | BindingsArgType -> <:expr< Genarg.globwit_bindings >> @@ -85,6 +87,7 @@ let rec make_wit loc = function | ConstrMayEvalArgType -> <:expr< Genarg.wit_constr_may_eval >> | TacticArgType -> <:expr< Genarg.wit_tactic >> | RedExprArgType -> <:expr< Genarg.wit_red_expr >> + | OpenConstrArgType -> <:expr< Genarg.wit_open_constr >> | CastedOpenConstrArgType -> <:expr< Genarg.wit_casted_open_constr >> | ConstrWithBindingsArgType -> <:expr< Genarg.wit_constr_with_bindings >> | BindingsArgType -> <:expr< Genarg.wit_bindings >> @@ -267,11 +270,14 @@ EXTEND declare_vernac_argument false loc s l ] ] ; argtype: - [ [ e = LIDENT -> fst (interp_entry_name loc e) - | e1 = LIDENT; "*"; e2 = LIDENT -> - let e1 = fst (interp_entry_name loc e1) in - let e2 = fst (interp_entry_name loc e2) in - PairArgType (e1, e2) ] ] + [ "2" RIGHTA + [ e1 = argtype; "*"; e2 = NEXT -> PairArgType (e1, e2) ] + | "1" + [ e = argtype; LIDENT "list" -> List0ArgType e + | e = argtype; LIDENT "option" -> OptArgType e ] + | "0" + [ e = LIDENT -> fst (interp_entry_name loc e) + | "("; e = argtype; ")" -> e ] ] ; argrule: [ [ "["; l = LIST0 genarg; "]"; "->"; "["; e = Pcaml.expr; "]" -> (l,e) ] ] @@ -286,4 +292,3 @@ EXTEND ] ] ; END - diff --git a/parsing/coqast.mli b/parsing/coqast.mli index 546725c0..0b1138f2 100644 --- a/parsing/coqast.mli +++ b/parsing/coqast.mli @@ -6,7 +6,7 @@ (* * GNU Lesser General Public License Version 2.1 *) (************************************************************************) -(*i $Id: coqast.mli,v 1.10.6.1 2004/07/16 19:30:37 herbelin Exp $ i*) +(*i $Id: coqast.mli,v 1.10.6.2 2005/01/21 16:42:36 herbelin Exp $ i*) (*i*) open Util @@ -43,9 +43,9 @@ val hcons_ast: val subst_ast: Names.substitution -> t -> t -(* +(*i val map_tactic_expr : (t -> t) -> (tactic_expr -> tactic_expr) -> tactic_expr -> tactic_expr val fold_tactic_expr : ('a -> t -> 'a) -> ('a -> tactic_expr -> 'a) -> 'a -> tactic_expr -> 'a val iter_tactic_expr : (tactic_expr -> unit) -> tactic_expr -> unit -*) +i*) diff --git a/parsing/doc.tex b/parsing/doc.tex new file mode 100644 index 00000000..68ab601c --- /dev/null +++ b/parsing/doc.tex @@ -0,0 +1,9 @@ + +\newpage +\section*{The Coq parsers and printers} + +\ocwsection \label{parsing} +This chapter describes the implementation of the \Coq\ parsers and printers. + +\bigskip +\begin{center}\epsfig{file=parsing.dep.ps}\end{center} diff --git a/parsing/egrammar.ml b/parsing/egrammar.ml index 9886bbf1..7a151c1a 100644 --- a/parsing/egrammar.ml +++ b/parsing/egrammar.ml @@ -6,10 +6,11 @@ (* * GNU Lesser General Public License Version 2.1 *) (************************************************************************) -(* $Id: egrammar.ml,v 1.48.2.1 2004/07/16 19:30:37 herbelin Exp $ *) +(* $Id: egrammar.ml,v 1.48.2.3 2004/11/26 19:37:59 herbelin Exp $ *) open Pp open Util +open Ppextend open Extend open Pcoq open Topconstr @@ -20,10 +21,11 @@ open Nameops (* State of the grammar extensions *) +type notation_grammar = + int * Gramext.g_assoc option * notation * prod_item list * int list option + type all_grammar_command = - | Notation of - (int * Gramext.g_assoc option * notation * prod_item list * - int list option) + | Notation of (precedence * tolerability list) * notation_grammar | Grammar of grammar_command | TacticGrammar of (string * (string * grammar_production list) * @@ -415,7 +417,7 @@ let add_tactic_entries gl = let extend_grammar gram = (match gram with - | Notation a -> extend_constr_notation a + | Notation (_,a) -> extend_constr_notation a | Grammar g -> extend_grammar_rules g | TacticGrammar l -> add_tactic_entries l); grammar_state := gram :: !grammar_state @@ -428,6 +430,12 @@ let reset_extend_grammars_v8 () = List.iter (fun (s,gl) -> extend_tactic_grammar s gl) te; List.iter (fun (s,gl) -> extend_vernac_command_grammar s gl) tv +let recover_notation_grammar ntn prec = + let l = map_succeed (function + | Notation (prec',(_,_,ntn',_,_ as x)) when prec = prec' & ntn = ntn' -> x + | _ -> failwith "") !grammar_state in + assert (List.length l = 1); + List.hd l (* Summary functions: the state of the lexer is included in that of the parser. Because the grammar affects the set of keywords when adding or removing diff --git a/parsing/egrammar.mli b/parsing/egrammar.mli index c601c5fc..0009b4b6 100644 --- a/parsing/egrammar.mli +++ b/parsing/egrammar.mli @@ -6,7 +6,7 @@ (* * GNU Lesser General Public License Version 2.1 *) (************************************************************************) -(*i $Id: egrammar.mli,v 1.14.2.2 2004/07/16 19:30:37 herbelin Exp $ i*) +(*i $Id: egrammar.mli,v 1.14.2.5 2004/11/27 09:25:44 herbelin Exp $ i*) (*i*) open Util @@ -14,14 +14,16 @@ open Topconstr open Ast open Coqast open Vernacexpr +open Ppextend open Extend open Rawterm (*i*) +type notation_grammar = + int * Gramext.g_assoc option * notation * prod_item list * int list option + type all_grammar_command = - | Notation of - (int * Gramext.g_assoc option * notation * prod_item list * - int list option) + | Notation of (precedence * tolerability list) * notation_grammar | Grammar of grammar_command | TacticGrammar of (string * (string * grammar_production list) * @@ -52,3 +54,6 @@ val subst_all_grammar_command : val interp_entry_name : string -> string -> entry_type * Token.t Gramext.g_symbol + +val recover_notation_grammar : + notation -> (precedence * tolerability list) -> notation_grammar diff --git a/parsing/esyntax.mli b/parsing/esyntax.mli index e05e1ca4..88d1a0e2 100644 --- a/parsing/esyntax.mli +++ b/parsing/esyntax.mli @@ -6,7 +6,7 @@ (* * GNU Lesser General Public License Version 2.1 *) (************************************************************************) -(*i $Id: esyntax.mli,v 1.10.2.1 2004/07/16 19:30:37 herbelin Exp $ i*) +(*i $Id: esyntax.mli,v 1.10.2.2 2005/01/21 16:42:36 herbelin Exp $ i*) (*i*) open Pp @@ -48,16 +48,14 @@ module Ppprim : val declare_primitive_printer : string -> scope_name -> primitive_printer -> unit -(* +(*i val declare_infix_symbol : Libnames.section_path -> string -> unit -*) +i*) (* Generic printing functions *) -(* +(*i val token_printer: std_printer -> std_printer -*) -(* val print_syntax_entry : string -> unparsing_subfunction -> Ast.env -> Ast.astpat syntax_entry -> std_ppcmds -*) +i*) val genprint : std_printer -> unparsing_subfunction diff --git a/parsing/extend.mli b/parsing/extend.mli index 761d0e04..c5417649 100644 --- a/parsing/extend.mli +++ b/parsing/extend.mli @@ -6,7 +6,7 @@ (* * GNU Lesser General Public License Version 2.1 *) (************************************************************************) -(*i $Id: extend.mli,v 1.19.2.1 2004/07/16 19:30:37 herbelin Exp $ i*) +(*i $Id: extend.mli,v 1.19.2.2 2005/01/21 16:42:37 herbelin Exp $ i*) (*i*) open Pp @@ -112,10 +112,11 @@ type 'pat unparsing_hunk = | UNP_FNL | UNP_SYMBOLIC of string option * string * 'pat unparsing_hunk -(*val subst_unparsing_hunk : +(*i +val subst_unparsing_hunk : Names.substitution -> (Names.substitution -> 'pat -> 'pat) -> 'pat unparsing_hunk -> 'pat unparsing_hunk -*) +i*) (* Checks if the precedence of the parent printer (None means the highest precedence), and the child's one, follow the given diff --git a/parsing/g_constr.ml4 b/parsing/g_constr.ml4 index 7b0f7da2..80dc69f1 100644 --- a/parsing/g_constr.ml4 +++ b/parsing/g_constr.ml4 @@ -6,7 +6,7 @@ (* * GNU Lesser General Public License Version 2.1 *) (************************************************************************) -(* $Id: g_constr.ml4,v 1.52.2.1 2004/07/16 19:30:38 herbelin Exp $ *) +(* $Id: g_constr.ml4,v 1.52.2.2 2004/11/17 12:48:35 herbelin Exp $ *) open Pcoq open Constr @@ -23,7 +23,7 @@ let constr_kw = ":"; "("; ")"; "["; "]"; "{"; "}"; ","; ";"; "->"; "="; ":="; "!"; "::"; "<:"; ":<"; "=>"; "<"; ">"; "|"; "?"; "/"; "<->"; "\\/"; "/\\"; "`"; "``"; "&"; "*"; "+"; "@"; "^"; "#"; "-"; - "~"; "'"; "<<"; ">>"; "<>" + "~"; "'"; "<<"; ">>"; "<>"; ".." ] let _ = if !Options.v7 then diff --git a/parsing/g_constrnew.ml4 b/parsing/g_constrnew.ml4 index 18dc5683..adc26532 100644 --- a/parsing/g_constrnew.ml4 +++ b/parsing/g_constrnew.ml4 @@ -6,7 +6,7 @@ (* * GNU Lesser General Public License Version 2.1 *) (************************************************************************) -(* $Id: g_constrnew.ml4,v 1.41.2.1 2004/07/16 19:30:38 herbelin Exp $ *) +(* $Id: g_constrnew.ml4,v 1.41.2.2 2004/11/17 12:48:35 herbelin Exp $ *) open Pcoq open Constr @@ -22,7 +22,7 @@ open Util let constr_kw = [ "forall"; "fun"; "match"; "fix"; "cofix"; "with"; "in"; "for"; "end"; "as"; "let"; "if"; "then"; "else"; "return"; - "Prop"; "Set"; "Type"; ".("; "_" ] + "Prop"; "Set"; "Type"; ".("; "_"; ".." ] let _ = if not !Options.v7 then diff --git a/parsing/g_natsyntax.ml b/parsing/g_natsyntax.ml index e43142ba..46ef81f3 100644 --- a/parsing/g_natsyntax.ml +++ b/parsing/g_natsyntax.ml @@ -6,7 +6,7 @@ (* * GNU Lesser General Public License Version 2.1 *) (************************************************************************) -(* $Id: g_natsyntax.ml,v 1.19.2.1 2004/07/16 19:30:39 herbelin Exp $ *) +(* $Id: g_natsyntax.ml,v 1.19.2.2 2004/09/08 13:47:51 herbelin Exp $ *) (* This file to allow writing (3) for (S (S (S O))) and still write (S y) for (S y) *) @@ -125,7 +125,7 @@ let nat_of_int dloc n = match n with | POS n -> if less_than (of_string "5000") n & Options.is_verbose () then begin - warning ("You may experiment stack overflow and segmentation fault\ + warning ("You may experience stack overflow and segmentation fault\ \nwhile parsing numbers in nat greater than 5000"); flush_all () end; diff --git a/parsing/g_tactic.ml4 b/parsing/g_tactic.ml4 index 2e067215..a1559572 100644 --- a/parsing/g_tactic.ml4 +++ b/parsing/g_tactic.ml4 @@ -6,7 +6,7 @@ (* * GNU Lesser General Public License Version 2.1 *) (************************************************************************) -(* $Id: g_tactic.ml4,v 1.83.2.2 2004/07/16 19:30:39 herbelin Exp $ *) +(* $Id: g_tactic.ml4,v 1.83.2.4 2005/01/15 14:56:53 herbelin Exp $ *) open Pp open Ast @@ -42,7 +42,7 @@ let join_to_constr loc c2 = (fst loc), snd (Topconstr.constr_loc c2) if !Options.v7 then GEXTEND Gram GLOBAL: simple_tactic constrarg bindings constr_with_bindings - quantified_hypothesis red_expr int_or_var castedopenconstr + quantified_hypothesis red_expr int_or_var castedopenconstr open_constr simple_intropattern; int_or_var: @@ -96,8 +96,11 @@ GEXTEND Gram | IDENT "Check"; c = constr -> ConstrTypeOf c | c = constr -> ConstrTerm c ] ] ; + open_constr: + [ [ c = constr -> ((),c) ] ] + ; castedopenconstr: - [ [ c = constr -> c ] ] + [ [ c = constr -> ((),c) ] ] ; induction_arg: [ [ n = natural -> ElimOnAnonHyp n @@ -180,7 +183,7 @@ GEXTEND Gram | IDENT "Unfold"; ul = LIST1 unfold_occ -> Unfold ul | IDENT "Fold"; cl = LIST1 constr -> Fold cl | IDENT "Pattern"; pl = LIST1 pattern_occ -> Pattern pl - | s = IDENT; c = constr -> ExtraRedExpr (s,c) ] ] + | s = IDENT -> ExtraRedExpr s ] ] ; hypident: [ [ id = id_or_meta -> id,[],(InHyp,ref None) diff --git a/parsing/g_tacticnew.ml4 b/parsing/g_tacticnew.ml4 index 2070b40e..643be98d 100644 --- a/parsing/g_tacticnew.ml4 +++ b/parsing/g_tacticnew.ml4 @@ -6,7 +6,7 @@ (* * GNU Lesser General Public License Version 2.1 *) (************************************************************************) -(* $Id: g_tacticnew.ml4,v 1.35.2.2 2004/07/16 19:30:39 herbelin Exp $ *) +(* $Id: g_tacticnew.ml4,v 1.35.2.6 2005/01/15 14:56:53 herbelin Exp $ *) open Pp open Ast @@ -78,7 +78,7 @@ open Tactic let mk_fix_tac (loc,id,bl,ann,ty) = let n = match bl,ann with - [([_],_)], None -> 0 + [([_],_)], None -> 1 | _, Some x -> let ids = List.map snd (List.flatten (List.map fst bl)) in (try list_index (snd x) ids @@ -109,7 +109,8 @@ let join_to_constr loc c2 = (fst loc), snd (Topconstr.constr_loc c2) if not !Options.v7 then GEXTEND Gram GLOBAL: simple_tactic constr_with_bindings quantified_hypothesis - bindings red_expr int_or_var castedopenconstr simple_intropattern; + bindings red_expr int_or_var open_constr castedopenconstr + simple_intropattern; int_or_var: [ [ n = integer -> Genarg.ArgArg n @@ -128,8 +129,11 @@ GEXTEND Gram | id = METAIDENT -> MetaId (loc,id) ] ] ; + open_constr: + [ [ c = constr -> ((),c) ] ] + ; castedopenconstr: - [ [ c = constr -> c ] ] + [ [ c = constr -> ((),c) ] ] ; induction_arg: [ [ n = natural -> ElimOnAnonHyp n @@ -212,7 +216,7 @@ GEXTEND Gram | IDENT "unfold"; ul = LIST1 unfold_occ -> Unfold ul | IDENT "fold"; cl = LIST1 constr -> Fold cl | IDENT "pattern"; pl = LIST1 pattern_occ -> Pattern pl - | s = IDENT; c = constr -> ExtraRedExpr (s,c) ] ] + | s = IDENT; OPT [ (* compat V8.0pl1 *) constr ] -> ExtraRedExpr s ] ] ; hypident: [ [ id = id_or_meta -> id,(InHyp,ref None) diff --git a/parsing/g_vernac.ml4 b/parsing/g_vernac.ml4 index e2eecf55..87183e18 100644 --- a/parsing/g_vernac.ml4 +++ b/parsing/g_vernac.ml4 @@ -6,7 +6,7 @@ (* * GNU Lesser General Public License Version 2.1 *) (************************************************************************) -(* $Id: g_vernac.ml4,v 1.93.2.2 2004/07/16 20:51:12 herbelin Exp $ *) +(* $Id: g_vernac.ml4,v 1.93.2.3 2004/10/12 10:11:28 herbelin Exp $ *) open Names open Topconstr @@ -189,8 +189,8 @@ GEXTEND Gram ; gallina: (* Definition, Theorem, Variable, Axiom, ... *) - [ [ thm = thm_token; id = identref; ":"; c = constr -> - VernacStartTheoremProof (thm, id, ([], c), false, (fun _ _ -> ())) + [ [ thm = thm_token; id = identref; bl = binders_list; ":"; c = constr -> + VernacStartTheoremProof (thm, id, (bl, c), false, (fun _ _ -> ())) | (f,d) = def_token; id = identref; b = def_body -> VernacDefinition (d, id, b, f) | stre = assumption_token; bl = ne_params_list -> diff --git a/parsing/g_vernacnew.ml4 b/parsing/g_vernacnew.ml4 index 8a99a51e..976cc259 100644 --- a/parsing/g_vernacnew.ml4 +++ b/parsing/g_vernacnew.ml4 @@ -6,7 +6,7 @@ (* * GNU Lesser General Public License Version 2.1 *) (************************************************************************) -(* $Id: g_vernacnew.ml4,v 1.63.2.1 2004/07/16 19:30:39 herbelin Exp $ *) +(* $Id: g_vernacnew.ml4,v 1.63.2.2 2004/10/12 10:10:29 herbelin Exp $ *) open Pp open Util @@ -93,9 +93,8 @@ GEXTEND Gram gallina: (* Definition, Theorem, Variable, Axiom, ... *) - [ [ thm = thm_token; id = identref; (* bl = LIST0 binder; *) ":"; + [ [ thm = thm_token; id = identref; bl = LIST0 binder_let; ":"; c = lconstr -> - let bl = [] in VernacStartTheoremProof (thm, id, (bl, c), false, (fun _ _ -> ())) | (f,d) = def_token; id = identref; b = def_body -> VernacDefinition (d, id, b, f) diff --git a/parsing/g_zsyntax.ml b/parsing/g_zsyntax.ml index 27eead96..2d8d2ddd 100644 --- a/parsing/g_zsyntax.ml +++ b/parsing/g_zsyntax.ml @@ -6,7 +6,7 @@ (* * GNU Lesser General Public License Version 2.1 *) (************************************************************************) -(* $Id: g_zsyntax.ml,v 1.16.2.1 2004/07/16 19:30:39 herbelin Exp $ *) +(* $Id: g_zsyntax.ml,v 1.16.2.2 2004/11/10 13:00:44 herbelin Exp $ *) open Coqast open Pcoq @@ -197,11 +197,14 @@ let rec pat_pos_of_bignat dloc x name = | (q,true) -> PatCstr (dloc,path_of_xH,[],name) +let error_non_positive dloc = + user_err_loc (dloc, "interp_positive", + str "No non-positive numbers in type \"positive\"!") + let pat_interp_positive dloc = function - | POS n -> pat_pos_of_bignat dloc n - | NEG n -> - user_err_loc (dloc, "interp_positive", - str "No negative number in type \"positive\"!") + | NEG n -> error_non_positive dloc + | POS n -> + if is_nonzero n then pat_pos_of_bignat dloc n else error_non_positive dloc (**********************************************************************) (* Printing positive via scopes *) diff --git a/parsing/pcoq.ml4 b/parsing/pcoq.ml4 index cda482af..b5ab2387 100644 --- a/parsing/pcoq.ml4 +++ b/parsing/pcoq.ml4 @@ -6,7 +6,7 @@ (* * GNU Lesser General Public License Version 2.1 *) (************************************************************************) -(*i $Id: pcoq.ml4,v 1.80.2.1 2004/07/16 19:30:40 herbelin Exp $ i*) +(*i $Id: pcoq.ml4,v 1.80.2.3 2005/01/15 14:56:53 herbelin Exp $ i*) open Pp open Util @@ -371,6 +371,8 @@ module Tactic = (* Entries that can be refered via the string -> Gram.Entry.e table *) (* Typically for tactic user extensions *) + let open_constr = + make_gen_entry utactic rawwit_open_constr "open_constr" let castedopenconstr = make_gen_entry utactic rawwit_casted_open_constr "castedopenconstr" let constr_with_bindings = @@ -774,7 +776,9 @@ let is_self from e = let is_binder_level from e = match from, e with - ETConstr(200,()), ETConstr(NumLevel 200,_) -> not !Options.v7 + ETConstr(200,()), + ETConstr(NumLevel 200,(BorderProd(false,_)|InternalProd)) -> + not !Options.v7 | _ -> false let rec symbol_of_production assoc from forpat typ = @@ -799,5 +803,3 @@ let rec symbol_of_production assoc from forpat typ = | (eobj,Some None,_) -> Gramext.Snext | (eobj,Some (Some (lev,cur)),_) -> Gramext.Snterml (Gram.Entry.obj eobj,constr_prod_level assoc cur lev) - - diff --git a/parsing/pcoq.mli b/parsing/pcoq.mli index 5c6c8354..361137f4 100644 --- a/parsing/pcoq.mli +++ b/parsing/pcoq.mli @@ -6,7 +6,7 @@ (* * GNU Lesser General Public License Version 2.1 *) (************************************************************************) -(*i $Id: pcoq.mli,v 1.63.2.1 2004/07/16 19:30:40 herbelin Exp $ i*) +(*i $Id: pcoq.mli,v 1.63.2.2 2005/01/15 14:56:53 herbelin Exp $ i*) open Util open Names @@ -156,7 +156,8 @@ module Module : module Tactic : sig open Rawterm - val castedopenconstr : constr_expr Gram.Entry.e + val open_constr : open_constr_expr Gram.Entry.e + val castedopenconstr : open_constr_expr Gram.Entry.e val constr_with_bindings : constr_expr with_bindings Gram.Entry.e val bindings : constr_expr bindings Gram.Entry.e val constrarg : (constr_expr,reference) may_eval Gram.Entry.e diff --git a/parsing/ppconstr.ml b/parsing/ppconstr.ml index 6a5242e8..ddf008cb 100644 --- a/parsing/ppconstr.ml +++ b/parsing/ppconstr.ml @@ -6,7 +6,7 @@ (* * GNU Lesser General Public License Version 2.1 *) (************************************************************************) -(* $Id: ppconstr.ml,v 1.32.2.1 2004/07/16 19:30:40 herbelin Exp $ *) +(* $Id: ppconstr.ml,v 1.32.2.2 2004/12/29 10:17:11 herbelin Exp $ *) (*i*) open Ast @@ -370,8 +370,7 @@ let pr_red_expr (pr_constr,pr_ref) = function | Fold l -> hov 1 (str "Fold" ++ prlist (pr_arg pr_constr) l) | Pattern l -> hov 1 (str "Pattern " ++ prlist (pr_occurrences pr_constr) l) | Red true -> error "Shouldn't be accessible from user" - | ExtraRedExpr (s,c) -> - hov 1 (str s ++ pr_arg pr_constr c) + | ExtraRedExpr s -> str s let rec pr_may_eval pr pr2 = function | ConstrEval (r,c) -> diff --git a/parsing/ppconstr.mli b/parsing/ppconstr.mli index d238b371..039cd745 100644 --- a/parsing/ppconstr.mli +++ b/parsing/ppconstr.mli @@ -6,7 +6,7 @@ (* * GNU Lesser General Public License Version 2.1 *) (************************************************************************) -(* $Id: ppconstr.mli,v 1.7.2.1 2004/07/16 19:30:40 herbelin Exp $ *) +(*i $Id: ppconstr.mli,v 1.7.2.2 2005/01/21 17:19:37 herbelin Exp $ i*) open Pp open Environ diff --git a/parsing/pptactic.ml b/parsing/pptactic.ml index 95e134ae..1d7a9428 100644 --- a/parsing/pptactic.ml +++ b/parsing/pptactic.ml @@ -6,7 +6,7 @@ (* * GNU Lesser General Public License Version 2.1 *) (************************************************************************) -(* $Id: pptactic.ml,v 1.54.2.2 2004/07/16 19:30:40 herbelin Exp $ *) +(* $Id: pptactic.ml,v 1.54.2.3 2005/01/15 14:56:53 herbelin Exp $ *) open Pp open Names @@ -272,8 +272,9 @@ let rec pr_raw_generic prc prlc prtac prref x = pr_arg (pr_red_expr (prc,prref)) (out_gen rawwit_red_expr x) | TacticArgType -> pr_arg prtac (out_gen rawwit_tactic x) + | OpenConstrArgType -> pr_arg prc (snd (out_gen rawwit_open_constr x)) | CastedOpenConstrArgType -> - pr_arg prc (out_gen rawwit_casted_open_constr x) + pr_arg prc (snd (out_gen rawwit_casted_open_constr x)) | ConstrWithBindingsArgType -> pr_arg (pr_with_bindings prc prlc) (out_gen rawwit_constr_with_bindings x) | BindingsArgType -> @@ -320,8 +321,9 @@ let rec pr_glob_generic prc prlc prtac x = pr_arg (pr_red_expr (prc,pr_or_var (pr_and_short_name pr_evaluable_reference))) (out_gen globwit_red_expr x) | TacticArgType -> pr_arg prtac (out_gen globwit_tactic x) + | OpenConstrArgType -> pr_arg prc (snd (out_gen globwit_open_constr x)) | CastedOpenConstrArgType -> - pr_arg prc (out_gen globwit_casted_open_constr x) + pr_arg prc (snd (out_gen globwit_casted_open_constr x)) | ConstrWithBindingsArgType -> pr_arg (pr_with_bindings prc prlc) (out_gen globwit_constr_with_bindings x) | BindingsArgType -> @@ -367,6 +369,7 @@ let rec pr_generic prc prlc prtac x = | RedExprArgType -> pr_arg (pr_red_expr (prc,pr_evaluable_reference)) (out_gen wit_red_expr x) | TacticArgType -> pr_arg prtac (out_gen wit_tactic x) + | OpenConstrArgType -> pr_arg prc (snd (out_gen wit_open_constr x)) | CastedOpenConstrArgType -> pr_arg prc (snd (out_gen wit_casted_open_constr x)) | ConstrWithBindingsArgType -> diff --git a/parsing/pptactic.mli b/parsing/pptactic.mli index a80ec6fb..b9cf7401 100644 --- a/parsing/pptactic.mli +++ b/parsing/pptactic.mli @@ -6,7 +6,7 @@ (* * GNU Lesser General Public License Version 2.1 *) (************************************************************************) -(* $Id: pptactic.mli,v 1.9.2.1 2004/07/16 19:30:40 herbelin Exp $ *) +(*i $Id: pptactic.mli,v 1.9.2.2 2005/01/21 17:19:37 herbelin Exp $ i*) open Pp open Genarg diff --git a/parsing/printer.mli b/parsing/printer.mli index b4cd87b0..c44be124 100644 --- a/parsing/printer.mli +++ b/parsing/printer.mli @@ -6,7 +6,7 @@ (* * GNU Lesser General Public License Version 2.1 *) (************************************************************************) -(*i $Id: printer.mli,v 1.26.2.1 2004/07/16 19:30:41 herbelin Exp $ i*) +(*i $Id: printer.mli,v 1.26.2.2 2005/01/21 16:42:37 herbelin Exp $ i*) (*i*) open Pp @@ -22,9 +22,9 @@ open Termops (*i*) (* These are the entry points for printing terms, context, tac, ... *) -(* +(*i val gentacpr : Tacexpr.raw_tactic_expr -> std_ppcmds -*) +i*) val prterm_env : env -> constr -> std_ppcmds val prterm_env_at_top : env -> constr -> std_ppcmds diff --git a/parsing/q_coqast.ml4 b/parsing/q_coqast.ml4 index aa0fce9d..a278e3d5 100644 --- a/parsing/q_coqast.ml4 +++ b/parsing/q_coqast.ml4 @@ -6,7 +6,7 @@ (* * GNU Lesser General Public License Version 2.1 *) (************************************************************************) -(* $Id: q_coqast.ml4,v 1.47.2.2 2004/07/16 20:51:12 herbelin Exp $ *) +(* $Id: q_coqast.ml4,v 1.47.2.5 2005/01/15 14:56:54 herbelin Exp $ *) open Util open Names @@ -21,8 +21,12 @@ let purge_str s = let anti loc x = let e = - let loc = unloc loc in - let loc = make_loc (1, snd loc - fst loc) in <:expr< $lid:purge_str x$ >> + let loc = + ifdef OCAML_308 then + loc + else + (1, snd loc - fst loc) + in <:expr< $lid:purge_str x$ >> in <:expr< $anti:e$ >> @@ -244,9 +248,8 @@ let mlexpr_of_red_expr = function | Rawterm.Pattern l -> let f = mlexpr_of_list mlexpr_of_occ_constr in <:expr< Rawterm.Pattern $f l$ >> - | Rawterm.ExtraRedExpr (s,c) -> - let l = mlexpr_of_constr c in - <:expr< Rawterm.ExtraRedExpr $mlexpr_of_string s$ $l$ >> + | Rawterm.ExtraRedExpr s -> + <:expr< Rawterm.ExtraRedExpr $mlexpr_of_string s$ >> let rec mlexpr_of_argtype loc = function | Genarg.BoolArgType -> <:expr< Genarg.BoolArgType >> @@ -259,6 +262,7 @@ let rec mlexpr_of_argtype loc = function | Genarg.HypArgType -> <:expr< Genarg.HypArgType >> | Genarg.StringArgType -> <:expr< Genarg.StringArgType >> | Genarg.QuantHypArgType -> <:expr< Genarg.QuantHypArgType >> + | Genarg.OpenConstrArgType -> <:expr< Genarg.OpenConstrArgType >> | Genarg.CastedOpenConstrArgType -> <:expr< Genarg.CastedOpenConstrArgType >> | Genarg.ConstrWithBindingsArgType -> <:expr< Genarg.ConstrWithBindingsArgType >> | Genarg.BindingsArgType -> <:expr< Genarg.BindingsArgType >> diff --git a/pretyping/cases.ml b/pretyping/cases.ml index 2126f015..378eee30 100644 --- a/pretyping/cases.ml +++ b/pretyping/cases.ml @@ -6,7 +6,7 @@ (* * GNU Lesser General Public License Version 2.1 *) (************************************************************************) -(* $Id: cases.ml,v 1.111.2.1 2004/07/16 19:30:43 herbelin Exp $ *) +(* $Id: cases.ml,v 1.111.2.4 2004/12/09 20:07:01 herbelin Exp $ *) open Util open Names @@ -262,9 +262,10 @@ type tomatch_stack = tomatch_status list (* The type [predicate_signature] types the terms to match and the rhs: - - [PrLetIn (n,dep,pred)] types a pushed term ([Pushed]), if dep is true, - the term is dependent, if n<>0 then the type of the pushed term is - necessarily inductive with n real arguments. Otherwise, it may be + - [PrLetIn (names,dep,pred)] types a pushed term ([Pushed]), + if dep<>Anonymous, the term is dependent, let n=|names|, if + n<>0 then the type of the pushed term is necessarily an + inductive with n real arguments. Otherwise, it may be non inductive, or inductive without real arguments, or inductive originating from a subterm in which case real args are not dependent; it accounts for n+1 binders if dep or n binders if not dep @@ -274,7 +275,7 @@ type tomatch_stack = tomatch_status list *) type predicate_signature = - | PrLetIn of (int * bool) * predicate_signature + | PrLetIn of (name list * name) * predicate_signature | PrProd of predicate_signature | PrCcl of constr @@ -408,12 +409,11 @@ let inh_coerce_to_ind isevars env tmloc ty tyi = let hole_source = match tmloc with | Some loc -> fun i -> (loc, TomatchTypeParameter (tyi,i)) | None -> fun _ -> (dummy_loc, InternalHole) in - let (_,evarl,_) = + let (evarl,_) = List.fold_right - (fun (na,ty) (env,evl,n) -> - (push_rel (na,None,ty) env, - (new_isevar isevars env (hole_source n) ty)::evl,n+1)) - ntys (env,[],1) in + (fun (na,ty) (evl,n) -> + (new_isevar isevars env (hole_source n) (substl evl ty))::evl,n+1) + ntys ([],1) in let expected_typ = applist (mkInd tyi,evarl) in (* devrait être indifférent d'exiger leq ou pas puisque pour un inductif cela doit être égal *) @@ -976,10 +976,17 @@ let rec map_predicate f k = function | PrCcl ccl -> PrCcl (f k ccl) | PrProd pred -> PrProd (map_predicate f (k+1) pred) - | PrLetIn ((nargs,dep as tm),pred) -> - let k' = nargs + (if dep then 1 else 0) in + | PrLetIn ((names,dep as tm),pred) -> + let k' = List.length names + (if dep<>Anonymous then 1 else 0) in PrLetIn (tm, map_predicate f (k+k') pred) +let rec noccurn_predicate k = function + | PrCcl ccl -> noccurn k ccl + | PrProd pred -> noccurn_predicate (k+1) pred + | PrLetIn ((names,dep as tm),pred) -> + let k' = List.length names + (if dep<>Anonymous then 1 else 0) in + noccurn_predicate (k+k') pred + let liftn_predicate n = map_predicate (liftn n) let lift_predicate n = liftn_predicate n 1 @@ -998,12 +1005,12 @@ let subst_predicate (args,copt) pred = let specialize_predicate_var (cur,typ) = function | PrProd _ | PrCcl _ -> anomaly "specialize_predicate_var: a pattern-variable must be pushed" - | PrLetIn ((0,dep),pred) -> - subst_predicate ([],if dep then Some cur else None) pred + | PrLetIn (([],dep),pred) -> + subst_predicate ([],if dep<>Anonymous then Some cur else None) pred | PrLetIn ((_,dep),pred) -> (match typ with | IsInd (_,IndType (_,realargs)) -> - subst_predicate (realargs,if dep then Some cur else None) pred + subst_predicate (realargs,if dep<>Anonymous then Some cur else None) pred | _ -> anomaly "specialize_predicate_var") let ungeneralize_predicate = function @@ -1020,9 +1027,9 @@ let ungeneralize_predicate = function (* then we have to replace x by x' in t(x) and y by y' in P *) (*****************************************************************************) let generalize_predicate c ny d = function - | PrLetIn ((nargs,dep as tm),pred) -> - if not dep then anomaly "Undetected dependency"; - let p = nargs + 1 in + | PrLetIn ((names,dep as tm),pred) -> + if dep=Anonymous then anomaly "Undetected dependency"; + let p = List.length names + 1 in let pred = lift_predicate 1 pred in let pred = regeneralize_index_predicate (ny+p+1) pred in PrLetIn (tm, PrProd pred) @@ -1038,18 +1045,18 @@ let rec extract_predicate l = function | PrProd pred, Abstract d'::tms -> let d' = map_rel_declaration (lift (List.length l)) d' in substl l (mkProd_or_LetIn d' (extract_predicate [] (pred,tms))) - | PrLetIn ((0,dep),pred), Pushed ((cur,_),_)::tms -> - extract_predicate (if dep then cur::l else l) (pred,tms) + | PrLetIn (([],dep),pred), Pushed ((cur,_),_)::tms -> + extract_predicate (if dep<>Anonymous then cur::l else l) (pred,tms) | PrLetIn ((_,dep),pred), Pushed ((cur,IsInd (_,(IndType(_,realargs)))),_)::tms -> let l = List.rev realargs@l in - extract_predicate (if dep then cur::l else l) (pred,tms) + extract_predicate (if dep<>Anonymous then cur::l else l) (pred,tms) | PrCcl ccl, [] -> substl l ccl | _ -> anomaly"extract_predicate: predicate inconsistent with terms to match" let abstract_predicate env sigma indf cur tms = function | (PrProd _ | PrCcl _) -> anomaly "abstract_predicate: must be some LetIn" - | PrLetIn ((nrealargs,dep),pred) -> + | PrLetIn ((names,dep),pred) -> let sign = make_arity_signature env true indf in (* n is the number of real args + 1 *) let n = List.length sign in @@ -1061,18 +1068,24 @@ let abstract_predicate env sigma indf cur tms = function (* Depending on whether the predicate is dependent or not, and has real args or not, we lift it to make room for [sign] *) (* Even if not intrinsically dep, we move the predicate into a dep one *) - let k = - if nrealargs = 0 & n <> 1 then - (* Real args were not considered *) if dep then n-1 else n + let sign,k = + if names = [] & n <> 1 then + (* Real args were not considered *) + (if dep<>Anonymous then + ((let (_,c,t) = List.hd sign in (dep,c,t)::List.tl sign),n-1) + else + (sign,n)) else - (* Real args are OK *) if dep then 0 else 1 in + (* Real args are OK *) + (List.map2 (fun na (_,c,t) -> (na,c,t)) (dep::names) sign, + if dep<>Anonymous then 0 else 1) in let pred = lift_predicate k pred in let pred = extract_predicate [] (pred,tms) in (true, it_mkLambda_or_LetIn_name env pred sign) let rec known_dependent = function | None -> false - | Some (PrLetIn ((_,dep),_)) -> dep + | Some (PrLetIn ((_,dep),_)) -> dep<>Anonymous | Some (PrCcl _) -> false | Some (PrProd _) -> anomaly "known_dependent: can only be used when patterns remain" @@ -1084,10 +1097,13 @@ let rec known_dependent = function let expand_arg n alreadydep (na,t) deps (k,pred) = (* current can occur in pred even if the original problem is not dependent *) - let dep = deps <> [] || alreadydep in - let pred = if dep then pred else lift_predicate (-1) pred in + let dep = + if alreadydep<>Anonymous then alreadydep + else if deps = [] && noccurn_predicate 1 pred then Anonymous + else Name (id_of_string "x") in + let pred = if dep<>Anonymous then pred else lift_predicate (-1) pred in (* There is no dependency in realargs for subpattern *) - (k-1, PrLetIn ((0,dep), pred)) + (k-1, PrLetIn (([],dep), pred)) (*****************************************************************************) @@ -1107,14 +1123,15 @@ let expand_arg n alreadydep (na,t) deps (k,pred) = let specialize_predicate tomatchs deps cs = function | (PrProd _ | PrCcl _) -> anomaly "specialize_predicate: a matched pattern must be pushed" - | PrLetIn ((nrealargs,isdep),pred) -> + | PrLetIn ((names,isdep),pred) -> (* Assume some gamma st: gamma, (X,x:=realargs,copt) |- pred *) - let k = nrealargs + (if isdep then 1 else 0) in + let nrealargs = List.length names in + let k = nrealargs + (if isdep<>Anonymous then 1 else 0) in (* We adjust pred st: gamma, x1..xn, (X,x:=realargs,copt) |- pred' *) let n = cs.cs_nargs in let pred' = liftn_predicate n (k+1) pred in let argsi = if nrealargs <> 0 then Array.to_list cs.cs_concl_realargs else [] in - let copti = if isdep then Some (build_dependent_constructor cs) else None in + let copti = if isdep<>Anonymous then Some (build_dependent_constructor cs) else None in (* The substituends argsi, copti are all defined in gamma, x1...xn *) (* We need _parallel_ bindings to get gamma, x1...xn |- pred'' *) let pred'' = subst_predicate (argsi, copti) pred' in @@ -1513,24 +1530,28 @@ let extract_predicate_conclusion isdep tomatchl pred = let cook = function | _,IsInd (_,IndType(_,args)) -> Some (List.length args) | _,NotInd _ -> None in - let decomp_lam_force p = + let rec decomp_lam_force n l p = + if n=0 then (l,p) else match kind_of_term p with - | Lambda (_,_,c) -> c - | _ -> (* eta-expansion *) applist (lift 1 p, [mkRel 1]) in - let rec buildrec p = function - | [] -> p + | Lambda (na,_,c) -> decomp_lam_force (n-1) (na::l) c + | _ -> (* eta-expansion *) + let na = Name (id_of_string "x") in + decomp_lam_force (n-1) (na::l) (applist (lift 1 p, [mkRel 1])) in + let rec buildrec allnames p = function + | [] -> (List.rev allnames,p) | tm::ltm -> match cook tm with | None -> let p = (* adjust to a sign containing the NotInd's *) if isdep then lift 1 p else p in - buildrec p ltm + let names = if isdep then [Anonymous] else [] in + buildrec (names::allnames) p ltm | Some n -> let n = if isdep then n+1 else n in - let p = iterate decomp_lam_force n p in - buildrec p ltm - in buildrec pred tomatchl + let names,p = decomp_lam_force n [] p in + buildrec (names::allnames) p ltm + in buildrec [] pred tomatchl let set_arity_signature dep n arsign tomatchl pred x = (* avoid is not exhaustive ! *) @@ -1572,18 +1593,19 @@ let set_arity_signature dep n arsign tomatchl pred x = decomp_block [] pred (tomatchl,arsign) let prepare_predicate_from_tycon loc dep env isevars tomatchs c = - let cook (n, l, env) = function + let cook (n, l, signs) = function | c,IsInd (_,IndType(indf,realargs)) -> let indf' = lift_inductive_family n indf in - let sign = make_arity_signature env dep indf' in + let arsign = make_arity_signature env dep indf' in let p = List.length realargs in if dep then - (n + p + 1, c::(List.rev realargs)@l, push_rels sign env) + (n + p + 1, c::(List.rev realargs)@l, arsign::signs) else - (n + p, (List.rev realargs)@l, push_rels sign env) + (n + p, (List.rev realargs)@l, arsign::signs) | c,NotInd _ -> - (n, l, env) in - let n, allargs, env = List.fold_left cook (0, [], env) tomatchs in + (n, l, []::signs) in + let n, allargs, signs = List.fold_left cook (0, [], []) tomatchs in + let env = List.fold_right push_rels signs env in let allargs = List.map (fun c -> lift n (nf_betadeltaiota env (evars_of isevars) c)) allargs in let rec build_skeleton env c = @@ -1594,28 +1616,32 @@ let prepare_predicate_from_tycon loc dep env isevars tomatchs c = mkExistential isevars env (loc, CasesType) else map_constr_with_full_binders push_rel build_skeleton env c in - build_skeleton env (lift n c) + List.rev (List.map (List.map pi1) signs), build_skeleton env (lift n c) (* Here, [pred] is assumed to be in the context built from all *) (* realargs and terms to match *) -let build_initial_predicate isdep pred tomatchl = - let nar = List.fold_left (fun n (_,t) -> - let p = match t with IsInd (_,IndType(_,a)) -> List.length a | _ -> 0 in - if isdep then n+p+1 else n+p) 0 tomatchl in - let cook = function - | _,IsInd (_,IndType(_,realargs)) -> List.length realargs - | _,NotInd _ -> 0 in +let build_initial_predicate isdep allnames pred = + let nar = List.fold_left (fun n names -> List.length names + n) 0 allnames in let rec buildrec n pred = function | [] -> PrCcl pred - | tm::ltm -> - let nrealargs = cook tm in + | names::lnames -> + let names' = if isdep then List.tl names else names in + let n' = n + List.length names' in let pred, p, user_p = if isdep then - if dependent (mkRel (nar-n)) pred then pred, 1, 1 - else liftn (-1) (nar-n) pred, 0, 1 + if dependent (mkRel (nar-n')) pred then pred, 1, 1 + else liftn (-1) (nar-n') pred, 0, 1 else pred, 0, 0 in - PrLetIn ((nrealargs,p=1), buildrec (n+nrealargs+user_p) pred ltm) - in buildrec 0 pred tomatchl + let na = + if p=1 then + let na = List.hd names in + if na = Anonymous then + (* peut arriver en raison des evars *) + Name (id_of_string "x") (*Hum*) + else na + else Anonymous in + PrLetIn ((names',na), buildrec (n'+user_p) pred lnames) + in buildrec 0 pred allnames let extract_arity_signature env0 tomatchl tmsign = let get_one_sign n tm {contents = (na,t)} = @@ -1652,9 +1678,9 @@ let extract_arity_signature env0 tomatchl tmsign = | [],[] -> [] | (_,tm)::ltm, x::tmsign -> let l = get_one_sign n tm x in - (buildrec (n + List.length l) (ltm,tmsign)) @ l + l :: buildrec (n + List.length l) (ltm,tmsign) | _ -> assert false - in buildrec 0 (tomatchl,tmsign) + in List.rev (buildrec 0 (tomatchl,tmsign)) (* Builds the predicate. If the predicate is dependent, its context is * made of 1+nrealargs assumptions for each matched term in an inductive @@ -1683,17 +1709,18 @@ let prepare_predicate loc typing_fun isevars env tomatchs sign tycon = function (match tycon with | None -> None | Some t -> - let pred = prepare_predicate_from_tycon loc false env isevars tomatchs t in - Some (build_initial_predicate false pred tomatchs)) + let names,pred = prepare_predicate_from_tycon loc false env isevars tomatchs t in + Some (build_initial_predicate false names pred)) (* v8 style type annotation *) | (None,{contents = Some rtntyp}) -> (* We extract the signature of the arity *) - let arsign = extract_arity_signature env tomatchs sign in - let env = push_rels arsign env in + let arsigns = extract_arity_signature env tomatchs sign in + let env = List.fold_right push_rels arsigns env in + let allnames = List.rev (List.map (List.map pi1) arsigns) in let predccl = (typing_fun (mk_tycon (new_Type ())) env rtntyp).uj_val in - Some (build_initial_predicate true predccl tomatchs) + Some (build_initial_predicate true allnames predccl) (* v7 style type annotation; set the v8 annotation by side effect *) | (Some pred,x) -> @@ -1721,12 +1748,9 @@ let prepare_predicate loc typing_fun isevars env tomatchs sign tycon = function error_wrong_predicate_arity_loc loc env predj.uj_val ndep_arity dep_arity in - let predccl = extract_predicate_conclusion dep tomatchs predj.uj_val in -(* - let etapred,cdep = case_dependent env (evars_of isevars) loc predj tomatchs in -*) + let ln,predccl= extract_predicate_conclusion dep tomatchs predj.uj_val in set_arity_signature dep n sign tomatchs pred x; - Some (build_initial_predicate dep predccl tomatchs) + Some (build_initial_predicate dep ln predccl) (**************************************************************************) diff --git a/pretyping/evarconv.ml b/pretyping/evarconv.ml index 6f396b43..0ee95a0f 100644 --- a/pretyping/evarconv.ml +++ b/pretyping/evarconv.ml @@ -6,7 +6,7 @@ (* * GNU Lesser General Public License Version 2.1 *) (************************************************************************) -(* $Id: evarconv.ml,v 1.44.6.1 2004/07/16 19:30:44 herbelin Exp $ *) +(* $Id: evarconv.ml,v 1.44.6.2 2004/11/26 23:51:39 herbelin Exp $ *) open Util open Names @@ -39,8 +39,11 @@ let flex_kind_of_term c l = let eval_flexible_term env c = match kind_of_term c with | Const c -> constant_opt_value env c - | Rel n -> let (_,v,_) = lookup_rel n env in option_app (lift n) v - | Var id -> let (_,v,_) = lookup_named id env in v + | Rel n -> + (try let (_,v,_) = lookup_rel n env in option_app (lift n) v + with Not_found -> None) + | Var id -> + (try let (_,v,_) = lookup_named id env in v with Not_found -> None) | LetIn (_,b,_,c) -> Some (subst1 b c) | Lambda _ -> Some c | _ -> assert false diff --git a/pretyping/evarutil.ml b/pretyping/evarutil.ml index 441070fe..4337c0fc 100644 --- a/pretyping/evarutil.ml +++ b/pretyping/evarutil.ml @@ -6,7 +6,7 @@ (* * GNU Lesser General Public License Version 2.1 *) (************************************************************************) -(* $Id: evarutil.ml,v 1.64.2.3 2004/07/16 19:30:44 herbelin Exp $ *) +(* $Id: evarutil.ml,v 1.64.2.5 2004/12/09 14:45:38 herbelin Exp $ *) open Util open Pp @@ -30,25 +30,6 @@ let rec filter_unique = function if List.mem x l then filter_unique (List.filter (fun y -> x<>y) l) else x::filter_unique l -(* -let distinct_id_list = - let rec drec fresh = function - [] -> List.rev fresh - | id::rest -> - let id' = next_ident_away_from id fresh in drec (id'::fresh) rest - in drec [] -*) - -(* -let filter_sign p sign x = - sign_it - (fun id ty (v,ids,sgn) -> - let (disc,v') = p v (id,ty) in - if disc then (v', id::ids, sgn) else (v', ids, add_sign (id,ty) sgn)) - sign - (x,[],nil_sign) -*) - (* Expanding existential variables (pretyping.ml) *) (* 1- whd_ise fails if an existential is undefined *) @@ -183,20 +164,9 @@ let do_restrict_hyps sigma ev args = let evd = Evd.map sigma ev in let env = evar_env evd in let hyps = evd.evar_hyps in - let (_,(rsign,ncargs)) = - List.fold_left - (fun (sign,(rs,na)) a -> - (List.tl sign, - if not(closed0 a) then - (rs,na) - else - (add_named_decl (List.hd sign) rs, a::na))) - (hyps,([],[])) args - in - let sign' = List.rev rsign in - let env' = reset_with_named_context sign' env in - let instance = make_evar_instance env' in - let (sigma',nc) = new_isevar_sign env' sigma evd.evar_concl instance in + let (sign,ncargs) = list_filter2 (fun _ a -> closed0 a) (hyps,args) in + let env' = reset_with_named_context sign env in + let (sigma',nc) = new_isevar_sign env' sigma evd.evar_concl ncargs in let nc = refresh_universes nc in (* needed only if nc is an inferred type *) let sigma'' = Evd.define sigma' ev nc in (sigma'', nc) diff --git a/pretyping/inductiveops.ml b/pretyping/inductiveops.ml index 24a8fbc7..c33a261b 100644 --- a/pretyping/inductiveops.ml +++ b/pretyping/inductiveops.ml @@ -6,7 +6,7 @@ (* * GNU Lesser General Public License Version 2.1 *) (************************************************************************) -(* $Id: inductiveops.ml,v 1.14.2.1 2004/07/16 19:30:45 herbelin Exp $ *) +(* $Id: inductiveops.ml,v 1.14.2.2 2004/12/29 12:15:00 herbelin Exp $ *) open Util open Names @@ -341,9 +341,9 @@ let control_only_guard env = Inductive.check_fix env fix; Array.iter control_rec tys; Array.iter control_rec bds; - | Case(_,p,c,b) ->control_rec p;control_rec c;Array.iter control_rec b + | Case(_,p,c,b) -> control_rec p;control_rec c;Array.iter control_rec b | Evar (_,cl) -> Array.iter control_rec cl - | App (_,cl) -> Array.iter control_rec cl + | App (c,cl) -> control_rec c; Array.iter control_rec cl | Cast (c1,c2) -> control_rec c1; control_rec c2 | Prod (_,c1,c2) -> control_rec c1; control_rec c2 | Lambda (_,c1,c2) -> control_rec c1; control_rec c2 diff --git a/pretyping/inductiveops.mli b/pretyping/inductiveops.mli index a8dcef29..8cfa9b3c 100644 --- a/pretyping/inductiveops.mli +++ b/pretyping/inductiveops.mli @@ -6,7 +6,7 @@ (* * GNU Lesser General Public License Version 2.1 *) (************************************************************************) -(* $Id: inductiveops.mli,v 1.10.2.1 2004/07/16 19:30:45 herbelin Exp $ *) +(*i $Id: inductiveops.mli,v 1.10.2.3 2005/01/21 17:19:37 herbelin Exp $ i*) open Names open Term @@ -66,7 +66,7 @@ val make_arity_signature : val make_arity : env -> bool -> inductive_family -> sorts -> types val build_branch_type : env -> bool -> constr -> constructor_summary -> types -(* Raise Not_found if not given an valid inductive type *) +(* Raise [Not_found] if not given an valid inductive type *) val extract_mrectype : constr -> inductive * constr list val find_mrectype : env -> evar_map -> constr -> inductive * constr list val find_rectype : env -> evar_map -> constr -> inductive_type diff --git a/pretyping/matching.mli b/pretyping/matching.mli index 808c46a4..2f666880 100644 --- a/pretyping/matching.mli +++ b/pretyping/matching.mli @@ -6,7 +6,7 @@ (* * GNU Lesser General Public License Version 2.1 *) (************************************************************************) -(*i $Id: matching.mli,v 1.3.2.1 2004/07/16 19:30:45 herbelin Exp $ i*) +(*i $Id: matching.mli,v 1.3.2.2 2005/01/21 16:42:37 herbelin Exp $ i*) (*i*) open Names @@ -42,7 +42,7 @@ val matches_conv :env -> Evd.evar_map -> constr_pattern -> constr -> patvar_map (* To skip to the next occurrence *) exception NextOccurrence of int -(* Tries to match a _closed_ subterm of [c] with [pat] *) +(* Tries to match a **closed** subterm of [c] with [pat] *) val sub_match : int -> constr_pattern -> constr -> patvar_map * constr (* [is_matching_conv env sigma pat c] tells if [c] matches against [pat] diff --git a/pretyping/pattern.ml b/pretyping/pattern.ml index 80ab1b6e..f58a12c6 100644 --- a/pretyping/pattern.ml +++ b/pretyping/pattern.ml @@ -6,7 +6,7 @@ (* * GNU Lesser General Public License Version 2.1 *) (************************************************************************) -(* $Id: pattern.ml,v 1.24.2.1 2004/07/16 19:30:45 herbelin Exp $ *) +(* $Id: pattern.ml,v 1.24.2.2 2004/11/26 17:51:52 herbelin Exp $ *) open Util open Names @@ -182,8 +182,7 @@ let rec pattern_of_constr t = Some (pattern_of_constr p),pattern_of_constr a, Array.map pattern_of_constr br) | Fix f -> PFix f - | CoFix _ -> - error "pattern_of_constr: (co)fix currently not supported" + | CoFix f -> PCoFix f (* To process patterns, we need a translation without typing at all. *) diff --git a/pretyping/rawterm.ml b/pretyping/rawterm.ml index 520f09e9..ef4a4670 100644 --- a/pretyping/rawterm.ml +++ b/pretyping/rawterm.ml @@ -6,7 +6,7 @@ (* * GNU Lesser General Public License Version 2.1 *) (************************************************************************) -(* $Id: rawterm.ml,v 1.43.2.2 2004/07/16 19:30:46 herbelin Exp $ *) +(* $Id: rawterm.ml,v 1.43.2.4 2004/12/29 10:17:10 herbelin Exp $ *) (*i*) open Util @@ -49,7 +49,7 @@ type 'a bindings = type 'a with_bindings = 'a * 'a bindings type hole_kind = - | ImplicitArg of global_reference * int + | ImplicitArg of global_reference * (int * identifier option) | BinderType of name | QuestionMark | CasesType @@ -356,7 +356,7 @@ type ('a,'b) red_expr_gen = | Unfold of 'b occurrences list | Fold of 'a list | Pattern of 'a occurrences list - | ExtraRedExpr of string * 'a + | ExtraRedExpr of string type ('a,'b) may_eval = | ConstrTerm of 'a diff --git a/pretyping/rawterm.mli b/pretyping/rawterm.mli index d78d1866..97e11af6 100644 --- a/pretyping/rawterm.mli +++ b/pretyping/rawterm.mli @@ -6,7 +6,7 @@ (* * GNU Lesser General Public License Version 2.1 *) (************************************************************************) -(*i $Id: rawterm.mli,v 1.47.2.2 2004/07/16 19:30:46 herbelin Exp $ i*) +(*i $Id: rawterm.mli,v 1.47.2.5 2005/01/21 16:42:37 herbelin Exp $ i*) (*i*) open Util @@ -47,7 +47,7 @@ type 'a bindings = type 'a with_bindings = 'a * 'a bindings type hole_kind = - | ImplicitArg of global_reference * int + | ImplicitArg of global_reference * (int * identifier option) | BinderType of name | QuestionMark | CasesType @@ -97,11 +97,11 @@ i*) val map_rawconstr : (rawconstr -> rawconstr) -> rawconstr -> rawconstr -(* +(*i val map_rawconstr_with_binders_loc : loc -> (identifier -> 'a -> identifier * 'a) -> ('a -> rawconstr -> rawconstr) -> 'a -> rawconstr -> rawconstr -*) +i*) val occur_rawconstr : identifier -> rawconstr -> bool @@ -130,7 +130,7 @@ type ('a,'b) red_expr_gen = | Unfold of 'b occurrences list | Fold of 'a list | Pattern of 'a occurrences list - | ExtraRedExpr of string * 'a + | ExtraRedExpr of string type ('a,'b) may_eval = | ConstrTerm of 'a diff --git a/pretyping/tacred.ml b/pretyping/tacred.ml index 7e79a4fe..f225e79f 100644 --- a/pretyping/tacred.ml +++ b/pretyping/tacred.ml @@ -6,7 +6,7 @@ (* * GNU Lesser General Public License Version 2.1 *) (************************************************************************) -(* $Id: tacred.ml,v 1.75.2.2 2004/07/16 19:30:46 herbelin Exp $ *) +(* $Id: tacred.ml,v 1.75.2.6 2004/12/29 10:17:10 herbelin Exp $ *) open Pp open Util @@ -329,7 +329,7 @@ let make_elim_fun (names,(nbfix,lv,n)) largs = mkLambda (Name(id_of_string"x"), substl (rev_firstn_liftn (n-k) (-i) la') a, c)) - 0 (applistc (mkEvalRef ref) la') lv) + 1 (applistc (mkEvalRef ref) la') (List.rev lv)) (* [f] is convertible to [Fix(recindices,bodynum),bodyvect)] make the reduction using this extra information *) @@ -808,6 +808,7 @@ let abstract_scheme env sigma (locc,a) t = let pattern_occs loccs_trm env sigma c = let abstr_trm = List.fold_right (abstract_scheme env sigma) loccs_trm c in + let _ = Typing.type_of env sigma abstr_trm in applist(abstr_trm, List.map snd loccs_trm) (* Generic reduction: reduction functions used in reduction tactics *) @@ -858,7 +859,7 @@ let reduction_of_redexp = function | Unfold ubinds -> unfoldn ubinds | Fold cl -> fold_commands cl | Pattern lp -> pattern_occs lp - | ExtraRedExpr (s,c) -> + | ExtraRedExpr s -> (try Stringmap.find s !red_expr_tab with Not_found -> error("unknown user-defined reduction \""^s^"\"")) (* Used in several tactics. *) @@ -945,7 +946,10 @@ let reduce_to_ref_gen allow_product env sigma ref t = try let t' = nf_betaiota (one_step_reduce env sigma t) in elimrec env t' l - with NotStepReducible -> raise Not_found + with NotStepReducible -> + errorlabstrm "" + (str "Not a statement of conclusion " ++ + Nametab.pr_global_env Idset.empty ref) in elimrec env t [] diff --git a/pretyping/tacred.mli b/pretyping/tacred.mli index 162275d5..7998a8fd 100644 --- a/pretyping/tacred.mli +++ b/pretyping/tacred.mli @@ -6,7 +6,7 @@ (* * GNU Lesser General Public License Version 2.1 *) (************************************************************************) -(*i $Id: tacred.mli,v 1.21.2.1 2004/07/16 19:30:46 herbelin Exp $ i*) +(*i $Id: tacred.mli,v 1.21.2.2 2005/01/21 16:42:37 herbelin Exp $ i*) (*i*) open Names @@ -62,7 +62,7 @@ val reduce_to_atomic_ind : env -> evar_map -> types -> inductive * types val reduce_to_quantified_ind : env -> evar_map -> types -> inductive * types (* [reduce_to_quantified_ref env sigma ref t] try to put [t] in the form - [t'=(x1:A1)..(xn:An)(ref args)] and raise Not_found if not possible *) + [t'=(x1:A1)..(xn:An)(ref args)] and raise [Not_found] if not possible *) val reduce_to_quantified_ref : env -> evar_map -> Libnames.global_reference -> types -> types diff --git a/pretyping/termops.mli b/pretyping/termops.mli index dd9742ea..22bd0aba 100644 --- a/pretyping/termops.mli +++ b/pretyping/termops.mli @@ -6,7 +6,7 @@ (* * GNU Lesser General Public License Version 2.1 *) (************************************************************************) -(* $Id: termops.mli,v 1.21.2.1 2004/07/16 19:30:46 herbelin Exp $ *) +(*i $Id: termops.mli,v 1.21.2.3 2005/01/21 17:19:37 herbelin Exp $ i*) open Util open Pp @@ -16,7 +16,7 @@ open Sign open Environ (* Universes *) -(*val set_module : Names.dir_path -> unit*) +(*i val set_module : Names.dir_path -> unit i*) val new_univ : unit -> Univ.universe val new_sort_in_family : sorts_family -> sorts diff --git a/proofs/clenv.ml b/proofs/clenv.ml index 423350d7..999bb651 100644 --- a/proofs/clenv.ml +++ b/proofs/clenv.ml @@ -6,7 +6,7 @@ (* * GNU Lesser General Public License Version 2.1 *) (************************************************************************) -(* $Id: clenv.ml,v 1.97.2.3 2004/07/16 19:30:48 herbelin Exp $ *) +(* $Id: clenv.ml,v 1.97.2.4 2004/12/06 12:59:11 herbelin Exp $ *) open Pp open Util @@ -65,7 +65,7 @@ let exist_to_meta sigma (emap, c) = let ty = nf_betaiota (nf_evar emap (existential_type emap evar)) in let n = new_meta() in metamap := (n, ty) :: !metamap; - mkMeta n in + mkCast (mkMeta n, ty) in let rec replace c = match kind_of_term c with Evar (k,_ as ev) when not (Evd.in_dom sigma k) -> change_exist ev diff --git a/proofs/clenv.mli b/proofs/clenv.mli index 10e0004e..737fbea3 100644 --- a/proofs/clenv.mli +++ b/proofs/clenv.mli @@ -6,7 +6,7 @@ (* * GNU Lesser General Public License Version 2.1 *) (************************************************************************) -(*i $Id: clenv.mli,v 1.32.2.1 2004/07/16 19:30:49 herbelin Exp $ i*) +(*i $Id: clenv.mli,v 1.32.2.2 2005/01/21 16:41:51 herbelin Exp $ i*) (*i*) open Util @@ -102,9 +102,9 @@ val clenv_independent : wc clausenv -> metavariable list val clenv_missing : 'a clausenv -> metavariable list val clenv_constrain_missing_args : (* Used in user contrib Lannion *) constr list -> wc clausenv -> wc clausenv -(* +(*i val clenv_constrain_dep_args : constr list -> wc clausenv -> wc clausenv -*) +i*) val clenv_lookup_name : 'a clausenv -> identifier -> metavariable val clenv_unique_resolver : bool -> wc clausenv -> goal sigma -> wc clausenv diff --git a/proofs/evar_refiner.ml b/proofs/evar_refiner.ml index d59ff835..ac4dd43a 100644 --- a/proofs/evar_refiner.ml +++ b/proofs/evar_refiner.ml @@ -6,7 +6,7 @@ (* * GNU Lesser General Public License Version 2.1 *) (************************************************************************) -(* $Id: evar_refiner.ml,v 1.36.2.1 2004/07/16 19:30:49 herbelin Exp $ *) +(* $Id: evar_refiner.ml,v 1.36.2.2 2004/08/03 21:37:27 herbelin Exp $ *) open Pp open Util @@ -178,6 +178,7 @@ let instantiate_pf_com n com pfts = List.nth (Evd.non_instantiated sigma) (n-1) with Failure _ -> error "not so many uninstantiated existential variables" + | Invalid_argument _ -> error "incorrect existential variable index" in let c = Constrintern.interp_constr sigma (Evarutil.evar_env evd) com in let wc' = w_Define sp c wc in diff --git a/proofs/evar_refiner.mli b/proofs/evar_refiner.mli index d7f393b3..d57e1b84 100644 --- a/proofs/evar_refiner.mli +++ b/proofs/evar_refiner.mli @@ -6,7 +6,7 @@ (* * GNU Lesser General Public License Version 2.1 *) (************************************************************************) -(*i $Id: evar_refiner.mli,v 1.28.2.1 2004/07/16 19:30:49 herbelin Exp $ i*) +(*i $Id: evar_refiner.mli,v 1.28.2.2 2005/01/21 16:41:51 herbelin Exp $ i*) (*i*) open Names @@ -51,7 +51,7 @@ val w_const_value : wc -> constant -> constr val w_defined_evar : wc -> existential_key -> bool val instantiate : int -> constr -> identifier Tacexpr.gsimple_clause -> tactic -(* +(*i val instantiate_tac : tactic_arg list -> tactic -*) +i*) val instantiate_pf_com : int -> Topconstr.constr_expr -> pftreestate -> pftreestate diff --git a/proofs/refiner.mli b/proofs/refiner.mli index bed1158d..f6f2082e 100644 --- a/proofs/refiner.mli +++ b/proofs/refiner.mli @@ -1,4 +1,3 @@ - (************************************************************************) (* v * The Coq Proof Assistant / The Coq Development Team *) (* pftreestate val change_constraints_pftreestate : evar_map -> pftreestate -> pftreestate -(* +(*i val vernac_tactic : string * tactic_arg list -> tactic -*) +i*) (*s The most primitive tactics. *) val refiner : rule -> tactic diff --git a/scripts/coqc.ml b/scripts/coqc.ml index 7d1cc206..34025ec9 100644 --- a/scripts/coqc.ml +++ b/scripts/coqc.ml @@ -6,7 +6,7 @@ (* * GNU Lesser General Public License Version 2.1 *) (************************************************************************) -(* $Id: coqc.ml,v 1.25.2.1 2004/07/16 19:30:50 herbelin Exp $ *) +(* $Id: coqc.ml,v 1.25.2.3 2004/09/04 10:34:56 herbelin Exp $ *) (* Afin de rendre Coq plus portable, ce programme Caml remplace le script coqc. @@ -130,8 +130,15 @@ let parse_args () = image := f; parse (cfiles,args) rem | "-image" :: [] -> usage () + | "-libdir" :: _ :: rem -> + print_string "Warning: option -libdir deprecated\n"; flush stdout; + parse (cfiles,args) rem + | ("-db"|"-debugger") :: rem -> + print_string "Warning: option -db/-debugger deprecated\n";flush stdout; + parse (cfiles,args) rem + | ("-?"|"-h"|"-H"|"-help"|"--help") :: _ -> usage () - | ("-libdir"|"-I"|"-include"|"-outputstate" + | ("-I"|"-include"|"-outputstate" |"-inputstate"|"-is"|"-load-vernac-source"|"-l"|"-load-vernac-object" |"-load-ml-source"|"-require"|"-load-ml-object"|"-user" |"-init-file"|"-dump-glob" as o) :: rem -> @@ -141,7 +148,7 @@ let parse_args () = | [] -> usage () end | "-R" as o :: s :: t :: rem -> parse (cfiles,t::s::o::args) rem - | ("-notactics"|"-debug"|"-db"|"-debugger"|"-nolib"|"-batch"|"-nois" + | ("-notactics"|"-debug"|"-nolib"|"-batch"|"-nois" |"-q"|"-full"|"-profile"|"-just-parsing"|"-echo" |"-unsafe"|"-quiet" |"-silent"|"-m"|"-xml"|"-v7"|"-v8"|"-translate"|"-strict-implicit" |"-dont-load-proofs"|"-impredicative-set" as o) :: rem -> diff --git a/tactics/auto.ml b/tactics/auto.ml index d087420a..b530178e 100644 --- a/tactics/auto.ml +++ b/tactics/auto.ml @@ -6,7 +6,7 @@ (* * GNU Lesser General Public License Version 2.1 *) (************************************************************************) -(* $Id: auto.ml,v 1.63.2.1 2004/07/16 19:30:51 herbelin Exp $ *) +(* $Id: auto.ml,v 1.63.2.2 2004/12/06 11:25:21 herbelin Exp $ *) open Pp open Util @@ -199,8 +199,12 @@ let make_apply_entry env sigma (eapply,verbose) name (c,cty) = in if eapply & (nmiss <> 0) then begin if verbose then + if !Options.v7 then warn (str "the hint: EApply " ++ prterm c ++ - str " will only be used by EAuto"); + str " will only be used by EAuto") + else + warn (str "the hint: eapply " ++ prterm c ++ + str " will only be used by eauto"); (hd, { hname = name; pri = nb_hyp cty + nmiss; @@ -281,40 +285,8 @@ let add_hint dbname hintlist = let cache_autohint (_,(local,name,hintlist)) = add_hint name hintlist -(* let recalc_hints hintlist = - let env = Global.env() and sigma = Evd.empty in - let recalc_hint ((_,data) as hint) = - match data.code with - | Res_pf (c,_) -> - let c' = Term.subst_mps subst c in - if c==c' then hint else - make_apply_entry env sigma (false,false) - data.hname (c', type_of env sigma c') - | ERes_pf (c,_) -> - let c' = Term.subst_mps subst c in - if c==c' then hint else - make_apply_entry env sigma (true,false) - data.hname (c', type_of env sigma c') - | Give_exact c -> - let c' = Term.subst_mps subst c in - if c==c' then hint else - make_exact_entry data.hname (c',type_of env sigma c') - | Res_pf_THEN_trivial_fail (c,_) -> - let c' = Term.subst_mps subst c in - if c==c' then hint else - make_trivial env sigma (data.hname,c') - | Unfold_nth ref -> - let ref' = subst_global subst ref in - if ref==ref' then hint else - make_unfold (data.hname,ref') - | Extern _ -> - anomaly "Extern hints cannot be substituted!!!" - in - list_smartmap recalc_hint hintlist -*) - let forward_subst_tactic = - ref (fun _ -> failwith "subst_tactic is not installed for Auto") + ref (fun _ -> failwith "subst_tactic is not installed for auto") let set_extern_subst_tactic f = forward_subst_tactic := f @@ -430,7 +402,7 @@ let add_trivials env sigma l local dbnames = dbnames let forward_intern_tac = - ref (fun _ -> failwith "intern_tac is not installed for Auto") + ref (fun _ -> failwith "intern_tac is not installed for auto") let set_extern_intern_tac f = forward_intern_tac := f @@ -492,7 +464,9 @@ let add_hints local dbnames0 h = (* Functions for printing the hints *) (**************************************************************************) -let fmt_autotactic = function +let fmt_autotactic = + if !Options.v7 then + function | Res_pf (c,clenv) -> (str"Apply " ++ prterm c) | ERes_pf (c,clenv) -> (str"EApply " ++ prterm c) | Give_exact c -> (str"Exact " ++ prterm c) @@ -500,6 +474,16 @@ let fmt_autotactic = function (str"Apply " ++ prterm c ++ str" ; Trivial") | Unfold_nth c -> (str"Unfold " ++ pr_global c) | Extern tac -> (str "Extern " ++ Pptactic.pr_glob_tactic tac) + else + function + | Res_pf (c,clenv) -> (str"apply " ++ prterm c) + | ERes_pf (c,clenv) -> (str"eapply " ++ prterm c) + | Give_exact c -> (str"exact " ++ prterm c) + | Res_pf_THEN_trivial_fail (c,clenv) -> + (str"apply " ++ prterm c ++ str" ; trivial") + | Unfold_nth c -> (str"unfold " ++ pr_global c) + | Extern tac -> + (str "(external) " ++ Pptacticnew.pr_glob_tactic (Global.env()) tac) let fmt_hint v = (fmt_autotactic v.code ++ str"(" ++ int v.pri ++ str")" ++ spc ()) @@ -631,7 +615,7 @@ si apr (* conclPattern doit échouer avec error car il est rattraper par tclFIRST *) let forward_interp_tactic = - ref (fun _ -> failwith "interp_tactic is not installed for Auto") + ref (fun _ -> failwith "interp_tactic is not installed for auto") let set_extern_interp f = forward_interp_tactic := f @@ -700,7 +684,10 @@ let trivial dbnames gl = try searchtable_map x with Not_found -> - error ("Trivial: "^x^": No such Hint database")) + if !Options.v7 then + error ("Trivial: "^x^": No such Hint database") + else + error ("trivial: "^x^": No such Hint database")) ("core"::dbnames) in tclTRY (trivial_fail_db db_list (make_local_hint_db gl)) gl @@ -799,7 +786,10 @@ let auto n dbnames gl = try searchtable_map x with Not_found -> - error ("Auto: "^x^": No such Hint database")) + if !Options.v7 then + error ("Auto: "^x^": No such Hint database") + else + error ("auto: "^x^": No such Hint database")) ("core"::dbnames) in let hyps = pf_hyps gl in diff --git a/tactics/auto.mli b/tactics/auto.mli index ef6b85ea..ec8c0d71 100644 --- a/tactics/auto.mli +++ b/tactics/auto.mli @@ -6,7 +6,7 @@ (* * GNU Lesser General Public License Version 2.1 *) (************************************************************************) -(*i $Id: auto.mli,v 1.22.2.1 2004/07/16 19:30:51 herbelin Exp $ i*) +(*i $Id: auto.mli,v 1.22.2.2 2005/01/21 16:41:52 herbelin Exp $ i*) (*i*) open Util @@ -105,7 +105,7 @@ val make_resolves : (* [make_resolve_hyp hname htyp]. used to add an hypothesis to the local hint database; - Never raises an User_exception; + Never raises a user exception; If the hyp cannot be used as a Hint, the empty list is returned. *) val make_resolve_hyp : diff --git a/tactics/autorewrite.ml b/tactics/autorewrite.ml index 7c134b89..5706e134 100644 --- a/tactics/autorewrite.ml +++ b/tactics/autorewrite.ml @@ -22,7 +22,7 @@ open Vernacinterp open Tacexpr (* Rewriting rules *) -type rew_rule = constr * bool * tactic +type rew_rule = constr * bool * glob_tactic_expr (* Summary and Object declaration *) let rewtab = @@ -39,7 +39,6 @@ let _ = Summary.survive_module = false; Summary.survive_section = false } -(* Rewriting rules before tactic interpretation *) type raw_rew_rule = constr * bool * raw_tactic_expr (* Applies all the rules of one base *) @@ -51,6 +50,7 @@ let one_base tac_main bas = errorlabstrm "AutoRewrite" (str ("Rewriting base "^(bas)^" does not exist")) in + let lrul = List.map (fun (c,b,t) -> (c,b,Tacinterp.eval_tactic t)) lrul in tclREPEAT_MAIN (tclPROGRESS (List.fold_left (fun tac (csr,dir,tc) -> tclTHEN tac (tclREPEAT_MAIN @@ -65,12 +65,11 @@ let autorewrite tac_main lbas = (* Functions necessary to the library object declaration *) let cache_hintrewrite (_,(rbase,lrl)) = - let l = List.rev_map (fun (c,b,t) -> (c,b,Tacinterp.eval_tactic t)) lrl in let l = try - List.rev_append l (Stringmap.find rbase !rewtab) + lrl @ Stringmap.find rbase !rewtab with - | Not_found -> List.rev l + | Not_found -> lrl in rewtab:=Stringmap.add rbase l !rewtab diff --git a/tactics/equality.ml b/tactics/equality.ml index dd9054f5..994abb9d 100644 --- a/tactics/equality.ml +++ b/tactics/equality.ml @@ -6,7 +6,7 @@ (* * GNU Lesser General Public License Version 2.1 *) (************************************************************************) -(* $Id: equality.ml,v 1.120.2.1 2004/07/16 19:30:53 herbelin Exp $ *) +(* $Id: equality.ml,v 1.120.2.4 2004/11/21 22:24:09 herbelin Exp $ *) open Pp open Util @@ -18,6 +18,7 @@ open Termops open Inductive open Inductiveops open Environ +open Libnames open Reductionops open Instantiate open Typeops @@ -327,8 +328,11 @@ let descend_then sigma env head dirn = (dirn_nlams, dirn_env, (fun dirnval (dfltval,resty) -> - let arign,_ = get_arity env indf in - let p = it_mkLambda_or_LetIn (lift mip.mind_nrealargs resty) arign in + let arsign,_ = get_arity env indf in + let depind = build_dependent_inductive env indf in + let deparsign = (Anonymous,None,depind)::arsign in + let p = + it_mkLambda_or_LetIn (lift (mip.mind_nrealargs+1) resty) deparsign in let build_branch i = let result = if i = dirn then dirnval else dfltval in it_mkLambda_or_LetIn_name env result cstr.(i-1).cs_args in @@ -371,7 +375,9 @@ let construct_discriminator sigma env dirn c sort = let (mib,mip) = lookup_mind_specif env ind in let arsign,arsort = get_arity env indf in let (true_0,false_0,sort_0) = build_coq_True(),build_coq_False(),Prop Null in - let p = it_mkLambda_or_LetIn (mkSort sort_0) arsign in + let depind = build_dependent_inductive env indf in + let deparsign = (Anonymous,None,depind)::arsign in + let p = it_mkLambda_or_LetIn (mkSort sort_0) deparsign in let cstrs = get_constructors env indf in let build_branch i = let endpt = if i = dirn then true_0 else false_0 in @@ -419,14 +425,8 @@ let discrimination_pf e (t,t1,t2) discriminator lbeq gls = exception NotDiscriminable -let discr id gls = - let eqn = pf_whd_betadeltaiota gls (pf_get_hyp_typ gls id) in +let discrEq (lbeq,(t,t1,t2)) id gls = let sort = pf_type_of gls (pf_concl gls) in - let (lbeq,(t,t1,t2)) = - try find_eq_data_decompose eqn - with PatternMatchingFailure -> - errorlabstrm "discr" (pr_id id ++ str": not a primitive equality here") - in let sigma = project gls in let env = pf_env gls in (match find_positions env sigma t1 t2 with @@ -445,24 +445,40 @@ let discr id gls = ([onLastHyp gen_absurdity; refine (mkApp (pf, [| mkVar id |]))]))) gls) - let not_found_message id = (str "The variable" ++ spc () ++ str (string_of_id id) ++ spc () ++ str" was not found in the current environment") +let onEquality tac id gls = + let eqn = pf_whd_betadeltaiota gls (pf_get_hyp_typ gls id) in + let eq = + try find_eq_data_decompose eqn + with PatternMatchingFailure -> + errorlabstrm "" (pr_id id ++ str": not a primitive equality") + in tac eq id gls + +let check_equality tac id gls = + let eqn = pf_whd_betadeltaiota gls (pf_get_hyp_typ gls id) in + let eq = + try find_eq_data_decompose eqn + with PatternMatchingFailure -> + errorlabstrm "" (str "The goal should negate an equality") + in tac eq id gls + let onNegatedEquality tac gls = - if is_matching_not (pf_concl gls) then - (tclTHEN (tclTHEN hnf_in_concl intro) (onLastHyp tac)) gls - else if is_matching_imp_False (pf_concl gls)then - (tclTHEN intro (onLastHyp tac)) gls - else + if is_matching_not (pf_concl gls) then + (tclTHEN (tclTHEN hnf_in_concl intro) (onLastHyp(check_equality tac))) gls + else if is_matching_imp_False (pf_concl gls)then + (tclTHEN intro (onLastHyp (check_equality tac))) gls + else errorlabstrm "extract_negated_equality_then" (str"The goal should negate an equality") - let discrSimpleClause = function - | None -> onNegatedEquality discr - | Some (id,_,_) -> discr id + | None -> onNegatedEquality discrEq + | Some (id,_,_) -> onEquality discrEq id + +let discr = onEquality discrEq let discrClause = onClauses discrSimpleClause @@ -566,7 +582,7 @@ let sig_clausal_form env sigma sort_of_ty siglen ty (dFLT,dFLTty) = let isevars = Evarutil.create_evar_defs sigma in let rec sigrec_clausal_form siglen p_i = if siglen = 0 then - if Evarconv.the_conv_x env isevars p_i dFLTty then + if Evarconv.the_conv_x_leq env isevars dFLTty p_i then (* the_conv_x had a side-effect on isevars *) dFLT else @@ -695,13 +711,7 @@ let try_delta_expand env sigma t = expands then only when the whdnf has a constructor of an inductive type in hd position, otherwise delta expansion is not done *) -let inj id gls = - let eqn = pf_whd_betadeltaiota gls (pf_get_hyp_typ gls id) in - let (eq,(t,t1,t2))= - try find_eq_data_decompose eqn - with PatternMatchingFailure -> - errorlabstrm "Inj" (pr_id id ++ str": not a primitive equality here") - in +let injEq (eq,(t,t1,t2)) id gls = let sigma = project gls in let env = pf_env gls in match find_positions env sigma t1 t2 with @@ -749,17 +759,17 @@ let inj id gls = in ((tclTHENS (cut ty) ([tclIDTAC;refine pf])))) injectors gls - + +let inj = onEquality injEq + let injClause = function - | None -> onNegatedEquality inj + | None -> onNegatedEquality injEq | Some id -> try_intros_until inj id let injConcl gls = injClause None gls let injHyp id gls = injClause (Some id) gls -let decompEqThen ntac id gls = - let eqn = pf_whd_betadeltaiota gls (pf_get_hyp_typ gls id) in - let (lbeq,(t,t1,t2))= find_eq_data_decompose eqn in +let decompEqThen ntac (lbeq,(t,t1,t2)) id gls = let sort = pf_type_of gls (pf_concl gls) in let sigma = project gls in let env = pf_env gls in @@ -806,17 +816,12 @@ let decompEqThen ntac id gls = (ntac (List.length injectors))) gls)) -let decompEq = decompEqThen (fun x -> tclIDTAC) - let dEqThen ntac = function | None -> onNegatedEquality (decompEqThen ntac) - | Some id -> try_intros_until (decompEqThen ntac) id + | Some id -> try_intros_until (onEquality (decompEqThen ntac)) id let dEq = dEqThen (fun x -> tclIDTAC) -let dEqConcl gls = dEq None gls -let dEqHyp id gls = dEq (Some id) gls - let rewrite_msg = function | None -> str "passed term is not a primitive equality" | Some id -> pr_id id ++ str "does not satisfy preconditions " diff --git a/tactics/extraargs.mli b/tactics/extraargs.mli index 60a1ddc5..2b4746ae 100644 --- a/tactics/extraargs.mli +++ b/tactics/extraargs.mli @@ -6,7 +6,7 @@ (* * GNU Lesser General Public License Version 2.1 *) (************************************************************************) -(* $Id: extraargs.mli,v 1.3.2.1 2004/07/16 19:30:53 herbelin Exp $ *) +(*i $Id: extraargs.mli,v 1.3.2.2 2005/01/21 17:14:10 herbelin Exp $ i*) open Tacexpr open Term diff --git a/tactics/extratactics.ml4 b/tactics/extratactics.ml4 index 1dbf84ab..237f0a0d 100644 --- a/tactics/extratactics.ml4 +++ b/tactics/extratactics.ml4 @@ -8,7 +8,7 @@ (*i camlp4deps: "parsing/grammar.cma" i*) -(* $Id: extratactics.ml4,v 1.21.2.1 2004/07/16 19:30:53 herbelin Exp $ *) +(* $Id: extratactics.ml4,v 1.21.2.2 2004/11/15 11:06:49 herbelin Exp $ *) open Pp open Pcoq @@ -202,21 +202,21 @@ open Rawterm VERNAC COMMAND EXTEND DeriveInversion | [ "Derive" "Inversion" ident(na) "with" constr(c) "Sort" sort(s) ] - -> [ add_inversion_lemma_exn na c s false half_inv_tac ] + -> [ add_inversion_lemma_exn na c s false inv_tac ] | [ "Derive" "Inversion" ident(na) "with" constr(c) ] - -> [ add_inversion_lemma_exn na c (RProp Null) false half_inv_tac ] + -> [ add_inversion_lemma_exn na c (RProp Null) false inv_tac ] | [ "Derive" "Inversion" ident(na) hyp(id) ] - -> [ inversion_lemma_from_goal 1 na id Term.mk_Prop false half_inv_tac ] + -> [ inversion_lemma_from_goal 1 na id Term.mk_Prop false inv_tac ] | [ "Derive" "Inversion" natural(n) ident(na) hyp(id) ] - -> [ inversion_lemma_from_goal n na id Term.mk_Prop false half_inv_tac ] + -> [ inversion_lemma_from_goal n na id Term.mk_Prop false inv_tac ] END VERNAC COMMAND EXTEND DeriveDependentInversion | [ "Derive" "Dependent" "Inversion" ident(na) "with" constr(c) "Sort" sort(s) ] - -> [ add_inversion_lemma_exn na c s true half_dinv_tac ] + -> [ add_inversion_lemma_exn na c s true dinv_tac ] END VERNAC COMMAND EXTEND DeriveDependentInversionClear diff --git a/tactics/extratactics.mli b/tactics/extratactics.mli index a714c8dd..78a94190 100644 --- a/tactics/extratactics.mli +++ b/tactics/extratactics.mli @@ -6,7 +6,7 @@ (* * GNU Lesser General Public License Version 2.1 *) (************************************************************************) -(* $Id: extratactics.mli,v 1.3.10.1 2004/07/16 19:30:53 herbelin Exp $ *) +(*i $Id: extratactics.mli,v 1.3.10.2 2005/01/21 17:14:10 herbelin Exp $ i*) open Names open Term diff --git a/tactics/hiddentac.mli b/tactics/hiddentac.mli index 816678ae..1b37291c 100644 --- a/tactics/hiddentac.mli +++ b/tactics/hiddentac.mli @@ -6,7 +6,7 @@ (* * GNU Lesser General Public License Version 2.1 *) (************************************************************************) -(*i $Id: hiddentac.mli,v 1.19.2.1 2004/07/16 19:30:53 herbelin Exp $ i*) +(*i $Id: hiddentac.mli,v 1.19.2.2 2005/01/21 16:41:52 herbelin Exp $ i*) (*i*) open Names @@ -78,9 +78,9 @@ val h_rename : identifier -> identifier -> tactic (* Constructors *) -(* +(*i val h_any_constructor : tactic -> tactic -*) +i*) val h_constructor : int -> constr bindings -> tactic val h_left : constr bindings -> tactic val h_right : constr bindings -> tactic diff --git a/tactics/setoid_replace.mli b/tactics/setoid_replace.mli index 565ae169..854fa478 100644 --- a/tactics/setoid_replace.mli +++ b/tactics/setoid_replace.mli @@ -6,7 +6,7 @@ (* * GNU Lesser General Public License Version 2.1 *) (************************************************************************) -(* $Id: setoid_replace.mli,v 1.3.6.1 2004/07/16 19:30:55 herbelin Exp $ *) +(*i $Id: setoid_replace.mli,v 1.3.6.2 2005/01/21 17:14:11 herbelin Exp $ i*) open Term open Proof_type diff --git a/tactics/tacinterp.ml b/tactics/tacinterp.ml index 2080b5dc..4f8e7d7c 100644 --- a/tactics/tacinterp.ml +++ b/tactics/tacinterp.ml @@ -6,7 +6,7 @@ (* * GNU Lesser General Public License Version 2.1 *) (************************************************************************) -(* $Id: tacinterp.ml,v 1.84.2.4 2004/07/16 19:30:55 herbelin Exp $ *) +(* $Id: tacinterp.ml,v 1.84.2.8 2005/01/15 14:56:54 herbelin Exp $ *) open Constrintern open Closure @@ -552,8 +552,7 @@ let intern_redexp ist = function | Lazy f -> Lazy (intern_flag ist f) | Pattern l -> Pattern (List.map (intern_constr_occurrence ist) l) | Simpl o -> Simpl (option_app (intern_constr_occurrence ist) o) - | (Red _ | Hnf as r) -> r - | ExtraRedExpr (s,c) -> ExtraRedExpr (s, intern_constr ist c) + | (Red _ | Hnf | ExtraRedExpr _ as r) -> r let intern_inversion_strength lf ist = function | NonDepInversion (k,idl,ids) -> @@ -879,9 +878,12 @@ and intern_genarg ist x = in_gen globwit_red_expr (intern_redexp ist (out_gen rawwit_red_expr x)) | TacticArgType -> in_gen globwit_tactic (intern_tactic ist (out_gen rawwit_tactic x)) + | OpenConstrArgType -> + in_gen globwit_open_constr + ((),intern_constr ist (snd (out_gen rawwit_open_constr x))) | CastedOpenConstrArgType -> in_gen globwit_casted_open_constr - (intern_constr ist (out_gen rawwit_casted_open_constr x)) + ((),intern_constr ist (snd (out_gen rawwit_casted_open_constr x))) | ConstrWithBindingsArgType -> in_gen globwit_constr_with_bindings (intern_constr_with_bindings ist (out_gen rawwit_constr_with_bindings x)) @@ -964,6 +966,10 @@ let is_match_catchable = function | No_match | Eval_fail _ -> true | e -> is_failure e or Logic.catchable_exception e +let hack_fail_level_shift = ref 0 +let hack_fail_level n = + if n >= !hack_fail_level_shift then n - !hack_fail_level_shift else 0 + (* Verifies if the matched list is coherent with respect to lcm *) let rec verify_metas_coherence gl lcm = function | (num,csr)::tl -> @@ -1202,12 +1208,12 @@ let interp_constr ist sigma env c = interp_casted_constr None ist sigma env c (* Interprets an open constr expression casted by the current goal *) -let pf_interp_casted_openconstr ist gl (c,ce) = +let pf_interp_openconstr_gen casted ist gl (c,ce) = let sigma = project gl in let env = pf_env gl in let (ltacvars,l) = constr_list ist env in let typs = retype_list sigma env ltacvars in - let ocl = Some (pf_concl gl) in + let ocl = if casted then Some (pf_concl gl) else None in match ce with | None -> Pretyping.understand_gen_tcc sigma env typs ocl c @@ -1216,6 +1222,9 @@ let pf_interp_casted_openconstr ist gl (c,ce) = intros/lettac/inversion hypothesis names *) | Some c -> interp_openconstr_gen sigma env (ltacvars,l) c ocl +let pf_interp_casted_openconstr = pf_interp_openconstr_gen true +let pf_interp_openconstr = pf_interp_openconstr_gen false + (* Interprets a constr expression *) let pf_interp_constr ist gl = interp_constr ist (project gl) (pf_env gl) @@ -1242,8 +1251,7 @@ let redexp_interp ist sigma env = function | Lazy f -> Lazy (interp_flag ist env f) | Pattern l -> Pattern (List.map (interp_pattern ist sigma env) l) | Simpl o -> Simpl (option_app (interp_pattern ist sigma env) o) - | (Red _ | Hnf as r) -> r - | ExtraRedExpr (s,c) -> ExtraRedExpr (s,interp_constr ist sigma env c) + | (Red _ | Hnf | ExtraRedExpr _ as r) -> r let pf_redexp_interp ist gl = redexp_interp ist (project gl) (pf_env gl) @@ -1349,7 +1357,7 @@ and eval_tactic ist = function | TacMatchContext _ -> assert false | TacMatch (c,lmr) -> assert false | TacId s -> tclIDTAC_MESSAGE s - | TacFail (n,s) -> tclFAIL (interp_int_or_var ist n) s + | TacFail (n,s) -> tclFAIL (hack_fail_level (interp_int_or_var ist n)) s | TacProgress tac -> tclPROGRESS (interp_tactic ist tac) | TacAbstract (tac,s) -> Tactics.tclABSTRACT s (interp_tactic ist tac) | TacThen (t1,t2) -> tclTHEN (interp_tactic ist t1) (interp_tactic ist t2) @@ -1494,7 +1502,7 @@ and interp_match_context ist g lr lmr = let lgoal = List.map (fun (id,c) -> (id,VConstr c)) lgoal in eval_with_fail { ist with lfun=lgoal@lctxt@ist.lfun } mt goal else - apply_hyps_context ist env goal mt lgoal mhyps hyps + apply_hyps_context ist env goal mt lctxt lgoal mhyps hyps with | e when is_failure e -> raise e | NextOccurrence _ -> raise No_match @@ -1508,7 +1516,9 @@ and interp_match_context ist g lr lmr = begin db_mc_pattern_success ist.debug; try eval_with_fail ist t goal - with e when is_match_catchable e -> + with + | e when is_failure e -> raise e + | e when is_match_catchable e -> apply_match_context ist env goal (nrs+1) (List.tl lex) tl end | (Pat (mhyps,mgoal,mt))::tl -> @@ -1529,9 +1539,10 @@ and interp_match_context ist g lr lmr = eval_with_fail {ist with lfun=lgoal@ist.lfun} mt goal end else - apply_hyps_context ist env goal mt lgoal mhyps hyps + apply_hyps_context ist env goal mt [] lgoal mhyps hyps end) with + | e when is_failure e -> raise e | e when is_match_catchable e -> begin (match e with @@ -1542,7 +1553,9 @@ and interp_match_context ist g lr lmr = end) | Subterm (id,mg) -> (try apply_goal_sub ist env goal 0 (id,mg) concl mt mhyps hyps - with e when is_match_catchable e -> + with + | e when is_failure e -> raise e + | e when is_match_catchable e -> apply_match_context ist env goal (nrs+1) (List.tl lex) tl)) | _ -> errorlabstrm "Tacinterp.apply_match_context" (str @@ -1557,7 +1570,7 @@ and interp_match_context ist g lr lmr = (read_match_rule (project g) env (fst (constr_list ist env)) lmr) (* Tries to match the hypotheses in a Match Context *) -and apply_hyps_context ist env goal mt lgmatch mhyps hyps = +and apply_hyps_context ist env goal mt lctxt lgmatch mhyps hyps = let rec apply_hyps_context_rec lfun lmatch lhyps_rest current = function | Hyp ((_,hypname),mhyp)::tl as mhyps -> let (lids,lm,hyp_match,next) = @@ -1578,7 +1591,7 @@ and apply_hyps_context ist env goal mt lgmatch mhyps hyps = db_mc_pattern_success ist.debug; eval_with_fail {ist with lfun=lmatch@lfun@ist.lfun} mt goal in - apply_hyps_context_rec [] lgmatch hyps (hyps,0) mhyps + apply_hyps_context_rec lctxt lgmatch hyps (hyps,0) mhyps (* Interprets extended tactic generic arguments *) and interp_genarg ist goal x = @@ -1617,9 +1630,12 @@ and interp_genarg ist goal x = | RedExprArgType -> in_gen wit_red_expr (pf_redexp_interp ist goal (out_gen globwit_red_expr x)) | TacticArgType -> in_gen wit_tactic (out_gen globwit_tactic x) + | OpenConstrArgType -> + in_gen wit_open_constr + (pf_interp_openconstr ist goal (snd (out_gen globwit_open_constr x))) | CastedOpenConstrArgType -> in_gen wit_casted_open_constr - (pf_interp_casted_openconstr ist goal (out_gen globwit_casted_open_constr x)) + (pf_interp_casted_openconstr ist goal (snd (out_gen globwit_casted_open_constr x))) | ConstrWithBindingsArgType -> in_gen wit_constr_with_bindings (interp_constr_with_bindings ist goal (out_gen globwit_constr_with_bindings x)) @@ -1641,6 +1657,8 @@ and interp_match ist g constr lmr = let lm = List.map (fun (id,c) -> (id,VConstr c)) lm in val_interp {ist with lfun=lm@lctxt@ist.lfun} g mt with | NextOccurrence _ -> raise No_match + | e when is_match_catchable e -> + apply_sub_match ist (nocc + 1) (id,c) csr mt in let rec apply_match ist csr = function | (All t)::_ -> @@ -1668,7 +1686,14 @@ and interp_match ist g constr lmr = errorlabstrm "Tacinterp.apply_match" (str "Argument of match does not evaluate to a term") in let ilr = read_match_rule (project g) env (fst (constr_list ist env)) lmr in - apply_match ist csr ilr + try + incr hack_fail_level_shift; + let x = apply_match ist csr ilr in + decr hack_fail_level_shift; + x + with e -> + decr hack_fail_level_shift; + raise e (* Interprets tactic expressions : returns a "tactic" *) and interp_tactic ist tac gl = @@ -1829,7 +1854,7 @@ and interp_atomic ist gl = function | TacticArgType -> val_interp ist gl (out_gen globwit_tactic x) | StringArgType | BoolArgType - | QuantHypArgType | RedExprArgType + | QuantHypArgType | RedExprArgType | OpenConstrArgType | CastedOpenConstrArgType | ConstrWithBindingsArgType | BindingsArgType | ExtraArgType _ | List0ArgType _ | List1ArgType _ | OptArgType _ | PairArgType _ -> error "This generic type is not supported in alias" @@ -1926,8 +1951,7 @@ let subst_redexp subst = function | Lazy f -> Lazy (subst_flag subst f) | Pattern l -> Pattern (List.map (subst_constr_occurrence subst) l) | Simpl o -> Simpl (option_app (subst_constr_occurrence subst) o) - | (Red _ | Hnf as r) -> r - | ExtraRedExpr (s,c) -> ExtraRedExpr (s, subst_rawconstr subst c) + | (Red _ | Hnf | ExtraRedExpr _ as r) -> r let subst_raw_may_eval subst = function | ConstrEval (r,c) -> ConstrEval (subst_redexp subst r,subst_rawconstr subst c) @@ -2120,9 +2144,12 @@ and subst_genarg subst (x:glob_generic_argument) = in_gen globwit_red_expr (subst_redexp subst (out_gen globwit_red_expr x)) | TacticArgType -> in_gen globwit_tactic (subst_tactic subst (out_gen globwit_tactic x)) + | OpenConstrArgType -> + in_gen globwit_open_constr + ((),subst_rawconstr subst (snd (out_gen globwit_open_constr x))) | CastedOpenConstrArgType -> in_gen globwit_casted_open_constr - (subst_rawconstr subst (out_gen globwit_casted_open_constr x)) + ((),subst_rawconstr subst (snd (out_gen globwit_casted_open_constr x))) | ConstrWithBindingsArgType -> in_gen globwit_constr_with_bindings (subst_raw_with_bindings subst (out_gen globwit_constr_with_bindings x)) diff --git a/tactics/tacticals.mli b/tactics/tacticals.mli index 2cb63b40..111a5e2d 100644 --- a/tactics/tacticals.mli +++ b/tactics/tacticals.mli @@ -6,7 +6,7 @@ (* * GNU Lesser General Public License Version 2.1 *) (************************************************************************) -(*i $Id: tacticals.mli,v 1.38.2.1 2004/07/16 19:30:55 herbelin Exp $ i*) +(*i $Id: tacticals.mli,v 1.38.2.2 2005/01/21 16:41:52 herbelin Exp $ i*) (*i*) open Names @@ -127,7 +127,7 @@ type branch_assumptions = { ba : branch_args; (* the branch args *) assums : named_context} (* the list of assumptions introduced *) -(* Useful for "as intro_pattern" modifier *) +(* Useful for [as intro_pattern] modifier *) val compute_induction_names : int -> intro_pattern_expr option -> intro_pattern_expr list array diff --git a/tactics/tactics.ml b/tactics/tactics.ml index cab4f025..b6eaf015 100644 --- a/tactics/tactics.ml +++ b/tactics/tactics.ml @@ -6,7 +6,7 @@ (* * GNU Lesser General Public License Version 2.1 *) (************************************************************************) -(* $Id: tactics.ml,v 1.162.2.2 2004/07/16 19:30:55 herbelin Exp $ *) +(* $Id: tactics.ml,v 1.162.2.4 2004/12/04 10:26:46 herbelin Exp $ *) open Pp open Util @@ -654,7 +654,7 @@ let occurrences_of_hyp id cls = let occurrences_of_goal cls = if cls.onconcl then Some cls.concl_occs else None -let everywhere cls = (cls=allClauses) +let in_every_hyp cls = (cls.onhyps = None) (* (* Implementation with generalisation then re-intro: introduces noise *) @@ -721,8 +721,8 @@ let letin_abstract id c occs gl = | None -> depdecls | Some occ -> let newdecl = subst_term_occ_decl occ c d in - if d = newdecl then - if not (everywhere occs) + if occ = [] & d = newdecl then + if not (in_every_hyp occs) then raise (RefinerError (DoesNotOccurIn (c,hyp))) else depdecls else @@ -1175,7 +1175,7 @@ let induct_discharge statuslists destopt avoid' ((avoid7,avoid8),ra) (names,forc (match kind_of_term (pf_concl gl) with | Prod (name,t,_) -> (name,None,t) | LetIn (name,b,t,_) -> (name,Some b,t) - | _ -> assert false)) gl in + | _ -> raise (RefinerError IntroNeedsProduct))) gl in if Options.do_translate() & id7 <> id8 then force := true; let id = if !Options.v7 then id7 else id8 in rnames := !rnames @ [IntroIdentifier id]; @@ -1192,12 +1192,12 @@ let induct_discharge statuslists destopt avoid' ((avoid7,avoid8),ra) (names,forc (match kind_of_term (pf_concl gl) with | Prod (name,t,_) -> (name,None,t) | LetIn (name,b,t,_) -> (name,Some b,t) - | _ -> assert false)) gl in + | _ -> raise (RefinerError IntroNeedsProduct))) gl in let id8 = fresh_id avoid8 (default_id gl (match kind_of_term (pf_concl gl) with | Prod (name,t,_) -> (name,None,t) | LetIn (name,b,t,_) -> (name,Some b,t) - | _ -> assert false)) gl in + | _ -> raise (RefinerError IntroNeedsProduct))) gl in if Options.do_translate() & id7 <> id8 then force := true; let id = if !Options.v7 then id7 else id8 in let avoid = if !Options.v7 then avoid7 else avoid8 in diff --git a/tactics/tactics.mli b/tactics/tactics.mli index 6e67a9cd..1155d845 100644 --- a/tactics/tactics.mli +++ b/tactics/tactics.mli @@ -6,7 +6,7 @@ (* * GNU Lesser General Public License Version 2.1 *) (************************************************************************) -(*i $Id: tactics.mli,v 1.59.2.1 2004/07/16 19:30:55 herbelin Exp $ i*) +(*i $Id: tactics.mli,v 1.59.2.2 2005/01/21 16:41:52 herbelin Exp $ i*) (*i*) open Names @@ -26,6 +26,7 @@ open Genarg open Tacexpr open Nametab open Rawterm +(*i*) (* Main tactics. *) diff --git a/test-suite/check b/test-suite/check index 1c7822d1..378c8e5d 100755 --- a/test-suite/check +++ b/test-suite/check @@ -99,7 +99,7 @@ test_parser() { foutput=`dirname $f`/`basename $f .v`.out echo "parse_file 1 \"$f\"" | ../bin/parser > $tmpoutput 2>&1 perl -ne 'if(/Starting.*Parser Loop/){$printit = 1};print if $printit' \ - $tmpoutput | grep -i error > /dev/null + $tmpoutput 2>&1 | grep -i error > /dev/null if [ $? = 0 ] ; then echo "Error! (unexpected output)" else diff --git a/test-suite/success/RecTutorial.v8 b/test-suite/success/RecTutorial.v8 new file mode 100644 index 00000000..1cef3f2f --- /dev/null +++ b/test-suite/success/RecTutorial.v8 @@ -0,0 +1,1229 @@ +Inductive nat : Set := + | O : nat + | S : nat->nat. +Check nat. +Check O. +Check S. + +Reset nat. +Print nat. + + +Print le. + +Theorem zero_leq_three: 0 <= 3. + +Proof. + constructor 2. + constructor 2. + constructor 2. + constructor 1. + +Qed. + +Print zero_leq_three. + + +Lemma zero_leq_three': 0 <= 3. + repeat constructor. +Qed. + + +Lemma zero_lt_three : 0 < 3. +Proof. + unfold lt. + repeat constructor. +Qed. + + +Require Import List. + +Print list. + +Check list. + +Check (nil (A:=nat)). + +Check (nil (A:= nat -> nat)). + +Check (fun A: Set => (cons (A:=A))). + +Check (cons 3 (cons 2 nil)). + + + + +Require Import Bvector. + +Print vector. + +Check (Vnil nat). + +Check (fun (A:Set)(a:A)=> Vcons _ a _ (Vnil _)). + +Check (Vcons _ 5 _ (Vcons _ 3 _ (Vnil _))). + + + + + + + + + + + + + +Lemma eq_3_3 : 2 + 1 = 3. +Proof. + reflexivity. +Qed. +Print eq_3_3. + +Lemma eq_proof_proof : refl_equal (2*6) = refl_equal (3*4). +Proof. + reflexivity. +Qed. +Print eq_proof_proof. + +Lemma eq_lt_le : ( 2 < 4) = (3 <= 4). +Proof. + reflexivity. +Qed. + +Lemma eq_nat_nat : nat = nat. +Proof. + reflexivity. +Qed. + +Lemma eq_Set_Set : Set = Set. +Proof. + reflexivity. +Qed. + +Lemma eq_Type_Type : Type = Type. +Proof. + reflexivity. +Qed. + + +Check (2 + 1 = 3). + + +Check (Type = Type). + +Goal Type = Type. +reflexivity. +Qed. + + +Print or. + +Print and. + + +Print sumbool. + +Print ex. + +Require Import ZArith. +Require Import Compare_dec. + +Check le_lt_dec. + +Definition max (n p :nat) := match le_lt_dec n p with + | left _ => p + | right _ => n + end. + +Theorem le_max : forall n p, n <= p -> max n p = p. +Proof. + intros n p ; unfold max ; case (le_lt_dec n p); simpl. + trivial. + intros; absurd (p < p); eauto with arith. +Qed. + +Extraction max. + + + + + + +Inductive tree(A:Set) : Set := + node : A -> forest A -> tree A +with + forest (A: Set) : Set := + nochild : forest A | + addchild : tree A -> forest A -> forest A. + + + + + +Inductive + even : nat->Prop := + evenO : even O | + evenS : forall n, odd n -> even (S n) +with + odd : nat->Prop := + oddS : forall n, even n -> odd (S n). + +Lemma odd_49 : odd (7 * 7). + simpl; repeat constructor. +Qed. + + + +Definition nat_case := + fun (Q : Type)(g0 : Q)(g1 : nat -> Q)(n:nat) => + match n return Q with + | 0 => g0 + | S p => g1 p + end. + +Eval simpl in (nat_case nat 0 (fun p => p) 34). + +Eval simpl in (fun g0 g1 => nat_case nat g0 g1 34). + +Eval simpl in (fun g0 g1 => nat_case nat g0 g1 0). + + +Definition pred (n:nat) := match n with O => O | S m => m end. + +Eval simpl in pred 56. + +Eval simpl in pred 0. + +Eval simpl in fun p => pred (S p). + + +Definition xorb (b1 b2:bool) := +match b1, b2 with + | false, true => true + | true, false => true + | _ , _ => false +end. + + + Definition pred_spec (n:nat) := {m:nat | n=0 /\ m=0 \/ n = S m}. + + + Definition predecessor : forall n:nat, pred_spec n. + intro n;case n. + unfold pred_spec;exists 0;auto. + unfold pred_spec; intro n0;exists n0; auto. + Defined. + +Print predecessor. + +Extraction predecessor. + +Theorem nat_expand : + forall n:nat, n = match n with 0 => 0 | S p => S p end. + intro n;case n;simpl;auto. +Qed. + +Check (fun p:False => match p return 2=3 with end). + +Theorem fromFalse : False -> 0=1. + intro absurd. + contradiction. +Qed. + +Section equality_elimination. + Variables (A: Type) + (a b : A) + (p : a = b) + (Q : A -> Type). + Check (fun H : Q a => + match p in (eq _ y) return Q y with + refl_equal => H + end). + +End equality_elimination. + + +Theorem trans : forall n m p:nat, n=m -> m=p -> n=p. +Proof. + intros n m p eqnm. + case eqnm. + trivial. +Qed. + +Lemma Rw : forall x y: nat, y = y * x -> y * x * x = y. + intros x y e; do 2 rewrite <- e. + reflexivity. +Qed. + + +Require Import Arith. + +Check mult_1_l. +(* +mult_1_l + : forall n : nat, 1 * n = n +*) + +Check mult_plus_distr_r. +(* +mult_plus_distr_r + : forall n m p : nat, (n + m) * p = n * p + m * p + +*) + +Lemma mult_distr_S : forall n p : nat, n * p + p = (S n)* p. + simpl;auto with arith. +Qed. + +Lemma four_n : forall n:nat, n+n+n+n = 4*n. + intro n;rewrite <- (mult_1_l n). + + Undo. + intro n; pattern n at 1. + + + rewrite <- mult_1_l. + repeat rewrite mult_distr_S. + trivial. +Qed. + + +Section Le_case_analysis. + Variables (n p : nat) + (H : n <= p) + (Q : nat -> Prop) + (H0 : Q n) + (HS : forall m, n <= m -> Q (S m)). + Check ( + match H in (_ <= q) return (Q q) with + | le_n => H0 + | le_S m Hm => HS m Hm + end + ). + + +End Le_case_analysis. + + +Lemma predecessor_of_positive : forall n, 1 <= n -> exists p:nat, n = S p. +Proof. + intros n H; case H. + exists 0; trivial. + intros m Hm; exists m;trivial. +Qed. + +Definition Vtail_total + (A : Set) (n : nat) (v : vector A n) : vector A (pred n):= +match v in (vector _ n0) return (vector A (pred n0)) with +| Vnil => Vnil A +| Vcons _ n0 v0 => v0 +end. + +Definition Vtail' (A:Set)(n:nat)(v:vector A n) : vector A (pred n). + intros A n v; case v. + simpl. + exact (Vnil A). + simpl. + auto. +Defined. + +(* +Inductive Lambda : Set := + lambda : (Lambda -> False) -> Lambda. + + +Error: Non strictly positive occurrence of "Lambda" in + "(Lambda -> False) -> Lambda" + +*) + +Section Paradox. + Variable Lambda : Set. + Variable lambda : (Lambda -> False) ->Lambda. + + Variable matchL : Lambda -> forall Q:Prop, ((Lambda ->False) -> Q) -> Q. + (* + understand matchL Q l (fun h : Lambda -> False => t) + + as match l return Q with lambda h => t end + *) + + Definition application (f x: Lambda) :False := + matchL f False (fun h => h x). + + Definition Delta : Lambda := lambda (fun x : Lambda => application x x). + + Definition loop : False := application Delta Delta. + + Theorem two_is_three : 2 = 3. + Proof. + elim loop. + Qed. + +End Paradox. + + +Require Import ZArith. + + + +Inductive itree : Set := +| ileaf : itree +| inode : Z-> (nat -> itree) -> itree. + +Definition isingle l := inode l (fun i => ileaf). + +Definition t1 := inode 0 (fun n => isingle (Z_of_nat (2*n))). + +Definition t2 := inode 0 + (fun n : nat => + inode (Z_of_nat n) + (fun p => isingle (Z_of_nat (n*p)))). + + +Inductive itree_le : itree-> itree -> Prop := + | le_leaf : forall t, itree_le ileaf t + | le_node : forall l l' s s', + Zle l l' -> + (forall i, exists j:nat, itree_le (s i) (s' j)) -> + itree_le (inode l s) (inode l' s'). + + +Theorem itree_le_trans : + forall t t', itree_le t t' -> + forall t'', itree_le t' t'' -> itree_le t t''. + induction t. + constructor 1. + + intros t'; case t'. + inversion 1. + intros z0 i0 H0. + intro t'';case t''. + inversion 1. + intros. + inversion_clear H1. + constructor 2. + inversion_clear H0;eauto with zarith. + inversion_clear H0. + intro i2; case (H4 i2). + intros. + generalize (H i2 _ H0). + intros. + case (H3 x);intros. + generalize (H5 _ H6). + exists x0;auto. +Qed. + + + +Inductive itree_le' : itree-> itree -> Prop := + | le_leaf' : forall t, itree_le' ileaf t + | le_node' : forall l l' s s' g, + Zle l l' -> + (forall i, itree_le' (s i) (s' (g i))) -> + itree_le' (inode l s) (inode l' s'). + + + + + +Lemma t1_le_t2 : itree_le t1 t2. + unfold t1, t2. + constructor. + auto with zarith. + intro i; exists (2 * i). + unfold isingle. + constructor. + auto with zarith. + exists i;constructor. +Qed. + + + +Lemma t1_le'_t2 : itree_le' t1 t2. + unfold t1, t2. + constructor 2 with (fun i : nat => 2 * i). + auto with zarith. + unfold isingle; + intro i ; constructor 2 with (fun i :nat => i). + auto with zarith. + constructor . +Qed. + + +Require Import List. + +Inductive ltree (A:Set) : Set := + lnode : A -> list (ltree A) -> ltree A. + +Inductive prop : Prop := + prop_intro : Prop -> prop. + +Lemma prop_inject: prop. +Proof prop_intro prop. + + +Inductive ex_Prop (P : Prop -> Prop) : Prop := + exP_intro : forall X : Prop, P X -> ex_Prop P. + +Lemma ex_Prop_inhabitant : ex_Prop (fun P => P -> P). +Proof. + exists (ex_Prop (fun P => P -> P)). + trivial. +Qed. + + + + +(* + +Check (fun (P:Prop->Prop)(p: ex_Prop P) => + match p with exP_intro X HX => X end). +Error: +Incorrect elimination of "p" in the inductive type +"ex_Prop", the return type has sort "Type" while it should be +"Prop" + +Elimination of an inductive object of sort "Prop" +is not allowed on a predicate in sort "Type" +because proofs can be eliminated only to build proofs + +*) + +(* +Check (match prop_inject with (prop_intro P p) => P end). + +Error: +Incorrect elimination of "prop_inject" in the inductive type +"prop", the return type has sort "Type" while it should be +"Prop" + +Elimination of an inductive object of sort "Prop" +is not allowed on a predicate in sort "Type" +because proofs can be eliminated only to build proofs + +*) +Print prop_inject. + +(* +prop_inject = +prop_inject = prop_intro prop (fun H : prop => H) + : prop +*) + + +Inductive typ : Type := + typ_intro : Type -> typ. + +Definition typ_inject: typ. +split. +exact typ. +(* +Defined. + +Error: Universe Inconsistency. +*) +Abort. +(* + +Inductive aSet : Set := + aSet_intro: Set -> aSet. + + +User error: Large non-propositional inductive types must be in Type + +*) + +Inductive ex_Set (P : Set -> Prop) : Type := + exS_intro : forall X : Set, P X -> ex_Set P. + + +Inductive comes_from_the_left (P Q:Prop): P \/ Q -> Prop := + c1 : forall p, comes_from_the_left P Q (or_introl (A:=P) Q p). + +Goal (comes_from_the_left _ _ (or_introl True I)). +split. +Qed. + +Goal ~(comes_from_the_left _ _ (or_intror True I)). + red;inversion 1. + (* discriminate H0. + *) +Abort. + +Reset comes_from_the_left. + +(* + + + + + + + Definition comes_from_the_left (P Q:Prop)(H:P \/ Q): Prop := + match H with + | or_introl p => True + | or_intror q => False + end. + +Error: +Incorrect elimination of "H" in the inductive type +"or", the return type has sort "Type" while it should be +"Prop" + +Elimination of an inductive object of sort "Prop" +is not allowed on a predicate in sort "Type" +because proofs can be eliminated only to build proofs + +*) + +Definition comes_from_the_left_sumbool + (P Q:Prop)(x:{P}+{Q}): Prop := + match x with + | left p => True + | right q => False + end. + + + + +Close Scope Z_scope. + + + + + +Theorem S_is_not_O : forall n, S n <> 0. + +Definition Is_zero (x:nat):= match x with + | 0 => True + | _ => False + end. + Lemma O_is_zero : forall m, m = 0 -> Is_zero m. + Proof. + intros m H; subst m. + (* + ============================ + Is_zero 0 + *) + simpl;trivial. + Qed. + + red; intros n Hn. + apply O_is_zero with (m := S n). + assumption. +Qed. + +Theorem disc2 : forall n, S (S n) <> 1. +Proof. + intros n Hn; discriminate. +Qed. + + +Theorem disc3 : forall n, S (S n) = 0 -> forall Q:Prop, Q. +Proof. + intros n Hn Q. + discriminate. +Qed. + + + +Theorem inj_succ : forall n m, S n = S m -> n = m. +Proof. + + +Lemma inj_pred : forall n m, n = m -> pred n = pred m. +Proof. + intros n m eq_n_m. + rewrite eq_n_m. + trivial. +Qed. + + intros n m eq_Sn_Sm. + apply inj_pred with (n:= S n) (m := S m); assumption. +Qed. + +Lemma list_inject : forall (A:Set)(a b :A)(l l':list A), + a :: b :: l = b :: a :: l' -> a = b /\ l = l'. +Proof. + intros A a b l l' e. + injection e. + auto. +Qed. + + +Theorem not_le_Sn_0 : forall n:nat, ~ (S n <= 0). +Proof. + red; intros n H. + case H. +Undo. + +Lemma not_le_Sn_0_with_constraints : + forall n p , S n <= p -> p = 0 -> False. +Proof. + intros n p H; case H ; + intros; discriminate. +Qed. + +eapply not_le_Sn_0_with_constraints; eauto. +Qed. + + +Theorem not_le_Sn_0' : forall n:nat, ~ (S n <= 0). +Proof. + red; intros n H ; inversion H. +Qed. + +Derive Inversion le_Sn_0_inv with (forall n :nat, S n <= 0). +Check le_Sn_0_inv. + +Theorem le_Sn_0'' : forall n p : nat, ~ S n <= 0 . +Proof. + intros n p H; + inversion H using le_Sn_0_inv. +Qed. + +Derive Inversion_clear le_Sn_0_inv' with (forall n :nat, S n <= 0). +Check le_Sn_0_inv'. + + +Theorem le_reverse_rules : + forall n m:nat, n <= m -> + n = m \/ + exists p, n <= p /\ m = S p. +Proof. + intros n m H; inversion H. + left;trivial. + right; exists m0; split; trivial. +Restart. + intros n m H; inversion_clear H. + left;trivial. + right; exists m0; split; trivial. +Qed. + +Inductive ArithExp : Set := + Zero : ArithExp + | Succ : ArithExp -> ArithExp + | Plus : ArithExp -> ArithExp -> ArithExp. + +Inductive RewriteRel : ArithExp -> ArithExp -> Prop := + RewSucc : forall e1 e2 :ArithExp, + RewriteRel e1 e2 -> RewriteRel (Succ e1) (Succ e2) + | RewPlus0 : forall e:ArithExp, + RewriteRel (Plus Zero e) e + | RewPlusS : forall e1 e2:ArithExp, + RewriteRel e1 e2 -> + RewriteRel (Plus (Succ e1) e2) (Succ (Plus e1 e2)). + + + +Fixpoint plus (n p:nat) {struct n} : nat := + match n with + | 0 => p + | S m => S (plus m p) + end. + +Fixpoint plus' (n p:nat) {struct p} : nat := + match p with + | 0 => n + | S q => S (plus' n q) + end. + +Fixpoint plus'' (n p:nat) {struct n} : nat := + match n with + | 0 => p + | S m => plus'' m (S p) + end. + + +Fixpoint even_test (n:nat) : bool := + match n + with 0 => true + | 1 => false + | S (S p) => even_test p + end. + + +Reset even_test. + +Fixpoint even_test (n:nat) : bool := + match n + with + | 0 => true + | S p => odd_test p + end +with odd_test (n:nat) : bool := + match n + with + | 0 => false + | S p => even_test p + end. + + + +Eval simpl in even_test. + + + +Eval simpl in (fun x : nat => even_test x). + + +Eval simpl in (fun x : nat => even_test (plus 5 x)). + +Eval simpl in (fun x : nat => even_test (plus x 5)). + + +Section Principle_of_Induction. +Variable P : nat -> Prop. +Hypothesis base_case : P 0. +Hypothesis inductive_hyp : forall n:nat, P n -> P (S n). +Fixpoint nat_ind (n:nat) : (P n) := + match n return P n with + | 0 => base_case + | S m => inductive_hyp m (nat_ind m) + end. + +End Principle_of_Induction. + +Scheme Even_induction := Minimality for even Sort Prop +with Odd_induction := Minimality for odd Sort Prop. + +Theorem even_plus_four : forall n:nat, even n -> even (4+n). +Proof. + intros n H. + elim H using Even_induction with (P0 := fun n => odd (4+n)); + simpl;repeat constructor;assumption. +Qed. + + +Section Principle_of_Double_Induction. +Variable P : nat -> nat ->Prop. +Hypothesis base_case1 : forall x:nat, P 0 x. +Hypothesis base_case2 : forall x:nat, P (S x) 0. +Hypothesis inductive_hyp : forall n m:nat, P n m -> P (S n) (S m). +Fixpoint nat_double_ind (n m:nat){struct n} : P n m := + match n, m return P n m with + | 0 , x => base_case1 x + | (S x), 0 => base_case2 x + | (S x), (S y) => inductive_hyp x y (nat_double_ind x y) + end. +End Principle_of_Double_Induction. + +Section Principle_of_Double_Recursion. +Variable P : nat -> nat -> Set. +Hypothesis base_case1 : forall x:nat, P 0 x. +Hypothesis base_case2 : forall x:nat, P (S x) 0. +Hypothesis inductive_hyp : forall n m:nat, P n m -> P (S n) (S m). +Fixpoint nat_double_rec (n m:nat){struct n} : P n m := + match n, m return P n m with + | 0 , x => base_case1 x + | (S x), 0 => base_case2 x + | (S x), (S y) => inductive_hyp x y (nat_double_rec x y) + end. +End Principle_of_Double_Recursion. + +Definition min : nat -> nat -> nat := + nat_double_rec (fun (x y:nat) => nat) + (fun (x:nat) => 0) + (fun (y:nat) => 0) + (fun (x y r:nat) => S r). + +Eval compute in (min 5 8). +Eval compute in (min 8 5). + + + +Lemma not_circular : forall n:nat, n <> S n. +Proof. + intro n. + apply nat_ind with (P:= fun n => n <> S n). + discriminate. + red; intros n0 Hn0 eqn0Sn0;injection eqn0Sn0;trivial. +Qed. + +Definition eq_nat_dec : forall n p:nat , {n=p}+{n <> p}. +Proof. + intros n p. + apply nat_double_rec with (P:= fun (n q:nat) => {q=p}+{q <> p}). +Undo. + pattern p,n. + elim n using nat_double_rec. + destruct x; auto. + destruct x; auto. + intros n0 m H; case H. + intro eq; rewrite eq ; auto. + intro neg; right; red ; injection 1; auto. +Defined. + +Definition eq_nat_dec' : forall n p:nat, {n=p}+{n <> p}. + decide equality. +Defined. + +Print Acc. + + +Require Import Minus. + +(* +Fixpoint div (x y:nat){struct x}: nat := + if eq_nat_dec x 0 + then 0 + else if eq_nat_dec y 0 + then x + else S (div (x-y) y). + +Error: +Recursive definition of div is ill-formed. +In environment +div : nat -> nat -> nat +x : nat +y : nat +_ : x <> 0 +_ : y <> 0 + +Recursive call to div has principal argument equal to +"x - y" +instead of a subterm of x + +*) + +Lemma minus_smaller_S: forall x y:nat, x - y < S x. +Proof. + intros x y; pattern y, x; + elim x using nat_double_ind. + destruct x0; auto with arith. + simpl; auto with arith. + simpl; auto with arith. +Qed. + +Lemma minus_smaller_positive : forall x y:nat, x <>0 -> y <> 0 -> + x - y < x. +Proof. + destruct x; destruct y; + ( simpl;intros; apply minus_smaller_S || + intros; absurd (0=0); auto). +Qed. + +Definition minus_decrease : forall x y:nat, Acc lt x -> + x <> 0 -> + y <> 0 -> + Acc lt (x-y). +Proof. + intros x y H; case H. + intros z Hz posz posy. + apply Hz; apply minus_smaller_positive; assumption. +Defined. + +Print minus_decrease. + + + +Definition div_aux (x y:nat)(H: Acc lt x):nat. + fix 3. + intros. + refine (if eq_nat_dec x 0 + then 0 + else if eq_nat_dec y 0 + then y + else div_aux (x-y) y _). + apply (minus_decrease x y H);assumption. +Defined. + + +Print div_aux. +(* +div_aux = +(fix div_aux (x y : nat) (H : Acc lt x) {struct H} : nat := + match eq_nat_dec x 0 with + | left _ => 0 + | right _ => + match eq_nat_dec y 0 with + | left _ => y + | right _0 => div_aux (x - y) y (minus_decrease x y H _ _0) + end + end) + : forall x : nat, nat -> Acc lt x -> nat +*) + +Require Import Wf_nat. +Definition div x y := div_aux x y (lt_wf x). + +Extraction div. +(* +let div x y = + div_aux x y +*) + +Extraction div_aux. + +(* +let rec div_aux x y = + match eq_nat_dec x O with + | Left -> O + | Right -> + (match eq_nat_dec y O with + | Left -> y + | Right -> div_aux (minus x y) y) +*) + +Lemma vector0_is_vnil : forall (A:Set)(v:vector A 0), v = Vnil A. +Proof. + intros A v;inversion v. +Abort. + +(* + Lemma vector0_is_vnil_aux : forall (A:Set)(n:nat)(v:vector A n), + n= 0 -> v = Vnil A. + +Toplevel input, characters 40281-40287 +> Lemma vector0_is_vnil_aux : forall (A:Set)(n:nat)(v:vector A n), n= 0 -> v = Vnil A. +> ^^^^^^ +Error: In environment +A : Set +n : nat +v : vector A n +e : n = 0 +The term "Vnil A" has type "vector A 0" while it is expected to have type + "vector A n" +*) + Require Import JMeq. + +Lemma vector0_is_vnil_aux : forall (A:Set)(n:nat)(v:vector A n), + n= 0 -> JMeq v (Vnil A). +Proof. + destruct v. + auto. + intro; discriminate. +Qed. + +Lemma vector0_is_vnil : forall (A:Set)(v:vector A 0), v = Vnil A. +Proof. + intros a v;apply JMeq_eq. + apply vector0_is_vnil_aux. + trivial. +Qed. + + +Implicit Arguments Vcons [A n]. +Implicit Arguments Vnil [A]. +Implicit Arguments Vhead [A n]. +Implicit Arguments Vtail [A n]. + +Definition Vid : forall (A : Set)(n:nat), vector A n -> vector A n. +Proof. + destruct n; intro v. + exact Vnil. + exact (Vcons (Vhead v) (Vtail v)). +Defined. + +Eval simpl in (fun (A:Set)(v:vector A 0) => (Vid _ _ v)). + +Eval simpl in (fun (A:Set)(v:vector A 0) => v). + + + +Lemma Vid_eq : forall (n:nat) (A:Set)(v:vector A n), v=(Vid _ n v). +Proof. + destruct v. + reflexivity. + reflexivity. +Defined. + +Theorem zero_nil : forall A (v:vector A 0), v = Vnil. +Proof. + intros. + change (Vnil (A:=A)) with (Vid _ 0 v). + apply Vid_eq. +Defined. + + +Theorem decomp : + forall (A : Set) (n : nat) (v : vector A (S n)), + v = Vcons (Vhead v) (Vtail v). +Proof. + intros. + change (Vcons (Vhead v) (Vtail v)) with (Vid _ (S n) v). + apply Vid_eq. +Defined. + + + +Definition vector_double_rect : + forall (A:Set) (P: forall (n:nat),(vector A n)->(vector A n) -> Type), + P 0 Vnil Vnil -> + (forall n (v1 v2 : vector A n) a b, P n v1 v2 -> + P (S n) (Vcons a v1) (Vcons b v2)) -> + forall n (v1 v2 : vector A n), P n v1 v2. + induction n. + intros; rewrite (zero_nil _ v1); rewrite (zero_nil _ v2). + auto. + intros v1 v2; rewrite (decomp _ _ v1);rewrite (decomp _ _ v2). + apply X0; auto. +Defined. + +Require Import Bool. + +Definition bitwise_or n v1 v2 : vector bool n := + vector_double_rect bool (fun n v1 v2 => vector bool n) + Vnil + (fun n v1 v2 a b r => Vcons (orb a b) r) n v1 v2. + + +Fixpoint vector_nth (A:Set)(n:nat)(p:nat)(v:vector A p){struct v} + : option A := + match n,v with + _ , Vnil => None + | 0 , Vcons b _ _ => Some b + | S n', Vcons _ p' v' => vector_nth A n' p' v' + end. + +Implicit Arguments vector_nth [A p]. + + +Lemma nth_bitwise : forall (n:nat) (v1 v2: vector bool n) i a b, + vector_nth i v1 = Some a -> + vector_nth i v2 = Some b -> + vector_nth i (bitwise_or _ v1 v2) = Some (orb a b). +Proof. + intros n v1 v2; pattern n,v1,v2. + apply vector_double_rect. + simpl. + destruct i; discriminate 1. + destruct i; simpl;auto. + injection 1; injection 2;intros; subst a; subst b; auto. +Qed. + + Set Implicit Arguments. + + CoInductive Stream (A:Set) : Set := + | Cons : A -> Stream A -> Stream A. + + CoInductive LList (A: Set) : Set := + | LNil : LList A + | LCons : A -> LList A -> LList A. + + + + + + Definition head (A:Set)(s : Stream A) := match s with Cons a s' => a end. + + Definition tail (A : Set)(s : Stream A) := + match s with Cons a s' => s' end. + + CoFixpoint repeat (A:Set)(a:A) : Stream A := Cons a (repeat a). + + CoFixpoint iterate (A: Set)(f: A -> A)(a : A) : Stream A:= + Cons a (iterate f (f a)). + + CoFixpoint map (A B:Set)(f: A -> B)(s : Stream A) : Stream B:= + match s with Cons a tl => Cons (f a) (map f tl) end. + +Eval simpl in (fun (A:Set)(a:A) => repeat a). + +Eval simpl in (fun (A:Set)(a:A) => head (repeat a)). + + +CoInductive EqSt (A: Set) : Stream A -> Stream A -> Prop := + eqst : forall s1 s2: Stream A, + head s1 = head s2 -> + EqSt (tail s1) (tail s2) -> + EqSt s1 s2. + + +Section Parks_Principle. +Variable A : Set. +Variable R : Stream A -> Stream A -> Prop. +Hypothesis bisim1 : forall s1 s2:Stream A, R s1 s2 -> + head s1 = head s2. +Hypothesis bisim2 : forall s1 s2:Stream A, R s1 s2 -> + R (tail s1) (tail s2). + +CoFixpoint park_ppl : forall s1 s2:Stream A, R s1 s2 -> + EqSt s1 s2 := + fun s1 s2 (p : R s1 s2) => + eqst s1 s2 (bisim1 p) + (park_ppl (bisim2 p)). +End Parks_Principle. + + +Theorem map_iterate : forall (A:Set)(f:A->A)(x:A), + EqSt (iterate f (f x)) (map f (iterate f x)). +Proof. + intros A f x. + apply park_ppl with + (R:= fun s1 s2 => exists x: A, + s1 = iterate f (f x) /\ s2 = map f (iterate f x)). + + intros s1 s2 (x0,(eqs1,eqs2));rewrite eqs1;rewrite eqs2;reflexivity. + intros s1 s2 (x0,(eqs1,eqs2)). + exists (f x0);split;[rewrite eqs1|rewrite eqs2]; reflexivity. + exists x;split; reflexivity. +Qed. + +Ltac infiniteproof f := + cofix f; constructor; [clear f| simpl; try (apply f; clear f)]. + + +Theorem map_iterate' : forall (A:Set)(f:A->A)(x:A), + EqSt (iterate f (f x)) (map f (iterate f x)). +infiniteproof map_iterate'. + reflexivity. +Qed. + + +Implicit Arguments LNil [A]. + +Lemma Lnil_not_Lcons : forall (A:Set)(a:A)(l:LList A), + LNil <> (LCons a l). + intros;discriminate. +Qed. + +Lemma injection_demo : forall (A:Set)(a b : A)(l l': LList A), + LCons a (LCons b l) = LCons b (LCons a l') -> + a = b /\ l = l'. +Proof. + intros A a b l l' e; injection e; auto. +Qed. + + +Inductive Finite (A:Set) : LList A -> Prop := +| Lnil_fin : Finite (LNil (A:=A)) +| Lcons_fin : forall a l, Finite l -> Finite (LCons a l). + +CoInductive Infinite (A:Set) : LList A -> Prop := +| LCons_inf : forall a l, Infinite l -> Infinite (LCons a l). + +Lemma LNil_not_Infinite : forall (A:Set), ~ Infinite (LNil (A:=A)). +Proof. + intros A H;inversion H. +Qed. + +Lemma Finite_not_Infinite : forall (A:Set)(l:LList A), + Finite l -> ~ Infinite l. +Proof. + intros A l H; elim H. + apply LNil_not_Infinite. + intros a l0 F0 I0' I1. + case I0'; inversion_clear I1. + trivial. +Qed. + +Lemma Not_Finite_Infinite : forall (A:Set)(l:LList A), + ~ Finite l -> Infinite l. +Proof. + cofix H. + destruct l. + intro; absurd (Finite (LNil (A:=A)));[auto|constructor]. + constructor. + apply H. + red; intro H1;case H0. + constructor. + trivial. +Qed. + + + + diff --git a/test-suite/success/univers.v b/test-suite/success/univers.v index 0a4b284f..a619b8da 100644 --- a/test-suite/success/univers.v +++ b/test-suite/success/univers.v @@ -17,3 +17,24 @@ Lemma lem3 : (P:Prop)P. Intro P ; Pattern P. Apply lem2. Abort. + +(* Check managing of universe constraints in inversion *) +(* Bug report #855 *) + +Inductive dep_eq : (X:Type) X -> X -> Prop := + | intro_eq : (X:Type) (f:X)(dep_eq X f f) + | intro_feq : (A:Type) (B:A->Type) + let T = (x:A)(B x) in + (f, g:T) (x:A) + (dep_eq (B x) (f x) (g x)) -> + (dep_eq T f g). + +Require Import Relations. + +Theorem dep_eq_trans : (X:Type) (transitive X (dep_eq X)). +Proof. + Unfold transitive. + Intros X f g h H1 H2. + Inversion H1. +Abort. + diff --git a/theories/Arith/Arith.v b/theories/Arith/Arith.v index d44efb56..114a60ee 100755 --- a/theories/Arith/Arith.v +++ b/theories/Arith/Arith.v @@ -6,7 +6,7 @@ (* * GNU Lesser General Public License Version 2.1 *) (************************************************************************) -(*i $Id: Arith.v,v 1.11.2.1 2004/07/16 19:30:59 herbelin Exp $ i*) +(*i $Id: Arith.v,v 1.11.2.2 2004/08/03 17:42:42 herbelin Exp $ i*) Require Export Le. Require Export Lt. @@ -15,7 +15,6 @@ Require Export Gt. Require Export Minus. Require Export Mult. Require Export Between. -Require Export Minus. Require Export Peano_dec. Require Export Compare_dec. -Require Export Factorial. \ No newline at end of file +Require Export Factorial. diff --git a/theories/Init/Notations.v b/theories/Init/Notations.v index 2e7cb1fc..e0a18747 100644 --- a/theories/Init/Notations.v +++ b/theories/Init/Notations.v @@ -6,11 +6,11 @@ (* * GNU Lesser General Public License Version 2.1 *) (************************************************************************) -(*i $Id: Notations.v,v 1.24.2.1 2004/07/16 19:31:03 herbelin Exp $ i*) +(*i $Id: Notations.v,v 1.24.2.2 2004/08/01 09:36:44 herbelin Exp $ i*) -(** These are the notations whose level and associativity is imposed by Coq *) +(** These are the notations whose level and associativity are imposed by Coq *) -(** Notations for logical connectives *) +(** Notations for propositional connectives *) Reserved Notation "x <-> y" (at level 95, no associativity). Reserved Notation "x /\ y" (at level 80, right associativity). diff --git a/theories/Logic/Berardi.v b/theories/Logic/Berardi.v index 7e950c17..0fe8a87d 100644 --- a/theories/Logic/Berardi.v +++ b/theories/Logic/Berardi.v @@ -6,11 +6,11 @@ (* * GNU Lesser General Public License Version 2.1 *) (************************************************************************) -(*i $Id: Berardi.v,v 1.5.2.1 2004/07/16 19:31:06 herbelin Exp $ i*) +(*i $Id: Berardi.v,v 1.5.2.2 2004/08/03 17:42:43 herbelin Exp $ i*) (** This file formalizes Berardi's paradox which says that in the calculus of constructions, excluded middle (EM) and axiom of - choice (AC) implie proof irrelevenace (PI). + choice (AC) imply proof irrelevance (PI). Here, the axiom of choice is not necessary because of the use of inductive types. << @@ -156,4 +156,4 @@ intros not_true is_true. elim not_true; trivial. Qed. -End Berardis_paradox. \ No newline at end of file +End Berardis_paradox. diff --git a/theories/Logic/ChoiceFacts.v b/theories/Logic/ChoiceFacts.v index a1f4417c..87d8a70e 100644 --- a/theories/Logic/ChoiceFacts.v +++ b/theories/Logic/ChoiceFacts.v @@ -6,14 +6,14 @@ (* * GNU Lesser General Public License Version 2.1 *) (************************************************************************) -(*i $Id: ChoiceFacts.v,v 1.7.2.1 2004/07/16 19:31:06 herbelin Exp $ i*) +(*i $Id: ChoiceFacts.v,v 1.7.2.2 2004/08/01 09:29:59 herbelin Exp $ i*) -(* We show that the functional formulation of the axiom of Choice +(** We show that the functional formulation of the axiom of Choice (usual formulation in type theory) is equivalent to its relational formulation (only formulation of set theory) + the axiom of (parametric) definite description (aka axiom of unique choice) *) -(* This shows that the axiom of choice can be assumed (under its +(** This shows that the axiom of choice can be assumed (under its relational formulation) without known inconsistency with classical logic, though definite description conflicts with classical logic *) @@ -80,7 +80,7 @@ intro H; split; intros [H H0]; exact (description_rel_choice_imp_funct_choice H0 H). Qed. -(* We show that the guarded relational formulation of the axiom of Choice +(** We show that the guarded relational formulation of the axiom of Choice comes from the non guarded formulation in presence either of the independance of premises or proof-irrelevance *) diff --git a/theories/Logic/Diaconescu.v b/theories/Logic/Diaconescu.v index 55eed096..2b982963 100644 --- a/theories/Logic/Diaconescu.v +++ b/theories/Logic/Diaconescu.v @@ -6,9 +6,9 @@ (* * GNU Lesser General Public License Version 2.1 *) (************************************************************************) -(*i $Id: Diaconescu.v,v 1.5.2.1 2004/07/16 19:31:06 herbelin Exp $ i*) +(*i $Id: Diaconescu.v,v 1.5.2.3 2004/08/01 09:36:44 herbelin Exp $ i*) -(* R. Diaconescu [Diaconescu] showed that the Axiom of Choice in Set Theory +(** R. Diaconescu [Diaconescu] showed that the Axiom of Choice in Set Theory entails Excluded-Middle; S. Lacas and B. Werner [LacasWerner] adapted the proof to show that the axiom of choice in equivalence classes entails Excluded-Middle in Type Theory. @@ -27,12 +27,12 @@ Section PredExt_GuardRelChoice_imp_EM. -(* The axiom of extensionality for predicates *) +(** The axiom of extensionality for predicates *) Definition PredicateExtensionality := forall P Q:bool -> Prop, (forall b:bool, P b <-> Q b) -> P = Q. -(* From predicate extensionality we get propositional extensionality +(** From predicate extensionality we get propositional extensionality hence proof-irrelevance *) Require Import ClassicalFacts. @@ -54,7 +54,7 @@ Proof. apply (ext_prop_dep_proof_irrel_cic prop_ext). Qed. -(* From proof-irrelevance and relational choice, we get guarded +(** From proof-irrelevance and relational choice, we get guarded relational choice *) Require Import ChoiceFacts. @@ -73,8 +73,8 @@ Proof. (rel_choice_and_proof_irrel_imp_guarded_rel_choice rel_choice proof_irrel). Qed. -(* The form of choice we need: there is a functional relation which chooses - an element in any non empty subset of bool *) +(** The form of choice we need: there is a functional relation which chooses + an element in any non empty subset of bool *) Require Import Bool. @@ -90,30 +90,30 @@ Proof. exact (fun _ H => H). Qed. -(* The proof of the excluded middle *) -(* Remark: P could have been in Set or Type *) +(** The proof of the excluded middle *) +(** Remark: P could have been in Set or Type *) Theorem pred_ext_and_rel_choice_imp_EM : forall P:Prop, P \/ ~ P. Proof. intro P. -(* first we exhibit the choice functional relation R *) +(** first we exhibit the choice functional relation R *) destruct AC as [R H]. set (class_of_true := fun b => b = true \/ P). set (class_of_false := fun b => b = false \/ P). -(* the actual "decision": is (R class_of_true) = true or false? *) +(** the actual "decision": is (R class_of_true) = true or false? *) destruct (H class_of_true) as [b0 [H0 [H0' H0'']]]. exists true; left; reflexivity. destruct H0. -(* the actual "decision": is (R class_of_false) = true or false? *) +(** the actual "decision": is (R class_of_false) = true or false? *) destruct (H class_of_false) as [b1 [H1 [H1' H1'']]]. exists false; left; reflexivity. destruct H1. -(* case where P is false: (R class_of_true)=true /\ (R class_of_false)=false *) +(** case where P is false: (R class_of_true)=true /\ (R class_of_false)=false *) right. intro HP. assert (Hequiv : forall b:bool, class_of_true b <-> class_of_false b). @@ -129,7 +129,7 @@ rewrite <- H0''. reflexivity. rewrite Heq. assumption. -(* cases where P is true *) +(** cases where P is true *) left; assumption. left; assumption. diff --git a/theories/Logic/JMeq.v b/theories/Logic/JMeq.v index 5b7528be..4666d9b4 100644 --- a/theories/Logic/JMeq.v +++ b/theories/Logic/JMeq.v @@ -6,9 +6,16 @@ (* * GNU Lesser General Public License Version 2.1 *) (************************************************************************) -(*i $Id: JMeq.v,v 1.8.2.1 2004/07/16 19:31:06 herbelin Exp $ i*) +(*i $Id: JMeq.v,v 1.8.2.2 2004/08/03 17:42:32 herbelin Exp $ i*) -(** John Major's Equality as proposed by C. Mc Bride *) +(** John Major's Equality as proposed by C. Mc Bride + + Reference: + + [McBride] Elimination with a Motive, Proceedings of TYPES 2000, + LNCS 2277, pp 197-216, 2002. + +*) Set Implicit Arguments. @@ -65,4 +72,4 @@ Lemma eq_dep_JMeq : Proof. destruct 1. apply JMeq_refl. -Qed. \ No newline at end of file +Qed. diff --git a/theories/Logic/RelationalChoice.v b/theories/Logic/RelationalChoice.v index ca7b760e..08873aa5 100644 --- a/theories/Logic/RelationalChoice.v +++ b/theories/Logic/RelationalChoice.v @@ -6,9 +6,9 @@ (* * GNU Lesser General Public License Version 2.1 *) (************************************************************************) -(*i $Id: RelationalChoice.v,v 1.3.2.1 2004/07/16 19:31:06 herbelin Exp $ i*) +(*i $Id: RelationalChoice.v,v 1.3.2.2 2004/08/01 09:29:59 herbelin Exp $ i*) -(* This file axiomatizes the relational form of the axiom of choice *) +(** This file axiomatizes the relational form of the axiom of choice *) Axiom relational_choice : diff --git a/theories/ZArith/ZArith.v b/theories/ZArith/ZArith.v index 78295591..7e361621 100644 --- a/theories/ZArith/ZArith.v +++ b/theories/ZArith/ZArith.v @@ -6,7 +6,7 @@ (* * GNU Lesser General Public License Version 2.1 *) (************************************************************************) -(*i $Id: ZArith.v,v 1.5.2.1 2004/07/16 19:31:20 herbelin Exp $ i*) +(*i $Id: ZArith.v,v 1.5.2.2 2004/08/03 17:56:30 herbelin Exp $ i*) (** Library for manipulating integers based on binary encoding *) @@ -19,4 +19,3 @@ Require Export Zsqrt. Require Export Zpower. Require Export Zdiv. Require Export Zlogarithm. -Require Export Zbool. \ No newline at end of file diff --git a/tools/coq_makefile.ml4 b/tools/coq_makefile.ml4 index 4879e97d..02607f14 100644 --- a/tools/coq_makefile.ml4 +++ b/tools/coq_makefile.ml4 @@ -6,7 +6,7 @@ (* * GNU Lesser General Public License Version 2.1 *) (************************************************************************) -(* $Id: coq_makefile.ml4,v 1.16.2.1 2004/07/16 19:31:45 herbelin Exp $ *) +(* $Id: coq_makefile.ml4,v 1.16.2.4 2005/01/12 16:00:19 sacerdot Exp $ *) (* créer un Makefile pour un développement Coq automatiquement *) @@ -81,7 +81,7 @@ coq_makefile [subdirectory] .... [file.v] ... [file.ml] ... [-custom let standard sds = print "byte:\n"; - print "\t$(MAKE) all \"OPT=\"\n\n"; + print "\t$(MAKE) all \"OPT=-byte\"\n\n"; print "opt:\n"; if !opt = "" then print "\t@echo \"WARNING: opt is disabled\"\n"; print "\t$(MAKE) all \"OPT="; print !opt; print "\"\n\n"; @@ -89,8 +89,8 @@ let standard sds = print ".depend depend:\n"; if !some_file then begin print "\trm -f .depend\n"; - print "\t$(COQDEP) -i $(COQLIBS) *.v *.ml *.mli >.depend\n"; - print "\t$(COQDEP) $(COQLIBS) -suffix .html *.v >>.depend\n"; + print "\t$(COQDEP) -i $(COQLIBS) $(VFILES) *.ml *.mli >.depend\n"; + print "\t$(COQDEP) $(COQLIBS) -suffix .html $(VFILES) >>.depend\n"; end; List.iter (fun x -> print "\t(cd "; print x; print " ; $(MAKE) depend)\n") @@ -98,7 +98,7 @@ let standard sds = print "\n"; print "install:\n"; print "\tmkdir -p `$(COQC) -where`/user-contrib\n"; - if !some_vfile then print "\tcp -f *.vo `$(COQC) -where`/user-contrib\n"; + if !some_vfile then print "\tcp -f $(VOFILES) `$(COQC) -where`/user-contrib\n"; if !some_mlfile then print "\tcp -f *.cmo `$(COQC) -where`/user-contrib\n"; List.iter (fun x -> print "\t(cd "; print x; print " ; $(MAKE) install)\n") @@ -115,7 +115,7 @@ let standard sds = print "\n"; end; print "clean:\n"; - print "\trm -f *.cmo *.cmi *.cmx *.o *.vo *.vi *.g *~\n"; + print "\trm -f *.cmo *.cmi *.cmx *.o $(VOFILES) $(VIFILES) $(GFILES) *~\n"; print "\trm -f all.ps all-gal.ps $(HTMLFILES) $(GHTMLFILES)\n"; List.iter (fun x -> print "\t(cd "; print x; print " ; $(MAKE) clean)\n") diff --git a/tools/coqdoc/index.mll b/tools/coqdoc/index.mll index 799825ad..875a2337 100644 --- a/tools/coqdoc/index.mll +++ b/tools/coqdoc/index.mll @@ -6,7 +6,7 @@ (* * GNU Lesser General Public License Version 2.1 *) (************************************************************************) -(*i $Id: index.mll,v 1.2.2.1 2004/07/16 19:31:46 herbelin Exp $ i*) +(*i $Id: index.mll,v 1.2.2.2 2004/08/03 17:31:04 herbelin Exp $ i*) { @@ -197,7 +197,7 @@ rule traverse = parse | "Variable" 's'? space { current_type := Variable; index_idents lexbuf; traverse lexbuf } ***i*) - | "Require" (space+ "Export")? space+ ident + | "Require" (space+ ("Export"|"Import"))? space+ ident { ref_module (lexeme_start lexbuf) (lexeme lexbuf); traverse lexbuf } | begin_hide { skip_hide lexbuf; traverse lexbuf } diff --git a/toplevel/class.ml b/toplevel/class.ml index 429469b1..f5493929 100644 --- a/toplevel/class.ml +++ b/toplevel/class.ml @@ -6,7 +6,7 @@ (* * GNU Lesser General Public License Version 2.1 *) (************************************************************************) -(* $Id: class.ml,v 1.44.2.2 2004/07/16 19:31:47 herbelin Exp $ *) +(* $Id: class.ml,v 1.44.2.3 2004/11/26 18:06:54 herbelin Exp $ *) open Util open Pp @@ -92,15 +92,13 @@ let explain_coercion_error g = function (* Verifications pour l'ajout d'une classe *) -let rec arity_sort a = match kind_of_term a with - | Sort (Prop _ | Type _) -> 0 - | Prod (_,_,c) -> (arity_sort c) +1 - | LetIn (_,_,_,c) -> arity_sort c (* Utile ?? *) - | Cast (c,_) -> arity_sort c +let rec arity_sort (ctx,a) = match kind_of_term a with + | Sort (Prop _ | Type _) -> List.length ctx | _ -> raise Not_found let check_reference_arity ref = - try arity_sort (Global.type_of_global ref) + let t = Global.type_of_global ref in + try arity_sort (Reductionops.splay_prod (Global.env()) Evd.empty t) with Not_found -> raise (CoercionError (NotAClass ref)) let check_arity = function diff --git a/toplevel/command.ml b/toplevel/command.ml index b9a47781..3da1c838 100644 --- a/toplevel/command.ml +++ b/toplevel/command.ml @@ -6,7 +6,7 @@ (* * GNU Lesser General Public License Version 2.1 *) (************************************************************************) -(* $Id: command.ml,v 1.116.2.1 2004/07/16 19:31:47 herbelin Exp $ *) +(* $Id: command.ml,v 1.116.2.3 2004/12/31 12:01:16 herbelin Exp $ *) open Pp open Util @@ -49,12 +49,12 @@ let rec abstract_rawconstr c = function List.fold_right (fun x b -> mkLambdaC([x],t,b)) idl (abstract_rawconstr c bl) -let rec prod_rawconstr c = function +let rec generalize_rawconstr c = function | [] -> c - | LocalRawDef (x,b)::bl -> mkLetInC(x,b,prod_rawconstr c bl) + | LocalRawDef (x,b)::bl -> mkLetInC(x,b,generalize_rawconstr c bl) | LocalRawAssum (idl,t)::bl -> List.fold_right (fun x b -> mkProdC([x],t,b)) idl - (prod_rawconstr c bl) + (generalize_rawconstr c bl) let rec destSubCast c = match kind_of_term c with | Lambda (x,t,c) -> @@ -103,12 +103,28 @@ let constant_entry_of_com (bl,com,comtypopt,opacity) = const_entry_type = Some typ; const_entry_opaque = opacity } -let red_constant_entry ce = function +let rec length_of_raw_binders = function + | [] -> 0 + | LocalRawDef _::bl -> 1 + length_of_raw_binders bl + | LocalRawAssum (idl,_)::bl -> List.length idl + length_of_raw_binders bl + +let rec under_binders env f n c = + if n = 0 then f env Evd.empty c else + match kind_of_term c with + | Lambda (x,t,c) -> + mkLambda (x,t,under_binders (push_rel (x,None,t) env) f (n-1) c) + | LetIn (x,b,t,c) -> + mkLetIn (x,b,t,under_binders (push_rel (x,Some b,t) env) f (n-1) c) + | _ -> assert false + +let red_constant_entry bl ce = function | None -> ce | Some red -> let body = ce.const_entry_body in { ce with const_entry_body = - reduction_of_redexp red (Global.env()) Evd.empty body } + under_binders (Global.env()) (reduction_of_redexp red) + (length_of_raw_binders bl) + body } let declare_global_definition ident ce local = let (_,kn) = declare_constant ident (DefinitionEntry ce,IsDefinition) in @@ -119,9 +135,7 @@ let declare_global_definition ident ce local = let declare_definition ident (local,_) bl red_option c typopt hook = let ce = constant_entry_of_com (bl,c,typopt,false) in - if bl<>[] && red_option <> None then - error "Evaluation under a local context not supported"; - let ce' = red_constant_entry ce red_option in + let ce' = red_constant_entry bl ce red_option in let r = match local with | Local when Lib.sections_are_opened () -> let c = @@ -168,7 +182,7 @@ let declare_one_assumption is_coe (local,kind) c (_,ident) = if is_coe then Class.try_add_new_coercion r local let declare_assumption idl is_coe k bl c = - let c = prod_rawconstr c bl in + let c = generalize_rawconstr c bl in let c = interp_type Evd.empty (Global.env()) c in List.iter (declare_one_assumption is_coe k c) idl @@ -458,7 +472,7 @@ let build_recursive (lnameargsardef:(fixpoint_expr *decl_notation) list) = let (rec_sign,rec_impls,arityl) = List.fold_left (fun (env,impls,arl) ((recname,_,bl,arityc,_),_) -> - let arityc = prod_rawconstr arityc bl in + let arityc = generalize_rawconstr arityc bl in let arity = interp_type sigma env0 arityc in let impl = if Impargs.is_implicit_args() @@ -479,7 +493,7 @@ let build_recursive (lnameargsardef:(fixpoint_expr *decl_notation) list) = let def = try List.iter (fun (df,c,scope) -> (* No scope for tmp notation *) - Metasyntax.add_notation_interpretation df [] c None) notations; + Metasyntax.add_notation_interpretation df rec_impls c None) notations; List.map2 (fun ((_,_,bl,_,def),_) arity -> let def = abstract_rawconstr def bl in @@ -533,7 +547,7 @@ let build_corecursive lnameardef = try List.fold_left (fun (env,arl) (recname,bl,arityc,_) -> - let arityc = prod_rawconstr arityc bl in + let arityc = generalize_rawconstr arityc bl in let arj = type_judgment_of_rawconstr Evd.empty env0 arityc in let arity = arj.utj_val in let _ = declare_variable recname @@ -546,7 +560,7 @@ let build_corecursive lnameardef = let recdef = try List.map (fun (_,bl,arityc,def) -> - let arityc = prod_rawconstr arityc bl in + let arityc = generalize_rawconstr arityc bl in let def = abstract_rawconstr def bl in let arity = interp_constr sigma rec_sign arityc in interp_casted_constr sigma rec_sign def arity) @@ -610,13 +624,6 @@ let build_scheme lnamedepindsort = let lrecref = List.fold_right2 declare listdecl lrecnames [] in if_verbose ppnl (recursive_message (Array.of_list lrecref)) -let rec generalize_rawconstr c = function - | [] -> c - | LocalRawDef (id,b)::bl -> mkLetInC(id,b,generalize_rawconstr c bl) - | LocalRawAssum (idl,t)::bl -> - List.fold_right (fun x b -> mkProdC([x],t,b)) idl - (generalize_rawconstr c bl) - let start_proof id kind c hook = let sign = Global.named_context () in let sign = clear_proofs sign in diff --git a/toplevel/coqtop.ml b/toplevel/coqtop.ml index aa765b16..83d240a1 100644 --- a/toplevel/coqtop.ml +++ b/toplevel/coqtop.ml @@ -6,7 +6,7 @@ (* * GNU Lesser General Public License Version 2.1 *) (************************************************************************) -(* $Id: coqtop.ml,v 1.72.2.3 2004/07/16 19:31:47 herbelin Exp $ *) +(* $Id: coqtop.ml,v 1.72.2.4 2004/09/03 15:05:23 herbelin Exp $ *) open Pp open Util @@ -68,7 +68,7 @@ let set_outputstate s = outputstate:=s let outputstate () = if !outputstate <> "" then extern_state !outputstate let check_coq_overwriting p = - if string_of_id (List.hd (repr_dirpath p)) = "Coq" then + if string_of_id (list_last (repr_dirpath p)) = "Coq" then error "The \"Coq\" logical root directory is reserved for the Coq library" let set_include d p = push_include (d,p) diff --git a/toplevel/himsg.ml b/toplevel/himsg.ml index de341bd9..beb80d03 100644 --- a/toplevel/himsg.ml +++ b/toplevel/himsg.ml @@ -6,7 +6,7 @@ (* * GNU Lesser General Public License Version 2.1 *) (************************************************************************) -(* $Id: himsg.ml,v 1.86.2.2 2004/07/16 19:31:49 herbelin Exp $ *) +(* $Id: himsg.ml,v 1.86.2.4 2004/12/03 18:45:53 herbelin Exp $ *) open Pp open Util @@ -73,12 +73,16 @@ let explain_reference_variables c = str "the constant" ++ spc () ++ pc ++ spc () ++ str "refers to variables which are not in the context" +let rec pr_disjunction pr = function + | [a] -> pr a + | [a;b] -> pr a ++ str " or" ++ spc () ++ pr b + | a::l -> pr a ++ str "," ++ spc () ++ pr_disjunction pr l + | [] -> assert false + let explain_elim_arity ctx ind aritylst c pj okinds = let ctx = make_all_name_different ctx in let pi = pr_inductive ctx ind in - let ppar = prlist_with_sep pr_coma (prterm_env ctx) aritylst in let pc = prterm_env ctx c in - let pp = prterm_env ctx pj.uj_val in let ppt = prterm_env ctx pj.uj_type in let msg = match okinds with | Some(kp,ki,explanation) -> @@ -86,26 +90,41 @@ let explain_elim_arity ctx ind aritylst c pj okinds = let pkp = prterm_env ctx kp in let explanation = match explanation with | NonInformativeToInformative -> - "non-informative objects may not construct informative ones." + "proofs can be eliminated only to build proofs" | StrongEliminationOnNonSmallType -> "strong elimination on non-small inductive types leads to paradoxes." | WrongArity -> "wrong arity" in (hov 0 - (fnl () ++ str "Elimination of an inductive object of sort : " ++ + (fnl () ++ str "Elimination of an inductive object of sort " ++ pki ++ brk(1,0) ++ - str "is not allowed on a predicate in sort : " ++ pkp ++fnl () ++ + str "is not allowed on a predicate in sort " ++ pkp ++fnl () ++ str "because" ++ spc () ++ str explanation)) | None -> mt () in - str "Incorrect elimination of" ++ brk(1,1) ++ pc ++ spc () ++ - str "in the inductive type" ++ brk(1,1) ++ pi ++ fnl () ++ - str "The elimination predicate" ++ brk(1,1) ++ pp ++ spc () ++ - str "has type" ++ brk(1,1) ++ ppt ++ fnl () ++ - str "It should be one of :" ++ brk(1,1) ++ hov 0 ppar ++ fnl () ++ - msg - + hov 0 ( + str "Incorrect elimination of" ++ spc() ++ pc ++ spc () ++ + str "in the inductive type " ++ spc() ++ quote pi ++ + (if !Options.v7 then + let pp = prterm_env ctx pj.uj_val in + let ppar = pr_disjunction (prterm_env ctx) aritylst in + let ppt = prterm_env ctx pj.uj_type in + fnl () ++ + str "The elimination predicate" ++ brk(1,1) ++ pp ++ spc () ++ + str "has arity" ++ brk(1,1) ++ ppt ++ fnl () ++ + str "It should be " ++ brk(1,1) ++ ppar + else + let sorts = List.map (fun x -> mkSort (new_sort_in_family x)) + (list_uniquize (List.map (fun ar -> + family_of_sort (destSort (snd (decompose_prod_assum ar)))) aritylst)) in + let ppar = pr_disjunction (prterm_env ctx) sorts in + let ppt = prterm_env ctx (snd (decompose_prod_assum pj.uj_type)) in + str "," ++ spc() ++ str "the return type has sort" ++ spc() ++ ppt ++ + spc () ++ str "while it should be " ++ ppar)) + ++ fnl () ++ msg + + let explain_case_not_inductive ctx cj = let ctx = make_all_name_different ctx in let pc = prterm_env ctx cj.uj_val in @@ -322,13 +341,12 @@ let explain_hole_kind env = function str "a type for " ++ Nameops.pr_id id | BinderType Anonymous -> str "a type for this anonymous binder" - | ImplicitArg (c,n) -> + | ImplicitArg (c,(n,ido)) -> if !Options.v7 then str "the " ++ pr_ord n ++ str " implicit argument of " ++ Nametab.pr_global_env Idset.empty c else - let imps = Impargs.implicits_of_global c in - let id = Impargs.name_of_implicit (List.nth imps (n-1)) in + let id = out_some ido in str "an instance for the implicit parameter " ++ pr_id id ++ spc () ++ str "of" ++ spc () ++ Nametab.pr_global_env Idset.empty c diff --git a/toplevel/metasyntax.ml b/toplevel/metasyntax.ml index 84bda0af..ca64cda0 100644 --- a/toplevel/metasyntax.ml +++ b/toplevel/metasyntax.ml @@ -6,7 +6,7 @@ (* * GNU Lesser General Public License Version 2.1 *) (************************************************************************) -(* $Id: metasyntax.ml,v 1.105.2.2 2004/07/16 19:31:49 herbelin Exp $ *) +(* $Id: metasyntax.ml,v 1.105.2.6 2004/11/22 12:41:38 herbelin Exp $ *) open Pp open Util @@ -606,6 +606,41 @@ let make_hunks etyps symbols from = in make NoBreak symbols +let error_format () = error "The format does not match the notation" + +let rec split_format_at_ldots hd = function + | UnpTerminal s :: fmt when id_of_string s = ldots_var -> List.rev hd, fmt + | u :: fmt -> + check_no_ldots_in_box u; + split_format_at_ldots (u::hd) fmt + | [] -> raise Exit + +and check_no_ldots_in_box = function + | UnpBox (_,fmt) -> + (try + let _ = split_format_at_ldots [] fmt in + error ("The special symbol \"..\" must occur at the same formatting depth than the variables of which it is the ellipse") + with Exit -> ()) + | _ -> () + +let skip_var_in_recursive_format = function + | UnpTerminal _ :: sl (* skip first var *) -> + (* To do, though not so important: check that the names match + the names in the notation *) + sl + | _ -> error_format () + +let read_recursive_format sl fmt = + let get_head fmt = + let sl = skip_var_in_recursive_format fmt in + try split_format_at_ldots [] sl with Exit -> error_format () in + let rec get_tail = function + | a :: sepfmt, b :: fmt when a = b -> get_tail (sepfmt, fmt) + | [], tail -> skip_var_in_recursive_format tail + | _ -> error "The format is not the same on the right and left hand side of the special token \"..\"" in + let slfmt, fmt = get_head fmt in + slfmt, get_tail (slfmt, fmt) + let hunks_of_format (from,(vars,typs) as vt) symfmt = let rec aux = function | symbs, (UnpTerminal s' as u) :: fmt @@ -624,12 +659,20 @@ let hunks_of_format (from,(vars,typs) as vt) symfmt = symbs', UnpBox (a,b') :: l | symbs, (UnpCut _ as u) :: fmt -> let symbs, l = aux (symbs,fmt) in symbs, u :: l + | SProdList (m,sl) :: symbs, fmt -> + let i = list_index m vars in + let _,prec = precedence_of_entry_type from (List.nth typs (i-1)) in + let slfmt,fmt = read_recursive_format sl fmt in + let sl, slfmt = aux (sl,slfmt) in + if sl <> [] then error_format (); + let symbs, l = aux (symbs,fmt) in + symbs, UnpListMetaVar (i,prec,slfmt) :: l | symbs, [] -> symbs, [] - | _, _ -> error "The format does not match the notation" + | _, _ -> error_format () in match aux symfmt with | [], l -> l - | _ -> error "The format does not match the notation" + | _ -> error_format () let string_of_prec (n,p) = (string_of_int n)^(match p with E -> "E" | L -> "L" | _ -> "") @@ -708,13 +751,6 @@ let recompute_assoc typs = | _, Some Gramext.RightA -> Some Gramext.RightA | _ -> None -let rec expand_squash = function - | Term ("","{") :: NonTerm (ETConstr _, n) :: Term ("","}") :: l -> - NonTerm (ETConstr (NextLevel,InternalProd),n) - :: expand_squash l - | a :: l -> a :: expand_squash l - | [] -> [] - let make_grammar_rule n typs symbols ntn perm = let assoc = recompute_assoc typs in let prod = make_production typs symbols in @@ -777,7 +813,7 @@ let pr_level ntn (from,args) = str "at level " ++ int from ++ spc () ++ str "with arguments" ++ spc() ++ prlist_with_sep pr_coma (pr_arg_level from) args -let cache_syntax_extension (_,(_,(prec,prec8),ntn,gr,se)) = +let cache_syntax_extension (_,(_,((prec,prec8),ntn,gr,se))) = try let oldprec, oldprec8 = Symbols.level_of_notation ntn in if prec8 <> oldprec8 & (Options.do_translate () or not !Options.v7) then @@ -799,13 +835,14 @@ let cache_syntax_extension (_,(_,(prec,prec8),ntn,gr,se)) = warning ("Notation "^ntn^ " was already assigned a different level or sublevels"); if oldprec = None or out_some oldprec <> out_some prec then - Egrammar.extend_grammar (Egrammar.Notation (out_some gr)) + Egrammar.extend_grammar (Egrammar.Notation (out_some prec,out_some gr)) end with Not_found -> (* Reserve the notation level *) Symbols.declare_notation_level ntn (prec,prec8); (* Declare the parsing rule *) - option_iter (fun gr -> Egrammar.extend_grammar (Egrammar.Notation gr)) gr; + option_iter (fun gr -> + Egrammar.extend_grammar (Egrammar.Notation (out_some prec,gr))) gr; (* Declare the printing rule *) Symbols.declare_notation_printing_rule ntn (se,fst prec8) @@ -813,15 +850,15 @@ let subst_notation_grammar subst x = x let subst_printing_rule subst x = x -let subst_syntax_extension (_,subst,(local,prec,ntn,gr,se)) = - (local,prec,ntn, +let subst_syntax_extension (_,subst,(local,(prec,ntn,gr,se))) = + (local,(prec,ntn, option_app (subst_notation_grammar subst) gr, - subst_printing_rule subst se) + subst_printing_rule subst se)) -let classify_syntax_definition (_,(local,_,_,_,_ as o)) = +let classify_syntax_definition (_,(local,_ as o)) = if local then Dispose else Substitute o -let export_syntax_definition (local,_,_,_,_ as o) = +let export_syntax_definition (local,_ as o) = if local then None else Some o let (inSyntaxExtension, outSyntaxExtension) = @@ -897,6 +934,10 @@ let check_rule_reversibility l = if List.for_all (function NonTerminal _ -> true | _ -> false) l then error "A notation must include at least one symbol" +let is_not_printable = function + | AVar _ -> warning "This notation won't be used for printing as it is bound to a \nsingle variable"; true + | _ -> false + let find_precedence_v7 lev etyps symbols = (match symbols with | NonTerminal x :: _ -> @@ -1010,7 +1051,7 @@ let add_syntax_extension local mv mv8 = let ntn' = match data with Some ((_,_,_,_,ntn),_,_,_) -> ntn | _ -> ntn in let pp_rule = make_pp_rule ppdata in Lib.add_anonymous_leaf - (inSyntaxExtension (local,(prec,ppprec),ntn',gram_rule,pp_rule)) + (inSyntaxExtension (local,((prec,ppprec),ntn',gram_rule,pp_rule))) (**********************************************************************) (* Distfix, Infix, Symbols *) @@ -1139,33 +1180,38 @@ let add_notation_in_scope local df c mods omodv8 scope toks = let gram_rule = make_grammar_rule n typs symbols ntn permut in Lib.add_anonymous_leaf (inSyntaxExtension - (local,(Some prec,ppprec),ntn,Some gram_rule,pp_rule)); + (local,((Some prec,ppprec),ntn,Some gram_rule,pp_rule))); (* Declare interpretation *) let (acvars,ac) = interp_aconstr [] ppvars c in let a = (remove_vars pprecvars acvars,ac) (* For recursive parts *) in let old_pp_rule = (* Used only by v7; disable if contains a recursive pattern *) - if onlyparse or pprecvars <> [] then None + if onlyparse or pprecvars <> [] or not (!Options.v7) then None else let r = interp_global_rawconstr_with_vars vars c in Some (make_old_pp_rule n symbols typs r intnot scope vars) in - let onlyparse = onlyparse or !Options.v7_only in + let onlyparse = onlyparse or !Options.v7_only or is_not_printable ac in Lib.add_anonymous_leaf (inNotation(local,old_pp_rule,intnot,scope,a,onlyparse,false,df')) let level_rule (n,p) = if p = E then n else max (n-1) 0 -let check_notation_existence notation = - try - let a,_ = Symbols.level_of_notation (contract_notation notation) in - if a = None then raise Not_found - with Not_found -> - error "Parsing rule for this notation has to be previously declared" +let recover_syntax ntn = + try + match Symbols.level_of_notation ntn with + | (Some prec,_ as pprec) -> + let rule,_ = Symbols.find_notation_printing_rule ntn in + let gr = Egrammar.recover_notation_grammar ntn prec in + Some (pprec,ntn,Some gr,rule) + | None,_ -> None + with Not_found -> None -let exists_notation_syntax ntn = - try fst (Symbols.level_of_notation (contract_notation ntn)) <> None - with Not_found -> false +let recover_notation_syntax rawntn = + let ntn = contract_notation rawntn in + match recover_syntax ntn with + | None -> None + | Some gr -> Some (gr,if ntn=rawntn then None else recover_syntax "{ _ }") let set_data_for_v7_pp recs a vars = if not !Options.v7 then None else @@ -1185,34 +1231,44 @@ let build_old_pp_rule notation scope symbs (r,vars) = make_old_pp_rule (fst prec) symbs typs r notation scope vars let add_notation_interpretation_core local symbs for_old df a scope onlyparse - onlypp = + onlypp gram_data = let notation = make_notation_key symbs in let old_pp_rule = if !Options.v7 then option_app (build_old_pp_rule notation scope symbs) for_old else None in + option_iter + (fun (x,y) -> + Lib.add_anonymous_leaf (inSyntaxExtension (local,x)); + option_iter + (fun z -> Lib.add_anonymous_leaf (inSyntaxExtension (local,z))) y) + gram_data; Lib.add_anonymous_leaf (inNotation(local,old_pp_rule,notation,scope,a,onlyparse,onlypp, (Lib.library_dp(),df))) let add_notation_interpretation df names c sc = let (recs,vars,symbs) = analyse_notation_tokens (split_notation_string df) in - check_notation_existence (make_notation_key symbs); + let gram_data = recover_notation_syntax (make_notation_key symbs) in + if gram_data = None then + error "Parsing rule for this notation has to be previously declared"; let (acvars,ac) = interp_aconstr names vars c in let a = (remove_vars recs acvars,ac) (* For recursive parts *) in let a_for_old = interp_rawconstr_with_implicits Evd.empty (Global.env()) vars names c in let for_oldpp = set_data_for_v7_pp recs a_for_old vars in - add_notation_interpretation_core false symbs for_oldpp df a sc false false + let onlyparse = is_not_printable ac in + add_notation_interpretation_core false symbs for_oldpp df a sc onlyparse + false gram_data let add_notation_in_scope_v8only local df c mv8 scope toks = let (_,recs,vars,intnot,notation),prec,ppdata,df' = compute_syntax_data false (df,mv8) in let pp_rule = make_pp_rule ppdata in Lib.add_anonymous_leaf - (inSyntaxExtension(local,(None,prec),notation,None,pp_rule)); + (inSyntaxExtension(local,((None,prec),notation,None,pp_rule))); (* Declare the interpretation *) - let onlyparse = false in let (acvars,ac) = interp_aconstr [] vars c in let a = (remove_vars recs acvars,ac) (* For recursive parts *) in + let onlyparse = is_not_printable ac in Lib.add_anonymous_leaf (inNotation(local,None,intnot,scope,a,onlyparse,true,df')) @@ -1231,11 +1287,12 @@ let add_notation_v8only local c (df,modifiers) sc = else (* Declare only interpretation *) let (recs,vars,symbs) = analyse_notation_tokens toks in - let onlyparse = modifiers = [SetOnlyParsing] in let (acvars,ac) = interp_aconstr [] vars c in + let onlyparse = modifiers = [SetOnlyParsing] + or is_not_printable ac in let a = (remove_vars recs acvars,ac) in add_notation_interpretation_core local symbs None df a sc - onlyparse true + onlyparse true None | Some n -> (* Declare both syntax and interpretation *) let mods = @@ -1266,14 +1323,17 @@ let add_notation local c dfmod mv8 sc = else (* Declare only interpretation *) let (recs,vars,symbs) = analyse_notation_tokens toks in - if exists_notation_syntax (make_notation_key symbs) then - let onlyparse = modifiers = [SetOnlyParsing] in + let gram_data = + recover_notation_syntax (make_notation_key symbs) in + if gram_data <> None then let (acvars,ac) = interp_aconstr [] vars c in let a = (remove_vars recs acvars,ac) in + let onlyparse = modifiers = [SetOnlyParsing] + or is_not_printable ac in let a_for_old = interp_global_rawconstr_with_vars vars c in let for_old = set_data_for_v7_pp recs a_for_old vars in add_notation_interpretation_core local symbs for_old df a - sc onlyparse false + sc onlyparse false gram_data else add_notation_in_scope local df c modifiers mv8 sc toks | Some n -> @@ -1340,7 +1400,7 @@ let add_infix local (inf,modl) pr mv8 sc = let a' = (remove_vars recs acvars,ac) in let a_for_old = interp_global_rawconstr_with_vars vars a in add_notation_interpretation_core local symbs None df a' sc - onlyparse true + onlyparse true None else if n8 = None then error "Needs a level" else let mv8 = match a8 with None -> SetAssoc Gramext.NonA :: mv8 |_ -> mv8 in @@ -1365,13 +1425,14 @@ let add_infix local (inf,modl) pr mv8 sc = (* de ne déclarer que l'interprétation *) (* Declare only interpretation *) let (recs,vars,symbs) = analyse_notation_tokens toks in - if exists_notation_syntax (make_notation_key symbs) then + let gram_data = recover_notation_syntax (make_notation_key symbs) in + if gram_data <> None then let (acvars,ac) = interp_aconstr [] vars a in let a' = (remove_vars recs acvars,ac) in let a_for_old = interp_global_rawconstr_with_vars vars a in let for_old = set_data_for_v7_pp recs a_for_old vars in add_notation_interpretation_core local symbs for_old df a' sc - onlyparse false + onlyparse false gram_data else let mv,mv8 = make_infix_data n assoc modl mv8 in add_notation_in_scope local df a mv mv8 sc toks diff --git a/toplevel/recordobj.mli b/toplevel/recordobj.mli index 8ea39767..91550c34 100755 --- a/toplevel/recordobj.mli +++ b/toplevel/recordobj.mli @@ -6,7 +6,7 @@ (* * GNU Lesser General Public License Version 2.1 *) (************************************************************************) -(* $Id: recordobj.mli,v 1.7.6.1 2004/07/16 19:31:49 herbelin Exp $ *) +(*i $Id: recordobj.mli,v 1.7.6.2 2005/01/21 17:18:33 herbelin Exp $ i*) val objdef_declare : Libnames.global_reference -> unit val add_object_hook : Tacexpr.declaration_hook diff --git a/toplevel/usage.ml b/toplevel/usage.ml index 9fe8b280..b00cfffc 100644 --- a/toplevel/usage.ml +++ b/toplevel/usage.ml @@ -6,7 +6,7 @@ (* * GNU Lesser General Public License Version 2.1 *) (************************************************************************) -(* $Id: usage.ml,v 1.15.2.1 2004/07/16 19:31:50 herbelin Exp $ *) +(* $Id: usage.ml,v 1.15.2.2 2004/09/03 14:35:26 herbelin Exp $ *) let version () = Printf.printf "The Coq Proof Assistant, version %s (%s)\n" @@ -23,7 +23,7 @@ let print_usage_channel co command = " -I dir add directory dir in the include path -include dir (idem) -R dir coqdir recursively map physical dir to logical coqdir - -src add source directories in the include path + -top coqdir set the toplevel name to be coqdir instead of Top -inputstate f read state from file f.coq -is f (idem) @@ -35,14 +35,14 @@ let print_usage_channel co command = -load-vernac-source f load Coq file f.v (Load f.) -l f (idem) -load-vernac-source-verbose f load Coq file f.v (Load Verbose f.) - -lv f (idem) + -lv f (idem) -load-vernac-object f load Coq object file f.vo -require f load Coq object file f.vo and import it (Require f.) -compile f compile Coq file f.v (implies -batch) -compile-verbose f verbosely compile Coq file f.v (implies -batch) - -opt run the native-code version of Coq or Coq_SearchIsos - -byte run the bytecode version of Coq or Coq_SearchIsos + -opt run the native-code version of Coq + -byte run the bytecode version of Coq -where print Coq's standard library location and exit -v print Coq version and exit @@ -59,6 +59,9 @@ let print_usage_channel co command = -xml export XML files either to the hierarchy rooted in the directory $COQ_XML_LIBRARY_ROOT (if set) or to stdout (if unset) + -quality improve the legibility of the proof terms produced by + some tactics + -h, --help print this list of options " (* print the usage on standard error *) @@ -72,5 +75,6 @@ let print_usage_coqc () = print_usage "Usage: coqc file...\n options are: -verbose compile verbosely + -bindir override the default directory where coqc looks for coqtop -image f specify an alternative executable for Coq -t keep temporary files\n\n" diff --git a/toplevel/vernacentries.mli b/toplevel/vernacentries.mli index a359b4a1..89e0d708 100644 --- a/toplevel/vernacentries.mli +++ b/toplevel/vernacentries.mli @@ -6,7 +6,7 @@ (* * GNU Lesser General Public License Version 2.1 *) (************************************************************************) -(*i $Id: vernacentries.mli,v 1.16.2.1 2004/07/16 19:31:50 herbelin Exp $ i*) +(*i $Id: vernacentries.mli,v 1.16.2.2 2005/01/21 16:41:52 herbelin Exp $ i*) (*i*) open Names @@ -27,11 +27,11 @@ val show_node : unit -> unit in the context of the current goal, as for instance in pcoq *) val get_current_context_of_args : int option -> Evd.evar_map * Environ.env +(*i (* this function is used to analyse the extra arguments in search commands. It is used in pcoq. *) (*i anciennement: inside_outside i*) -(* val interp_search_restriction : search_restriction -> dir_path list * bool -*) +i*) type pcoq_hook = { start_proof : unit -> unit; diff --git a/toplevel/vernacexpr.ml b/toplevel/vernacexpr.ml index e1525c17..382434dc 100644 --- a/toplevel/vernacexpr.ml +++ b/toplevel/vernacexpr.ml @@ -6,7 +6,7 @@ (* * GNU Lesser General Public License Version 2.1 *) (************************************************************************) -(* $Id: vernacexpr.ml,v 1.55.2.1 2004/07/16 19:31:50 herbelin Exp $ *) +(*i $Id: vernacexpr.ml,v 1.55.2.2 2005/01/21 17:14:10 herbelin Exp $ i*) open Util open Names diff --git a/translate/ppconstrnew.ml b/translate/ppconstrnew.ml index 7d2feaf2..f75f767d 100644 --- a/translate/ppconstrnew.ml +++ b/translate/ppconstrnew.ml @@ -6,7 +6,7 @@ (* * GNU Lesser General Public License Version 2.1 *) (************************************************************************) -(* $Id: ppconstrnew.ml,v 1.62.2.2 2004/07/16 20:48:17 herbelin Exp $ *) +(* $Id: ppconstrnew.ml,v 1.62.2.4 2004/12/29 10:17:11 herbelin Exp $ *) (*i*) open Ast @@ -367,28 +367,31 @@ let rec split_fix n typ def = let (bl,typ,def) = split_fix (n-1) typ def in (LocalRawAssum ([na],t)::bl,typ,def) -let pr_recursive_decl pr id bl annot t c = +let pr_recursive_decl pr pr_dangling dangling_with_for id bl annot t c = + let pr_body = + if dangling_with_for then pr_dangling else pr in pr_id id ++ str" " ++ hov 0 (pr_undelimited_binders (pr ltop) bl ++ annot) ++ pr_opt_type_spc pr t ++ str " :=" ++ - pr_sep_com (fun () -> brk(1,2)) (pr ltop) c + pr_sep_com (fun () -> brk(1,2)) (pr_body ltop) c -let pr_fixdecl pr (id,n,bl,t,c) = +let pr_fixdecl pr prd dangling_with_for (id,n,bl,t,c) = let annot = let ids = names_of_local_assums bl in if List.length ids > 1 then spc() ++ str "{struct " ++ pr_name (snd (List.nth ids n)) ++ str"}" else mt() in - pr_recursive_decl pr id bl annot t c + pr_recursive_decl pr prd dangling_with_for id bl annot t c -let pr_cofixdecl pr (id,bl,t,c) = - pr_recursive_decl pr id bl (mt()) t c +let pr_cofixdecl pr prd dangling_with_for (id,bl,t,c) = + pr_recursive_decl pr prd dangling_with_for id bl (mt()) t c let pr_recursive pr_decl id = function | [] -> anomaly "(co)fixpoint with no definition" - | [d1] -> pr_decl d1 + | [d1] -> pr_decl false d1 | dl -> - prlist_with_sep (fun () -> fnl() ++ str "with ") pr_decl dl ++ + prlist_with_sep (fun () -> fnl() ++ str "with ") + (pr_decl true) dl ++ fnl() ++ str "for " ++ pr_id id let pr_arg pr x = spc () ++ pr x @@ -462,16 +465,15 @@ let rec pr sep inherited a = let (strm,prec) = match a with | CRef r -> pr_reference r, latom | CFix (_,id,fix) -> - let p = hov 0 (str"fix " ++ - pr_recursive (pr_fixdecl (pr mt)) (snd id) fix) in - if List.length fix = 1 & prec_less (fst inherited) ltop - then surround p, latom else p, lfix + hov 0 (str"fix " ++ + pr_recursive + (pr_fixdecl (pr mt) (pr_dangling_with_for mt)) (snd id) fix), + lfix | CCoFix (_,id,cofix) -> - let p = - hov 0 (str "cofix " ++ - pr_recursive (pr_cofixdecl (pr mt)) (snd id) cofix) in - if List.length cofix = 1 & prec_less (fst inherited) ltop - then surround p, latom else p, lfix + hov 0 (str "cofix " ++ + pr_recursive + (pr_cofixdecl (pr mt) (pr_dangling_with_for mt)) (snd id) cofix), + lfix | CArrow (_,a,b) -> hov 0 (pr mt (larrow,L) a ++ str " ->" ++ pr (fun () ->brk(1,0)) (-larrow,E) b), @@ -530,8 +532,9 @@ let rec pr sep inherited a = v 0 (hv 0 (str "match" ++ brk (1,2) ++ hov 0 ( - prlist_with_sep sep_v (pr_case_item (pr mt)) c - ++ pr_case_type (pr mt) rtntypopt) ++ + prlist_with_sep sep_v + (pr_case_item (pr_dangling_with_for mt)) c + ++ pr_case_type (pr_dangling_with_for mt) rtntypopt) ++ spc () ++ str "with") ++ prlist (pr_eqn (pr mt)) eqns ++ spc() ++ str "end"), latom @@ -579,7 +582,7 @@ let rec pr sep inherited a = hv 0 ( str (if style=MatchStyle then "old_match " else "match ") ++ pr mt ltop c ++ - pr_return_type (pr mt) po ++ + pr_return_type (pr_dangling_with_for mt) po ++ str " with" ++ brk (1,0) ++ hov 0 (prlist (fun b -> str "| ??? =>" ++ pr spc ltop b ++ fnl ()) bl) ++ @@ -604,6 +607,11 @@ let rec pr sep inherited a = pr_with_comments loc (sep() ++ if prec_less prec inherited then strm else surround strm) +and pr_dangling_with_for sep inherited a = + match a with + | (CFix (_,_,[_])|CCoFix(_,_,[_])) -> pr sep (latom,E) a + | _ -> pr sep inherited a + let pr = pr mt let rec abstract_constr_expr c = function @@ -768,8 +776,7 @@ let pr_red_expr (pr_constr,pr_lconstr,pr_ref) = function pr_arg (prlist_with_sep pr_coma (pr_pattern_occ pr_constr)) l) | Red true -> error "Shouldn't be accessible from user" - | ExtraRedExpr (s,c) -> - hov 1 (str s ++ pr_arg pr_constr c) + | ExtraRedExpr s -> str s let rec pr_may_eval test prc prlc pr2 = function | ConstrEval (r,c) -> diff --git a/translate/ppconstrnew.mli b/translate/ppconstrnew.mli index 4477728c..4a488499 100644 --- a/translate/ppconstrnew.mli +++ b/translate/ppconstrnew.mli @@ -6,7 +6,7 @@ (* * GNU Lesser General Public License Version 2.1 *) (************************************************************************) -(* $Id: ppconstrnew.mli,v 1.16.2.1 2004/07/16 19:31:52 herbelin Exp $ *) +(*i $Id: ppconstrnew.mli,v 1.16.2.2 2005/01/21 17:17:20 herbelin Exp $ i*) open Pp open Environ diff --git a/translate/pptacticnew.mli b/translate/pptacticnew.mli index 2558413f..b49b9e56 100644 --- a/translate/pptacticnew.mli +++ b/translate/pptacticnew.mli @@ -6,7 +6,7 @@ (* * GNU Lesser General Public License Version 2.1 *) (************************************************************************) -(* $Id: pptacticnew.mli,v 1.6.2.1 2004/07/16 19:31:52 herbelin Exp $ *) +(*i $Id: pptacticnew.mli,v 1.6.2.3 2005/01/21 17:17:20 herbelin Exp $ i*) open Pp open Genarg @@ -17,6 +17,8 @@ open Names val qsnew : string -> std_ppcmds +val pr_intro_pattern : intro_pattern_expr -> std_ppcmds + val pr_raw_tactic : Environ.env -> raw_tactic_expr -> std_ppcmds val pr_glob_tactic : Environ.env -> glob_tactic_expr -> std_ppcmds diff --git a/translate/ppvernacnew.ml b/translate/ppvernacnew.ml index 246253eb..bfcbee43 100644 --- a/translate/ppvernacnew.ml +++ b/translate/ppvernacnew.ml @@ -6,7 +6,7 @@ (* * GNU Lesser General Public License Version 2.1 *) (************************************************************************) -(* $Id: ppvernacnew.ml,v 1.95.2.2 2004/07/16 20:48:17 herbelin Exp $ *) +(* $Id: ppvernacnew.ml,v 1.95.2.3 2004/10/12 10:10:29 herbelin Exp $ *) open Pp open Names @@ -622,7 +622,7 @@ let rec pr_vernac = function hov 1 (pr_thm_token ki ++ spc() ++ pr_lident id ++ spc() ++ (match bl with | [] -> mt() - | _ -> error "Statements with local binders no longer supported") + | _ -> pr_binders bl ++ spc()) ++ str":" ++ pr_spc_type (rename_bound_variables (snd id) c)) | VernacEndProof Admitted -> str"Admitted" | VernacEndProof (Proved (opac,o)) -> (match o with diff --git a/translate/ppvernacnew.mli b/translate/ppvernacnew.mli index 73101a1a..4506b811 100644 --- a/translate/ppvernacnew.mli +++ b/translate/ppvernacnew.mli @@ -6,7 +6,7 @@ (* * GNU Lesser General Public License Version 2.1 *) (************************************************************************) -(* $Id: ppvernacnew.mli,v 1.3.2.1 2004/07/16 19:31:52 herbelin Exp $ *) +(*i $Id: ppvernacnew.mli,v 1.3.2.2 2005/01/21 17:17:20 herbelin Exp $ i*) open Pp open Genarg -- cgit v1.2.3