OSDN Git Service

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