X-Git-Url: http://matita.cs.unibo.it/gitweb/?a=blobdiff_plain;f=helm%2Focaml%2Fcic_disambiguation%2FcicTextualParser2.ml;h=25c15c575f9c763e33962106b2912456ed3554d1;hb=7793efe5c9ac8ff4c71579e6fc0aa4764dd2bc9e;hp=efacfccd762d6ef8102c503e3761587924f417a2;hpb=60033ee6d57f253ce1b90e3758a69b85d13f6a41;p=helm.git

diff --git a/helm/ocaml/cic_disambiguation/cicTextualParser2.ml b/helm/ocaml/cic_disambiguation/cicTextualParser2.ml
index efacfccd7..25c15c575 100644
--- a/helm/ocaml/cic_disambiguation/cicTextualParser2.ml
+++ b/helm/ocaml/cic_disambiguation/cicTextualParser2.ml
@@ -181,7 +181,7 @@ EXTEND
     [ defs = LIST1 [
         name = IDENT;
         args = LIST1 [arg = arg -> arg];
-        index_name = OPT [ IDENT "on"; idx = IDENT -> idx ];
+        index_name = OPT [ "on"; idx = IDENT -> idx ];
         ty = OPT [ SYMBOL ":" ; t = term -> t ];
         SYMBOL <:unicode<def>> (* ≝ *);
         t1 = term ->
@@ -318,28 +318,54 @@ EXTEND
   ident_list0: [
     [ PAREN "["; idents = LIST0 IDENT SEP SYMBOL ";"; PAREN "]" -> idents ]
   ];
+  tactic_term_list1: [
+    [ tactic_terms = LIST1 tactic_term SEP SYMBOL "," -> tactic_terms ]
+  ];
   reduction_kind: [
     [ [ IDENT "reduce" ] -> `Reduce
     | [ IDENT "simplify" ] -> `Simpl
     | [ IDENT "whd" ] -> `Whd 
     | [ IDENT "normalize" ] -> `Normalize ]
   ];
+  sequent_pattern_spec : [
+   [ hyp_paths =
+      LIST0
+       [ id = IDENT ;
+         path = OPT [SYMBOL ":" ; path = term -> path ] ->
+         (id,match path with Some p -> p | None -> CicAst.UserInput) ]
+       SEP SYMBOL ";";
+     goal_path = OPT [ SYMBOL <:unicode<vdash>>; term = term -> term ] ->
+      let goal_path =
+       match goal_path with
+          None -> CicAst.UserInput
+        | Some goal_path -> goal_path
+      in
+       hyp_paths,goal_path
+   ]
+  ];
   pattern_spec: [
-    [ "in";
-      hyp_paths =
-       LIST0
-        [ id = IDENT ;
-          path = OPT [SYMBOL ":" ; path = term -> path ] ->
-          (id,match path with Some p -> p | None -> CicAst.UserInput) ]
-        SEP SYMBOL ";";
-      goal_path = OPT [ SYMBOL <:unicode<vdash>>; term = term -> term ] ->
-        (hyp_paths, goal_path) ]
+    [ res = OPT [
+       "in";
+       wanted_and_sps =
+        [ "match" ; wanted = term ;
+          sps = OPT [ "in"; sps = sequent_pattern_spec -> sps ] ->
+           Some wanted,sps
+        | sps = sequent_pattern_spec ->
+           None,Some sps
+        ] ->
+         let wanted,hyp_paths,goal_path =
+          match wanted_and_sps with
+             wanted,None -> wanted, [], CicAst.UserInput
+           | wanted,Some (hyp_paths,goal_path) -> wanted,hyp_paths,goal_path
+         in
+          wanted, hyp_paths, goal_path ] ->
+      match res with
+         None -> None,[],CicAst.UserInput
+       | Some ps -> ps]
   ];
   direction: [
-    [ IDENT "left" -> `Left
-    | SYMBOL ">" -> `Left
-    | IDENT "right" -> `Right
-    | SYMBOL "<" -> `Right ]
+    [ SYMBOL ">" -> `LeftToRight
+    | SYMBOL "<" -> `RightToLeft ]
   ];
   tactic: [
     [ IDENT "absurd"; t = tactic_term ->
@@ -350,11 +376,14 @@ EXTEND
         TacticAst.Assumption loc
     | IDENT "auto";
       depth = OPT [ IDENT "depth"; SYMBOL "="; i = NUM -> int_of_string i ];
-      width = OPT [ IDENT "depth"; SYMBOL "="; i = NUM -> int_of_string i ] -> 
+      width = OPT [ IDENT "width"; SYMBOL "="; i = NUM -> int_of_string i ] -> 
           TacticAst.Auto (loc,depth,width)
-    | IDENT "change"; t1 = tactic_term; "with"; t2 = tactic_term; "in";
-      where = pattern_spec ->
-        TacticAst.Change (loc, t1, t2, where)
+    | IDENT "clear"; id = IDENT ->
+        TacticAst.Clear (loc,id)
+    | IDENT "clearbody"; id = IDENT ->
+        TacticAst.ClearBody (loc,id)
+    | IDENT "change"; what = pattern_spec; "with"; t = tactic_term ->
+        TacticAst.Change (loc, what, t)
     | IDENT "compare"; t = tactic_term ->
         TacticAst.Compare (loc,t)
     | IDENT "constructor"; n = NUM ->
@@ -365,7 +394,7 @@ EXTEND
         TacticAst.Cut (loc, ident, t)
     | IDENT "decide"; IDENT "equality" ->
         TacticAst.DecideEquality loc
-    | IDENT "decompose"; where = term ->
+    | IDENT "decompose"; where = tactic_term ->
         TacticAst.Decompose (loc, where)
     | IDENT "discriminate"; t = tactic_term ->
         TacticAst.Discriminate (loc, t)
@@ -378,41 +407,57 @@ EXTEND
         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 = pattern_spec ->
+       let (pt,_,_) = p in
+        if pt <> None then
+         raise
+          (Parse_error
+            (loc,"the pattern cannot specify the term to replace, only its paths in the hypotheses and in the conclusion"))
+        else
+         TacticAst.Fold (loc, kind, t, p)
     | IDENT "fourier" ->
         TacticAst.Fourier loc
-    | IDENT "fwd"; t = term ->
-        TacticAst.FwdSimpl (loc, t)
-    | 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 "fwd"; hyp = IDENT; idents = OPT ident_list0 ->
+        let idents = match idents with None -> [] | Some idents -> idents in
+        TacticAst.FwdSimpl (loc, hyp, idents)
+    | IDENT "generalize"; p=pattern_spec; id = OPT ["as" ; id = IDENT -> id] ->
+       TacticAst.Generalize (loc,p,id)
     | IDENT "goal"; n = NUM ->
         TacticAst.Goal (loc, int_of_string n)
-    | IDENT "injection"; t = term ->
+    | IDENT "id" -> TacticAst.IdTac loc
+    | IDENT "injection"; t = tactic_term ->
         TacticAst.Injection (loc, t)
-    | IDENT "intros"; num = OPT [num = int -> num]; idents = OPT ident_list0 ->
-        let idents = match idents with None -> [] | Some idents -> idents in
-        TacticAst.Intros (loc, num, idents)
     | 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 ] ->
-        TacticAst.LApply (loc, to_what, what)
+    | IDENT "intros"; num = OPT [num = int -> num]; idents = OPT ident_list0 ->
+        let idents = match idents with None -> [] | Some idents -> idents in
+        TacticAst.Intros (loc, num, idents)
+    | IDENT "lapply"; 
+      depth = OPT [ IDENT "depth"; SYMBOL "="; i = NUM -> int_of_string i ];
+      what = tactic_term; 
+      to_what = OPT [ "to" ; t = tactic_term_list1 -> t ];
+      ident = OPT [ "using" ; ident = IDENT -> ident ] ->
+        let to_what = match to_what with None -> [] | Some to_what -> to_what in
+        TacticAst.LApply (loc, depth, 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
+    | kind = reduction_kind; p = pattern_spec ->
         TacticAst.Reduce (loc, kind, p)
     | IDENT "reflexivity" ->
         TacticAst.Reflexivity loc
-    | IDENT "replace"; t1 = tactic_term; "with"; t2 = tactic_term ->
-        TacticAst.Replace (loc, t1, t2)
-    | 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 "replace"; p = pattern_spec; "with"; t = tactic_term ->
+        TacticAst.Replace (loc, p, t)
+    | IDENT "rewrite" ; d = direction; t = tactic_term ; p = pattern_spec ->
+       let (pt,_,_) = p in
+        if pt <> None then
+         raise
+          (Parse_error
+            (loc,"the pattern cannot specify the term to rewrite, only its paths in the hypotheses and in the conclusion"))
+        else
+         TacticAst.Rewrite (loc, d, t, p)
     | IDENT "right" ->
         TacticAst.Right loc
     | IDENT "ring" ->
@@ -432,7 +477,7 @@ EXTEND
       ]
     | "then" NONA
       [ tac = tactical;
-        PAREN "["; tacs = LIST0 tactical SEP SYMBOL ";"; PAREN "]" ->
+        PAREN "["; tacs = LIST0 tactical SEP SYMBOL "|"; PAREN "]" ->
           (TacticAst.Then (loc, tac, tacs))
       ]
     | "loops" RIGHTA
@@ -447,8 +492,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)
       ]
@@ -560,8 +603,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 ] ->