OSDN Git Service

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