OSDN Git Service

2008-07-21 Manuel Lopez-Ibanez <manu@gcc.gnu.org>
[pf3gnuchains/gcc-fork.git] / libcpp / macro.c
1 /* Part of CPP library.  (Macro and #define handling.)
2    Copyright (C) 1986, 1987, 1989, 1992, 1993, 1994, 1995, 1996, 1998,
3    1999, 2000, 2001, 2002, 2003, 2004, 2005,
4    2006, 2007, 2008 Free Software Foundation, Inc.
5    Written by Per Bothner, 1994.
6    Based on CCCP program by Paul Rubin, June 1986
7    Adapted to ANSI C, Richard Stallman, Jan 1987
8
9 This program is free software; you can redistribute it and/or modify it
10 under the terms of the GNU General Public License as published by the
11 Free Software Foundation; either version 2, or (at your option) any
12 later version.
13
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
17 GNU General Public License for more details.
18
19 You should have received a copy of the GNU General Public License
20 along with this program; if not, write to the Free Software
21 Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
22
23  In other words, you are welcome to use, share and improve this program.
24  You are forbidden to forbid anyone else to use, share and improve
25  what you give them.   Help stamp out software-hoarding!  */
26
27 #include "config.h"
28 #include "system.h"
29 #include "cpplib.h"
30 #include "internal.h"
31
32 typedef struct macro_arg macro_arg;
33 struct macro_arg
34 {
35   const cpp_token **first;      /* First token in unexpanded argument.  */
36   const cpp_token **expanded;   /* Macro-expanded argument.  */
37   const cpp_token *stringified; /* Stringified argument.  */
38   unsigned int count;           /* # of tokens in argument.  */
39   unsigned int expanded_count;  /* # of tokens in expanded argument.  */
40 };
41
42 /* Macro expansion.  */
43
44 static int enter_macro_context (cpp_reader *, cpp_hashnode *,
45                                 const cpp_token *);
46 static int builtin_macro (cpp_reader *, cpp_hashnode *);
47 static void push_ptoken_context (cpp_reader *, cpp_hashnode *, _cpp_buff *,
48                                  const cpp_token **, unsigned int);
49 static _cpp_buff *collect_args (cpp_reader *, const cpp_hashnode *,
50                                 _cpp_buff **);
51 static cpp_context *next_context (cpp_reader *);
52 static const cpp_token *padding_token (cpp_reader *, const cpp_token *);
53 static void expand_arg (cpp_reader *, macro_arg *);
54 static const cpp_token *new_string_token (cpp_reader *, uchar *, unsigned int);
55 static const cpp_token *stringify_arg (cpp_reader *, macro_arg *);
56 static void paste_all_tokens (cpp_reader *, const cpp_token *);
57 static bool paste_tokens (cpp_reader *, const cpp_token **, const cpp_token *);
58 static void replace_args (cpp_reader *, cpp_hashnode *, cpp_macro *,
59                           macro_arg *);
60 static _cpp_buff *funlike_invocation_p (cpp_reader *, cpp_hashnode *,
61                                         _cpp_buff **);
62 static bool create_iso_definition (cpp_reader *, cpp_macro *);
63
64 /* #define directive parsing and handling.  */
65
66 static cpp_token *alloc_expansion_token (cpp_reader *, cpp_macro *);
67 static cpp_token *lex_expansion_token (cpp_reader *, cpp_macro *);
68 static bool warn_of_redefinition (cpp_reader *, const cpp_hashnode *,
69                                   const cpp_macro *);
70 static bool parse_params (cpp_reader *, cpp_macro *);
71 static void check_trad_stringification (cpp_reader *, const cpp_macro *,
72                                         const cpp_string *);
73
74 /* Emits a warning if NODE is a macro defined in the main file that
75    has not been used.  */
76 int
77 _cpp_warn_if_unused_macro (cpp_reader *pfile, cpp_hashnode *node,
78                            void *v ATTRIBUTE_UNUSED)
79 {
80   if (node->type == NT_MACRO && !(node->flags & NODE_BUILTIN))
81     {
82       cpp_macro *macro = node->value.macro;
83
84       if (!macro->used
85           && MAIN_FILE_P (linemap_lookup (pfile->line_table, macro->line)))
86         cpp_error_with_line (pfile, CPP_DL_WARNING, macro->line, 0,
87                              "macro \"%s\" is not used", NODE_NAME (node));
88     }
89
90   return 1;
91 }
92
93 /* Allocates and returns a CPP_STRING token, containing TEXT of length
94    LEN, after null-terminating it.  TEXT must be in permanent storage.  */
95 static const cpp_token *
96 new_string_token (cpp_reader *pfile, unsigned char *text, unsigned int len)
97 {
98   cpp_token *token = _cpp_temp_token (pfile);
99
100   text[len] = '\0';
101   token->type = CPP_STRING;
102   token->val.str.len = len;
103   token->val.str.text = text;
104   token->flags = 0;
105   return token;
106 }
107
108 static const char * const monthnames[] =
109 {
110   "Jan", "Feb", "Mar", "Apr", "May", "Jun",
111   "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"
112 };
113
114 /* Helper function for builtin_macro.  Returns the text generated by
115    a builtin macro. */
116 const uchar *
117 _cpp_builtin_macro_text (cpp_reader *pfile, cpp_hashnode *node)
118 {
119   const struct line_map *map;
120   const uchar *result = NULL;
121   linenum_type number = 1;
122
123   switch (node->value.builtin)
124     {
125     default:
126       cpp_error (pfile, CPP_DL_ICE, "invalid built-in macro \"%s\"",
127                  NODE_NAME (node));
128       break;
129
130     case BT_TIMESTAMP:
131       {
132         cpp_buffer *pbuffer = cpp_get_buffer (pfile);
133         if (pbuffer->timestamp == NULL)
134           {
135             /* Initialize timestamp value of the assotiated file. */
136             struct _cpp_file *file = cpp_get_file (pbuffer);
137             if (file)
138               {
139                 /* Generate __TIMESTAMP__ string, that represents 
140                    the date and time of the last modification 
141                    of the current source file. The string constant 
142                    looks like "Sun Sep 16 01:03:52 1973".  */
143                 struct tm *tb = NULL;
144                 struct stat *st = _cpp_get_file_stat (file);
145                 if (st)
146                   tb = localtime (&st->st_mtime);
147                 if (tb)
148                   {
149                     char *str = asctime (tb);
150                     size_t len = strlen (str);
151                     unsigned char *buf = _cpp_unaligned_alloc (pfile, len + 2);
152                     buf[0] = '"';
153                     strcpy ((char *) buf + 1, str);
154                     buf[len] = '"';
155                     pbuffer->timestamp = buf;
156                   }
157                 else
158                   {
159                     cpp_errno (pfile, CPP_DL_WARNING,
160                         "could not determine file timestamp");
161                     pbuffer->timestamp = UC"\"??? ??? ?? ??:??:?? ????\"";
162                   }
163               }
164           }
165         result = pbuffer->timestamp;
166       }
167       break;
168     case BT_FILE:
169     case BT_BASE_FILE:
170       {
171         unsigned int len;
172         const char *name;
173         uchar *buf;
174         map = linemap_lookup (pfile->line_table, pfile->line_table->highest_line);
175
176         if (node->value.builtin == BT_BASE_FILE)
177           while (! MAIN_FILE_P (map))
178             map = INCLUDED_FROM (pfile->line_table, map);
179
180         name = map->to_file;
181         len = strlen (name);
182         buf = _cpp_unaligned_alloc (pfile, len * 2 + 3);
183         result = buf;
184         *buf = '"';
185         buf = cpp_quote_string (buf + 1, (const unsigned char *) name, len);
186         *buf++ = '"';
187         *buf = '\0';
188       }
189       break;
190
191     case BT_INCLUDE_LEVEL:
192       /* The line map depth counts the primary source as level 1, but
193          historically __INCLUDE_DEPTH__ has called the primary source
194          level 0.  */
195       number = pfile->line_table->depth - 1;
196       break;
197
198     case BT_SPECLINE:
199       map = &pfile->line_table->maps[pfile->line_table->used-1];
200       /* If __LINE__ is embedded in a macro, it must expand to the
201          line of the macro's invocation, not its definition.
202          Otherwise things like assert() will not work properly.  */
203       number = SOURCE_LINE (map, 
204                             CPP_OPTION (pfile, traditional) 
205                             ? pfile->line_table->highest_line
206                             : pfile->cur_token[-1].src_loc);
207       break;
208
209       /* __STDC__ has the value 1 under normal circumstances.
210          However, if (a) we are in a system header, (b) the option
211          stdc_0_in_system_headers is true (set by target config), and
212          (c) we are not in strictly conforming mode, then it has the
213          value 0.  (b) and (c) are already checked in cpp_init_builtins.  */
214     case BT_STDC:
215       if (cpp_in_system_header (pfile))
216         number = 0;
217       else
218         number = 1;
219       break;
220
221     case BT_DATE:
222     case BT_TIME:
223       if (pfile->date == NULL)
224         {
225           /* Allocate __DATE__ and __TIME__ strings from permanent
226              storage.  We only do this once, and don't generate them
227              at init time, because time() and localtime() are very
228              slow on some systems.  */
229           time_t tt;
230           struct tm *tb = NULL;
231
232           /* (time_t) -1 is a legitimate value for "number of seconds
233              since the Epoch", so we have to do a little dance to
234              distinguish that from a genuine error.  */
235           errno = 0;
236           tt = time(NULL);
237           if (tt != (time_t)-1 || errno == 0)
238             tb = localtime (&tt);
239
240           if (tb)
241             {
242               pfile->date = _cpp_unaligned_alloc (pfile,
243                                                   sizeof ("\"Oct 11 1347\""));
244               sprintf ((char *) pfile->date, "\"%s %2d %4d\"",
245                        monthnames[tb->tm_mon], tb->tm_mday,
246                        tb->tm_year + 1900);
247
248               pfile->time = _cpp_unaligned_alloc (pfile,
249                                                   sizeof ("\"12:34:56\""));
250               sprintf ((char *) pfile->time, "\"%02d:%02d:%02d\"",
251                        tb->tm_hour, tb->tm_min, tb->tm_sec);
252             }
253           else
254             {
255               cpp_errno (pfile, CPP_DL_WARNING,
256                          "could not determine date and time");
257                 
258               pfile->date = UC"\"??? ?? ????\"";
259               pfile->time = UC"\"??:??:??\"";
260             }
261         }
262
263       if (node->value.builtin == BT_DATE)
264         result = pfile->date;
265       else
266         result = pfile->time;
267       break;
268
269     case BT_COUNTER:
270       if (CPP_OPTION (pfile, directives_only) && pfile->state.in_directive)
271         cpp_error (pfile, CPP_DL_ERROR,
272             "__COUNTER__ expanded inside directive with -fdirectives-only");
273       number = pfile->counter++;
274       break;
275     }
276
277   if (result == NULL)
278     {
279       /* 21 bytes holds all NUL-terminated unsigned 64-bit numbers.  */
280       result = _cpp_unaligned_alloc (pfile, 21);
281       sprintf ((char *) result, "%u", number);
282     }
283
284   return result;      
285 }
286
287 /* Convert builtin macros like __FILE__ to a token and push it on the
288    context stack.  Also handles _Pragma, for which a new token may not
289    be created.  Returns 1 if it generates a new token context, 0 to
290    return the token to the caller.  */
291 static int
292 builtin_macro (cpp_reader *pfile, cpp_hashnode *node)
293 {
294   const uchar *buf;
295   size_t len;
296   char *nbuf;
297
298   if (node->value.builtin == BT_PRAGMA)
299     {
300       /* Don't interpret _Pragma within directives.  The standard is
301          not clear on this, but to me this makes most sense.  */
302       if (pfile->state.in_directive)
303         return 0;
304
305       return _cpp_do__Pragma (pfile);
306     }
307
308   buf = _cpp_builtin_macro_text (pfile, node);
309   len = ustrlen (buf);
310   nbuf = (char *) alloca (len + 1);
311   memcpy (nbuf, buf, len);
312   nbuf[len]='\n';
313
314   cpp_push_buffer (pfile, (uchar *) nbuf, len, /* from_stage3 */ true);
315   _cpp_clean_line (pfile);
316
317   /* Set pfile->cur_token as required by _cpp_lex_direct.  */
318   pfile->cur_token = _cpp_temp_token (pfile);
319   _cpp_push_token_context (pfile, NULL, _cpp_lex_direct (pfile), 1);
320   if (pfile->buffer->cur != pfile->buffer->rlimit)
321     cpp_error (pfile, CPP_DL_ICE, "invalid built-in macro \"%s\"",
322                NODE_NAME (node));
323   _cpp_pop_buffer (pfile);
324
325   return 1;
326 }
327
328 /* Copies SRC, of length LEN, to DEST, adding backslashes before all
329    backslashes and double quotes. DEST must be of sufficient size.
330    Returns a pointer to the end of the string.  */
331 uchar *
332 cpp_quote_string (uchar *dest, const uchar *src, unsigned int len)
333 {
334   while (len--)
335     {
336       uchar c = *src++;
337
338       if (c == '\\' || c == '"')
339         {
340           *dest++ = '\\';
341           *dest++ = c;
342         }
343       else
344           *dest++ = c;
345     }
346
347   return dest;
348 }
349
350 /* Convert a token sequence ARG to a single string token according to
351    the rules of the ISO C #-operator.  */
352 static const cpp_token *
353 stringify_arg (cpp_reader *pfile, macro_arg *arg)
354 {
355   unsigned char *dest;
356   unsigned int i, escape_it, backslash_count = 0;
357   const cpp_token *source = NULL;
358   size_t len;
359
360   if (BUFF_ROOM (pfile->u_buff) < 3)
361     _cpp_extend_buff (pfile, &pfile->u_buff, 3);
362   dest = BUFF_FRONT (pfile->u_buff);
363   *dest++ = '"';
364
365   /* Loop, reading in the argument's tokens.  */
366   for (i = 0; i < arg->count; i++)
367     {
368       const cpp_token *token = arg->first[i];
369
370       if (token->type == CPP_PADDING)
371         {
372           if (source == NULL)
373             source = token->val.source;
374           continue;
375         }
376
377       escape_it = (token->type == CPP_STRING || token->type == CPP_CHAR
378                    || token->type == CPP_WSTRING || token->type == CPP_STRING
379                    || token->type == CPP_STRING32 || token->type == CPP_CHAR32
380                    || token->type == CPP_STRING16 || token->type == CPP_CHAR16);
381
382       /* Room for each char being written in octal, initial space and
383          final quote and NUL.  */
384       len = cpp_token_len (token);
385       if (escape_it)
386         len *= 4;
387       len += 3;
388
389       if ((size_t) (BUFF_LIMIT (pfile->u_buff) - dest) < len)
390         {
391           size_t len_so_far = dest - BUFF_FRONT (pfile->u_buff);
392           _cpp_extend_buff (pfile, &pfile->u_buff, len);
393           dest = BUFF_FRONT (pfile->u_buff) + len_so_far;
394         }
395
396       /* Leading white space?  */
397       if (dest - 1 != BUFF_FRONT (pfile->u_buff))
398         {
399           if (source == NULL)
400             source = token;
401           if (source->flags & PREV_WHITE)
402             *dest++ = ' ';
403         }
404       source = NULL;
405
406       if (escape_it)
407         {
408           _cpp_buff *buff = _cpp_get_buff (pfile, len);
409           unsigned char *buf = BUFF_FRONT (buff);
410           len = cpp_spell_token (pfile, token, buf, true) - buf;
411           dest = cpp_quote_string (dest, buf, len);
412           _cpp_release_buff (pfile, buff);
413         }
414       else
415         dest = cpp_spell_token (pfile, token, dest, true);
416
417       if (token->type == CPP_OTHER && token->val.str.text[0] == '\\')
418         backslash_count++;
419       else
420         backslash_count = 0;
421     }
422
423   /* Ignore the final \ of invalid string literals.  */
424   if (backslash_count & 1)
425     {
426       cpp_error (pfile, CPP_DL_WARNING,
427                  "invalid string literal, ignoring final '\\'");
428       dest--;
429     }
430
431   /* Commit the memory, including NUL, and return the token.  */
432   *dest++ = '"';
433   len = dest - BUFF_FRONT (pfile->u_buff);
434   BUFF_FRONT (pfile->u_buff) = dest + 1;
435   return new_string_token (pfile, dest - len, len);
436 }
437
438 /* Try to paste two tokens.  On success, return nonzero.  In any
439    case, PLHS is updated to point to the pasted token, which is
440    guaranteed to not have the PASTE_LEFT flag set.  */
441 static bool
442 paste_tokens (cpp_reader *pfile, const cpp_token **plhs, const cpp_token *rhs)
443 {
444   unsigned char *buf, *end, *lhsend;
445   cpp_token *lhs;
446   unsigned int len;
447
448   len = cpp_token_len (*plhs) + cpp_token_len (rhs) + 1;
449   buf = (unsigned char *) alloca (len);
450   end = lhsend = cpp_spell_token (pfile, *plhs, buf, false);
451
452   /* Avoid comment headers, since they are still processed in stage 3.
453      It is simpler to insert a space here, rather than modifying the
454      lexer to ignore comments in some circumstances.  Simply returning
455      false doesn't work, since we want to clear the PASTE_LEFT flag.  */
456   if ((*plhs)->type == CPP_DIV && rhs->type != CPP_EQ)
457     *end++ = ' ';
458   /* In one obscure case we might see padding here.  */
459   if (rhs->type != CPP_PADDING)
460     end = cpp_spell_token (pfile, rhs, end, false);
461   *end = '\n';
462
463   cpp_push_buffer (pfile, buf, end - buf, /* from_stage3 */ true);
464   _cpp_clean_line (pfile);
465
466   /* Set pfile->cur_token as required by _cpp_lex_direct.  */
467   pfile->cur_token = _cpp_temp_token (pfile);
468   lhs = _cpp_lex_direct (pfile);
469   if (pfile->buffer->cur != pfile->buffer->rlimit)
470     {
471       source_location saved_loc = lhs->src_loc;
472
473       _cpp_pop_buffer (pfile);
474       _cpp_backup_tokens (pfile, 1);
475       *lhsend = '\0';
476
477       /* We have to remove the PASTE_LEFT flag from the old lhs, but
478          we want to keep the new location.  */
479       *lhs = **plhs;
480       *plhs = lhs;
481       lhs->src_loc = saved_loc;
482       lhs->flags &= ~PASTE_LEFT;
483
484       /* Mandatory error for all apart from assembler.  */
485       if (CPP_OPTION (pfile, lang) != CLK_ASM)
486         cpp_error (pfile, CPP_DL_ERROR,
487          "pasting \"%s\" and \"%s\" does not give a valid preprocessing token",
488                    buf, cpp_token_as_text (pfile, rhs));
489       return false;
490     }
491
492   *plhs = lhs;
493   _cpp_pop_buffer (pfile);
494   return true;
495 }
496
497 /* Handles an arbitrarily long sequence of ## operators, with initial
498    operand LHS.  This implementation is left-associative,
499    non-recursive, and finishes a paste before handling succeeding
500    ones.  If a paste fails, we back up to the RHS of the failing ##
501    operator before pushing the context containing the result of prior
502    successful pastes, with the effect that the RHS appears in the
503    output stream after the pasted LHS normally.  */
504 static void
505 paste_all_tokens (cpp_reader *pfile, const cpp_token *lhs)
506 {
507   const cpp_token *rhs;
508   cpp_context *context = pfile->context;
509
510   do
511     {
512       /* Take the token directly from the current context.  We can do
513          this, because we are in the replacement list of either an
514          object-like macro, or a function-like macro with arguments
515          inserted.  In either case, the constraints to #define
516          guarantee we have at least one more token.  */
517       if (context->direct_p)
518         rhs = FIRST (context).token++;
519       else
520         rhs = *FIRST (context).ptoken++;
521
522       if (rhs->type == CPP_PADDING)
523         {
524           if (rhs->flags & PASTE_LEFT)
525             abort ();
526         }
527       if (!paste_tokens (pfile, &lhs, rhs))
528         break;
529     }
530   while (rhs->flags & PASTE_LEFT);
531
532   /* Put the resulting token in its own context.  */
533   _cpp_push_token_context (pfile, NULL, lhs, 1);
534 }
535
536 /* Returns TRUE if the number of arguments ARGC supplied in an
537    invocation of the MACRO referenced by NODE is valid.  An empty
538    invocation to a macro with no parameters should pass ARGC as zero.
539
540    Note that MACRO cannot necessarily be deduced from NODE, in case
541    NODE was redefined whilst collecting arguments.  */
542 bool
543 _cpp_arguments_ok (cpp_reader *pfile, cpp_macro *macro, const cpp_hashnode *node, unsigned int argc)
544 {
545   if (argc == macro->paramc)
546     return true;
547
548   if (argc < macro->paramc)
549     {
550       /* As an extension, a rest argument is allowed to not appear in
551          the invocation at all.
552          e.g. #define debug(format, args...) something
553          debug("string");
554
555          This is exactly the same as if there had been an empty rest
556          argument - debug("string", ).  */
557
558       if (argc + 1 == macro->paramc && macro->variadic)
559         {
560           if (CPP_PEDANTIC (pfile) && ! macro->syshdr)
561             cpp_error (pfile, CPP_DL_PEDWARN,
562                        "ISO C99 requires rest arguments to be used");
563           return true;
564         }
565
566       cpp_error (pfile, CPP_DL_ERROR,
567                  "macro \"%s\" requires %u arguments, but only %u given",
568                  NODE_NAME (node), macro->paramc, argc);
569     }
570   else
571     cpp_error (pfile, CPP_DL_ERROR,
572                "macro \"%s\" passed %u arguments, but takes just %u",
573                NODE_NAME (node), argc, macro->paramc);
574
575   return false;
576 }
577
578 /* Reads and returns the arguments to a function-like macro
579    invocation.  Assumes the opening parenthesis has been processed.
580    If there is an error, emits an appropriate diagnostic and returns
581    NULL.  Each argument is terminated by a CPP_EOF token, for the
582    future benefit of expand_arg().  If there are any deferred
583    #pragma directives among macro arguments, store pointers to the
584    CPP_PRAGMA ... CPP_PRAGMA_EOL tokens into *PRAGMA_BUFF buffer.  */
585 static _cpp_buff *
586 collect_args (cpp_reader *pfile, const cpp_hashnode *node,
587               _cpp_buff **pragma_buff)
588 {
589   _cpp_buff *buff, *base_buff;
590   cpp_macro *macro;
591   macro_arg *args, *arg;
592   const cpp_token *token;
593   unsigned int argc;
594
595   macro = node->value.macro;
596   if (macro->paramc)
597     argc = macro->paramc;
598   else
599     argc = 1;
600   buff = _cpp_get_buff (pfile, argc * (50 * sizeof (cpp_token *)
601                                        + sizeof (macro_arg)));
602   base_buff = buff;
603   args = (macro_arg *) buff->base;
604   memset (args, 0, argc * sizeof (macro_arg));
605   buff->cur = (unsigned char *) &args[argc];
606   arg = args, argc = 0;
607
608   /* Collect the tokens making up each argument.  We don't yet know
609      how many arguments have been supplied, whether too many or too
610      few.  Hence the slightly bizarre usage of "argc" and "arg".  */
611   do
612     {
613       unsigned int paren_depth = 0;
614       unsigned int ntokens = 0;
615
616       argc++;
617       arg->first = (const cpp_token **) buff->cur;
618
619       for (;;)
620         {
621           /* Require space for 2 new tokens (including a CPP_EOF).  */
622           if ((unsigned char *) &arg->first[ntokens + 2] > buff->limit)
623             {
624               buff = _cpp_append_extend_buff (pfile, buff,
625                                               1000 * sizeof (cpp_token *));
626               arg->first = (const cpp_token **) buff->cur;
627             }
628
629           token = cpp_get_token (pfile);
630
631           if (token->type == CPP_PADDING)
632             {
633               /* Drop leading padding.  */
634               if (ntokens == 0)
635                 continue;
636             }
637           else if (token->type == CPP_OPEN_PAREN)
638             paren_depth++;
639           else if (token->type == CPP_CLOSE_PAREN)
640             {
641               if (paren_depth-- == 0)
642                 break;
643             }
644           else if (token->type == CPP_COMMA)
645             {
646               /* A comma does not terminate an argument within
647                  parentheses or as part of a variable argument.  */
648               if (paren_depth == 0
649                   && ! (macro->variadic && argc == macro->paramc))
650                 break;
651             }
652           else if (token->type == CPP_EOF
653                    || (token->type == CPP_HASH && token->flags & BOL))
654             break;
655           else if (token->type == CPP_PRAGMA)
656             {
657               cpp_token *newtok = _cpp_temp_token (pfile);
658
659               /* CPP_PRAGMA token lives in directive_result, which will
660                  be overwritten on the next directive.  */
661               *newtok = *token;
662               token = newtok;
663               do
664                 {
665                   if (*pragma_buff == NULL
666                       || BUFF_ROOM (*pragma_buff) < sizeof (cpp_token *))
667                     {
668                       _cpp_buff *next;
669                       if (*pragma_buff == NULL)
670                         *pragma_buff
671                           = _cpp_get_buff (pfile, 32 * sizeof (cpp_token *));
672                       else
673                         {
674                           next = *pragma_buff;
675                           *pragma_buff
676                             = _cpp_get_buff (pfile,
677                                              (BUFF_FRONT (*pragma_buff)
678                                               - (*pragma_buff)->base) * 2);
679                           (*pragma_buff)->next = next;
680                         }
681                     }
682                   *(const cpp_token **) BUFF_FRONT (*pragma_buff) = token;
683                   BUFF_FRONT (*pragma_buff) += sizeof (cpp_token *);
684                   if (token->type == CPP_PRAGMA_EOL)
685                     break;
686                   token = cpp_get_token (pfile);
687                 }
688               while (token->type != CPP_EOF);
689
690               /* In deferred pragmas parsing_args and prevent_expansion
691                  had been changed, reset it.  */
692               pfile->state.parsing_args = 2;
693               pfile->state.prevent_expansion = 1;
694
695               if (token->type == CPP_EOF)
696                 break;
697               else
698                 continue;
699             }
700
701           arg->first[ntokens++] = token;
702         }
703
704       /* Drop trailing padding.  */
705       while (ntokens > 0 && arg->first[ntokens - 1]->type == CPP_PADDING)
706         ntokens--;
707
708       arg->count = ntokens;
709       arg->first[ntokens] = &pfile->eof;
710
711       /* Terminate the argument.  Excess arguments loop back and
712          overwrite the final legitimate argument, before failing.  */
713       if (argc <= macro->paramc)
714         {
715           buff->cur = (unsigned char *) &arg->first[ntokens + 1];
716           if (argc != macro->paramc)
717             arg++;
718         }
719     }
720   while (token->type != CPP_CLOSE_PAREN && token->type != CPP_EOF);
721
722   if (token->type == CPP_EOF)
723     {
724       /* We still need the CPP_EOF to end directives, and to end
725          pre-expansion of a macro argument.  Step back is not
726          unconditional, since we don't want to return a CPP_EOF to our
727          callers at the end of an -include-d file.  */
728       if (pfile->context->prev || pfile->state.in_directive)
729         _cpp_backup_tokens (pfile, 1);
730       cpp_error (pfile, CPP_DL_ERROR,
731                  "unterminated argument list invoking macro \"%s\"",
732                  NODE_NAME (node));
733     }
734   else
735     {
736       /* A single empty argument is counted as no argument.  */
737       if (argc == 1 && macro->paramc == 0 && args[0].count == 0)
738         argc = 0;
739       if (_cpp_arguments_ok (pfile, macro, node, argc))
740         {
741           /* GCC has special semantics for , ## b where b is a varargs
742              parameter: we remove the comma if b was omitted entirely.
743              If b was merely an empty argument, the comma is retained.
744              If the macro takes just one (varargs) parameter, then we
745              retain the comma only if we are standards conforming.
746
747              If FIRST is NULL replace_args () swallows the comma.  */
748           if (macro->variadic && (argc < macro->paramc
749                                   || (argc == 1 && args[0].count == 0
750                                       && !CPP_OPTION (pfile, std))))
751             args[macro->paramc - 1].first = NULL;
752           return base_buff;
753         }
754     }
755
756   /* An error occurred.  */
757   _cpp_release_buff (pfile, base_buff);
758   return NULL;
759 }
760
761 /* Search for an opening parenthesis to the macro of NODE, in such a
762    way that, if none is found, we don't lose the information in any
763    intervening padding tokens.  If we find the parenthesis, collect
764    the arguments and return the buffer containing them.  PRAGMA_BUFF
765    argument is the same as in collect_args.  */
766 static _cpp_buff *
767 funlike_invocation_p (cpp_reader *pfile, cpp_hashnode *node,
768                       _cpp_buff **pragma_buff)
769 {
770   const cpp_token *token, *padding = NULL;
771
772   for (;;)
773     {
774       token = cpp_get_token (pfile);
775       if (token->type != CPP_PADDING)
776         break;
777       if (padding == NULL
778           || (!(padding->flags & PREV_WHITE) && token->val.source == NULL))
779         padding = token;
780     }
781
782   if (token->type == CPP_OPEN_PAREN)
783     {
784       pfile->state.parsing_args = 2;
785       return collect_args (pfile, node, pragma_buff);
786     }
787
788   /* CPP_EOF can be the end of macro arguments, or the end of the
789      file.  We mustn't back up over the latter.  Ugh.  */
790   if (token->type != CPP_EOF || token == &pfile->eof)
791     {
792       /* Back up.  We may have skipped padding, in which case backing
793          up more than one token when expanding macros is in general
794          too difficult.  We re-insert it in its own context.  */
795       _cpp_backup_tokens (pfile, 1);
796       if (padding)
797         _cpp_push_token_context (pfile, NULL, padding, 1);
798     }
799
800   return NULL;
801 }
802
803 /* Push the context of a macro with hash entry NODE onto the context
804    stack.  If we can successfully expand the macro, we push a context
805    containing its yet-to-be-rescanned replacement list and return one.
806    If there were additionally any unexpanded deferred #pragma directives
807    among macro arguments, push another context containing the
808    pragma tokens before the yet-to-be-rescanned replacement list
809    and return two.  Otherwise, we don't push a context and return zero.  */
810 static int
811 enter_macro_context (cpp_reader *pfile, cpp_hashnode *node,
812                      const cpp_token *result)
813 {
814   /* The presence of a macro invalidates a file's controlling macro.  */
815   pfile->mi_valid = false;
816
817   pfile->state.angled_headers = false;
818
819   if ((node->flags & NODE_BUILTIN) && !(node->flags & NODE_USED))
820     {
821       node->flags |= NODE_USED;
822       if (pfile->cb.used_define)
823         pfile->cb.used_define (pfile, pfile->directive_line, node);
824     }
825
826   /* Handle standard macros.  */
827   if (! (node->flags & NODE_BUILTIN))
828     {
829       cpp_macro *macro = node->value.macro;
830       _cpp_buff *pragma_buff = NULL;
831
832       if (macro->fun_like)
833         {
834           _cpp_buff *buff;
835
836           pfile->state.prevent_expansion++;
837           pfile->keep_tokens++;
838           pfile->state.parsing_args = 1;
839           buff = funlike_invocation_p (pfile, node, &pragma_buff);
840           pfile->state.parsing_args = 0;
841           pfile->keep_tokens--;
842           pfile->state.prevent_expansion--;
843
844           if (buff == NULL)
845             {
846               if (CPP_WTRADITIONAL (pfile) && ! node->value.macro->syshdr)
847                 cpp_error (pfile, CPP_DL_WARNING,
848  "function-like macro \"%s\" must be used with arguments in traditional C",
849                            NODE_NAME (node));
850
851               if (pragma_buff)
852                 _cpp_release_buff (pfile, pragma_buff);
853
854               return 0;
855             }
856
857           if (macro->paramc > 0)
858             replace_args (pfile, node, macro, (macro_arg *) buff->base);
859           _cpp_release_buff (pfile, buff);
860         }
861
862       /* Disable the macro within its expansion.  */
863       node->flags |= NODE_DISABLED;
864
865       if (!(node->flags & NODE_USED))
866         {
867           node->flags |= NODE_USED;
868           if (pfile->cb.used_define)
869             pfile->cb.used_define (pfile, pfile->directive_line, node);
870         }
871
872       macro->used = 1;
873
874       if (macro->paramc == 0)
875         _cpp_push_token_context (pfile, node, macro->exp.tokens, macro->count);
876
877       if (pragma_buff)
878         {
879           if (!pfile->state.in_directive)
880             _cpp_push_token_context (pfile, NULL,
881                                      padding_token (pfile, result), 1);
882           do
883             {
884               _cpp_buff *tail = pragma_buff->next;
885               pragma_buff->next = NULL;
886               push_ptoken_context (pfile, NULL, pragma_buff,
887                                    (const cpp_token **) pragma_buff->base,
888                                    ((const cpp_token **) BUFF_FRONT (pragma_buff)
889                                     - (const cpp_token **) pragma_buff->base));
890               pragma_buff = tail;
891             }
892           while (pragma_buff != NULL);
893           return 2;
894         }
895
896       return 1;
897     }
898
899   /* Handle built-in macros and the _Pragma operator.  */
900   return builtin_macro (pfile, node);
901 }
902
903 /* Replace the parameters in a function-like macro of NODE with the
904    actual ARGS, and place the result in a newly pushed token context.
905    Expand each argument before replacing, unless it is operated upon
906    by the # or ## operators.  */
907 static void
908 replace_args (cpp_reader *pfile, cpp_hashnode *node, cpp_macro *macro, macro_arg *args)
909 {
910   unsigned int i, total;
911   const cpp_token *src, *limit;
912   const cpp_token **dest, **first;
913   macro_arg *arg;
914   _cpp_buff *buff;
915
916   /* First, fully macro-expand arguments, calculating the number of
917      tokens in the final expansion as we go.  The ordering of the if
918      statements below is subtle; we must handle stringification before
919      pasting.  */
920   total = macro->count;
921   limit = macro->exp.tokens + macro->count;
922
923   for (src = macro->exp.tokens; src < limit; src++)
924     if (src->type == CPP_MACRO_ARG)
925       {
926         /* Leading and trailing padding tokens.  */
927         total += 2;
928
929         /* We have an argument.  If it is not being stringified or
930            pasted it is macro-replaced before insertion.  */
931         arg = &args[src->val.arg_no - 1];
932
933         if (src->flags & STRINGIFY_ARG)
934           {
935             if (!arg->stringified)
936               arg->stringified = stringify_arg (pfile, arg);
937           }
938         else if ((src->flags & PASTE_LEFT)
939                  || (src > macro->exp.tokens && (src[-1].flags & PASTE_LEFT)))
940           total += arg->count - 1;
941         else
942           {
943             if (!arg->expanded)
944               expand_arg (pfile, arg);
945             total += arg->expanded_count - 1;
946           }
947       }
948
949   /* Now allocate space for the expansion, copy the tokens and replace
950      the arguments.  */
951   buff = _cpp_get_buff (pfile, total * sizeof (cpp_token *));
952   first = (const cpp_token **) buff->base;
953   dest = first;
954
955   for (src = macro->exp.tokens; src < limit; src++)
956     {
957       unsigned int count;
958       const cpp_token **from, **paste_flag;
959
960       if (src->type != CPP_MACRO_ARG)
961         {
962           *dest++ = src;
963           continue;
964         }
965
966       paste_flag = 0;
967       arg = &args[src->val.arg_no - 1];
968       if (src->flags & STRINGIFY_ARG)
969         count = 1, from = &arg->stringified;
970       else if (src->flags & PASTE_LEFT)
971         count = arg->count, from = arg->first;
972       else if (src != macro->exp.tokens && (src[-1].flags & PASTE_LEFT))
973         {
974           count = arg->count, from = arg->first;
975           if (dest != first)
976             {
977               if (dest[-1]->type == CPP_COMMA
978                   && macro->variadic
979                   && src->val.arg_no == macro->paramc)
980                 {
981                   /* Swallow a pasted comma if from == NULL, otherwise
982                      drop the paste flag.  */
983                   if (from == NULL)
984                     dest--;
985                   else
986                     paste_flag = dest - 1;
987                 }
988               /* Remove the paste flag if the RHS is a placemarker.  */
989               else if (count == 0)
990                 paste_flag = dest - 1;
991             }
992         }
993       else
994         count = arg->expanded_count, from = arg->expanded;
995
996       /* Padding on the left of an argument (unless RHS of ##).  */
997       if ((!pfile->state.in_directive || pfile->state.directive_wants_padding)
998           && src != macro->exp.tokens && !(src[-1].flags & PASTE_LEFT))
999         *dest++ = padding_token (pfile, src);
1000
1001       if (count)
1002         {
1003           memcpy (dest, from, count * sizeof (cpp_token *));
1004           dest += count;
1005
1006           /* With a non-empty argument on the LHS of ##, the last
1007              token should be flagged PASTE_LEFT.  */
1008           if (src->flags & PASTE_LEFT)
1009             paste_flag = dest - 1;
1010         }
1011       else if (CPP_PEDANTIC (pfile) && ! macro->syshdr
1012                && ! CPP_OPTION (pfile, c99)
1013                && ! cpp_in_system_header (pfile))
1014         {
1015           cpp_error (pfile, CPP_DL_PEDWARN,
1016                      "invoking macro %s argument %d: "
1017                      "empty macro arguments are undefined"
1018                      " in ISO C90 and ISO C++98",
1019                      NODE_NAME (node),
1020                      src->val.arg_no);
1021         }
1022
1023       /* Avoid paste on RHS (even case count == 0).  */
1024       if (!pfile->state.in_directive && !(src->flags & PASTE_LEFT))
1025         *dest++ = &pfile->avoid_paste;
1026
1027       /* Add a new paste flag, or remove an unwanted one.  */
1028       if (paste_flag)
1029         {
1030           cpp_token *token = _cpp_temp_token (pfile);
1031           token->type = (*paste_flag)->type;
1032           token->val = (*paste_flag)->val;
1033           if (src->flags & PASTE_LEFT)
1034             token->flags = (*paste_flag)->flags | PASTE_LEFT;
1035           else
1036             token->flags = (*paste_flag)->flags & ~PASTE_LEFT;
1037           *paste_flag = token;
1038         }
1039     }
1040
1041   /* Free the expanded arguments.  */
1042   for (i = 0; i < macro->paramc; i++)
1043     if (args[i].expanded)
1044       free (args[i].expanded);
1045
1046   push_ptoken_context (pfile, node, buff, first, dest - first);
1047 }
1048
1049 /* Return a special padding token, with padding inherited from SOURCE.  */
1050 static const cpp_token *
1051 padding_token (cpp_reader *pfile, const cpp_token *source)
1052 {
1053   cpp_token *result = _cpp_temp_token (pfile);
1054
1055   result->type = CPP_PADDING;
1056
1057   /* Data in GCed data structures cannot be made const so far, so we
1058      need a cast here.  */
1059   result->val.source = (cpp_token *) source;
1060   result->flags = 0;
1061   return result;
1062 }
1063
1064 /* Get a new uninitialized context.  Create a new one if we cannot
1065    re-use an old one.  */
1066 static cpp_context *
1067 next_context (cpp_reader *pfile)
1068 {
1069   cpp_context *result = pfile->context->next;
1070
1071   if (result == 0)
1072     {
1073       result = XNEW (cpp_context);
1074       result->prev = pfile->context;
1075       result->next = 0;
1076       pfile->context->next = result;
1077     }
1078
1079   pfile->context = result;
1080   return result;
1081 }
1082
1083 /* Push a list of pointers to tokens.  */
1084 static void
1085 push_ptoken_context (cpp_reader *pfile, cpp_hashnode *macro, _cpp_buff *buff,
1086                      const cpp_token **first, unsigned int count)
1087 {
1088   cpp_context *context = next_context (pfile);
1089
1090   context->direct_p = false;
1091   context->macro = macro;
1092   context->buff = buff;
1093   FIRST (context).ptoken = first;
1094   LAST (context).ptoken = first + count;
1095 }
1096
1097 /* Push a list of tokens.  */
1098 void
1099 _cpp_push_token_context (cpp_reader *pfile, cpp_hashnode *macro,
1100                          const cpp_token *first, unsigned int count)
1101 {
1102   cpp_context *context = next_context (pfile);
1103
1104   context->direct_p = true;
1105   context->macro = macro;
1106   context->buff = NULL;
1107   FIRST (context).token = first;
1108   LAST (context).token = first + count;
1109 }
1110
1111 /* Push a traditional macro's replacement text.  */
1112 void
1113 _cpp_push_text_context (cpp_reader *pfile, cpp_hashnode *macro,
1114                         const uchar *start, size_t len)
1115 {
1116   cpp_context *context = next_context (pfile);
1117
1118   context->direct_p = true;
1119   context->macro = macro;
1120   context->buff = NULL;
1121   CUR (context) = start;
1122   RLIMIT (context) = start + len;
1123   macro->flags |= NODE_DISABLED;
1124 }
1125
1126 /* Expand an argument ARG before replacing parameters in a
1127    function-like macro.  This works by pushing a context with the
1128    argument's tokens, and then expanding that into a temporary buffer
1129    as if it were a normal part of the token stream.  collect_args()
1130    has terminated the argument's tokens with a CPP_EOF so that we know
1131    when we have fully expanded the argument.  */
1132 static void
1133 expand_arg (cpp_reader *pfile, macro_arg *arg)
1134 {
1135   unsigned int capacity;
1136   bool saved_warn_trad;
1137
1138   if (arg->count == 0)
1139     return;
1140
1141   /* Don't warn about funlike macros when pre-expanding.  */
1142   saved_warn_trad = CPP_WTRADITIONAL (pfile);
1143   CPP_WTRADITIONAL (pfile) = 0;
1144
1145   /* Loop, reading in the arguments.  */
1146   capacity = 256;
1147   arg->expanded = XNEWVEC (const cpp_token *, capacity);
1148
1149   push_ptoken_context (pfile, NULL, NULL, arg->first, arg->count + 1);
1150   for (;;)
1151     {
1152       const cpp_token *token;
1153
1154       if (arg->expanded_count + 1 >= capacity)
1155         {
1156           capacity *= 2;
1157           arg->expanded = XRESIZEVEC (const cpp_token *, arg->expanded,
1158                                       capacity);
1159         }
1160
1161       token = cpp_get_token (pfile);
1162
1163       if (token->type == CPP_EOF)
1164         break;
1165
1166       arg->expanded[arg->expanded_count++] = token;
1167     }
1168
1169   _cpp_pop_context (pfile);
1170
1171   CPP_WTRADITIONAL (pfile) = saved_warn_trad;
1172 }
1173
1174 /* Pop the current context off the stack, re-enabling the macro if the
1175    context represented a macro's replacement list.  The context
1176    structure is not freed so that we can re-use it later.  */
1177 void
1178 _cpp_pop_context (cpp_reader *pfile)
1179 {
1180   cpp_context *context = pfile->context;
1181
1182   if (context->macro)
1183     context->macro->flags &= ~NODE_DISABLED;
1184
1185   if (context->buff)
1186     _cpp_release_buff (pfile, context->buff);
1187
1188   pfile->context = context->prev;
1189 }
1190
1191 /* External routine to get a token.  Also used nearly everywhere
1192    internally, except for places where we know we can safely call
1193    _cpp_lex_token directly, such as lexing a directive name.
1194
1195    Macro expansions and directives are transparently handled,
1196    including entering included files.  Thus tokens are post-macro
1197    expansion, and after any intervening directives.  External callers
1198    see CPP_EOF only at EOF.  Internal callers also see it when meeting
1199    a directive inside a macro call, when at the end of a directive and
1200    state.in_directive is still 1, and at the end of argument
1201    pre-expansion.  */
1202 const cpp_token *
1203 cpp_get_token (cpp_reader *pfile)
1204 {
1205   const cpp_token *result;
1206   bool can_set = pfile->set_invocation_location;
1207   pfile->set_invocation_location = false;
1208
1209   for (;;)
1210     {
1211       cpp_hashnode *node;
1212       cpp_context *context = pfile->context;
1213
1214       /* Context->prev == 0 <=> base context.  */
1215       if (!context->prev)
1216         result = _cpp_lex_token (pfile);
1217       else if (FIRST (context).token != LAST (context).token)
1218         {
1219           if (context->direct_p)
1220             result = FIRST (context).token++;
1221           else
1222             result = *FIRST (context).ptoken++;
1223
1224           if (result->flags & PASTE_LEFT)
1225             {
1226               paste_all_tokens (pfile, result);
1227               if (pfile->state.in_directive)
1228                 continue;
1229               return padding_token (pfile, result);
1230             }
1231         }
1232       else
1233         {
1234           _cpp_pop_context (pfile);
1235           if (pfile->state.in_directive)
1236             continue;
1237           return &pfile->avoid_paste;
1238         }
1239
1240       if (pfile->state.in_directive && result->type == CPP_COMMENT)
1241         continue;
1242
1243       if (result->type != CPP_NAME)
1244         break;
1245
1246       node = result->val.node;
1247
1248       if (node->type != NT_MACRO || (result->flags & NO_EXPAND))
1249         break;
1250
1251       if (!(node->flags & NODE_DISABLED))
1252         {
1253           int ret = 0;
1254           /* If not in a macro context, and we're going to start an
1255              expansion, record the location.  */
1256           if (can_set && !context->macro)
1257             pfile->invocation_location = result->src_loc;
1258           if (pfile->state.prevent_expansion)
1259             break;
1260
1261           /* Conditional macros require that a predicate be evaluated
1262              first.  */
1263           if (((!(node->flags & NODE_CONDITIONAL))
1264                || (pfile->cb.macro_to_expand
1265                    && (node = pfile->cb.macro_to_expand (pfile, result))))
1266               && (ret = enter_macro_context (pfile, node, result)))
1267             {
1268               if (pfile->state.in_directive || ret == 2)
1269                 continue;
1270               return padding_token (pfile, result);
1271             }
1272         }
1273       else
1274         {
1275           /* Flag this token as always unexpandable.  FIXME: move this
1276              to collect_args()?.  */
1277           cpp_token *t = _cpp_temp_token (pfile);
1278           t->type = result->type;
1279           t->flags = result->flags | NO_EXPAND;
1280           t->val = result->val;
1281           result = t;
1282         }
1283
1284       break;
1285     }
1286
1287   return result;
1288 }
1289
1290 /* Like cpp_get_token, but also returns a location separate from the
1291    one provided by the returned token.  LOC is an out parameter; *LOC
1292    is set to the location "as expected by the user".  This matters
1293    when a token results from macro expansion -- the token's location
1294    will indicate where the macro is defined, but *LOC will be the
1295    location of the start of the expansion.  */
1296 const cpp_token *
1297 cpp_get_token_with_location (cpp_reader *pfile, source_location *loc)
1298 {
1299   const cpp_token *result;
1300
1301   pfile->set_invocation_location = true;
1302   result = cpp_get_token (pfile);
1303   if (pfile->context->macro)
1304     *loc = pfile->invocation_location;
1305   else
1306     *loc = result->src_loc;
1307
1308   return result;
1309 }
1310
1311 /* Returns true if we're expanding an object-like macro that was
1312    defined in a system header.  Just checks the macro at the top of
1313    the stack.  Used for diagnostic suppression.  */
1314 int
1315 cpp_sys_macro_p (cpp_reader *pfile)
1316 {
1317   cpp_hashnode *node = pfile->context->macro;
1318
1319   return node && node->value.macro && node->value.macro->syshdr;
1320 }
1321
1322 /* Read each token in, until end of the current file.  Directives are
1323    transparently processed.  */
1324 void
1325 cpp_scan_nooutput (cpp_reader *pfile)
1326 {
1327   /* Request a CPP_EOF token at the end of this file, rather than
1328      transparently continuing with the including file.  */
1329   pfile->buffer->return_at_eof = true;
1330
1331   pfile->state.discarding_output++;
1332   pfile->state.prevent_expansion++;
1333
1334   if (CPP_OPTION (pfile, traditional))
1335     while (_cpp_read_logical_line_trad (pfile))
1336       ;
1337   else
1338     while (cpp_get_token (pfile)->type != CPP_EOF)
1339       ;
1340
1341   pfile->state.discarding_output--;
1342   pfile->state.prevent_expansion--;
1343 }
1344
1345 /* Step back one or more tokens obtained from the lexer.  */
1346 void
1347 _cpp_backup_tokens_direct (cpp_reader *pfile, unsigned int count)
1348 {
1349   pfile->lookaheads += count;
1350   while (count--)
1351     {
1352       pfile->cur_token--;
1353       if (pfile->cur_token == pfile->cur_run->base
1354           /* Possible with -fpreprocessed and no leading #line.  */
1355           && pfile->cur_run->prev != NULL)
1356         {
1357           pfile->cur_run = pfile->cur_run->prev;
1358           pfile->cur_token = pfile->cur_run->limit;
1359         }
1360     }
1361 }
1362
1363 /* Step back one (or more) tokens.  Can only step back more than 1 if
1364    they are from the lexer, and not from macro expansion.  */
1365 void
1366 _cpp_backup_tokens (cpp_reader *pfile, unsigned int count)
1367 {
1368   if (pfile->context->prev == NULL)
1369     _cpp_backup_tokens_direct (pfile, count);
1370   else
1371     {
1372       if (count != 1)
1373         abort ();
1374       if (pfile->context->direct_p)
1375         FIRST (pfile->context).token--;
1376       else
1377         FIRST (pfile->context).ptoken--;
1378     }
1379 }
1380
1381 /* #define directive parsing and handling.  */
1382
1383 /* Returns nonzero if a macro redefinition warning is required.  */
1384 static bool
1385 warn_of_redefinition (cpp_reader *pfile, const cpp_hashnode *node,
1386                       const cpp_macro *macro2)
1387 {
1388   const cpp_macro *macro1;
1389   unsigned int i;
1390
1391   /* Some redefinitions need to be warned about regardless.  */
1392   if (node->flags & NODE_WARN)
1393     return true;
1394
1395   /* Redefinitions of conditional (context-sensitive) macros, on
1396      the other hand, must be allowed silently.  */
1397   if (node->flags & NODE_CONDITIONAL)
1398     return false;
1399
1400   /* Redefinition of a macro is allowed if and only if the old and new
1401      definitions are the same.  (6.10.3 paragraph 2).  */
1402   macro1 = node->value.macro;
1403
1404   /* Don't check count here as it can be different in valid
1405      traditional redefinitions with just whitespace differences.  */
1406   if (macro1->paramc != macro2->paramc
1407       || macro1->fun_like != macro2->fun_like
1408       || macro1->variadic != macro2->variadic)
1409     return true;
1410
1411   /* Check parameter spellings.  */
1412   for (i = 0; i < macro1->paramc; i++)
1413     if (macro1->params[i] != macro2->params[i])
1414       return true;
1415
1416   /* Check the replacement text or tokens.  */
1417   if (CPP_OPTION (pfile, traditional))
1418     return _cpp_expansions_different_trad (macro1, macro2);
1419
1420   if (macro1->count != macro2->count)
1421     return true;
1422
1423   for (i = 0; i < macro1->count; i++)
1424     if (!_cpp_equiv_tokens (&macro1->exp.tokens[i], &macro2->exp.tokens[i]))
1425       return true;
1426
1427   return false;
1428 }
1429
1430 /* Free the definition of hashnode H.  */
1431 void
1432 _cpp_free_definition (cpp_hashnode *h)
1433 {
1434   /* Macros and assertions no longer have anything to free.  */
1435   h->type = NT_VOID;
1436   /* Clear builtin flag in case of redefinition.  */
1437   h->flags &= ~(NODE_BUILTIN | NODE_DISABLED | NODE_USED);
1438 }
1439
1440 /* Save parameter NODE to the parameter list of macro MACRO.  Returns
1441    zero on success, nonzero if the parameter is a duplicate.  */
1442 bool
1443 _cpp_save_parameter (cpp_reader *pfile, cpp_macro *macro, cpp_hashnode *node)
1444 {
1445   unsigned int len;
1446   /* Constraint 6.10.3.6 - duplicate parameter names.  */
1447   if (node->flags & NODE_MACRO_ARG)
1448     {
1449       cpp_error (pfile, CPP_DL_ERROR, "duplicate macro parameter \"%s\"",
1450                  NODE_NAME (node));
1451       return true;
1452     }
1453
1454   if (BUFF_ROOM (pfile->a_buff)
1455       < (macro->paramc + 1) * sizeof (cpp_hashnode *))
1456     _cpp_extend_buff (pfile, &pfile->a_buff, sizeof (cpp_hashnode *));
1457
1458   ((cpp_hashnode **) BUFF_FRONT (pfile->a_buff))[macro->paramc++] = node;
1459   node->flags |= NODE_MACRO_ARG;
1460   len = macro->paramc * sizeof (union _cpp_hashnode_value);
1461   if (len > pfile->macro_buffer_len)
1462     {
1463       pfile->macro_buffer = XRESIZEVEC (unsigned char, pfile->macro_buffer,
1464                                         len);
1465       pfile->macro_buffer_len = len;
1466     }
1467   ((union _cpp_hashnode_value *) pfile->macro_buffer)[macro->paramc - 1]
1468     = node->value;
1469   
1470   node->value.arg_index  = macro->paramc;
1471   return false;
1472 }
1473
1474 /* Check the syntax of the parameters in a MACRO definition.  Returns
1475    false if an error occurs.  */
1476 static bool
1477 parse_params (cpp_reader *pfile, cpp_macro *macro)
1478 {
1479   unsigned int prev_ident = 0;
1480
1481   for (;;)
1482     {
1483       const cpp_token *token = _cpp_lex_token (pfile);
1484
1485       switch (token->type)
1486         {
1487         default:
1488           /* Allow/ignore comments in parameter lists if we are
1489              preserving comments in macro expansions.  */
1490           if (token->type == CPP_COMMENT
1491               && ! CPP_OPTION (pfile, discard_comments_in_macro_exp))
1492             continue;
1493
1494           cpp_error (pfile, CPP_DL_ERROR,
1495                      "\"%s\" may not appear in macro parameter list",
1496                      cpp_token_as_text (pfile, token));
1497           return false;
1498
1499         case CPP_NAME:
1500           if (prev_ident)
1501             {
1502               cpp_error (pfile, CPP_DL_ERROR,
1503                          "macro parameters must be comma-separated");
1504               return false;
1505             }
1506           prev_ident = 1;
1507
1508           if (_cpp_save_parameter (pfile, macro, token->val.node))
1509             return false;
1510           continue;
1511
1512         case CPP_CLOSE_PAREN:
1513           if (prev_ident || macro->paramc == 0)
1514             return true;
1515
1516           /* Fall through to pick up the error.  */
1517         case CPP_COMMA:
1518           if (!prev_ident)
1519             {
1520               cpp_error (pfile, CPP_DL_ERROR, "parameter name missing");
1521               return false;
1522             }
1523           prev_ident = 0;
1524           continue;
1525
1526         case CPP_ELLIPSIS:
1527           macro->variadic = 1;
1528           if (!prev_ident)
1529             {
1530               _cpp_save_parameter (pfile, macro,
1531                                    pfile->spec_nodes.n__VA_ARGS__);
1532               pfile->state.va_args_ok = 1;
1533               if (! CPP_OPTION (pfile, c99)
1534                   && CPP_OPTION (pfile, pedantic)
1535                   && CPP_OPTION (pfile, warn_variadic_macros))
1536                 cpp_error (pfile, CPP_DL_PEDWARN,
1537                            "anonymous variadic macros were introduced in C99");
1538             }
1539           else if (CPP_OPTION (pfile, pedantic)
1540                    && CPP_OPTION (pfile, warn_variadic_macros))
1541             cpp_error (pfile, CPP_DL_PEDWARN,
1542                        "ISO C does not permit named variadic macros");
1543
1544           /* We're at the end, and just expect a closing parenthesis.  */
1545           token = _cpp_lex_token (pfile);
1546           if (token->type == CPP_CLOSE_PAREN)
1547             return true;
1548           /* Fall through.  */
1549
1550         case CPP_EOF:
1551           cpp_error (pfile, CPP_DL_ERROR, "missing ')' in macro parameter list");
1552           return false;
1553         }
1554     }
1555 }
1556
1557 /* Allocate room for a token from a macro's replacement list.  */
1558 static cpp_token *
1559 alloc_expansion_token (cpp_reader *pfile, cpp_macro *macro)
1560 {
1561   if (BUFF_ROOM (pfile->a_buff) < (macro->count + 1) * sizeof (cpp_token))
1562     _cpp_extend_buff (pfile, &pfile->a_buff, sizeof (cpp_token));
1563
1564   return &((cpp_token *) BUFF_FRONT (pfile->a_buff))[macro->count++];
1565 }
1566
1567 /* Lex a token from the expansion of MACRO, but mark parameters as we
1568    find them and warn of traditional stringification.  */
1569 static cpp_token *
1570 lex_expansion_token (cpp_reader *pfile, cpp_macro *macro)
1571 {
1572   cpp_token *token, *saved_cur_token;
1573
1574   saved_cur_token = pfile->cur_token;
1575   pfile->cur_token = alloc_expansion_token (pfile, macro);
1576   token = _cpp_lex_direct (pfile);
1577   pfile->cur_token = saved_cur_token;
1578
1579   /* Is this a parameter?  */
1580   if (token->type == CPP_NAME
1581       && (token->val.node->flags & NODE_MACRO_ARG) != 0)
1582     {
1583       token->type = CPP_MACRO_ARG;
1584       token->val.arg_no = token->val.node->value.arg_index;
1585     }
1586   else if (CPP_WTRADITIONAL (pfile) && macro->paramc > 0
1587            && (token->type == CPP_STRING || token->type == CPP_CHAR))
1588     check_trad_stringification (pfile, macro, &token->val.str);
1589
1590   return token;
1591 }
1592
1593 static bool
1594 create_iso_definition (cpp_reader *pfile, cpp_macro *macro)
1595 {
1596   cpp_token *token;
1597   const cpp_token *ctoken;
1598   bool following_paste_op = false;
1599   const char *paste_op_error_msg =
1600     N_("'##' cannot appear at either end of a macro expansion");
1601
1602   /* Get the first token of the expansion (or the '(' of a
1603      function-like macro).  */
1604   ctoken = _cpp_lex_token (pfile);
1605
1606   if (ctoken->type == CPP_OPEN_PAREN && !(ctoken->flags & PREV_WHITE))
1607     {
1608       bool ok = parse_params (pfile, macro);
1609       macro->params = (cpp_hashnode **) BUFF_FRONT (pfile->a_buff);
1610       if (!ok)
1611         return false;
1612
1613       /* Success.  Commit or allocate the parameter array.  */
1614       if (pfile->hash_table->alloc_subobject)
1615         {
1616           cpp_hashnode **params =
1617             (cpp_hashnode **) pfile->hash_table->alloc_subobject
1618             (sizeof (cpp_hashnode *) * macro->paramc);
1619           memcpy (params, macro->params,
1620                   sizeof (cpp_hashnode *) * macro->paramc);
1621           macro->params = params;
1622         }
1623       else
1624         BUFF_FRONT (pfile->a_buff) = (uchar *) &macro->params[macro->paramc];
1625       macro->fun_like = 1;
1626     }
1627   else if (ctoken->type != CPP_EOF && !(ctoken->flags & PREV_WHITE))
1628     {
1629       /* While ISO C99 requires whitespace before replacement text
1630          in a macro definition, ISO C90 with TC1 allows there characters
1631          from the basic source character set.  */
1632       if (CPP_OPTION (pfile, c99))
1633         cpp_error (pfile, CPP_DL_PEDWARN,
1634                    "ISO C99 requires whitespace after the macro name");
1635       else
1636         {
1637           int warntype = CPP_DL_WARNING;
1638           switch (ctoken->type)
1639             {
1640             case CPP_ATSIGN:
1641             case CPP_AT_NAME:
1642             case CPP_OBJC_STRING:
1643               /* '@' is not in basic character set.  */
1644               warntype = CPP_DL_PEDWARN;
1645               break;
1646             case CPP_OTHER:
1647               /* Basic character set sans letters, digits and _.  */
1648               if (strchr ("!\"#%&'()*+,-./:;<=>?[\\]^{|}~",
1649                           ctoken->val.str.text[0]) == NULL)
1650                 warntype = CPP_DL_PEDWARN;
1651               break;
1652             default:
1653               /* All other tokens start with a character from basic
1654                  character set.  */
1655               break;
1656             }
1657           cpp_error (pfile, warntype,
1658                      "missing whitespace after the macro name");
1659         }
1660     }
1661
1662   if (macro->fun_like)
1663     token = lex_expansion_token (pfile, macro);
1664   else
1665     {
1666       token = alloc_expansion_token (pfile, macro);
1667       *token = *ctoken;
1668     }
1669
1670   for (;;)
1671     {
1672       /* Check the stringifying # constraint 6.10.3.2.1 of
1673          function-like macros when lexing the subsequent token.  */
1674       if (macro->count > 1 && token[-1].type == CPP_HASH && macro->fun_like)
1675         {
1676           if (token->type == CPP_MACRO_ARG)
1677             {
1678               token->flags &= ~PREV_WHITE;
1679               token->flags |= STRINGIFY_ARG;
1680               token->flags |= token[-1].flags & PREV_WHITE;
1681               token[-1] = token[0];
1682               macro->count--;
1683             }
1684           /* Let assembler get away with murder.  */
1685           else if (CPP_OPTION (pfile, lang) != CLK_ASM)
1686             {
1687               cpp_error (pfile, CPP_DL_ERROR,
1688                          "'#' is not followed by a macro parameter");
1689               return false;
1690             }
1691         }
1692
1693       if (token->type == CPP_EOF)
1694         {
1695           /* Paste operator constraint 6.10.3.3.1:
1696              Token-paste ##, can appear in both object-like and
1697              function-like macros, but not at the end.  */
1698           if (following_paste_op)
1699             {
1700               cpp_error (pfile, CPP_DL_ERROR, paste_op_error_msg);
1701               return false;
1702             }
1703           break;
1704         }
1705
1706       /* Paste operator constraint 6.10.3.3.1.  */
1707       if (token->type == CPP_PASTE)
1708         {
1709           /* Token-paste ##, can appear in both object-like and
1710              function-like macros, but not at the beginning.  */
1711           if (macro->count == 1)
1712             {
1713               cpp_error (pfile, CPP_DL_ERROR, paste_op_error_msg);
1714               return false;
1715             }
1716
1717           --macro->count;
1718           token[-1].flags |= PASTE_LEFT;
1719         }
1720
1721       following_paste_op = (token->type == CPP_PASTE);
1722       token = lex_expansion_token (pfile, macro);
1723     }
1724
1725   macro->exp.tokens = (cpp_token *) BUFF_FRONT (pfile->a_buff);
1726   macro->traditional = 0;
1727
1728   /* Don't count the CPP_EOF.  */
1729   macro->count--;
1730
1731   /* Clear whitespace on first token for warn_of_redefinition().  */
1732   if (macro->count)
1733     macro->exp.tokens[0].flags &= ~PREV_WHITE;
1734
1735   /* Commit or allocate the memory.  */
1736   if (pfile->hash_table->alloc_subobject)
1737     {
1738       cpp_token *tokns =
1739         (cpp_token *) pfile->hash_table->alloc_subobject (sizeof (cpp_token)
1740                                                           * macro->count);
1741       memcpy (tokns, macro->exp.tokens, sizeof (cpp_token) * macro->count);
1742       macro->exp.tokens = tokns;
1743     }
1744   else
1745     BUFF_FRONT (pfile->a_buff) = (uchar *) &macro->exp.tokens[macro->count];
1746
1747   return true;
1748 }
1749
1750 /* Parse a macro and save its expansion.  Returns nonzero on success.  */
1751 bool
1752 _cpp_create_definition (cpp_reader *pfile, cpp_hashnode *node)
1753 {
1754   cpp_macro *macro;
1755   unsigned int i;
1756   bool ok;
1757
1758   if (pfile->hash_table->alloc_subobject)
1759     macro = (cpp_macro *) pfile->hash_table->alloc_subobject
1760       (sizeof (cpp_macro));
1761   else
1762     macro = (cpp_macro *) _cpp_aligned_alloc (pfile, sizeof (cpp_macro));
1763   macro->line = pfile->directive_line;
1764   macro->params = 0;
1765   macro->paramc = 0;
1766   macro->variadic = 0;
1767   macro->used = !CPP_OPTION (pfile, warn_unused_macros);
1768   macro->count = 0;
1769   macro->fun_like = 0;
1770   /* To suppress some diagnostics.  */
1771   macro->syshdr = pfile->buffer && pfile->buffer->sysp != 0;
1772
1773   if (CPP_OPTION (pfile, traditional))
1774     ok = _cpp_create_trad_definition (pfile, macro);
1775   else
1776     {
1777       ok = create_iso_definition (pfile, macro);
1778
1779       /* We set the type for SEEN_EOL() in directives.c.
1780
1781          Longer term we should lex the whole line before coming here,
1782          and just copy the expansion.  */
1783
1784       /* Stop the lexer accepting __VA_ARGS__.  */
1785       pfile->state.va_args_ok = 0;
1786     }
1787
1788   /* Clear the fast argument lookup indices.  */
1789   for (i = macro->paramc; i-- > 0; )
1790     {
1791       struct cpp_hashnode *node = macro->params[i];
1792       node->flags &= ~ NODE_MACRO_ARG;
1793       node->value = ((union _cpp_hashnode_value *) pfile->macro_buffer)[i];
1794     }
1795
1796   if (!ok)
1797     return ok;
1798
1799   if (node->type == NT_MACRO)
1800     {
1801       if (CPP_OPTION (pfile, warn_unused_macros))
1802         _cpp_warn_if_unused_macro (pfile, node, NULL);
1803
1804       if (warn_of_redefinition (pfile, node, macro))
1805         {
1806           cpp_error_with_line (pfile, CPP_DL_PEDWARN, pfile->directive_line, 0,
1807                                "\"%s\" redefined", NODE_NAME (node));
1808
1809           if (node->type == NT_MACRO && !(node->flags & NODE_BUILTIN))
1810             cpp_error_with_line (pfile, CPP_DL_PEDWARN,
1811                                  node->value.macro->line, 0,
1812                          "this is the location of the previous definition");
1813         }
1814     }
1815
1816   if (node->type != NT_VOID)
1817     _cpp_free_definition (node);
1818
1819   /* Enter definition in hash table.  */
1820   node->type = NT_MACRO;
1821   node->value.macro = macro;
1822   if (! ustrncmp (NODE_NAME (node), DSC ("__STDC_"))
1823       && ustrcmp (NODE_NAME (node), (const uchar *) "__STDC_FORMAT_MACROS")
1824       /* __STDC_LIMIT_MACROS and __STDC_CONSTANT_MACROS are mentioned
1825          in the C standard, as something that one must use in C++.
1826          However DR#593 indicates that these aren't actually mentioned
1827          in the C++ standard.  We special-case them anyway.  */
1828       && ustrcmp (NODE_NAME (node), (const uchar *) "__STDC_LIMIT_MACROS")
1829       && ustrcmp (NODE_NAME (node), (const uchar *) "__STDC_CONSTANT_MACROS"))
1830     node->flags |= NODE_WARN;
1831
1832   /* If user defines one of the conditional macros, remove the
1833      conditional flag */
1834   node->flags &= ~NODE_CONDITIONAL;
1835
1836   return ok;
1837 }
1838
1839 /* Warn if a token in STRING matches one of a function-like MACRO's
1840    parameters.  */
1841 static void
1842 check_trad_stringification (cpp_reader *pfile, const cpp_macro *macro,
1843                             const cpp_string *string)
1844 {
1845   unsigned int i, len;
1846   const uchar *p, *q, *limit;
1847
1848   /* Loop over the string.  */
1849   limit = string->text + string->len - 1;
1850   for (p = string->text + 1; p < limit; p = q)
1851     {
1852       /* Find the start of an identifier.  */
1853       while (p < limit && !is_idstart (*p))
1854         p++;
1855
1856       /* Find the end of the identifier.  */
1857       q = p;
1858       while (q < limit && is_idchar (*q))
1859         q++;
1860
1861       len = q - p;
1862
1863       /* Loop over the function macro arguments to see if the
1864          identifier inside the string matches one of them.  */
1865       for (i = 0; i < macro->paramc; i++)
1866         {
1867           const cpp_hashnode *node = macro->params[i];
1868
1869           if (NODE_LEN (node) == len
1870               && !memcmp (p, NODE_NAME (node), len))
1871             {
1872               cpp_error (pfile, CPP_DL_WARNING,
1873            "macro argument \"%s\" would be stringified in traditional C",
1874                          NODE_NAME (node));
1875               break;
1876             }
1877         }
1878     }
1879 }
1880
1881 /* Returns the name, arguments and expansion of a macro, in a format
1882    suitable to be read back in again, and therefore also for DWARF 2
1883    debugging info.  e.g. "PASTE(X, Y) X ## Y", or "MACNAME EXPANSION".
1884    Caller is expected to generate the "#define" bit if needed.  The
1885    returned text is temporary, and automatically freed later.  */
1886 const unsigned char *
1887 cpp_macro_definition (cpp_reader *pfile, const cpp_hashnode *node)
1888 {
1889   unsigned int i, len;
1890   const cpp_macro *macro = node->value.macro;
1891   unsigned char *buffer;
1892
1893   if (node->type != NT_MACRO || (node->flags & NODE_BUILTIN))
1894     {
1895       cpp_error (pfile, CPP_DL_ICE,
1896                  "invalid hash type %d in cpp_macro_definition", node->type);
1897       return 0;
1898     }
1899
1900   /* Calculate length.  */
1901   len = NODE_LEN (node) + 2;                    /* ' ' and NUL.  */
1902   if (macro->fun_like)
1903     {
1904       len += 4;         /* "()" plus possible final ".." of named
1905                            varargs (we have + 1 below).  */
1906       for (i = 0; i < macro->paramc; i++)
1907         len += NODE_LEN (macro->params[i]) + 1; /* "," */
1908     }
1909
1910   /* This should match below where we fill in the buffer.  */
1911   if (CPP_OPTION (pfile, traditional))
1912     len += _cpp_replacement_text_len (macro);
1913   else
1914     {
1915       for (i = 0; i < macro->count; i++)
1916         {
1917           cpp_token *token = &macro->exp.tokens[i];
1918
1919           if (token->type == CPP_MACRO_ARG)
1920             len += NODE_LEN (macro->params[token->val.arg_no - 1]);
1921           else
1922             len += cpp_token_len (token);
1923
1924           if (token->flags & STRINGIFY_ARG)
1925             len++;                      /* "#" */
1926           if (token->flags & PASTE_LEFT)
1927             len += 3;           /* " ##" */
1928           if (token->flags & PREV_WHITE)
1929             len++;              /* " " */
1930         }
1931     }
1932
1933   if (len > pfile->macro_buffer_len)
1934     {
1935       pfile->macro_buffer = XRESIZEVEC (unsigned char,
1936                                         pfile->macro_buffer, len);
1937       pfile->macro_buffer_len = len;
1938     }
1939
1940   /* Fill in the buffer.  Start with the macro name.  */
1941   buffer = pfile->macro_buffer;
1942   memcpy (buffer, NODE_NAME (node), NODE_LEN (node));
1943   buffer += NODE_LEN (node);
1944
1945   /* Parameter names.  */
1946   if (macro->fun_like)
1947     {
1948       *buffer++ = '(';
1949       for (i = 0; i < macro->paramc; i++)
1950         {
1951           cpp_hashnode *param = macro->params[i];
1952
1953           if (param != pfile->spec_nodes.n__VA_ARGS__)
1954             {
1955               memcpy (buffer, NODE_NAME (param), NODE_LEN (param));
1956               buffer += NODE_LEN (param);
1957             }
1958
1959           if (i + 1 < macro->paramc)
1960             /* Don't emit a space after the comma here; we're trying
1961                to emit a Dwarf-friendly definition, and the Dwarf spec
1962                forbids spaces in the argument list.  */
1963             *buffer++ = ',';
1964           else if (macro->variadic)
1965             *buffer++ = '.', *buffer++ = '.', *buffer++ = '.';
1966         }
1967       *buffer++ = ')';
1968     }
1969
1970   /* The Dwarf spec requires a space after the macro name, even if the
1971      definition is the empty string.  */
1972   *buffer++ = ' ';
1973
1974   if (CPP_OPTION (pfile, traditional))
1975     buffer = _cpp_copy_replacement_text (macro, buffer);
1976   else if (macro->count)
1977   /* Expansion tokens.  */
1978     {
1979       for (i = 0; i < macro->count; i++)
1980         {
1981           cpp_token *token = &macro->exp.tokens[i];
1982
1983           if (token->flags & PREV_WHITE)
1984             *buffer++ = ' ';
1985           if (token->flags & STRINGIFY_ARG)
1986             *buffer++ = '#';
1987
1988           if (token->type == CPP_MACRO_ARG)
1989             {
1990               memcpy (buffer,
1991                       NODE_NAME (macro->params[token->val.arg_no - 1]),
1992                       NODE_LEN (macro->params[token->val.arg_no - 1]));
1993               buffer += NODE_LEN (macro->params[token->val.arg_no - 1]);
1994             }
1995           else
1996             buffer = cpp_spell_token (pfile, token, buffer, false);
1997
1998           if (token->flags & PASTE_LEFT)
1999             {
2000               *buffer++ = ' ';
2001               *buffer++ = '#';
2002               *buffer++ = '#';
2003               /* Next has PREV_WHITE; see _cpp_create_definition.  */
2004             }
2005         }
2006     }
2007
2008   *buffer = '\0';
2009   return pfile->macro_buffer;
2010 }