diff options
Diffstat (limited to 'gcc-4.9/gcc/testsuite/gcc.dg/cpp/macro1.c')
| -rw-r--r-- | gcc-4.9/gcc/testsuite/gcc.dg/cpp/macro1.c | 128 |
1 files changed, 128 insertions, 0 deletions
diff --git a/gcc-4.9/gcc/testsuite/gcc.dg/cpp/macro1.c b/gcc-4.9/gcc/testsuite/gcc.dg/cpp/macro1.c new file mode 100644 index 000000000..e7235f577 --- /dev/null +++ b/gcc-4.9/gcc/testsuite/gcc.dg/cpp/macro1.c @@ -0,0 +1,128 @@ +/* Copyright (C) 2000 Free Software Foundation, Inc. */ + +/* { dg-do run } */ + +/* Tests various macro abuse is correctly expanded. */ + +extern int puts (const char *); +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; +} |