X-Git-Url: http://matita.cs.unibo.it/gitweb/?a=blobdiff_plain;f=helm%2Fsoftware%2Fcomponents%2Fgrafite_parser%2FgrafiteParser.ml;h=d7aae9ee8c1bc9021686b619ae096943a3d4c4a0;hb=964844c87f7c3d7061dfeb7f2d84b6b8bbcdaf13;hp=2fbfe41790e77e0b3c8328fe38df2099bcd10c70;hpb=da5dd88bbcc43d9f4342e47c922b820abf91c92f;p=helm.git

diff --git a/helm/software/components/grafite_parser/grafiteParser.ml b/helm/software/components/grafite_parser/grafiteParser.ml
index 2fbfe4179..d7aae9ee8 100644
--- a/helm/software/components/grafite_parser/grafiteParser.ml
+++ b/helm/software/components/grafite_parser/grafiteParser.ml
@@ -95,7 +95,7 @@ let mk_rec_corec ind_kind defs loc =
    else
     `MutualDefinition
   in
-   (loc, N.Theorem(flavour, name, ty, Some (N.LetRec (ind_kind, defs, body))))
+   (loc, N.Theorem(flavour, name, ty, Some (N.LetRec (ind_kind, defs, body)), `Regular))
 
 let nmk_rec_corec ind_kind defs loc = 
  let loc,t = mk_rec_corec ind_kind defs loc in
@@ -128,6 +128,11 @@ let npunct_of_punct = function
   | G.Semicolon loc -> G.NSemicolon loc
   | G.Dot loc -> G.NDot loc
 ;;
+let cons_ntac t p = 
+  match t with
+  | G.NTactic(loc,[t]) -> G.NTactic(loc,[t;p])
+  | x -> x
+;;
 
 type by_continuation =
    BYC_done
