X-Git-Url: http://matita.cs.unibo.it/gitweb/?a=blobdiff_plain;f=matita%2Fcomponents%2Fgrafite_parser%2FgrafiteParser.ml;h=be39556d8502fb59826083c753232a1e60148107;hb=f9abd21eb0d26cf9b632af4df819225be4d091e3;hp=9485190867edd74a55b8689049550f20424371aa;hpb=30bbfa78612ca1ad0c131a75d7075cfd35bebbe1;p=helm.git diff --git a/matita/components/grafite_parser/grafiteParser.ml b/matita/components/grafite_parser/grafiteParser.ml index 948519086..be39556d8 100644 --- a/matita/components/grafite_parser/grafiteParser.ml +++ b/matita/components/grafite_parser/grafiteParser.ml @@ -23,60 +23,55 @@ * http://helm.cs.unibo.it/ *) -(* $Id$ *) +(* $Id: grafiteParser.ml 13176 2016-04-18 15:29:33Z fguidi $ *) 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 f () with - | Stdpp.Exc_located (_, End_of_file) -> raise End_of_file - | Stdpp.Exc_located (floc, Stream.Error msg) -> + | Ploc.Exc (_, End_of_file) -> raise End_of_file + | Ploc.Exc (floc, Stream.Error msg) -> raise (HExtlib.Localized (floc,CicNotationParser.Parse_error msg)) - | Stdpp.Exc_located (floc, HExtlib.Localized(_,exn)) -> + | Ploc.Exc (floc, HExtlib.Localized(_,exn)) -> raise (HExtlib.Localized (floc,CicNotationParser.Parse_error (Printexc.to_string exn))) - | Stdpp.Exc_located (floc, exn) -> + | Ploc.Exc (floc, exn) -> 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 grafite_parser (fst parsable))) + +let strm_of_parsable (_,buf) = buf let add_raw_attribute ~text t = N.AttributedTerm (`Raw text, t) let default_associativity = Gramext.NonA -let mk_rec_corec ind_kind defs loc = - let name,ty = - match defs with - | (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 - | _ -> assert false - in - let body = N.Ident (name,None) in - (loc, N.Theorem(`Definition, name, ty, Some (N.LetRec (ind_kind, defs, body)), `Regular)) +let mk_rec_corec src flavour ind_kind defs loc = + let attrs = src, flavour, `Regular in + (loc, N.LetRec (ind_kind, defs, attrs)) -let nmk_rec_corec ind_kind defs loc = - let loc,t = mk_rec_corec ind_kind defs loc in - G.NObj (loc,t) +let nmk_rec_corec src flavour ind_kind defs loc index = + let loc,t = mk_rec_corec src flavour ind_kind defs loc in + G.NObj (loc,t,index) +let shift_vars binder (vars, ty) bo = + let map var bo = N.Binder (binder, (var, ty), bo) in + List.fold_right map vars bo + +let shift_params binder params bo = + List.fold_right (shift_vars binder) params bo (* let nnon_punct_of_punct = function | G.Skip loc -> G.NSkip loc @@ -94,27 +89,18 @@ 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 let_codefs = CicNotationParser.let_codefs lstatus in let protected_binder_vars = CicNotationParser.protected_binder_vars lstatus in (* {{{ parser initialization *) 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_list1: [ [ LPAREN; idents = LIST1 IDENT; RPAREN -> idents ] ]; - tactic_term_list1: [ - [ tactic_terms = LIST1 tactic_term SEP SYMBOL "," -> tactic_terms ] - ]; nreduction_kind: [ [ IDENT "normalize" ; delta = OPT [ IDENT "nodelta" -> () ] -> let delta = match delta with None -> true | _ -> false in `Normalize delta - (*| IDENT "unfold"; t = OPT tactic_term -> `Unfold t*) | IDENT "whd" ; delta = OPT [ IDENT "nodelta" -> () ] -> let delta = match delta with None -> true | _ -> false in `Whd delta] @@ -137,14 +123,15 @@ EXTEND ]; pattern_spec: [ [ res = OPT [ - "in"; + "in" ; wanted_and_sps = [ "match" ; wanted = tactic_term ; sps = OPT [ "in"; sps = sequent_pattern_spec -> sps ] -> Some wanted,sps | sps = sequent_pattern_spec -> None,Some sps - ] -> + ]; + SYMBOL ";" -> let wanted,hyp_paths,goal_path = match wanted_and_sps with wanted,None -> wanted, [], Some N.UserInput @@ -167,26 +154,18 @@ 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 ] ]; -(* MATITA 1.0 - intros_spec: [ - [ OPT [ IDENT "names" ]; - num = OPT [ num = int -> num ]; - idents = intros_names -> - num, idents - ] - ]; -*) -(* 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)]) | IDENT "applyS"; t = tactic_term -> G.NTactic(loc,[G.NSmartApply(loc, t)]) | IDENT "assert"; seqs = LIST0 [ @@ -198,8 +177,6 @@ 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)])*) | SYMBOL "/"; num = OPT NUMBER ; just_and_params = auto_params; SYMBOL "/" -> let just,params = just_and_params in @@ -211,25 +188,23 @@ EXTEND | Some (`Univ univ) -> G.NTactic(loc, [G.NAuto(loc,(Some univ,["depth",depth]@params))]) - | Some `EmptyUniv -> - G.NTactic(loc, - [G.NAuto(loc,(Some [],["depth",depth]@params))]) | Some `Trace -> 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)) + | SYMBOL "#"; SYMBOL "#" -> G.NMacro (loc, G.NIntroGuess loc) + | IDENT "check"; t = tactic_term -> G.NMacro(loc,G.NCheck (loc,t)) | IDENT "screenshot"; fname = QSTRING -> G.NMacro(loc,G.Screenshot (loc, fname)) | IDENT "cases"; what = tactic_term ; where = pattern_spec -> G.NTactic(loc,[G.NCases (loc, what, where)]) - | IDENT "change"; what = pattern_spec; "with"; with_what = tactic_term -> + | IDENT "change"; "with"; with_what = tactic_term; what = pattern_spec -> 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 "-"; id = IDENT -> + G.NTactic(loc,[G.NClear (loc, [id])]) + | 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) *) | IDENT "destruct"; just = OPT [ dom = ident_list1 -> dom ]; exclude = OPT [ IDENT "skip"; skip = ident_list1 -> skip ] -> let exclude' = match exclude with None -> [] | Some l -> l in @@ -248,8 +223,6 @@ EXTEND G.NTactic(loc,[G.NReduce (loc, kind, p)]) | dir = direction; what = tactic_term ; where = pattern_spec -> G.NTactic(loc,[G.NRewrite (loc, dir, what, where)]) - | IDENT "rewrite"; dir = direction; what = tactic_term ; where = pattern_spec -> - G.NTactic(loc,[G.NRewrite (loc, dir, what, where)]) | IDENT "try"; tac = SELF -> let tac = match tac with G.NTactic(_,[t]) -> t | _ -> assert false in G.NTactic(loc,[ G.NTry (loc,tac)]) @@ -265,20 +238,17 @@ EXTEND | SYMBOL "#"; ns=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)]) + | SYMBOL "*"; "as"; n=IDENT -> G.NTactic(loc,[ G.NCase1 (loc,n)]) ] ]; auto_fixed_param: [ [ IDENT "demod" | IDENT "fast_paramod" | IDENT "paramod" - | IDENT "depth" | IDENT "width" | IDENT "size" - | IDENT "timeout" - | IDENT "library" - | IDENT "type" - | IDENT "all" + | IDENT "nohyps" +(* | IDENT "timeout" *) ] ]; auto_params: [ @@ -288,8 +258,7 @@ EXTEND | i = auto_fixed_param ; SYMBOL "="; v = [ v = int -> string_of_int v | v = IDENT -> v ] -> i,v ]; just = OPT [ IDENT "by"; by = - [ univ = tactic_term_list1 -> `Univ univ - | SYMBOL "{"; SYMBOL "}" -> `EmptyUniv + [ univ = LIST0 tactic_term SEP SYMBOL "," -> `Univ univ | SYMBOL "_" -> `Trace ] -> by ] -> just,params ] ]; @@ -522,41 +491,76 @@ EXTEND 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 ]]; + index: [[ b = OPT SYMBOL "-" -> match b with None -> true | _ -> false ]]; + + source: [[ + src = OPT [ IDENT "implied" ] -> + match src with None -> `Provided | _ -> `Implied + ]]; + grafite_ncommand: [ [ - IDENT "qed" -> G.NQed loc - | nflavour = ntheorem_flavour; name = IDENT; SYMBOL ":"; typ = term; + lc = lexicon_command -> lc + | IDENT "qed" ; i = index -> G.NQed (loc,i) + | IDENT "defined" ; i = index -> G.NQed (loc,i) (* FG: presentational qed for definitions *) + | src = source; nflavour = ntheorem_flavour; name = IDENT; + params = LIST0 protected_binder_vars; SYMBOL ":"; typ = term; (* FG: params added *) body = OPT [ SYMBOL <:unicode> (* ≝ *); body = term -> body ] -> - G.NObj (loc, N.Theorem (nflavour, name, typ, body,`Regular)) - | nflavour = ntheorem_flavour; name = IDENT; SYMBOL <:unicode> (* ≝ *); + let typ = shift_params `Forall params typ in + let body = match body with + | Some bo -> Some (shift_params `Lambda params bo) + | None -> None + in + let attrs = src, nflavour, `Regular in + G.NObj (loc, N.Theorem (name, typ, body, attrs),true) + | src = source; nflavour = ntheorem_flavour; name = IDENT; + params = LIST0 protected_binder_vars; SYMBOL <:unicode> (* ≝ *); (* FG: params added *) body = term -> - G.NObj (loc, N.Theorem (nflavour, name, N.Implicit `JustOne, Some body,`Regular)) - | IDENT "axiom"; name = IDENT; SYMBOL ":"; typ = term -> - G.NObj (loc, N.Theorem (`Axiom, name, typ, None, `Regular)) - | IDENT "discriminator" ; indty = tactic_term -> G.NDiscriminator (loc,indty) - | IDENT "inverter"; 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 "inductive"; spec = inductive_spec -> + let body = shift_params `Lambda params body in + let attrs = src, nflavour, `Regular in + G.NObj (loc, + N.Theorem(name, N.Implicit `JustOne, Some body, attrs), + true) + | src = source; IDENT "axiom"; i = index; name = IDENT; + params = LIST0 protected_binder_vars; SYMBOL ":"; typ = term -> (* FG: params added *) + let typ = shift_params `Forall params typ in + let attrs = src, `Axiom, `Regular in + G.NObj (loc, N.Theorem (name, typ, None, attrs),i) + | src = source; IDENT "inductive"; spec = inductive_spec -> let (params, ind_types) = spec in - G.NObj (loc, N.Inductive (params, ind_types)) - | IDENT "coinductive"; spec = inductive_spec -> + G.NObj (loc, N.Inductive (params, ind_types, src),true) + | src = source; IDENT "coinductive"; 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; + G.NObj (loc, N.Inductive (params, ind_types, src),true) + | src = source; IDENT "record" ; (params,name,ty,fields) = record_spec -> + G.NObj (loc, N.Record (params,name,ty,fields,src),true) +(* FG: new syntax for inductive/coinductive definitions and statements *) + | src = source; IDENT "rec"; nflavour = ntheorem_flavour; defs = let_defs -> + nmk_rec_corec src nflavour `Inductive defs loc true + | src = source; IDENT "corec"; nflavour = ntheorem_flavour; defs = let_codefs -> + nmk_rec_corec src nflavour `CoInductive defs loc true +(**) + | LETCOREC ; defs = let_codefs -> + nmk_rec_corec `Provided `Definition `CoInductive defs loc true + | LETREC ; defs = let_defs -> + nmk_rec_corec `Provided `Definition `Inductive defs loc true + | IDENT "discriminator" ; indty = tactic_term -> G.NDiscriminator (loc,indty) + | IDENT "inverter"; 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) + | IDENT "universe"; cyclic = OPT [ IDENT "cyclic" -> () ] ; IDENT "constraint"; u1 = tactic_term; SYMBOL <:unicode> ; u2 = tactic_term -> + let acyclic = match cyclic with None -> true | Some () -> false in let urify = function | NotationPt.AttributedTerm (_, NotationPt.Sort (`NType i)) -> NUri.uri_of_string ("cic:/matita/pts/Type"^i^".univ") @@ -564,21 +568,21 @@ EXTEND in let u1 = urify u1 in let u2 = urify u2 in - G.NUnivConstraint (loc,u1,u2) + G.NUnivConstraint (loc,acyclic,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" -> () ]; + spec = OPT [ 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) - | IDENT "record" ; (params,name,ty,fields) = record_spec -> - G.NObj (loc, N.Record (params,name,ty,fields)) + "to"; target = term -> t,ty,(id,source),target ] -> + let compose = compose = None in + G.NCoercion(loc,name,compose,spec) | 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: [ [ @@ -612,12 +616,10 @@ EXTEND ] ]; 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 ] ]; @@ -626,23 +628,23 @@ EXTEND 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)