OSDN Git Service

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