X-Git-Url: http://matita.cs.unibo.it/gitweb/?a=blobdiff_plain;f=helm%2Focaml%2Fcic_disambiguation%2FcicTextualParser2.ml;h=1b67821c1ec8630a3d24dd71c7ae4c3e3e2042da;hb=180f30d039f1d2894c6a118ecee5549835127c72;hp=bba6fef7c8d68bf936f20626d04a293ede7e12ee;hpb=3a18a6ebcf71b6c195de316f8df6655580d0a122;p=helm.git

diff --git a/helm/ocaml/cic_disambiguation/cicTextualParser2.ml b/helm/ocaml/cic_disambiguation/cicTextualParser2.ml
index bba6fef7c..1b67821c1 100644
--- a/helm/ocaml/cic_disambiguation/cicTextualParser2.ml
+++ b/helm/ocaml/cic_disambiguation/cicTextualParser2.ml
@@ -53,9 +53,9 @@ let fresh_num_instance =
   else
     (fun () -> 0)
 
-let choice_of_uri uri =
-  let term = CicUtil.term_of_uri uri in
-  (uri, (fun _ _ _ -> term))
+let choice_of_uri suri =
+  let term = CicUtil.term_of_uri (UriManager.uri_of_string suri) in
+  (suri, (fun _ _ _ -> term))
 
 let grammar = Grammar.gcreate cic_lexer
 
@@ -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 ] ];
@@ -312,111 +314,115 @@ EXTEND
       | PAREN "("; t = term; PAREN ")" -> return_term loc t
       ]
     ];
-  tactic_where: [
-    [ where = OPT [ "in"; ident = IDENT -> ident ] -> where ]
-  ];
   tactic_term: [ [ t = term -> t ] ];
   ident_list0: [
     [ PAREN "["; idents = LIST0 IDENT SEP SYMBOL ";"; PAREN "]" -> idents ]
   ];
-  ident_list1: [
-    [ PAREN "["; idents = LIST1 IDENT SEP SYMBOL ";"; PAREN "]" -> idents ]
-  ];
   reduction_kind: [
     [ [ IDENT "reduce" ] -> `Reduce
     | [ IDENT "simplify" ] -> `Simpl
     | [ IDENT "whd" ] -> `Whd 
     | [ IDENT "normalize" ] -> `Normalize ]
   ];
