OSDN Git Service

016754bc9529566ce2929bd1801bf13942b2f39c
[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
1013       /* Avoid paste on RHS (even case count == 0).  */
1014       if (!pfile->state.in_directive && !(src->flags & PASTE_LEFT))
1015         *dest++ = &pfile->avoid_paste;
1016
1017       /* Add a new paste flag, or remove an unwanted one.  */
1018       if (paste_flag)
1019         {
1020           cpp_token *token = _cpp_temp_token (pfile);
1021           token->type = (*paste_flag)->type;
1022           token->val = (*paste_flag)->val;
1023           if (src->flags & PASTE_LEFT)
1024             token->flags = (*paste_flag)->flags | PASTE_LEFT;
1025           else
1026             token->flags = (*paste_flag)->flags & ~PASTE_LEFT;
1027           *paste_flag = token;
1028         }
1029     }
1030
1031   /* Free the expanded arguments.  */
1032   for (i = 0; i < macro->paramc; i++)
1033     if (args[i].expanded)
1034       free (args[i].expanded);
1035
1036   push_ptoken_context (pfile, node, buff, first, dest - first);
1037 }
1038
1039 /* Return a special padding token, with padding inherited from SOURCE.  */
1040 static const cpp_token *
1041 padding_token (cpp_reader *pfile, const cpp_token *source)
1042 {
1043   cpp_token *result = _cpp_temp_token (pfile);
1044
1045   result->type = CPP_PADDING;
1046
1047   /* Data in GCed data structures cannot be made const so far, so we
1048      need a cast here.  */
1049   result->val.source = (cpp_token *) source;
1050   result->flags = 0;
1051   return result;
1052 }
1053
1054 /* Get a new uninitialized context.  Create a new one if we cannot
1055    re-use an old one.  */
1056 static cpp_context *
1057 next_context (cpp_reader *pfile)
1058 {
1059   cpp_context *result = pfile->context->next;
1060
1061   if (result == 0)
1062     {
1063       result = XNEW (cpp_context);
1064       result->prev = pfile->context;
1065       result->next = 0;
1066       pfile->context->next = result;
1067     }
1068
1069   pfile->context = result;
1070   return result;
1071 }
1072
1073 /* Push a list of pointers to tokens.  */
1074 static void
1075 push_ptoken_context (cpp_reader *pfile, cpp_hashnode *macro, _cpp_buff *buff,
1076                      const cpp_token **first, unsigned int count)
1077 {
1078   cpp_context *context = next_context (pfile);
1079
1080   context->direct_p = false;
1081   context->macro = macro;
1082   context->buff = buff;
1083   FIRST (context).ptoken = first;
1084   LAST (context).ptoken = first + count;
1085 }
1086
1087 /* Push a list of tokens.  */
1088 void
1089 _cpp_push_token_context (cpp_reader *pfile, cpp_hashnode *macro,
1090                          const cpp_token *first, unsigned int count)
1091 {
1092   cpp_context *context = next_context (pfile);
1093
1094   context->direct_p = true;
1095   context->macro = macro;
1096   context->buff = NULL;
1097   FIRST (context).token = first;
1098   LAST (context).token = first + count;
1099 }
1100
1101 /* Push a traditional macro's replacement text.  */
1102 void
1103 _cpp_push_text_context (cpp_reader *pfile, cpp_hashnode *macro,
1104                         const uchar *start, size_t len)
1105 {
1106   cpp_context *context = next_context (pfile);
1107
1108   context->direct_p = true;
1109   context->macro = macro;
1110   context->buff = NULL;
1111   CUR (context) = start;
1112   RLIMIT (context) = start + len;
1113   macro->flags |= NODE_DISABLED;
1114 }
1115
1116 /* Expand an argument ARG before replacing parameters in a
1117    function-like macro.  This works by pushing a context with the
1118    argument's tokens, and then expanding that into a temporary buffer
1119    as if it were a normal part of the token stream.  collect_args()
1120    has terminated the argument's tokens with a CPP_EOF so that we know
1121    when we have fully expanded the argument.  */
1122 static void
1123 expand_arg (cpp_reader *pfile, macro_arg *arg)
1124 {
1125   unsigned int capacity;
1126   bool saved_warn_trad;
1127
1128   if (arg->count == 0)
1129     return;
1130
1131   /* Don't warn about funlike macros when pre-expanding.  */
1132   saved_warn_trad = CPP_WTRADITIONAL (pfile);
1133   CPP_WTRADITIONAL (pfile) = 0;
1134
1135   /* Loop, reading in the arguments.  */
1136   capacity = 256;
1137   arg->expanded = XNEWVEC (const cpp_token *, capacity);
1138
1139   push_ptoken_context (pfile, NULL, NULL, arg->first, arg->count + 1);
1140   for (;;)
1141     {
1142       const cpp_token *token;
1143
1144       if (arg->expanded_count + 1 >= capacity)
1145         {
1146           capacity *= 2;
1147           arg->expanded = XRESIZEVEC (const cpp_token *, arg->expanded,
1148                                       capacity);
1149         }
1150
1151       token = cpp_get_token (pfile);
1152
1153       if (token->type == CPP_EOF)
1154         break;
1155
1156       arg->expanded[arg->expanded_count++] = token;
1157     }
1158
1159   _cpp_pop_context (pfile);
1160
1161   CPP_WTRADITIONAL (pfile) = saved_warn_trad;
1162 }
1163
1164 /* Pop the current context off the stack, re-enabling the macro if the
1165    context represented a macro's replacement list.  The context
1166    structure is not freed so that we can re-use it later.  */
1167 void
1168 _cpp_pop_context (cpp_reader *pfile)
1169 {
1170   cpp_context *context = pfile->context;
1171
1172   if (context->macro)
1173     context->macro->flags &= ~NODE_DISABLED;
1174
1175   if (context->buff)
1176     _cpp_release_buff (pfile, context->buff);
1177
1178   pfile->context = context->prev;
1179 }
1180
1181 /* External routine to get a token.  Also used nearly everywhere
1182    internally, except for places where we know we can safely call
1183    _cpp_lex_token directly, such as lexing a directive name.
1184
1185    Macro expansions and directives are transparently handled,
1186    including entering included files.  Thus tokens are post-macro
1187    expansion, and after any intervening directives.  External callers
1188    see CPP_EOF only at EOF.  Internal callers also see it when meeting
1189    a directive inside a macro call, when at the end of a directive and
1190    state.in_directive is still 1, and at the end of argument
1191    pre-expansion.  */
1192 const cpp_token *
1193 cpp_get_token (cpp_reader *pfile)
1194 {
1195   const cpp_token *result;
1196   bool can_set = pfile->set_invocation_location;
1197   pfile->set_invocation_location = false;
1198
1199   for (;;)
1200     {
1201       cpp_hashnode *node;
1202       cpp_context *context = pfile->context;
1203
1204       /* Context->prev == 0 <=> base context.  */
1205       if (!context->prev)
1206         result = _cpp_lex_token (pfile);
1207       else if (FIRST (context).token != LAST (context).token)
1208         {
1209           if (context->direct_p)
1210             result = FIRST (context).token++;
1211           else
1212             result = *FIRST (context).ptoken++;
1213
1214           if (result->flags & PASTE_LEFT)
1215             {
1216               paste_all_tokens (pfile, result);
1217               if (pfile->state.in_directive)
1218                 continue;
1219               return padding_token (pfile, result);
1220             }
1221         }
1222       else
1223         {
1224           _cpp_pop_context (pfile);
1225           if (pfile->state.in_directive)
1226             continue;
1227           return &pfile->avoid_paste;
1228         }
1229
1230       if (pfile->state.in_directive && result->type == CPP_COMMENT)
1231         continue;
1232
1233       if (result->type != CPP_NAME)
1234         break;
1235
1236       node = result->val.node;
1237
1238       if (node->type != NT_MACRO || (result->flags & NO_EXPAND))
1239         break;
1240
1241       if (!(node->flags & NODE_DISABLED))
1242         {
1243           int ret;
1244           /* If not in a macro context, and we're going to start an
1245              expansion, record the location.  */
1246           if (can_set && !context->macro)
1247             pfile->invocation_location = result->src_loc;
1248           if (pfile->state.prevent_expansion)
1249             break;
1250           ret = enter_macro_context (pfile, node, result);
1251           if (ret)
1252             {
1253               if (pfile->state.in_directive || ret == 2)
1254                 continue;
1255               return padding_token (pfile, result);
1256             }
1257         }
1258       else
1259         {
1260           /* Flag this token as always unexpandable.  FIXME: move this
1261              to collect_args()?.  */
1262           cpp_token *t = _cpp_temp_token (pfile);
1263           t->type = result->type;
1264           t->flags = result->flags | NO_EXPAND;
1265           t->val = result->val;
1266           result = t;
1267         }
1268
1269       break;
1270     }
1271
1272   return result;
1273 }
1274
1275 /* Like cpp_get_token, but also returns a location separate from the
1276    one provided by the returned token.  LOC is an out parameter; *LOC
1277    is set to the location "as expected by the user".  This matters
1278    when a token results from macro expansion -- the token's location
1279    will indicate where the macro is defined, but *LOC will be the
1280    location of the start of the expansion.  */
1281 const cpp_token *
1282 cpp_get_token_with_location (cpp_reader *pfile, source_location *loc)
1283 {
1284   const cpp_token *result;
1285
1286   pfile->set_invocation_location = true;
1287   result = cpp_get_token (pfile);
1288   if (pfile->context->macro)
1289     *loc = pfile->invocation_location;
1290   else
1291     *loc = result->src_loc;
1292
1293   return result;
1294 }
1295
1296 /* Returns true if we're expanding an object-like macro that was
1297    defined in a system header.  Just checks the macro at the top of
1298    the stack.  Used for diagnostic suppression.  */
1299 int
1300 cpp_sys_macro_p (cpp_reader *pfile)
1301 {
1302   cpp_hashnode *node = pfile->context->macro;
1303
1304   return node && node->value.macro && node->value.macro->syshdr;
1305 }
1306
1307 /* Read each token in, until end of the current file.  Directives are
1308    transparently processed.  */
1309 void
1310 cpp_scan_nooutput (cpp_reader *pfile)
1311 {
1312   /* Request a CPP_EOF token at the end of this file, rather than
1313      transparently continuing with the including file.  */
1314   pfile->buffer->return_at_eof = true;
1315
1316   pfile->state.discarding_output++;
1317   pfile->state.prevent_expansion++;
1318
1319   if (CPP_OPTION (pfile, traditional))
1320     while (_cpp_read_logical_line_trad (pfile))
1321       ;
1322   else
1323     while (cpp_get_token (pfile)->type != CPP_EOF)
1324       ;
1325
1326   pfile->state.discarding_output--;
1327   pfile->state.prevent_expansion--;
1328 }
1329
1330 /* Step back one (or more) tokens.  Can only step back more than 1 if
1331    they are from the lexer, and not from macro expansion.  */
1332 void
1333 _cpp_backup_tokens (cpp_reader *pfile, unsigned int count)
1334 {
1335   if (pfile->context->prev == NULL)
1336     {
1337       pfile->lookaheads += count;
1338       while (count--)
1339         {
1340           pfile->cur_token--;
1341           if (pfile->cur_token == pfile->cur_run->base
1342               /* Possible with -fpreprocessed and no leading #line.  */
1343               && pfile->cur_run->prev != NULL)
1344             {
1345               pfile->cur_run = pfile->cur_run->prev;
1346               pfile->cur_token = pfile->cur_run->limit;
1347             }
1348         }
1349     }
1350   else
1351     {
1352       if (count != 1)
1353         abort ();
1354       if (pfile->context->direct_p)
1355         FIRST (pfile->context).token--;
1356       else
1357         FIRST (pfile->context).ptoken--;
1358     }
1359 }
1360
1361 /* #define directive parsing and handling.  */
1362
1363 /* Returns nonzero if a macro redefinition warning is required.  */
1364 static bool
1365 warn_of_redefinition (cpp_reader *pfile, const cpp_hashnode *node,
1366                       const cpp_macro *macro2)
1367 {
1368   const cpp_macro *macro1;
1369   unsigned int i;
1370
1371   /* Some redefinitions need to be warned about regardless.  */
1372   if (node->flags & NODE_WARN)
1373     return true;
1374
1375   /* Redefinition of a macro is allowed if and only if the old and new
1376      definitions are the same.  (6.10.3 paragraph 2).  */
1377   macro1 = node->value.macro;
1378
1379   /* Don't check count here as it can be different in valid
1380      traditional redefinitions with just whitespace differences.  */
1381   if (macro1->paramc != macro2->paramc
1382       || macro1->fun_like != macro2->fun_like
1383       || macro1->variadic != macro2->variadic)
1384     return true;
1385
1386   /* Check parameter spellings.  */
1387   for (i = 0; i < macro1->paramc; i++)
1388     if (macro1->params[i] != macro2->params[i])
1389       return true;
1390
1391   /* Check the replacement text or tokens.  */
1392   if (CPP_OPTION (pfile, traditional))
1393     return _cpp_expansions_different_trad (macro1, macro2);
1394
1395   if (macro1->count != macro2->count)
1396     return true;
1397
1398   for (i = 0; i < macro1->count; i++)
1399     if (!_cpp_equiv_tokens (&macro1->exp.tokens[i], &macro2->exp.tokens[i]))
1400       return true;
1401
1402   return false;
1403 }
1404
1405 /* Free the definition of hashnode H.  */
1406 void
1407 _cpp_free_definition (cpp_hashnode *h)
1408 {
1409   /* Macros and assertions no longer have anything to free.  */
1410   h->type = NT_VOID;
1411   /* Clear builtin flag in case of redefinition.  */
1412   h->flags &= ~(NODE_BUILTIN | NODE_DISABLED | NODE_USED);
1413 }
1414
1415 /* Save parameter NODE to the parameter list of macro MACRO.  Returns
1416    zero on success, nonzero if the parameter is a duplicate.  */
1417 bool
1418 _cpp_save_parameter (cpp_reader *pfile, cpp_macro *macro, cpp_hashnode *node)
1419 {
1420   unsigned int len;
1421   /* Constraint 6.10.3.6 - duplicate parameter names.  */
1422   if (node->flags & NODE_MACRO_ARG)
1423     {
1424       cpp_error (pfile, CPP_DL_ERROR, "duplicate macro parameter \"%s\"",
1425                  NODE_NAME (node));
1426       return true;
1427     }
1428
1429   if (BUFF_ROOM (pfile->a_buff)
1430       < (macro->paramc + 1) * sizeof (cpp_hashnode *))
1431     _cpp_extend_buff (pfile, &pfile->a_buff, sizeof (cpp_hashnode *));
1432
1433   ((cpp_hashnode **) BUFF_FRONT (pfile->a_buff))[macro->paramc++] = node;
1434   node->flags |= NODE_MACRO_ARG;
1435   len = macro->paramc * sizeof (union _cpp_hashnode_value);
1436   if (len > pfile->macro_buffer_len)
1437     {
1438       pfile->macro_buffer = XRESIZEVEC (unsigned char, pfile->macro_buffer,
1439                                         len);
1440       pfile->macro_buffer_len = len;
1441     }
1442   ((union _cpp_hashnode_value *) pfile->macro_buffer)[macro->paramc - 1]
1443     = node->value;
1444   
1445   node->value.arg_index  = macro->paramc;
1446   return false;
1447 }
1448
1449 /* Check the syntax of the parameters in a MACRO definition.  Returns
1450    false if an error occurs.  */
1451 static bool
1452 parse_params (cpp_reader *pfile, cpp_macro *macro)
1453 {
1454   unsigned int prev_ident = 0;
1455
1456   for (;;)
1457     {
1458       const cpp_token *token = _cpp_lex_token (pfile);
1459
1460       switch (token->type)
1461         {
1462         default:
1463           /* Allow/ignore comments in parameter lists if we are
1464              preserving comments in macro expansions.  */
1465           if (token->type == CPP_COMMENT
1466               && ! CPP_OPTION (pfile, discard_comments_in_macro_exp))
1467             continue;
1468
1469           cpp_error (pfile, CPP_DL_ERROR,
1470                      "\"%s\" may not appear in macro parameter list",
1471                      cpp_token_as_text (pfile, token));
1472           return false;
1473
1474         case CPP_NAME:
1475           if (prev_ident)
1476             {
1477               cpp_error (pfile, CPP_DL_ERROR,
1478                          "macro parameters must be comma-separated");
1479               return false;
1480             }
1481           prev_ident = 1;
1482
1483           if (_cpp_save_parameter (pfile, macro, token->val.node))
1484             return false;
1485           continue;
1486
1487         case CPP_CLOSE_PAREN:
1488           if (prev_ident || macro->paramc == 0)
1489             return true;
1490
1491           /* Fall through to pick up the error.  */
1492         case CPP_COMMA:
1493           if (!prev_ident)
1494             {
1495               cpp_error (pfile, CPP_DL_ERROR, "parameter name missing");
1496               return false;
1497             }
1498           prev_ident = 0;
1499           continue;
1500
1501         case CPP_ELLIPSIS:
1502           macro->variadic = 1;
1503           if (!prev_ident)
1504             {
1505               _cpp_save_parameter (pfile, macro,
1506                                    pfile->spec_nodes.n__VA_ARGS__);
1507               pfile->state.va_args_ok = 1;
1508               if (! CPP_OPTION (pfile, c99)
1509                   && CPP_OPTION (pfile, pedantic)
1510                   && CPP_OPTION (pfile, warn_variadic_macros))
1511                 cpp_error (pfile, CPP_DL_PEDWARN,
1512                            "anonymous variadic macros were introduced in C99");
1513             }
1514           else if (CPP_OPTION (pfile, pedantic)
1515                    && CPP_OPTION (pfile, warn_variadic_macros))
1516             cpp_error (pfile, CPP_DL_PEDWARN,
1517                        "ISO C does not permit named variadic macros");
1518
1519           /* We're at the end, and just expect a closing parenthesis.  */
1520           token = _cpp_lex_token (pfile);
1521           if (token->type == CPP_CLOSE_PAREN)
1522             return true;
1523           /* Fall through.  */
1524
1525         case CPP_EOF:
1526           cpp_error (pfile, CPP_DL_ERROR, "missing ')' in macro parameter list");
1527           return false;
1528         }
1529     }
1530 }
1531
1532 /* Allocate room for a token from a macro's replacement list.  */
1533 static cpp_token *
1534 alloc_expansion_token (cpp_reader *pfile, cpp_macro *macro)
1535 {
1536   if (BUFF_ROOM (pfile->a_buff) < (macro->count + 1) * sizeof (cpp_token))
1537     _cpp_extend_buff (pfile, &pfile->a_buff, sizeof (cpp_token));
1538
1539   return &((cpp_token *) BUFF_FRONT (pfile->a_buff))[macro->count++];
1540 }
1541
1542 /* Lex a token from the expansion of MACRO, but mark parameters as we
1543    find them and warn of traditional stringification.  */
1544 static cpp_token *
1545 lex_expansion_token (cpp_reader *pfile, cpp_macro *macro)
1546 {
1547   cpp_token *token, *saved_cur_token;
1548
1549   saved_cur_token = pfile->cur_token;
1550   pfile->cur_token = alloc_expansion_token (pfile, macro);
1551   token = _cpp_lex_direct (pfile);
1552   pfile->cur_token = saved_cur_token;
1553
1554   /* Is this a parameter?  */
1555   if (token->type == CPP_NAME
1556       && (token->val.node->flags & NODE_MACRO_ARG) != 0)
1557     {
1558       token->type = CPP_MACRO_ARG;
1559       token->val.arg_no = token->val.node->value.arg_index;
1560     }
1561   else if (CPP_WTRADITIONAL (pfile) && macro->paramc > 0
1562            && (token->type == CPP_STRING || token->type == CPP_CHAR))
1563     check_trad_stringification (pfile, macro, &token->val.str);
1564
1565   return token;
1566 }
1567
1568 static bool
1569 create_iso_definition (cpp_reader *pfile, cpp_macro *macro)
1570 {
1571   cpp_token *token;
1572   const cpp_token *ctoken;
1573   bool following_paste_op = false;
1574   const char *paste_op_error_msg =
1575     N_("'##' cannot appear at either end of a macro expansion");
1576
1577   /* Get the first token of the expansion (or the '(' of a
1578      function-like macro).  */
1579   ctoken = _cpp_lex_token (pfile);
1580
1581   if (ctoken->type == CPP_OPEN_PAREN && !(ctoken->flags & PREV_WHITE))
1582     {
1583       bool ok = parse_params (pfile, macro);
1584       macro->params = (cpp_hashnode **) BUFF_FRONT (pfile->a_buff);
1585       if (!ok)
1586         return false;
1587
1588       /* Success.  Commit or allocate the parameter array.  */
1589       if (pfile->hash_table->alloc_subobject)
1590         {
1591           cpp_hashnode **params =
1592             (cpp_hashnode **) pfile->hash_table->alloc_subobject
1593             (sizeof (cpp_hashnode *) * macro->paramc);
1594           memcpy (params, macro->params,
1595                   sizeof (cpp_hashnode *) * macro->paramc);
1596           macro->params = params;
1597         }
1598       else
1599         BUFF_FRONT (pfile->a_buff) = (uchar *) &macro->params[macro->paramc];
1600       macro->fun_like = 1;
1601     }
1602   else if (ctoken->type != CPP_EOF && !(ctoken->flags & PREV_WHITE))
1603     {
1604       /* While ISO C99 requires whitespace before replacement text
1605          in a macro definition, ISO C90 with TC1 allows there characters
1606          from the basic source character set.  */
1607       if (CPP_OPTION (pfile, c99))
1608         cpp_error (pfile, CPP_DL_PEDWARN,
1609                    "ISO C99 requires whitespace after the macro name");
1610       else
1611         {
1612           int warntype = CPP_DL_WARNING;
1613           switch (ctoken->type)
1614             {
1615             case CPP_ATSIGN:
1616             case CPP_AT_NAME:
1617             case CPP_OBJC_STRING:
1618               /* '@' is not in basic character set.  */
1619               warntype = CPP_DL_PEDWARN;
1620               break;
1621             case CPP_OTHER:
1622               /* Basic character set sans letters, digits and _.  */
1623               if (strchr ("!\"#%&'()*+,-./:;<=>?[\\]^{|}~",
1624                           ctoken->val.str.text[0]) == NULL)
1625                 warntype = CPP_DL_PEDWARN;
1626               break;
1627             default:
1628               /* All other tokens start with a character from basic
1629                  character set.  */
1630               break;
1631             }
1632           cpp_error (pfile, warntype,
1633                      "missing whitespace after the macro name");
1634         }
1635     }
1636
1637   if (macro->fun_like)
1638     token = lex_expansion_token (pfile, macro);
1639   else
1640     {
1641       token = alloc_expansion_token (pfile, macro);
1642       *token = *ctoken;
1643     }
1644
1645   for (;;)
1646     {
1647       /* Check the stringifying # constraint 6.10.3.2.1 of
1648          function-like macros when lexing the subsequent token.  */
1649       if (macro->count > 1 && token[-1].type == CPP_HASH && macro->fun_like)
1650         {
1651           if (token->type == CPP_MACRO_ARG)
1652             {
1653               token->flags &= ~PREV_WHITE;
1654               token->flags |= STRINGIFY_ARG;
1655               token->flags |= token[-1].flags & PREV_WHITE;
1656               token[-1] = token[0];
1657               macro->count--;
1658             }
1659           /* Let assembler get away with murder.  */
1660           else if (CPP_OPTION (pfile, lang) != CLK_ASM)
1661             {
1662               cpp_error (pfile, CPP_DL_ERROR,
1663                          "'#' is not followed by a macro parameter");
1664               return false;
1665             }
1666         }
1667
1668       if (token->type == CPP_EOF)
1669         {
1670           /* Paste operator constraint 6.10.3.3.1:
1671              Token-paste ##, can appear in both object-like and
1672              function-like macros, but not at the end.  */
1673           if (following_paste_op)
1674             {
1675               cpp_error (pfile, CPP_DL_ERROR, paste_op_error_msg);
1676               return false;
1677             }
1678           break;
1679         }
1680
1681       /* Paste operator constraint 6.10.3.3.1.  */
1682       if (token->type == CPP_PASTE)
1683         {
1684           /* Token-paste ##, can appear in both object-like and
1685              function-like macros, but not at the beginning.  */
1686           if (macro->count == 1)
1687             {
1688               cpp_error (pfile, CPP_DL_ERROR, paste_op_error_msg);
1689               return false;
1690             }
1691
1692           --macro->count;
1693           token[-1].flags |= PASTE_LEFT;
1694         }
1695
1696       following_paste_op = (token->type == CPP_PASTE);
1697       token = lex_expansion_token (pfile, macro);
1698     }
1699
1700   macro->exp.tokens = (cpp_token *) BUFF_FRONT (pfile->a_buff);
1701   macro->traditional = 0;
1702
1703   /* Don't count the CPP_EOF.  */
1704   macro->count--;
1705
1706   /* Clear whitespace on first token for warn_of_redefinition().  */
1707   if (macro->count)
1708     macro->exp.tokens[0].flags &= ~PREV_WHITE;
1709
1710   /* Commit or allocate the memory.  */
1711   if (pfile->hash_table->alloc_subobject)
1712     {
1713       cpp_token *tokns =
1714         (cpp_token *) pfile->hash_table->alloc_subobject (sizeof (cpp_token)
1715                                                           * macro->count);
1716       memcpy (tokns, macro->exp.tokens, sizeof (cpp_token) * macro->count);
1717       macro->exp.tokens = tokns;
1718     }
1719   else
1720     BUFF_FRONT (pfile->a_buff) = (uchar *) &macro->exp.tokens[macro->count];
1721
1722   return true;
1723 }
1724
1725 /* Parse a macro and save its expansion.  Returns nonzero on success.  */
1726 bool
1727 _cpp_create_definition (cpp_reader *pfile, cpp_hashnode *node)
1728 {
1729   cpp_macro *macro;
1730   unsigned int i;
1731   bool ok;
1732
1733   if (pfile->hash_table->alloc_subobject)
1734     macro = (cpp_macro *) pfile->hash_table->alloc_subobject
1735       (sizeof (cpp_macro));
1736   else
1737     macro = (cpp_macro *) _cpp_aligned_alloc (pfile, sizeof (cpp_macro));
1738   macro->line = pfile->directive_line;
1739   macro->params = 0;
1740   macro->paramc = 0;
1741   macro->variadic = 0;
1742   macro->used = !CPP_OPTION (pfile, warn_unused_macros);
1743   macro->count = 0;
1744   macro->fun_like = 0;
1745   /* To suppress some diagnostics.  */
1746   macro->syshdr = pfile->buffer && pfile->buffer->sysp != 0;
1747
1748   if (CPP_OPTION (pfile, traditional))
1749     ok = _cpp_create_trad_definition (pfile, macro);
1750   else
1751     {
1752       ok = create_iso_definition (pfile, macro);
1753
1754       /* We set the type for SEEN_EOL() in directives.c.
1755
1756          Longer term we should lex the whole line before coming here,
1757          and just copy the expansion.  */
1758
1759       /* Stop the lexer accepting __VA_ARGS__.  */
1760       pfile->state.va_args_ok = 0;
1761     }
1762
1763   /* Clear the fast argument lookup indices.  */
1764   for (i = macro->paramc; i-- > 0; )
1765     {
1766       struct cpp_hashnode *node = macro->params[i];
1767       node->flags &= ~ NODE_MACRO_ARG;
1768       node->value = ((union _cpp_hashnode_value *) pfile->macro_buffer)[i];
1769     }
1770
1771   if (!ok)
1772     return ok;
1773
1774   if (node->type == NT_MACRO)
1775     {
1776       if (CPP_OPTION (pfile, warn_unused_macros))
1777         _cpp_warn_if_unused_macro (pfile, node, NULL);
1778
1779       if (warn_of_redefinition (pfile, node, macro))
1780         {
1781           cpp_error_with_line (pfile, CPP_DL_PEDWARN, pfile->directive_line, 0,
1782                                "\"%s\" redefined", NODE_NAME (node));
1783
1784           if (node->type == NT_MACRO && !(node->flags & NODE_BUILTIN))
1785             cpp_error_with_line (pfile, CPP_DL_PEDWARN,
1786                                  node->value.macro->line, 0,
1787                          "this is the location of the previous definition");
1788         }
1789     }
1790
1791   if (node->type != NT_VOID)
1792     _cpp_free_definition (node);
1793
1794   /* Enter definition in hash table.  */
1795   node->type = NT_MACRO;
1796   node->value.macro = macro;
1797   if (! ustrncmp (NODE_NAME (node), DSC ("__STDC_"))
1798       && ustrcmp (NODE_NAME (node), (const uchar *) "__STDC_FORMAT_MACROS")
1799       /* __STDC_LIMIT_MACROS and __STDC_CONSTANT_MACROS are mentioned
1800          in the C standard, as something that one must use in C++.
1801          However DR#593 indicates that these aren't actually mentioned
1802          in the C++ standard.  We special-case them anyway.  */
1803       && ustrcmp (NODE_NAME (node), (const uchar *) "__STDC_LIMIT_MACROS")
1804       && ustrcmp (NODE_NAME (node), (const uchar *) "__STDC_CONSTANT_MACROS"))
1805     node->flags |= NODE_WARN;
1806
1807   return ok;
1808 }
1809
1810 /* Warn if a token in STRING matches one of a function-like MACRO's
1811    parameters.  */
1812 static void
1813 check_trad_stringification (cpp_reader *pfile, const cpp_macro *macro,
1814                             const cpp_string *string)
1815 {
1816   unsigned int i, len;
1817   const uchar *p, *q, *limit;
1818
1819   /* Loop over the string.  */
1820   limit = string->text + string->len - 1;
1821   for (p = string->text + 1; p < limit; p = q)
1822     {
1823       /* Find the start of an identifier.  */
1824       while (p < limit && !is_idstart (*p))
1825         p++;
1826
1827       /* Find the end of the identifier.  */
1828       q = p;
1829       while (q < limit && is_idchar (*q))
1830         q++;
1831
1832       len = q - p;
1833
1834       /* Loop over the function macro arguments to see if the
1835          identifier inside the string matches one of them.  */
1836       for (i = 0; i < macro->paramc; i++)
1837         {
1838           const cpp_hashnode *node = macro->params[i];
1839
1840           if (NODE_LEN (node) == len
1841               && !memcmp (p, NODE_NAME (node), len))
1842             {
1843               cpp_error (pfile, CPP_DL_WARNING,
1844            "macro argument \"%s\" would be stringified in traditional C",
1845                          NODE_NAME (node));
1846               break;
1847             }
1848         }
1849     }
1850 }
1851
1852 /* Returns the name, arguments and expansion of a macro, in a format
1853    suitable to be read back in again, and therefore also for DWARF 2
1854    debugging info.  e.g. "PASTE(X, Y) X ## Y", or "MACNAME EXPANSION".
1855    Caller is expected to generate the "#define" bit if needed.  The
1856    returned text is temporary, and automatically freed later.  */
1857 const unsigned char *
1858 cpp_macro_definition (cpp_reader *pfile, const cpp_hashnode *node)
1859 {
1860   unsigned int i, len;
1861   const cpp_macro *macro = node->value.macro;
1862   unsigned char *buffer;
1863
1864   if (node->type != NT_MACRO || (node->flags & NODE_BUILTIN))
1865     {
1866       cpp_error (pfile, CPP_DL_ICE,
1867                  "invalid hash type %d in cpp_macro_definition", node->type);
1868       return 0;
1869     }
1870
1871   /* Calculate length.  */
1872   len = NODE_LEN (node) + 2;                    /* ' ' and NUL.  */
1873   if (macro->fun_like)
1874     {
1875       len += 4;         /* "()" plus possible final ".." of named
1876                            varargs (we have + 1 below).  */
1877       for (i = 0; i < macro->paramc; i++)
1878         len += NODE_LEN (macro->params[i]) + 1; /* "," */
1879     }
1880
1881   /* This should match below where we fill in the buffer.  */
1882   if (CPP_OPTION (pfile, traditional))
1883     len += _cpp_replacement_text_len (macro);
1884   else
1885     {
1886       for (i = 0; i < macro->count; i++)
1887         {
1888           cpp_token *token = &macro->exp.tokens[i];
1889
1890           if (token->type == CPP_MACRO_ARG)
1891             len += NODE_LEN (macro->params[token->val.arg_no - 1]);
1892           else
1893             len += cpp_token_len (token);
1894
1895           if (token->flags & STRINGIFY_ARG)
1896             len++;                      /* "#" */
1897           if (token->flags & PASTE_LEFT)
1898             len += 3;           /* " ##" */
1899           if (token->flags & PREV_WHITE)
1900             len++;              /* " " */
1901         }
1902     }
1903
1904   if (len > pfile->macro_buffer_len)
1905     {
1906       pfile->macro_buffer = XRESIZEVEC (unsigned char,
1907                                         pfile->macro_buffer, len);
1908       pfile->macro_buffer_len = len;
1909     }
1910
1911   /* Fill in the buffer.  Start with the macro name.  */
1912   buffer = pfile->macro_buffer;
1913   memcpy (buffer, NODE_NAME (node), NODE_LEN (node));
1914   buffer += NODE_LEN (node);
1915
1916   /* Parameter names.  */
1917   if (macro->fun_like)
1918     {
1919       *buffer++ = '(';
1920       for (i = 0; i < macro->paramc; i++)
1921         {
1922           cpp_hashnode *param = macro->params[i];
1923
1924           if (param != pfile->spec_nodes.n__VA_ARGS__)
1925             {
1926               memcpy (buffer, NODE_NAME (param), NODE_LEN (param));
1927               buffer += NODE_LEN (param);
1928             }
1929
1930           if (i + 1 < macro->paramc)
1931             /* Don't emit a space after the comma here; we're trying
1932                to emit a Dwarf-friendly definition, and the Dwarf spec
1933                forbids spaces in the argument list.  */
1934             *buffer++ = ',';
1935           else if (macro->variadic)
1936             *buffer++ = '.', *buffer++ = '.', *buffer++ = '.';
1937         }
1938       *buffer++ = ')';
1939     }
1940
1941   /* The Dwarf spec requires a space after the macro name, even if the
1942      definition is the empty string.  */
1943   *buffer++ = ' ';
1944
1945   if (CPP_OPTION (pfile, traditional))
1946     buffer = _cpp_copy_replacement_text (macro, buffer);
1947   else if (macro->count)
1948   /* Expansion tokens.  */
1949     {
1950       for (i = 0; i < macro->count; i++)
1951         {
1952           cpp_token *token = &macro->exp.tokens[i];
1953
1954           if (token->flags & PREV_WHITE)
1955             *buffer++ = ' ';
1956           if (token->flags & STRINGIFY_ARG)
1957             *buffer++ = '#';
1958
1959           if (token->type == CPP_MACRO_ARG)
1960             {
1961               memcpy (buffer,
1962                       NODE_NAME (macro->params[token->val.arg_no - 1]),
1963                       NODE_LEN (macro->params[token->val.arg_no - 1]));
1964               buffer += NODE_LEN (macro->params[token->val.arg_no - 1]);
1965             }
1966           else
1967             buffer = cpp_spell_token (pfile, token, buffer, false);
1968
1969           if (token->flags & PASTE_LEFT)
1970             {
1971               *buffer++ = ' ';
1972               *buffer++ = '#';
1973               *buffer++ = '#';
1974               /* Next has PREV_WHITE; see _cpp_create_definition.  */
1975             }
1976         }
1977     }
1978
1979   *buffer = '\0';
1980   return pfile->macro_buffer;
1981 }