@@ -237,7 +242,8 @@ EXTEND
   ];
   using: [ [ using = OPT [ IDENT "using"; t = tactic_term -> t ] -> using ] ];
   ntactic: [
-    [ IDENT "napply"; t = tactic_term -> G.NApply (loc, t)
+    [ IDENT "napply"; t = tactic_term -> G.NTactic(loc,[G.NApply (loc, t)])
+    | IDENT "napplyS"; t = tactic_term -> G.NTactic(loc,[G.NSmartApply(loc, t)])
     | IDENT "nassert";
        seqs = LIST0 [
         hyps = LIST0
@@ -247,37 +253,73 @@ EXTEND
             id,`Def (bo,ty)];
         SYMBOL <:unicode<vdash>>;
         concl = tactic_term -> (List.rev hyps,concl) ] ->
-         G.NAssert (loc, seqs)
-    | IDENT "nauto"; params = auto_params -> G.NAuto (loc, params)
+         G.NTactic(loc,[G.NAssert (loc, seqs)])
+    | IDENT "nauto"; params = auto_params -> 
+        G.NTactic(loc,[G.NAuto (loc, params)])
+    | SYMBOL "/"; num = OPT NUMBER ; 
+       params = nauto_params; SYMBOL "/" ; 
+       just = OPT [ IDENT "by"; by = 
+         [ univ = tactic_term_list1 -> `Univ univ
+         | SYMBOL "{"; SYMBOL "}" -> `EmptyUniv
+         | SYMBOL "_" -> `Trace ] -> by ] ->
+       let depth = match num with Some n -> n | None -> "1" in
+       (match just with
+       | None -> 
+	   G.NTactic(loc,
+            [G.NAuto(loc,(None,["slir","";"depth",depth]@params))])
+       | Some (`Univ univ) ->
+	   G.NTactic(loc,
+            [G.NAuto(loc,(Some univ,["slir","";"depth",depth]@params))])
+       | Some `EmptyUniv ->
+	   G.NTactic(loc,
+            [G.NAuto(loc,(Some [],["slir","";"depth",depth]@params))])
+       | Some `Trace ->
+	   G.NMacro(loc,
+             G.NAutoInteractive (loc, (None,["slir","";"depth",depth]@params))))
+    | IDENT "nintros" -> G.NMacro (loc, G.NIntroGuess loc)
+    | IDENT "ncheck"; t = term -> G.NMacro(loc,G.NCheck (loc,t))
+    | IDENT "screenshot"; fname = QSTRING -> 
+        G.NMacro(loc,G.Screenshot (loc, fname))
     | IDENT "ncases"; what = tactic_term ; where = pattern_spec ->
-        G.NCases (loc, what, where)
+        G.NTactic(loc,[G.NCases (loc, what, where)])
     | IDENT "nchange"; what = pattern_spec; "with"; with_what = tactic_term -> 
-        G.NChange (loc, what, with_what)
+        G.NTactic(loc,[G.NChange (loc, what, with_what)])
     | SYMBOL "@"; num = OPT NUMBER; l = LIST0 tactic_term -> 
-        G.NConstructor (loc,
-           (match num with None -> None | Some x -> Some (int_of_string x)),l)
-    | IDENT "ncut"; t = tactic_term -> G.NCut (loc, t)
+        G.NTactic(loc,[G.NConstructor (loc, (match num with None -> None | Some x -> Some (int_of_string x)),l)])
+    | IDENT "ncut"; t = tactic_term -> G.NTactic(loc,[G.NCut (loc, t)])
+(*  | IDENT "ndiscriminate"; t = tactic_term -> G.NDiscriminate (loc, t)
+    | IDENT "nsubst"; t = tactic_term -> G.NSubst (loc, t) *)
+    | IDENT "ndestruct" -> G.NTactic(loc,[G.NDestruct loc])
     | IDENT "nelim"; what = tactic_term ; where = pattern_spec ->
-        G.NElim (loc, what, where)
+        G.NTactic(loc,[G.NElim (loc, what, where)])
     | IDENT "ngeneralize"; p=pattern_spec ->
-        G.NGeneralize (loc, p)
-    | IDENT "nlapply"; t = tactic_term -> G.NLApply (loc, t)
+        G.NTactic(loc,[G.NGeneralize (loc, p)])
+    | IDENT "ninversion"; what = tactic_term ; where = pattern_spec ->
+        G.NTactic(loc,[G.NInversion (loc, what, where)])
+    | IDENT "nlapply"; t = tactic_term -> G.NTactic(loc,[G.NLApply (loc, t)])
     | IDENT "nletin"; name = IDENT ; SYMBOL <:unicode<def>> ; t = tactic_term;
         where = pattern_spec ->
-        G.NLetIn (loc,where,t,name)
+        G.NTactic(loc,[G.NLetIn (loc,where,t,name)])
     | kind = nreduction_kind; p = pattern_spec ->
-        G.NReduce (loc, kind, p)
+        G.NTactic(loc,[G.NReduce (loc, kind, p)])
     | IDENT "nrewrite"; dir = direction; what = tactic_term ; where = pattern_spec ->	
-        G.NRewrite (loc, dir, what, where)
-    | IDENT "ntry"; tac = SELF -> G.NTry (loc,tac)
-    | IDENT "nrepeat"; tac = SELF -> G.NRepeat (loc,tac)
-    | LPAREN; l = LIST1 SELF; RPAREN -> G.NBlock (loc,l)
-    | IDENT "nassumption" -> G.NAssumption loc
-    | SYMBOL "#"; n=IDENT -> G.NIntro (loc,n)
-    | SYMBOL "#"; SYMBOL "_" -> G.NIntro (loc,"_")
-    | SYMBOL "*" -> G.NCase1 (loc,"_")
-    | SYMBOL "*"; n=IDENT ->
-        G.NCase1 (loc,n)
+        G.NTactic(loc,[G.NRewrite (loc, dir, what, where)])
+    | IDENT "ntry"; tac = SELF -> 
+        let tac = match tac with G.NTactic(_,[t]) -> t | _ -> assert false in
+        G.NTactic(loc,[ G.NTry (loc,tac)])
+    | IDENT "nrepeat"; tac = SELF -> 
+        let tac = match tac with G.NTactic(_,[t]) -> t | _ -> assert false in
+        G.NTactic(loc,[ G.NRepeat (loc,tac)])
+    | LPAREN; l = LIST1 SELF; RPAREN -> 
+        let l = 
+          List.flatten 
+            (List.map (function G.NTactic(_,t) -> t | _ -> assert false) l) in
+        G.NTactic(loc,[G.NBlock (loc,l)])
+    | IDENT "nassumption" -> G.NTactic(loc,[ G.NAssumption loc])
+    | SYMBOL "#"; ns=LIST0 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)])
     ]
   ];
   tactic: [
@@ -413,7 +455,7 @@ EXTEND
     | "let" ; id1 = IDENT ; SYMBOL ":" ; t1 = tactic_term ;
       IDENT "such" ; IDENT "that" ; t2=tactic_term ; LPAREN ; 
       id2 = IDENT ; RPAREN -> 
-        G.ExistsElim (loc, `Auto ([],[]), id1, t1, id2, t2)
+        G.ExistsElim (loc, `Auto (None,[]), id1, t1, id2, t2)
     | just =
        [ IDENT "using"; t=tactic_term -> `Term t
        | params = auto_params -> `Auto params] ;
@@ -475,6 +517,10 @@ EXTEND
 ];
   auto_fixed_param: [
    [ IDENT "paramodulation"
+   | IDENT "demod"
+   | IDENT "fast_paramod"
+   | IDENT "paramod"
+   | IDENT "slir"
    | IDENT "depth"
    | IDENT "width"
    | IDENT "size"
@@ -485,16 +531,26 @@ EXTEND
    ]
 ];
   auto_params: [
-   [ params =
+    [ params = 
       LIST0 [
          i = auto_fixed_param -> i,""
        | i = auto_fixed_param ; SYMBOL "="; v = [ v = int ->
               string_of_int v | v = IDENT -> v ] -> i,v ]; 
-      tl = OPT [ IDENT "by"; tl = tactic_term_list1 -> tl] ->
-      (match tl with Some l -> l | None -> []),
+      tl = OPT [ IDENT "by"; tl = tactic_term_list1 -> tl] -> tl,
+      (* (match tl with Some l -> l | None -> []), *)
       params
    ]
 ];
+  nauto_params: [
+    [ params = 
+      LIST0 [
+         i = auto_fixed_param -> i,""
+       | i = auto_fixed_param ; SYMBOL "="; v = [ v = int ->
+              string_of_int v | v = IDENT -> v ] -> i,v ] ->
+      params
+   ]
+];
+
   inline_params:[
    [ params = LIST0 
       [ IDENT "prefix"; SYMBOL "="; prefix = QSTRING -> G.IPPrefix prefix  
@@ -566,6 +622,7 @@ EXTEND
       | SYMBOL "|" -> G.NShift loc
       | i = LIST1 int SEP SYMBOL ","; SYMBOL ":" -> G.NPos (loc, i)
       | SYMBOL "*"; SYMBOL ":" -> G.NWildcard loc
+      | name = IDENT; SYMBOL ":" -> G.NPosbyname (loc, name)
       | SYMBOL "]" -> G.NMerge loc
       | SYMBOL ";" -> G.NSemicolon loc
       | SYMBOL "." -> G.NDot loc
@@ -658,12 +715,6 @@ EXTEND
         (params,name,typ,fields)
     ] ];
 
-    nmacro: [
-      [ [ IDENT "ncheck" ]; t = term -> G.NCheck (loc,t)
-      | [ IDENT "screenshot"]; fname = QSTRING -> G.Screenshot (loc, fname)
-      ]
-    ];
-    
     macro: [
       [ [ IDENT "check"   ]; t = term ->
           G.Check (loc, t)
@@ -797,12 +848,13 @@ EXTEND
       IDENT "nqed" -> G.NQed loc
     | 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))
+        G.NObj (loc, N.Theorem (nflavour, name, typ, body,`Regular))
     | nflavour = ntheorem_flavour; name = IDENT; SYMBOL <:unicode<def>> (* ≝ *);
       body = term ->
-        G.NObj (loc, N.Theorem (nflavour, name, N.Implicit `JustOne, Some body))
+        G.NObj (loc, N.Theorem (nflavour, name, N.Implicit `JustOne, Some body,`Regular))
     | IDENT "naxiom"; name = IDENT; SYMBOL ":"; typ = term ->
-        G.NObj (loc, N.Theorem (`Axiom, name, typ, None))
+        G.NObj (loc, N.Theorem (`Axiom, name, typ, None, `Regular))
+    | IDENT "ndiscriminator" ; indty = tactic_term -> G.NDiscriminator (loc,indty)
     | IDENT "ninverter"; name = IDENT; IDENT "for" ; indty = tactic_term ;
       paramspec = OPT inverter_param_list ; 
       outsort = OPT [ SYMBOL ":" ; outsort = term -> outsort ] -> 
@@ -856,16 +908,16 @@ EXTEND
       typ = term; SYMBOL <:unicode<def>> ; newname = IDENT ->
         G.Obj (loc, 
           N.Theorem 
-            (`Variant,name,typ,Some (N.Ident (newname, None))))
+            (`Variant,name,typ,Some (N.Ident (newname, None)), `Regular))
     | flavour = theorem_flavour; name = IDENT; SYMBOL ":"; typ = term;
       body = OPT [ SYMBOL <:unicode<def>> (* ≝ *); body = term -> body ] ->
-        G.Obj (loc, N.Theorem (flavour, name, typ, body))
+        G.Obj (loc, N.Theorem (flavour, name, typ, body,`Regular))
     | flavour = theorem_flavour; name = IDENT; SYMBOL <:unicode<def>> (* ≝ *);
       body = term ->
         G.Obj (loc,
-          N.Theorem (flavour, name, N.Implicit `JustOne, Some body))
+          N.Theorem (flavour, name, N.Implicit `JustOne, Some body,`Regular))
     | IDENT "axiom"; name = IDENT; SYMBOL ":"; typ = term ->
-        G.Obj (loc, N.Theorem (`Axiom, name, typ, None))
+        G.Obj (loc, N.Theorem (`Axiom, name, typ, None, `Regular))
     | LETCOREC ; defs = let_defs -> 
         mk_rec_corec `CoInductive defs loc
     | LETREC ; defs = let_defs -> 
@@ -927,10 +979,13 @@ EXTEND
     | tac = atomic_tactical LEVEL "loops"; punct = punctuation_tactical ->
         G.Tactic (loc, Some tac, punct)
     | punct = punctuation_tactical -> G.Tactic (loc, None, punct)
-    | tac = ntactic; SYMBOL "#" ; SYMBOL "#" ; punct = punctuation_tactical ->
-        G.NTactic (loc, [tac; npunct_of_punct punct])
+    | tac = ntactic; OPT [ SYMBOL "#" ; SYMBOL "#" ] ; 
+      punct = punctuation_tactical ->
+        cons_ntac tac (npunct_of_punct punct)
+(*
     | tac = ntactic; punct = punctuation_tactical ->
-        G.NTactic (loc, [tac; npunct_of_punct punct])
+        cons_ntac tac (npunct_of_punct punct)
+*)
     | SYMBOL "#" ; SYMBOL "#" ; punct = npunctuation_tactical ->
         G.NTactic (loc, [punct])
     | tac = non_punctuation_tactical; punct = punctuation_tactical ->
@@ -942,7 +997,6 @@ EXTEND
         punct = punctuation_tactical ->
           G.NTactic (loc, [nnon_punct_of_punct tac; npunct_of_punct punct])
     | mac = macro; SYMBOL "." -> G.Macro (loc, mac)
-    | mac = nmacro; SYMBOL "." -> G.NMacro (loc, mac)
     ]
   ];
   comment: [