Better error message.

[helm.git] / helm / software / components / grafite_parser / grafiteParser.ml

diff --git a/helm/software/components/grafite_parser/grafiteParser.ml b/helm/software/components/grafite_parser/grafiteParser.ml
index c9ece6dba31b1aa1b2260aae49d7f6aa8f67869f..0fc42291d318d76408280f51104c11340f7b5f23 100644 (file)
--- 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
@@ -660,6 +660,7 @@ EXTEND
 
     nmacro: [
       [ [ IDENT "ncheck" ]; t = term -> G.NCheck (loc,t)
+      | [ IDENT "screenshot"]; fname = QSTRING -> G.Screenshot (loc, fname)
       ]
     ];
     
@@ -796,12 +797,16 @@ 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 "ninverter"; name = IDENT; IDENT "for" ; indty = tactic_term ;
+      paramspec = OPT inverter_param_list ; 
+      outsort = OPT [ SYMBOL ":" ; outsort = term -> outsort ] -> 
+        G.NInverter (loc,name,indty,paramspec,outsort)
     | NLETCOREC ; defs = let_defs -> 
         nmk_rec_corec `CoInductive defs loc
     | NLETREC ; defs = let_defs -> 
@@ -817,26 +822,15 @@ EXTEND
         in
         G.NObj (loc, N.Inductive (params, ind_types))
     | IDENT "universe"; IDENT "constraint"; u1 = tactic_term; 
-        strict = [ SYMBOL <:unicode<lt>> -> true 
-                 | SYMBOL <:unicode<leq>> -> false ]; 
-        u2 = tactic_term ->
-        let u1 =
-          match u1 with
+        SYMBOL <:unicode<lt>> ; u2 = tactic_term ->
+        let urify = function 
           | CicNotationPt.AttributedTerm (_, CicNotationPt.Sort (`NType i)) ->
               NUri.uri_of_string ("cic:/matita/pts/Type"^i^".univ")
-          | CicNotationPt.AttributedTerm (_, CicNotationPt.Sort (`NCProp i)) ->
-              NUri.uri_of_string ("cic:/matita/pts/CProp"^i^".univ")
-          | _ -> raise (Failure "only a sort can be constrained")
+          | _ -> raise (Failure "only a Type[…] sort can be constrained")
         in
-        let u2 =
-          match u2 with
-          | CicNotationPt.AttributedTerm (_, CicNotationPt.Sort (`NType i)) ->
-              NUri.uri_of_string ("cic:/matita/pts/Type"^i^".univ")
-          | CicNotationPt.AttributedTerm (_, CicNotationPt.Sort (`NCProp i)) ->
-              NUri.uri_of_string ("cic:/matita/pts/CProp"^i^".univ")
-          | _ -> raise (Failure "only a sort can be constrained")
-        in
-         G.NUnivConstraint (loc, strict,u1,u2)
+        let u1 = urify u1 in
+        let u2 = urify u2 in
+         G.NUnivConstraint (loc,u1,u2)
     | IDENT "unification"; IDENT "hint"; n = int; t = tactic_term ->
         G.UnificationHint (loc, t, n)
     | IDENT "ncoercion"; name = IDENT; SYMBOL ":"; ty = term; 
@@ -862,16 +856,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 ->