OSDN Git Service

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