X-Git-Url: http://matita.cs.unibo.it/gitweb/?a=blobdiff_plain;f=matita%2Fcomponents%2Fgrafite_parser%2FgrafiteParser.ml;h=aeb0080c4fa163023069d8d2e681fffccf46933c;hb=7f72de8dea7fc5b9472ba63fb020419efd7cd183;hp=110c9e912c6b5946ddd603ae20b3a3859a3e3812;hpb=0d2bfb98d8343b4e6cefdb506a813b7cb5749630;p=helm.git diff --git a/matita/components/grafite_parser/grafiteParser.ml b/matita/components/grafite_parser/grafiteParser.ml index 110c9e912..aeb0080c4 100644 --- a/matita/components/grafite_parser/grafiteParser.ml +++ b/matita/components/grafite_parser/grafiteParser.ml @@ -27,43 +27,32 @@ module N = NotationPt module G = GrafiteAst -module L = LexiconAst -module LE = LexiconEngine -exception NoInclusionPerformed of string (* full path *) - -type 'a localized_option = - LSome of 'a - | LNone of G.loc - -type ast_statement = G.statement - -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 'status parser_status = { - grammar : Grammar.g; - term : N.term Grammar.Entry.e; - statement : #LE.status as 'status statement Grammar.Entry.e; -} +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) -> + raise (HExtlib.Localized (floc,CicNotationParser.Parse_error msg)) + | Stdpp.Exc_located (floc, HExtlib.Localized(_,exn)) -> + raise (HExtlib.Localized + (floc,CicNotationParser.Parse_error (Printexc.to_string exn))) + | Stdpp.Exc_located (floc, exn) -> + raise (HExtlib.Localized + (floc,CicNotationParser.Parse_error (Printexc.to_string exn))) -let grafite_callback = ref (fun _ -> ()) -let set_grafite_callback cb = grafite_callback := cb +type parsable = Grammar.parsable * Ulexing.lexbuf -let lexicon_callback = ref (fun _ -> ()) -let set_lexicon_callback cb = lexicon_callback := cb +let parsable_statement status buf = + let grammar = CicNotationParser.level2_ast_grammar status in + Grammar.parsable grammar (Obj.magic buf), buf -let initial_parser () = - let grammar = CicNotationParser.level2_ast_grammar () in - let term = CicNotationParser.term () in - let statement = Grammar.Entry.create grammar "statement" in - { grammar = grammar; term = term; statement = statement } -;; +let parse_statement grafite_parser parsable = + exc_located_wrapper + (fun () -> (Grammar.Entry.parse_parsable (Obj.magic grafite_parser) (fst parsable))) -let grafite_parser = ref (initial_parser ()) +let strm_of_parsable (_,buf) = buf let add_raw_attribute ~text t = N.AttributedTerm (`Raw text, t) @@ -102,31 +91,26 @@ type by_continuation = | BYC_letsuchthat of string * N.term * string * N.term | BYC_wehaveand of string * N.term * string * N.term -let initialize_parser () = +let mk_parser statement lstatus = +(* let grammar = CicNotationParser.level2_ast_grammar lstatus in *) + let term = CicNotationParser.term lstatus in + let let_defs = CicNotationParser.let_defs lstatus in + let protected_binder_vars = CicNotationParser.protected_binder_vars lstatus in (* {{{ parser initialization *) - let term = !grafite_parser.term in - let statement = !grafite_parser.statement in - let let_defs = CicNotationParser.let_defs () in - let protected_binder_vars = CicNotationParser.protected_binder_vars () in EXTEND GLOBAL: term statement; constructor: [ [ name = IDENT; SYMBOL ":"; typ = term -> (name, typ) ] ]; tactic_term: [ [ t = term LEVEL "90" -> t ] ]; +(* MATITA 1.0 new_name: [ [ 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 ] ]; - reduction_kind: [ - [ IDENT "normalize" -> `Normalize - | IDENT "simplify" -> `Simpl - | IDENT "unfold"; t = OPT tactic_term -> `Unfold t - | IDENT "whd" -> `Whd ] - ]; nreduction_kind: [ [ IDENT "normalize" ; delta = OPT [ IDENT "nodelta" -> () ] -> let delta = match delta with None -> true | _ -> false in @@ -184,18 +168,17 @@ EXTEND | 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 | SYMBOL "<" -> `RightToLeft ] ]; int: [ [ num = NUMBER -> int_of_string num ] ]; - intros_names: [ - [ idents = OPT ident_list0 -> - match idents with None -> [] | Some idents -> idents - ] - ]; +(* MATITA 1.0 intros_spec: [ [ OPT [ IDENT "names" ]; num = OPT [ num = int -> num ]; @@ -203,7 +186,8 @@ EXTEND num, idents ] ]; - using: [ [ using = OPT [ IDENT "using"; t = tactic_term -> t ] -> using ] ]; +*) +(* MATITA 1.0 using: [ [ using = OPT [ IDENT "using"; t = tactic_term -> t ] -> using ] ]; *) ntactic: [ [ SYMBOL "@"; t = tactic_term -> G.NTactic(loc,[G.NApply (loc, t)]) | IDENT "apply"; t = tactic_term -> G.NTactic(loc,[G.NApply (loc, t)]) @@ -218,28 +202,25 @@ EXTEND SYMBOL <:unicode>; concl = tactic_term -> (List.rev hyps,concl) ] -> G.NTactic(loc,[G.NAssert (loc, seqs)]) - | IDENT "auto"; params = auto_params -> - G.NTactic(loc,[G.NAuto (loc, params)]) + (*| IDENT "auto"; 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 ] -> + just_and_params = auto_params; SYMBOL "/" -> + let just,params = just_and_params in 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))]) + G.NTactic(loc, + [G.NAuto(loc,(None,["depth",depth]@params))]) | Some (`Univ univ) -> - G.NTactic(loc, - [G.NAuto(loc,(Some univ,["slir","";"depth",depth]@params))]) + G.NTactic(loc, + [G.NAuto(loc,(Some univ,["depth",depth]@params))]) | Some `EmptyUniv -> - G.NTactic(loc, - [G.NAuto(loc,(Some [],["slir","";"depth",depth]@params))]) + G.NTactic(loc, + [G.NAuto(loc,(Some [],["depth",depth]@params))]) | Some `Trace -> - G.NMacro(loc, - G.NAutoInteractive (loc, (None,["slir","";"depth",depth]@params)))) + G.NMacro(loc, + G.NAutoInteractive (loc, (None,["depth",depth]@params)))) | IDENT "intros" -> G.NMacro (loc, G.NIntroGuess loc) | IDENT "check"; t = term -> G.NMacro(loc,G.NCheck (loc,t)) | IDENT "screenshot"; fname = QSTRING -> @@ -248,8 +229,11 @@ EXTEND 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) *) @@ -310,21 +294,14 @@ EXTEND 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 -> []), *) - 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 + just = OPT [ IDENT "by"; by = + [ univ = tactic_term_list1 -> `Univ univ + | SYMBOL "{"; SYMBOL "}" -> `EmptyUniv + | SYMBOL "_" -> `Trace ] -> by ] -> just,params ] ]; +(* MATITA 1.0 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) | WEPROVED; ty = tactic_term ; t1 = OPT [IDENT "that" ; IDENT "is" ; IDENT "equivalent" ; "to" ; t2 = tactic_term -> t2] ; @@ -337,11 +314,14 @@ EXTEND BYC_wehaveand (id1,t1,id2,t2) ] ]; +*) +(* MATITA 1.0 rewriting_step_continuation : [ [ "done" -> true | -> false ] ]; +*) (* MATITA 1.0 atomic_tactical: [ "sequence" LEFTA @@ -461,12 +441,10 @@ EXTEND let ident = "\\("^alpha^ident_cont^"*"^decoration^"*\\|_"^ident_cont^"+"^decoration^"*\\)" in let rex = Str.regexp ("^"^ident^"$") in if Str.string_match rex id 0 then - if (try ignore (UriManager.uri_of_string uri); true - with UriManager.IllFormedUri _ -> false) || - (try ignore (NReference.reference_of_string uri); true + if (try ignore (NReference.reference_of_string uri); true with NReference.IllFormedReference _ -> false) then - L.Ident_alias (id, uri) + G.Ident_alias (id, uri) else raise (HExtlib.Localized (loc, CicNotationParser.Parse_error (Printf.sprintf "Not a valid uri: %s" uri))) @@ -479,14 +457,14 @@ EXTEND let instance = match instance with Some i -> i | None -> 0 in - L.Symbol_alias (symbol, instance, dsc) + G.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 - L.Number_alias (instance, dsc) + G.Number_alias (instance, dsc) ] ]; argument: [ @@ -511,11 +489,11 @@ EXTEND p2 = [ blob = UNPARSED_AST -> add_raw_attribute ~text:(Printf.sprintf "@{%s}" blob) - (CicNotationParser.parse_level2_ast + (CicNotationParser.parse_level2_ast lstatus (Ulexing.from_utf8_string blob)) | blob = UNPARSED_META -> add_raw_attribute ~text:(Printf.sprintf "${%s}" blob) - (CicNotationParser.parse_level2_meta + (CicNotationParser.parse_level2_meta lstatus (Ulexing.from_utf8_string blob)) ] -> let assoc = @@ -525,15 +503,14 @@ EXTEND in let p1 = add_raw_attribute ~text:s - (CicNotationParser.parse_level1_pattern prec + (CicNotationParser.parse_level1_pattern lstatus prec (Ulexing.from_utf8_string s)) in (dir, p1, assoc, prec, p2) ] ]; level3_term: [ - [ u = URI -> N.UriPattern (UriManager.uri_of_string u) - | r = NREF -> N.NRefPattern (NReference.reference_of_string r) + [ r = NREF -> N.NRefPattern (NReference.reference_of_string r) | IMPLICIT -> N.ImplicitPattern | id = IDENT -> N.VarPattern id | LPAREN; terms = LIST1 SELF; RPAREN -> @@ -551,11 +528,11 @@ EXTEND include_command: [ [ IDENT "include" ; path = QSTRING -> - loc,path,true,L.WithPreferences - | IDENT "include" ; IDENT "source" ; path = QSTRING -> - loc,path,false,L.WithPreferences + loc,path,G.WithPreferences + | IDENT "include" ; IDENT "alias"; path = QSTRING -> + loc,path,G.OnlyPreferences | IDENT "include'" ; path = QSTRING -> - loc,path,true,L.WithoutPreferences + loc,path,G.WithoutPreferences ]]; grafite_ncommand: [ [ @@ -573,9 +550,9 @@ EXTEND 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 @@ -610,16 +587,17 @@ EXTEND 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) + | lc = lexicon_command -> lc ]]; lexicon_command: [ [ IDENT "alias" ; spec = alias_spec -> - L.Alias (loc, spec) + G.Alias (loc, spec) | IDENT "notation"; (dir, l1, assoc, prec, l2) = notation -> - L.Notation (loc, dir, l1, assoc, prec, l2) + G.Notation (loc, dir, l1, assoc, prec, l2) | IDENT "interpretation"; id = QSTRING; (symbol, args, l3) = interpretation -> - L.Interpretation (loc, id, (symbol, args), l3) + G.Interpretation (loc, id, (symbol, args), l3) ]]; executable: [ [ ncmd = grafite_ncommand; SYMBOL "." -> G.NCommand (loc, ncmd) @@ -643,87 +621,49 @@ EXTEND ] ]; statement: [ - [ ex = executable -> - fun ?(never_include=false) ~include_paths status -> - let stm = G.Executable (loc, ex) in - !grafite_callback stm; - status, LSome stm - | com = comment -> - fun ?(never_include=false) ~include_paths status -> - let stm = G.Comment (loc, com) in - !grafite_callback stm; - status, LSome stm - | (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 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))) - in - status, LSome stm - end - | scom = lexicon_command ; SYMBOL "." -> - fun ?(never_include=false) ~include_paths status -> - !lexicon_callback scom; - let status = LE.eval_command status scom in - status, LNone loc + [ ex = executable -> G.Executable (loc, ex) + | com = comment -> G.Comment (loc, com) + | (iloc,fname,mode) = include_command ; SYMBOL "." -> + G.Executable (loc,G.NCommand (loc,G.Include (iloc,mode,fname))) | EOI -> raise End_of_file ] ]; -END + END; (* }}} *) + statement ;; -let _ = initialize_parser () ;; - -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) -> - raise (HExtlib.Localized (floc,CicNotationParser.Parse_error msg)) - | Stdpp.Exc_located (floc, HExtlib.Localized(_,exn)) -> - raise - (HExtlib.Localized (floc,CicNotationParser.Parse_error (Printexc.to_string exn))) - | Stdpp.Exc_located (floc, exn) -> - raise - (HExtlib.Localized (floc,CicNotationParser.Parse_error (Printexc.to_string exn))) - -let parse_statement lexbuf = - exc_located_wrapper - (fun () -> (Grammar.Entry.parse (Obj.magic !grafite_parser.statement) (Obj.magic lexbuf))) - -let statement () = Obj.magic !grafite_parser.statement +type db = GrafiteAst.statement Grammar.Entry.e ;; -let history = ref [] ;; +class type g_status = + object + inherit CicNotationParser.g_status + method parser_db: db + end -let push () = - LexiconSync.push (); - history := !grafite_parser :: !history; - grafite_parser := initial_parser (); - initialize_parser () -;; +class virtual status = + object(self) + 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_notation_parser_status o + initializer + let grammar = CicNotationParser.level2_ast_grammar self in + db <- Some (mk_parser (Grammar.Entry.create grammar "statement") self) + end -let pop () = - LexiconSync.pop (); - match !history with - | [] -> assert false - | gp :: tail -> - grafite_parser := gp; - history := tail +let extend status l1 action = + let status = CicNotationParser.extend status l1 action in + let grammar = CicNotationParser.level2_ast_grammar status in + status#set_parser_db + (mk_parser (Grammar.Entry.create grammar "statement") status) ;; -(* vim:set foldmethod=marker: *) +let parse_statement status = + parse_statement status#parser_db +(* vim:set foldmethod=marker: *)