OSDN Git Service

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