+  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) ]
+  ];
+  direction: [
+    [ IDENT "left" -> `Left
+    | SYMBOL ">" -> `Left
+    | IDENT "right" -> `Right
+    | SYMBOL "<" -> `Right ]
+  ];
   tactic: [
-    [ [ IDENT "absurd" ]; t = tactic_term ->
+    [ IDENT "absurd"; t = tactic_term ->
         TacticAst.Absurd (loc, t)
-    | [ IDENT "apply" ]; t = tactic_term ->
+    | IDENT "apply"; t = tactic_term ->
         TacticAst.Apply (loc, t)
-    | [ IDENT "assumption" ] ->
+    | 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;
-      where = tactic_where ->
+    | 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 "change"; t1 = tactic_term; "with"; t2 = tactic_term; "in";
+      where = pattern_spec ->
         TacticAst.Change (loc, t1, t2, where)
-    (* TODO Change_pattern *)
-    | [ IDENT "contradiction" ] ->
+    | IDENT "compare"; t = tactic_term ->
+        TacticAst.Compare (loc,t)
+    | IDENT "constructor"; n = NUM ->
+        TacticAst.Constructor (loc,int_of_string n)
+    | IDENT "contradiction" ->
         TacticAst.Contradiction loc
-    | [ IDENT "cut" ];
-      t = tactic_term ->
+    | IDENT "cut"; t = tactic_term ->
         TacticAst.Cut (loc, t)
-    | [ IDENT "decompose" ];
-      principles = ident_list1; where = IDENT ->
-        TacticAst.Decompose (loc, where, principles)
-    | [ IDENT "discriminate" ];
-      hyp = IDENT ->
-        TacticAst.Discriminate (loc, hyp)
-    | [ IDENT "elimType" ]; t = tactic_term ->
-        TacticAst.ElimType (loc, t)
-    | [ IDENT "elim" ];
-      t1 = tactic_term;
+    | 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 "elim"; t1 = tactic_term;
       using = OPT [ "using"; using = tactic_term -> using ] ->
         TacticAst.Elim (loc, t1, using)
-    | [ IDENT "exact" ]; t = tactic_term ->
+    | IDENT "elimType"; t = tactic_term ->
+        TacticAst.ElimType (loc, t)
+    | IDENT "exact"; t = tactic_term ->
         TacticAst.Exact (loc, t)
-    | [ IDENT "exists" ] ->
+    | IDENT "exists" ->
         TacticAst.Exists loc
-    | [ IDENT "fold" ];
-      kind = reduction_kind; t = tactic_term ->
+    | IDENT "fold"; kind = reduction_kind; t = tactic_term ->
         TacticAst.Fold (loc, kind, t)
-    | [ IDENT "fourier" ] ->
+    | IDENT "fourier" ->
         TacticAst.Fourier loc
-    | IDENT "goal"; n = NUM -> TacticAst.Goal (loc, int_of_string n)
-    | [ IDENT "injection" ]; ident = IDENT ->
-        TacticAst.Injection (loc, ident)
-    | [ IDENT "intros" ];
-      num = OPT [ num = int -> num ];
-      idents = OPT ident_list0 ->
+    | 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 "goal"; n = NUM ->
+        TacticAst.Goal (loc, int_of_string n)
+    | IDENT "injection"; t = 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" ] ->
-        TacticAst.Intros (loc, Some 1, [])
-    | [ IDENT "left" ] -> TacticAst.Left loc
-    | [ IDENT "letin" ];
-       where = IDENT ; SYMBOL <:unicode<def>> ; t = tactic_term ->
+    | 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 "left" -> TacticAst.Left loc
+    | IDENT "letin"; where = IDENT ; SYMBOL <:unicode<def>> ; t = tactic_term ->
         TacticAst.LetIn (loc, t, where)
-    | kind = reduction_kind;
-      pat = OPT [
-        "in"; pat = [ IDENT "goal" -> `Goal | IDENT "hyp" -> `Everywhere ] ->
-          pat
-      ];
-      terms = LIST0 term SEP SYMBOL "," ->
-        (match (pat, terms) with
-        | None, [] -> TacticAst.Reduce (loc, kind, None)
-        | None, terms -> TacticAst.Reduce (loc, kind, Some (terms, `Goal))
-        | Some pat, [] -> fail loc "Missing term [list]"
-        | Some pat, terms -> TacticAst.Reduce (loc, kind, Some (terms, pat)))
-    | kind = reduction_kind; where = IDENT ; IDENT "at" ; pat = term ->
-        TacticAst.ReduceAt (loc, kind, where, pat)
-    | [ IDENT "reflexivity" ] ->
+    | kind = reduction_kind; p = OPT [ pattern_spec ] ->
+        let p = match p with None -> [], None | Some p -> p in
+        TacticAst.Reduce (loc, kind, p)
+    | IDENT "reflexivity" ->
         TacticAst.Reflexivity loc
-    | [ IDENT "replace" ];
-      t1 = tactic_term; "with"; t2 = tactic_term ->
+    | IDENT "replace"; t1 = tactic_term; "with"; t2 = tactic_term ->
         TacticAst.Replace (loc, t1, t2)
-    | [ IDENT "rewrite" ; IDENT "left" ] ; t = term ->
-        TacticAst.Rewrite (loc,`Left, t, None)
-    | [ IDENT "rewrite" ; IDENT "right" ] ; t = term ->
-        TacticAst.Rewrite (loc,`Right, t, None)
-    (* TODO Replace_pattern *)
-    | [ IDENT "right" ] -> TacticAst.Right loc
-    | [ IDENT "ring" ] -> TacticAst.Ring loc
-    | [ IDENT "split" ] -> TacticAst.Split loc
-    | [ IDENT "symmetry" ] ->
+    | 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 "symmetry" ->
         TacticAst.Symmetry loc
-    | [ IDENT "transitivity" ];
-      t = tactic_term ->
+    | IDENT "transitivity"; t = tactic_term ->
         TacticAst.Transitivity (loc, t)
-    | [ IDENT "fwd" ]; name = IDENT ->
-        TacticAst.FwdSimpl (loc, name)
-    | [ IDENT "lapply" ]; t = term ->
-        TacticAst.LApply (loc, t, [])
     ]
   ];
   tactical:
@@ -683,8 +689,8 @@ module EnvironmentP3 =
       alias: [  (* return a pair <domain_item, codomain_item> from an alias *)
         [ IDENT "alias";
           choice =
-            [ IDENT "id"; id = IDENT; SYMBOL "="; uri = URI ->
-                (Id id, choice_of_uri uri)
+            [ IDENT "id"; id = IDENT; SYMBOL "="; suri = URI ->
+                (Id id, choice_of_uri suri)
             | IDENT "symbol"; symbol = QSTRING;
               PAREN "("; IDENT "instance"; instance = NUM; PAREN ")";
               SYMBOL "="; dsc = QSTRING ->