OSDN Git Service

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