Viewing file:  macro1.c (3.42 KB) -rw-r--r--
Select action/file-type:
 (+) |  (+) |  (+) | Code (+) | Session (+) |  (+) | SDB (+) |  (+) |  (+) |  (+) |  (+) |  (+) |
/* Copyright (C) 2000 Free Software Foundation, Inc. */
/* { dg-do run } */
/* Tests various macro abuse is correctly expanded. */
#if DEBUG
extern int puts (const char *);
#else
#define puts(X)
#endif
extern void abort (void);
extern int strcmp(const char *s1, const char *s2);
#define err(str) do { puts(str); abort(); } while (0)
#define j(x, y) x + y
#define k(x, y) j(x + 2, y +
#define glue(x, y) x ## y
#define xglue(x, y) glue(x, y)
/* Functions called when macros are left unexpanded. */
int q(int x) {return x + 40;}
int B(int x) {return x + 20;}
int foo(int x) {return x + 10;}
int bar(int x, int y) {return x + y;}
int baz(int x, int y) {return x + y;}
int toupper(int x) {return x + 32;}
int M(int x) {return x * 2;}
int main (int argc, char *argv[])
{
#define q(x) x
if (q(q)(2) != 42)
err ("q");
#define A(x) B(x)
if (A(A(2)) != 42)
err ("A");
#define E(x) A x
#define F (22)
if (E(F) != 42)
err ("E(F)");
#define COMMA ,
#define NASTY(a) j(a 37)
if (NASTY (5 COMMA) != 42)
err ("NASTY");
#define bar(x, y) foo(x(y, 0))
#define apply(x, y) foo(x(y, 22))
#define bam bar
if (bar(bar, 32) != 42) /* foo(bar(32, 0)). */
err ("bar bar");
if (bar(bam, 32) != 42) /* Same. */
err ("bar bam");
if (apply(bar, baz) != 42) /* foo(foo(baz(22, 0))). */
err ("apply bar baz");
/* Taken from glibc. */
#define __tobody(c, f) f (c)
#define toupper(c) __tobody (c, toupper)
if (toupper (10) != 42) /* toupper (10). */
err ("toupper");
/* This tests that M gets expanded the right no. of times. Too many
times, and we get excess "2 +"s and the wrong sum. Derived from
nested stpcpy in dggettext.c. */
#define M(x) 2 + M(x)
#define stpcpy(a) M(a)
if (stpcpy (stpcpy (9)) != 42) /* 2 + M (2 + M (9)) */
err ("stpcpy");
/* Another test derived from nested stpcpy's of dggettext.c. Uses
macro A(x) and function B(x) as defined above. The problem was
the same - excess "1 +"s and the wrong sum. */
#define B(x) 1 + B(x)
#define C(x) A(x)
if (C(B(0)) != 42) /* 1 + B (1 + B (0)) */
err ("C");
/* More tests derived from gcc itself - the use of XEXP and COST.
These first two should both expand to the same thing. */
{
int insn = 6, i = 2, b = 2;
#define XEXP(RTX, N) (RTX * N + 2)
#define PATTERN(INSN) XEXP(INSN, 3)
if (XEXP (PATTERN (insn), i) != 42) /* ((insn * 3 + 2) * i + 2) */
err ("XEXP (PATTERN)");
if (XEXP (XEXP (insn, 3), i) != 42) /* ((insn * 3 + 2) * i + 2) */
err ("XEXP (XEXP)");
#define COST(X) XEXP (XEXP (X, 4), 4)
if (COST (b) != 42) /* ((b * 4 + 2) * 4 + 2) */
err ("COST");
}
/* This tests macro recursion and expand-after-paste. */
#define FORTYTWO "forty"
#define TWO TWO "-two"
if (strcmp (glue(FORTY, TWO), "forty"))
err ("glue");
if (strcmp (xglue(FORTY, TWO), "forty-two"))
err ("xglue");
/* Test ability to call macro over multiple logical lines. */
if (q
(42) != 42
|| q (
42) != 42
|| q (42
) != 42
|| q
(
42
)
!= 42)
err ("q over multiple lines");
/* Corner case. Test that macro expansion is turned off for later
q, when not at start but at end of argument context, and supplied
with the '(' necessary for expansion. */
if (q(1 + q)(1) != 42) /* 1 + q(1) */
err ("Nested q");
/* This looks like it has too many ')', but it hasn't. */
if (k(1, 4) 35) != 42)
err ("k");
/* Phew! */
return 0;
}
|
