X-Git-Url: http://matita.cs.unibo.it/gitweb/?a=blobdiff_plain;f=helm%2Fsoftware%2Fcomponents%2Fgrafite_parser%2FgrafiteParser.ml;h=8a418200d94604127cd7aad3a000aafdca921417;hb=ddd6560f4e70ec3306d223738a441d5f1dd3eac9;hp=d0a97072c0d1c1c2b7a1ee366863e5992d80d93c;hpb=d17a38ddca548c784e9efa7c55e87c80203b024d;p=helm.git diff --git a/helm/software/components/grafite_parser/grafiteParser.ml b/helm/software/components/grafite_parser/grafiteParser.ml index d0a97072c..8a418200d 100644 --- a/helm/software/components/grafite_parser/grafiteParser.ml +++ b/helm/software/components/grafite_parser/grafiteParser.ml @@ -39,20 +39,22 @@ type 'a localized_option = type ast_statement = (N.term, N.term, N.term G.reduction, N.term N.obj, string) G.statement -type statement = - ?never_include:bool -> include_paths:string list -> LE.status -> - LE.status * ast_statement localized_option +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 parser_status = { +type 'status parser_status = { grammar : Grammar.g; term : N.term Grammar.Entry.e; - statement : statement Grammar.Entry.e; + statement : #LE.status as 'status statement Grammar.Entry.e; } -let grafite_callback = ref (fun _ _ -> ()) +let grafite_callback = ref (fun _ -> ()) let set_grafite_callback cb = grafite_callback := cb -let lexicon_callback = ref (fun _ _ -> ()) +let lexicon_callback = ref (fun _ -> ()) let set_lexicon_callback cb = lexicon_callback := cb let initial_parser () = @@ -68,7 +70,7 @@ let add_raw_attribute ~text t = N.AttributedTerm (`Raw text, t) let default_associativity = Gramext.NonA -let mk_rec_corec ng ind_kind defs loc = +let mk_rec_corec ind_kind defs loc = (* In case of mutual definitions here we produce just the syntax tree for the first one. The others will be generated from the completely specified term just before @@ -76,15 +78,14 @@ let mk_rec_corec ng ind_kind defs loc = `MutualDefinition to rememer this. *) let name,ty = match defs with - | (params,(N.Ident (name, None), Some ty),_,_) :: _ -> + | (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 - | (_,(N.Ident (name, None), None),_,_) :: _ -> - name, N.Implicit | _ -> assert false in let body = N.Ident (name,None) in @@ -94,12 +95,39 @@ let mk_rec_corec ng ind_kind defs loc = else `MutualDefinition in - if ng then - G.NObj (loc, N.Theorem(flavour, name, ty, - Some (N.LetRec (ind_kind, defs, body)))) - else - G.Obj (loc, N.Theorem(flavour, name, ty, - Some (N.LetRec (ind_kind, defs, body)))) + (loc, N.Theorem(flavour, name, ty, Some (N.LetRec (ind_kind, defs, body)))) + +let nmk_rec_corec ind_kind defs loc = + let loc,t = mk_rec_corec ind_kind defs loc in + G.NObj (loc,t) + +let mk_rec_corec ind_kind defs loc = + let loc,t = mk_rec_corec ind_kind defs loc in + G.Obj (loc,t) + +let npunct_of_punct = function + | G.Branch loc -> G.NBranch loc + | G.Shift loc -> G.NShift loc + | G.Pos (loc, i) -> G.NPos (loc, i) + | G.Wildcard loc -> G.NWildcard loc + | G.Merge loc -> G.NMerge loc + | G.Semicolon loc -> G.NSemicolon loc + | G.Dot loc -> G.NDot loc +;; +let nnon_punct_of_punct = function + | G.Skip loc -> G.NSkip loc + | G.Unfocus loc -> G.NUnfocus loc + | G.Focus (loc,l) -> G.NFocus (loc,l) +;; +let npunct_of_punct = function + | G.Branch loc -> G.NBranch loc + | G.Shift loc -> G.NShift loc + | G.Pos (loc, i) -> G.NPos (loc, i) + | G.Wildcard loc -> G.NWildcard loc + | G.Merge loc -> G.NMerge loc + | G.Semicolon loc -> G.NSemicolon loc + | G.Dot loc -> G.NDot loc +;; type by_continuation = BYC_done @@ -181,11 +209,11 @@ EXTEND let deannotate = function | N.AttributedTerm (_,t) | t -> t in match deannotate params with - | N.Implicit -> [false] + | N.Implicit _ -> [false] | N.UserInput -> [true] | N.Appl l -> List.map (fun x -> match deannotate x with - | N.Implicit -> false + | N.Implicit _ -> false | N.UserInput -> true | _ -> raise (Invalid_argument "malformed target parameter list 1")) l | _ -> raise (Invalid_argument ("malformed target parameter list 2\n" ^ CicNotationPp.pp_term params)) ] @@ -220,21 +248,31 @@ EXTEND SYMBOL <:unicode>; concl = tactic_term -> (List.rev hyps,concl) ] -> G.NAssert (loc, seqs) + | IDENT "nauto"; params = auto_params -> G.NAuto (loc, params) | IDENT "ncases"; what = tactic_term ; where = pattern_spec -> G.NCases (loc, what, where) | IDENT "nchange"; what = pattern_spec; "with"; with_what = tactic_term -> G.NChange (loc, what, with_what) + | SYMBOL "@"; num = OPT NUMBER; l = LIST0 tactic_term -> + 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 "nelim"; what = tactic_term ; where = pattern_spec -> G.NElim (loc, what, where) | IDENT "ngeneralize"; p=pattern_spec -> G.NGeneralize (loc, p) + | IDENT "nlapply"; t = tactic_term -> G.NLApply (loc, t) | IDENT "nletin"; name = IDENT ; SYMBOL <:unicode> ; t = tactic_term; where = pattern_spec -> G.NLetIn (loc,where,t,name) | kind = nreduction_kind; p = pattern_spec -> G.NReduce (loc, kind, p) - | IDENT "nrewrite"; dir = direction; what = tactic_term ; where = pattern_spec -> + | IDENT "nrewrite"; dir = direction; what = tactic_term ; where = pattern_spec -> 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,"_") @@ -461,10 +499,14 @@ EXTEND [ params = LIST0 [ IDENT "prefix"; SYMBOL "="; prefix = QSTRING -> G.IPPrefix prefix | flavour = inline_flavour -> G.IPAs flavour + | IDENT "coercions" -> G.IPCoercions + | IDENT "debug"; SYMBOL "="; debug = int -> G.IPDebug debug | IDENT "procedural" -> G.IPProcedural | IDENT "nodefaults" -> G.IPNoDefaults | IDENT "depth"; SYMBOL "="; depth = int -> G.IPDepth depth | IDENT "level"; SYMBOL "="; level = int -> G.IPLevel level + | IDENT "comments" -> G.IPComments + | IDENT "cr" -> G.IPCR ] -> params ] ]; @@ -518,6 +560,17 @@ EXTEND | tac = tactic -> tac ] ]; + npunctuation_tactical: + [ + [ SYMBOL "[" -> G.NBranch loc + | SYMBOL "|" -> G.NShift loc + | i = LIST1 int SEP SYMBOL ","; SYMBOL ":" -> G.NPos (loc, i) + | SYMBOL "*"; SYMBOL ":" -> G.NWildcard loc + | SYMBOL "]" -> G.NMerge loc + | SYMBOL ";" -> G.NSemicolon loc + | SYMBOL "." -> G.NDot loc + ] + ]; punctuation_tactical: [ [ SYMBOL "[" -> G.Branch loc @@ -604,6 +657,12 @@ EXTEND in (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 -> @@ -709,6 +768,7 @@ EXTEND ]; level3_term: [ [ u = URI -> N.UriPattern (UriManager.uri_of_string u) + | r = NREF -> N.NRefPattern (NReference.reference_of_string r) | IMPLICIT -> N.ImplicitPattern | id = IDENT -> N.VarPattern id | LPAREN; terms = LIST1 SELF; RPAREN -> @@ -726,53 +786,91 @@ EXTEND include_command: [ [ IDENT "include" ; path = QSTRING -> - loc,path,false,L.WithPreferences + loc,path,true,L.WithPreferences | IDENT "include" ; IDENT "source" ; path = QSTRING -> - loc,path,true,L.WithPreferences + loc,path,false,L.WithPreferences | IDENT "include'" ; path = QSTRING -> - loc,path,false,L.WithoutPreferences + loc,path,true,L.WithoutPreferences ]]; + grafite_ncommand: [ [ + IDENT "nqed" -> G.NQed loc + | nflavour = ntheorem_flavour; name = IDENT; SYMBOL ":"; typ = term; + body = OPT [ SYMBOL <:unicode> (* ≝ *); body = term -> body ] -> + G.NObj (loc, N.Theorem (nflavour, name, typ, body)) + | nflavour = ntheorem_flavour; name = IDENT; SYMBOL <:unicode> (* ≝ *); + body = term -> + G.NObj (loc, N.Theorem (nflavour, name, N.Implicit `JustOne, Some body)) + | IDENT "naxiom"; name = IDENT; SYMBOL ":"; typ = term -> + G.NObj (loc, N.Theorem (`Axiom, name, typ, None)) + | IDENT "ninverter"; name = IDENT; IDENT "for" ; indty = term -> + G.NInverter (loc,name,indty) + | NLETCOREC ; defs = let_defs -> + nmk_rec_corec `CoInductive defs loc + | NLETREC ; defs = let_defs -> + nmk_rec_corec `Inductive defs loc + | IDENT "ninductive"; spec = inductive_spec -> + let (params, ind_types) = spec in + G.NObj (loc, N.Inductive (params, ind_types)) + | IDENT "ncoinductive"; 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; + SYMBOL <:unicode> ; u2 = tactic_term -> + let urify = function + | CicNotationPt.AttributedTerm (_, CicNotationPt.Sort (`NType i)) -> + NUri.uri_of_string ("cic:/matita/pts/Type"^i^".univ") + | _ -> raise (Failure "only a Type[…] sort can be constrained") + in + let u1 = urify u1 in + let u2 = urify u2 in + G.NUnivConstraint (loc,u1,u2) + | IDENT "unification"; IDENT "hint"; n = int; t = tactic_term -> + G.UnificationHint (loc, t, n) + | IDENT "ncoercion"; name = IDENT; 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 "nrecord" ; (params,name,ty,fields) = record_spec -> + G.NObj (loc, N.Record (params,name,ty,fields)) + | IDENT "ncopy" ; 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) + ]]; + grafite_command: [ [ IDENT "set"; n = QSTRING; v = QSTRING -> G.Set (loc, n, v) | IDENT "drop" -> G.Drop loc | IDENT "print"; s = IDENT -> G.Print (loc,s) | IDENT "qed" -> G.Qed loc - | IDENT "nqed" -> G.NQed loc | IDENT "variant" ; name = IDENT; SYMBOL ":"; typ = term; SYMBOL <:unicode> ; newname = IDENT -> G.Obj (loc, N.Theorem (`Variant,name,typ,Some (N.Ident (newname, None)))) - | nflavour = ntheorem_flavour; name = IDENT; SYMBOL ":"; typ = term; - body = OPT [ SYMBOL <:unicode> (* ≝ *); body = term -> body ] -> - G.NObj (loc, N.Theorem (nflavour, name, typ, body)) | flavour = theorem_flavour; name = IDENT; SYMBOL ":"; typ = term; body = OPT [ SYMBOL <:unicode> (* ≝ *); body = term -> body ] -> G.Obj (loc, N.Theorem (flavour, name, typ, body)) | flavour = theorem_flavour; name = IDENT; SYMBOL <:unicode> (* ≝ *); body = term -> G.Obj (loc, - N.Theorem (flavour, name, N.Implicit, Some body)) + N.Theorem (flavour, name, N.Implicit `JustOne, Some body)) | IDENT "axiom"; name = IDENT; SYMBOL ":"; typ = term -> G.Obj (loc, N.Theorem (`Axiom, name, typ, None)) - | IDENT "naxiom"; name = IDENT; SYMBOL ":"; typ = term -> - G.NObj (loc, N.Theorem (`Axiom, name, typ, None)) | LETCOREC ; defs = let_defs -> - mk_rec_corec false `CoInductive defs loc + mk_rec_corec `CoInductive defs loc | LETREC ; defs = let_defs -> - mk_rec_corec false `Inductive defs loc - | NLETCOREC ; defs = let_defs -> - mk_rec_corec true `CoInductive defs loc - | NLETREC ; defs = let_defs -> - mk_rec_corec true `Inductive defs loc + mk_rec_corec `Inductive defs loc | IDENT "inductive"; spec = inductive_spec -> let (params, ind_types) = spec in G.Obj (loc, N.Inductive (params, ind_types)) - | IDENT "ninductive"; spec = inductive_spec -> - let (params, ind_types) = spec in - G.NObj (loc, N.Inductive (params, ind_types)) | IDENT "coinductive"; spec = inductive_spec -> let (params, ind_types) = spec in let ind_types = (* set inductive flags to false (coinductive) *) @@ -780,34 +878,6 @@ EXTEND ind_types in G.Obj (loc, N.Inductive (params, ind_types)) - | IDENT "ncoinductive"; 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; - strict = [ SYMBOL <:unicode> -> true - | SYMBOL <:unicode> -> false ]; - u2 = tactic_term -> - let u1 = - match u1 with - | CicNotationPt.AttributedTerm (_, CicNotationPt.Sort (`NType i)) -> - NUri.uri_of_string ("cic:/matita/pts/Type"^i^".univ") - | CicNotationPt.AttributedTerm (_, CicNotationPt.Sort (`NCProp i)) -> - NUri.uri_of_string ("cic:/matita/pts/CProp"^i^".univ") - | _ -> raise (Failure "only a sort can be constrained") - in - let u2 = - match u2 with - | CicNotationPt.AttributedTerm (_, CicNotationPt.Sort (`NType i)) -> - NUri.uri_of_string ("cic:/matita/pts/Type"^i^".univ") - | CicNotationPt.AttributedTerm (_, CicNotationPt.Sort (`NCProp i)) -> - NUri.uri_of_string ("cic:/matita/pts/CProp"^i^".univ") - | _ -> raise (Failure "only a sort can be constrained") - in - G.NUnivConstraint (loc, strict,u1,u2) | IDENT "coercion" ; t = [ u = URI -> N.Uri (u,None) | t = tactic_term ; OPT "with" -> t ] ; arity = OPT int ; saturations = OPT int; @@ -821,16 +891,12 @@ EXTEND G.PreferCoercion (loc, t) | IDENT "pump" ; steps = int -> G.Pump(loc,steps) - | IDENT "unification"; IDENT "hint"; n = int; t = tactic_term -> - G.UnificationHint (loc, t, n) | IDENT "inverter"; name = IDENT; IDENT "for"; indty = tactic_term; paramspec = inverter_param_list -> G.Inverter (loc, name, indty, paramspec) | IDENT "record" ; (params,name,ty,fields) = record_spec -> G.Obj (loc, N.Record (params,name,ty,fields)) - | IDENT "nrecord" ; (params,name,ty,fields) = record_spec -> - G.NObj (loc, N.Record (params,name,ty,fields)) | IDENT "default" ; what = QSTRING ; uris = LIST1 URI -> let uris = List.map UriManager.uri_of_string uris in G.Default (loc,what,uris) @@ -855,18 +921,26 @@ EXTEND ]]; executable: [ [ cmd = grafite_command; SYMBOL "." -> G.Command (loc, cmd) + | ncmd = grafite_ncommand; SYMBOL "." -> G.NCommand (loc, ncmd) | tac = atomic_tactical LEVEL "loops"; punct = punctuation_tactical -> G.Tactic (loc, Some tac, punct) | punct = punctuation_tactical -> G.Tactic (loc, None, punct) + | tac = ntactic; SYMBOL "#" ; SYMBOL "#" ; punct = punctuation_tactical -> + G.NTactic (loc, [tac; npunct_of_punct punct]) | tac = ntactic; punct = punctuation_tactical -> - G.NTactic (loc, tac, punct) - | SYMBOL "#" ; SYMBOL "#" ; punct = punctuation_tactical -> - G.NTactic (loc, G.NId loc, 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 -> G.NonPunctuationTactical (loc, tac, punct) - | SYMBOL "#" ; SYMBOL "#" ; tac = non_punctuation_tactical; punct = punctuation_tactical -> - G.NNonPunctuationTactical (loc, tac, punct) + | SYMBOL "#" ; SYMBOL "#" ; tac = non_punctuation_tactical; + SYMBOL "#" ; SYMBOL "#" ; punct = punctuation_tactical -> + G.NTactic (loc, [nnon_punct_of_punct tac; npunct_of_punct punct]) + | SYMBOL "#" ; SYMBOL "#" ; tac = non_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: [ @@ -880,33 +954,35 @@ EXTEND [ ex = executable -> fun ?(never_include=false) ~include_paths status -> let stm = G.Executable (loc, ex) in - !grafite_callback status stm; + !grafite_callback stm; status, LSome stm | com = comment -> fun ?(never_include=false) ~include_paths status -> let stm = G.Comment (loc, com) in - !grafite_callback status stm; + !grafite_callback stm; status, LSome stm - | (iloc,fname,source,mode) = include_command ; SYMBOL "." -> + | (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, source, fname))) - in - !grafite_callback status stm; - let _root, buri, fullpath, _rrelpath = - Librarian.baseuri_of_script ~include_paths fname - in + G.Executable + (loc, G.Command (loc, G.Include (iloc,normal,`OldAndNew,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, source, buri))) + G.Executable + (loc,G.Command (loc,G.Include (iloc,normal,`OldAndNew,buri))) in - let status = - if never_include then raise (NoInclusionPerformed fullpath) - else LE.eval_command status (L.Include (iloc,buri,mode,fullpath)) - in - status, LSome stm + status, LSome stm + end | scom = lexicon_command ; SYMBOL "." -> fun ?(never_include=false) ~include_paths status -> - !lexicon_callback status scom; + !lexicon_callback scom; let status = LE.eval_command status scom in status, LNone loc | EOI -> raise End_of_file @@ -934,9 +1010,9 @@ let exc_located_wrapper f = let parse_statement lexbuf = exc_located_wrapper - (fun () -> (Grammar.Entry.parse !grafite_parser.statement (Obj.magic lexbuf))) + (fun () -> (Grammar.Entry.parse (Obj.magic !grafite_parser.statement) (Obj.magic lexbuf))) -let statement () = !grafite_parser.statement +let statement () = Obj.magic !grafite_parser.statement let history = ref [] ;;