(enum sharp_token_type): New type.

(stringify, raw_before, raw_after): Use this type instead of char.
(collect_expansion, dump_single_macro): Keep track of white space
after # and around ## tokens, since the C Standard requires a
diagnostic if the white space doesn't match during a redefinition.
(sharp_token, sharp_sharp_token): Labels renamed from hash_token and
hash_hash_token for naming consistency.

git-svn-id: svn+ssh://gcc.gnu.org/svn/gcc/trunk@9036 138bc75d-0d04-0410-961f-82ee72b054a4

diff --git a/gcc/cccp.c b/gcc/cccp.c
index d63bba9..3121c54 100644 (file)
--- a/gcc/cccp.c
+++ b/gcc/cccp.c
@@ -677,6 +677,16 @@ struct macrodef
 static struct macrodef create_definition ();
 
 \f
+enum sharp_token_type {
+  NO_SHARP_TOKEN,              /* token not present */
+
+  SHARP_TOKEN = '#',           /* token spelled with # only */
+  WHITE_SHARP_TOKEN,           /* token spelled with # and white space */
+
+  PERCENT_COLON_TOKEN = '%',   /* token spelled with %: only */
+  WHITE_PERCENT_COLON_TOKEN    /* token spelled with %: and white space */
+};
+
 /* Structure allocated for every #define.  For a simple replacement
    such as
        #define foo bar ,
@@ -711,12 +721,9 @@ struct definition {
   struct reflist {
     struct reflist *next;
 
-    /* The following three members have the value '#' if spelled with "#",
-       and '%' if spelled with "%:".  */
-    char stringify;            /* nonzero if this arg was preceded by a
-                                  # operator. */
-    char raw_before;           /* Nonzero if a ## operator before arg. */
-    char raw_after;            /* Nonzero if a ## operator after arg. */
+    enum sharp_token_type stringify;   /* set if a # operator before arg */
+    enum sharp_token_type raw_before;  /* set if a ## operator before arg */
+    enum sharp_token_type raw_after;   /* set if a ## operator after arg */
 
     char rest_args;            /* Nonzero if this arg. absorbs the rest */
     int nchars;                        /* Number of literal chars to copy before
@@ -5757,9 +5764,9 @@ collect_expansion (buf, end, nargs, arglist)
   U_CHAR *concat = 0;
   /* Pointer to first nonspace after last single-# seen.  */
   U_CHAR *stringify = 0;
-  /* How those tokens were spelled: 0, '#', or '%' (meaning %:).  */
-  char concat_spelling = 0;
-  char stringify_spelling = 0;
+  /* How those tokens were spelled.  */
+  enum sharp_token_type concat_sharp_token_type = NO_SHARP_TOKEN;
+  enum sharp_token_type stringify_sharp_token_type = NO_SHARP_TOKEN;
   int maxsize;
   int expected_delimiter = '\0';
 
@@ -5843,11 +5850,11 @@ collect_expansion (buf, end, nargs, arglist)
            /* Treat %:%: as ## and %: as #.  */
            if (p[1] == '%' && p[2] == ':') {
              p += 2;
-             goto hash_hash_token;
+             goto sharp_sharp_token;
            }
            if (nargs >= 0) {
              p++;
-             goto hash_token;
+             goto sharp_token;
            }
          }
        }
@@ -5858,7 +5865,7 @@ collect_expansion (buf, end, nargs, arglist)
        if (expected_delimiter)
          break;
        if (*p == '#') {
-       hash_hash_token:
+       sharp_sharp_token:
          /* ##: concatenate preceding and following tokens.  */
          /* Take out the first #, discard preceding whitespace.  */
          exp_p--;
@@ -5866,24 +5873,30 @@ collect_expansion (buf, end, nargs, arglist)
            --exp_p;
          /* Skip the second #.  */
          p++;
-         /* Discard following whitespace.  */
-         SKIP_WHITE_SPACE (p);
+         concat_sharp_token_type = c;
+         if (is_hor_space[*p]) {
+           concat_sharp_token_type++;
+           p++;
+           SKIP_WHITE_SPACE (p);
+         }
          concat = p;
-         concat_spelling = c;
          if (p == limit)
            error ("`##' at end of macro definition");
        } else if (nargs >= 0) {
          /* Single #: stringify following argument ref.
             Don't leave the # in the expansion.  */
-       hash_token:
+       sharp_token:
          exp_p--;
-         SKIP_WHITE_SPACE (p);
+         stringify_sharp_token_type = c;
+         if (is_hor_space[*p]) {
+           stringify_sharp_token_type++;
+           p++;
+           SKIP_WHITE_SPACE (p);
+         }
          if (! is_idstart[*p] || nargs == 0)
            error ("`#' operator is not followed by a macro argument name");
-         else {
+         else
            stringify = p;
-           stringify_spelling = c;
-         }
        }
        break;
       }
