| 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
| 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 ]
];
];
using: [ [ using = OPT [ IDENT "using"; t = tactic_term -> t ] -> using ] ];
ntactic: [
- [ 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 "napply"; t = tactic_term -> G.NApply (loc, t)
| IDENT "nassert";
seqs = LIST0 [
hyps = LIST0
id,`Def (bo,ty)];
SYMBOL <:unicode<vdash>>;
concl = tactic_term -> (List.rev hyps,concl) ] ->
- 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))
+ G.NAssert (loc, seqs)
+ | IDENT "nauto"; params = auto_params -> G.NAuto (loc, params)
| IDENT "ncases"; what = tactic_term ; where = pattern_spec ->
- G.NTactic(loc,[G.NCases (loc, what, where)])
+ G.NCases (loc, what, where)
| IDENT "nchange"; what = pattern_spec; "with"; with_what = tactic_term ->
- G.NTactic(loc,[G.NChange (loc, what, with_what)])
+ 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)])
+ G.NConstructor (loc,
+ (match num with None -> None | Some x -> Some (int_of_string x)),l)
+ | IDENT "ncut"; t = tactic_term -> 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 "ndestruct" -> G.NDestruct loc
| IDENT "nelim"; what = tactic_term ; where = pattern_spec ->
- G.NTactic(loc,[G.NElim (loc, what, where)])
+ G.NElim (loc, what, where)
| IDENT "ngeneralize"; p=pattern_spec ->
- 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)])
+ G.NGeneralize (loc, p)
+ | IDENT "nlapply"; t = tactic_term -> G.NLApply (loc, t)
| IDENT "nletin"; name = IDENT ; SYMBOL <:unicode<def>> ; t = tactic_term;
where = pattern_spec ->
- G.NTactic(loc,[G.NLetIn (loc,where,t,name)])
+ G.NLetIn (loc,where,t,name)
| kind = nreduction_kind; p = pattern_spec ->
- G.NTactic(loc,[G.NReduce (loc, kind, p)])
+ 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)])
+ G.NRewrite (loc, dir, what, where)
+ | IDENT "ntry"; tac = SELF -> G.NTry (loc,tac)
+ | IDENT "nrepeat"; tac = SELF -> G.NRepeat (loc,tac)
+ | LPAREN; l = LIST1 SELF; RPAREN -> G.NBlock (loc,l)
+ | IDENT "nassumption" -> G.NAssumption loc
+ | SYMBOL "#"; n=IDENT -> G.NIntro (loc,n)
+ | SYMBOL "#"; SYMBOL "_" -> G.NIntro (loc,"_")
+ | SYMBOL "*" -> G.NCase1 (loc,"_")
+ | SYMBOL "*"; n=IDENT ->
+ 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 (None,[]), 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] ;
];
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] -> tl,
- (* (match tl with Some l -> l | None -> []), *)
+ tl = OPT [ IDENT "by"; tl = tactic_term_list1 -> 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
(params,name,typ,fields)
] ];
+ nmacro: [
+ [ [ IDENT "ncheck" ]; t = term -> G.NCheck (loc,t)
+ | [ IDENT "screenshot"]; fname = QSTRING -> G.Screenshot (loc, fname)
+ ]
+ ];
+
macro: [
[ [ IDENT "check" ]; t = term ->
G.Check (loc, t)
| 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; SYMBOL "#" ; SYMBOL "#" ; punct = punctuation_tactical ->
+ G.NTactic (loc, [tac; npunct_of_punct punct])
| tac = ntactic; punct = punctuation_tactical ->
- cons_ntac tac (npunct_of_punct punct)
-*)
+ G.NTactic (loc, [tac; npunct_of_punct punct])
| SYMBOL "#" ; SYMBOL "#" ; punct = npunctuation_tactical ->
G.NTactic (loc, [punct])
| tac = non_punctuation_tactical; punct = punctuation_tactical ->
punct = punctuation_tactical ->
G.NTactic (loc, [nnon_punct_of_punct tac; npunct_of_punct punct])
| mac = macro; SYMBOL "." -> G.Macro (loc, mac)
+ | mac = nmacro; SYMBOL "." -> G.NMacro (loc, mac)
]
];
comment: [
projects / helm.git / blobdiff