X-Git-Url: http://matita.cs.unibo.it/gitweb/?a=blobdiff_plain;f=matita%2Fcomponents%2Fgrafite_parser%2FgrafiteParser.ml;h=9e1e54ee72ae481bb7722d3f7ba0744496249c23;hb=988cf01c5bd740d6e75767327f201a3c43d635ed;hp=29d52c01f2753ec1dda2cd4ed14e324b335855fb;hpb=f3f6b451707a3feb8245717e3fa7ca25df0ce8ef;p=helm.git diff --git a/matita/components/grafite_parser/grafiteParser.ml b/matita/components/grafite_parser/grafiteParser.ml index 29d52c01f..9e1e54ee7 100644 --- a/matita/components/grafite_parser/grafiteParser.ml +++ b/matita/components/grafite_parser/grafiteParser.ml @@ -27,16 +27,6 @@ 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 let exc_located_wrapper f = try @@ -52,9 +42,17 @@ let exc_located_wrapper f = 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) @@ -170,7 +168,10 @@ 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 @@ -228,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) *) @@ -440,7 +444,7 @@ EXTEND 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))) @@ -453,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: [ @@ -524,15 +528,17 @@ 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: [ [ - IDENT "qed" -> G.NQed loc + IDENT "qed" ; b = OPT SYMBOL "-" -> + let b = match b with None -> true | Some _ -> false in + G.NQed (loc,b) | 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)) @@ -546,9 +552,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 @@ -572,27 +578,31 @@ EXTEND 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>; 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"; 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) @@ -616,20 +626,10 @@ EXTEND ] ]; statement: [ - [ ex = executable -> - LSome (G.Executable (loc, ex)) - | com = comment -> - LSome (G.Comment (loc, com)) - | (iloc,fname,normal,mode) = include_command ; SYMBOL "." -> - LSome (G.Executable - (loc,G.Command (loc,G.Include (iloc,fname,(),"")))) - | scom = lexicon_command ; SYMBOL "." -> - assert false -(* - fun ?(never_include=false) ~include_paths status -> - 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 ] ]; @@ -638,28 +638,36 @@ EXTEND statement ;; -type db = ast_statement localized_option Grammar.Entry.e ;; +type db = GrafiteAst.statement Grammar.Entry.e ;; class type g_status = object - inherit LexiconEngine.g_status + inherit CicNotationParser.g_status method parser_db: db end -class status = - let lstatus = assert false in - let grammar = CicNotationParser.level2_ast_grammar lstatus in - object - inherit LexiconEngine.status - val db = - mk_parser (Grammar.Entry.create grammar "statement") lstatus - method parser_db = db - method set_parser_db v = {< db = v >} +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 = 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) end +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) +;; + + let parse_statement status = parse_statement status#parser_db