X-Git-Url: http://matita.cs.unibo.it/gitweb/?a=blobdiff_plain;f=helm%2Fsoftware%2Fcomponents%2Fgrafite_parser%2FgrafiteParser.ml;h=b1362b0f648c97bb131cae47537f4c848718d4be;hb=f9abd21eb0d26cf9b632af4df819225be4d091e3;hp=5a22a4b62817c6cf354d9bcfa7668aa03deacff7;hpb=7ce251730873891f2975bc8c46b122e842d203db;p=helm.git diff --git a/helm/software/components/grafite_parser/grafiteParser.ml b/helm/software/components/grafite_parser/grafiteParser.ml index 5a22a4b62..b1362b0f6 100644 --- a/helm/software/components/grafite_parser/grafiteParser.ml +++ b/helm/software/components/grafite_parser/grafiteParser.ml @@ -39,20 +39,22 @@ type 'a localized_option = type ast_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 -> LE.status -> - LE.status * ast_statement localized_option +type 'status statement = + ?never_include:bool -> + (* do not call LexiconEngine to do includes, always raise NoInclusionPerformed *) + include_paths:string list -> (#LE.status as 'status) -> + 'status * ast_statement localized_option -type parser_status = { +type 'status parser_status = { grammar : Grammar.g; term : N.term Grammar.Entry.e; - statement : statement Grammar.Entry.e; + statement : #LE.status as 'status statement Grammar.Entry.e; } -let grafite_callback = ref (fun _ _ -> ()) +let grafite_callback = ref (fun _ -> ()) let set_grafite_callback cb = grafite_callback := cb -let lexicon_callback = ref (fun _ _ -> ()) +let lexicon_callback = ref (fun _ -> ()) let set_lexicon_callback cb = lexicon_callback := cb let initial_parser () = @@ -68,7 +70,7 @@ let add_raw_attribute ~text t = N.AttributedTerm (`Raw text, t) let default_associativity = Gramext.NonA -let mk_rec_corec ng ind_kind defs loc = +let mk_rec_corec ind_kind defs loc = (* In case of mutual definitions here we produce just the syntax tree for the first one. The others will be generated from the completely specified term just before @@ -76,15 +78,14 @@ let mk_rec_corec ng ind_kind defs loc = `MutualDefinition to rememer this. *) let name,ty = match defs with - | (params,(N.Ident (name, None), Some ty),_,_) :: _ -> + | (params,(N.Ident (name, None), ty),_,_) :: _ -> + let ty = match ty with Some ty -> ty | None -> N.Implicit `JustOne in let ty = List.fold_right (fun var ty -> N.Binder (`Pi,var,ty) ) params ty in name,ty - | (_,(N.Ident (name, None), None),_,_) :: _ -> - name, N.Implicit | _ -> assert false in let body = N.Ident (name,None) in @@ -94,12 +95,44 @@ let mk_rec_corec ng ind_kind defs loc = else `MutualDefinition in - if ng then - G.NObj (loc, N.Theorem(flavour, name, ty, - Some (N.LetRec (ind_kind, defs, body)))) - else - G.Obj (loc, N.Theorem(flavour, name, ty, - Some (N.LetRec (ind_kind, defs, body)))) + (loc, N.Theorem(flavour, name, ty, Some (N.LetRec (ind_kind, defs, body)), `Regular)) + +let nmk_rec_corec ind_kind defs loc = + let loc,t = mk_rec_corec ind_kind defs loc in + G.NObj (loc,t) + +let mk_rec_corec ind_kind defs loc = + let loc,t = mk_rec_corec ind_kind defs loc in + G.Obj (loc,t) + +let npunct_of_punct = function + | G.Branch loc -> G.NBranch loc + | G.Shift loc -> G.NShift loc + | G.Pos (loc, i) -> G.NPos (loc, i) + | G.Wildcard loc -> G.NWildcard loc + | G.Merge loc -> G.NMerge loc + | G.Semicolon loc -> G.NSemicolon loc + | G.Dot loc -> G.NDot loc +;; +let nnon_punct_of_punct = function + | G.Skip loc -> G.NSkip loc + | G.Unfocus loc -> G.NUnfocus loc + | G.Focus (loc,l) -> G.NFocus (loc,l) +;; +let npunct_of_punct = function + | G.Branch loc -> G.NBranch loc + | G.Shift loc -> G.NShift loc + | G.Pos (loc, i) -> G.NPos (loc, i) + | G.Wildcard loc -> G.NWildcard loc + | G.Merge loc -> G.NMerge loc + | G.Semicolon loc -> G.NSemicolon loc + | G.Dot loc -> G.NDot loc +;; +let cons_ntac t p = + match t with + | G.NTactic(loc,[t]) -> G.NTactic(loc,[t;p]) + | x -> x +;; type by_continuation = BYC_done @@ -118,10 +151,11 @@ EXTEND constructor: [ [ name = IDENT; SYMBOL ":"; typ = term -> (name, typ) ] ]; tactic_term: [ [ t = term LEVEL "90" -> t ] ]; new_name: [ - [ id = IDENT -> Some id - | SYMBOL "_" -> None ] + [ SYMBOL "_" -> None + | id = IDENT -> Some id ] ]; ident_list0: [ [ LPAREN; idents = LIST0 new_name; RPAREN -> idents ] ]; + ident_list1: [ [ LPAREN; idents = LIST1 IDENT; RPAREN -> idents ] ]; tactic_term_list1: [ [ tactic_terms = LIST1 tactic_term SEP SYMBOL "," -> tactic_terms ] ]; @@ -131,6 +165,15 @@ EXTEND | IDENT "unfold"; t = OPT tactic_term -> `Unfold t | IDENT "whd" -> `Whd ] ]; + nreduction_kind: [ + [ IDENT "nnormalize" ; delta = OPT [ IDENT "nodelta" -> () ] -> + let delta = match delta with None -> true | _ -> false in + `Normalize delta + (*| IDENT "unfold"; t = OPT tactic_term -> `Unfold t*) + | IDENT "nwhd" ; delta = OPT [ IDENT "nodelta" -> () ] -> + let delta = match delta with None -> true | _ -> false in + `Whd delta] + ]; sequent_pattern_spec: [ [ hyp_paths = LIST0 @@ -172,11 +215,11 @@ EXTEND let deannotate = function | N.AttributedTerm (_,t) | t -> t in match deannotate params with - | N.Implicit -> [false] + | N.Implicit _ -> [false] | N.UserInput -> [true] | N.Appl l -> List.map (fun x -> match deannotate x with - | N.Implicit -> false + | 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)) ] @@ -200,7 +243,8 @@ EXTEND ]; using: [ [ using = OPT [ IDENT "using"; t = tactic_term -> t ] -> using ] ]; ntactic: [ - [ IDENT "napply"; t = tactic_term -> G.NApply (loc, t) + [ IDENT "napply"; t = tactic_term -> G.NTactic(loc,[G.NApply (loc, t)]) + | IDENT "napplyS"; t = tactic_term -> G.NTactic(loc,[G.NSmartApply(loc, t)]) | IDENT "nassert"; seqs = LIST0 [ hyps = LIST0 @@ -210,29 +254,76 @@ EXTEND id,`Def (bo,ty)]; SYMBOL <:unicode>; concl = tactic_term -> (List.rev hyps,concl) ] -> - G.NAssert (loc, seqs) + G.NTactic(loc,[G.NAssert (loc, seqs)]) + | IDENT "nauto"; params = auto_params -> + G.NTactic(loc,[G.NAuto (loc, params)]) + | SYMBOL "/"; num = OPT NUMBER ; + params = nauto_params; SYMBOL "/" ; + just = OPT [ IDENT "by"; by = + [ univ = tactic_term_list1 -> `Univ univ + | SYMBOL "{"; SYMBOL "}" -> `EmptyUniv + | SYMBOL "_" -> `Trace ] -> by ] -> + let depth = match num with Some n -> n | None -> "1" in + (match just with + | None -> + G.NTactic(loc, + [G.NAuto(loc,(None,["slir","";"depth",depth]@params))]) + | Some (`Univ univ) -> + G.NTactic(loc, + [G.NAuto(loc,(Some univ,["slir","";"depth",depth]@params))]) + | Some `EmptyUniv -> + G.NTactic(loc, + [G.NAuto(loc,(Some [],["slir","";"depth",depth]@params))]) + | Some `Trace -> + G.NMacro(loc, + G.NAutoInteractive (loc, (None,["slir","";"depth",depth]@params)))) + | IDENT "nintros" -> G.NMacro (loc, G.NIntroGuess loc) + | IDENT "ncheck"; t = term -> G.NMacro(loc,G.NCheck (loc,t)) + | IDENT "screenshot"; fname = QSTRING -> + G.NMacro(loc,G.Screenshot (loc, fname)) | IDENT "ncases"; what = tactic_term ; where = pattern_spec -> - G.NCases (loc, what, where) + G.NTactic(loc,[G.NCases (loc, what, where)]) | IDENT "nchange"; what = pattern_spec; "with"; with_what = tactic_term -> - G.NChange (loc, what, with_what) + G.NTactic(loc,[G.NChange (loc, what, with_what)]) + | SYMBOL "@"; num = OPT NUMBER; l = LIST0 tactic_term -> + G.NTactic(loc,[G.NConstructor (loc, (match num with None -> None | Some x -> Some (int_of_string x)),l)]) + | IDENT "ncut"; t = tactic_term -> G.NTactic(loc,[G.NCut (loc, t)]) +(* | IDENT "ndiscriminate"; t = tactic_term -> G.NDiscriminate (loc, t) + | IDENT "nsubst"; t = tactic_term -> G.NSubst (loc, t) *) + | IDENT "ndestruct"; just = OPT [ dom = ident_list1 -> dom ]; + exclude = OPT [ IDENT "skip"; skip = ident_list1 -> skip ] + -> let exclude' = match exclude with None -> [] | Some l -> l in + G.NTactic(loc,[G.NDestruct (loc,just,exclude')]) | IDENT "nelim"; what = tactic_term ; where = pattern_spec -> - G.NElim (loc, what, where) + G.NTactic(loc,[G.NElim (loc, what, where)]) | IDENT "ngeneralize"; p=pattern_spec -> - G.NGeneralize (loc, p) + G.NTactic(loc,[G.NGeneralize (loc, p)]) + | IDENT "ninversion"; what = tactic_term ; where = pattern_spec -> + G.NTactic(loc,[G.NInversion (loc, what, where)]) + | IDENT "nlapply"; t = tactic_term -> G.NTactic(loc,[G.NLApply (loc, t)]) | IDENT "nletin"; name = IDENT ; SYMBOL <:unicode> ; t = tactic_term; where = pattern_spec -> - G.NLetIn (loc,where,t,name) - | IDENT "nrewrite"; dir = direction; what = tactic_term ; where = pattern_spec -> - G.NRewrite (loc, dir, what, where) - | IDENT "nwhd"; delta = OPT [ IDENT "nodelta" -> () ]; - where = pattern_spec -> - let delta = match delta with None -> true | _ -> false in - 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 -> - G.NCase1 (loc,n) + G.NTactic(loc,[G.NLetIn (loc,where,t,name)]) + | kind = nreduction_kind; p = pattern_spec -> + G.NTactic(loc,[G.NReduce (loc, kind, p)]) + | IDENT "nrewrite"; dir = direction; what = tactic_term ; where = pattern_spec -> + G.NTactic(loc,[G.NRewrite (loc, dir, what, where)]) + | IDENT "ntry"; tac = SELF -> + let tac = match tac with G.NTactic(_,[t]) -> t | _ -> assert false in + G.NTactic(loc,[ G.NTry (loc,tac)]) + | IDENT "nrepeat"; tac = SELF -> + let tac = match tac with G.NTactic(_,[t]) -> t | _ -> assert false in + G.NTactic(loc,[ G.NRepeat (loc,tac)]) + | LPAREN; l = LIST1 SELF; RPAREN -> + let l = + List.flatten + (List.map (function G.NTactic(_,t) -> t | _ -> assert false) l) in + G.NTactic(loc,[G.NBlock (loc,l)]) + | IDENT "nassumption" -> G.NTactic(loc,[ G.NAssumption loc]) + | SYMBOL "#"; ns=LIST0 IDENT -> G.NTactic(loc,[ G.NIntros (loc,ns)]) + | SYMBOL "#"; SYMBOL "_" -> G.NTactic(loc,[ G.NIntro (loc,"_")]) + | SYMBOL "*" -> G.NTactic(loc,[ G.NCase1 (loc,"_")]) + | SYMBOL "*"; n=IDENT -> G.NTactic(loc,[ G.NCase1 (loc,n)]) ] ]; tactic: [ @@ -368,7 +459,7 @@ EXTEND | "let" ; id1 = IDENT ; SYMBOL ":" ; t1 = tactic_term ; IDENT "such" ; IDENT "that" ; t2=tactic_term ; LPAREN ; id2 = IDENT ; RPAREN -> - G.ExistsElim (loc, `Auto ([],[]), id1, t1, id2, t2) + G.ExistsElim (loc, `Auto (None,[]), id1, t1, id2, t2) | just = [ IDENT "using"; t=tactic_term -> `Term t | params = auto_params -> `Auto params] ; @@ -430,6 +521,10 @@ EXTEND ]; auto_fixed_param: [ [ IDENT "paramodulation" + | IDENT "demod" + | IDENT "fast_paramod" + | IDENT "paramod" + | IDENT "slir" | IDENT "depth" | IDENT "width" | IDENT "size" @@ -440,15 +535,40 @@ EXTEND ] ]; auto_params: [ - [ params = + [ params = LIST0 [ i = auto_fixed_param -> i,"" | i = auto_fixed_param ; SYMBOL "="; v = [ v = int -> string_of_int v | v = IDENT -> v ] -> i,v ]; - tl = OPT [ IDENT "by"; tl = tactic_term_list1 -> tl] -> - (match tl with Some l -> l | None -> []), + tl = OPT [ IDENT "by"; tl = tactic_term_list1 -> tl] -> tl, + (* (match tl with Some l -> l | None -> []), *) params ] +]; + nauto_params: [ + [ params = + LIST0 [ + i = auto_fixed_param -> i,"" + | i = auto_fixed_param ; SYMBOL "="; v = [ v = int -> + string_of_int v | v = IDENT -> v ] -> i,v ] -> + params + ] +]; + + inline_params:[ + [ params = LIST0 + [ IDENT "prefix"; SYMBOL "="; prefix = QSTRING -> G.IPPrefix prefix + | flavour = inline_flavour -> G.IPAs flavour + | IDENT "coercions" -> G.IPCoercions + | IDENT "debug"; SYMBOL "="; debug = int -> G.IPDebug debug + | IDENT "procedural" -> G.IPProcedural + | IDENT "nodefaults" -> G.IPNoDefaults + | IDENT "depth"; SYMBOL "="; depth = int -> G.IPDepth depth + | IDENT "level"; SYMBOL "="; level = int -> G.IPLevel level + | IDENT "comments" -> G.IPComments + | IDENT "cr" -> G.IPCR + ] -> params + ] ]; by_continuation: [ [ WEPROVED; ty = tactic_term ; LPAREN ; id = IDENT ; RPAREN ; t1 = OPT [IDENT "that" ; IDENT "is" ; IDENT "equivalent" ; "to" ; t2 = tactic_term -> t2] -> BYC_weproved (ty,Some id,t1) @@ -500,6 +620,18 @@ EXTEND | tac = tactic -> tac ] ]; + npunctuation_tactical: + [ + [ SYMBOL "[" -> G.NBranch loc + | SYMBOL "|" -> G.NShift loc + | i = LIST1 int SEP SYMBOL ","; SYMBOL ":" -> G.NPos (loc, i) + | SYMBOL "*"; SYMBOL ":" -> G.NWildcard loc + | name = IDENT; SYMBOL ":" -> G.NPosbyname (loc, name) + | SYMBOL "]" -> G.NMerge loc + | SYMBOL ";" -> G.NSemicolon loc + | SYMBOL "." -> G.NDot loc + ] + ]; punctuation_tactical: [ [ SYMBOL "[" -> G.Branch loc @@ -537,7 +669,7 @@ EXTEND inline_flavour: [ [ attr = theorem_flavour -> attr | [ IDENT "axiom" ] -> `Axiom - | [ IDENT "mutual" ] -> `MutualDefinition + | [ IDENT "variant" ] -> `Variant ] ]; inductive_spec: [ [ @@ -586,22 +718,14 @@ EXTEND in (params,name,typ,fields) ] ]; - + macro: [ [ [ IDENT "check" ]; t = term -> G.Check (loc, t) | [ IDENT "eval" ]; kind = reduction_kind; "on"; t = tactic_term -> 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 -> G.Declarative - | Some depth -> G.Procedural depth - in - let prefix = match prefix with None -> "" | Some prefix -> prefix in - G.Inline (loc,style,suri,prefix, flavour) + | IDENT "inline"; suri = QSTRING; params = inline_params -> + G.Inline (loc, suri, params) | [ IDENT "hint" ]; rew = OPT (IDENT "rewrite") -> if rew = None then G.Hint (loc, false) else G.Hint (loc,true) | IDENT "auto"; params = auto_params -> @@ -654,7 +778,7 @@ EXTEND in L.Number_alias (instance, dsc) ] - ]; + ]; argument: [ [ l = LIST0 [ SYMBOL <:unicode> (* η *); SYMBOL "." -> () ]; id = IDENT -> @@ -699,8 +823,9 @@ EXTEND ]; level3_term: [ [ u = URI -> N.UriPattern (UriManager.uri_of_string u) + | r = NREF -> N.NRefPattern (NReference.reference_of_string r) + | IMPLICIT -> N.ImplicitPattern | id = IDENT -> N.VarPattern id - | SYMBOL "_" -> N.ImplicitPattern | LPAREN; terms = LIST1 SELF; RPAREN -> (match terms with | [] -> assert false @@ -716,51 +841,94 @@ EXTEND include_command: [ [ IDENT "include" ; path = QSTRING -> - loc,path,L.WithPreferences + loc,path,true,L.WithPreferences + | IDENT "include" ; IDENT "source" ; path = QSTRING -> + loc,path,false,L.WithPreferences | IDENT "include'" ; path = QSTRING -> - loc,path,L.WithoutPreferences + loc,path,true,L.WithoutPreferences ]]; + grafite_ncommand: [ [ + IDENT "nqed" -> G.NQed loc + | nflavour = ntheorem_flavour; name = IDENT; SYMBOL ":"; typ = term; + body = OPT [ SYMBOL <:unicode> (* ≝ *); body = term -> body ] -> + G.NObj (loc, N.Theorem (nflavour, name, typ, body,`Regular)) + | nflavour = ntheorem_flavour; name = IDENT; SYMBOL <:unicode> (* ≝ *); + body = term -> + G.NObj (loc, N.Theorem (nflavour, name, N.Implicit `JustOne, Some body,`Regular)) + | IDENT "naxiom"; name = IDENT; SYMBOL ":"; typ = term -> + G.NObj (loc, N.Theorem (`Axiom, name, typ, None, `Regular)) + | IDENT "ndiscriminator" ; indty = tactic_term -> G.NDiscriminator (loc,indty) + | IDENT "ninverter"; name = IDENT; IDENT "for" ; indty = tactic_term ; + paramspec = OPT inverter_param_list ; + outsort = OPT [ SYMBOL ":" ; outsort = term -> outsort ] -> + G.NInverter (loc,name,indty,paramspec,outsort) + | NLETCOREC ; defs = let_defs -> + nmk_rec_corec `CoInductive defs loc + | NLETREC ; defs = let_defs -> + nmk_rec_corec `Inductive defs loc + | IDENT "ninductive"; spec = inductive_spec -> + let (params, ind_types) = spec in + G.NObj (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 + G.NObj (loc, N.Inductive (params, ind_types)) + | IDENT "universe"; IDENT "constraint"; u1 = tactic_term; + SYMBOL <:unicode> ; u2 = tactic_term -> + let urify = function + | CicNotationPt.AttributedTerm (_, CicNotationPt.Sort (`NType i)) -> + NUri.uri_of_string ("cic:/matita/pts/Type"^i^".univ") + | _ -> raise (Failure "only a Type[…] sort can be constrained") + in + let u1 = urify u1 in + let u2 = urify u2 in + G.NUnivConstraint (loc,u1,u2) + | IDENT "unification"; IDENT "hint"; n = int; t = tactic_term -> + G.UnificationHint (loc, t, n) + | IDENT "ncoercion"; name = IDENT; SYMBOL ":"; ty = term; + SYMBOL <:unicode>; t = term; "on"; + id = [ IDENT | PIDENT ]; SYMBOL ":"; source = term; + "to"; target = term -> + G.NCoercion(loc,name,t,ty,(id,source),target) + | IDENT "nrecord" ; (params,name,ty,fields) = record_spec -> + G.NObj (loc, N.Record (params,name,ty,fields)) + | IDENT "ncopy" ; s = IDENT; IDENT "from"; u = URI; "with"; + m = LIST0 [ u1 = URI; SYMBOL <:unicode>; u2 = URI -> u1,u2 ] -> + G.NCopy (loc,s,NUri.uri_of_string u, + List.map (fun a,b -> NUri.uri_of_string a, NUri.uri_of_string b) m) + ]]; + grafite_command: [ [ IDENT "set"; n = QSTRING; v = QSTRING -> 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 -> 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 ] -> - G.NObj (loc, N.Theorem (nflavour, name, typ, body)) + (`Variant,name,typ,Some (N.Ident (newname, None)), `Regular)) | flavour = theorem_flavour; name = IDENT; SYMBOL ":"; typ = term; body = OPT [ SYMBOL <:unicode> (* ≝ *); body = term -> body ] -> - G.Obj (loc, N.Theorem (flavour, name, typ, body)) + G.Obj (loc, N.Theorem (flavour, name, typ, body,`Regular)) | flavour = theorem_flavour; name = IDENT; SYMBOL <:unicode> (* ≝ *); body = term -> G.Obj (loc, - N.Theorem (flavour, name, N.Implicit, Some body)) + N.Theorem (flavour, name, N.Implicit `JustOne, Some body,`Regular)) | IDENT "axiom"; name = IDENT; SYMBOL ":"; typ = term -> - G.Obj (loc, N.Theorem (`Axiom, name, typ, None)) - | IDENT "naxiom"; name = IDENT; SYMBOL ":"; typ = term -> - G.NObj (loc, N.Theorem (`Axiom, name, typ, None)) + G.Obj (loc, N.Theorem (`Axiom, name, typ, None, `Regular)) | LETCOREC ; defs = let_defs -> - mk_rec_corec false `CoInductive defs loc + mk_rec_corec `CoInductive defs loc | LETREC ; defs = let_defs -> - mk_rec_corec false `Inductive defs loc - | NLETCOREC ; defs = let_defs -> - mk_rec_corec true `CoInductive defs loc - | NLETREC ; defs = let_defs -> - mk_rec_corec true `Inductive defs loc + mk_rec_corec `Inductive defs loc | IDENT "inductive"; spec = inductive_spec -> let (params, ind_types) = spec in G.Obj (loc, N.Inductive (params, ind_types)) - | IDENT "ninductive"; spec = inductive_spec -> - let (params, ind_types) = spec in - 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) *) @@ -768,13 +936,6 @@ EXTEND ind_types in 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 - G.NObj (loc, N.Inductive (params, ind_types)) | IDENT "coercion" ; t = [ u = URI -> N.Uri (u,None) | t = tactic_term ; OPT "with" -> t ] ; arity = OPT int ; saturations = OPT int; @@ -788,16 +949,12 @@ EXTEND G.PreferCoercion (loc, t) | IDENT "pump" ; steps = int -> G.Pump(loc,steps) - | IDENT "unification"; IDENT "hint"; n = int; t = tactic_term -> - G.UnificationHint (loc, t, n) | IDENT "inverter"; name = IDENT; IDENT "for"; indty = tactic_term; paramspec = inverter_param_list -> G.Inverter (loc, name, indty, paramspec) | IDENT "record" ; (params,name,ty,fields) = record_spec -> G.Obj (loc, N.Record (params,name,ty,fields)) - | IDENT "nrecord" ; (params,name,ty,fields) = record_spec -> - G.NObj (loc, N.Record (params,name,ty,fields)) | IDENT "default" ; what = QSTRING ; uris = LIST1 URI -> let uris = List.map UriManager.uri_of_string uris in G.Default (loc,what,uris) @@ -822,15 +979,27 @@ EXTEND ]]; executable: [ [ cmd = grafite_command; SYMBOL "." -> G.Command (loc, cmd) + | ncmd = grafite_ncommand; SYMBOL "." -> G.NCommand (loc, ncmd) | tac = atomic_tactical LEVEL "loops"; punct = punctuation_tactical -> G.Tactic (loc, Some tac, punct) | punct = punctuation_tactical -> G.Tactic (loc, None, punct) + | tac = ntactic; OPT [ SYMBOL "#" ; SYMBOL "#" ] ; + punct = punctuation_tactical -> + cons_ntac tac (npunct_of_punct punct) +(* | tac = ntactic; punct = punctuation_tactical -> - G.NTactic (loc, tac, punct) - | SYMBOL "#" ; SYMBOL "#" ; punct = punctuation_tactical -> - G.NTactic (loc, G.NId loc, punct) + cons_ntac tac (npunct_of_punct punct) +*) + | SYMBOL "#" ; SYMBOL "#" ; punct = npunctuation_tactical -> + G.NTactic (loc, [punct]) | tac = non_punctuation_tactical; punct = punctuation_tactical -> G.NonPunctuationTactical (loc, tac, punct) + | SYMBOL "#" ; SYMBOL "#" ; tac = non_punctuation_tactical; + SYMBOL "#" ; SYMBOL "#" ; punct = punctuation_tactical -> + G.NTactic (loc, [nnon_punct_of_punct tac; npunct_of_punct punct]) + | SYMBOL "#" ; SYMBOL "#" ; tac = non_punctuation_tactical; + punct = punctuation_tactical -> + G.NTactic (loc, [nnon_punct_of_punct tac; npunct_of_punct punct]) | mac = macro; SYMBOL "." -> G.Macro (loc, mac) ] ]; @@ -845,33 +1014,35 @@ EXTEND [ ex = executable -> fun ?(never_include=false) ~include_paths status -> let stm = G.Executable (loc, ex) in - !grafite_callback status stm; + !grafite_callback stm; status, LSome stm | com = comment -> fun ?(never_include=false) ~include_paths status -> let stm = G.Comment (loc, com) in - !grafite_callback status stm; + !grafite_callback stm; status, LSome stm - | (iloc,fname,mode) = include_command ; SYMBOL "." -> + | (iloc,fname,normal,mode) = include_command ; SYMBOL "." -> fun ?(never_include=false) ~include_paths status -> + let _root, buri, fullpath, _rrelpath = + Librarian.baseuri_of_script ~include_paths fname in + if never_include then raise (NoInclusionPerformed fullpath) + else + begin 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 + G.Executable + (loc, G.Command (loc, G.Include (iloc,normal,`OldAndNew,fname))) in + !grafite_callback stm; + let status = + LE.eval_command status (L.Include (iloc,buri,mode,fullpath)) in let stm = - G.Executable (loc, G.Command (loc, G.Include (iloc, buri))) + G.Executable + (loc,G.Command (loc,G.Include (iloc,normal,`OldAndNew,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 + status, LSome stm + end | scom = lexicon_command ; SYMBOL "." -> fun ?(never_include=false) ~include_paths status -> - !lexicon_callback status scom; + !lexicon_callback scom; let status = LE.eval_command status scom in status, LNone loc | EOI -> raise End_of_file @@ -887,21 +1058,21 @@ let exc_located_wrapper f = try f () with - | Stdpp.Exc_located (_, End_of_file) -> raise End_of_file - | Stdpp.Exc_located (floc, Stream.Error msg) -> + | Ploc.Exc (_, End_of_file) -> raise End_of_file + | Ploc.Exc (floc, Stream.Error msg) -> raise (HExtlib.Localized (floc,CicNotationParser.Parse_error msg)) - | Stdpp.Exc_located (floc, HExtlib.Localized(_,exn)) -> + | Ploc.Exc (floc, HExtlib.Localized(_,exn)) -> raise (HExtlib.Localized (floc,CicNotationParser.Parse_error (Printexc.to_string exn))) - | Stdpp.Exc_located (floc, exn) -> + | Ploc.Exc (floc, exn) -> raise (HExtlib.Localized (floc,CicNotationParser.Parse_error (Printexc.to_string exn))) let parse_statement lexbuf = exc_located_wrapper - (fun () -> (Grammar.Entry.parse !grafite_parser.statement (Obj.magic lexbuf))) + (fun () -> (Grammar.Entry.parse (Obj.magic !grafite_parser.statement) (Obj.magic lexbuf))) -let statement () = !grafite_parser.statement +let statement () = Obj.magic !grafite_parser.statement let history = ref [] ;;