various updates, removed proofs for now because they are the real bottleneck!!

[helm.git] / helm / ocaml / cic_disambiguation / cicTextualParser2.ml

diff --git a/helm/ocaml/cic_disambiguation/cicTextualParser2.ml b/helm/ocaml/cic_disambiguation/cicTextualParser2.ml
index 19d5c5b145e25f7d599f02c496680a9f4a4ff205..352c925fbba057947ede41bab2f91fec9f6aa929 100644 (file)
--- a/helm/ocaml/cic_disambiguation/cicTextualParser2.ml
+++ b/helm/ocaml/cic_disambiguation/cicTextualParser2.ml
@@ -229,10 +229,12 @@ EXTEND
     ]];
   constructor: [ [ name = IDENT; SYMBOL ":"; typ = term -> (name, typ) ] ];
   binder_vars: [
-      [ vars = LIST1 IDENT SEP SYMBOL ",";
+      [ vars = [ l = LIST1 IDENT SEP SYMBOL "," -> l | SYMBOL "_" -> ["_"]];
         typ = OPT [ SYMBOL ":"; t = term -> t ] -> (vars, typ)
-      | PAREN "("; vars = LIST1 IDENT SEP SYMBOL ",";
-        typ = OPT [ SYMBOL ":"; t = term -> t ]; PAREN ")" -> (vars, typ)
+      | PAREN "("; 
+          vars = [ l =  LIST1 IDENT SEP SYMBOL "," -> l | SYMBOL "_" -> ["_"]];
+          typ = OPT [ SYMBOL ":"; t = term -> t ]; 
+        PAREN ")" -> (vars, typ)
       ]
   ];
   term0: [ [ t = term; EOI -> return_term loc t ] ];
@@ -346,9 +348,15 @@ EXTEND
         TacticAst.Apply (loc, t)
     | IDENT "assumption" ->
         TacticAst.Assumption loc
-    | IDENT "auto"; num = OPT [ i = NUM -> int_of_string i ] -> 
-          TacticAst.Auto (loc,num)
-    | IDENT "change"; t1 = tactic_term; "with"; t2 = tactic_term;
+    | IDENT "auto";
+      depth = OPT [ IDENT "depth"; SYMBOL "="; i = NUM -> int_of_string i ];
+      width = OPT [ IDENT "depth"; SYMBOL "="; i = NUM -> int_of_string i ] -> 
+          TacticAst.Auto (loc,depth,width)
+    | IDENT "clear"; id = IDENT ->
+        TacticAst.Clear (loc,id)
+    | IDENT "clearbody"; id = IDENT ->
+        TacticAst.ClearBody (loc,id)
+    | IDENT "change"; t1 = tactic_term; "with"; t2 = tactic_term; "in";
       where = pattern_spec ->
         TacticAst.Change (loc, t1, t2, where)
     | IDENT "compare"; t = tactic_term ->
@@ -357,29 +365,40 @@ EXTEND
         TacticAst.Constructor (loc,int_of_string n)
     | IDENT "contradiction" ->
         TacticAst.Contradiction loc
-    | IDENT "cut"; t = tactic_term ->
-        TacticAst.Cut (loc, t)
+    | IDENT "cut"; t = tactic_term; ident = OPT [ "as"; id = IDENT -> id] ->
+        TacticAst.Cut (loc, ident, t)
     | IDENT "decide"; IDENT "equality" ->
         TacticAst.DecideEquality loc
     | IDENT "decompose"; where = term ->
         TacticAst.Decompose (loc, where)
     | IDENT "discriminate"; t = tactic_term ->
         TacticAst.Discriminate (loc, t)
-    | IDENT "elimType"; t = tactic_term ->
-        TacticAst.ElimType (loc, t)
     | IDENT "elim"; t1 = tactic_term;
       using = OPT [ "using"; using = tactic_term -> using ] ->
         TacticAst.Elim (loc, t1, using)
+    | IDENT "elimType"; t = tactic_term ->
+        TacticAst.ElimType (loc, t)
     | IDENT "exact"; t = tactic_term ->
         TacticAst.Exact (loc, t)
     | IDENT "exists" ->
         TacticAst.Exists loc
-    | IDENT "fold"; kind = reduction_kind; t = tactic_term ->
-        TacticAst.Fold (loc, kind, t)
+    | IDENT "fail" -> TacticAst.Fail loc
+    | IDENT "fold"; kind = reduction_kind; t = tactic_term;
+      p = OPT [ pattern_spec ] ->
+        let p = match p with None -> [], None | Some p -> p in
+        TacticAst.Fold (loc, kind, t, p)
     | IDENT "fourier" ->
         TacticAst.Fourier loc
+    | IDENT "fwd"; t = term ->
+        TacticAst.FwdSimpl (loc, t)
+    | IDENT "generalize"; t = tactic_term;
+       id = OPT [ "as" ; id = IDENT -> id ];
+       p = OPT [ pattern_spec ] ->
+       let p = match p with None -> [], None | Some p -> p in
+       TacticAst.Generalize (loc,t,id,p)
     | IDENT "goal"; n = NUM ->
         TacticAst.Goal (loc, int_of_string n)
+    | IDENT "id" -> TacticAst.IdTac loc
     | IDENT "injection"; t = term ->
         TacticAst.Injection (loc, t)
     | IDENT "intros"; num = OPT [num = int -> num]; idents = OPT ident_list0 ->
@@ -388,34 +407,34 @@ EXTEND
     | IDENT "intro"; ident = OPT IDENT ->
         let idents = match ident with None -> [] | Some id -> [id] in
         TacticAst.Intros (loc, Some 1, idents)
+    | IDENT "lapply"; what = tactic_term; 
+      to_what = OPT [ "to" ; t = tactic_term -> t ];
+      ident = OPT [ "using" ; id = IDENT -> id ] ->
+        TacticAst.LApply (loc, to_what, what, ident)
     | IDENT "left" -> TacticAst.Left loc
     | IDENT "letin"; where = IDENT ; SYMBOL <:unicode<def>> ; t = tactic_term ->
         TacticAst.LetIn (loc, t, where)
     | kind = reduction_kind; p = OPT [ pattern_spec ] ->
         let p = match p with None -> [], None | Some p -> p in
         TacticAst.Reduce (loc, kind, p)
-    | IDENT "generalize"; t = tactic_term; p = OPT [ pattern_spec ] ->
-       let p = match p with None -> [], None | Some p -> p in
-       TacticAst.Generalize (loc,t,p)
     | IDENT "reflexivity" ->
         TacticAst.Reflexivity loc
-    | IDENT "replace"; t1 = tactic_term; "with"; t2 = tactic_term ->
-        TacticAst.Replace (loc, t1, t2)
+    | IDENT "replace"; p = OPT [ pattern_spec ]; "with"; t = tactic_term ->
+        let p = match p with None -> [], None | Some p -> p in
+        TacticAst.Replace (loc, p, t)
     | IDENT "rewrite" ; d = direction; t = term ; p = OPT [ pattern_spec ] ->
         let p = match p with None -> [], None | Some p -> p in
         TacticAst.Rewrite (loc, d, t, p)
-    | IDENT "right" -> TacticAst.Right loc
-    | IDENT "ring" -> TacticAst.Ring loc
-    | IDENT "split" -> TacticAst.Split loc
+    | IDENT "right" ->
+        TacticAst.Right loc
+    | IDENT "ring" ->
+        TacticAst.Ring loc
+    | IDENT "split" ->
+        TacticAst.Split loc
     | IDENT "symmetry" ->
         TacticAst.Symmetry loc
     | IDENT "transitivity"; t = tactic_term ->
         TacticAst.Transitivity (loc, t)
-    | IDENT "fwd"; t = term ->
-        TacticAst.FwdSimpl (loc, t)
-    | IDENT "lapply"; what = tactic_term; 
-      to_what = OPT [ "to" ; t = tactic_term -> t ] ->
-        TacticAst.LApply (loc, to_what, what)
     ]
   ];
   tactical:
@@ -440,8 +459,6 @@ EXTEND
           TacticAst.Tries (loc, tacs)
       | IDENT "try"; tac = NEXT ->
           TacticAst.Try (loc, tac)
-      | IDENT "fail" -> TacticAst.Fail loc
-      | IDENT "id" -> TacticAst.IdTac loc
       | PAREN "("; tac = tactical; PAREN ")" -> tac
       | tac = tactic -> TacticAst.Tactic (loc, tac)
       ]
@@ -553,8 +570,9 @@ EXTEND
   ];
   
   command: [[
-      [ IDENT "set"    ]; n = QSTRING; v = QSTRING ->
+       [ IDENT "set" ]; n = QSTRING; v = QSTRING ->
         TacticAst.Set (loc, n, v)
+    |  [ IDENT "drop" ] -> TacticAst.Drop loc
     | [ IDENT "qed"   ] -> TacticAst.Qed loc
     | flavour = theorem_flavour; name = IDENT; SYMBOL ":"; typ = term;
       body = OPT [ SYMBOL <:unicode<def>> (* ≝ *); body = term -> body ] ->