X-Git-Url: http://matita.cs.unibo.it/gitweb/?a=blobdiff_plain;f=helm%2Fsoftware%2Fcomponents%2Fgrafite_parser%2FgrafiteParser.ml;h=7b119ab11ac7e11db3256bb9207523ae77f6eaf0;hb=9fb5c64e77e7cde6c6e47549a9dbf7619f685372;hp=0b13980161ba6f27dc6e3e7b7c37b2664421c556;hpb=5649890273cf8e660bba744e84ce5fee1e5efe69;p=helm.git diff --git a/helm/software/components/grafite_parser/grafiteParser.ml b/helm/software/components/grafite_parser/grafiteParser.ml index 0b1398016..7b119ab11 100644 --- a/helm/software/components/grafite_parser/grafiteParser.ml +++ b/helm/software/components/grafite_parser/grafiteParser.ml @@ -55,8 +55,36 @@ let statement = Grammar.Entry.create grammar "statement" let add_raw_attribute ~text t = Ast.AttributedTerm (`Raw text, t) -let default_precedence = 50 let default_associativity = Gramext.NonA + +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 + insertion in the environment. We use the flavour + `MutualDefinition to rememer this. *) + let name,ty = + match defs with + | (params,(Ast.Ident (name, None), Some ty),_,_) :: _ -> + let ty = + List.fold_right + (fun var ty -> Ast.Binder (`Pi,var,ty) + ) params ty + in + name,ty + | (_,(Ast.Ident (name, None), None),_,_) :: _ -> + name, Ast.Implicit + | _ -> assert false + in + let body = Ast.Ident (name,None) in + let flavour = + if List.length defs = 1 then + `Definition + else + `MutualDefinition + in + GrafiteAst.Obj (loc, Ast.Theorem(flavour, name, ty, + Some (Ast.LetRec (ind_kind, defs, body)))) type by_continuation = BYC_done @@ -67,7 +95,7 @@ type by_continuation = EXTEND GLOBAL: term statement; constructor: [ [ name = IDENT; SYMBOL ":"; typ = term -> (name, typ) ] ]; - tactic_term: [ [ t = term LEVEL "90N" -> t ] ]; + tactic_term: [ [ t = term LEVEL "90" -> t ] ]; new_name: [ [ id = IDENT -> Some id | SYMBOL "_" -> None ] @@ -148,8 +176,13 @@ EXTEND | IDENT "autobatch"; params = auto_params -> GrafiteAst.AutoBatch (loc,params) | IDENT "cases"; what = tactic_term; + pattern = OPT pattern_spec; specs = intros_spec -> - GrafiteAst.Cases (loc, what, specs) + let pattern = match pattern with + | None -> None, [], Some Ast.UserInput + | Some pattern -> pattern + in + GrafiteAst.Cases (loc, what, pattern, specs) | IDENT "clear"; ids = LIST1 IDENT -> GrafiteAst.Clear (loc, ids) | IDENT "clearbody"; id = IDENT -> @@ -167,22 +200,22 @@ EXTEND | IDENT "cut"; t = tactic_term; ident = OPT [ "as"; id = IDENT -> id] -> GrafiteAst.Cut (loc, ident, t) | IDENT "decompose"; idents = OPT [ "as"; idents = LIST1 new_name -> idents ] -> - let idents = match idents with None -> [] | Some idents -> idents in - GrafiteAst.Decompose (loc, idents) + let idents = match idents with None -> [] | Some idents -> idents in + GrafiteAst.Decompose (loc, idents) | IDENT "demodulate"; p = auto_params -> GrafiteAst.Demodulate (loc, p) | IDENT "destruct"; xts = OPT [ ts = tactic_term_list1 -> ts ] -> GrafiteAst.Destruct (loc, xts) | IDENT "elim"; what = tactic_term; using = using; pattern = OPT pattern_spec; (num, idents) = intros_spec -> - let pattern = match pattern with - | None -> None, [], Some Ast.UserInput - | Some pattern -> pattern - in - GrafiteAst.Elim (loc, what, using, pattern, (num, idents)) + let pattern = match pattern with + | None -> None, [], Some Ast.UserInput + | Some pattern -> pattern + in + GrafiteAst.Elim (loc, what, using, pattern, (num, idents)) | IDENT "elimType"; what = tactic_term; using = using; (num, idents) = intros_spec -> - GrafiteAst.ElimType (loc, what, using, (num, idents)) + GrafiteAst.ElimType (loc, what, using, (num, idents)) | IDENT "exact"; t = tactic_term -> GrafiteAst.Exact (loc, t) | IDENT "exists" -> @@ -218,7 +251,7 @@ EXTEND to_what = OPT [ "to" ; t = tactic_term_list1 -> t ]; ident = OPT [ "as" ; ident = IDENT -> ident ] -> let linear = match linear with None -> false | Some _ -> true in - let to_what = match to_what with None -> [] | Some to_what -> to_what in + let to_what = match to_what with None -> [] | Some to_what -> to_what in GrafiteAst.LApply (loc, linear, depth, to_what, what, ident) | IDENT "left" -> GrafiteAst.Left loc | IDENT "letin"; where = IDENT ; SYMBOL <:unicode> ; t = tactic_term -> @@ -238,7 +271,7 @@ EXTEND (CicNotationParser.Parse_error "the pattern cannot specify the term to rewrite, only its paths in the hypotheses and in the conclusion"))) else - let n = match xnames with None -> [] | Some names -> names in + let n = match xnames with None -> [] | Some names -> names in GrafiteAst.Rewrite (loc, d, t, p, n) | IDENT "right" -> GrafiteAst.Right loc @@ -253,76 +286,104 @@ EXTEND (* Produzioni Aggiunte *) | IDENT "assume" ; id = IDENT ; SYMBOL ":" ; t = tactic_term -> GrafiteAst.Assume (loc, id, t) - | IDENT "suppose" ; t = tactic_term ; LPAREN ; id = IDENT ; RPAREN ; t1 = OPT [IDENT "that" ; IDENT "is" ; IDENT "equivalent" ; "to" ; t' = tactic_term -> t']-> + | IDENT "suppose" ; t = tactic_term ; LPAREN ; id = IDENT ; RPAREN ; + t1 = OPT [IDENT "that" ; IDENT "is" ; IDENT "equivalent" ; "to" ; + t' = tactic_term -> t']-> GrafiteAst.Suppose (loc, t, id, t1) - | "by" ; t = [t' = tactic_term -> LSome t' | SYMBOL "_" -> LNone loc]; + | "let" ; id1 = IDENT ; SYMBOL ":" ; t1 = tactic_term ; + IDENT "such" ; IDENT "that" ; t2=tactic_term ; LPAREN ; + id2 = IDENT ; RPAREN -> + GrafiteAst.ExistsElim (loc, `Auto ([],[]), id1, t1, id2, t2) + | just = + [ IDENT "using"; t=tactic_term -> `Term t + | params = auto_params -> `Auto params] ; cont=by_continuation -> - let t' = match t with LNone _ -> None | LSome t -> Some t in (match cont with - BYC_done -> GrafiteAst.Bydone (loc, t') - | BYC_weproved (ty,id,t1) -> - GrafiteAst.By_term_we_proved(loc, t', ty, id, t1) - | BYC_letsuchthat (id1,t1,id2,t2) -> - (* (match t with - LNone floc -> - raise (HExtlib.Localized - (floc,CicNotationParser.Parse_error - "tactic_term expected here")) - | LSome t ->*) GrafiteAst.ExistsElim (loc, t', id1, t1, id2, t2)(*)*) - | BYC_wehaveand (id1,t1,id2,t2) -> - (match t with - LNone floc -> - raise (HExtlib.Localized - (floc,CicNotationParser.Parse_error - "tactic_term expected here")) - | LSome t -> GrafiteAst.AndElim (loc, t, id1, t1, id2, t2))) + BYC_done -> GrafiteAst.Bydone (loc, just) + | BYC_weproved (ty,id,t1) -> + GrafiteAst.By_just_we_proved(loc, just, ty, id, t1) + | BYC_letsuchthat (id1,t1,id2,t2) -> + GrafiteAst.ExistsElim (loc, just, id1, t1, id2, t2) + | BYC_wehaveand (id1,t1,id2,t2) -> + GrafiteAst.AndElim (loc, just, id1, t1, id2, t2)) | IDENT "we" ; IDENT "need" ; "to" ; IDENT "prove" ; t = tactic_term ; id = OPT [ LPAREN ; id = IDENT ; RPAREN -> id ] ; t1 = OPT [IDENT "or" ; IDENT "equivalently"; t' = tactic_term -> t']-> GrafiteAst.We_need_to_prove (loc, t, id, t1) - | IDENT "we" ; IDENT "proceed" ; "by" ; IDENT "cases" ; "on" ; t=tactic_term ; "to" ; IDENT "prove" ; t1=tactic_term -> + | IDENT "we" ; IDENT "proceed" ; IDENT "by" ; IDENT "cases" ; "on" ; t=tactic_term ; "to" ; IDENT "prove" ; t1=tactic_term -> GrafiteAst.We_proceed_by_cases_on (loc, t, t1) - | IDENT "we" ; IDENT "proceed" ; "by" ; IDENT "induction" ; "on" ; t=tactic_term ; "to" ; IDENT "prove" ; t1=tactic_term -> + | IDENT "we" ; IDENT "proceed" ; IDENT "by" ; IDENT "induction" ; "on" ; t=tactic_term ; "to" ; IDENT "prove" ; t1=tactic_term -> GrafiteAst.We_proceed_by_induction_on (loc, t, t1) - | "by" ; IDENT "induction" ; IDENT "hypothesis" ; IDENT "we" ; IDENT "know" ; t=tactic_term ; LPAREN ; id = IDENT ; RPAREN -> + | IDENT "by" ; IDENT "induction" ; IDENT "hypothesis" ; IDENT "we" ; IDENT "know" ; t=tactic_term ; LPAREN ; id = IDENT ; RPAREN -> GrafiteAst.Byinduction(loc, t, id) | IDENT "the" ; IDENT "thesis" ; IDENT "becomes" ; t=tactic_term -> GrafiteAst.Thesisbecomes(loc, t) | IDENT "case" ; id = IDENT ; params=LIST0[LPAREN ; i=IDENT ; SYMBOL":" ; t=tactic_term ; RPAREN -> i,t] -> - GrafiteAst.Case(loc,id,params) - | start = OPT [ - start = - [ IDENT "conclude" -> None - | IDENT "obtain" ; name = IDENT -> Some name ] ; - termine = tactic_term -> start, termine]; + GrafiteAst.Case(loc,id,params) + (* DO NOT FACTORIZE with the two following, camlp5 sucks*) + | IDENT "conclude"; + termine = tactic_term; + SYMBOL "=" ; + t1=tactic_term ; + t2 = + [ IDENT "using"; t=tactic_term -> `Term t + | IDENT "using"; IDENT "once"; term=tactic_term -> `SolveWith term + | IDENT "proof" -> `Proof + | params = auto_params -> `Auto params]; + cont = rewriting_step_continuation -> + GrafiteAst.RewritingStep(loc, Some (None,termine), t1, t2, cont) + | IDENT "obtain" ; name = IDENT; + termine = tactic_term; SYMBOL "=" ; t1=tactic_term ; t2 = - [ IDENT "exact"; t=tactic_term -> `Term t - | IDENT "using"; term=tactic_term -> `SolveWith term + [ IDENT "using"; t=tactic_term -> `Term t + | IDENT "using"; IDENT "once"; term=tactic_term -> `SolveWith term + | IDENT "proof" -> `Proof + | params = auto_params -> `Auto params]; + cont = rewriting_step_continuation -> + GrafiteAst.RewritingStep(loc, Some (Some name,termine), t1, t2, cont) + | SYMBOL "=" ; + t1=tactic_term ; + t2 = + [ IDENT "using"; t=tactic_term -> `Term t + | IDENT "using"; IDENT "once"; term=tactic_term -> `SolveWith term | IDENT "proof" -> `Proof | params = auto_params -> `Auto params]; cont = rewriting_step_continuation -> - GrafiteAst.RewritingStep(loc, start, t1, t2, cont) + GrafiteAst.RewritingStep(loc, None, t1, t2, cont) ] +]; + auto_fixed_param: [ + [ IDENT "paramodulation" + | IDENT "depth" + | IDENT "width" + | IDENT "size" + | IDENT "timeout" + | IDENT "library" + | IDENT "type" + ] ]; auto_params: [ [ params = - LIST0 [ i = IDENT -> i,"" | i = IDENT ; SYMBOL "="; v = [ v = int -> + LIST0 [ + i = auto_fixed_param -> i,"" + | i = auto_fixed_param ; SYMBOL "="; v = [ v = int -> string_of_int v | v = IDENT -> v ] -> i,v ]; - tl = OPT [ "by"; tl = LIST1 tactic_term -> tl] -> + tl = OPT [ IDENT "by"; tl = tactic_term_list1 -> tl] -> (match tl with Some l -> l | None -> []), params ] ]; by_continuation: [ - [ IDENT "we" ; IDENT "proved" ; 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) - | IDENT "we" ; IDENT "proved" ; ty = tactic_term ; t1 = OPT [IDENT "that" ; IDENT "is" ; IDENT "equivalent" ; "to" ; t2 = tactic_term -> t2] ; + [ 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] ; "done" -> BYC_weproved (ty,None,t1) | "done" -> BYC_done | "let" ; id1 = IDENT ; SYMBOL ":" ; t1 = tactic_term ; - IDENT "such" ; IDENT "that" ; t2=tactic_term ; LPAREN ; id2 = IDENT ; RPAREN -> BYC_letsuchthat (id1,t1,id2,t2) - | IDENT "we" ; IDENT "have" ; t1=tactic_term ; LPAREN ; id1=IDENT ; RPAREN ;"and" ; t2=tactic_term ; LPAREN ; id2=IDENT ; RPAREN -> - BYC_wehaveand (id1,t1,id2,t2) + IDENT "such" ; IDENT "that" ; t2=tactic_term ; LPAREN ; + id2 = IDENT ; RPAREN -> BYC_letsuchthat (id1,t1,id2,t2) + | WEHAVE; t1=tactic_term ; LPAREN ; id1=IDENT ; RPAREN ;"and" ; t2=tactic_term ; LPAREN ; id2=IDENT ; RPAREN -> + BYC_wehaveand (id1,t1,id2,t2) ] ]; rewriting_step_continuation : [ @@ -439,13 +500,13 @@ EXTEND GrafiteAst.Check (loc, t) | [ IDENT "inline"]; style = OPT [ IDENT "procedural"; depth = OPT int -> depth ]; - suri = QSTRING; prefix = OPT QSTRING -> + suri = QSTRING; prefix = OPT QSTRING -> let style = match style with - | None -> GrafiteAst.Declarative - | Some depth -> GrafiteAst.Procedural depth - in - let prefix = match prefix with None -> "" | Some prefix -> prefix in - GrafiteAst.Inline (loc,style,suri,prefix) + | None -> GrafiteAst.Declarative + | Some depth -> GrafiteAst.Procedural depth + in + let prefix = match prefix with None -> "" | Some prefix -> prefix in + GrafiteAst.Inline (loc,style,suri,prefix) | [ IDENT "hint" ]; rew = OPT (IDENT "rewrite") -> if rew = None then GrafiteAst.Hint (loc, false) else GrafiteAst.Hint (loc,true) | IDENT "auto"; params = auto_params -> @@ -513,7 +574,7 @@ EXTEND ]; notation: [ [ dir = OPT direction; s = QSTRING; - assoc = OPT associativity; prec = OPT precedence; + assoc = OPT associativity; prec = precedence; IDENT "for"; p2 = [ blob = UNPARSED_AST -> @@ -530,14 +591,9 @@ EXTEND | None -> default_associativity | Some assoc -> assoc in - let prec = - match prec with - | None -> default_precedence - | Some prec -> prec - in let p1 = add_raw_attribute ~text:s - (CicNotationParser.parse_level1_pattern + (CicNotationParser.parse_level1_pattern prec (Ulexing.from_utf8_string s)) in (dir, p1, assoc, prec, p2) @@ -587,35 +643,10 @@ EXTEND Ast.Theorem (flavour, name, Ast.Implicit, Some body)) | IDENT "axiom"; name = IDENT; SYMBOL ":"; typ = term -> GrafiteAst.Obj (loc, Ast.Theorem (`Axiom, name, typ, None)) - | "let"; ind_kind = [ "corec" -> `CoInductive | "rec"-> `Inductive ]; - defs = CicNotationParser.let_defs -> - (* 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 - insertion in the environment. We use the flavour - `MutualDefinition to rememer this. *) - let name,ty = - match defs with - | (params,(Ast.Ident (name, None), Some ty),_,_) :: _ -> - let ty = - List.fold_right - (fun var ty -> Ast.Binder (`Pi,var,ty) - ) params ty - in - name,ty - | (_,(Ast.Ident (name, None), None),_,_) :: _ -> - name, Ast.Implicit - | _ -> assert false - in - let body = Ast.Ident (name,None) in - let flavour = - if List.length defs = 1 then - `Definition - else - `MutualDefinition - in - GrafiteAst.Obj (loc, Ast.Theorem(flavour, name, ty, - Some (Ast.LetRec (ind_kind, defs, body)))) + | LETCOREC ; defs = CicNotationParser.let_defs -> + mk_rec_corec `CoInductive defs loc + | LETREC ; defs = CicNotationParser.let_defs -> + mk_rec_corec `Inductive defs loc | IDENT "inductive"; spec = inductive_spec -> let (params, ind_types) = spec in GrafiteAst.Obj (loc, Ast.Inductive (params, ind_types)) @@ -639,11 +670,11 @@ EXTEND let uris = List.map UriManager.uri_of_string uris in GrafiteAst.Default (loc,what,uris) | IDENT "relation" ; aeq = tactic_term ; "on" ; a = tactic_term ; - refl = OPT [ IDENT "reflexivity" ; IDENT "proved" ; "by" ; + refl = OPT [ IDENT "reflexivity" ; IDENT "proved" ; IDENT "by" ; refl = tactic_term -> refl ] ; - sym = OPT [ IDENT "symmetry" ; IDENT "proved" ; "by" ; + sym = OPT [ IDENT "symmetry" ; IDENT "proved" ; IDENT "by" ; sym = tactic_term -> sym ] ; - trans = OPT [ IDENT "transitivity" ; IDENT "proved" ; "by" ; + trans = OPT [ IDENT "transitivity" ; IDENT "proved" ; IDENT "by" ; trans = tactic_term -> trans ] ; "as" ; id = IDENT -> GrafiteAst.Relation (loc,id,a,aeq,refl,sym,trans) @@ -680,8 +711,9 @@ EXTEND | com = comment -> fun ?(never_include=false) ~include_paths status -> status,LSome (GrafiteAst.Comment (loc, com)) | (iloc,fname,mode) = include_command ; SYMBOL "." -> + !out fname; fun ?(never_include=false) ~include_paths status -> - let _root, buri, fullpath, _rrelpath = + let _root, buri, fullpath, _rrelpath = Librarian.baseuri_of_script ~include_paths fname in let status = @@ -689,7 +721,6 @@ EXTEND else LexiconEngine.eval_command status (LexiconAst.Include (iloc,buri,mode,fullpath)) in - !out fname; status, LSome (GrafiteAst.Executable @@ -697,7 +728,7 @@ EXTEND (loc,GrafiteAst.Include (iloc,buri)))) | scom = lexicon_command ; SYMBOL "." -> fun ?(never_include=false) ~include_paths status -> - let status = LexiconEngine.eval_command status scom in + let status = LexiconEngine.eval_command status scom in status,LNone loc | EOI -> raise End_of_file ] @@ -711,6 +742,9 @@ let exc_located_wrapper f = | 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)))