From: Ferruccio Guidi Date: Sat, 25 Apr 2009 13:16:47 +0000 (+0000) Subject: - matitacLib: better handling of the callbacks for the dump operation X-Git-Tag: make_still_working~4057 X-Git-Url: http://matita.cs.unibo.it/gitweb/?a=commitdiff_plain;h=6cc401c4136bafb6515bd39d86db6b5a917318bf;p=helm.git - matitacLib: better handling of the callbacks for the dump operation - applyTransformation: notation disabled when rendering reconstructed inductive types to avoid notation conflict between notation and inductive type syntax - lexicon/lexiconEngine: better error messages and one callback removed - termAcicContent: in lookup_interpretations, sorting the returned interpretations is optional and defaults to true (as before) - disambiguateChoices: in lookup_symbol_by_dsc, the interpretations are not sorted before choosing, sorting them here is a bug because their order is lost so the chosen one is not the most recent - grafiteParser: better callback functions for the drop feature of matitac, we introduced module name abbreviations for our convenience - syntax_extensions/.depend: something is wrong with the Makefiles, this .depend is commited every time :( --- diff --git a/helm/software/components/acic_content/termAcicContent.ml b/helm/software/components/acic_content/termAcicContent.ml index 508411d28..c350f38c4 100644 --- a/helm/software/components/acic_content/termAcicContent.ml +++ b/helm/software/components/acic_content/termAcicContent.ml @@ -442,19 +442,22 @@ let set_active_interpretations ids = exception Interpretation_not_found -let lookup_interpretations symbol = +let lookup_interpretations ?(sorted=true) symbol = try - HExtlib.list_uniq - (List.sort Pervasives.compare - (List.map - (fun id -> - let (dsc, _, args, appl_pattern) = - try - Hashtbl.find !level2_patterns32 id - with Not_found -> assert false - in - dsc, args, appl_pattern) - !(Hashtbl.find !interpretations symbol))) + let raw = + List.map ( + fun id -> + let (dsc, _, args, appl_pattern) = + try + Hashtbl.find !level2_patterns32 id + with Not_found -> assert false + in + dsc, args, appl_pattern + ) + !(Hashtbl.find !interpretations symbol) + in + if sorted then HExtlib.list_uniq (List.sort Pervasives.compare raw) + else raw with Not_found -> raise Interpretation_not_found let remove_interpretation id = diff --git a/helm/software/components/acic_content/termAcicContent.mli b/helm/software/components/acic_content/termAcicContent.mli index 91438d248..605a8f5ca 100644 --- a/helm/software/components/acic_content/termAcicContent.mli +++ b/helm/software/components/acic_content/termAcicContent.mli @@ -36,7 +36,7 @@ val add_interpretation: (** @raise Interpretation_not_found *) val lookup_interpretations: - string -> (* symbol *) + ?sorted:bool -> string -> (* symbol *) (string * CicNotationPt.argument_pattern list * CicNotationPt.cic_appl_pattern) list diff --git a/helm/software/components/cic_disambiguation/disambiguateChoices.ml b/helm/software/components/cic_disambiguation/disambiguateChoices.ml index b540033dc..bc82e60ff 100644 --- a/helm/software/components/cic_disambiguation/disambiguateChoices.ml +++ b/helm/software/components/cic_disambiguation/disambiguateChoices.ml @@ -75,11 +75,10 @@ let mk_choice ~mk_appl ~mk_implicit ~term_of_uri (dsc, args, appl_pattern)= | _::_ -> mk_appl (combined::rest)) let lookup_symbol_by_dsc ~mk_appl ~mk_implicit ~term_of_uri symbol dsc = + let interpretations = TermAcicContent.lookup_interpretations ~sorted:false symbol in try mk_choice ~mk_appl ~mk_implicit ~term_of_uri - (List.find - (fun (dsc', _, _) -> dsc = dsc') - (TermAcicContent.lookup_interpretations symbol)) + (List.find (fun (dsc', _, _) -> dsc = dsc') interpretations) with TermAcicContent.Interpretation_not_found | Not_found -> raise (Choice_not_found (lazy (sprintf "Symbol %s, dsc %s" symbol dsc))) diff --git a/helm/software/components/grafite_parser/grafiteParser.ml b/helm/software/components/grafite_parser/grafiteParser.ml index 389e2eb21..633d98ea9 100644 --- a/helm/software/components/grafite_parser/grafiteParser.ml +++ b/helm/software/components/grafite_parser/grafiteParser.ml @@ -25,35 +25,36 @@ (* $Id$ *) -let out = ref ignore -let set_callback f = out := f - -module Ast = CicNotationPt +module N = CicNotationPt +module G = GrafiteAst +module L = LexiconAst +module LE = LexiconEngine exception NoInclusionPerformed of string (* full path *) type 'a localized_option = LSome of 'a - | LNone of GrafiteAst.loc + | LNone of G.loc type ast_statement = - (CicNotationPt.term, CicNotationPt.term, - CicNotationPt.term GrafiteAst.reduction, - CicNotationPt.term CicNotationPt.obj, string) - GrafiteAst.statement + (N.term, N.term, N.term G.reduction, N.term N.obj, string) G.statement type statement = - ?never_include:bool -> - include_paths:string list -> - LexiconEngine.status -> - LexiconEngine.status * ast_statement localized_option + ?never_include:bool -> include_paths:string list -> LE.status -> + LE.status * ast_statement localized_option type parser_status = { grammar : Grammar.g; - term : CicNotationPt.term Grammar.Entry.e; + term : N.term Grammar.Entry.e; statement : statement Grammar.Entry.e; } +let grafite_callback = ref (fun _ _ -> ()) +let set_grafite_callback cb = grafite_callback := cb + +let lexicon_callback = ref (fun _ _ -> ()) +let set_lexicon_callback cb = lexicon_callback := cb + let initial_parser () = let grammar = CicNotationParser.level2_ast_grammar () in let term = CicNotationParser.term () in @@ -63,7 +64,7 @@ let initial_parser () = let grafite_parser = ref (initial_parser ()) -let add_raw_attribute ~text t = Ast.AttributedTerm (`Raw text, t) +let add_raw_attribute ~text t = N.AttributedTerm (`Raw text, t) let default_associativity = Gramext.NonA @@ -75,18 +76,18 @@ let mk_rec_corec ng ind_kind defs loc = `MutualDefinition to rememer this. *) let name,ty = match defs with - | (params,(Ast.Ident (name, None), Some ty),_,_) :: _ -> + | (params,(N.Ident (name, None), Some ty),_,_) :: _ -> let ty = List.fold_right - (fun var ty -> Ast.Binder (`Pi,var,ty) + (fun var ty -> N.Binder (`Pi,var,ty) ) params ty in name,ty - | (_,(Ast.Ident (name, None), None),_,_) :: _ -> - name, Ast.Implicit + | (_,(N.Ident (name, None), None),_,_) :: _ -> + name, N.Implicit | _ -> assert false in - let body = Ast.Ident (name,None) in + let body = N.Ident (name,None) in let flavour = if List.length defs = 1 then `Definition @@ -94,17 +95,17 @@ let mk_rec_corec ng ind_kind defs loc = `MutualDefinition in if ng then - GrafiteAst.NObj (loc, Ast.Theorem(flavour, name, ty, - Some (Ast.LetRec (ind_kind, defs, body)))) + G.NObj (loc, N.Theorem(flavour, name, ty, + Some (N.LetRec (ind_kind, defs, body)))) else - GrafiteAst.Obj (loc, Ast.Theorem(flavour, name, ty, - Some (Ast.LetRec (ind_kind, defs, body)))) + G.Obj (loc, N.Theorem(flavour, name, ty, + Some (N.LetRec (ind_kind, defs, body)))) type by_continuation = BYC_done - | BYC_weproved of CicNotationPt.term * string option * CicNotationPt.term option - | BYC_letsuchthat of string * CicNotationPt.term * string * CicNotationPt.term - | BYC_wehaveand of string * CicNotationPt.term * string * CicNotationPt.term + | BYC_weproved of N.term * string option * N.term option + | BYC_letsuchthat of string * N.term * string * N.term + | BYC_wehaveand of string * N.term * string * N.term let initialize_parser () = (* {{{ parser initialization *) @@ -135,11 +136,11 @@ EXTEND LIST0 [ id = IDENT ; path = OPT [SYMBOL ":" ; path = tactic_term -> path ] -> - (id,match path with Some p -> p | None -> Ast.UserInput) ]; + (id,match path with Some p -> p | None -> N.UserInput) ]; goal_path = OPT [ SYMBOL <:unicode>; term = tactic_term -> term ] -> let goal_path = match goal_path, hyp_paths with - None, [] -> Some Ast.UserInput + None, [] -> Some N.UserInput | None, _::_ -> None | Some goal_path, _ -> Some goal_path in @@ -158,25 +159,25 @@ EXTEND ] -> let wanted,hyp_paths,goal_path = match wanted_and_sps with - wanted,None -> wanted, [], Some Ast.UserInput + wanted,None -> wanted, [], Some N.UserInput | wanted,Some (hyp_paths,goal_path) -> wanted,hyp_paths,goal_path in wanted, hyp_paths, goal_path ] -> match res with - None -> None,[],Some Ast.UserInput + None -> None,[],Some N.UserInput | Some ps -> ps] ]; inverter_param_list: [ [ params = tactic_term -> let deannotate = function - | Ast.AttributedTerm (_,t) | t -> t + | N.AttributedTerm (_,t) | t -> t in match deannotate params with - | Ast.Implicit -> [false] - | Ast.UserInput -> [true] - | Ast.Appl l -> + | N.Implicit -> [false] + | N.UserInput -> [true] + | N.Appl l -> List.map (fun x -> match deannotate x with - | Ast.Implicit -> false - | Ast.UserInput -> true + | N.Implicit -> false + | N.UserInput -> true | _ -> raise (Invalid_argument "malformed target parameter list 1")) l | _ -> raise (Invalid_argument ("malformed target parameter list 2\n" ^ CicNotationPp.pp_term params)) ] ]; @@ -199,7 +200,7 @@ EXTEND ]; using: [ [ using = OPT [ IDENT "using"; t = tactic_term -> t ] -> using ] ]; ntactic: [ - [ IDENT "napply"; t = tactic_term -> GrafiteAst.NApply (loc, t) + [ IDENT "napply"; t = tactic_term -> G.NApply (loc, t) | IDENT "nassert"; seqs = LIST0 [ hyps = LIST0 @@ -209,92 +210,92 @@ EXTEND id,`Def (bo,ty)]; SYMBOL <:unicode>; concl = tactic_term -> (List.rev hyps,concl) ] -> - GrafiteAst.NAssert (loc, seqs) + G.NAssert (loc, seqs) | IDENT "ncases"; what = tactic_term ; where = pattern_spec -> - GrafiteAst.NCases (loc, what, where) + G.NCases (loc, what, where) | IDENT "nchange"; what = pattern_spec; "with"; with_what = tactic_term -> - GrafiteAst.NChange (loc, what, with_what) + G.NChange (loc, what, with_what) | IDENT "nelim"; what = tactic_term ; where = pattern_spec -> - GrafiteAst.NElim (loc, what, where) + G.NElim (loc, what, where) | IDENT "ngeneralize"; p=pattern_spec -> - GrafiteAst.NGeneralize (loc, p) + G.NGeneralize (loc, p) | IDENT "nletin"; name = IDENT ; SYMBOL <:unicode> ; t = tactic_term; where = pattern_spec -> - GrafiteAst.NLetIn (loc,where,t,name) + G.NLetIn (loc,where,t,name) | IDENT "nrewrite"; dir = direction; what = tactic_term ; where = pattern_spec -> - GrafiteAst.NRewrite (loc, dir, what, where) + G.NRewrite (loc, dir, what, where) | IDENT "nwhd"; delta = OPT [ IDENT "nodelta" -> () ]; where = pattern_spec -> let delta = match delta with None -> true | _ -> false in - GrafiteAst.NEval (loc, where, `Whd delta) - | SYMBOL "#"; n=IDENT -> GrafiteAst.NIntro (loc,n) - | SYMBOL "#"; SYMBOL "_" -> GrafiteAst.NIntro (loc,"_") - | SYMBOL "*" -> GrafiteAst.NCase1 (loc,"_") + G.NEval (loc, where, `Whd delta) + | SYMBOL "#"; n=IDENT -> G.NIntro (loc,n) + | SYMBOL "#"; SYMBOL "_" -> G.NIntro (loc,"_") + | SYMBOL "*" -> G.NCase1 (loc,"_") | SYMBOL "*"; n=IDENT -> - GrafiteAst.NCase1 (loc,n) + G.NCase1 (loc,n) ] ]; tactic: [ [ IDENT "absurd"; t = tactic_term -> - GrafiteAst.Absurd (loc, t) + G.Absurd (loc, t) | IDENT "apply"; IDENT "rule"; t = tactic_term -> - GrafiteAst.ApplyRule (loc, t) + G.ApplyRule (loc, t) | IDENT "apply"; t = tactic_term -> - GrafiteAst.Apply (loc, t) + G.Apply (loc, t) | IDENT "applyP"; t = tactic_term -> - GrafiteAst.ApplyP (loc, t) + G.ApplyP (loc, t) | IDENT "applyS"; t = tactic_term ; params = auto_params -> - GrafiteAst.ApplyS (loc, t, params) + G.ApplyS (loc, t, params) | IDENT "assumption" -> - GrafiteAst.Assumption loc + G.Assumption loc | IDENT "autobatch"; params = auto_params -> - GrafiteAst.AutoBatch (loc,params) + G.AutoBatch (loc,params) | IDENT "cases"; what = tactic_term; pattern = OPT pattern_spec; specs = intros_spec -> let pattern = match pattern with - | None -> None, [], Some Ast.UserInput + | None -> None, [], Some N.UserInput | Some pattern -> pattern in - GrafiteAst.Cases (loc, what, pattern, specs) + G.Cases (loc, what, pattern, specs) | IDENT "clear"; ids = LIST1 IDENT -> - GrafiteAst.Clear (loc, ids) + G.Clear (loc, ids) | IDENT "clearbody"; id = IDENT -> - GrafiteAst.ClearBody (loc,id) + G.ClearBody (loc,id) | IDENT "change"; what = pattern_spec; "with"; t = tactic_term -> - GrafiteAst.Change (loc, what, t) + G.Change (loc, what, t) | IDENT "compose"; times = OPT int; t1 = tactic_term; t2 = OPT [ "with"; t = tactic_term -> t ]; specs = intros_spec -> let times = match times with None -> 1 | Some i -> i in - GrafiteAst.Compose (loc, t1, t2, times, specs) + G.Compose (loc, t1, t2, times, specs) | IDENT "constructor"; n = int -> - GrafiteAst.Constructor (loc, n) + G.Constructor (loc, n) | IDENT "contradiction" -> - GrafiteAst.Contradiction loc + G.Contradiction loc | IDENT "cut"; t = tactic_term; ident = OPT [ "as"; id = IDENT -> id] -> - GrafiteAst.Cut (loc, ident, t) + G.Cut (loc, ident, t) | IDENT "decompose"; idents = OPT [ "as"; idents = LIST1 new_name -> idents ] -> let idents = match idents with None -> [] | Some idents -> idents in - GrafiteAst.Decompose (loc, idents) - | IDENT "demodulate"; p = auto_params -> GrafiteAst.Demodulate (loc, p) + G.Decompose (loc, idents) + | IDENT "demodulate"; p = auto_params -> G.Demodulate (loc, p) | IDENT "destruct"; xts = OPT [ ts = tactic_term_list1 -> ts ] -> - GrafiteAst.Destruct (loc, xts) + G.Destruct (loc, xts) | IDENT "elim"; what = tactic_term; using = using; pattern = OPT pattern_spec; ispecs = intros_spec -> let pattern = match pattern with - | None -> None, [], Some Ast.UserInput + | None -> None, [], Some N.UserInput | Some pattern -> pattern in - GrafiteAst.Elim (loc, what, using, pattern, ispecs) + G.Elim (loc, what, using, pattern, ispecs) | IDENT "elimType"; what = tactic_term; using = using; (num, idents) = intros_spec -> - GrafiteAst.ElimType (loc, what, using, (num, idents)) + G.ElimType (loc, what, using, (num, idents)) | IDENT "exact"; t = tactic_term -> - GrafiteAst.Exact (loc, t) + G.Exact (loc, t) | IDENT "exists" -> - GrafiteAst.Exists loc - | IDENT "fail" -> GrafiteAst.Fail loc + G.Exists loc + | IDENT "fail" -> G.Fail loc | IDENT "fold"; kind = reduction_kind; t = tactic_term; p = pattern_spec -> let (pt,_,_) = p in if pt <> None then @@ -302,22 +303,22 @@ EXTEND ("the pattern cannot specify the term to replace, only its" ^ " paths in the hypotheses and in the conclusion"))) else - GrafiteAst.Fold (loc, kind, t, p) + G.Fold (loc, kind, t, p) | IDENT "fourier" -> - GrafiteAst.Fourier loc + G.Fourier loc | IDENT "fwd"; hyp = IDENT; idents = OPT [ "as"; idents = LIST1 new_name -> idents ] -> let idents = match idents with None -> [] | Some idents -> idents in - GrafiteAst.FwdSimpl (loc, hyp, idents) + G.FwdSimpl (loc, hyp, idents) | IDENT "generalize"; p=pattern_spec; id = OPT ["as" ; id = IDENT -> id] -> - GrafiteAst.Generalize (loc,p,id) - | IDENT "id" -> GrafiteAst.IdTac loc + G.Generalize (loc,p,id) + | IDENT "id" -> G.IdTac loc | IDENT "intro"; ident = OPT IDENT -> let idents = match ident with None -> [] | Some id -> [Some id] in - GrafiteAst.Intros (loc, (Some 1, idents)) + G.Intros (loc, (Some 1, idents)) | IDENT "intros"; specs = intros_spec -> - GrafiteAst.Intros (loc, specs) + G.Intros (loc, specs) | IDENT "inversion"; t = tactic_term -> - GrafiteAst.Inversion (loc, t) + G.Inversion (loc, t) | IDENT "lapply"; linear = OPT [ IDENT "linear" ]; depth = OPT [ IDENT "depth"; SYMBOL "="; i = int -> i ]; @@ -326,16 +327,16 @@ EXTEND ident = OPT [ "as" ; ident = IDENT -> ident ] -> let linear = match linear with None -> false | Some _ -> true in let to_what = match to_what with None -> [] | Some to_what -> to_what in - GrafiteAst.LApply (loc, linear, depth, to_what, what, ident) - | IDENT "left" -> GrafiteAst.Left loc + G.LApply (loc, linear, depth, to_what, what, ident) + | IDENT "left" -> G.Left loc | IDENT "letin"; where = IDENT ; SYMBOL <:unicode> ; t = tactic_term -> - GrafiteAst.LetIn (loc, t, where) + G.LetIn (loc, t, where) | kind = reduction_kind; p = pattern_spec -> - GrafiteAst.Reduce (loc, kind, p) + G.Reduce (loc, kind, p) | IDENT "reflexivity" -> - GrafiteAst.Reflexivity loc + G.Reflexivity loc | IDENT "replace"; p = pattern_spec; "with"; t = tactic_term -> - GrafiteAst.Replace (loc, p, t) + G.Replace (loc, p, t) | IDENT "rewrite" ; d = direction; t = tactic_term ; p = pattern_spec; xnames = OPT [ "as"; n = ident_list0 -> n ] -> let (pt,_,_) = p in @@ -346,53 +347,53 @@ EXTEND "the pattern cannot specify the term to rewrite, only its paths in the hypotheses and in the conclusion"))) else let n = match xnames with None -> [] | Some names -> names in - GrafiteAst.Rewrite (loc, d, t, p, n) + G.Rewrite (loc, d, t, p, n) | IDENT "right" -> - GrafiteAst.Right loc + G.Right loc | IDENT "ring" -> - GrafiteAst.Ring loc + G.Ring loc | IDENT "split" -> - GrafiteAst.Split loc + G.Split loc | IDENT "symmetry" -> - GrafiteAst.Symmetry loc + G.Symmetry loc | IDENT "transitivity"; t = tactic_term -> - GrafiteAst.Transitivity (loc, t) + G.Transitivity (loc, t) (* Produzioni Aggiunte *) | IDENT "assume" ; id = IDENT ; SYMBOL ":" ; t = tactic_term -> - GrafiteAst.Assume (loc, id, t) + G.Assume (loc, id, t) | IDENT "suppose" ; t = tactic_term ; LPAREN ; id = IDENT ; RPAREN ; t1 = OPT [IDENT "that" ; IDENT "is" ; IDENT "equivalent" ; "to" ; t' = tactic_term -> t']-> - GrafiteAst.Suppose (loc, t, id, t1) + G.Suppose (loc, t, id, t1) | "let" ; id1 = IDENT ; SYMBOL ":" ; t1 = tactic_term ; IDENT "such" ; IDENT "that" ; t2=tactic_term ; LPAREN ; id2 = IDENT ; RPAREN -> - GrafiteAst.ExistsElim (loc, `Auto ([],[]), id1, t1, id2, t2) + G.ExistsElim (loc, `Auto ([],[]), id1, t1, id2, t2) | just = [ IDENT "using"; t=tactic_term -> `Term t | params = auto_params -> `Auto params] ; cont=by_continuation -> (match cont with - BYC_done -> GrafiteAst.Bydone (loc, just) + BYC_done -> G.Bydone (loc, just) | BYC_weproved (ty,id,t1) -> - GrafiteAst.By_just_we_proved(loc, just, ty, id, t1) + G.By_just_we_proved(loc, just, ty, id, t1) | BYC_letsuchthat (id1,t1,id2,t2) -> - GrafiteAst.ExistsElim (loc, just, id1, t1, id2, t2) + G.ExistsElim (loc, just, id1, t1, id2, t2) | BYC_wehaveand (id1,t1,id2,t2) -> - GrafiteAst.AndElim (loc, just, id1, t1, id2, t2)) + G.AndElim (loc, just, id1, t1, id2, t2)) | IDENT "we" ; IDENT "need" ; "to" ; IDENT "prove" ; t = tactic_term ; id = OPT [ LPAREN ; id = IDENT ; RPAREN -> id ] ; t1 = OPT [IDENT "or" ; IDENT "equivalently"; t' = tactic_term -> t']-> - GrafiteAst.We_need_to_prove (loc, t, id, t1) + G.We_need_to_prove (loc, t, id, t1) | IDENT "we" ; IDENT "proceed" ; IDENT "by" ; IDENT "cases" ; "on" ; t=tactic_term ; "to" ; IDENT "prove" ; t1=tactic_term -> - GrafiteAst.We_proceed_by_cases_on (loc, t, t1) + G.We_proceed_by_cases_on (loc, t, t1) | IDENT "we" ; IDENT "proceed" ; IDENT "by" ; IDENT "induction" ; "on" ; t=tactic_term ; "to" ; IDENT "prove" ; t1=tactic_term -> - GrafiteAst.We_proceed_by_induction_on (loc, t, t1) + G.We_proceed_by_induction_on (loc, t, t1) | IDENT "by" ; IDENT "induction" ; IDENT "hypothesis" ; IDENT "we" ; IDENT "know" ; t=tactic_term ; LPAREN ; id = IDENT ; RPAREN -> - GrafiteAst.Byinduction(loc, t, id) + G.Byinduction(loc, t, id) | IDENT "the" ; IDENT "thesis" ; IDENT "becomes" ; t=tactic_term -> - GrafiteAst.Thesisbecomes(loc, t) + G.Thesisbecomes(loc, t) | IDENT "case" ; id = IDENT ; params=LIST0[LPAREN ; i=IDENT ; SYMBOL":" ; t=tactic_term ; RPAREN -> i,t] -> - GrafiteAst.Case(loc,id,params) + G.Case(loc,id,params) (* DO NOT FACTORIZE with the two following, camlp5 sucks*) | IDENT "conclude"; termine = tactic_term; @@ -404,7 +405,7 @@ EXTEND | IDENT "proof" -> `Proof | params = auto_params -> `Auto params]; cont = rewriting_step_continuation -> - GrafiteAst.RewritingStep(loc, Some (None,termine), t1, t2, cont) + G.RewritingStep(loc, Some (None,termine), t1, t2, cont) | IDENT "obtain" ; name = IDENT; termine = tactic_term; SYMBOL "=" ; @@ -415,7 +416,7 @@ EXTEND | IDENT "proof" -> `Proof | params = auto_params -> `Auto params]; cont = rewriting_step_continuation -> - GrafiteAst.RewritingStep(loc, Some (Some name,termine), t1, t2, cont) + G.RewritingStep(loc, Some (Some name,termine), t1, t2, cont) | SYMBOL "=" ; t1=tactic_term ; t2 = @@ -424,7 +425,7 @@ EXTEND | IDENT "proof" -> `Proof | params = auto_params -> `Auto params]; cont = rewriting_step_continuation -> - GrafiteAst.RewritingStep(loc, None, t1, t2, cont) + G.RewritingStep(loc, None, t1, t2, cont) ] ]; auto_fixed_param: [ @@ -472,50 +473,50 @@ EXTEND [ t1 = SELF; SYMBOL ";"; t2 = SELF -> let ts = match t1 with - | GrafiteAst.Seq (_, l) -> l @ [ t2 ] + | G.Seq (_, l) -> l @ [ t2 ] | _ -> [ t1; t2 ] in - GrafiteAst.Seq (loc, ts) + G.Seq (loc, ts) ] | "then" NONA [ tac = SELF; SYMBOL ";"; SYMBOL "["; tacs = LIST0 SELF SEP SYMBOL "|"; SYMBOL "]"-> - (GrafiteAst.Then (loc, tac, tacs)) + (G.Then (loc, tac, tacs)) ] | "loops" RIGHTA [ IDENT "do"; count = int; tac = SELF -> - GrafiteAst.Do (loc, count, tac) - | IDENT "repeat"; tac = SELF -> GrafiteAst.Repeat (loc, tac) + G.Do (loc, count, tac) + | IDENT "repeat"; tac = SELF -> G.Repeat (loc, tac) ] | "simple" NONA [ IDENT "first"; SYMBOL "["; tacs = LIST0 SELF SEP SYMBOL "|"; SYMBOL "]"-> - GrafiteAst.First (loc, tacs) - | IDENT "try"; tac = SELF -> GrafiteAst.Try (loc, tac) + G.First (loc, tacs) + | IDENT "try"; tac = SELF -> G.Try (loc, tac) | IDENT "solve"; SYMBOL "["; tacs = LIST0 SELF SEP SYMBOL "|"; SYMBOL "]"-> - GrafiteAst.Solve (loc, tacs) - | IDENT "progress"; tac = SELF -> GrafiteAst.Progress (loc, tac) + G.Solve (loc, tacs) + | IDENT "progress"; tac = SELF -> G.Progress (loc, tac) | LPAREN; tac = SELF; RPAREN -> tac | tac = tactic -> tac ] ]; punctuation_tactical: [ - [ SYMBOL "[" -> GrafiteAst.Branch loc - | SYMBOL "|" -> GrafiteAst.Shift loc - | i = LIST1 int SEP SYMBOL ","; SYMBOL ":" -> GrafiteAst.Pos (loc, i) - | SYMBOL "*"; SYMBOL ":" -> GrafiteAst.Wildcard loc - | SYMBOL "]" -> GrafiteAst.Merge loc - | SYMBOL ";" -> GrafiteAst.Semicolon loc - | SYMBOL "." -> GrafiteAst.Dot loc + [ SYMBOL "[" -> G.Branch loc + | SYMBOL "|" -> G.Shift loc + | i = LIST1 int SEP SYMBOL ","; SYMBOL ":" -> G.Pos (loc, i) + | SYMBOL "*"; SYMBOL ":" -> G.Wildcard loc + | SYMBOL "]" -> G.Merge loc + | SYMBOL ";" -> G.Semicolon loc + | SYMBOL "." -> G.Dot loc ] ]; non_punctuation_tactical: [ "simple" NONA - [ IDENT "focus"; goals = LIST1 int -> GrafiteAst.Focus (loc, goals) - | IDENT "unfocus" -> GrafiteAst.Unfocus loc - | IDENT "skip" -> GrafiteAst.Skip loc + [ IDENT "focus"; goals = LIST1 int -> G.Focus (loc, goals) + | IDENT "unfocus" -> G.Unfocus loc + | IDENT "skip" -> G.Skip loc ] ]; ntheorem_flavour: [ @@ -589,33 +590,33 @@ EXTEND macro: [ [ [ IDENT "check" ]; t = term -> - GrafiteAst.Check (loc, t) + G.Check (loc, t) | [ IDENT "eval" ]; kind = reduction_kind; "on"; t = tactic_term -> - GrafiteAst.Eval (loc, kind, t) + G.Eval (loc, kind, t) | [ IDENT "inline"]; style = OPT [ IDENT "procedural"; depth = OPT int -> depth ]; suri = QSTRING; prefix = OPT QSTRING; flavour = OPT [ "as"; attr = inline_flavour -> attr ] -> let style = match style with - | None -> GrafiteAst.Declarative - | Some depth -> GrafiteAst.Procedural depth + | None -> G.Declarative + | Some depth -> G.Procedural depth in let prefix = match prefix with None -> "" | Some prefix -> prefix in - GrafiteAst.Inline (loc,style,suri,prefix, flavour) + G.Inline (loc,style,suri,prefix, flavour) | [ IDENT "hint" ]; rew = OPT (IDENT "rewrite") -> - if rew = None then GrafiteAst.Hint (loc, false) else GrafiteAst.Hint (loc,true) + if rew = None then G.Hint (loc, false) else G.Hint (loc,true) | IDENT "auto"; params = auto_params -> - GrafiteAst.AutoInteractive (loc,params) + G.AutoInteractive (loc,params) | [ IDENT "whelp"; "match" ] ; t = term -> - GrafiteAst.WMatch (loc,t) + G.WMatch (loc,t) | [ IDENT "whelp"; IDENT "instance" ] ; t = term -> - GrafiteAst.WInstance (loc,t) + G.WInstance (loc,t) | [ IDENT "whelp"; IDENT "locate" ] ; id = QSTRING -> - GrafiteAst.WLocate (loc,id) + G.WLocate (loc,id) | [ IDENT "whelp"; IDENT "elim" ] ; t = term -> - GrafiteAst.WElim (loc, t) + G.WElim (loc, t) | [ IDENT "whelp"; IDENT "hint" ] ; t = term -> - GrafiteAst.WHint (loc,t) + G.WHint (loc,t) ] ]; alias_spec: [ @@ -630,7 +631,7 @@ EXTEND if (try ignore (UriManager.uri_of_string uri); true with UriManager.IllFormedUri _ -> false) then - LexiconAst.Ident_alias (id, uri) + L.Ident_alias (id, uri) else raise (HExtlib.Localized (loc, CicNotationParser.Parse_error (Printf.sprintf "Not a valid uri: %s" uri))) @@ -643,20 +644,20 @@ EXTEND let instance = match instance with Some i -> i | None -> 0 in - LexiconAst.Symbol_alias (symbol, instance, dsc) + L.Symbol_alias (symbol, instance, dsc) | IDENT "num"; instance = OPT [ LPAREN; IDENT "instance"; n = int; RPAREN -> n ]; SYMBOL "="; dsc = QSTRING -> let instance = match instance with Some i -> i | None -> 0 in - LexiconAst.Number_alias (instance, dsc) + L.Number_alias (instance, dsc) ] ]; argument: [ [ l = LIST0 [ SYMBOL <:unicode> (* η *); SYMBOL "." -> () ]; id = IDENT -> - Ast.IdentArg (List.length l, id) + N.IdentArg (List.length l, id) ] ]; associativity: [ @@ -696,14 +697,14 @@ EXTEND ] ]; level3_term: [ - [ u = URI -> Ast.UriPattern (UriManager.uri_of_string u) - | id = IDENT -> Ast.VarPattern id - | SYMBOL "_" -> Ast.ImplicitPattern + [ u = URI -> N.UriPattern (UriManager.uri_of_string u) + | id = IDENT -> N.VarPattern id + | SYMBOL "_" -> N.ImplicitPattern | LPAREN; terms = LIST1 SELF; RPAREN -> (match terms with | [] -> assert false | [term] -> term - | terms -> Ast.ApplPattern terms) + | terms -> N.ApplPattern terms) ] ]; interpretation: [ @@ -714,37 +715,37 @@ EXTEND include_command: [ [ IDENT "include" ; path = QSTRING -> - loc,path,LexiconAst.WithPreferences + loc,path,L.WithPreferences | IDENT "include'" ; path = QSTRING -> - loc,path,LexiconAst.WithoutPreferences + loc,path,L.WithoutPreferences ]]; grafite_command: [ [ IDENT "set"; n = QSTRING; v = QSTRING -> - GrafiteAst.Set (loc, n, v) - | IDENT "drop" -> GrafiteAst.Drop loc - | IDENT "print"; s = IDENT -> GrafiteAst.Print (loc,s) - | IDENT "qed" -> GrafiteAst.Qed loc - | IDENT "nqed" -> GrafiteAst.NQed loc + G.Set (loc, n, v) + | IDENT "drop" -> G.Drop loc + | IDENT "print"; s = IDENT -> G.Print (loc,s) + | IDENT "qed" -> G.Qed loc + | IDENT "nqed" -> G.NQed loc | IDENT "variant" ; name = IDENT; SYMBOL ":"; typ = term; SYMBOL <:unicode> ; newname = IDENT -> - GrafiteAst.Obj (loc, - Ast.Theorem - (`Variant,name,typ,Some (Ast.Ident (newname, None)))) + G.Obj (loc, + N.Theorem + (`Variant,name,typ,Some (N.Ident (newname, None)))) | nflavour = ntheorem_flavour; name = IDENT; SYMBOL ":"; typ = term; body = OPT [ SYMBOL <:unicode> (* ≝ *); body = term -> body ] -> - GrafiteAst.NObj (loc, Ast.Theorem (nflavour, name, typ, body)) + G.NObj (loc, N.Theorem (nflavour, name, typ, body)) | flavour = theorem_flavour; name = IDENT; SYMBOL ":"; typ = term; body = OPT [ SYMBOL <:unicode> (* ≝ *); body = term -> body ] -> - GrafiteAst.Obj (loc, Ast.Theorem (flavour, name, typ, body)) + G.Obj (loc, N.Theorem (flavour, name, typ, body)) | flavour = theorem_flavour; name = IDENT; SYMBOL <:unicode> (* ≝ *); body = term -> - GrafiteAst.Obj (loc, - Ast.Theorem (flavour, name, Ast.Implicit, Some body)) + G.Obj (loc, + N.Theorem (flavour, name, N.Implicit, Some body)) | IDENT "axiom"; name = IDENT; SYMBOL ":"; typ = term -> - GrafiteAst.Obj (loc, Ast.Theorem (`Axiom, name, typ, None)) + G.Obj (loc, N.Theorem (`Axiom, name, typ, None)) | IDENT "naxiom"; name = IDENT; SYMBOL ":"; typ = term -> - GrafiteAst.NObj (loc, Ast.Theorem (`Axiom, name, typ, None)) + G.NObj (loc, N.Theorem (`Axiom, name, typ, None)) | LETCOREC ; defs = let_defs -> mk_rec_corec false `CoInductive defs loc | LETREC ; defs = let_defs -> @@ -755,48 +756,48 @@ EXTEND mk_rec_corec true `Inductive defs loc | IDENT "inductive"; spec = inductive_spec -> let (params, ind_types) = spec in - GrafiteAst.Obj (loc, Ast.Inductive (params, ind_types)) + G.Obj (loc, N.Inductive (params, ind_types)) | IDENT "ninductive"; spec = inductive_spec -> let (params, ind_types) = spec in - GrafiteAst.NObj (loc, Ast.Inductive (params, ind_types)) + G.NObj (loc, N.Inductive (params, ind_types)) | IDENT "coinductive"; spec = inductive_spec -> let (params, ind_types) = spec in let ind_types = (* set inductive flags to false (coinductive) *) List.map (fun (name, _, term, ctors) -> (name, false, term, ctors)) ind_types in - GrafiteAst.Obj (loc, Ast.Inductive (params, ind_types)) + G.Obj (loc, N.Inductive (params, ind_types)) | IDENT "ncoinductive"; spec = inductive_spec -> let (params, ind_types) = spec in let ind_types = (* set inductive flags to false (coinductive) *) List.map (fun (name, _, term, ctors) -> (name, false, term, ctors)) ind_types in - GrafiteAst.NObj (loc, Ast.Inductive (params, ind_types)) + G.NObj (loc, N.Inductive (params, ind_types)) | IDENT "coercion" ; - t = [ u = URI -> Ast.Uri (u,None) | t = tactic_term ; OPT "with" -> t ] ; + t = [ u = URI -> N.Uri (u,None) | t = tactic_term ; OPT "with" -> t ] ; arity = OPT int ; saturations = OPT int; composites = OPT (IDENT "nocomposites") -> let arity = match arity with None -> 0 | Some x -> x in let saturations = match saturations with None -> 0 | Some x -> x in let composites = match composites with None -> true | Some _ -> false in - GrafiteAst.Coercion + G.Coercion (loc, t, composites, arity, saturations) | IDENT "prefer" ; IDENT "coercion"; t = tactic_term -> - GrafiteAst.PreferCoercion (loc, t) + G.PreferCoercion (loc, t) | IDENT "pump" ; steps = int -> - GrafiteAst.Pump(loc,steps) + G.Pump(loc,steps) | IDENT "unification"; IDENT "hint"; n = int; t = tactic_term -> - GrafiteAst.UnificationHint (loc, t, n) + G.UnificationHint (loc, t, n) | IDENT "inverter"; name = IDENT; IDENT "for"; indty = tactic_term; paramspec = inverter_param_list -> - GrafiteAst.Inverter + G.Inverter (loc, name, indty, paramspec) | IDENT "record" ; (params,name,ty,fields) = record_spec -> - GrafiteAst.Obj (loc, Ast.Record (params,name,ty,fields)) + G.Obj (loc, N.Record (params,name,ty,fields)) | IDENT "default" ; what = QSTRING ; uris = LIST1 URI -> let uris = List.map UriManager.uri_of_string uris in - GrafiteAst.Default (loc,what,uris) + G.Default (loc,what,uris) | IDENT "relation" ; aeq = tactic_term ; "on" ; a = tactic_term ; refl = OPT [ IDENT "reflexivity" ; IDENT "proved" ; IDENT "by" ; refl = tactic_term -> refl ] ; @@ -805,64 +806,71 @@ EXTEND trans = OPT [ IDENT "transitivity" ; IDENT "proved" ; IDENT "by" ; trans = tactic_term -> trans ] ; "as" ; id = IDENT -> - GrafiteAst.Relation (loc,id,a,aeq,refl,sym,trans) + G.Relation (loc,id,a,aeq,refl,sym,trans) ]]; lexicon_command: [ [ IDENT "alias" ; spec = alias_spec -> - LexiconAst.Alias (loc, spec) + L.Alias (loc, spec) | IDENT "notation"; (dir, l1, assoc, prec, l2) = notation -> - LexiconAst.Notation (loc, dir, l1, assoc, prec, l2) + L.Notation (loc, dir, l1, assoc, prec, l2) | IDENT "interpretation"; id = QSTRING; (symbol, args, l3) = interpretation -> - LexiconAst.Interpretation (loc, id, (symbol, args), l3) + L.Interpretation (loc, id, (symbol, args), l3) ]]; executable: [ - [ cmd = grafite_command; SYMBOL "." -> GrafiteAst.Command (loc, cmd) + [ cmd = grafite_command; SYMBOL "." -> G.Command (loc, cmd) | tac = atomic_tactical LEVEL "loops"; punct = punctuation_tactical -> - GrafiteAst.Tactic (loc, Some tac, punct) - | punct = punctuation_tactical -> GrafiteAst.Tactic (loc, None, punct) + G.Tactic (loc, Some tac, punct) + | punct = punctuation_tactical -> G.Tactic (loc, None, punct) | tac = ntactic; punct = punctuation_tactical -> - GrafiteAst.NTactic (loc, tac, punct) + G.NTactic (loc, tac, punct) | SYMBOL "#" ; SYMBOL "#" ; punct = punctuation_tactical -> - GrafiteAst.NTactic (loc, GrafiteAst.NId loc, punct) + G.NTactic (loc, G.NId loc, punct) | tac = non_punctuation_tactical; punct = punctuation_tactical -> - GrafiteAst.NonPunctuationTactical (loc, tac, punct) - | mac = macro; SYMBOL "." -> GrafiteAst.Macro (loc, mac) + G.NonPunctuationTactical (loc, tac, punct) + | mac = macro; SYMBOL "." -> G.Macro (loc, mac) ] ]; comment: [ [ BEGINCOMMENT ; ex = executable ; ENDCOMMENT -> - GrafiteAst.Code (loc, ex) + G.Code (loc, ex) | str = NOTE -> - GrafiteAst.Note (loc, str) + G.Note (loc, str) ] ]; statement: [ [ ex = executable -> - fun ?(never_include=false) ~include_paths status -> status,LSome(GrafiteAst.Executable (loc,ex)) + fun ?(never_include=false) ~include_paths status -> + let stm = G.Executable (loc, ex) in + !grafite_callback status stm; + status, LSome stm | com = comment -> fun ?(never_include=false) ~include_paths status -> - status,LSome (GrafiteAst.Comment (loc, com)) + let stm = G.Comment (loc, com) in + !grafite_callback status stm; + status, LSome stm | (iloc,fname,mode) = include_command ; SYMBOL "." -> - !out fname; fun ?(never_include=false) ~include_paths status -> - let _root, buri, fullpath, _rrelpath = - Librarian.baseuri_of_script ~include_paths fname - in - let status = - if never_include then raise (NoInclusionPerformed fullpath) - else LexiconEngine.eval_command status - (LexiconAst.Include (iloc,buri,mode,fullpath)) - in - status, - LSome - (GrafiteAst.Executable - (loc,GrafiteAst.Command - (loc,GrafiteAst.Include (iloc,buri)))) + let stm = + G.Executable (loc, G.Command (loc, G.Include (iloc, fname))) + in + !grafite_callback status stm; + let _root, buri, fullpath, _rrelpath = + Librarian.baseuri_of_script ~include_paths fname + in + let stm = + G.Executable (loc, G.Command (loc, G.Include (iloc, buri))) + in + let status = + if never_include then raise (NoInclusionPerformed fullpath) + else LE.eval_command status (L.Include (iloc,buri,mode,fullpath)) + in + status, LSome stm | scom = lexicon_command ; SYMBOL "." -> fun ?(never_include=false) ~include_paths status -> - let status = LexiconEngine.eval_command status scom in - status,LNone loc + !lexicon_callback status scom; + let status = LE.eval_command status scom in + status, LNone loc | EOI -> raise End_of_file ] ]; diff --git a/helm/software/components/grafite_parser/grafiteParser.mli b/helm/software/components/grafite_parser/grafiteParser.mli index b0dc6e8fd..1413e93fd 100644 --- a/helm/software/components/grafite_parser/grafiteParser.mli +++ b/helm/software/components/grafite_parser/grafiteParser.mli @@ -46,8 +46,13 @@ val parse_statement: Ulexing.lexbuf -> statement (** @raise End_of_file *) val statement: unit -> statement Grammar.Entry.e -(* this callback is called on every include command *) -val set_callback: (string -> unit) -> unit +(* this callback is called before every grafite statement *) +val set_grafite_callback: + (LexiconEngine.status -> ast_statement -> unit) -> unit + +(* this callback is called before every lexicon command *) +val set_lexicon_callback: + (LexiconEngine.status -> LexiconAst.command -> unit) -> unit val push : unit -> unit val pop : unit -> unit diff --git a/helm/software/components/lexicon/lexiconEngine.ml b/helm/software/components/lexicon/lexiconEngine.ml index 22d9b2f33..6f30801a4 100644 --- a/helm/software/components/lexicon/lexiconEngine.ml +++ b/helm/software/components/lexicon/lexiconEngine.ml @@ -25,21 +25,27 @@ (* $Id$ *) -let out = ref ignore +module L = LexiconAst -let set_callback f = out := f +let debug = ref true (* lexicon file name * ma file name *) exception IncludedFileNotCompiled of string * string exception MetadataNotFound of string (* file name *) type status = { - aliases: LexiconAst.alias_spec DisambiguateTypes.Environment.t; - multi_aliases: LexiconAst.alias_spec list DisambiguateTypes.Environment.t; + aliases: L.alias_spec DisambiguateTypes.Environment.t; + multi_aliases: L.alias_spec list DisambiguateTypes.Environment.t; lexicon_content_rev: LexiconMarshal.lexicon; notation_ids: CicNotation.notation_id list; (** in-scope notation ids *) } +let dump_aliases out msg status = + out (if msg = "" then "aliases dump:" else msg ^ ": aliases dump:"); + DisambiguateTypes.Environment.iter + (fun _ x -> out (LexiconAstPp.pp_alias x)) + status.aliases + let initial_status = { aliases = DisambiguateTypes.Environment.empty; multi_aliases = DisambiguateTypes.Environment.empty; @@ -53,30 +59,33 @@ let add_lexicon_content cmds status = List.fold_right (fun cmd acc -> match cmd with - | LexiconAst.Alias _ - | LexiconAst.Include _ - | LexiconAst.Notation _ -> cmd :: (List.filter ((<>) cmd) acc) - | LexiconAst.Interpretation _ -> if List.exists ((=) cmd) acc then acc else cmd::acc) + | L.Alias _ + | L.Include _ + | L.Notation _ -> cmd :: (List.filter ((<>) cmd) acc) + | L.Interpretation _ -> if List.exists ((=) cmd) acc then acc else cmd::acc) cmds content in -(* prerr_endline ("new lexicon content: " ^ String.concat " " (List.map - LexiconAstPp.pp_command content')); *) +(* + prerr_endline ("new lexicon content: " ^ + String.concat "; " (List.map LexiconAstPp.pp_command content') + ); +*) { status with lexicon_content_rev = content' } let set_proof_aliases mode status new_aliases = - if mode = LexiconAst.WithoutPreferences then + if mode = L.WithoutPreferences then status else let commands_of_aliases = List.map - (fun _,alias -> LexiconAst.Alias (HExtlib.dummy_floc, alias)) + (fun _,alias -> L.Alias (HExtlib.dummy_floc, alias)) in let aliases = List.fold_left (fun acc (d,c) -> DisambiguateTypes.Environment.add d c acc) status.aliases new_aliases in let multi_aliases = List.fold_left (fun acc (d,c) -> - DisambiguateTypes.Environment.cons LexiconAst.description_of_alias + DisambiguateTypes.Environment.cons L.description_of_alias d c acc) status.multi_aliases new_aliases in @@ -92,10 +101,14 @@ let set_proof_aliases mode status new_aliases = status -let rec eval_command ?(mode=LexiconAst.WithPreferences) status cmd = +let rec eval_command ?(mode=L.WithPreferences) status cmd = +(* + let bmode = match mode with L.WithPreferences -> true | _ -> false in + Printf.eprintf "Include preferences: %b\n" bmode; +*) let cmd = match cmd with - | LexiconAst.Interpretation (loc, dsc, (symbol, args), cic_appl_pattern) -> + | L.Interpretation (loc, dsc, (symbol, args), cic_appl_pattern) -> let rec disambiguate = function CicNotationPt.ApplPattern l -> @@ -106,29 +119,30 @@ let rec eval_command ?(mode=LexiconAst.WithPreferences) status cmd = (function (CicNotationPt.IdentArg (_,id')) -> id'=id) args) -> let item = DisambiguateTypes.Id id in - (try + begin try let uri = match DisambiguateTypes.Environment.find item status.aliases with - LexiconAst.Ident_alias (_, uri)-> UriManager.uri_of_string uri + L.Ident_alias (_, uri)-> UriManager.uri_of_string uri | _ -> assert false in CicNotationPt.UriPattern uri with Not_found -> - prerr_endline ("Domain item not found: " ^ + prerr_endline ("LexiconEngine.eval_command: domain item not found: " ^ (DisambiguateTypes.string_of_domain_item item)); - assert false) + dump_aliases prerr_endline "" status; + assert false + end | p -> p in - LexiconAst.Interpretation + L.Interpretation (loc, dsc, (symbol, args), disambiguate cic_appl_pattern) | _-> cmd in - !out cmd; let notation_ids' = CicNotation.process_notation cmd in let status = { status with notation_ids = notation_ids' @ status.notation_ids } in match cmd with - | LexiconAst.Include (loc, baseuri, mode, fullpath) -> + | L.Include (loc, baseuri, mode, fullpath) -> let lexiconpath_rw, lexiconpath_r = LibraryMisc.lexicon_file_of_baseuri ~must_exist:false ~writable:true ~baseuri, @@ -143,25 +157,25 @@ let rec eval_command ?(mode=LexiconAst.WithPreferences) status cmd = let lexicon = LexiconMarshal.load_lexicon lexiconpath in let status = List.fold_left (eval_command ~mode) status lexicon in status - | LexiconAst.Alias (loc, spec) -> + | L.Alias (loc, spec) -> let diff = (*CSC: Warning: this code should be factorized with the corresponding code in DisambiguatePp *) match spec with - | LexiconAst.Ident_alias (id,uri) -> + | L.Ident_alias (id,uri) -> [DisambiguateTypes.Id id,spec] - | LexiconAst.Symbol_alias (symb, instance, desc) -> + | L.Symbol_alias (symb, instance, desc) -> [DisambiguateTypes.Symbol (symb,instance),spec] - | LexiconAst.Number_alias (instance,desc) -> + | L.Number_alias (instance,desc) -> [DisambiguateTypes.Num instance,spec] in set_proof_aliases mode status diff - | LexiconAst.Interpretation (_, dsc, (symbol, _), _) as stm -> + | L.Interpretation (_, dsc, (symbol, _), _) as stm -> let status = add_lexicon_content [stm] status in let diff = try [DisambiguateTypes.Symbol (symbol, 0), - LexiconAst.Symbol_alias (symbol,0,dsc)] + L.Symbol_alias (symbol,0,dsc)] with DisambiguateChoices.Choice_not_found msg -> prerr_endline (Lazy.force msg); @@ -169,10 +183,17 @@ let rec eval_command ?(mode=LexiconAst.WithPreferences) status cmd = in let status = set_proof_aliases mode status diff in status - | LexiconAst.Notation _ as stm -> + | L.Notation _ as stm -> add_lexicon_content [stm] status -let eval_command = eval_command ?mode:None +let eval_command status cmd = + if !debug then dump_aliases prerr_endline "before eval_command" status; + let status = eval_command ?mode:None status cmd in + if !debug then dump_aliases prerr_endline "after eval_command" status; + status -let set_proof_aliases = set_proof_aliases LexiconAst.WithPreferences - +let set_proof_aliases status aliases = + if !debug then dump_aliases prerr_endline "before set_proof_aliases" status; + let status = set_proof_aliases L.WithPreferences status aliases in + if !debug then dump_aliases prerr_endline "after set_proof_aliases" status; + status diff --git a/helm/software/components/lexicon/lexiconEngine.mli b/helm/software/components/lexicon/lexiconEngine.mli index 27d9b05eb..11d92d462 100644 --- a/helm/software/components/lexicon/lexiconEngine.mli +++ b/helm/software/components/lexicon/lexiconEngine.mli @@ -40,5 +40,5 @@ val set_proof_aliases: status -> (DisambiguateTypes.domain_item * LexiconAst.alias_spec) list -> status -(* this callback is called on every lexicon command *) -val set_callback: (LexiconAst.command -> unit) -> unit +(* args: print function, message (may be empty), status *) +val dump_aliases: (string -> unit) -> string -> status -> unit diff --git a/helm/software/components/syntax_extensions/.depend b/helm/software/components/syntax_extensions/.depend index 25e67131f..f3c6a8bd1 100644 --- a/helm/software/components/syntax_extensions/.depend +++ b/helm/software/components/syntax_extensions/.depend @@ -1,5 +1,2 @@ -utf8Macro.cmi: -utf8MacroTable.cmo: -utf8MacroTable.cmx: utf8Macro.cmo: utf8MacroTable.cmo utf8Macro.cmi utf8Macro.cmx: utf8MacroTable.cmx utf8Macro.cmi diff --git a/helm/software/matita/applyTransformation.ml b/helm/software/matita/applyTransformation.ml index 21b841f41..2309d8fb0 100644 --- a/helm/software/matita/applyTransformation.ml +++ b/helm/software/matita/applyTransformation.ml @@ -45,6 +45,7 @@ module GE = GrafiteEngine module LS = LibrarySync module Ds = CicDischarge module PO = ProceduralOptimizer +module N = CicNotationPt let mpres_document pres_box = Xml.add_xml_declaration (CicNotationPres.print_box pres_box) @@ -176,6 +177,13 @@ let term2pres ~map_unicode_to_tex n ids_to_inner_sorts annterm = let s = BoxPp.render_to_string ~map_unicode_to_tex render n mpres in remove_closed_substs s +let enable_notations x = () (* function + | true -> + CicNotation.set_active_notations + (List.map fst (CicNotation.get_all_notations ())) + | false -> + CicNotation.set_active_notations [] +*) let txt_of_cic_object ~map_unicode_to_tex ?skip_thm_and_qed ?skip_initial_lambdas n style ?flavour prefix obj @@ -224,14 +232,24 @@ let txt_of_cic_object let term_pp = term2pres ~map_unicode_to_tex (n - 8) ids_to_inner_sorts in let lazy_term_pp = term_pp in let obj_pp = CicNotationPp.pp_obj term_pp in - let aux = GrafiteAstPp.pp_statement - ~map_unicode_to_tex ~term_pp ~lazy_term_pp ~obj_pp in + let stm_pp = + GrafiteAstPp.pp_statement + ~map_unicode_to_tex ~term_pp ~lazy_term_pp ~obj_pp + in + let aux = function + | G.Executable (_, G.Command (_, G.Obj (_, N.Inductive _))) as stm + -> + enable_notations false; + let str = stm_pp stm in enable_notations true; str +(* FG: we disable notation for Inductive to avoid recursive notation *) + | stm -> stm_pp stm + in let script = Acic2Procedural.procedural_of_acic_object ~ids_to_inner_sorts ~ids_to_inner_types ~info ?depth ?flavour prefix aobj in - "\n\n" ^ String.concat "" (List.map aux script) + String.concat "" (List.map aux script) ^ "\n\n" let cic_prefix = Str.regexp_string "cic:/" let matita_prefix = Str.regexp_string "cic:/matita/" diff --git a/helm/software/matita/matitacLib.ml b/helm/software/matita/matitacLib.ml index aff789517..b33b103c1 100644 --- a/helm/software/matita/matitacLib.ml +++ b/helm/software/matita/matitacLib.ml @@ -63,36 +63,46 @@ let dump f = Helm_registry.set_bool "matita.moo" false; let floc = H.dummy_floc in let nl_ast = G.Comment (floc, G.Note (floc, "")) in - let pp_ast_statement st = + let pp_statement stm = GrafiteAstPp.pp_statement ~term_pp:CicNotationPp.pp_term ~map_unicode_to_tex:(Helm_registry.get_bool "matita.paste_unicode_as_tex") ~lazy_term_pp:CicNotationPp.pp_term - ~obj_pp:(CicNotationPp.pp_obj CicNotationPp.pp_term) st + ~obj_pp:(CicNotationPp.pp_obj CicNotationPp.pp_term) stm in + let pp_lexicon = LexiconAstPp.pp_command in let och = open_out f in - let nl () = output_string och (pp_ast_statement nl_ast) in + let nl () = output_string och (pp_statement nl_ast) in MatitaMisc.out_preamble och; - let grafite_parser_cb fname = - let ast = G.Executable - (floc, G.Command (floc, G.Include (floc, fname))) in - output_string och (pp_ast_statement ast); nl (); nl () + let grafite_parser_cb status = function + | G.Executable (_, G.Macro (_, G.Inline _)) -> () + | stm -> + output_string och (pp_statement stm); nl (); nl () in + let lexicon_parser_cb status cmd = + output_string och (pp_lexicon cmd); nl (); nl () + in +(* let matita_engine_cb = function | G.Executable (_, G.Macro (_, G.Inline _)) | G.Executable (_, G.Command (_, G.Include _)) -> () | ast -> - output_string och (pp_ast_statement ast); nl (); nl () - in +*) let matitac_lib_cb = output_string och in - GrafiteParser.set_callback grafite_parser_cb; - MatitaEngine.set_callback matita_engine_cb; - set_callback matitac_lib_cb; - fun x -> + begin fun () -> + GrafiteParser.set_grafite_callback grafite_parser_cb; + GrafiteParser.set_lexicon_callback lexicon_parser_cb; +(* + MatitaEngine.set_callback matita_engine_cb; +*) + set_callback matitac_lib_cb + end, + begin fun x -> close_out och; - GrafiteParser.set_callback ignore; - MatitaEngine.set_callback ignore; + GrafiteParser.set_grafite_callback (fun _ _ -> ()); + GrafiteParser.set_lexicon_callback (fun _ _ -> ()); set_callback ignore; x + end ;; let get_macro_context = function @@ -164,7 +174,7 @@ let activate_extraction baseuri fname = flush f; []); ;; -let compile options fname = +let compile atstart options fname = let matita_debug = Helm_registry.get_bool "matita.debug" in let include_paths = get_include_paths options in let root,baseuri,fname,_tgt = @@ -175,6 +185,7 @@ let compile options fname = CicNotation2.load_notation ~include_paths:[] BuildTimeConf.core_notation_script in + atstart (); let grafite_status = GrafiteSync.init lexicon_status baseuri in let big_bang = Unix.gettimeofday () in let { Unix.tms_utime = big_bang_u ; Unix.tms_stime = big_bang_s} = @@ -302,7 +313,8 @@ let compile options fname = let (x, y) = HExtlib.loc_of_floc floc in HLog.error (sprintf "Parse error at %d-%d: %s" x y err) | exn when matita_debug -> raise exn' - | exn -> HLog.error (snd (MatitaExcPp.to_string exn))); + | exn -> HLog.error (snd (MatitaExcPp.to_string exn)) + ); (* LexiconSync.time_travel ~present:lex_stat ~past:initial_lexicon_status; * *) pp_times fname false big_bang big_bang_u big_bang_s; @@ -365,11 +377,11 @@ module F = let build options fname = let matita_debug = Helm_registry.get_bool "matita.debug" in - let compile opts fname = + let compile atstart opts fname = try GrafiteSync.push (); GrafiteParser.push (); - let rc = compile opts fname in + let rc = compile atstart opts fname in GrafiteParser.pop (); GrafiteSync.pop (); rc @@ -384,15 +396,15 @@ module F = in if Filename.check_suffix fname ".mma" then let generated = Filename.chop_suffix fname ".mma" ^ ".ma" in - let atexit = dump generated in - let res = compile options fname in + let atstart, atexit = dump generated in + let res = compile atstart options fname in let r = compact (atexit res) in if r then r else begin - Sys.remove generated; +(* Sys.remove generated; *) Printf.printf "rm %s\n" generated; flush stdout; r end else - compile options fname + compile ignore options fname ;; let load_deps_file = Librarian.load_deps_file;;