OSDN Git Service

PR preprocessor/19475
[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, 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 /* 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 = 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 = 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 = xmalloc (capacity * sizeof (cpp_token *));
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 = xrealloc (arg->expanded,
1015                                     capacity * sizeof (cpp_token *));
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 = xrealloc (pfile->macro_buffer, len);
1276       pfile->macro_buffer_len = len;
1277     }
1278   ((union _cpp_hashnode_value *) pfile->macro_buffer)[macro->paramc - 1]
1279     = node->value;
1280   
1281   node->value.arg_index  = macro->paramc;
1282   return false;
1283 }
1284
1285 /* Check the syntax of the parameters in a MACRO definition.  Returns
1286    false if an error occurs.  */
1287 static bool
1288 parse_params (cpp_reader *pfile, cpp_macro *macro)
1289 {
1290   unsigned int prev_ident = 0;
1291
1292   for (;;)
1293     {
1294       const cpp_token *token = _cpp_lex_token (pfile);
1295
1296       switch (token->type)
1297         {
1298         default:
1299           /* Allow/ignore comments in parameter lists if we are
1300              preserving comments in macro expansions.  */
1301           if (token->type == CPP_COMMENT
1302               && ! CPP_OPTION (pfile, discard_comments_in_macro_exp))
1303             continue;
1304
1305           cpp_error (pfile, CPP_DL_ERROR,
1306                      "\"%s\" may not appear in macro parameter list",
1307                      cpp_token_as_text (pfile, token));
1308           return false;
1309
1310         case CPP_NAME:
1311           if (prev_ident)
1312             {
1313               cpp_error (pfile, CPP_DL_ERROR,
1314                          "macro parameters must be comma-separated");
1315               return false;
1316             }
1317           prev_ident = 1;
1318
1319           if (_cpp_save_parameter (pfile, macro, token->val.node))
1320             return false;
1321           continue;
1322
1323         case CPP_CLOSE_PAREN:
1324           if (prev_ident || macro->paramc == 0)
1325             return true;
1326
1327           /* Fall through to pick up the error.  */
1328         case CPP_COMMA:
1329           if (!prev_ident)
1330             {
1331               cpp_error (pfile, CPP_DL_ERROR, "parameter name missing");
1332               return false;
1333             }
1334           prev_ident = 0;
1335           continue;
1336
1337         case CPP_ELLIPSIS:
1338           macro->variadic = 1;
1339           if (!prev_ident)
1340             {
1341               _cpp_save_parameter (pfile, macro,
1342                                    pfile->spec_nodes.n__VA_ARGS__);
1343               pfile->state.va_args_ok = 1;
1344               if (! CPP_OPTION (pfile, c99)
1345                   && CPP_OPTION (pfile, pedantic)
1346                   && CPP_OPTION (pfile, warn_variadic_macros))
1347                 cpp_error (pfile, CPP_DL_PEDWARN,
1348                            "anonymous variadic macros were introduced in C99");
1349             }
1350           else if (CPP_OPTION (pfile, pedantic)
1351                    && CPP_OPTION (pfile, warn_variadic_macros))
1352             cpp_error (pfile, CPP_DL_PEDWARN,
1353                        "ISO C does not permit named variadic macros");
1354
1355           /* We're at the end, and just expect a closing parenthesis.  */
1356           token = _cpp_lex_token (pfile);
1357           if (token->type == CPP_CLOSE_PAREN)
1358             return true;
1359           /* Fall through.  */
1360
1361         case CPP_EOF:
1362           cpp_error (pfile, CPP_DL_ERROR, "missing ')' in macro parameter list");
1363           return false;
1364         }
1365     }
1366 }
1367
1368 /* Allocate room for a token from a macro's replacement list.  */
1369 static cpp_token *
1370 alloc_expansion_token (cpp_reader *pfile, cpp_macro *macro)
1371 {
1372   if (BUFF_ROOM (pfile->a_buff) < (macro->count + 1) * sizeof (cpp_token))
1373     _cpp_extend_buff (pfile, &pfile->a_buff, sizeof (cpp_token));
1374
1375   return &((cpp_token *) BUFF_FRONT (pfile->a_buff))[macro->count++];
1376 }
1377
1378 /* Lex a token from the expansion of MACRO, but mark parameters as we
1379    find them and warn of traditional stringification.  */
1380 static cpp_token *
1381 lex_expansion_token (cpp_reader *pfile, cpp_macro *macro)
1382 {
1383   cpp_token *token;
1384
1385   pfile->cur_token = alloc_expansion_token (pfile, macro);
1386   token = _cpp_lex_direct (pfile);
1387
1388   /* Is this a parameter?  */
1389   if (token->type == CPP_NAME
1390       && (token->val.node->flags & NODE_MACRO_ARG) != 0)
1391     {
1392       token->type = CPP_MACRO_ARG;
1393       token->val.arg_no = token->val.node->value.arg_index;
1394     }
1395   else if (CPP_WTRADITIONAL (pfile) && macro->paramc > 0
1396            && (token->type == CPP_STRING || token->type == CPP_CHAR))
1397     check_trad_stringification (pfile, macro, &token->val.str);
1398
1399   return token;
1400 }
1401
1402 static bool
1403 create_iso_definition (cpp_reader *pfile, cpp_macro *macro)
1404 {
1405   cpp_token *token;
1406   const cpp_token *ctoken;
1407
1408   /* Get the first token of the expansion (or the '(' of a
1409      function-like macro).  */
1410   ctoken = _cpp_lex_token (pfile);
1411
1412   if (ctoken->type == CPP_OPEN_PAREN && !(ctoken->flags & PREV_WHITE))
1413     {
1414       bool ok = parse_params (pfile, macro);
1415       macro->params = (cpp_hashnode **) BUFF_FRONT (pfile->a_buff);
1416       if (!ok)
1417         return false;
1418
1419       /* Success.  Commit or allocate the parameter array.  */
1420       if (pfile->hash_table->alloc_subobject)
1421         {
1422           cpp_hashnode **params = pfile->hash_table->alloc_subobject
1423             (sizeof (cpp_hashnode *) * macro->paramc);
1424           memcpy (params, macro->params,
1425                   sizeof (cpp_hashnode *) * macro->paramc);
1426           macro->params = params;
1427         }
1428       else
1429         BUFF_FRONT (pfile->a_buff) = (uchar *) &macro->params[macro->paramc];
1430       macro->fun_like = 1;
1431     }
1432   else if (ctoken->type != CPP_EOF && !(ctoken->flags & PREV_WHITE))
1433     {
1434       /* While ISO C99 requires whitespace before replacement text
1435          in a macro definition, ISO C90 with TC1 allows there characters
1436          from the basic source character set.  */
1437       if (CPP_OPTION (pfile, c99))
1438         cpp_error (pfile, CPP_DL_PEDWARN,
1439                    "ISO C99 requires whitespace after the macro name");
1440       else
1441         {
1442           int warntype = CPP_DL_WARNING;
1443           switch (ctoken->type)
1444             {
1445             case CPP_ATSIGN:
1446             case CPP_AT_NAME:
1447             case CPP_OBJC_STRING:
1448               /* '@' is not in basic character set.  */
1449               warntype = CPP_DL_PEDWARN;
1450               break;
1451             case CPP_OTHER:
1452               /* Basic character set sans letters, digits and _.  */
1453               if (strchr ("!\"#%&'()*+,-./:;<=>?[\\]^{|}~",
1454                           ctoken->val.str.text[0]) == NULL)
1455                 warntype = CPP_DL_PEDWARN;
1456               break;
1457             default:
1458               /* All other tokens start with a character from basic
1459                  character set.  */
1460               break;
1461             }
1462           cpp_error (pfile, warntype,
1463                      "missing whitespace after the macro name");
1464         }
1465     }
1466
1467   if (macro->fun_like)
1468     token = lex_expansion_token (pfile, macro);
1469   else
1470     {
1471       token = alloc_expansion_token (pfile, macro);
1472       *token = *ctoken;
1473     }
1474
1475   for (;;)
1476     {
1477       /* Check the stringifying # constraint 6.10.3.2.1 of
1478          function-like macros when lexing the subsequent token.  */
1479       if (macro->count > 1 && token[-1].type == CPP_HASH && macro->fun_like)
1480         {
1481           if (token->type == CPP_MACRO_ARG)
1482             {
1483               token->flags &= ~PREV_WHITE;
1484               token->flags |= STRINGIFY_ARG;
1485               token->flags |= token[-1].flags & PREV_WHITE;
1486               token[-1] = token[0];
1487               macro->count--;
1488             }
1489           /* Let assembler get away with murder.  */
1490           else if (CPP_OPTION (pfile, lang) != CLK_ASM)
1491             {
1492               cpp_error (pfile, CPP_DL_ERROR,
1493                          "'#' is not followed by a macro parameter");
1494               return false;
1495             }
1496         }
1497
1498       if (token->type == CPP_EOF)
1499         break;
1500
1501       /* Paste operator constraint 6.10.3.3.1.  */
1502       if (token->type == CPP_PASTE)
1503         {
1504           /* Token-paste ##, can appear in both object-like and
1505              function-like macros, but not at the ends.  */
1506           if (--macro->count > 0)
1507             token = lex_expansion_token (pfile, macro);
1508
1509           if (macro->count == 0 || token->type == CPP_EOF)
1510             {
1511               cpp_error (pfile, CPP_DL_ERROR,
1512                  "'##' cannot appear at either end of a macro expansion");
1513               return false;
1514             }
1515
1516           token[-1].flags |= PASTE_LEFT;
1517         }
1518
1519       token = lex_expansion_token (pfile, macro);
1520     }
1521
1522   macro->exp.tokens = (cpp_token *) BUFF_FRONT (pfile->a_buff);
1523   macro->traditional = 0;
1524
1525   /* Don't count the CPP_EOF.  */
1526   macro->count--;
1527
1528   /* Clear whitespace on first token for warn_of_redefinition().  */
1529   if (macro->count)
1530     macro->exp.tokens[0].flags &= ~PREV_WHITE;
1531
1532   /* Commit or allocate the memory.  */
1533   if (pfile->hash_table->alloc_subobject)
1534     {
1535       cpp_token *tokns = pfile->hash_table->alloc_subobject (sizeof (cpp_token)
1536                                                              * macro->count);
1537       memcpy (tokns, macro->exp.tokens, sizeof (cpp_token) * macro->count);
1538       macro->exp.tokens = tokns;
1539     }
1540   else
1541     BUFF_FRONT (pfile->a_buff) = (uchar *) &macro->exp.tokens[macro->count];
1542
1543   return true;
1544 }
1545
1546 /* Parse a macro and save its expansion.  Returns nonzero on success.  */
1547 bool
1548 _cpp_create_definition (cpp_reader *pfile, cpp_hashnode *node)
1549 {
1550   cpp_macro *macro;
1551   unsigned int i;
1552   bool ok;
1553
1554   if (pfile->hash_table->alloc_subobject)
1555     macro = pfile->hash_table->alloc_subobject (sizeof (cpp_macro));
1556   else
1557     macro = (cpp_macro *) _cpp_aligned_alloc (pfile, sizeof (cpp_macro));
1558   macro->line = pfile->directive_line;
1559   macro->params = 0;
1560   macro->paramc = 0;
1561   macro->variadic = 0;
1562   macro->used = !CPP_OPTION (pfile, warn_unused_macros);
1563   macro->count = 0;
1564   macro->fun_like = 0;
1565   /* To suppress some diagnostics.  */
1566   macro->syshdr = pfile->buffer && pfile->buffer->sysp != 0;
1567
1568   if (CPP_OPTION (pfile, traditional))
1569     ok = _cpp_create_trad_definition (pfile, macro);
1570   else
1571     {
1572       cpp_token *saved_cur_token = pfile->cur_token;
1573
1574       ok = create_iso_definition (pfile, macro);
1575
1576       /* Restore lexer position because of games lex_expansion_token()
1577          plays lexing the macro.  We set the type for SEEN_EOL() in
1578          directives.c.
1579
1580          Longer term we should lex the whole line before coming here,
1581          and just copy the expansion.  */
1582       saved_cur_token[-1].type = pfile->cur_token[-1].type;
1583       pfile->cur_token = saved_cur_token;
1584
1585       /* Stop the lexer accepting __VA_ARGS__.  */
1586       pfile->state.va_args_ok = 0;
1587     }
1588
1589   /* Clear the fast argument lookup indices.  */
1590   for (i = macro->paramc; i-- > 0; )
1591     {
1592       struct cpp_hashnode *node = macro->params[i];
1593       node->flags &= ~ NODE_MACRO_ARG;
1594       node->value = ((union _cpp_hashnode_value *) pfile->macro_buffer)[i];
1595     }
1596
1597   if (!ok)
1598     return ok;
1599
1600   if (node->type == NT_MACRO)
1601     {
1602       if (CPP_OPTION (pfile, warn_unused_macros))
1603         _cpp_warn_if_unused_macro (pfile, node, NULL);
1604
1605       if (warn_of_redefinition (pfile, node, macro))
1606         {
1607           cpp_error_with_line (pfile, CPP_DL_PEDWARN, pfile->directive_line, 0,
1608                                "\"%s\" redefined", NODE_NAME (node));
1609
1610           if (node->type == NT_MACRO && !(node->flags & NODE_BUILTIN))
1611             cpp_error_with_line (pfile, CPP_DL_PEDWARN,
1612                                  node->value.macro->line, 0,
1613                          "this is the location of the previous definition");
1614         }
1615     }
1616
1617   if (node->type != NT_VOID)
1618     _cpp_free_definition (node);
1619
1620   /* Enter definition in hash table.  */
1621   node->type = NT_MACRO;
1622   node->value.macro = macro;
1623   if (! ustrncmp (NODE_NAME (node), DSC ("__STDC_")))
1624     node->flags |= NODE_WARN;
1625
1626   return ok;
1627 }
1628
1629 /* Warn if a token in STRING matches one of a function-like MACRO's
1630    parameters.  */
1631 static void
1632 check_trad_stringification (cpp_reader *pfile, const cpp_macro *macro,
1633                             const cpp_string *string)
1634 {
1635   unsigned int i, len;
1636   const uchar *p, *q, *limit;
1637
1638   /* Loop over the string.  */
1639   limit = string->text + string->len - 1;
1640   for (p = string->text + 1; p < limit; p = q)
1641     {
1642       /* Find the start of an identifier.  */
1643       while (p < limit && !is_idstart (*p))
1644         p++;
1645
1646       /* Find the end of the identifier.  */
1647       q = p;
1648       while (q < limit && is_idchar (*q))
1649         q++;
1650
1651       len = q - p;
1652
1653       /* Loop over the function macro arguments to see if the
1654          identifier inside the string matches one of them.  */
1655       for (i = 0; i < macro->paramc; i++)
1656         {
1657           const cpp_hashnode *node = macro->params[i];
1658
1659           if (NODE_LEN (node) == len
1660               && !memcmp (p, NODE_NAME (node), len))
1661             {
1662               cpp_error (pfile, CPP_DL_WARNING,
1663            "macro argument \"%s\" would be stringified in traditional C",
1664                          NODE_NAME (node));
1665               break;
1666             }
1667         }
1668     }
1669 }
1670
1671 /* Returns the name, arguments and expansion of a macro, in a format
1672    suitable to be read back in again, and therefore also for DWARF 2
1673    debugging info.  e.g. "PASTE(X, Y) X ## Y", or "MACNAME EXPANSION".
1674    Caller is expected to generate the "#define" bit if needed.  The
1675    returned text is temporary, and automatically freed later.  */
1676 const unsigned char *
1677 cpp_macro_definition (cpp_reader *pfile, const cpp_hashnode *node)
1678 {
1679   unsigned int i, len;
1680   const cpp_macro *macro = node->value.macro;
1681   unsigned char *buffer;
1682
1683   if (node->type != NT_MACRO || (node->flags & NODE_BUILTIN))
1684     {
1685       cpp_error (pfile, CPP_DL_ICE,
1686                  "invalid hash type %d in cpp_macro_definition", node->type);
1687       return 0;
1688     }
1689
1690   /* Calculate length.  */
1691   len = NODE_LEN (node) + 2;                    /* ' ' and NUL.  */
1692   if (macro->fun_like)
1693     {
1694       len += 4;         /* "()" plus possible final ".." of named
1695                            varargs (we have + 1 below).  */
1696       for (i = 0; i < macro->paramc; i++)
1697         len += NODE_LEN (macro->params[i]) + 1; /* "," */
1698     }
1699
1700   /* This should match below where we fill in the buffer.  */
1701   if (CPP_OPTION (pfile, traditional))
1702     len += _cpp_replacement_text_len (macro);
1703   else
1704     {
1705       for (i = 0; i < macro->count; i++)
1706         {
1707           cpp_token *token = &macro->exp.tokens[i];
1708
1709           if (token->type == CPP_MACRO_ARG)
1710             len += NODE_LEN (macro->params[token->val.arg_no - 1]);
1711           else
1712             len += cpp_token_len (token);
1713
1714           if (token->flags & STRINGIFY_ARG)
1715             len++;                      /* "#" */
1716           if (token->flags & PASTE_LEFT)
1717             len += 3;           /* " ##" */
1718           if (token->flags & PREV_WHITE)
1719             len++;              /* " " */
1720         }
1721     }
1722
1723   if (len > pfile->macro_buffer_len)
1724     {
1725       pfile->macro_buffer = xrealloc (pfile->macro_buffer, len);
1726       pfile->macro_buffer_len = len;
1727     }
1728
1729   /* Fill in the buffer.  Start with the macro name.  */
1730   buffer = pfile->macro_buffer;
1731   memcpy (buffer, NODE_NAME (node), NODE_LEN (node));
1732   buffer += NODE_LEN (node);
1733
1734   /* Parameter names.  */
1735   if (macro->fun_like)
1736     {
1737       *buffer++ = '(';
1738       for (i = 0; i < macro->paramc; i++)
1739         {
1740           cpp_hashnode *param = macro->params[i];
1741
1742           if (param != pfile->spec_nodes.n__VA_ARGS__)
1743             {
1744               memcpy (buffer, NODE_NAME (param), NODE_LEN (param));
1745               buffer += NODE_LEN (param);
1746             }
1747
1748           if (i + 1 < macro->paramc)
1749             /* Don't emit a space after the comma here; we're trying
1750                to emit a Dwarf-friendly definition, and the Dwarf spec
1751                forbids spaces in the argument list.  */
1752             *buffer++ = ',';
1753           else if (macro->variadic)
1754             *buffer++ = '.', *buffer++ = '.', *buffer++ = '.';
1755         }
1756       *buffer++ = ')';
1757     }
1758
1759   /* The Dwarf spec requires a space after the macro name, even if the
1760      definition is the empty string.  */
1761   *buffer++ = ' ';
1762
1763   if (CPP_OPTION (pfile, traditional))
1764     buffer = _cpp_copy_replacement_text (macro, buffer);
1765   else if (macro->count)
1766   /* Expansion tokens.  */
1767     {
1768       for (i = 0; i < macro->count; i++)
1769         {
1770           cpp_token *token = &macro->exp.tokens[i];
1771
1772           if (token->flags & PREV_WHITE)
1773             *buffer++ = ' ';
1774           if (token->flags & STRINGIFY_ARG)
1775             *buffer++ = '#';
1776
1777           if (token->type == CPP_MACRO_ARG)
1778             {
1779               memcpy (buffer,
1780                       NODE_NAME (macro->params[token->val.arg_no - 1]),
1781                       NODE_LEN (macro->params[token->val.arg_no - 1]));
1782               buffer += NODE_LEN (macro->params[token->val.arg_no - 1]);
1783             }
1784           else
1785             buffer = cpp_spell_token (pfile, token, buffer, false);
1786
1787           if (token->flags & PASTE_LEFT)
1788             {
1789               *buffer++ = ' ';
1790               *buffer++ = '#';
1791               *buffer++ = '#';
1792               /* Next has PREV_WHITE; see _cpp_create_definition.  */
1793             }
1794         }
1795     }
1796
1797   *buffer = '\0';
1798   return pfile->macro_buffer;
1799 }