OSDN Git Service

2d0eeaa0388bfd7d45f2d8b655978db495299d41
[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, 2007, 2008, 2009, 2010, 2011 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 3, 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; see the file COPYING3.  If not see
21 <http://www.gnu.org/licenses/>.
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 /* This structure represents the tokens of a macro argument.  These
34    tokens can be macro themselves, in which case they can be either
35    expanded or unexpanded.  When they are expanded, this data
36    structure keeps both the expanded and unexpanded forms.  */
37 struct macro_arg
38 {
39   const cpp_token **first;      /* First token in unexpanded argument.  */
40   const cpp_token **expanded;   /* Macro-expanded argument.  */
41   const cpp_token *stringified; /* Stringified argument.  */
42   unsigned int count;           /* # of tokens in argument.  */
43   unsigned int expanded_count;  /* # of tokens in expanded argument.  */
44   source_location *virt_locs;   /* Where virtual locations for
45                                    unexpanded tokens are stored.  */
46   source_location *expanded_virt_locs; /* Where virtual locations for
47                                           expanded tokens are
48                                           stored.  */
49 };
50
51 /* The kind of macro tokens which the instance of
52    macro_arg_token_iter is supposed to iterate over.  */
53 enum macro_arg_token_kind {
54   MACRO_ARG_TOKEN_NORMAL,
55   /* This is a macro argument token that got transformed into a string
56      litteral, e.g. #foo.  */
57   MACRO_ARG_TOKEN_STRINGIFIED,
58   /* This is a token resulting from the expansion of a macro
59      argument that was itself a macro.  */
60   MACRO_ARG_TOKEN_EXPANDED
61 };
62
63 /* An iterator over tokens coming from a function-like macro
64    argument.  */
65 typedef struct macro_arg_token_iter macro_arg_token_iter;
66 struct macro_arg_token_iter
67 {
68   /* Whether or not -ftrack-macro-expansion is used.  */
69   bool track_macro_exp_p;
70   /* The kind of token over which we are supposed to iterate.  */
71   enum macro_arg_token_kind kind;
72   /* A pointer to the current token pointed to by the iterator.  */
73   const cpp_token **token_ptr;
74   /* A pointer to the "full" location of the current token.  If
75      -ftrack-macro-expansion is used this location tracks loci accross
76      macro expansion.  */
77   const source_location *location_ptr;
78 #ifdef ENABLE_CHECKING
79   /* The number of times the iterator went forward. This useful only
80      when checking is enabled.  */
81   size_t num_forwards;
82 #endif
83 };
84
85 /* Macro expansion.  */
86
87 static int enter_macro_context (cpp_reader *, cpp_hashnode *,
88                                 const cpp_token *, source_location);
89 static int builtin_macro (cpp_reader *, cpp_hashnode *);
90 static void push_ptoken_context (cpp_reader *, cpp_hashnode *, _cpp_buff *,
91                                  const cpp_token **, unsigned int);
92 static void push_extended_tokens_context (cpp_reader *, cpp_hashnode *,
93                                           _cpp_buff *, source_location *,
94                                           const cpp_token **, unsigned int);
95 static _cpp_buff *collect_args (cpp_reader *, const cpp_hashnode *,
96                                 _cpp_buff **, unsigned *);
97 static cpp_context *next_context (cpp_reader *);
98 static const cpp_token *padding_token (cpp_reader *, const cpp_token *);
99 static void expand_arg (cpp_reader *, macro_arg *);
100 static const cpp_token *new_string_token (cpp_reader *, uchar *, unsigned int);
101 static const cpp_token *stringify_arg (cpp_reader *, macro_arg *);
102 static void paste_all_tokens (cpp_reader *, const cpp_token *);
103 static bool paste_tokens (cpp_reader *, const cpp_token **, const cpp_token *);
104 static void alloc_expanded_arg_mem (cpp_reader *, macro_arg *, size_t);
105 static void ensure_expanded_arg_room (cpp_reader *, macro_arg *, size_t, size_t *);
106 static void delete_macro_args (_cpp_buff*, unsigned num_args);
107 static void set_arg_token (macro_arg *, const cpp_token *,
108                            source_location, size_t,
109                            enum macro_arg_token_kind,
110                            bool);
111 static const source_location *get_arg_token_location (const macro_arg *,
112                                                       enum macro_arg_token_kind);
113 static const cpp_token **arg_token_ptr_at (const macro_arg *,
114                                            size_t,
115                                            enum macro_arg_token_kind,
116                                            source_location **virt_location);
117
118 static void macro_arg_token_iter_init (macro_arg_token_iter *, bool,
119                                        enum macro_arg_token_kind,
120                                        const macro_arg *,
121                                        const cpp_token **);
122 static const cpp_token *macro_arg_token_iter_get_token
123 (const macro_arg_token_iter *it);
124 static source_location macro_arg_token_iter_get_location
125 (const macro_arg_token_iter *);
126 static void macro_arg_token_iter_forward (macro_arg_token_iter *);
127 static _cpp_buff *tokens_buff_new (cpp_reader *, size_t,
128                                    source_location **);
129 static size_t tokens_buff_count (_cpp_buff *);
130 static const cpp_token **tokens_buff_last_token_ptr (_cpp_buff *);
131 static const cpp_token **tokens_buff_put_token_to (const cpp_token **,
132                                                    source_location *, 
133                                                    const cpp_token *,
134                                                    source_location,
135                                                    source_location,
136                                                    const struct line_map *,
137                                                    unsigned int);
138
139 static const cpp_token **tokens_buff_add_token (_cpp_buff *,
140                                                 source_location *,
141                                                 const cpp_token *,
142                                                 source_location,
143                                                 source_location,
144                                                 const struct line_map *,
145                                                 unsigned int);
146 static void tokens_buff_remove_last_token (_cpp_buff *);
147 static void replace_args (cpp_reader *, cpp_hashnode *, cpp_macro *,
148                           macro_arg *, source_location);
149 static _cpp_buff *funlike_invocation_p (cpp_reader *, cpp_hashnode *,
150                                         _cpp_buff **, unsigned *);
151 static bool create_iso_definition (cpp_reader *, cpp_macro *);
152
153 /* #define directive parsing and handling.  */
154
155 static cpp_token *alloc_expansion_token (cpp_reader *, cpp_macro *);
156 static cpp_token *lex_expansion_token (cpp_reader *, cpp_macro *);
157 static bool warn_of_redefinition (cpp_reader *, cpp_hashnode *,
158                                   const cpp_macro *);
159 static bool parse_params (cpp_reader *, cpp_macro *);
160 static void check_trad_stringification (cpp_reader *, const cpp_macro *,
161                                         const cpp_string *);
162 static bool reached_end_of_context (cpp_context *);
163 static void consume_next_token_from_context (cpp_reader *pfile,
164                                              const cpp_token **,
165                                              source_location *);
166 static const cpp_token* cpp_get_token_1 (cpp_reader *, source_location *);
167
168 /* Statistical counter tracking the number of macros that got
169    expanded.  */
170 unsigned num_expanded_macros_counter = 0;
171 /* Statistical counter tracking the total number tokens resulting
172    from macro expansion.  */
173 unsigned num_macro_tokens_counter = 0;
174
175 /* Emits a warning if NODE is a macro defined in the main file that
176    has not been used.  */
177 int
178 _cpp_warn_if_unused_macro (cpp_reader *pfile, cpp_hashnode *node,
179                            void *v ATTRIBUTE_UNUSED)
180 {
181   if (node->type == NT_MACRO && !(node->flags & NODE_BUILTIN))
182     {
183       cpp_macro *macro = node->value.macro;
184
185       if (!macro->used
186           && MAIN_FILE_P (linemap_lookup (pfile->line_table, macro->line)))
187         cpp_warning_with_line (pfile, CPP_W_UNUSED_MACROS, macro->line, 0,
188                                "macro \"%s\" is not used", NODE_NAME (node));
189     }
190
191   return 1;
192 }
193
194 /* Allocates and returns a CPP_STRING token, containing TEXT of length
195    LEN, after null-terminating it.  TEXT must be in permanent storage.  */
196 static const cpp_token *
197 new_string_token (cpp_reader *pfile, unsigned char *text, unsigned int len)
198 {
199   cpp_token *token = _cpp_temp_token (pfile);
200
201   text[len] = '\0';
202   token->type = CPP_STRING;
203   token->val.str.len = len;
204   token->val.str.text = text;
205   token->flags = 0;
206   return token;
207 }
208
209 static const char * const monthnames[] =
210 {
211   "Jan", "Feb", "Mar", "Apr", "May", "Jun",
212   "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"
213 };
214
215 /* Helper function for builtin_macro.  Returns the text generated by
216    a builtin macro. */
217 const uchar *
218 _cpp_builtin_macro_text (cpp_reader *pfile, cpp_hashnode *node)
219 {
220   const struct line_map *map;
221   const uchar *result = NULL;
222   linenum_type number = 1;
223
224   switch (node->value.builtin)
225     {
226     default:
227       cpp_error (pfile, CPP_DL_ICE, "invalid built-in macro \"%s\"",
228                  NODE_NAME (node));
229       break;
230
231     case BT_TIMESTAMP:
232       {
233         cpp_buffer *pbuffer = cpp_get_buffer (pfile);
234         if (pbuffer->timestamp == NULL)
235           {
236             /* Initialize timestamp value of the assotiated file. */
237             struct _cpp_file *file = cpp_get_file (pbuffer);
238             if (file)
239               {
240                 /* Generate __TIMESTAMP__ string, that represents 
241                    the date and time of the last modification 
242                    of the current source file. The string constant 
243                    looks like "Sun Sep 16 01:03:52 1973".  */
244                 struct tm *tb = NULL;
245                 struct stat *st = _cpp_get_file_stat (file);
246                 if (st)
247                   tb = localtime (&st->st_mtime);
248                 if (tb)
249                   {
250                     char *str = asctime (tb);
251                     size_t len = strlen (str);
252                     unsigned char *buf = _cpp_unaligned_alloc (pfile, len + 2);
253                     buf[0] = '"';
254                     strcpy ((char *) buf + 1, str);
255                     buf[len] = '"';
256                     pbuffer->timestamp = buf;
257                   }
258                 else
259                   {
260                     cpp_errno (pfile, CPP_DL_WARNING,
261                         "could not determine file timestamp");
262                     pbuffer->timestamp = UC"\"??? ??? ?? ??:??:?? ????\"";
263                   }
264               }
265           }
266         result = pbuffer->timestamp;
267       }
268       break;
269     case BT_FILE:
270     case BT_BASE_FILE:
271       {
272         unsigned int len;
273         const char *name;
274         uchar *buf;
275         
276         if (node->value.builtin == BT_FILE)
277           name = linemap_get_expansion_filename (pfile->line_table,
278                                                  pfile->line_table->highest_line);
279         else
280           {
281             map = linemap_lookup (pfile->line_table, pfile->line_table->highest_line);
282             while (! MAIN_FILE_P (map))
283               map = INCLUDED_FROM (pfile->line_table, map);
284             name = ORDINARY_MAP_FILE_NAME (map);
285           }
286         len = strlen (name);
287         buf = _cpp_unaligned_alloc (pfile, len * 2 + 3);
288         result = buf;
289         *buf = '"';
290         buf = cpp_quote_string (buf + 1, (const unsigned char *) name, len);
291         *buf++ = '"';
292         *buf = '\0';
293       }
294       break;
295
296     case BT_INCLUDE_LEVEL:
297       /* The line map depth counts the primary source as level 1, but
298          historically __INCLUDE_DEPTH__ has called the primary source
299          level 0.  */
300       number = pfile->line_table->depth - 1;
301       break;
302
303     case BT_SPECLINE:
304       map = LINEMAPS_LAST_ORDINARY_MAP (pfile->line_table);
305       /* If __LINE__ is embedded in a macro, it must expand to the
306          line of the macro's invocation, not its definition.
307          Otherwise things like assert() will not work properly.  */
308       number = linemap_get_expansion_line (pfile->line_table,
309                                            CPP_OPTION (pfile, traditional)
310                                            ? pfile->line_table->highest_line
311                                            : pfile->cur_token[-1].src_loc);
312       break;
313
314       /* __STDC__ has the value 1 under normal circumstances.
315          However, if (a) we are in a system header, (b) the option
316          stdc_0_in_system_headers is true (set by target config), and
317          (c) we are not in strictly conforming mode, then it has the
318          value 0.  (b) and (c) are already checked in cpp_init_builtins.  */
319     case BT_STDC:
320       if (cpp_in_system_header (pfile))
321         number = 0;
322       else
323         number = 1;
324       break;
325
326     case BT_DATE:
327     case BT_TIME:
328       if (pfile->date == NULL)
329         {
330           /* Allocate __DATE__ and __TIME__ strings from permanent
331              storage.  We only do this once, and don't generate them
332              at init time, because time() and localtime() are very
333              slow on some systems.  */
334           time_t tt;
335           struct tm *tb = NULL;
336
337           /* (time_t) -1 is a legitimate value for "number of seconds
338              since the Epoch", so we have to do a little dance to
339              distinguish that from a genuine error.  */
340           errno = 0;
341           tt = time(NULL);
342           if (tt != (time_t)-1 || errno == 0)
343             tb = localtime (&tt);
344
345           if (tb)
346             {
347               pfile->date = _cpp_unaligned_alloc (pfile,
348                                                   sizeof ("\"Oct 11 1347\""));
349               sprintf ((char *) pfile->date, "\"%s %2d %4d\"",
350                        monthnames[tb->tm_mon], tb->tm_mday,
351                        tb->tm_year + 1900);
352
353               pfile->time = _cpp_unaligned_alloc (pfile,
354                                                   sizeof ("\"12:34:56\""));
355               sprintf ((char *) pfile->time, "\"%02d:%02d:%02d\"",
356                        tb->tm_hour, tb->tm_min, tb->tm_sec);
357             }
358           else
359             {
360               cpp_errno (pfile, CPP_DL_WARNING,
361                          "could not determine date and time");
362                 
363               pfile->date = UC"\"??? ?? ????\"";
364               pfile->time = UC"\"??:??:??\"";
365             }
366         }
367
368       if (node->value.builtin == BT_DATE)
369         result = pfile->date;
370       else
371         result = pfile->time;
372       break;
373
374     case BT_COUNTER:
375       if (CPP_OPTION (pfile, directives_only) && pfile->state.in_directive)
376         cpp_error (pfile, CPP_DL_ERROR,
377             "__COUNTER__ expanded inside directive with -fdirectives-only");
378       number = pfile->counter++;
379       break;
380     }
381
382   if (result == NULL)
383     {
384       /* 21 bytes holds all NUL-terminated unsigned 64-bit numbers.  */
385       result = _cpp_unaligned_alloc (pfile, 21);
386       sprintf ((char *) result, "%u", number);
387     }
388
389   return result;      
390 }
391
392 /* Convert builtin macros like __FILE__ to a token and push it on the
393    context stack.  Also handles _Pragma, for which a new token may not
394    be created.  Returns 1 if it generates a new token context, 0 to
395    return the token to the caller.  */
396 static int
397 builtin_macro (cpp_reader *pfile, cpp_hashnode *node)
398 {
399   const uchar *buf;
400   size_t len;
401   char *nbuf;
402
403   if (node->value.builtin == BT_PRAGMA)
404     {
405       /* Don't interpret _Pragma within directives.  The standard is
406          not clear on this, but to me this makes most sense.  */
407       if (pfile->state.in_directive)
408         return 0;
409
410       return _cpp_do__Pragma (pfile);
411     }
412
413   buf = _cpp_builtin_macro_text (pfile, node);
414   len = ustrlen (buf);
415   nbuf = (char *) alloca (len + 1);
416   memcpy (nbuf, buf, len);
417   nbuf[len]='\n';
418
419   cpp_push_buffer (pfile, (uchar *) nbuf, len, /* from_stage3 */ true);
420   _cpp_clean_line (pfile);
421
422   /* Set pfile->cur_token as required by _cpp_lex_direct.  */
423   pfile->cur_token = _cpp_temp_token (pfile);
424   _cpp_push_token_context (pfile, NULL, _cpp_lex_direct (pfile), 1);
425   if (pfile->buffer->cur != pfile->buffer->rlimit)
426     cpp_error (pfile, CPP_DL_ICE, "invalid built-in macro \"%s\"",
427                NODE_NAME (node));
428   _cpp_pop_buffer (pfile);
429
430   return 1;
431 }
432
433 /* Copies SRC, of length LEN, to DEST, adding backslashes before all
434    backslashes and double quotes. DEST must be of sufficient size.
435    Returns a pointer to the end of the string.  */
436 uchar *
437 cpp_quote_string (uchar *dest, const uchar *src, unsigned int len)
438 {
439   while (len--)
440     {
441       uchar c = *src++;
442
443       if (c == '\\' || c == '"')
444         {
445           *dest++ = '\\';
446           *dest++ = c;
447         }
448       else
449           *dest++ = c;
450     }
451
452   return dest;
453 }
454
455 /* Convert a token sequence ARG to a single string token according to
456    the rules of the ISO C #-operator.  */
457 static const cpp_token *
458 stringify_arg (cpp_reader *pfile, macro_arg *arg)
459 {
460   unsigned char *dest;
461   unsigned int i, escape_it, backslash_count = 0;
462   const cpp_token *source = NULL;
463   size_t len;
464
465   if (BUFF_ROOM (pfile->u_buff) < 3)
466     _cpp_extend_buff (pfile, &pfile->u_buff, 3);
467   dest = BUFF_FRONT (pfile->u_buff);
468   *dest++ = '"';
469
470   /* Loop, reading in the argument's tokens.  */
471   for (i = 0; i < arg->count; i++)
472     {
473       const cpp_token *token = arg->first[i];
474
475       if (token->type == CPP_PADDING)
476         {
477           if (source == NULL
478               || (!(source->flags & PREV_WHITE)
479                   && token->val.source == NULL))
480             source = token->val.source;
481           continue;
482         }
483
484       escape_it = (token->type == CPP_STRING || token->type == CPP_CHAR
485                    || token->type == CPP_WSTRING || token->type == CPP_WCHAR
486                    || token->type == CPP_STRING32 || token->type == CPP_CHAR32
487                    || token->type == CPP_STRING16 || token->type == CPP_CHAR16
488                    || token->type == CPP_UTF8STRING);
489
490       /* Room for each char being written in octal, initial space and
491          final quote and NUL.  */
492       len = cpp_token_len (token);
493       if (escape_it)
494         len *= 4;
495       len += 3;
496
497       if ((size_t) (BUFF_LIMIT (pfile->u_buff) - dest) < len)
498         {
499           size_t len_so_far = dest - BUFF_FRONT (pfile->u_buff);
500           _cpp_extend_buff (pfile, &pfile->u_buff, len);
501           dest = BUFF_FRONT (pfile->u_buff) + len_so_far;
502         }
503
504       /* Leading white space?  */
505       if (dest - 1 != BUFF_FRONT (pfile->u_buff))
506         {
507           if (source == NULL)
508             source = token;
509           if (source->flags & PREV_WHITE)
510             *dest++ = ' ';
511         }
512       source = NULL;
513
514       if (escape_it)
515         {
516           _cpp_buff *buff = _cpp_get_buff (pfile, len);
517           unsigned char *buf = BUFF_FRONT (buff);
518           len = cpp_spell_token (pfile, token, buf, true) - buf;
519           dest = cpp_quote_string (dest, buf, len);
520           _cpp_release_buff (pfile, buff);
521         }
522       else
523         dest = cpp_spell_token (pfile, token, dest, true);
524
525       if (token->type == CPP_OTHER && token->val.str.text[0] == '\\')
526         backslash_count++;
527       else
528         backslash_count = 0;
529     }
530
531   /* Ignore the final \ of invalid string literals.  */
532   if (backslash_count & 1)
533     {
534       cpp_error (pfile, CPP_DL_WARNING,
535                  "invalid string literal, ignoring final '\\'");
536       dest--;
537     }
538
539   /* Commit the memory, including NUL, and return the token.  */
540   *dest++ = '"';
541   len = dest - BUFF_FRONT (pfile->u_buff);
542   BUFF_FRONT (pfile->u_buff) = dest + 1;
543   return new_string_token (pfile, dest - len, len);
544 }
545
546 /* Try to paste two tokens.  On success, return nonzero.  In any
547    case, PLHS is updated to point to the pasted token, which is
548    guaranteed to not have the PASTE_LEFT flag set.  */
549 static bool
550 paste_tokens (cpp_reader *pfile, const cpp_token **plhs, const cpp_token *rhs)
551 {
552   unsigned char *buf, *end, *lhsend;
553   cpp_token *lhs;
554   unsigned int len;
555
556   len = cpp_token_len (*plhs) + cpp_token_len (rhs) + 1;
557   buf = (unsigned char *) alloca (len);
558   end = lhsend = cpp_spell_token (pfile, *plhs, buf, false);
559
560   /* Avoid comment headers, since they are still processed in stage 3.
561      It is simpler to insert a space here, rather than modifying the
562      lexer to ignore comments in some circumstances.  Simply returning
563      false doesn't work, since we want to clear the PASTE_LEFT flag.  */
564   if ((*plhs)->type == CPP_DIV && rhs->type != CPP_EQ)
565     *end++ = ' ';
566   /* In one obscure case we might see padding here.  */
567   if (rhs->type != CPP_PADDING)
568     end = cpp_spell_token (pfile, rhs, end, false);
569   *end = '\n';
570
571   cpp_push_buffer (pfile, buf, end - buf, /* from_stage3 */ true);
572   _cpp_clean_line (pfile);
573
574   /* Set pfile->cur_token as required by _cpp_lex_direct.  */
575   pfile->cur_token = _cpp_temp_token (pfile);
576   lhs = _cpp_lex_direct (pfile);
577   if (pfile->buffer->cur != pfile->buffer->rlimit)
578     {
579       source_location saved_loc = lhs->src_loc;
580
581       _cpp_pop_buffer (pfile);
582       _cpp_backup_tokens (pfile, 1);
583       *lhsend = '\0';
584
585       /* We have to remove the PASTE_LEFT flag from the old lhs, but
586          we want to keep the new location.  */
587       *lhs = **plhs;
588       *plhs = lhs;
589       lhs->src_loc = saved_loc;
590       lhs->flags &= ~PASTE_LEFT;
591
592       /* Mandatory error for all apart from assembler.  */
593       if (CPP_OPTION (pfile, lang) != CLK_ASM)
594         cpp_error (pfile, CPP_DL_ERROR,
595          "pasting \"%s\" and \"%s\" does not give a valid preprocessing token",
596                    buf, cpp_token_as_text (pfile, rhs));
597       return false;
598     }
599
600   *plhs = lhs;
601   _cpp_pop_buffer (pfile);
602   return true;
603 }
604
605 /* Handles an arbitrarily long sequence of ## operators, with initial
606    operand LHS.  This implementation is left-associative,
607    non-recursive, and finishes a paste before handling succeeding
608    ones.  If a paste fails, we back up to the RHS of the failing ##
609    operator before pushing the context containing the result of prior
610    successful pastes, with the effect that the RHS appears in the
611    output stream after the pasted LHS normally.  */
612 static void
613 paste_all_tokens (cpp_reader *pfile, const cpp_token *lhs)
614 {
615   const cpp_token *rhs = NULL;
616   cpp_context *context = pfile->context;
617
618   do
619     {
620       /* Take the token directly from the current context.  We can do
621          this, because we are in the replacement list of either an
622          object-like macro, or a function-like macro with arguments
623          inserted.  In either case, the constraints to #define
624          guarantee we have at least one more token.  */
625       if (context->tokens_kind == TOKENS_KIND_DIRECT)
626         rhs = FIRST (context).token++;
627       else if (context->tokens_kind == TOKENS_KIND_INDIRECT)
628         rhs = *FIRST (context).ptoken++;
629       else if (context->tokens_kind == TOKENS_KIND_EXTENDED)
630         {
631           /* So we are in presence of an extended token context, which
632              means that each token in this context has a virtual
633              location attached to it.  So let's not forget to update
634              the pointer to the current virtual location of the
635              current token when we update the pointer to the current
636              token */
637
638           rhs = *FIRST (context).ptoken++;
639           /* context->c.mc must be non-null, as if we were not in a
640              macro context, context->tokens_kind could not be equal to
641              TOKENS_KIND_EXTENDED.  */
642           context->c.mc->cur_virt_loc++;
643         }
644
645       if (rhs->type == CPP_PADDING)
646         {
647           if (rhs->flags & PASTE_LEFT)
648             abort ();
649         }
650       if (!paste_tokens (pfile, &lhs, rhs))
651         break;
652     }
653   while (rhs->flags & PASTE_LEFT);
654
655   /* Put the resulting token in its own context.  */
656   _cpp_push_token_context (pfile, NULL, lhs, 1);
657 }
658
659 /* Returns TRUE if the number of arguments ARGC supplied in an
660    invocation of the MACRO referenced by NODE is valid.  An empty
661    invocation to a macro with no parameters should pass ARGC as zero.
662
663    Note that MACRO cannot necessarily be deduced from NODE, in case
664    NODE was redefined whilst collecting arguments.  */
665 bool
666 _cpp_arguments_ok (cpp_reader *pfile, cpp_macro *macro, const cpp_hashnode *node, unsigned int argc)
667 {
668   if (argc == macro->paramc)
669     return true;
670
671   if (argc < macro->paramc)
672     {
673       /* As an extension, a rest argument is allowed to not appear in
674          the invocation at all.
675          e.g. #define debug(format, args...) something
676          debug("string");
677
678          This is exactly the same as if there had been an empty rest
679          argument - debug("string", ).  */
680
681       if (argc + 1 == macro->paramc && macro->variadic)
682         {
683           if (CPP_PEDANTIC (pfile) && ! macro->syshdr)
684             cpp_error (pfile, CPP_DL_PEDWARN,
685                        "ISO C99 requires rest arguments to be used");
686           return true;
687         }
688
689       cpp_error (pfile, CPP_DL_ERROR,
690                  "macro \"%s\" requires %u arguments, but only %u given",
691                  NODE_NAME (node), macro->paramc, argc);
692     }
693   else
694     cpp_error (pfile, CPP_DL_ERROR,
695                "macro \"%s\" passed %u arguments, but takes just %u",
696                NODE_NAME (node), argc, macro->paramc);
697
698   return false;
699 }
700
701 /* Reads and returns the arguments to a function-like macro
702    invocation.  Assumes the opening parenthesis has been processed.
703    If there is an error, emits an appropriate diagnostic and returns
704    NULL.  Each argument is terminated by a CPP_EOF token, for the
705    future benefit of expand_arg().  If there are any deferred
706    #pragma directives among macro arguments, store pointers to the
707    CPP_PRAGMA ... CPP_PRAGMA_EOL tokens into *PRAGMA_BUFF buffer.
708
709    What is returned is the buffer that contains the memory allocated
710    to hold the macro arguments.  NODE is the name of the macro this
711    function is dealing with.  If NUM_ARGS is non-NULL, *NUM_ARGS is
712    set to the actual number of macro arguments allocated in the
713    returned buffer.  */
714 static _cpp_buff *
715 collect_args (cpp_reader *pfile, const cpp_hashnode *node,
716               _cpp_buff **pragma_buff, unsigned *num_args)
717 {
718   _cpp_buff *buff, *base_buff;
719   cpp_macro *macro;
720   macro_arg *args, *arg;
721   const cpp_token *token;
722   unsigned int argc;
723   source_location virt_loc;
724   bool track_macro_expansion_p = CPP_OPTION (pfile, track_macro_expansion);
725   unsigned num_args_alloced = 0;
726
727   macro = node->value.macro;
728   if (macro->paramc)
729     argc = macro->paramc;
730   else
731     argc = 1;
732
733 #define DEFAULT_NUM_TOKENS_PER_MACRO_ARG 50
734 #define ARG_TOKENS_EXTENT 1000
735
736   buff = _cpp_get_buff (pfile, argc * (DEFAULT_NUM_TOKENS_PER_MACRO_ARG
737                                        * sizeof (cpp_token *)
738                                        + sizeof (macro_arg)));
739   base_buff = buff;
740   args = (macro_arg *) buff->base;
741   memset (args, 0, argc * sizeof (macro_arg));
742   buff->cur = (unsigned char *) &args[argc];
743   arg = args, argc = 0;
744
745   /* Collect the tokens making up each argument.  We don't yet know
746      how many arguments have been supplied, whether too many or too
747      few.  Hence the slightly bizarre usage of "argc" and "arg".  */
748   do
749     {
750       unsigned int paren_depth = 0;
751       unsigned int ntokens = 0;
752       unsigned virt_locs_capacity = DEFAULT_NUM_TOKENS_PER_MACRO_ARG;
753       num_args_alloced++;
754
755       argc++;
756       arg->first = (const cpp_token **) buff->cur;
757       if (track_macro_expansion_p)
758         {
759           virt_locs_capacity = DEFAULT_NUM_TOKENS_PER_MACRO_ARG;
760           arg->virt_locs = XNEWVEC (source_location,
761                                     virt_locs_capacity);
762         }
763
764       for (;;)
765         {
766           /* Require space for 2 new tokens (including a CPP_EOF).  */
767           if ((unsigned char *) &arg->first[ntokens + 2] > buff->limit)
768             {
769               buff = _cpp_append_extend_buff (pfile, buff,
770                                               ARG_TOKENS_EXTENT
771                                               * sizeof (cpp_token *));
772               arg->first = (const cpp_token **) buff->cur;
773             }
774           if (track_macro_expansion_p
775               && (ntokens + 2 > virt_locs_capacity))
776             {
777               virt_locs_capacity += ARG_TOKENS_EXTENT;
778               arg->virt_locs = XRESIZEVEC (source_location,
779                                            arg->virt_locs,
780                                            virt_locs_capacity);
781             }
782
783           token = cpp_get_token_1 (pfile, &virt_loc);
784
785           if (token->type == CPP_PADDING)
786             {
787               /* Drop leading padding.  */
788               if (ntokens == 0)
789                 continue;
790             }
791           else if (token->type == CPP_OPEN_PAREN)
792             paren_depth++;
793           else if (token->type == CPP_CLOSE_PAREN)
794             {
795               if (paren_depth-- == 0)
796                 break;
797             }
798           else if (token->type == CPP_COMMA)
799             {
800               /* A comma does not terminate an argument within
801                  parentheses or as part of a variable argument.  */
802               if (paren_depth == 0
803                   && ! (macro->variadic && argc == macro->paramc))
804                 break;
805             }
806           else if (token->type == CPP_EOF
807                    || (token->type == CPP_HASH && token->flags & BOL))
808             break;
809           else if (token->type == CPP_PRAGMA)
810             {
811               cpp_token *newtok = _cpp_temp_token (pfile);
812
813               /* CPP_PRAGMA token lives in directive_result, which will
814                  be overwritten on the next directive.  */
815               *newtok = *token;
816               token = newtok;
817               do
818                 {
819                   if (*pragma_buff == NULL
820                       || BUFF_ROOM (*pragma_buff) < sizeof (cpp_token *))
821                     {
822                       _cpp_buff *next;
823                       if (*pragma_buff == NULL)
824                         *pragma_buff
825                           = _cpp_get_buff (pfile, 32 * sizeof (cpp_token *));
826                       else
827                         {
828                           next = *pragma_buff;
829                           *pragma_buff
830                             = _cpp_get_buff (pfile,
831                                              (BUFF_FRONT (*pragma_buff)
832                                               - (*pragma_buff)->base) * 2);
833                           (*pragma_buff)->next = next;
834                         }
835                     }
836                   *(const cpp_token **) BUFF_FRONT (*pragma_buff) = token;
837                   BUFF_FRONT (*pragma_buff) += sizeof (cpp_token *);
838                   if (token->type == CPP_PRAGMA_EOL)
839                     break;
840                   token = cpp_get_token_1 (pfile, &virt_loc);
841                 }
842               while (token->type != CPP_EOF);
843
844               /* In deferred pragmas parsing_args and prevent_expansion
845                  had been changed, reset it.  */
846               pfile->state.parsing_args = 2;
847               pfile->state.prevent_expansion = 1;
848
849               if (token->type == CPP_EOF)
850                 break;
851               else
852                 continue;
853             }
854           set_arg_token (arg, token, virt_loc,
855                          ntokens, MACRO_ARG_TOKEN_NORMAL,
856                          CPP_OPTION (pfile, track_macro_expansion));
857           ntokens++;
858         }
859
860       /* Drop trailing padding.  */
861       while (ntokens > 0 && arg->first[ntokens - 1]->type == CPP_PADDING)
862         ntokens--;
863
864       arg->count = ntokens;
865       set_arg_token (arg, &pfile->eof, pfile->eof.src_loc,
866                      ntokens, MACRO_ARG_TOKEN_NORMAL,
867                      CPP_OPTION (pfile, track_macro_expansion));
868
869       /* Terminate the argument.  Excess arguments loop back and
870          overwrite the final legitimate argument, before failing.  */
871       if (argc <= macro->paramc)
872         {
873           buff->cur = (unsigned char *) &arg->first[ntokens + 1];
874           if (argc != macro->paramc)
875             arg++;
876         }
877     }
878   while (token->type != CPP_CLOSE_PAREN && token->type != CPP_EOF);
879
880   if (token->type == CPP_EOF)
881     {
882       /* We still need the CPP_EOF to end directives, and to end
883          pre-expansion of a macro argument.  Step back is not
884          unconditional, since we don't want to return a CPP_EOF to our
885          callers at the end of an -include-d file.  */
886       if (pfile->context->prev || pfile->state.in_directive)
887         _cpp_backup_tokens (pfile, 1);
888       cpp_error (pfile, CPP_DL_ERROR,
889                  "unterminated argument list invoking macro \"%s\"",
890                  NODE_NAME (node));
891     }
892   else
893     {
894       /* A single empty argument is counted as no argument.  */
895       if (argc == 1 && macro->paramc == 0 && args[0].count == 0)
896         argc = 0;
897       if (_cpp_arguments_ok (pfile, macro, node, argc))
898         {
899           /* GCC has special semantics for , ## b where b is a varargs
900              parameter: we remove the comma if b was omitted entirely.
901              If b was merely an empty argument, the comma is retained.
902              If the macro takes just one (varargs) parameter, then we
903              retain the comma only if we are standards conforming.
904
905              If FIRST is NULL replace_args () swallows the comma.  */
906           if (macro->variadic && (argc < macro->paramc
907                                   || (argc == 1 && args[0].count == 0
908                                       && !CPP_OPTION (pfile, std))))
909             args[macro->paramc - 1].first = NULL;
910           if (num_args)
911             *num_args = num_args_alloced;
912           return base_buff;
913         }
914     }
915
916   /* An error occurred.  */
917   _cpp_release_buff (pfile, base_buff);
918   return NULL;
919 }
920
921 /* Search for an opening parenthesis to the macro of NODE, in such a
922    way that, if none is found, we don't lose the information in any
923    intervening padding tokens.  If we find the parenthesis, collect
924    the arguments and return the buffer containing them.  PRAGMA_BUFF
925    argument is the same as in collect_args.  If NUM_ARGS is non-NULL,
926    *NUM_ARGS is set to the number of arguments contained in the
927    returned buffer.  */
928 static _cpp_buff *
929 funlike_invocation_p (cpp_reader *pfile, cpp_hashnode *node,
930                       _cpp_buff **pragma_buff, unsigned *num_args)
931 {
932   const cpp_token *token, *padding = NULL;
933
934   for (;;)
935     {
936       token = cpp_get_token (pfile);
937       if (token->type != CPP_PADDING)
938         break;
939       if (padding == NULL
940           || (!(padding->flags & PREV_WHITE) && token->val.source == NULL))
941         padding = token;
942     }
943
944   if (token->type == CPP_OPEN_PAREN)
945     {
946       pfile->state.parsing_args = 2;
947       return collect_args (pfile, node, pragma_buff, num_args);
948     }
949
950   /* CPP_EOF can be the end of macro arguments, or the end of the
951      file.  We mustn't back up over the latter.  Ugh.  */
952   if (token->type != CPP_EOF || token == &pfile->eof)
953     {
954       /* Back up.  We may have skipped padding, in which case backing
955          up more than one token when expanding macros is in general
956          too difficult.  We re-insert it in its own context.  */
957       _cpp_backup_tokens (pfile, 1);
958       if (padding)
959         _cpp_push_token_context (pfile, NULL, padding, 1);
960     }
961
962   return NULL;
963 }
964
965 /* Return the real number of tokens in the expansion of MACRO.  */
966 static inline unsigned int
967 macro_real_token_count (const cpp_macro *macro)
968 {
969   unsigned int i;
970   if (__builtin_expect (!macro->extra_tokens, true))
971     return macro->count;
972   for (i = 0; i < macro->count; i++)
973     if (macro->exp.tokens[i].type == CPP_PASTE)
974       return i;
975   abort ();
976 }
977
978 /* Push the context of a macro with hash entry NODE onto the context
979    stack.  If we can successfully expand the macro, we push a context
980    containing its yet-to-be-rescanned replacement list and return one.
981    If there were additionally any unexpanded deferred #pragma
982    directives among macro arguments, push another context containing
983    the pragma tokens before the yet-to-be-rescanned replacement list
984    and return two.  Otherwise, we don't push a context and return
985    zero. LOCATION is the location of the expansion point of the
986    macro.  */
987 static int
988 enter_macro_context (cpp_reader *pfile, cpp_hashnode *node,
989                      const cpp_token *result, source_location location)
990 {
991   /* The presence of a macro invalidates a file's controlling macro.  */
992   pfile->mi_valid = false;
993
994   pfile->state.angled_headers = false;
995
996   if ((node->flags & NODE_BUILTIN) && !(node->flags & NODE_USED))
997     {
998       node->flags |= NODE_USED;
999       if ((!pfile->cb.user_builtin_macro
1000            || !pfile->cb.user_builtin_macro (pfile, node))
1001           && pfile->cb.used_define)
1002         pfile->cb.used_define (pfile, pfile->directive_line, node);
1003     }
1004
1005   /* Handle standard macros.  */
1006   if (! (node->flags & NODE_BUILTIN))
1007     {
1008       cpp_macro *macro = node->value.macro;
1009       _cpp_buff *pragma_buff = NULL;
1010
1011       if (macro->fun_like)
1012         {
1013           _cpp_buff *buff;
1014           unsigned num_args = 0;
1015
1016           pfile->state.prevent_expansion++;
1017           pfile->keep_tokens++;
1018           pfile->state.parsing_args = 1;
1019           buff = funlike_invocation_p (pfile, node, &pragma_buff,
1020                                        &num_args);
1021           pfile->state.parsing_args = 0;
1022           pfile->keep_tokens--;
1023           pfile->state.prevent_expansion--;
1024
1025           if (buff == NULL)
1026             {
1027               if (CPP_WTRADITIONAL (pfile) && ! node->value.macro->syshdr)
1028                 cpp_warning (pfile, CPP_W_TRADITIONAL,
1029  "function-like macro \"%s\" must be used with arguments in traditional C",
1030                              NODE_NAME (node));
1031
1032               if (pragma_buff)
1033                 _cpp_release_buff (pfile, pragma_buff);
1034
1035               return 0;
1036             }
1037
1038           if (macro->paramc > 0)
1039             replace_args (pfile, node, macro,
1040                           (macro_arg *) buff->base,
1041                           location);
1042           /* Free the memory used by the arguments of this
1043              function-like macro.  This memory has been allocated by
1044              funlike_invocation_p and by replace_args.  */
1045           delete_macro_args (buff, num_args);
1046         }
1047
1048       /* Disable the macro within its expansion.  */
1049       node->flags |= NODE_DISABLED;
1050
1051       if (!(node->flags & NODE_USED))
1052         {
1053           node->flags |= NODE_USED;
1054           if (pfile->cb.used_define)
1055             pfile->cb.used_define (pfile, pfile->directive_line, node);
1056         }
1057
1058       if (pfile->cb.used)
1059         pfile->cb.used (pfile, location, node);
1060
1061       macro->used = 1;
1062
1063       if (macro->paramc == 0)
1064         {
1065           if (CPP_OPTION (pfile, track_macro_expansion))
1066             {
1067               unsigned int i, count = macro->count;
1068               const cpp_token *src = macro->exp.tokens;
1069               const struct line_map *map;
1070               source_location *virt_locs = NULL;
1071               _cpp_buff *macro_tokens =
1072                 tokens_buff_new (pfile, count, &virt_locs);
1073
1074               /* Create a macro map to record the locations of the
1075                  tokens that are involved in the expansion. LOCATION
1076                  is the location of the macro expansion point.  */
1077               map  = linemap_enter_macro (pfile->line_table,
1078                                           node, location, count);
1079               for (i = 0; i < count; ++i)
1080                 {
1081                   tokens_buff_add_token (macro_tokens, virt_locs,
1082                                          src, src->src_loc,
1083                                          src->src_loc, map, i);
1084                   ++src;
1085                 }
1086               push_extended_tokens_context (pfile, node,
1087                                             macro_tokens,
1088                                             virt_locs,
1089                                             (const cpp_token **)
1090                                             macro_tokens->base,
1091                                             count);
1092               num_macro_tokens_counter += count;
1093             }
1094           else
1095             {
1096               unsigned tokens_count = macro_real_token_count (macro);
1097               _cpp_push_token_context (pfile, node, macro->exp.tokens,
1098                                        tokens_count);
1099               num_macro_tokens_counter += tokens_count;
1100             }
1101         }
1102
1103       if (pragma_buff)
1104         {
1105           if (!pfile->state.in_directive)
1106             _cpp_push_token_context (pfile, NULL,
1107                                      padding_token (pfile, result), 1);
1108           do
1109             {
1110               unsigned tokens_count;
1111               _cpp_buff *tail = pragma_buff->next;
1112               pragma_buff->next = NULL;
1113               tokens_count = ((const cpp_token **) BUFF_FRONT (pragma_buff)
1114                               - (const cpp_token **) pragma_buff->base);
1115               push_ptoken_context (pfile, NULL, pragma_buff,
1116                                    (const cpp_token **) pragma_buff->base,
1117                                    tokens_count);
1118               pragma_buff = tail;
1119               if (!CPP_OPTION (pfile, track_macro_expansion))
1120                 num_macro_tokens_counter += tokens_count;
1121
1122             }
1123           while (pragma_buff != NULL);
1124           return 2;
1125         }
1126
1127       return 1;
1128     }
1129
1130   /* Handle built-in macros and the _Pragma operator.  */
1131   return builtin_macro (pfile, node);
1132 }
1133
1134 /* De-allocate the memory used by BUFF which is an array of instances
1135    of macro_arg.  NUM_ARGS is the number of instances of macro_arg
1136    present in BUFF.  */
1137 static void
1138 delete_macro_args (_cpp_buff *buff, unsigned num_args)
1139 {
1140   macro_arg *macro_args;
1141   unsigned i;
1142
1143   if (buff == NULL)
1144     return;
1145
1146   macro_args = (macro_arg *) buff->base;
1147
1148   /* Walk instances of macro_arg to free their expanded tokens as well
1149      as their macro_arg::virt_locs members.  */
1150   for (i = 0; i < num_args; ++i)
1151     {
1152       if (macro_args[i].expanded)
1153         {
1154           free (macro_args[i].expanded);
1155           macro_args[i].expanded = NULL;
1156         }
1157       if (macro_args[i].virt_locs)
1158         {
1159           free (macro_args[i].virt_locs);
1160           macro_args[i].virt_locs = NULL;
1161         }
1162       if (macro_args[i].expanded_virt_locs)
1163         {
1164           free (macro_args[i].expanded_virt_locs);
1165           macro_args[i].expanded_virt_locs = NULL;
1166         }
1167     }
1168   _cpp_free_buff (buff);
1169 }
1170
1171 /* Set the INDEXth token of the macro argument ARG. TOKEN is the token
1172    to set, LOCATION is its virtual location.  "Virtual" location means
1173    the location that encodes loci accross macro expansion. Otherwise
1174    it has to be TOKEN->SRC_LOC.  KIND is the kind of tokens the
1175    argument ARG is supposed to contain.  Note that ARG must be
1176    tailored so that it has enough room to contain INDEX + 1 numbers of
1177    tokens, at least.  */
1178 static void
1179 set_arg_token (macro_arg *arg, const cpp_token *token,
1180                source_location location, size_t index,
1181                enum macro_arg_token_kind kind,
1182                bool track_macro_exp_p)
1183 {
1184   const cpp_token **token_ptr;
1185   source_location *loc = NULL;
1186
1187   token_ptr =
1188     arg_token_ptr_at (arg, index, kind,
1189                       track_macro_exp_p ? &loc : NULL);
1190   *token_ptr = token;
1191
1192   if (loc != NULL)
1193     {
1194 #ifdef ENABLE_CHECKING
1195       if (kind == MACRO_ARG_TOKEN_STRINGIFIED
1196           || !track_macro_exp_p)
1197         /* We can't set the location of a stringified argument
1198            token and we can't set any location if we aren't tracking
1199            macro expansion locations.   */
1200         abort ();
1201 #endif
1202       *loc = location;
1203     }
1204 }
1205
1206 /* Get the pointer to the location of the argument token of the
1207    function-like macro argument ARG.  This function must be called
1208    only when we -ftrack-macro-expansion is on.  */
1209 static const source_location *
1210 get_arg_token_location (const macro_arg *arg,
1211                         enum macro_arg_token_kind kind)
1212 {
1213   const source_location *loc = NULL;
1214   const cpp_token **token_ptr =
1215     arg_token_ptr_at (arg, 0, kind, (source_location **) &loc);
1216
1217   if (token_ptr == NULL)
1218     return NULL;
1219
1220   return loc;
1221 }
1222
1223 /* Return the pointer to the INDEXth token of the macro argument ARG.
1224    KIND specifies the kind of token the macro argument ARG contains.
1225    If VIRT_LOCATION is non NULL, *VIRT_LOCATION is set to the address
1226    of the virtual location of the returned token if the
1227    -ftrack-macro-expansion flag is on; otherwise, it's set to the
1228    spelling location of the returned token.  */
1229 static const cpp_token **
1230 arg_token_ptr_at (const macro_arg *arg, size_t index,
1231                   enum macro_arg_token_kind kind,
1232                   source_location **virt_location)
1233 {
1234   const cpp_token **tokens_ptr = NULL;
1235
1236   switch (kind)
1237     {
1238     case MACRO_ARG_TOKEN_NORMAL:
1239       tokens_ptr = arg->first;
1240       break;
1241     case MACRO_ARG_TOKEN_STRINGIFIED:      
1242       tokens_ptr = (const cpp_token **) &arg->stringified;
1243       break;
1244     case MACRO_ARG_TOKEN_EXPANDED:
1245         tokens_ptr = arg->expanded;
1246       break;
1247     }
1248
1249   if (tokens_ptr == NULL)
1250     /* This can happen for e.g, an empty token argument to a
1251        funtion-like macro.  */
1252     return tokens_ptr;
1253
1254   if (virt_location)
1255     {
1256       if (kind == MACRO_ARG_TOKEN_NORMAL)
1257         *virt_location = &arg->virt_locs[index];
1258       else if (kind == MACRO_ARG_TOKEN_EXPANDED)
1259         *virt_location = &arg->expanded_virt_locs[index];
1260       else if (kind == MACRO_ARG_TOKEN_STRINGIFIED)
1261         *virt_location =
1262           (source_location *) &tokens_ptr[index]->src_loc;
1263     }
1264   return &tokens_ptr[index];
1265 }
1266
1267 /* Initialize an iterator so that it iterates over the tokens of a
1268    function-like macro argument.  KIND is the kind of tokens we want
1269    ITER to iterate over. TOKEN_PTR points the first token ITER will
1270    iterate over.  */
1271 static void
1272 macro_arg_token_iter_init (macro_arg_token_iter *iter,
1273                            bool track_macro_exp_p,
1274                            enum macro_arg_token_kind kind,
1275                            const macro_arg *arg,
1276                            const cpp_token **token_ptr)
1277 {
1278   iter->track_macro_exp_p = track_macro_exp_p;
1279   iter->kind = kind;
1280   iter->token_ptr = token_ptr;
1281   if (track_macro_exp_p)
1282     iter->location_ptr = get_arg_token_location (arg, kind);
1283 #ifdef ENABLE_CHECKING
1284   iter->num_forwards = 0;
1285   if (track_macro_exp_p
1286       && token_ptr != NULL
1287       && iter->location_ptr == NULL)
1288     abort ();
1289 #endif
1290 }
1291
1292 /* Move the iterator one token forward. Note that if IT was
1293    initialized on an argument that has a stringified token, moving it
1294    foward doesn't make sense as a stringified token is essentially one
1295    string.  */
1296 static void
1297 macro_arg_token_iter_forward (macro_arg_token_iter *it)
1298 {
1299   switch (it->kind)
1300     {
1301     case MACRO_ARG_TOKEN_NORMAL:
1302     case MACRO_ARG_TOKEN_EXPANDED:
1303       it->token_ptr++;
1304       if (it->track_macro_exp_p)
1305         it->location_ptr++;
1306       break;
1307     case MACRO_ARG_TOKEN_STRINGIFIED:
1308 #ifdef ENABLE_CHECKING
1309       if (it->num_forwards > 0)
1310         abort ();
1311 #endif
1312       break;
1313     }
1314
1315 #ifdef ENABLE_CHECKING
1316   it->num_forwards++;
1317 #endif
1318 }
1319
1320 /* Return the token pointed to by the iterator.  */
1321 static const cpp_token *
1322 macro_arg_token_iter_get_token (const macro_arg_token_iter *it)
1323 {
1324 #ifdef ENABLE_CHECKING
1325   if (it->kind == MACRO_ARG_TOKEN_STRINGIFIED
1326       && it->num_forwards > 0)
1327     abort ();
1328 #endif
1329   if (it->token_ptr == NULL)
1330     return NULL;
1331   return *it->token_ptr;
1332 }
1333
1334 /* Return the location of the token pointed to by the iterator.*/
1335 static source_location
1336 macro_arg_token_iter_get_location (const macro_arg_token_iter *it)
1337 {
1338 #ifdef ENABLE_CHECKING
1339   if (it->kind == MACRO_ARG_TOKEN_STRINGIFIED
1340       && it->num_forwards > 0)
1341     abort ();
1342 #endif
1343   if (it->track_macro_exp_p)
1344     return *it->location_ptr;
1345   else
1346     return (*it->token_ptr)->src_loc;
1347 }
1348
1349 /* Return the index of a token [resulting from macro expansion] inside
1350    the total list of tokens resulting from a given macro
1351    expansion. The index can be different depending on whether if we
1352    want each tokens resulting from function-like macro arguments
1353    expansion to have a different location or not.
1354
1355    E.g, consider this function-like macro: 
1356
1357         #define M(x) x - 3
1358
1359    Then consider us "calling" it (and thus expanding it) like:
1360    
1361        M(1+4)
1362
1363    It will be expanded into:
1364
1365        1+4-3
1366
1367    Let's consider the case of the token '4'.
1368
1369    Its index can be 2 (it's the third token of the set of tokens
1370    resulting from the expansion) or it can be 0 if we consider that
1371    all tokens resulting from the expansion of the argument "1+2" have
1372    the same index, which is 0. In this later case, the index of token
1373    '-' would then be 1 and the index of token '3' would be 2.
1374
1375    The later case is useful to use less memory e.g, for the case of
1376    the user using the option -ftrack-macro-expansion=1.
1377
1378    ABSOLUTE_TOKEN_INDEX is the index of the macro argument token we
1379    are interested in.  CUR_REPLACEMENT_TOKEN is the token of the macro
1380    parameter (inside the macro replacement list) that corresponds to
1381    the macro argument for which ABSOLUTE_TOKEN_INDEX is a token index
1382    of.
1383
1384    If we refer to the example above, for the '4' argument token,
1385    ABSOLUTE_TOKEN_INDEX would be set to 2, and CUR_REPLACEMENT_TOKEN
1386    would be set to the token 'x', in the replacement list "x - 3" of
1387    macro M.
1388
1389    This is a subroutine of replace_args.  */
1390 inline static unsigned
1391 expanded_token_index (cpp_reader *pfile, cpp_macro *macro,
1392                       const cpp_token *cur_replacement_token,
1393                       unsigned absolute_token_index)
1394 {
1395   if (CPP_OPTION (pfile, track_macro_expansion) > 1)
1396     return absolute_token_index;
1397   return cur_replacement_token - macro->exp.tokens;
1398 }
1399
1400 /* Replace the parameters in a function-like macro of NODE with the
1401    actual ARGS, and place the result in a newly pushed token context.
1402    Expand each argument before replacing, unless it is operated upon
1403    by the # or ## operators. EXPANSION_POINT_LOC is the location of
1404    the expansion point of the macro. E.g, the location of the
1405    function-like macro invocation.  */
1406 static void
1407 replace_args (cpp_reader *pfile, cpp_hashnode *node, cpp_macro *macro,
1408               macro_arg *args, source_location expansion_point_loc)
1409 {
1410   unsigned int i, total;
1411   const cpp_token *src, *limit;
1412   const cpp_token **first = NULL;
1413   macro_arg *arg;
1414   _cpp_buff *buff = NULL;
1415   source_location *virt_locs = NULL;
1416   unsigned int exp_count;
1417   const struct line_map *map = NULL;
1418   int track_macro_exp;
1419
1420   /* First, fully macro-expand arguments, calculating the number of
1421      tokens in the final expansion as we go.  The ordering of the if
1422      statements below is subtle; we must handle stringification before
1423      pasting.  */
1424
1425   /* EXP_COUNT is the number of tokens in the macro replacement
1426      list.  TOTAL is the number of tokens /after/ macro parameters
1427      have been replaced by their arguments.   */
1428   exp_count = macro_real_token_count (macro);
1429   total = exp_count;
1430   limit = macro->exp.tokens + exp_count;
1431
1432   for (src = macro->exp.tokens; src < limit; src++)
1433     if (src->type == CPP_MACRO_ARG)
1434       {
1435         /* Leading and trailing padding tokens.  */
1436         total += 2;
1437         /* Account for leading and padding tokens in exp_count too.
1438            This is going to be important later down this function,
1439            when we want to handle the case of (track_macro_exp <
1440            2).  */
1441         exp_count += 2;
1442
1443         /* We have an argument.  If it is not being stringified or
1444            pasted it is macro-replaced before insertion.  */
1445         arg = &args[src->val.macro_arg.arg_no - 1];
1446
1447         if (src->flags & STRINGIFY_ARG)
1448           {
1449             if (!arg->stringified)
1450               arg->stringified = stringify_arg (pfile, arg);
1451           }
1452         else if ((src->flags & PASTE_LEFT)
1453                  || (src > macro->exp.tokens && (src[-1].flags & PASTE_LEFT)))
1454           total += arg->count - 1;
1455         else
1456           {
1457             if (!arg->expanded)
1458               expand_arg (pfile, arg);
1459             total += arg->expanded_count - 1;
1460           }
1461       }
1462
1463   /* When the compiler is called with the -ftrack-macro-expansion
1464      flag, we need to keep track of the location of each token that
1465      results from macro expansion.
1466
1467      A token resulting from macro expansion is not a new token. It is
1468      simply the same token as the token coming from the macro
1469      definition.  The new things that are allocated are the buffer
1470      that holds the tokens resulting from macro expansion and a new
1471      location that records many things like the locus of the expansion
1472      point as well as the original locus inside the definition of the
1473      macro.  This location is called a virtual location.
1474      
1475      So the buffer BUFF holds a set of cpp_token*, and the buffer
1476      VIRT_LOCS holds the virtual locations of the tokens held by BUFF.
1477
1478      Both of these two buffers are going to be hung off of the macro
1479      context, when the latter is pushed.  The memory allocated to
1480      store the tokens and their locations is going to be freed once
1481      the context of macro expansion is popped.
1482      
1483      As far as tokens are concerned, the memory overhead of
1484      -ftrack-macro-expansion is proportional to the number of
1485      macros that get expanded multiplied by sizeof (source_location).
1486      The good news is that extra memory gets freed when the macro
1487      context is freed, i.e shortly after the macro got expanded.  */
1488
1489   /* Is the -ftrack-macro-expansion flag in effect?  */
1490   track_macro_exp = CPP_OPTION (pfile, track_macro_expansion);
1491
1492   /* Now allocate memory space for tokens and locations resulting from
1493      the macro expansion, copy the tokens and replace the arguments.
1494      This memory must be freed when the context of the macro MACRO is
1495      popped.  */
1496   buff = tokens_buff_new (pfile, total, track_macro_exp ? &virt_locs : NULL);
1497
1498   first = (const cpp_token **) buff->base;
1499
1500   /* Create a macro map to record the locations of the tokens that are
1501      involved in the expansion.  Note that the expansion point is set
1502      to the location of the closing parenthesis.  Otherwise, the
1503      subsequent map created for the first token that comes after the
1504      macro map might have a wrong line number.  That would lead to
1505      tokens with wrong line numbers after the macro expansion.  This
1506      adds up to the memory overhead of the -ftrack-macro-expansion
1507      flag; for every macro that is expanded, a "macro map" is
1508      created.  */
1509   if (track_macro_exp)
1510     {
1511       int num_macro_tokens = total;
1512       if (track_macro_exp < 2)
1513         /* Then the number of macro tokens won't take in account the
1514            fact that function-like macro arguments can expand to
1515            multiple tokens. This is to save memory at the expense of
1516            accuracy.
1517
1518            Suppose we have #define SQARE(A) A * A
1519
1520            And then we do SQARE(2+3)
1521
1522            Then the tokens 2, +, 3, will have the same location,
1523            saying they come from the expansion of the argument A.  */
1524         num_macro_tokens = exp_count;
1525       map = linemap_enter_macro (pfile->line_table, node,
1526                                  expansion_point_loc,
1527                                  num_macro_tokens);
1528     }
1529   i = 0;
1530   for (src = macro->exp.tokens; src < limit; src++)
1531     {
1532       unsigned int arg_tokens_count;
1533       macro_arg_token_iter from;
1534       const cpp_token **paste_flag = NULL;
1535       const cpp_token **tmp_token_ptr;
1536
1537       if (src->type != CPP_MACRO_ARG)
1538         {
1539           /* Allocate a virtual location for token SRC, and add that
1540              token and its virtual location into the buffers BUFF and
1541              VIRT_LOCS.  */
1542           unsigned index = expanded_token_index (pfile, macro, src, i);
1543           tokens_buff_add_token (buff, virt_locs, src,
1544                                  src->src_loc, src->src_loc,
1545                                  map, index);
1546           i += 1;
1547           continue;
1548         }
1549
1550       paste_flag = 0;
1551       arg = &args[src->val.macro_arg.arg_no - 1];
1552       /* SRC is a macro parameter that we need to replace with its
1553          corresponding argument.  So at some point we'll need to
1554          iterate over the tokens of the macro argument and copy them
1555          into the "place" now holding the correspondig macro
1556          parameter.  We are going to use the iterator type
1557          macro_argo_token_iter to handle that iterating.  The 'if'
1558          below is to initialize the iterator depending on the type of
1559          tokens the macro argument has.  It also does some adjustment
1560          related to padding tokens and some pasting corner cases.  */
1561       if (src->flags & STRINGIFY_ARG)
1562         {
1563           arg_tokens_count = 1;
1564           macro_arg_token_iter_init (&from,
1565                                      CPP_OPTION (pfile,
1566                                                  track_macro_expansion),
1567                                      MACRO_ARG_TOKEN_STRINGIFIED,
1568                                      arg, &arg->stringified);
1569         }
1570       else if (src->flags & PASTE_LEFT)
1571         {
1572           arg_tokens_count = arg->count;
1573           macro_arg_token_iter_init (&from,
1574                                      CPP_OPTION (pfile,
1575                                                  track_macro_expansion),
1576                                      MACRO_ARG_TOKEN_NORMAL,
1577                                      arg, arg->first);
1578         }
1579       else if (src != macro->exp.tokens && (src[-1].flags & PASTE_LEFT))
1580         {
1581           int num_toks;
1582           arg_tokens_count = arg->count;
1583           macro_arg_token_iter_init (&from,
1584                                      CPP_OPTION (pfile,
1585                                                  track_macro_expansion),
1586                                      MACRO_ARG_TOKEN_NORMAL,
1587                                      arg, arg->first);
1588
1589           num_toks = tokens_buff_count (buff);
1590
1591           if (num_toks != 0)
1592             {
1593               /* So the current parameter token is pasted to the previous
1594                  token in the replacement list.  Let's look at what
1595                  we have as previous and current arguments.  */
1596
1597               /* This is the previous argument's token ...  */
1598               tmp_token_ptr = tokens_buff_last_token_ptr (buff);
1599
1600               if ((*tmp_token_ptr)->type == CPP_COMMA
1601                   && macro->variadic
1602                   && src->val.macro_arg.arg_no == macro->paramc)
1603                 {
1604                   /* ... which is a comma; and the current parameter
1605                      is the last parameter of a variadic function-like
1606                      macro.  If the argument to the current last
1607                      parameter is NULL, then swallow the comma,
1608                      otherwise drop the paste flag.  */
1609                   if (macro_arg_token_iter_get_token (&from) == NULL)
1610                     tokens_buff_remove_last_token (buff);
1611                   else
1612                     paste_flag = tmp_token_ptr;
1613                 }
1614               /* Remove the paste flag if the RHS is a placemarker.  */
1615               else if (arg_tokens_count == 0)
1616                 paste_flag = tmp_token_ptr;
1617             }
1618         }
1619       else
1620         {
1621           arg_tokens_count = arg->expanded_count;
1622           macro_arg_token_iter_init (&from,
1623                                      CPP_OPTION (pfile,
1624                                                  track_macro_expansion),
1625                                      MACRO_ARG_TOKEN_EXPANDED,
1626                                      arg, arg->expanded);
1627         }
1628
1629       /* Padding on the left of an argument (unless RHS of ##).  */
1630       if ((!pfile->state.in_directive || pfile->state.directive_wants_padding)
1631           && src != macro->exp.tokens && !(src[-1].flags & PASTE_LEFT))
1632         {
1633           const cpp_token *t = padding_token (pfile, src);
1634           unsigned index = expanded_token_index (pfile, macro, src, i);
1635           /* Allocate a virtual location for the padding token and
1636              append the token and its location to BUFF and
1637              VIRT_LOCS.   */
1638           tokens_buff_add_token (buff, virt_locs, t,
1639                                  t->src_loc, t->src_loc,
1640                                  map, index);
1641         }
1642
1643       if (arg_tokens_count)
1644         {
1645           /* So now we've got the number of tokens that make up the
1646              argument that is going to replace the current parameter
1647              in the macro's replacement list.  */
1648           unsigned int j;
1649           for (j = 0; j < arg_tokens_count; ++j)
1650             {
1651               /* So if track_macro_exp is < 2, the user wants to
1652                  save extra memory while tracking macro expansion
1653                  locations.  So in that case here is what we do:
1654
1655                  Suppose we have #define SQARE(A) A * A
1656
1657                  And then we do SQARE(2+3)
1658
1659                  Then the tokens 2, +, 3, will have the same location,
1660                  saying they come from the expansion of the argument
1661                  A.
1662
1663               So that means we are going to ignore the COUNT tokens
1664               resulting from the expansion of the current macro
1665               arugment. In other words all the ARG_TOKENS_COUNT tokens
1666               resulting from the expansion of the macro argument will
1667               have the index I. Normally, each of those token should
1668               have index I+J.  */
1669               unsigned token_index = i;
1670               unsigned index;
1671               if (track_macro_exp > 1)
1672                 token_index += j;
1673
1674               index = expanded_token_index (pfile, macro, src, token_index);
1675               tokens_buff_add_token (buff, virt_locs,
1676                                      macro_arg_token_iter_get_token (&from),
1677                                      macro_arg_token_iter_get_location (&from),
1678                                      src->src_loc, map, index);
1679               macro_arg_token_iter_forward (&from);
1680             }
1681
1682           /* With a non-empty argument on the LHS of ##, the last
1683              token should be flagged PASTE_LEFT.  */
1684           if (src->flags & PASTE_LEFT)
1685             paste_flag =
1686               (const cpp_token **) tokens_buff_last_token_ptr (buff);
1687         }
1688       else if (CPP_PEDANTIC (pfile) && ! macro->syshdr
1689                && ! CPP_OPTION (pfile, c99)
1690                && ! cpp_in_system_header (pfile))
1691         {
1692           cpp_error (pfile, CPP_DL_PEDWARN,
1693                      "invoking macro %s argument %d: "
1694                      "empty macro arguments are undefined"
1695                      " in ISO C90 and ISO C++98",
1696                      NODE_NAME (node),
1697                      src->val.macro_arg.arg_no);
1698         }
1699
1700       /* Avoid paste on RHS (even case count == 0).  */
1701       if (!pfile->state.in_directive && !(src->flags & PASTE_LEFT))
1702         {
1703           const cpp_token *t = &pfile->avoid_paste;
1704           tokens_buff_add_token (buff, virt_locs,
1705                                  t, t->src_loc, t->src_loc,
1706                                  NULL, 0);
1707         }
1708
1709       /* Add a new paste flag, or remove an unwanted one.  */
1710       if (paste_flag)
1711         {
1712           cpp_token *token = _cpp_temp_token (pfile);
1713           token->type = (*paste_flag)->type;
1714           token->val = (*paste_flag)->val;
1715           if (src->flags & PASTE_LEFT)
1716             token->flags = (*paste_flag)->flags | PASTE_LEFT;
1717           else
1718             token->flags = (*paste_flag)->flags & ~PASTE_LEFT;
1719           *paste_flag = token;
1720         }
1721
1722       i += arg_tokens_count;
1723     }
1724
1725   if (track_macro_exp)
1726     push_extended_tokens_context (pfile, node, buff, virt_locs, first,
1727                                   tokens_buff_count (buff));
1728   else
1729     push_ptoken_context (pfile, node, buff, first,
1730                          tokens_buff_count (buff));
1731
1732   num_macro_tokens_counter += tokens_buff_count (buff);
1733 }
1734
1735 /* Return a special padding token, with padding inherited from SOURCE.  */
1736 static const cpp_token *
1737 padding_token (cpp_reader *pfile, const cpp_token *source)
1738 {
1739   cpp_token *result = _cpp_temp_token (pfile);
1740
1741   result->type = CPP_PADDING;
1742
1743   /* Data in GCed data structures cannot be made const so far, so we
1744      need a cast here.  */
1745   result->val.source = (cpp_token *) source;
1746   result->flags = 0;
1747   return result;
1748 }
1749
1750 /* Get a new uninitialized context.  Create a new one if we cannot
1751    re-use an old one.  */
1752 static cpp_context *
1753 next_context (cpp_reader *pfile)
1754 {
1755   cpp_context *result = pfile->context->next;
1756
1757   if (result == 0)
1758     {
1759       result = XNEW (cpp_context);
1760       memset (result, 0, sizeof (cpp_context));
1761       result->prev = pfile->context;
1762       result->next = 0;
1763       pfile->context->next = result;
1764     }
1765
1766   pfile->context = result;
1767   return result;
1768 }
1769
1770 /* Push a list of pointers to tokens.  */
1771 static void
1772 push_ptoken_context (cpp_reader *pfile, cpp_hashnode *macro, _cpp_buff *buff,
1773                      const cpp_token **first, unsigned int count)
1774 {
1775   cpp_context *context = next_context (pfile);
1776
1777   context->tokens_kind = TOKENS_KIND_INDIRECT;
1778   context->c.macro = macro;
1779   context->buff = buff;
1780   FIRST (context).ptoken = first;
1781   LAST (context).ptoken = first + count;
1782 }
1783
1784 /* Push a list of tokens.  */
1785 void
1786 _cpp_push_token_context (cpp_reader *pfile, cpp_hashnode *macro,
1787                          const cpp_token *first, unsigned int count)
1788 {
1789    cpp_context *context = next_context (pfile);
1790  
1791    context->tokens_kind = TOKENS_KIND_DIRECT;
1792    context->c.macro = macro;
1793    context->buff = NULL;
1794   FIRST (context).token = first;
1795   LAST (context).token = first + count;
1796 }
1797
1798 /* Build a context containing a list of tokens as well as their
1799    virtual locations and push it.  TOKENS_BUFF is the buffer that
1800    contains the tokens pointed to by FIRST.  If TOKENS_BUFF is
1801    non-NULL, it means that the context owns it, meaning that
1802    _cpp_pop_context will free it as well as VIRT_LOCS_BUFF that
1803    contains the virtual locations.  */
1804 static void
1805 push_extended_tokens_context (cpp_reader *pfile,
1806                               cpp_hashnode *macro,
1807                               _cpp_buff *token_buff,
1808                               source_location *virt_locs,
1809                               const cpp_token **first,
1810                               unsigned int count)
1811 {
1812   cpp_context *context = next_context (pfile);
1813   macro_context *m;
1814
1815   context->tokens_kind = TOKENS_KIND_EXTENDED;
1816   context->buff = token_buff;
1817
1818   m = XNEW (macro_context);
1819   m->macro_node = macro;
1820   m->virt_locs = virt_locs;
1821   m->cur_virt_loc = virt_locs;
1822   context->c.mc = m;
1823   FIRST (context).ptoken = first;
1824   LAST (context).ptoken = first + count;
1825 }
1826
1827 /* Push a traditional macro's replacement text.  */
1828 void
1829 _cpp_push_text_context (cpp_reader *pfile, cpp_hashnode *macro,
1830                         const uchar *start, size_t len)
1831 {
1832   cpp_context *context = next_context (pfile);
1833
1834   context->tokens_kind = TOKENS_KIND_DIRECT;
1835   context->c.macro = macro;
1836   context->buff = NULL;
1837   CUR (context) = start;
1838   RLIMIT (context) = start + len;
1839   macro->flags |= NODE_DISABLED;
1840 }
1841
1842 /* Creates a buffer that holds tokens a.k.a "token buffer", usually
1843    for the purpose of storing them on a cpp_context. If VIRT_LOCS is
1844    non-null (which means that -ftrack-macro-expansion is on),
1845    *VIRT_LOCS is set to a newly allocated buffer that is supposed to
1846    hold the virtual locations of the tokens resulting from macro
1847    expansion.  */
1848 static _cpp_buff*
1849 tokens_buff_new (cpp_reader *pfile, size_t len,
1850                  source_location **virt_locs)
1851 {
1852   size_t tokens_size = len * sizeof (cpp_token *);
1853   size_t locs_size = len * sizeof (source_location);
1854
1855   if (virt_locs != NULL)
1856     *virt_locs = XNEWVEC (source_location, locs_size);
1857   return _cpp_get_buff (pfile, tokens_size);
1858 }
1859
1860 /* Returns the number of tokens contained in a token buffer.  The
1861    buffer holds a set of cpp_token*.  */
1862 static size_t
1863 tokens_buff_count (_cpp_buff *buff)
1864 {
1865   return (BUFF_FRONT (buff) - buff->base) / sizeof (cpp_token *);
1866 }
1867
1868 /* Return a pointer to the last token contained in the token buffer
1869    BUFF.  */
1870 static const cpp_token **
1871 tokens_buff_last_token_ptr (_cpp_buff *buff)
1872 {
1873   return &((const cpp_token **) BUFF_FRONT (buff))[-1];
1874 }
1875
1876 /* Remove the last token contained in the token buffer TOKENS_BUFF.
1877    If VIRT_LOCS_BUFF is non-NULL,  it should point at the buffer
1878    containing the virtual locations of the tokens in TOKENS_BUFF; in
1879    which case the function updates that buffer as well.   */
1880 static inline void
1881 tokens_buff_remove_last_token (_cpp_buff *tokens_buff)
1882
1883 {
1884   if (BUFF_FRONT (tokens_buff) > tokens_buff->base)
1885     BUFF_FRONT (tokens_buff) =
1886       (unsigned char *) &((cpp_token **) BUFF_FRONT (tokens_buff))[-1];
1887 }
1888
1889 /* Insert a token into the token buffer at the position pointed to by
1890    DEST.  Note that the buffer is not enlarged so the previous token
1891    that was at *DEST is overwritten.  VIRT_LOC_DEST, if non-null,
1892    means -ftrack-macro-expansion is effect; it then points to where to
1893    insert the virtual location of TOKEN.  TOKEN is the token to
1894    insert.  VIRT_LOC is the virtual location of the token, i.e, the
1895    location possibly encoding its locus accross macro expansion.  If
1896    TOKEN is an argument of a function-like macro (inside a macro
1897    replacement list), PARM_DEF_LOC is the spelling location of the
1898    macro parameter that TOKEN is replacing, in the replacement list of
1899    the macro.  If TOKEN is not an argument of a function-like macro or
1900    if it doesn't come from a macro expansion, then VIRT_LOC can just
1901    be set to the same value as PARM_DEF_LOC.  If MAP is non null, it
1902    means TOKEN comes from a macro expansion and MAP is the macro map
1903    associated to the macro.  MACRO_TOKEN_INDEX points to the index of
1904    the token in the macro map; it is not considered if MAP is NULL.
1905
1906    Upon successful completion this function returns the a pointer to
1907    the position of the token coming right after the insertion
1908    point.  */
1909 static inline const cpp_token **
1910 tokens_buff_put_token_to (const cpp_token **dest,
1911                           source_location *virt_loc_dest,
1912                           const cpp_token *token,
1913                           source_location virt_loc,
1914                           source_location parm_def_loc,                   
1915                           const struct line_map *map,
1916                           unsigned int macro_token_index)
1917 {
1918   source_location macro_loc = virt_loc;
1919   const cpp_token **result;
1920
1921   if (virt_loc_dest)
1922     {
1923       /* -ftrack-macro-expansion is on.  */
1924       if (map)
1925         macro_loc = linemap_add_macro_token (map, macro_token_index,
1926                                              virt_loc, parm_def_loc);
1927       *virt_loc_dest = macro_loc;
1928     }
1929   *dest = token;
1930   result = &dest[1];
1931
1932   return result;
1933 }
1934
1935 /* Adds a token at the end of the tokens contained in BUFFER.  Note
1936    that this function doesn't enlarge BUFFER when the number of tokens
1937    reaches BUFFER's size; it aborts in that situation.
1938
1939    TOKEN is the token to append. VIRT_LOC is the virtual location of
1940    the token, i.e, the location possibly encoding its locus accross
1941    macro expansion. If TOKEN is an argument of a function-like macro
1942    (inside a macro replacement list), PARM_DEF_LOC is the location of
1943    the macro parameter that TOKEN is replacing.  If TOKEN doesn't come
1944    from a macro expansion, then VIRT_LOC can just be set to the same
1945    value as PARM_DEF_LOC.  If MAP is non null, it means TOKEN comes
1946    from a macro expansion and MAP is the macro map associated to the
1947    macro.  MACRO_TOKEN_INDEX points to the index of the token in the
1948    macro map; It is not considered if MAP is NULL.  If VIRT_LOCS is
1949    non-null, it means -ftrack-macro-expansion is on; in which case
1950    this function adds the virtual location DEF_LOC to the VIRT_LOCS
1951    array, at the same index as the one of TOKEN in BUFFER.  Upon
1952    successful completion this function returns the a pointer to the
1953    position of the token coming right after the insertion point.  */
1954 static const cpp_token **
1955 tokens_buff_add_token (_cpp_buff *buffer,
1956                        source_location *virt_locs,
1957                        const cpp_token *token,
1958                        source_location virt_loc,
1959                        source_location parm_def_loc,
1960                        const struct line_map *map,
1961                        unsigned int macro_token_index)
1962 {
1963   const cpp_token **result;
1964   source_location *virt_loc_dest = NULL;
1965   unsigned token_index = 
1966     (BUFF_FRONT (buffer) - buffer->base) / sizeof (cpp_token *);
1967
1968   /* Abort if we pass the end the buffer.  */
1969   if (BUFF_FRONT (buffer) > BUFF_LIMIT (buffer))
1970     abort ();
1971
1972   if (virt_locs != NULL)
1973     virt_loc_dest = &virt_locs[token_index];
1974
1975   result =
1976     tokens_buff_put_token_to ((const cpp_token **) BUFF_FRONT (buffer),
1977                               virt_loc_dest, token, virt_loc, parm_def_loc,
1978                               map, macro_token_index);
1979
1980   BUFF_FRONT (buffer) = (unsigned char *) result;
1981   return result;
1982 }
1983
1984 /* Allocate space for the function-like macro argument ARG to store
1985    the tokens resulting from the macro-expansion of the tokens that
1986    make up ARG itself. That space is allocated in ARG->expanded and
1987    needs to be freed using free.  */
1988 static void
1989 alloc_expanded_arg_mem (cpp_reader *pfile, macro_arg *arg, size_t capacity)
1990 {
1991 #ifdef ENABLE_CHECKING
1992   if (arg->expanded != NULL
1993       || arg->expanded_virt_locs != NULL)
1994     abort ();
1995 #endif
1996   arg->expanded = XNEWVEC (const cpp_token *, capacity);
1997   if (CPP_OPTION (pfile, track_macro_expansion))
1998     arg->expanded_virt_locs = XNEWVEC (source_location, capacity);
1999
2000 }
2001
2002 /* If necessary, enlarge ARG->expanded to so that it can contain SIZE
2003    tokens.  */
2004 static void
2005 ensure_expanded_arg_room (cpp_reader *pfile, macro_arg *arg,
2006                           size_t size, size_t *expanded_capacity)
2007 {
2008   if (size <= *expanded_capacity)
2009     return;
2010
2011   size *= 2;
2012
2013   arg->expanded =
2014     XRESIZEVEC (const cpp_token *, arg->expanded, size);
2015   *expanded_capacity = size;
2016
2017   if (CPP_OPTION (pfile, track_macro_expansion))
2018     {
2019       if (arg->expanded_virt_locs == NULL)
2020         arg->expanded_virt_locs = XNEWVEC (source_location, size);
2021       else
2022         arg->expanded_virt_locs = XRESIZEVEC (source_location,
2023                                               arg->expanded_virt_locs,
2024                                               size);
2025     }
2026 }
2027
2028 /* Expand an argument ARG before replacing parameters in a
2029    function-like macro.  This works by pushing a context with the
2030    argument's tokens, and then expanding that into a temporary buffer
2031    as if it were a normal part of the token stream.  collect_args()
2032    has terminated the argument's tokens with a CPP_EOF so that we know
2033    when we have fully expanded the argument.  */
2034 static void
2035 expand_arg (cpp_reader *pfile, macro_arg *arg)
2036 {
2037   size_t capacity;
2038   bool saved_warn_trad;
2039   bool track_macro_exp_p = CPP_OPTION (pfile, track_macro_expansion);
2040
2041   if (arg->count == 0
2042       || arg->expanded != NULL)
2043     return;
2044
2045   /* Don't warn about funlike macros when pre-expanding.  */
2046   saved_warn_trad = CPP_WTRADITIONAL (pfile);
2047   CPP_WTRADITIONAL (pfile) = 0;
2048
2049   /* Loop, reading in the tokens of the argument.  */
2050   capacity = 256;
2051   alloc_expanded_arg_mem (pfile, arg, capacity);
2052
2053   if (track_macro_exp_p)
2054     push_extended_tokens_context (pfile, NULL, NULL,
2055                                   arg->virt_locs,
2056                                   arg->first,
2057                                   arg->count + 1);
2058   else
2059     push_ptoken_context (pfile, NULL, NULL,
2060                          arg->first, arg->count + 1);
2061
2062   for (;;)
2063     {
2064       const cpp_token *token;
2065       source_location location;
2066
2067       ensure_expanded_arg_room (pfile, arg, arg->expanded_count + 1,
2068                                 &capacity);
2069
2070       token = cpp_get_token_1 (pfile, &location);
2071
2072       if (token->type == CPP_EOF)
2073         break;
2074
2075       set_arg_token (arg, token, location,
2076                      arg->expanded_count, MACRO_ARG_TOKEN_EXPANDED,
2077                      CPP_OPTION (pfile, track_macro_expansion));
2078       arg->expanded_count++;
2079     }
2080
2081   _cpp_pop_context (pfile);
2082
2083   CPP_WTRADITIONAL (pfile) = saved_warn_trad;
2084 }
2085
2086 /* Pop the current context off the stack, re-enabling the macro if the
2087    context represented a macro's replacement list.  Initially the
2088    context structure was not freed so that we can re-use it later, but
2089    now we do free it to reduce peak memory consumption.  */
2090 void
2091 _cpp_pop_context (cpp_reader *pfile)
2092 {
2093   cpp_context *context = pfile->context;
2094
2095   if (context->c.macro)
2096     {
2097       cpp_hashnode *macro;
2098       if (context->tokens_kind == TOKENS_KIND_EXTENDED)
2099         {
2100           macro_context *mc = context->c.mc;
2101           macro = mc->macro_node;
2102           /* If context->buff is set, it means the life time of tokens
2103              is bound to the life time of this context; so we must
2104              free the tokens; that means we must free the virtual
2105              locations of these tokens too.  */
2106           if (context->buff && mc->virt_locs)
2107             {
2108               free (mc->virt_locs);
2109               mc->virt_locs = NULL;
2110             }
2111           free (mc);
2112           context->c.mc = NULL;
2113         }
2114       else
2115         macro = context->c.macro;
2116
2117       /* Beware that MACRO can be NULL in cases like when we are
2118          called from expand_arg.  In those cases, a dummy context with
2119          tokens is pushed just for the purpose of walking them using
2120          cpp_get_token_1.  In that case, no 'macro' field is set into
2121          the dummy context.  */
2122       if (macro != NULL)
2123         macro->flags &= ~NODE_DISABLED;
2124     }
2125
2126   if (context->buff)
2127     {
2128       /* Decrease memory peak consumption by freeing the memory used
2129          by the context.  */
2130       _cpp_free_buff (context->buff);
2131     }
2132
2133   pfile->context = context->prev;
2134   /* decrease peak memory consumption by feeing the context.  */
2135   pfile->context->next = NULL;
2136   free (context);
2137 }
2138
2139 /* Return TRUE if we reached the end of the set of tokens stored in
2140    CONTEXT, FALSE otherwise.  */
2141 static inline bool
2142 reached_end_of_context (cpp_context *context)
2143 {
2144   if (context->tokens_kind == TOKENS_KIND_DIRECT)
2145       return FIRST (context).token == LAST (context).token;
2146   else if (context->tokens_kind == TOKENS_KIND_INDIRECT
2147            || context->tokens_kind == TOKENS_KIND_EXTENDED)
2148     return FIRST (context).ptoken == LAST (context).ptoken;
2149   else
2150     abort ();
2151 }
2152
2153 /* Consume the next token contained in the current context of PFILE,
2154    and return it in *TOKEN. It's "full location" is returned in
2155    *LOCATION. If -ftrack-macro-location is in effeect, fFull location"
2156    means the location encoding the locus of the token accross macro
2157    expansion; otherwise it's just is the "normal" location of the
2158    token which (*TOKEN)->src_loc.  */
2159 static inline void
2160 consume_next_token_from_context (cpp_reader *pfile,
2161                                  const cpp_token ** token,
2162                                  source_location *location)
2163 {
2164   cpp_context *c = pfile->context;
2165
2166   if ((c)->tokens_kind == TOKENS_KIND_DIRECT)
2167     {
2168       *token = FIRST (c).token;
2169       *location = (*token)->src_loc;
2170       FIRST (c).token++;
2171     }
2172   else if ((c)->tokens_kind == TOKENS_KIND_INDIRECT)            
2173     {
2174       *token = *FIRST (c).ptoken;
2175       *location = (*token)->src_loc;
2176       FIRST (c).ptoken++;
2177     }
2178   else if ((c)->tokens_kind == TOKENS_KIND_EXTENDED)
2179     {
2180       macro_context *m = c->c.mc;
2181       *token = *FIRST (c).ptoken;
2182       if (m->virt_locs)
2183         {
2184           *location = *m->cur_virt_loc;
2185           m->cur_virt_loc++;
2186         }
2187       else
2188         *location = (*token)->src_loc;
2189       FIRST (c).ptoken++;
2190     }
2191   else
2192     abort ();
2193 }
2194
2195 /* In the traditional mode of the preprocessor, if we are currently in
2196    a directive, the location of a token must be the location of the
2197    start of the directive line.  This function returns the proper
2198    location if we are in the traditional mode, and just returns
2199    LOCATION otherwise.  */
2200
2201 static inline source_location
2202 maybe_adjust_loc_for_trad_cpp (cpp_reader *pfile, source_location location)
2203 {
2204   if (CPP_OPTION (pfile, traditional))
2205     {
2206       if (pfile->state.in_directive)
2207         return pfile->directive_line;
2208     }
2209   return location;
2210 }
2211
2212 /* Routine to get a token as well as its location.
2213
2214    Macro expansions and directives are transparently handled,
2215    including entering included files.  Thus tokens are post-macro
2216    expansion, and after any intervening directives.  External callers
2217    see CPP_EOF only at EOF.  Internal callers also see it when meeting
2218    a directive inside a macro call, when at the end of a directive and
2219    state.in_directive is still 1, and at the end of argument
2220    pre-expansion.
2221
2222    LOC is an out parameter; *LOC is set to the location "as expected
2223    by the user".  Please read the comment of
2224    cpp_get_token_with_location to learn more about the meaning of this
2225    location.  */
2226 static const cpp_token*
2227 cpp_get_token_1 (cpp_reader *pfile, source_location *location)
2228 {
2229   const cpp_token *result;
2230   bool can_set = pfile->set_invocation_location;
2231   /* This token is a virtual token that either encodes a location
2232      related to macro expansion or a spelling location.  */
2233   source_location virt_loc = 0;
2234   pfile->set_invocation_location = false;
2235
2236   for (;;)
2237     {
2238       cpp_hashnode *node;
2239       cpp_context *context = pfile->context;
2240
2241       /* Context->prev == 0 <=> base context.  */
2242       if (!context->prev)
2243         {
2244           result = _cpp_lex_token (pfile);
2245           virt_loc = result->src_loc;
2246         }
2247       else if (!reached_end_of_context (context))
2248         {
2249           consume_next_token_from_context (pfile, &result,
2250                                            &virt_loc);
2251           if (result->flags & PASTE_LEFT)
2252             {
2253               paste_all_tokens (pfile, result);
2254               if (pfile->state.in_directive)
2255                 continue;
2256               result = padding_token (pfile, result);
2257               goto out;
2258             }
2259         }
2260       else
2261         {
2262           if (pfile->context->c.macro)
2263             ++num_expanded_macros_counter;
2264           _cpp_pop_context (pfile);
2265           if (pfile->state.in_directive)
2266             continue;
2267           result = &pfile->avoid_paste;
2268           goto out;
2269         }
2270
2271       if (pfile->state.in_directive && result->type == CPP_COMMENT)
2272         continue;
2273
2274       if (result->type != CPP_NAME)
2275         break;
2276
2277       node = result->val.node.node;
2278
2279       if (node->type != NT_MACRO || (result->flags & NO_EXPAND))
2280         break;
2281
2282       if (!(node->flags & NODE_DISABLED))
2283         {
2284           int ret = 0;
2285           /* If not in a macro context, and we're going to start an
2286              expansion, record the location.  */
2287           if (can_set && !context->c.macro)
2288             pfile->invocation_location = result->src_loc;
2289           if (pfile->state.prevent_expansion)
2290             break;
2291
2292           /* Conditional macros require that a predicate be evaluated
2293              first.  */
2294           if ((node->flags & NODE_CONDITIONAL) != 0)
2295             {
2296               if (pfile->cb.macro_to_expand)
2297                 {
2298                   bool whitespace_after;
2299                   const cpp_token *peek_tok = cpp_peek_token (pfile, 0);
2300
2301                   whitespace_after = (peek_tok->type == CPP_PADDING
2302                                       || (peek_tok->flags & PREV_WHITE));
2303                   node = pfile->cb.macro_to_expand (pfile, result);
2304                   if (node)
2305                     ret = enter_macro_context (pfile, node, result,
2306                                                virt_loc);
2307                   else if (whitespace_after)
2308                     {
2309                       /* If macro_to_expand hook returned NULL and it
2310                          ate some tokens, see if we don't need to add
2311                          a padding token in between this and the
2312                          next token.  */
2313                       peek_tok = cpp_peek_token (pfile, 0);
2314                       if (peek_tok->type != CPP_PADDING
2315                           && (peek_tok->flags & PREV_WHITE) == 0)
2316                         _cpp_push_token_context (pfile, NULL,
2317                                                  padding_token (pfile,
2318                                                                 peek_tok), 1);
2319                     }
2320                 }
2321             }
2322           else
2323             ret = enter_macro_context (pfile, node, result, 
2324                                        virt_loc);
2325           if (ret)
2326             {
2327               if (pfile->state.in_directive || ret == 2)
2328                 continue;
2329               result = padding_token (pfile, result);
2330               goto out;
2331             }
2332         }
2333       else
2334         {
2335           /* Flag this token as always unexpandable.  FIXME: move this
2336              to collect_args()?.  */
2337           cpp_token *t = _cpp_temp_token (pfile);
2338           t->type = result->type;
2339           t->flags = result->flags | NO_EXPAND;
2340           t->val = result->val;
2341           result = t;
2342         }
2343
2344       break;
2345     }
2346
2347  out:
2348   if (location != NULL)
2349     {
2350       if (virt_loc == 0)
2351         virt_loc = result->src_loc;
2352       *location = virt_loc;
2353
2354       if (!CPP_OPTION (pfile, track_macro_expansion)
2355           && can_set
2356           && pfile->context->c.macro != NULL)
2357         /* We are in a macro expansion context, are not tracking
2358            virtual location, but were asked to report the location
2359            of the expansion point of the macro being expanded.  */
2360         *location = pfile->invocation_location;
2361
2362       *location = maybe_adjust_loc_for_trad_cpp (pfile, *location);
2363     }
2364   return result;
2365 }
2366
2367 /* External routine to get a token.  Also used nearly everywhere
2368    internally, except for places where we know we can safely call
2369    _cpp_lex_token directly, such as lexing a directive name.
2370
2371    Macro expansions and directives are transparently handled,
2372    including entering included files.  Thus tokens are post-macro
2373    expansion, and after any intervening directives.  External callers
2374    see CPP_EOF only at EOF.  Internal callers also see it when meeting
2375    a directive inside a macro call, when at the end of a directive and
2376    state.in_directive is still 1, and at the end of argument
2377    pre-expansion.  */
2378 const cpp_token *
2379 cpp_get_token (cpp_reader *pfile)
2380 {
2381   return cpp_get_token_1 (pfile, NULL);
2382 }
2383
2384 /* Like cpp_get_token, but also returns a virtual token location
2385    separate from the spelling location carried by the returned token.
2386
2387    LOC is an out parameter; *LOC is set to the location "as expected
2388    by the user".  This matters when a token results from macro
2389    expansion; in that case the token's spelling location indicates the
2390    locus of the token in the definition of the macro but *LOC
2391    virtually encodes all the other meaningful locuses associated to
2392    the token.
2393
2394    What? virtual location? Yes, virtual location.
2395
2396    If the token results from macro expansion and if macro expansion
2397    location tracking is enabled its virtual location encodes (at the
2398    same time):
2399
2400    - the spelling location of the token
2401
2402    - the locus of the macro expansion point
2403
2404    - the locus of the point where the token got instantiated as part
2405      of the macro expansion process.
2406
2407    You have to use the linemap API to get the locus you are interested
2408    in from a given virtual location.
2409
2410    Note however that virtual locations are not necessarily ordered for
2411    relations '<' and '>'.  One must use the function
2412    linemap_location_before_p instead of using the relational operator
2413    '<'.
2414
2415    If macro expansion tracking is off and if the token results from
2416    macro expansion the virtual location is the expansion point of the
2417    macro that got expanded.
2418
2419    When the token doesn't result from macro expansion, the virtual
2420    location is just the same thing as its spelling location.  */
2421
2422 const cpp_token *
2423 cpp_get_token_with_location (cpp_reader *pfile, source_location *loc)
2424 {
2425   const cpp_token *result;
2426
2427   pfile->set_invocation_location = true;
2428   result = cpp_get_token_1 (pfile, loc);
2429   return result;
2430 }
2431
2432 /* Returns true if we're expanding an object-like macro that was
2433    defined in a system header.  Just checks the macro at the top of
2434    the stack.  Used for diagnostic suppression.  */
2435 int
2436 cpp_sys_macro_p (cpp_reader *pfile)
2437 {
2438   cpp_hashnode *node = pfile->context->c.macro;
2439
2440   return node && node->value.macro && node->value.macro->syshdr;
2441 }
2442
2443 /* Read each token in, until end of the current file.  Directives are
2444    transparently processed.  */
2445 void
2446 cpp_scan_nooutput (cpp_reader *pfile)
2447 {
2448   /* Request a CPP_EOF token at the end of this file, rather than
2449      transparently continuing with the including file.  */
2450   pfile->buffer->return_at_eof = true;
2451
2452   pfile->state.discarding_output++;
2453   pfile->state.prevent_expansion++;
2454
2455   if (CPP_OPTION (pfile, traditional))
2456     while (_cpp_read_logical_line_trad (pfile))
2457       ;
2458   else
2459     while (cpp_get_token (pfile)->type != CPP_EOF)
2460       ;
2461
2462   pfile->state.discarding_output--;
2463   pfile->state.prevent_expansion--;
2464 }
2465
2466 /* Step back one or more tokens obtained from the lexer.  */
2467 void
2468 _cpp_backup_tokens_direct (cpp_reader *pfile, unsigned int count)
2469 {
2470   pfile->lookaheads += count;
2471   while (count--)
2472     {
2473       pfile->cur_token--;
2474       if (pfile->cur_token == pfile->cur_run->base
2475           /* Possible with -fpreprocessed and no leading #line.  */
2476           && pfile->cur_run->prev != NULL)
2477         {
2478           pfile->cur_run = pfile->cur_run->prev;
2479           pfile->cur_token = pfile->cur_run->limit;
2480         }
2481     }
2482 }
2483
2484 /* Step back one (or more) tokens.  Can only step back more than 1 if
2485    they are from the lexer, and not from macro expansion.  */
2486 void
2487 _cpp_backup_tokens (cpp_reader *pfile, unsigned int count)
2488 {
2489   if (pfile->context->prev == NULL)
2490     _cpp_backup_tokens_direct (pfile, count);
2491   else
2492     {
2493       if (count != 1)
2494         abort ();
2495       if (pfile->context->tokens_kind == TOKENS_KIND_DIRECT)
2496         FIRST (pfile->context).token--;
2497       else if (pfile->context->tokens_kind == TOKENS_KIND_INDIRECT)
2498         FIRST (pfile->context).ptoken--;
2499       else if (pfile->context->tokens_kind == TOKENS_KIND_EXTENDED)
2500         {
2501           FIRST (pfile->context).ptoken--;
2502           if (pfile->context->c.macro)
2503             {
2504               macro_context *m = pfile->context->c.mc;
2505               m->cur_virt_loc--;
2506 #ifdef ENABLE_CHECKING
2507               if (m->cur_virt_loc < m->virt_locs)
2508                 abort ();
2509 #endif
2510             }
2511           else
2512             abort ();
2513         }
2514       else
2515         abort ();
2516     }
2517 }
2518
2519 /* #define directive parsing and handling.  */
2520
2521 /* Returns nonzero if a macro redefinition warning is required.  */
2522 static bool
2523 warn_of_redefinition (cpp_reader *pfile, cpp_hashnode *node,
2524                       const cpp_macro *macro2)
2525 {
2526   const cpp_macro *macro1;
2527   unsigned int i;
2528
2529   /* Some redefinitions need to be warned about regardless.  */
2530   if (node->flags & NODE_WARN)
2531     return true;
2532
2533   /* Suppress warnings for builtins that lack the NODE_WARN flag.  */
2534   if (node->flags & NODE_BUILTIN)
2535     {
2536       if (!pfile->cb.user_builtin_macro
2537           || !pfile->cb.user_builtin_macro (pfile, node))
2538         return false;
2539     }
2540
2541   /* Redefinitions of conditional (context-sensitive) macros, on
2542      the other hand, must be allowed silently.  */
2543   if (node->flags & NODE_CONDITIONAL)
2544     return false;
2545
2546   /* Redefinition of a macro is allowed if and only if the old and new
2547      definitions are the same.  (6.10.3 paragraph 2).  */
2548   macro1 = node->value.macro;
2549
2550   /* Don't check count here as it can be different in valid
2551      traditional redefinitions with just whitespace differences.  */
2552   if (macro1->paramc != macro2->paramc
2553       || macro1->fun_like != macro2->fun_like
2554       || macro1->variadic != macro2->variadic)
2555     return true;
2556
2557   /* Check parameter spellings.  */
2558   for (i = 0; i < macro1->paramc; i++)
2559     if (macro1->params[i] != macro2->params[i])
2560       return true;
2561
2562   /* Check the replacement text or tokens.  */
2563   if (CPP_OPTION (pfile, traditional))
2564     return _cpp_expansions_different_trad (macro1, macro2);
2565
2566   if (macro1->count != macro2->count)
2567     return true;
2568
2569   for (i = 0; i < macro1->count; i++)
2570     if (!_cpp_equiv_tokens (&macro1->exp.tokens[i], &macro2->exp.tokens[i]))
2571       return true;
2572
2573   return false;
2574 }
2575
2576 /* Free the definition of hashnode H.  */
2577 void
2578 _cpp_free_definition (cpp_hashnode *h)
2579 {
2580   /* Macros and assertions no longer have anything to free.  */
2581   h->type = NT_VOID;
2582   /* Clear builtin flag in case of redefinition.  */
2583   h->flags &= ~(NODE_BUILTIN | NODE_DISABLED | NODE_USED);
2584 }
2585
2586 /* Save parameter NODE to the parameter list of macro MACRO.  Returns
2587    zero on success, nonzero if the parameter is a duplicate.  */
2588 bool
2589 _cpp_save_parameter (cpp_reader *pfile, cpp_macro *macro, cpp_hashnode *node)
2590 {
2591   unsigned int len;
2592   /* Constraint 6.10.3.6 - duplicate parameter names.  */
2593   if (node->flags & NODE_MACRO_ARG)
2594     {
2595       cpp_error (pfile, CPP_DL_ERROR, "duplicate macro parameter \"%s\"",
2596                  NODE_NAME (node));
2597       return true;
2598     }
2599
2600   if (BUFF_ROOM (pfile->a_buff)
2601       < (macro->paramc + 1) * sizeof (cpp_hashnode *))
2602     _cpp_extend_buff (pfile, &pfile->a_buff, sizeof (cpp_hashnode *));
2603
2604   ((cpp_hashnode **) BUFF_FRONT (pfile->a_buff))[macro->paramc++] = node;
2605   node->flags |= NODE_MACRO_ARG;
2606   len = macro->paramc * sizeof (union _cpp_hashnode_value);
2607   if (len > pfile->macro_buffer_len)
2608     {
2609       pfile->macro_buffer = XRESIZEVEC (unsigned char, pfile->macro_buffer,
2610                                         len);
2611       pfile->macro_buffer_len = len;
2612     }
2613   ((union _cpp_hashnode_value *) pfile->macro_buffer)[macro->paramc - 1]
2614     = node->value;
2615   
2616   node->value.arg_index  = macro->paramc;
2617   return false;
2618 }
2619
2620 /* Check the syntax of the parameters in a MACRO definition.  Returns
2621    false if an error occurs.  */
2622 static bool
2623 parse_params (cpp_reader *pfile, cpp_macro *macro)
2624 {
2625   unsigned int prev_ident = 0;
2626
2627   for (;;)
2628     {
2629       const cpp_token *token = _cpp_lex_token (pfile);
2630
2631       switch (token->type)
2632         {
2633         default:
2634           /* Allow/ignore comments in parameter lists if we are
2635              preserving comments in macro expansions.  */
2636           if (token->type == CPP_COMMENT
2637               && ! CPP_OPTION (pfile, discard_comments_in_macro_exp))
2638             continue;
2639
2640           cpp_error (pfile, CPP_DL_ERROR,
2641                      "\"%s\" may not appear in macro parameter list",
2642                      cpp_token_as_text (pfile, token));
2643           return false;
2644
2645         case CPP_NAME:
2646           if (prev_ident)
2647             {
2648               cpp_error (pfile, CPP_DL_ERROR,
2649                          "macro parameters must be comma-separated");
2650               return false;
2651             }
2652           prev_ident = 1;
2653
2654           if (_cpp_save_parameter (pfile, macro, token->val.node.node))
2655             return false;
2656           continue;
2657
2658         case CPP_CLOSE_PAREN:
2659           if (prev_ident || macro->paramc == 0)
2660             return true;
2661
2662           /* Fall through to pick up the error.  */
2663         case CPP_COMMA:
2664           if (!prev_ident)
2665             {
2666               cpp_error (pfile, CPP_DL_ERROR, "parameter name missing");
2667               return false;
2668             }
2669           prev_ident = 0;
2670           continue;
2671
2672         case CPP_ELLIPSIS:
2673           macro->variadic = 1;
2674           if (!prev_ident)
2675             {
2676               _cpp_save_parameter (pfile, macro,
2677                                    pfile->spec_nodes.n__VA_ARGS__);
2678               pfile->state.va_args_ok = 1;
2679               if (! CPP_OPTION (pfile, c99)
2680                   && CPP_OPTION (pfile, cpp_pedantic)
2681                   && CPP_OPTION (pfile, warn_variadic_macros))
2682                 cpp_pedwarning
2683                   (pfile, CPP_W_VARIADIC_MACROS,
2684                    "anonymous variadic macros were introduced in C99");
2685             }
2686           else if (CPP_OPTION (pfile, cpp_pedantic)
2687                    && CPP_OPTION (pfile, warn_variadic_macros))
2688             cpp_pedwarning (pfile, CPP_W_VARIADIC_MACROS,
2689                             "ISO C does not permit named variadic macros");
2690
2691           /* We're at the end, and just expect a closing parenthesis.  */
2692           token = _cpp_lex_token (pfile);
2693           if (token->type == CPP_CLOSE_PAREN)
2694             return true;
2695           /* Fall through.  */
2696
2697         case CPP_EOF:
2698           cpp_error (pfile, CPP_DL_ERROR, "missing ')' in macro parameter list");
2699           return false;
2700         }
2701     }
2702 }
2703
2704 /* Allocate room for a token from a macro's replacement list.  */
2705 static cpp_token *
2706 alloc_expansion_token (cpp_reader *pfile, cpp_macro *macro)
2707 {
2708   if (BUFF_ROOM (pfile->a_buff) < (macro->count + 1) * sizeof (cpp_token))
2709     _cpp_extend_buff (pfile, &pfile->a_buff, sizeof (cpp_token));
2710
2711   return &((cpp_token *) BUFF_FRONT (pfile->a_buff))[macro->count++];
2712 }
2713
2714 /* Lex a token from the expansion of MACRO, but mark parameters as we
2715    find them and warn of traditional stringification.  */
2716 static cpp_token *
2717 lex_expansion_token (cpp_reader *pfile, cpp_macro *macro)
2718 {
2719   cpp_token *token, *saved_cur_token;
2720
2721   saved_cur_token = pfile->cur_token;
2722   pfile->cur_token = alloc_expansion_token (pfile, macro);
2723   token = _cpp_lex_direct (pfile);
2724   pfile->cur_token = saved_cur_token;
2725
2726   /* Is this a parameter?  */
2727   if (token->type == CPP_NAME
2728       && (token->val.node.node->flags & NODE_MACRO_ARG) != 0)
2729     {
2730       token->type = CPP_MACRO_ARG;
2731       token->val.macro_arg.arg_no = token->val.node.node->value.arg_index;
2732     }
2733   else if (CPP_WTRADITIONAL (pfile) && macro->paramc > 0
2734            && (token->type == CPP_STRING || token->type == CPP_CHAR))
2735     check_trad_stringification (pfile, macro, &token->val.str);
2736
2737   return token;
2738 }
2739
2740 static bool
2741 create_iso_definition (cpp_reader *pfile, cpp_macro *macro)
2742 {
2743   cpp_token *token;
2744   const cpp_token *ctoken;
2745   bool following_paste_op = false;
2746   const char *paste_op_error_msg =
2747     N_("'##' cannot appear at either end of a macro expansion");
2748   unsigned int num_extra_tokens = 0;
2749
2750   /* Get the first token of the expansion (or the '(' of a
2751      function-like macro).  */
2752   ctoken = _cpp_lex_token (pfile);
2753
2754   if (ctoken->type == CPP_OPEN_PAREN && !(ctoken->flags & PREV_WHITE))
2755     {
2756       bool ok = parse_params (pfile, macro);
2757       macro->params = (cpp_hashnode **) BUFF_FRONT (pfile->a_buff);
2758       if (!ok)
2759         return false;
2760
2761       /* Success.  Commit or allocate the parameter array.  */
2762       if (pfile->hash_table->alloc_subobject)
2763         {
2764           cpp_hashnode **params =
2765             (cpp_hashnode **) pfile->hash_table->alloc_subobject
2766             (sizeof (cpp_hashnode *) * macro->paramc);
2767           memcpy (params, macro->params,
2768                   sizeof (cpp_hashnode *) * macro->paramc);
2769           macro->params = params;
2770         }
2771       else
2772         BUFF_FRONT (pfile->a_buff) = (uchar *) &macro->params[macro->paramc];
2773       macro->fun_like = 1;
2774     }
2775   else if (ctoken->type != CPP_EOF && !(ctoken->flags & PREV_WHITE))
2776     {
2777       /* While ISO C99 requires whitespace before replacement text
2778          in a macro definition, ISO C90 with TC1 allows there characters
2779          from the basic source character set.  */
2780       if (CPP_OPTION (pfile, c99))
2781         cpp_error (pfile, CPP_DL_PEDWARN,
2782                    "ISO C99 requires whitespace after the macro name");
2783       else
2784         {
2785           int warntype = CPP_DL_WARNING;
2786           switch (ctoken->type)
2787             {
2788             case CPP_ATSIGN:
2789             case CPP_AT_NAME:
2790             case CPP_OBJC_STRING:
2791               /* '@' is not in basic character set.  */
2792               warntype = CPP_DL_PEDWARN;
2793               break;
2794             case CPP_OTHER:
2795               /* Basic character set sans letters, digits and _.  */
2796               if (strchr ("!\"#%&'()*+,-./:;<=>?[\\]^{|}~",
2797                           ctoken->val.str.text[0]) == NULL)
2798                 warntype = CPP_DL_PEDWARN;
2799               break;
2800             default:
2801               /* All other tokens start with a character from basic
2802                  character set.  */
2803               break;
2804             }
2805           cpp_error (pfile, warntype,
2806                      "missing whitespace after the macro name");
2807         }
2808     }
2809
2810   if (macro->fun_like)
2811     token = lex_expansion_token (pfile, macro);
2812   else
2813     {
2814       token = alloc_expansion_token (pfile, macro);
2815       *token = *ctoken;
2816     }
2817
2818   for (;;)
2819     {
2820       /* Check the stringifying # constraint 6.10.3.2.1 of
2821          function-like macros when lexing the subsequent token.  */
2822       if (macro->count > 1 && token[-1].type == CPP_HASH && macro->fun_like)
2823         {
2824           if (token->type == CPP_MACRO_ARG)
2825             {
2826               if (token->flags & PREV_WHITE)
2827                 token->flags |= SP_PREV_WHITE;
2828               if (token[-1].flags & DIGRAPH)
2829                 token->flags |= SP_DIGRAPH;
2830               token->flags &= ~PREV_WHITE;
2831               token->flags |= STRINGIFY_ARG;
2832               token->flags |= token[-1].flags & PREV_WHITE;
2833               token[-1] = token[0];
2834               macro->count--;
2835             }
2836           /* Let assembler get away with murder.  */
2837           else if (CPP_OPTION (pfile, lang) != CLK_ASM)
2838             {
2839               cpp_error (pfile, CPP_DL_ERROR,
2840                          "'#' is not followed by a macro parameter");
2841               return false;
2842             }
2843         }
2844
2845       if (token->type == CPP_EOF)
2846         {
2847           /* Paste operator constraint 6.10.3.3.1:
2848              Token-paste ##, can appear in both object-like and
2849              function-like macros, but not at the end.  */
2850           if (following_paste_op)
2851             {
2852               cpp_error (pfile, CPP_DL_ERROR, paste_op_error_msg);
2853               return false;
2854             }
2855           break;
2856         }
2857
2858       /* Paste operator constraint 6.10.3.3.1.  */
2859       if (token->type == CPP_PASTE)
2860         {
2861           /* Token-paste ##, can appear in both object-like and
2862              function-like macros, but not at the beginning.  */
2863           if (macro->count == 1)
2864             {
2865               cpp_error (pfile, CPP_DL_ERROR, paste_op_error_msg);
2866               return false;
2867             }
2868
2869           if (token[-1].flags & PASTE_LEFT)
2870             {
2871               macro->extra_tokens = 1;
2872               num_extra_tokens++;
2873               token->val.token_no = macro->count - 1;
2874             }
2875           else
2876             {
2877               --macro->count;
2878               token[-1].flags |= PASTE_LEFT;
2879               if (token->flags & DIGRAPH)
2880                 token[-1].flags |= SP_DIGRAPH;
2881               if (token->flags & PREV_WHITE)
2882                 token[-1].flags |= SP_PREV_WHITE;
2883             }
2884         }
2885
2886       following_paste_op = (token->type == CPP_PASTE);
2887       token = lex_expansion_token (pfile, macro);
2888     }
2889
2890   macro->exp.tokens = (cpp_token *) BUFF_FRONT (pfile->a_buff);
2891   macro->traditional = 0;
2892
2893   /* Don't count the CPP_EOF.  */
2894   macro->count--;
2895
2896   /* Clear whitespace on first token for warn_of_redefinition().  */
2897   if (macro->count)
2898     macro->exp.tokens[0].flags &= ~PREV_WHITE;
2899
2900   /* Commit or allocate the memory.  */
2901   if (pfile->hash_table->alloc_subobject)
2902     {
2903       cpp_token *tokns =
2904         (cpp_token *) pfile->hash_table->alloc_subobject (sizeof (cpp_token)
2905                                                           * macro->count);
2906       if (num_extra_tokens)
2907         {
2908           /* Place second and subsequent ## or %:%: tokens in
2909              sequences of consecutive such tokens at the end of the
2910              list to preserve information about where they appear, how
2911              they are spelt and whether they are preceded by
2912              whitespace without otherwise interfering with macro
2913              expansion.  */
2914           cpp_token *normal_dest = tokns;
2915           cpp_token *extra_dest = tokns + macro->count - num_extra_tokens;
2916           unsigned int i;
2917           for (i = 0; i < macro->count; i++)
2918             {
2919               if (macro->exp.tokens[i].type == CPP_PASTE)
2920                 *extra_dest++ = macro->exp.tokens[i];
2921               else
2922                 *normal_dest++ = macro->exp.tokens[i];
2923             }
2924         }
2925       else
2926         memcpy (tokns, macro->exp.tokens, sizeof (cpp_token) * macro->count);
2927       macro->exp.tokens = tokns;
2928     }
2929   else
2930     BUFF_FRONT (pfile->a_buff) = (uchar *) &macro->exp.tokens[macro->count];
2931
2932   return true;
2933 }
2934
2935 /* Parse a macro and save its expansion.  Returns nonzero on success.  */
2936 bool
2937 _cpp_create_definition (cpp_reader *pfile, cpp_hashnode *node)
2938 {
2939   cpp_macro *macro;
2940   unsigned int i;
2941   bool ok;
2942
2943   if (pfile->hash_table->alloc_subobject)
2944     macro = (cpp_macro *) pfile->hash_table->alloc_subobject
2945       (sizeof (cpp_macro));
2946   else
2947     macro = (cpp_macro *) _cpp_aligned_alloc (pfile, sizeof (cpp_macro));
2948   macro->line = pfile->directive_line;
2949   macro->params = 0;
2950   macro->paramc = 0;
2951   macro->variadic = 0;
2952   macro->used = !CPP_OPTION (pfile, warn_unused_macros);
2953   macro->count = 0;
2954   macro->fun_like = 0;
2955   macro->extra_tokens = 0;
2956   /* To suppress some diagnostics.  */
2957   macro->syshdr = pfile->buffer && pfile->buffer->sysp != 0;
2958
2959   if (CPP_OPTION (pfile, traditional))
2960     ok = _cpp_create_trad_definition (pfile, macro);
2961   else
2962     {
2963       ok = create_iso_definition (pfile, macro);
2964
2965       /* We set the type for SEEN_EOL() in directives.c.
2966
2967          Longer term we should lex the whole line before coming here,
2968          and just copy the expansion.  */
2969
2970       /* Stop the lexer accepting __VA_ARGS__.  */
2971       pfile->state.va_args_ok = 0;
2972     }
2973
2974   /* Clear the fast argument lookup indices.  */
2975   for (i = macro->paramc; i-- > 0; )
2976     {
2977       struct cpp_hashnode *node = macro->params[i];
2978       node->flags &= ~ NODE_MACRO_ARG;
2979       node->value = ((union _cpp_hashnode_value *) pfile->macro_buffer)[i];
2980     }
2981
2982   if (!ok)
2983     return ok;
2984
2985   if (node->type == NT_MACRO)
2986     {
2987       if (CPP_OPTION (pfile, warn_unused_macros))
2988         _cpp_warn_if_unused_macro (pfile, node, NULL);
2989
2990       if (warn_of_redefinition (pfile, node, macro))
2991         {
2992           const int reason = (node->flags & NODE_BUILTIN)
2993                              ? CPP_W_BUILTIN_MACRO_REDEFINED : CPP_W_NONE;
2994           bool warned;
2995
2996           warned = cpp_pedwarning_with_line (pfile, reason,
2997                                              pfile->directive_line, 0,
2998                                              "\"%s\" redefined",
2999                                              NODE_NAME (node));
3000
3001           if (warned && node->type == NT_MACRO && !(node->flags & NODE_BUILTIN))
3002             cpp_error_with_line (pfile, CPP_DL_NOTE,
3003                                  node->value.macro->line, 0,
3004                          "this is the location of the previous definition");
3005         }
3006     }
3007
3008   if (node->type != NT_VOID)
3009     _cpp_free_definition (node);
3010
3011   /* Enter definition in hash table.  */
3012   node->type = NT_MACRO;
3013   node->value.macro = macro;
3014   if (! ustrncmp (NODE_NAME (node), DSC ("__STDC_"))
3015       && ustrcmp (NODE_NAME (node), (const uchar *) "__STDC_FORMAT_MACROS")
3016       /* __STDC_LIMIT_MACROS and __STDC_CONSTANT_MACROS are mentioned
3017          in the C standard, as something that one must use in C++.
3018          However DR#593 indicates that these aren't actually mentioned
3019          in the C++ standard.  We special-case them anyway.  */
3020       && ustrcmp (NODE_NAME (node), (const uchar *) "__STDC_LIMIT_MACROS")
3021       && ustrcmp (NODE_NAME (node), (const uchar *) "__STDC_CONSTANT_MACROS"))
3022     node->flags |= NODE_WARN;
3023
3024   /* If user defines one of the conditional macros, remove the
3025      conditional flag */
3026   node->flags &= ~NODE_CONDITIONAL;
3027
3028   return ok;
3029 }
3030
3031 /* Warn if a token in STRING matches one of a function-like MACRO's
3032    parameters.  */
3033 static void
3034 check_trad_stringification (cpp_reader *pfile, const cpp_macro *macro,
3035                             const cpp_string *string)
3036 {
3037   unsigned int i, len;
3038   const uchar *p, *q, *limit;
3039
3040   /* Loop over the string.  */
3041   limit = string->text + string->len - 1;
3042   for (p = string->text + 1; p < limit; p = q)
3043     {
3044       /* Find the start of an identifier.  */
3045       while (p < limit && !is_idstart (*p))
3046         p++;
3047
3048       /* Find the end of the identifier.  */
3049       q = p;
3050       while (q < limit && is_idchar (*q))
3051         q++;
3052
3053       len = q - p;
3054
3055       /* Loop over the function macro arguments to see if the
3056          identifier inside the string matches one of them.  */
3057       for (i = 0; i < macro->paramc; i++)
3058         {
3059           const cpp_hashnode *node = macro->params[i];
3060
3061           if (NODE_LEN (node) == len
3062               && !memcmp (p, NODE_NAME (node), len))
3063             {
3064               cpp_error (pfile, CPP_DL_WARNING,
3065            "macro argument \"%s\" would be stringified in traditional C",
3066                          NODE_NAME (node));
3067               break;
3068             }
3069         }
3070     }
3071 }
3072
3073 /* Returns the name, arguments and expansion of a macro, in a format
3074    suitable to be read back in again, and therefore also for DWARF 2
3075    debugging info.  e.g. "PASTE(X, Y) X ## Y", or "MACNAME EXPANSION".
3076    Caller is expected to generate the "#define" bit if needed.  The
3077    returned text is temporary, and automatically freed later.  */
3078 const unsigned char *
3079 cpp_macro_definition (cpp_reader *pfile, cpp_hashnode *node)
3080 {
3081   unsigned int i, len;
3082   const cpp_macro *macro;
3083   unsigned char *buffer;
3084
3085   if (node->type != NT_MACRO || (node->flags & NODE_BUILTIN))
3086     {
3087       if (node->type != NT_MACRO
3088           || !pfile->cb.user_builtin_macro
3089           || !pfile->cb.user_builtin_macro (pfile, node))
3090         {
3091           cpp_error (pfile, CPP_DL_ICE,
3092                      "invalid hash type %d in cpp_macro_definition",
3093                      node->type);
3094           return 0;
3095         }
3096     }
3097
3098   macro = node->value.macro;
3099   /* Calculate length.  */
3100   len = NODE_LEN (node) + 2;                    /* ' ' and NUL.  */
3101   if (macro->fun_like)
3102     {
3103       len += 4;         /* "()" plus possible final ".." of named
3104                            varargs (we have + 1 below).  */
3105       for (i = 0; i < macro->paramc; i++)
3106         len += NODE_LEN (macro->params[i]) + 1; /* "," */
3107     }
3108
3109   /* This should match below where we fill in the buffer.  */
3110   if (CPP_OPTION (pfile, traditional))
3111     len += _cpp_replacement_text_len (macro);
3112   else
3113     {
3114       unsigned int count = macro_real_token_count (macro);
3115       for (i = 0; i < count; i++)
3116         {
3117           cpp_token *token = &macro->exp.tokens[i];
3118
3119           if (token->type == CPP_MACRO_ARG)
3120             len += NODE_LEN (macro->params[token->val.macro_arg.arg_no - 1]);
3121           else
3122             len += cpp_token_len (token);
3123
3124           if (token->flags & STRINGIFY_ARG)
3125             len++;                      /* "#" */
3126           if (token->flags & PASTE_LEFT)
3127             len += 3;           /* " ##" */
3128           if (token->flags & PREV_WHITE)
3129             len++;              /* " " */
3130         }
3131     }
3132
3133   if (len > pfile->macro_buffer_len)
3134     {
3135       pfile->macro_buffer = XRESIZEVEC (unsigned char,
3136                                         pfile->macro_buffer, len);
3137       pfile->macro_buffer_len = len;
3138     }
3139
3140   /* Fill in the buffer.  Start with the macro name.  */
3141   buffer = pfile->macro_buffer;
3142   memcpy (buffer, NODE_NAME (node), NODE_LEN (node));
3143   buffer += NODE_LEN (node);
3144
3145   /* Parameter names.  */
3146   if (macro->fun_like)
3147     {
3148       *buffer++ = '(';
3149       for (i = 0; i < macro->paramc; i++)
3150         {
3151           cpp_hashnode *param = macro->params[i];
3152
3153           if (param != pfile->spec_nodes.n__VA_ARGS__)
3154             {
3155               memcpy (buffer, NODE_NAME (param), NODE_LEN (param));
3156               buffer += NODE_LEN (param);
3157             }
3158
3159           if (i + 1 < macro->paramc)
3160             /* Don't emit a space after the comma here; we're trying
3161                to emit a Dwarf-friendly definition, and the Dwarf spec
3162                forbids spaces in the argument list.  */
3163             *buffer++ = ',';
3164           else if (macro->variadic)
3165             *buffer++ = '.', *buffer++ = '.', *buffer++ = '.';
3166         }
3167       *buffer++ = ')';
3168     }
3169
3170   /* The Dwarf spec requires a space after the macro name, even if the
3171      definition is the empty string.  */
3172   *buffer++ = ' ';
3173
3174   if (CPP_OPTION (pfile, traditional))
3175     buffer = _cpp_copy_replacement_text (macro, buffer);
3176   else if (macro->count)
3177   /* Expansion tokens.  */
3178     {
3179       unsigned int count = macro_real_token_count (macro);
3180       for (i = 0; i < count; i++)
3181         {
3182           cpp_token *token = &macro->exp.tokens[i];
3183
3184           if (token->flags & PREV_WHITE)
3185             *buffer++ = ' ';
3186           if (token->flags & STRINGIFY_ARG)
3187             *buffer++ = '#';
3188
3189           if (token->type == CPP_MACRO_ARG)
3190             {
3191               memcpy (buffer,
3192                       NODE_NAME (macro->params[token->val.macro_arg.arg_no - 1]),
3193                       NODE_LEN (macro->params[token->val.macro_arg.arg_no - 1]));
3194               buffer += NODE_LEN (macro->params[token->val.macro_arg.arg_no - 1]);
3195             }
3196           else
3197             buffer = cpp_spell_token (pfile, token, buffer, false);
3198
3199           if (token->flags & PASTE_LEFT)
3200             {
3201               *buffer++ = ' ';
3202               *buffer++ = '#';
3203               *buffer++ = '#';
3204               /* Next has PREV_WHITE; see _cpp_create_definition.  */
3205             }
3206         }
3207     }
3208
3209   *buffer = '\0';
3210   return pfile->macro_buffer;
3211 }