]> matita.cs.unibo.it Git - helm.git/blobdiff - matita/components/grafite_parser/grafiteParser.ml
{pattern} => in pattern;
[helm.git] / matita / components / grafite_parser / grafiteParser.ml
index 5b092a6d310fc2dc3641374cc026a2a73118d194..b616a824b2d8c547a80cce9ae440ed9b114be7e3 100644 (file)
 
 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
@@ -49,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)
 
@@ -100,21 +101,11 @@ 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 +128,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 +159,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 +182,6 @@ EXTEND
         SYMBOL <:unicode<vdash>>;
         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 +193,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 -> 
         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 +228,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 +243,15 @@ 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"
    ]
 ];
   auto_params: [
@@ -288,8 +261,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,12 +494,16 @@ 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
      ]];
 
   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<def>> (* ≝ *); body = term -> body ] ->
         G.NObj (loc, N.Theorem (nflavour, name, typ, body,`Regular))
@@ -541,9 +517,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
@@ -567,11 +543,14 @@ 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" -> () ];
+        spec = OPT [ SYMBOL ":"; ty = term; 
         SYMBOL <:unicode<def>>; t = term; "on"; 
         id = [ IDENT | PIDENT ]; SYMBOL ":"; source = term;
-        "to"; target = term ->
-          G.NCoercion(loc,name,t,ty,(id,source),target)     
+        "to"; target = term -> t,ty,(id,source),target ] ->
+          let compose = compose = None in
+          G.NCoercion(loc,name,compose,spec)
     | 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"; 
@@ -612,12 +591,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,7 +603,7 @@ EXTEND
   statement
 ;;
 
-type db = ast_statement localized_option Grammar.Entry.e ;;
+type db = GrafiteAst.statement Grammar.Entry.e ;;
 
 class type g_status =
  object
@@ -634,10 +611,10 @@ class type g_status =
   method parser_db: db
  end
 
-class status =
+class virtual status =
  object(self)
   inherit CicNotationParser.status ~keywords:[]
-  val mutable db = None
+  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