module N = NotationPt
module G = GrafiteAst
-module LE = LexiconEngine
-
-type 'a localized_option =
- LSome of 'a
- | LNone of G.loc
-
-type ast_statement = G.statement
let exc_located_wrapper f =
try
raise (HExtlib.Localized
(floc,CicNotationParser.Parse_error (Printexc.to_string exn)))
-let parse_statement grafite_parser lexbuf =
+type parsable = Grammar.parsable * Ulexing.lexbuf
+
+let parsable_statement status buf =
+ let grammar = CicNotationParser.level2_ast_grammar status in
+ Grammar.parsable grammar (Obj.magic buf), buf
+
+let parse_statement grafite_parser parsable =
exc_located_wrapper
- (fun () -> (Grammar.Entry.parse (Obj.magic grafite_parser) (Obj.magic lexbuf)))
+ (fun () -> (Grammar.Entry.parse_parsable (Obj.magic grafite_parser) (fst parsable)))
+
+let strm_of_parsable (_,buf) = buf
let add_raw_attribute ~text t = N.AttributedTerm (`Raw text, t)
| N.Implicit _ -> false
| N.UserInput -> true
| _ -> raise (Invalid_argument "malformed target parameter list 1")) l
- | _ -> raise (Invalid_argument ("malformed target parameter list 2\n" ^ NotationPp.pp_term params)) ]
+ | _ ->
+ (*CSC: new NCicPp.status is the best I can do here without changing the
+ result type *)
+ raise (Invalid_argument ("malformed target parameter list 2\n" ^ NotationPp.pp_term (new NCicPp.status) params)) ]
];
direction: [
[ SYMBOL ">" -> `LeftToRight
G.NTactic(loc,[G.NCases (loc, what, where)])
| IDENT "change"; what = pattern_spec; "with"; with_what = tactic_term ->
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)])
+ | SYMBOL "-"; ids = LIST1 IDENT ->
+ G.NTactic(loc,[G.NClear (loc, ids)])
+ | (*SYMBOL "^"*)PLACEHOLDER; num = OPT NUMBER;
+ l = OPT [ SYMBOL "{"; l = LIST1 tactic_term; SYMBOL "}" -> l ] ->
+ G.NTactic(loc,[G.NConstructor (loc, (match num with None -> None | Some x -> Some (int_of_string x)),match l with None -> [] | Some l -> l)])
| IDENT "cut"; t = tactic_term -> G.NTactic(loc,[G.NCut (loc, t)])
(* | IDENT "discriminate"; t = tactic_term -> G.NDiscriminate (loc, t)
| IDENT "subst"; t = tactic_term -> G.NSubst (loc, t) *)
include_command: [ [
IDENT "include" ; path = QSTRING ->
loc,path,G.WithPreferences
+ | IDENT "include" ; IDENT "alias"; path = QSTRING ->
+ loc,path,G.OnlyPreferences
| IDENT "include'" ; path = QSTRING ->
loc,path,G.WithoutPreferences
]];
grafite_ncommand: [ [
- IDENT "qed" -> G.NQed loc
+ IDENT "qed" ; b = OPT SYMBOL "-" ->
+ let b = match b with None -> true | Some _ -> false in
+ if not b then prerr_endline "Should not index";
+ G.NQed (loc,b)
| 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))
paramspec = OPT inverter_param_list ;
outsort = OPT [ SYMBOL ":" ; outsort = term -> outsort ] ->
G.NInverter (loc,name,indty,paramspec,outsort)
- | NLETCOREC ; defs = let_defs ->
+ | LETCOREC ; defs = let_defs ->
nmk_rec_corec `CoInductive defs loc
- | NLETREC ; defs = let_defs ->
+ | LETREC ; defs = let_defs ->
nmk_rec_corec `Inductive defs loc
| IDENT "inductive"; spec = inductive_spec ->
let (params, ind_types) = spec in
G.NUnivConstraint (loc,u1,u2)
| IDENT "unification"; IDENT "hint"; n = int; t = tactic_term ->
G.UnificationHint (loc, t, n)
- | IDENT "coercion"; name = IDENT; SYMBOL ":"; ty = term;
+ | IDENT "coercion"; name = IDENT;
+ compose = OPT [ IDENT "nocomposites" -> () ];
+ 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)
+ let compose = compose = None in
+ G.NCoercion(loc,name,compose,t,ty,(id,source),target)
| IDENT "record" ; (params,name,ty,fields) = record_spec ->
G.NObj (loc, N.Record (params,name,ty,fields))
| IDENT "copy" ; s = IDENT; IDENT "from"; u = URI; "with";
]
];
statement: [
- [ ex = executable ->
- LSome (G.Executable (loc, ex))
- | com = comment ->
- LSome (G.Comment (loc, com))
+ [ ex = executable -> G.Executable (loc, ex)
+ | com = comment -> G.Comment (loc, com)
| (iloc,fname,mode) = include_command ; SYMBOL "." ->
- LSome (G.Executable (loc,G.NCommand (loc,G.Include (iloc,mode,fname))))
+ G.Executable (loc,G.NCommand (loc,G.Include (iloc,mode,fname)))
| EOI -> raise End_of_file
]
];
statement
;;
-type db = ast_statement localized_option Grammar.Entry.e ;;
+type db = GrafiteAst.statement Grammar.Entry.e ;;
class type g_status =
object
- inherit LexiconTypes.g_status
+ inherit CicNotationParser.g_status
method parser_db: db
end
-class status =
+class virtual status =
object(self)
- inherit LexiconTypes.status as super
- val mutable db = None
+ inherit CicNotationParser.status ~keywords:[]
+ val mutable db = None (* mutable only to initialize it :-( *)
method parser_db = match db with None -> assert false | Some x -> x
method set_parser_db v = {< db = Some v >}
method set_parser_status
: 'status. #g_status as 'status -> 'self
- = fun o -> {< db = Some o#parser_db >}#set_lexicon_engine_status o
+ = fun o -> {< db = Some o#parser_db >}#set_notation_parser_status o
initializer
let grammar = CicNotationParser.level2_ast_grammar self in
db <- Some (mk_parser (Grammar.Entry.create grammar "statement") self)
projects / helm.git / blobdiff