@@ -5965,11 +5978,13 @@ collect_expansion (buf, end, nargs, arglist)
               the pat list */
            tpat = (struct reflist *) xmalloc (sizeof (struct reflist));
            tpat->next = NULL;
-           tpat->raw_before = concat == id_beg ? concat_spelling : 0;
-           tpat->raw_after = 0;
+           tpat->raw_before
+             = concat == id_beg ? concat_sharp_token_type : NO_SHARP_TOKEN;
+           tpat->raw_after = NO_SHARP_TOKEN;
            tpat->rest_args = arg->rest_args;
-           tpat->stringify = (traditional ? expected_delimiter != '\0'
-                              : stringify == id_beg) ? stringify_spelling : 0;
+           tpat->stringify
+             = ((traditional ? expected_delimiter : stringify == id_beg)
+                ? stringify_sharp_token_type : NO_SHARP_TOKEN);
 
            if (endpat == NULL)
              defn->pattern = tpat;
@@ -5985,7 +6000,7 @@ collect_expansion (buf, end, nargs, arglist)
              if (p1[0]=='#'
                  ? p1[1]=='#'
                  : p1[0]=='%' && p1[1]==':' && p1[2]=='%' && p1[3]==':')
-               tpat->raw_after = p1[0];
+               tpat->raw_after = p1[0] + (p != p1);
            }
            lastp = exp_p;      /* place to start copying from next time */
            skipped_arg = 1;
@@ -7105,14 +7120,14 @@ skip_if_group (ip, any, op)
       while (bp[0] == '\\' && bp[1] == '\n')
        bp += 2;
       if (*bp == ':')
-       goto hash_token;
+       goto sharp_token;
       break;
     case '#':
       /* # keyword: a # must be first nonblank char on the line */
       if (beg_of_line == 0)
        break;
       ip->bufp = bp - 1;
-    hash_token:
+    sharp_token:
       /* Scan from start of line, skipping whitespace, comments
         and backslash-newlines, and see if we reach this #.
         If not, this # is not special.  */
@@ -9153,15 +9168,41 @@ dump_single_macro (hp, of)
     if (!traditional) {
       if (ap->nchars != 0)
        concat = 0;
-      if (ap->stringify)
-       fprintf (of, ap->stringify == '#' ? " #" : " %:");
-      if (ap->raw_before && !concat)
-       fprintf (of, ap->raw_before == '#' ? " ## " : " %:%: ");
+      if (ap->stringify) {
+       switch (ap->stringify) {
+        case SHARP_TOKEN: fprintf (of, "#"); break;
+        case WHITE_SHARP_TOKEN: fprintf (of, "# "); break;
+        case PERCENT_COLON_TOKEN: fprintf (of, "%:"); break;
+        case WHITE_PERCENT_COLON_TOKEN: fprintf (of, "%: "); break;
+       }
+      }
+      if (ap->raw_before) {
+       if (concat) {
+         switch (ap->raw_before) {
+          case WHITE_SHARP_TOKEN:
+          case WHITE_PERCENT_COLON_TOKEN:
+           fprintf (of, " ");
+           break;
+         }
+       } else {
+         switch (ap->raw_before) {
+          case SHARP_TOKEN: fprintf (of, "##"); break;
+          case WHITE_SHARP_TOKEN: fprintf (of, "## "); break;
+          case PERCENT_COLON_TOKEN: fprintf (of, "%:%:"); break;
+          case WHITE_PERCENT_COLON_TOKEN: fprintf (of, "%:%: "); break;
+         }
+       }
+      }
       concat = 0;
     }
     dump_arg_n (defn, ap->argno, of);
     if (!traditional && ap->raw_after) {
-      fprintf (of, ap->raw_after == '#' ? " ## " : " %:%: ");
+      switch (ap->raw_after) {
+       case SHARP_TOKEN: fprintf (of, "##"); break;
+       case WHITE_SHARP_TOKEN: fprintf (of, " ##"); break;
+       case PERCENT_COLON_TOKEN: fprintf (of, "%:%:"); break;
+       case WHITE_PERCENT_COLON_TOKEN: fprintf (of, " %:%:"); break;
+      }
       concat = 1;
     }
   }