X-Git-Url: http://matita.cs.unibo.it/gitweb/?a=blobdiff_plain;ds=sidebyside;f=helm%2Fsoftware%2Fcomponents%2Fgrafite_parser%2FgrafiteParser.ml;h=44dec6d32bf6adfc4aef459977bb26c861fe26cb;hb=5b45f78ed4293ebbe8cc73ad925bca11a300d021;hp=b9f6d388fa2faa50c318383f373b322b0bde459b;hpb=fd4196b476bff30c46a80cd858ea7bf057f301eb;p=helm.git

diff --git a/helm/software/components/grafite_parser/grafiteParser.ml b/helm/software/components/grafite_parser/grafiteParser.ml
index b9f6d388f..44dec6d32 100644
--- a/helm/software/components/grafite_parser/grafiteParser.ml
+++ b/helm/software/components/grafite_parser/grafiteParser.ml
@@ -48,10 +48,20 @@ type statement =
   LexiconEngine.status ->
     LexiconEngine.status * ast_statement localized_option
 
-let grammar = CicNotationParser.level2_ast_grammar
+type parser_status = {
+  grammar : Grammar.g;
+  term : CicNotationPt.term Grammar.Entry.e;
+  statement : statement Grammar.Entry.e;
+}
 
-let term = CicNotationParser.term
-let statement = Grammar.Entry.create grammar "statement"
+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 grafite_parser = ref (initial_parser ())
 
 let add_raw_attribute ~text t = Ast.AttributedTerm (`Raw text, t)
 
@@ -92,6 +102,12 @@ type by_continuation =
  | BYC_letsuchthat of string * CicNotationPt.term * string * CicNotationPt.term
  | BYC_wehaveand of string * CicNotationPt.term * string * CicNotationPt.term
 
+let initialize_parser () =
+  (* {{{ 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) ] ];
@@ -167,6 +183,8 @@ EXTEND
   tactic: [
     [ IDENT "absurd"; t = tactic_term ->
         GrafiteAst.Absurd (loc, t)
+    | IDENT "apply"; IDENT "rule"; t = tactic_term ->
+        GrafiteAst.ApplyRule (loc, t)
     | IDENT "apply"; t = tactic_term ->
         GrafiteAst.Apply (loc, t)
     | IDENT "applyP"; t = tactic_term ->
@@ -209,12 +227,12 @@ EXTEND
         GrafiteAst.Destruct (loc, xts)
     | IDENT "elim"; what = tactic_term; using = using; 
        pattern = OPT pattern_spec;
-       (num, idents) = intros_spec ->
+       ispecs = intros_spec ->
         let pattern = match pattern with
            | None         -> None, [], Some Ast.UserInput
            | Some pattern -> pattern   
         in
-        GrafiteAst.Elim (loc, what, using, pattern, (num, idents))
+        GrafiteAst.Elim (loc, what, using, pattern, ispecs)
     | IDENT "elimType"; what = tactic_term; using = using;
       (num, idents) = intros_spec ->
         GrafiteAst.ElimType (loc, what, using, (num, idents))
@@ -459,7 +477,8 @@ EXTEND
      ]
   ];
   inductive_spec: [ [
-    fst_name = IDENT; params = LIST0 CicNotationParser.protected_binder_vars;
+    fst_name = IDENT; 
+      params = LIST0 protected_binder_vars;
     SYMBOL ":"; fst_typ = term; SYMBOL <:unicode<def>>; OPT SYMBOL "|";
     fst_constructors = LIST0 constructor SEP SYMBOL "|";
     tl = OPT [ "with";
@@ -481,7 +500,8 @@ EXTEND
   ] ];
   
   record_spec: [ [
-    name = IDENT; params = LIST0 CicNotationParser.protected_binder_vars ;
+    name = IDENT; 
+    params = LIST0 protected_binder_vars;
      SYMBOL ":"; typ = term; SYMBOL <:unicode<def>>; SYMBOL "{" ; 
      fields = LIST0 [ 
        name = IDENT ; 
@@ -506,6 +526,8 @@ EXTEND
   macro: [
     [ [ IDENT "check"   ]; t = term ->
         GrafiteAst.Check (loc, t)
+    | [ IDENT "eval" ]; kind = reduction_kind; "on"; t = tactic_term ->
+        GrafiteAst.Eval (loc, kind, t)
     | [ IDENT "inline"]; 
         style = OPT [ IDENT "procedural"; depth = OPT int -> depth ];
         suri = QSTRING; prefix = OPT QSTRING;
@@ -537,7 +559,8 @@ EXTEND
       let alpha = "[a-zA-Z]" in
       let num = "[0-9]+" in
       let ident_cont = "\\("^alpha^"\\|"^num^"\\|_\\|\\\\\\)" in
-      let ident = "\\("^alpha^ident_cont^"*\\|_"^ident_cont^"+\\)" in
+      let decoration = "\\'" in
+      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
@@ -652,9 +675,9 @@ 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))
-    | LETCOREC ; defs = CicNotationParser.let_defs -> 
+    | LETCOREC ; defs = let_defs -> 
         mk_rec_corec `CoInductive defs loc
-    | LETREC ; defs = CicNotationParser.let_defs -> 
+    | LETREC ; defs = let_defs -> 
         mk_rec_corec `Inductive defs loc
     | IDENT "inductive"; spec = inductive_spec ->
         let (params, ind_types) = spec in
@@ -675,6 +698,10 @@ EXTEND
         let composites = match composites with None -> true | Some _ -> false in
         GrafiteAst.Coercion
          (loc, t, composites, arity, saturations)
+    | IDENT "prefer" ; IDENT "coercion"; t = tactic_term ->
+        GrafiteAst.PreferCoercion (loc, t)
+    | IDENT "unification"; IDENT "hint"; t = tactic_term ->
+        GrafiteAst.UnificationHint (loc, t)
     | IDENT "record" ; (params,name,ty,fields) = record_spec ->
         GrafiteAst.Obj (loc, Ast.Record (params,name,ty,fields))
     | IDENT "default" ; what = QSTRING ; uris = LIST1 URI ->
@@ -720,7 +747,8 @@ EXTEND
     [ ex = executable ->
        fun ?(never_include=false) ~include_paths status -> status,LSome(GrafiteAst.Executable (loc,ex))
     | com = comment ->
-       fun ?(never_include=false) ~include_paths status -> status,LSome (GrafiteAst.Comment (loc, com))
+       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 ->
@@ -745,6 +773,10 @@ EXTEND
     ]
   ];
 END
+(* }}} *)
+;;
+
+let _ = initialize_parser () ;;
 
 let exc_located_wrapper f =
   try
@@ -762,5 +794,28 @@ let exc_located_wrapper f =
 
 let parse_statement lexbuf =
   exc_located_wrapper
-    (fun () -> (Grammar.Entry.parse statement (Obj.magic lexbuf)))
+    (fun () -> (Grammar.Entry.parse !grafite_parser.statement (Obj.magic lexbuf)))
+
+let statement () = !grafite_parser.statement
+
+let history = ref [] ;;
+
+let push () =
+  LexiconSync.push ();
+  history := !grafite_parser :: !history;
+  grafite_parser := initial_parser ();
+  initialize_parser ()
+;;
+
+let pop () =
+  LexiconSync.pop ();
+  match !history with
+  | [] -> assert false
+  | gp :: tail ->
+      grafite_parser := gp;
+      history := tail
+;;
+
+(* vim:set foldmethod=marker: *)
+