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 () =
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
`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
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
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 ]
];
| 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
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)) ]
];
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
id,`Def (bo,ty)];
SYMBOL <:unicode<vdash>>;
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<def>> ; 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: [
| "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] ;
];
auto_fixed_param: [
[ IDENT "paramodulation"
+ | IDENT "demod"
+ | IDENT "fast_paramod"
+ | IDENT "paramod"
+ | IDENT "slir"
| IDENT "depth"
| IDENT "width"
| IDENT "size"
]
];
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)
| 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
inline_flavour: [
[ attr = theorem_flavour -> attr
| [ IDENT "axiom" ] -> `Axiom
- | [ IDENT "mutual" ] -> `MutualDefinition
+ | [ IDENT "variant" ] -> `Variant
]
];
inductive_spec: [ [
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 ->
in
L.Number_alias (instance, dsc)
]
- ];
+ ];
argument: [
[ l = LIST0 [ SYMBOL <:unicode<eta>> (* η *); SYMBOL "." -> () ];
id = IDENT ->
];
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
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<def>> (* ≝ *); body = term -> body ] ->
+ G.NObj (loc, N.Theorem (nflavour, name, typ, body,`Regular))
+ | nflavour = ntheorem_flavour; name = IDENT; SYMBOL <:unicode<def>> (* ≝ *);
+ 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<lt>> ; 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<def>>; 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<mapsto>>; 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<def>> ; 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<def>> (* ≝ *); 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<def>> (* ≝ *); 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<def>> (* ≝ *);
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) *)
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;
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 ->
+ | IDENT "record" ; (params,name,ty,fields) = record_spec ->
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
]];
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)
]
];
[ 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
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 [] ;;