[Top][All Lists]
[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]
proposed patch: verify: new macro verify_expr; verify_true deprecated
From: |
Paul Eggert |
Subject: |
proposed patch: verify: new macro verify_expr; verify_true deprecated |
Date: |
Mon, 13 Jun 2011 19:10:16 -0700 |
User-agent: |
Mozilla/5.0 (X11; U; Linux i686; en-US; rv:1.9.2.17) Gecko/20110516 Thunderbird/3.1.10 |
It's relatively common to want to verify a property at compile-time
inside an expression, when using a macro. For example, in Emacs,
I might want to do something like this:
#define ENCODE_CHAR(charset, c) \
(verify_true (sizeof (c) <= sizeof (int)), \
[some expression that assumes sizeof (c) <= sizeof (int)])
Unfortunately this elicits the following diagnostic with GCC 4.6.0:
charset.c:1767:14: error: left-hand operand of comma expression has no effect
[-Werror=unused-value]
So I am thinking of a new macro verify_expr (R, E), which verifies R
at compile-time and then yields the value of E. Then the Emacs macro
can be written this way:
#define ENCODE_CHAR(charset, c) \
verify_expr (sizeof (c) <= sizeof (int), \
[some expression that assumes sizeof (c) <= sizeof (int)])
The new macro verify_expr supersedes the existing verify_true macro,
which would be deprecated; old uses of verify_true (V) can be
rewritten as verify_expr (V, 1); better yet, since many existing uses
of verify_true are part of comma expressions, the containing comma
expression can be rewritten as above.
Here's a proposed patch to implement this. Comments are welcome.
verify: new macro verify_expr; verify_true deprecated
* NEWS: Mention this.
* doc/verify.texi (Compile-time Assertions): Document this.
* lib/verify.h (verify_true): Deprecate.
(verify_expr): New macro.
* tests/test-verify.c (function): Test verify_expr, not verify_true.
diff --git a/NEWS b/NEWS
index a87c3a4..a8a8c4e 100644
--- a/NEWS
+++ b/NEWS
@@ -12,6 +12,9 @@ User visible incompatible changes
Date Modules Changes
+2011-06-13 verify verify_true (V) is deprecated; please use
+ verify_expr (V, 1) instead.
+
2011-06-05 ansi-c++-opt When a C++ compiler is not found, the variable CXX
is now set to "no", not to ":".
diff --git a/doc/verify.texi b/doc/verify.texi
index f95279d..5fa8b14 100644
--- a/doc/verify.texi
+++ b/doc/verify.texi
@@ -14,7 +14,7 @@
@cindex assertion
@findex verify
address@hidden verify_true
address@hidden verify_expr
The @samp{verify} module supports compile-time tests, as opposed to
the standard @code{assert} macro which supports only runtime tests.
@@ -22,31 +22,36 @@ Since the tests occur at compile-time, they are more
reliable, and
they require no runtime overhead.
This module provides a header file @file{verify.h} that defines two
-macros: @code{verify (@var{EXPRESSION})} and @code{verify_true
-(@var{EXPRESSION})}. Both accept an integer constant expression
-argument and verify that it is nonzero. If not, a compile-time error
+macros: @code{verify (@var{V})} and @code{verify_expr
+(@var{V}, @var{EXPR})}. Both accept an integer constant expression
+argument @var{V} and verify that it is nonzero. If not, a compile-time error
results.
address@hidden (@var{EXPRESSION});} is a declaration; it can occur
-outside of functions. In contrast, @code{verify_true
-(@var{EXPRESSION})} is an integer constant expression that always
-evaluates to 1; it can be used in macros that expand to
-expressions.
-
address@hidden should be an integer constant expression in the sense
address@hidden (@var{V});} is a declaration; it can occur outside of
+functions. In contrast, @code{verify_expr (@var{V}, @var{EXPR})} is
+an expression that returns the value of @var{EXPR}; it can be used in
+macros that expand to expressions. If @var{EXPR} is an integer
+constant expression, then @code{verify_expr (@var{V}, @var{EXPR})} is
+also an integer constant expression. Although @var{EXPR} and
address@hidden (@var{V}, @var{EXPR})}@ are guaranteed to have the
+same side effects and value and type (after integer promotion), they
+need not have the same type if @var{EXPR}'s type is an integer that is
+narrower than @code{int} or @code{unsigned int}.
+
address@hidden should be an integer constant expression in the sense
of the C standard. Its leaf operands should be integer, enumeration,
or character constants; or @code{sizeof} expressions that return
constants; or floating constants that are the immediate operands of
-casts. Outside a @code{sizeof} subexpression, @var{EXPRESSION} should
+casts. Outside a @code{sizeof} subexpression, @var{V} should
not contain any assignments, function calls, comma operators, casts to
non-integer types, or subexpressions whose values are outside the
-representable ranges for their types. If @var{EXPRESSION} is not an
+representable ranges for their types. If @var{V} is not an
integer constant expression, then a compiler might reject a usage like
address@hidden (@var{EXPRESSION});} even when @var{EXPRESSION} is
address@hidden (@var{V});} even when @var{V} is
nonzero.
Although the standard @code{assert} macro is a runtime test, draft C1X
-specifies a builtin @code{_Static_assert (@var{EXPRESSION},
+specifies a builtin @code{_Static_assert (@var{V},
@var{STRING-LITERAL})}, its @file{assert.h} header has a similar macro
named @code{static_assert}, and draft C++0X has a similar
@code{static_assert} builtin. These draft builtins and macros differ
@@ -55,7 +60,7 @@ within a @code{struct} or @code{union} specifier, in place of
an
ordinary member declaration. Second, they require the programmer to
specify a compile-time diagnostic as a string literal.
-Here are some example uses of @code{verify} and @code{verify_true}.
+Here are some example uses of @code{verify} and @code{verify_expr}.
@example
#include <verify.h>
@@ -76,16 +81,10 @@ verify ((time_t) -1 < 0);
verify (~ (time_t) -1 == 0);
/* Return the maximum value of the integer type T,
- verifying that T is an unsigned integer type. */
-#define MAX_UNSIGNED_VAL_WITH_COMMA(t) \
- (verify_true (0 < (T) -1), (T) -1)
-
-/* Same as MAX_UNSIGNED_VAL_WITH_COMMA,
- but expand to an integer constant expression,
- which cannot contain a comma operator.
- The cast to (T) is outside the conditional expression
+ verifying that T is an unsigned integer type.
+ The cast to (T) is outside the call to verify_expr
so that the result is of type T
even when T is narrower than unsigned int. */
-#define MAX_UNSIGNED_VAL(t) ((T) \
- ((T) (verify_true (0 < (T) -1) ? -1 : 0))
+#define MAX_UNSIGNED_VAL(t) \
+ ((T) verify_expr (0 < (T) -1, -1))
@end example
diff --git a/lib/verify.h b/lib/verify.h
index c6d30a3..9a8caad 100644
--- a/lib/verify.h
+++ b/lib/verify.h
@@ -221,10 +221,18 @@ template <int w>
contexts, e.g., the top level. */
/* Verify requirement R at compile-time, as an integer constant expression.
- Return 1. */
+ Return 1. This is equivalent to verify_expr (R, 1).
+
+ verify_true is obsolescent; please use verify_expr instead. */
# define verify_true(R) _GL_VERIFY_TRUE (R, "verify_true (" #R ")")
+/* Verify requirement R at compile-time. Return the value of the
+ expression E. */
+
+# define verify_expr(R, E) \
+ (_GL_VERIFY_TRUE (R, "verify_expr (" #R ", " #E ")") ? (E) : (E))
+
/* Verify requirement R at compile-time, as a declaration without a
trailing ';'. */
diff --git a/tests/test-verify.c b/tests/test-verify.c
index 512c021..22544b8 100644
--- a/tests/test-verify.c
+++ b/tests/test-verify.c
@@ -39,7 +39,7 @@ verify (1 == 1); verify (1 == 1); /* should be ok */
enum
{
- item = verify_true (1 == 1) * 0 + 17 /* should be ok */
+ item = verify_expr (1 == 1, 1) * 0 + 17 /* should be ok */
};
static int
@@ -55,9 +55,9 @@ function (int n)
verify (1 == 1); verify (1 == 1); /* should be ok */
if (n)
- return ((void) verify_true (1 == 1), verify_true (1 == 1) + 7); /* should
be ok */
+ return ((void) verify_expr (1 == 1, 1), verify_expr (1 == 1, 8)); /*
should be ok */
#if EXP_FAIL == 5
- return (verify_true (1 == 2), 5); /* should give ERROR */
+ return verify_expr (1 == 2, 5); /* should give ERROR */
#endif
return 0;
}
- proposed patch: verify: new macro verify_expr; verify_true deprecated,
Paul Eggert <=