OSDN Git Service

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