/* 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;
}