blob: 016754bc9529566ce2929bd1801bf13942b2f39c [file] [log] [blame]
Neil Booth93c803682000-10-28 17:59:06 +00001/* Part of CPP library. (Macro and #define handling.)
Zack Weinberg711b8822000-07-18 00:59:49 +00002 Copyright (C) 1986, 1987, 1989, 1992, 1993, 1994, 1995, 1996, 1998,
Tom Tromeyee380362007-01-30 15:46:01 +00003 1999, 2000, 2001, 2002, 2003, 2004, 2005,
Tom Tromeyec460532008-01-22 21:43:49 +00004 2006, 2007, 2008 Free Software Foundation, Inc.
Zack Weinberg711b8822000-07-18 00:59:49 +00005 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
9This program is free software; you can redistribute it and/or modify it
10under the terms of the GNU General Public License as published by the
11Free Software Foundation; either version 2, or (at your option) any
12later version.
13
14This program is distributed in the hope that it will be useful,
15but WITHOUT ANY WARRANTY; without even the implied warranty of
16MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17GNU General Public License for more details.
18
19You should have received a copy of the GNU General Public License
20along with this program; if not, write to the Free Software
Kelley Cook200031d2005-06-29 02:34:39 +000021Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
Zack Weinberg711b8822000-07-18 00:59:49 +000022
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"
Paolo Bonzini4f4e53dd2004-05-24 10:50:45 +000030#include "internal.h"
Zack Weinberg711b8822000-07-18 00:59:49 +000031
Neil Booth93c803682000-10-28 17:59:06 +000032typedef struct macro_arg macro_arg;
33struct macro_arg
34{
Neil Booth4ed5bcf2001-09-24 22:53:12 +000035 const cpp_token **first; /* First token in unexpanded argument. */
Kazu Hirata6d2f8882001-10-10 11:33:39 +000036 const cpp_token **expanded; /* Macro-expanded argument. */
Neil Booth4ed5bcf2001-09-24 22:53:12 +000037 const cpp_token *stringified; /* Stringified argument. */
Neil Booth93c803682000-10-28 17:59:06 +000038 unsigned int count; /* # of tokens in argument. */
39 unsigned int expanded_count; /* # of tokens in expanded argument. */
40};
Zack Weinberg711b8822000-07-18 00:59:49 +000041
Neil Booth93c803682000-10-28 17:59:06 +000042/* Macro expansion. */
43
Jakub Jelinek765d6002008-01-25 10:01:27 +010044static int enter_macro_context (cpp_reader *, cpp_hashnode *,
45 const cpp_token *);
Zack Weinberg6cf87ca2003-06-17 06:17:44 +000046static int builtin_macro (cpp_reader *, cpp_hashnode *);
Zack Weinberg6cf87ca2003-06-17 06:17:44 +000047static void push_ptoken_context (cpp_reader *, cpp_hashnode *, _cpp_buff *,
48 const cpp_token **, unsigned int);
Jakub Jelinek765d6002008-01-25 10:01:27 +010049static _cpp_buff *collect_args (cpp_reader *, const cpp_hashnode *,
50 _cpp_buff **);
Zack Weinberg6cf87ca2003-06-17 06:17:44 +000051static cpp_context *next_context (cpp_reader *);
52static const cpp_token *padding_token (cpp_reader *, const cpp_token *);
53static void expand_arg (cpp_reader *, macro_arg *);
54static const cpp_token *new_string_token (cpp_reader *, uchar *, unsigned int);
55static const cpp_token *stringify_arg (cpp_reader *, macro_arg *);
56static void paste_all_tokens (cpp_reader *, const cpp_token *);
57static bool paste_tokens (cpp_reader *, const cpp_token **, const cpp_token *);
58static void replace_args (cpp_reader *, cpp_hashnode *, cpp_macro *,
59 macro_arg *);
Jakub Jelinek765d6002008-01-25 10:01:27 +010060static _cpp_buff *funlike_invocation_p (cpp_reader *, cpp_hashnode *,
61 _cpp_buff **);
Zack Weinberg6cf87ca2003-06-17 06:17:44 +000062static bool create_iso_definition (cpp_reader *, cpp_macro *);
Neil Booth93c803682000-10-28 17:59:06 +000063
Neil Booth93c803682000-10-28 17:59:06 +000064/* #define directive parsing and handling. */
65
Zack Weinberg6cf87ca2003-06-17 06:17:44 +000066static cpp_token *alloc_expansion_token (cpp_reader *, cpp_macro *);
67static cpp_token *lex_expansion_token (cpp_reader *, cpp_macro *);
68static bool warn_of_redefinition (cpp_reader *, const cpp_hashnode *,
69 const cpp_macro *);
70static bool parse_params (cpp_reader *, cpp_macro *);
71static void check_trad_stringification (cpp_reader *, const cpp_macro *,
72 const cpp_string *);
Zack Weinberg711b8822000-07-18 00:59:49 +000073
Neil Bootha69cbaa2002-07-23 22:57:49 +000074/* Emits a warning if NODE is a macro defined in the main file that
75 has not been used. */
76int
Zack Weinberg6cf87ca2003-06-17 06:17:44 +000077_cpp_warn_if_unused_macro (cpp_reader *pfile, cpp_hashnode *node,
78 void *v ATTRIBUTE_UNUSED)
Neil Bootha69cbaa2002-07-23 22:57:49 +000079{
80 if (node->type == NT_MACRO && !(node->flags & NODE_BUILTIN))
81 {
82 cpp_macro *macro = node->value.macro;
83
84 if (!macro->used
Per Bothner50f59cd2004-01-19 21:30:18 -080085 && MAIN_FILE_P (linemap_lookup (pfile->line_table, macro->line)))
John David Anglin0527bc42003-11-01 22:56:54 +000086 cpp_error_with_line (pfile, CPP_DL_WARNING, macro->line, 0,
Neil Bootha69cbaa2002-07-23 22:57:49 +000087 "macro \"%s\" is not used", NODE_NAME (node));
88 }
89
90 return 1;
91}
92
Neil Booth4ed5bcf2001-09-24 22:53:12 +000093/* Allocates and returns a CPP_STRING token, containing TEXT of length
94 LEN, after null-terminating it. TEXT must be in permanent storage. */
95static const cpp_token *
Zack Weinberg6cf87ca2003-06-17 06:17:44 +000096new_string_token (cpp_reader *pfile, unsigned char *text, unsigned int len)
Zack Weinberg711b8822000-07-18 00:59:49 +000097{
Neil Booth4ed5bcf2001-09-24 22:53:12 +000098 cpp_token *token = _cpp_temp_token (pfile);
Zack Weinberg711b8822000-07-18 00:59:49 +000099
Neil Booth4ed5bcf2001-09-24 22:53:12 +0000100 text[len] = '\0';
Neil Booth93c803682000-10-28 17:59:06 +0000101 token->type = CPP_STRING;
Neil Booth4ed5bcf2001-09-24 22:53:12 +0000102 token->val.str.len = len;
103 token->val.str.text = text;
Neil Booth93c803682000-10-28 17:59:06 +0000104 token->flags = 0;
Neil Booth4ed5bcf2001-09-24 22:53:12 +0000105 return token;
Neil Booth93c803682000-10-28 17:59:06 +0000106}
107
Neil Booth93c803682000-10-28 17:59:06 +0000108static const char * const monthnames[] =
109{
110 "Jan", "Feb", "Mar", "Apr", "May", "Jun",
111 "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"
112};
113
Zack Weinberg21b11492004-09-09 19:16:56 +0000114/* Helper function for builtin_macro. Returns the text generated by
115 a builtin macro. */
Neil Booth278c4662002-06-19 05:40:08 +0000116const uchar *
Zack Weinberg6cf87ca2003-06-17 06:17:44 +0000117_cpp_builtin_macro_text (cpp_reader *pfile, cpp_hashnode *node)
Neil Booth93c803682000-10-28 17:59:06 +0000118{
Per Bothner12f9df42004-02-11 07:29:30 -0800119 const struct line_map *map;
Neil Booth278c4662002-06-19 05:40:08 +0000120 const uchar *result = NULL;
121 unsigned int number = 1;
Neil Booth644edda2001-10-02 12:57:24 +0000122
Neil Booth93c803682000-10-28 17:59:06 +0000123 switch (node->value.builtin)
124 {
Neil Booth4ed5bcf2001-09-24 22:53:12 +0000125 default:
John David Anglin0527bc42003-11-01 22:56:54 +0000126 cpp_error (pfile, CPP_DL_ICE, "invalid built-in macro \"%s\"",
Neil Boothebef4e82002-04-14 18:42:47 +0000127 NODE_NAME (node));
Neil Booth278c4662002-06-19 05:40:08 +0000128 break;
Neil Booth4ed5bcf2001-09-24 22:53:12 +0000129
Grigory Zagorodnevbe8ac3e2006-02-18 09:25:31 +0000130 case BT_TIMESTAMP:
131 {
132 cpp_buffer *pbuffer = cpp_get_buffer (pfile);
133 if (pbuffer->timestamp == NULL)
134 {
135 /* Initialize timestamp value of the assotiated file. */
136 struct _cpp_file *file = cpp_get_file (pbuffer);
137 if (file)
138 {
139 /* Generate __TIMESTAMP__ string, that represents
140 the date and time of the last modification
141 of the current source file. The string constant
142 looks like "Sun Sep 16 01:03:52 1973". */
143 struct tm *tb = NULL;
144 struct stat *st = _cpp_get_file_stat (file);
145 if (st)
146 tb = localtime (&st->st_mtime);
147 if (tb)
148 {
149 char *str = asctime (tb);
150 size_t len = strlen (str);
151 unsigned char *buf = _cpp_unaligned_alloc (pfile, len + 2);
152 buf[0] = '"';
153 strcpy ((char *) buf + 1, str);
154 buf[len] = '"';
155 pbuffer->timestamp = buf;
156 }
157 else
158 {
159 cpp_errno (pfile, CPP_DL_WARNING,
160 "could not determine file timestamp");
Kris Van Heesb6baa672008-04-18 13:58:08 +0000161 pbuffer->timestamp = UC"\"??? ??? ?? ??:??:?? ????\"";
Grigory Zagorodnevbe8ac3e2006-02-18 09:25:31 +0000162 }
163 }
164 }
165 result = pbuffer->timestamp;
166 }
167 break;
Neil Booth93c803682000-10-28 17:59:06 +0000168 case BT_FILE:
169 case BT_BASE_FILE:
Zack Weinberg711b8822000-07-18 00:59:49 +0000170 {
Neil Booth4ed5bcf2001-09-24 22:53:12 +0000171 unsigned int len;
Neil Booth0bda4762000-12-11 07:45:16 +0000172 const char *name;
Neil Booth562a5c22002-04-21 18:46:42 +0000173 uchar *buf;
Per Bothner500bee02004-04-22 19:22:27 -0700174 map = linemap_lookup (pfile->line_table, pfile->line_table->highest_line);
Neil Booth93c803682000-10-28 17:59:06 +0000175
Neil Booth0bda4762000-12-11 07:45:16 +0000176 if (node->value.builtin == BT_BASE_FILE)
Neil Boothbb74c962001-08-17 22:23:49 +0000177 while (! MAIN_FILE_P (map))
Per Bothner50f59cd2004-01-19 21:30:18 -0800178 map = INCLUDED_FROM (pfile->line_table, map);
Neil Booth93c803682000-10-28 17:59:06 +0000179
Neil Boothbb74c962001-08-17 22:23:49 +0000180 name = map->to_file;
Neil Booth4ed5bcf2001-09-24 22:53:12 +0000181 len = strlen (name);
Andrew Pinski651ed942005-11-04 00:23:01 +0000182 buf = _cpp_unaligned_alloc (pfile, len * 2 + 3);
Neil Booth278c4662002-06-19 05:40:08 +0000183 result = buf;
184 *buf = '"';
185 buf = cpp_quote_string (buf + 1, (const unsigned char *) name, len);
186 *buf++ = '"';
187 *buf = '\0';
Zack Weinberg711b8822000-07-18 00:59:49 +0000188 }
Neil Booth644edda2001-10-02 12:57:24 +0000189 break;
190
Neil Booth93c803682000-10-28 17:59:06 +0000191 case BT_INCLUDE_LEVEL:
Neil Boothd8693c62001-08-21 23:05:12 +0000192 /* The line map depth counts the primary source as level 1, but
193 historically __INCLUDE_DEPTH__ has called the primary source
194 level 0. */
Per Bothner50f59cd2004-01-19 21:30:18 -0800195 number = pfile->line_table->depth - 1;
Neil Booth644edda2001-10-02 12:57:24 +0000196 break;
Neil Booth93c803682000-10-28 17:59:06 +0000197
198 case BT_SPECLINE:
Per Bothner500bee02004-04-22 19:22:27 -0700199 map = &pfile->line_table->maps[pfile->line_table->used-1];
Neil Booth93c803682000-10-28 17:59:06 +0000200 /* If __LINE__ is embedded in a macro, it must expand to the
201 line of the macro's invocation, not its definition.
202 Otherwise things like assert() will not work properly. */
Neil Booth278c4662002-06-19 05:40:08 +0000203 if (CPP_OPTION (pfile, traditional))
Per Bothner500bee02004-04-22 19:22:27 -0700204 number = pfile->line_table->highest_line;
Neil Booth278c4662002-06-19 05:40:08 +0000205 else
Per Bothner12f9df42004-02-11 07:29:30 -0800206 number = pfile->cur_token[-1].src_loc;
207 number = SOURCE_LINE (map, number);
Neil Booth644edda2001-10-02 12:57:24 +0000208 break;
Neil Booth93c803682000-10-28 17:59:06 +0000209
Zack Weinberg5279d732002-05-16 19:03:02 +0000210 /* __STDC__ has the value 1 under normal circumstances.
211 However, if (a) we are in a system header, (b) the option
Zack Weinberg2a1dc0d2002-05-21 21:55:37 +0000212 stdc_0_in_system_headers is true (set by target config), and
213 (c) we are not in strictly conforming mode, then it has the
Jakub Jelinek83900992006-01-23 22:50:15 +0100214 value 0. (b) and (c) are already checked in cpp_init_builtins. */
Neil Booth93c803682000-10-28 17:59:06 +0000215 case BT_STDC:
Jakub Jelinek83900992006-01-23 22:50:15 +0100216 if (cpp_in_system_header (pfile))
217 number = 0;
218 else
219 number = 1;
Neil Booth644edda2001-10-02 12:57:24 +0000220 break;
Neil Booth93c803682000-10-28 17:59:06 +0000221
222 case BT_DATE:
223 case BT_TIME:
Neil Booth278c4662002-06-19 05:40:08 +0000224 if (pfile->date == NULL)
Neil Booth93c803682000-10-28 17:59:06 +0000225 {
Neil Booth4ed5bcf2001-09-24 22:53:12 +0000226 /* Allocate __DATE__ and __TIME__ strings from permanent
227 storage. We only do this once, and don't generate them
228 at init time, because time() and localtime() are very
229 slow on some systems. */
Zack Weinberg56da7202002-08-02 04:18:16 +0000230 time_t tt;
231 struct tm *tb = NULL;
Neil Booth93c803682000-10-28 17:59:06 +0000232
Zack Weinberg56da7202002-08-02 04:18:16 +0000233 /* (time_t) -1 is a legitimate value for "number of seconds
234 since the Epoch", so we have to do a little dance to
235 distinguish that from a genuine error. */
236 errno = 0;
237 tt = time(NULL);
238 if (tt != (time_t)-1 || errno == 0)
239 tb = localtime (&tt);
Neil Booth4ed5bcf2001-09-24 22:53:12 +0000240
Zack Weinberg56da7202002-08-02 04:18:16 +0000241 if (tb)
242 {
243 pfile->date = _cpp_unaligned_alloc (pfile,
244 sizeof ("\"Oct 11 1347\""));
245 sprintf ((char *) pfile->date, "\"%s %2d %4d\"",
Zack Weinberg6cf87ca2003-06-17 06:17:44 +0000246 monthnames[tb->tm_mon], tb->tm_mday,
247 tb->tm_year + 1900);
Zack Weinberg56da7202002-08-02 04:18:16 +0000248
249 pfile->time = _cpp_unaligned_alloc (pfile,
250 sizeof ("\"12:34:56\""));
251 sprintf ((char *) pfile->time, "\"%02d:%02d:%02d\"",
252 tb->tm_hour, tb->tm_min, tb->tm_sec);
253 }
254 else
255 {
John David Anglin0527bc42003-11-01 22:56:54 +0000256 cpp_errno (pfile, CPP_DL_WARNING,
Zack Weinberg56da7202002-08-02 04:18:16 +0000257 "could not determine date and time");
258
Kris Van Heesb6baa672008-04-18 13:58:08 +0000259 pfile->date = UC"\"??? ?? ????\"";
260 pfile->time = UC"\"??:??:??\"";
Zack Weinberg56da7202002-08-02 04:18:16 +0000261 }
Neil Booth93c803682000-10-28 17:59:06 +0000262 }
Neil Booth93c803682000-10-28 17:59:06 +0000263
Neil Booth644edda2001-10-02 12:57:24 +0000264 if (node->value.builtin == BT_DATE)
Neil Booth278c4662002-06-19 05:40:08 +0000265 result = pfile->date;
Neil Booth644edda2001-10-02 12:57:24 +0000266 else
Neil Booth278c4662002-06-19 05:40:08 +0000267 result = pfile->time;
Neil Booth644edda2001-10-02 12:57:24 +0000268 break;
Ollie Wilda7020452007-05-24 20:55:36 +0000269
270 case BT_COUNTER:
Ollie Wildccfc4c92007-07-30 18:29:20 +0000271 if (CPP_OPTION (pfile, directives_only) && pfile->state.in_directive)
272 cpp_error (pfile, CPP_DL_ERROR,
273 "__COUNTER__ expanded inside directive with -fdirectives-only");
Ollie Wilda7020452007-05-24 20:55:36 +0000274 number = pfile->counter++;
275 break;
Neil Booth278c4662002-06-19 05:40:08 +0000276 }
Neil Booth644edda2001-10-02 12:57:24 +0000277
Neil Booth278c4662002-06-19 05:40:08 +0000278 if (result == NULL)
279 {
280 /* 21 bytes holds all NUL-terminated unsigned 64-bit numbers. */
281 result = _cpp_unaligned_alloc (pfile, 21);
282 sprintf ((char *) result, "%u", number);
283 }
284
285 return result;
286}
287
288/* Convert builtin macros like __FILE__ to a token and push it on the
Zack Weinberg21b11492004-09-09 19:16:56 +0000289 context stack. Also handles _Pragma, for which a new token may not
290 be created. Returns 1 if it generates a new token context, 0 to
Neil Booth278c4662002-06-19 05:40:08 +0000291 return the token to the caller. */
292static int
Zack Weinberg6cf87ca2003-06-17 06:17:44 +0000293builtin_macro (cpp_reader *pfile, cpp_hashnode *node)
Neil Booth278c4662002-06-19 05:40:08 +0000294{
295 const uchar *buf;
Neil Booth26aea072003-04-19 00:22:51 +0000296 size_t len;
297 char *nbuf;
Neil Booth278c4662002-06-19 05:40:08 +0000298
299 if (node->value.builtin == BT_PRAGMA)
300 {
Neil Booth644edda2001-10-02 12:57:24 +0000301 /* Don't interpret _Pragma within directives. The standard is
302 not clear on this, but to me this makes most sense. */
303 if (pfile->state.in_directive)
304 return 0;
305
Tom Tromey5b9a40d2007-10-31 14:50:13 +0000306 return _cpp_do__Pragma (pfile);
Neil Booth93c803682000-10-28 17:59:06 +0000307 }
Neil Booth644edda2001-10-02 12:57:24 +0000308
Neil Booth278c4662002-06-19 05:40:08 +0000309 buf = _cpp_builtin_macro_text (pfile, node);
Neil Booth26aea072003-04-19 00:22:51 +0000310 len = ustrlen (buf);
Gabriel Dos Reisc3f829c2005-05-28 15:52:48 +0000311 nbuf = (char *) alloca (len + 1);
Neil Booth26aea072003-04-19 00:22:51 +0000312 memcpy (nbuf, buf, len);
313 nbuf[len]='\n';
Neil Booth278c4662002-06-19 05:40:08 +0000314
Per Bothner40de9f72003-10-02 07:30:34 +0000315 cpp_push_buffer (pfile, (uchar *) nbuf, len, /* from_stage3 */ true);
Neil Booth26aea072003-04-19 00:22:51 +0000316 _cpp_clean_line (pfile);
Neil Booth278c4662002-06-19 05:40:08 +0000317
318 /* Set pfile->cur_token as required by _cpp_lex_direct. */
319 pfile->cur_token = _cpp_temp_token (pfile);
Richard Hendersonbc4071d2006-01-04 08:33:38 -0800320 _cpp_push_token_context (pfile, NULL, _cpp_lex_direct (pfile), 1);
Neil Booth278c4662002-06-19 05:40:08 +0000321 if (pfile->buffer->cur != pfile->buffer->rlimit)
John David Anglin0527bc42003-11-01 22:56:54 +0000322 cpp_error (pfile, CPP_DL_ICE, "invalid built-in macro \"%s\"",
Neil Booth278c4662002-06-19 05:40:08 +0000323 NODE_NAME (node));
324 _cpp_pop_buffer (pfile);
325
Neil Booth644edda2001-10-02 12:57:24 +0000326 return 1;
Neil Booth93c803682000-10-28 17:59:06 +0000327}
328
Neil Boothd15a58c2002-01-03 18:32:55 +0000329/* Copies SRC, of length LEN, to DEST, adding backslashes before all
Andrew Pinski651ed942005-11-04 00:23:01 +0000330 backslashes and double quotes. DEST must be of sufficient size.
331 Returns a pointer to the end of the string. */
Neil Booth562a5c22002-04-21 18:46:42 +0000332uchar *
Zack Weinberg6cf87ca2003-06-17 06:17:44 +0000333cpp_quote_string (uchar *dest, const uchar *src, unsigned int len)
Neil Booth93c803682000-10-28 17:59:06 +0000334{
335 while (len--)
336 {
Neil Booth562a5c22002-04-21 18:46:42 +0000337 uchar c = *src++;
Neil Booth93c803682000-10-28 17:59:06 +0000338
339 if (c == '\\' || c == '"')
340 {
341 *dest++ = '\\';
342 *dest++ = c;
343 }
344 else
Andrew Pinski651ed942005-11-04 00:23:01 +0000345 *dest++ = c;
Neil Booth93c803682000-10-28 17:59:06 +0000346 }
347
348 return dest;
349}
350
Neil Boothd15a58c2002-01-03 18:32:55 +0000351/* Convert a token sequence ARG to a single string token according to
352 the rules of the ISO C #-operator. */
Neil Booth4ed5bcf2001-09-24 22:53:12 +0000353static const cpp_token *
Zack Weinberg6cf87ca2003-06-17 06:17:44 +0000354stringify_arg (cpp_reader *pfile, macro_arg *arg)
Neil Booth93c803682000-10-28 17:59:06 +0000355{
Neil Booth6338b352003-04-23 22:44:06 +0000356 unsigned char *dest;
Neil Boothece54d52001-09-28 09:40:22 +0000357 unsigned int i, escape_it, backslash_count = 0;
Neil Booth4ed5bcf2001-09-24 22:53:12 +0000358 const cpp_token *source = NULL;
Neil Boothece54d52001-09-28 09:40:22 +0000359 size_t len;
Neil Booth93c803682000-10-28 17:59:06 +0000360
Neil Booth6338b352003-04-23 22:44:06 +0000361 if (BUFF_ROOM (pfile->u_buff) < 3)
362 _cpp_extend_buff (pfile, &pfile->u_buff, 3);
363 dest = BUFF_FRONT (pfile->u_buff);
364 *dest++ = '"';
365
Neil Booth93c803682000-10-28 17:59:06 +0000366 /* Loop, reading in the argument's tokens. */
367 for (i = 0; i < arg->count; i++)
368 {
Neil Booth4ed5bcf2001-09-24 22:53:12 +0000369 const cpp_token *token = arg->first[i];
Neil Booth4ed5bcf2001-09-24 22:53:12 +0000370
371 if (token->type == CPP_PADDING)
372 {
373 if (source == NULL)
374 source = token->val.source;
375 continue;
376 }
Neil Booth93c803682000-10-28 17:59:06 +0000377
Kris Van Heesb6baa672008-04-18 13:58:08 +0000378 escape_it = (token->type == CPP_STRING || token->type == CPP_CHAR
379 || token->type == CPP_WSTRING || token->type == CPP_STRING
380 || token->type == CPP_STRING32 || token->type == CPP_CHAR32
381 || token->type == CPP_STRING16 || token->type == CPP_CHAR16);
Neil Booth93c803682000-10-28 17:59:06 +0000382
Neil Boothece54d52001-09-28 09:40:22 +0000383 /* Room for each char being written in octal, initial space and
Neil Booth6338b352003-04-23 22:44:06 +0000384 final quote and NUL. */
Neil Booth4ed5bcf2001-09-24 22:53:12 +0000385 len = cpp_token_len (token);
Neil Booth93c803682000-10-28 17:59:06 +0000386 if (escape_it)
Neil Booth93c803682000-10-28 17:59:06 +0000387 len *= 4;
Neil Booth6338b352003-04-23 22:44:06 +0000388 len += 3;
Neil Booth93c803682000-10-28 17:59:06 +0000389
Neil Boothece54d52001-09-28 09:40:22 +0000390 if ((size_t) (BUFF_LIMIT (pfile->u_buff) - dest) < len)
Neil Booth93c803682000-10-28 17:59:06 +0000391 {
Neil Boothece54d52001-09-28 09:40:22 +0000392 size_t len_so_far = dest - BUFF_FRONT (pfile->u_buff);
Neil Booth8c3b2692001-09-30 10:03:11 +0000393 _cpp_extend_buff (pfile, &pfile->u_buff, len);
Neil Boothece54d52001-09-28 09:40:22 +0000394 dest = BUFF_FRONT (pfile->u_buff) + len_so_far;
Neil Booth93c803682000-10-28 17:59:06 +0000395 }
396
Neil Booth4ed5bcf2001-09-24 22:53:12 +0000397 /* Leading white space? */
Neil Booth6338b352003-04-23 22:44:06 +0000398 if (dest - 1 != BUFF_FRONT (pfile->u_buff))
Neil Booth4ed5bcf2001-09-24 22:53:12 +0000399 {
400 if (source == NULL)
401 source = token;
402 if (source->flags & PREV_WHITE)
403 *dest++ = ' ';
404 }
405 source = NULL;
Neil Booth93c803682000-10-28 17:59:06 +0000406
407 if (escape_it)
408 {
Neil Boothece54d52001-09-28 09:40:22 +0000409 _cpp_buff *buff = _cpp_get_buff (pfile, len);
410 unsigned char *buf = BUFF_FRONT (buff);
Geoffrey Keating47e20492005-03-12 10:44:06 +0000411 len = cpp_spell_token (pfile, token, buf, true) - buf;
Zack Weinbergdcc229e2002-03-14 18:17:18 +0000412 dest = cpp_quote_string (dest, buf, len);
Neil Boothece54d52001-09-28 09:40:22 +0000413 _cpp_release_buff (pfile, buff);
Neil Booth93c803682000-10-28 17:59:06 +0000414 }
415 else
Geoffrey Keating47e20492005-03-12 10:44:06 +0000416 dest = cpp_spell_token (pfile, token, dest, true);
Neil Booth93c803682000-10-28 17:59:06 +0000417
Neil Booth10676942003-04-22 19:28:00 +0000418 if (token->type == CPP_OTHER && token->val.str.text[0] == '\\')
Neil Booth93c803682000-10-28 17:59:06 +0000419 backslash_count++;
420 else
421 backslash_count = 0;
422 }
423
424 /* Ignore the final \ of invalid string literals. */
425 if (backslash_count & 1)
426 {
John David Anglin0527bc42003-11-01 22:56:54 +0000427 cpp_error (pfile, CPP_DL_WARNING,
Neil Boothebef4e82002-04-14 18:42:47 +0000428 "invalid string literal, ignoring final '\\'");
Neil Boothece54d52001-09-28 09:40:22 +0000429 dest--;
Neil Booth93c803682000-10-28 17:59:06 +0000430 }
431
Neil Booth4ed5bcf2001-09-24 22:53:12 +0000432 /* Commit the memory, including NUL, and return the token. */
Neil Booth6338b352003-04-23 22:44:06 +0000433 *dest++ = '"';
Neil Boothece54d52001-09-28 09:40:22 +0000434 len = dest - BUFF_FRONT (pfile->u_buff);
435 BUFF_FRONT (pfile->u_buff) = dest + 1;
436 return new_string_token (pfile, dest - len, len);
Neil Booth93c803682000-10-28 17:59:06 +0000437}
438
Kazu Hiratada7d8302002-09-22 02:03:17 +0000439/* Try to paste two tokens. On success, return nonzero. In any
Neil Boothc9e7a602001-09-27 12:59:38 +0000440 case, PLHS is updated to point to the pasted token, which is
441 guaranteed to not have the PASTE_LEFT flag set. */
442static bool
Zack Weinberg6cf87ca2003-06-17 06:17:44 +0000443paste_tokens (cpp_reader *pfile, const cpp_token **plhs, const cpp_token *rhs)
Neil Boothd63eefb2000-11-20 23:59:26 +0000444{
Jakub Jelinekde000d22006-10-12 11:25:59 +0200445 unsigned char *buf, *end, *lhsend;
Tom Tromeyfca35e12007-05-02 19:33:44 +0000446 cpp_token *lhs;
Neil Boothc9e7a602001-09-27 12:59:38 +0000447 unsigned int len;
Neil Boothd63eefb2000-11-20 23:59:26 +0000448
Tom Tromeyfca35e12007-05-02 19:33:44 +0000449 len = cpp_token_len (*plhs) + cpp_token_len (rhs) + 1;
Gabriel Dos Reisc3f829c2005-05-28 15:52:48 +0000450 buf = (unsigned char *) alloca (len);
Tom Tromeyfca35e12007-05-02 19:33:44 +0000451 end = lhsend = cpp_spell_token (pfile, *plhs, buf, false);
Neil Boothd63eefb2000-11-20 23:59:26 +0000452
Neil Boothc9e7a602001-09-27 12:59:38 +0000453 /* Avoid comment headers, since they are still processed in stage 3.
454 It is simpler to insert a space here, rather than modifying the
455 lexer to ignore comments in some circumstances. Simply returning
456 false doesn't work, since we want to clear the PASTE_LEFT flag. */
Tom Tromeyfca35e12007-05-02 19:33:44 +0000457 if ((*plhs)->type == CPP_DIV && rhs->type != CPP_EQ)
Neil Boothc9e7a602001-09-27 12:59:38 +0000458 *end++ = ' ';
Tom Tromeyf373b442007-11-01 18:20:48 +0000459 /* In one obscure case we might see padding here. */
460 if (rhs->type != CPP_PADDING)
461 end = cpp_spell_token (pfile, rhs, end, false);
Neil Booth26aea072003-04-19 00:22:51 +0000462 *end = '\n';
Neil Boothd63eefb2000-11-20 23:59:26 +0000463
Per Bothner40de9f72003-10-02 07:30:34 +0000464 cpp_push_buffer (pfile, buf, end - buf, /* from_stage3 */ true);
Neil Booth26aea072003-04-19 00:22:51 +0000465 _cpp_clean_line (pfile);
Neil Boothd63eefb2000-11-20 23:59:26 +0000466
Neil Boothc9e7a602001-09-27 12:59:38 +0000467 /* Set pfile->cur_token as required by _cpp_lex_direct. */
468 pfile->cur_token = _cpp_temp_token (pfile);
Tom Tromeyfca35e12007-05-02 19:33:44 +0000469 lhs = _cpp_lex_direct (pfile);
Jakub Jelinekde000d22006-10-12 11:25:59 +0200470 if (pfile->buffer->cur != pfile->buffer->rlimit)
471 {
Tom Tromeyfca35e12007-05-02 19:33:44 +0000472 source_location saved_loc = lhs->src_loc;
473
Jakub Jelinekde000d22006-10-12 11:25:59 +0200474 _cpp_pop_buffer (pfile);
475 _cpp_backup_tokens (pfile, 1);
476 *lhsend = '\0';
Neil Boothd63eefb2000-11-20 23:59:26 +0000477
Tom Tromeyfca35e12007-05-02 19:33:44 +0000478 /* We have to remove the PASTE_LEFT flag from the old lhs, but
479 we want to keep the new location. */
480 *lhs = **plhs;
481 *plhs = lhs;
482 lhs->src_loc = saved_loc;
483 lhs->flags &= ~PASTE_LEFT;
484
Jakub Jelinekde000d22006-10-12 11:25:59 +0200485 /* Mandatory error for all apart from assembler. */
486 if (CPP_OPTION (pfile, lang) != CLK_ASM)
487 cpp_error (pfile, CPP_DL_ERROR,
488 "pasting \"%s\" and \"%s\" does not give a valid preprocessing token",
489 buf, cpp_token_as_text (pfile, rhs));
490 return false;
491 }
492
Tom Tromeyfca35e12007-05-02 19:33:44 +0000493 *plhs = lhs;
Jakub Jelinekde000d22006-10-12 11:25:59 +0200494 _cpp_pop_buffer (pfile);
495 return true;
Neil Boothd63eefb2000-11-20 23:59:26 +0000496}
497
Neil Boothd15a58c2002-01-03 18:32:55 +0000498/* Handles an arbitrarily long sequence of ## operators, with initial
499 operand LHS. This implementation is left-associative,
500 non-recursive, and finishes a paste before handling succeeding
501 ones. If a paste fails, we back up to the RHS of the failing ##
502 operator before pushing the context containing the result of prior
503 successful pastes, with the effect that the RHS appears in the
504 output stream after the pasted LHS normally. */
Neil Booth93c803682000-10-28 17:59:06 +0000505static void
Zack Weinberg6cf87ca2003-06-17 06:17:44 +0000506paste_all_tokens (cpp_reader *pfile, const cpp_token *lhs)
Neil Booth93c803682000-10-28 17:59:06 +0000507{
Neil Booth4ed5bcf2001-09-24 22:53:12 +0000508 const cpp_token *rhs;
509 cpp_context *context = pfile->context;
510
Neil Booth93c803682000-10-28 17:59:06 +0000511 do
512 {
513 /* Take the token directly from the current context. We can do
514 this, because we are in the replacement list of either an
515 object-like macro, or a function-like macro with arguments
516 inserted. In either case, the constraints to #define
Neil Boothd63eefb2000-11-20 23:59:26 +0000517 guarantee we have at least one more token. */
Neil Booth4ed5bcf2001-09-24 22:53:12 +0000518 if (context->direct_p)
Neil Booth82eda772002-06-04 13:07:06 +0000519 rhs = FIRST (context).token++;
Neil Booth4ed5bcf2001-09-24 22:53:12 +0000520 else
Neil Booth82eda772002-06-04 13:07:06 +0000521 rhs = *FIRST (context).ptoken++;
Neil Booth4ed5bcf2001-09-24 22:53:12 +0000522
523 if (rhs->type == CPP_PADDING)
Tom Tromeyf373b442007-11-01 18:20:48 +0000524 {
525 if (rhs->flags & PASTE_LEFT)
526 abort ();
527 }
Neil Boothc9e7a602001-09-27 12:59:38 +0000528 if (!paste_tokens (pfile, &lhs, rhs))
Jakub Jelinekde000d22006-10-12 11:25:59 +0200529 break;
Neil Booth93c803682000-10-28 17:59:06 +0000530 }
531 while (rhs->flags & PASTE_LEFT);
532
Neil Boothc9e7a602001-09-27 12:59:38 +0000533 /* Put the resulting token in its own context. */
Richard Hendersonbc4071d2006-01-04 08:33:38 -0800534 _cpp_push_token_context (pfile, NULL, lhs, 1);
Neil Booth93c803682000-10-28 17:59:06 +0000535}
536
Neil Booth1ce676a2002-06-09 20:04:17 +0000537/* Returns TRUE if the number of arguments ARGC supplied in an
538 invocation of the MACRO referenced by NODE is valid. An empty
539 invocation to a macro with no parameters should pass ARGC as zero.
540
541 Note that MACRO cannot necessarily be deduced from NODE, in case
542 NODE was redefined whilst collecting arguments. */
543bool
Zack Weinberg6cf87ca2003-06-17 06:17:44 +0000544_cpp_arguments_ok (cpp_reader *pfile, cpp_macro *macro, const cpp_hashnode *node, unsigned int argc)
Neil Booth1ce676a2002-06-09 20:04:17 +0000545{
546 if (argc == macro->paramc)
547 return true;
548
549 if (argc < macro->paramc)
550 {
551 /* As an extension, a rest argument is allowed to not appear in
552 the invocation at all.
553 e.g. #define debug(format, args...) something
554 debug("string");
555
556 This is exactly the same as if there had been an empty rest
557 argument - debug("string", ). */
558
559 if (argc + 1 == macro->paramc && macro->variadic)
560 {
561 if (CPP_PEDANTIC (pfile) && ! macro->syshdr)
John David Anglin0527bc42003-11-01 22:56:54 +0000562 cpp_error (pfile, CPP_DL_PEDWARN,
Neil Booth1ce676a2002-06-09 20:04:17 +0000563 "ISO C99 requires rest arguments to be used");
564 return true;
565 }
566
John David Anglin0527bc42003-11-01 22:56:54 +0000567 cpp_error (pfile, CPP_DL_ERROR,
Neil Booth1ce676a2002-06-09 20:04:17 +0000568 "macro \"%s\" requires %u arguments, but only %u given",
569 NODE_NAME (node), macro->paramc, argc);
570 }
571 else
John David Anglin0527bc42003-11-01 22:56:54 +0000572 cpp_error (pfile, CPP_DL_ERROR,
Neil Booth1ce676a2002-06-09 20:04:17 +0000573 "macro \"%s\" passed %u arguments, but takes just %u",
574 NODE_NAME (node), argc, macro->paramc);
575
576 return false;
577}
578
Neil Boothd15a58c2002-01-03 18:32:55 +0000579/* Reads and returns the arguments to a function-like macro
580 invocation. Assumes the opening parenthesis has been processed.
581 If there is an error, emits an appropriate diagnostic and returns
582 NULL. Each argument is terminated by a CPP_EOF token, for the
Jakub Jelinek765d6002008-01-25 10:01:27 +0100583 future benefit of expand_arg(). If there are any deferred
584 #pragma directives among macro arguments, store pointers to the
585 CPP_PRAGMA ... CPP_PRAGMA_EOL tokens into *PRAGMA_BUFF buffer. */
Neil Boothb8af0ca2001-09-26 17:52:50 +0000586static _cpp_buff *
Jakub Jelinek765d6002008-01-25 10:01:27 +0100587collect_args (cpp_reader *pfile, const cpp_hashnode *node,
588 _cpp_buff **pragma_buff)
Neil Booth93c803682000-10-28 17:59:06 +0000589{
Neil Boothb8af0ca2001-09-26 17:52:50 +0000590 _cpp_buff *buff, *base_buff;
591 cpp_macro *macro;
592 macro_arg *args, *arg;
593 const cpp_token *token;
594 unsigned int argc;
Neil Booth93c803682000-10-28 17:59:06 +0000595
Neil Boothb8af0ca2001-09-26 17:52:50 +0000596 macro = node->value.macro;
597 if (macro->paramc)
598 argc = macro->paramc;
599 else
600 argc = 1;
601 buff = _cpp_get_buff (pfile, argc * (50 * sizeof (cpp_token *)
602 + sizeof (macro_arg)));
603 base_buff = buff;
604 args = (macro_arg *) buff->base;
605 memset (args, 0, argc * sizeof (macro_arg));
Neil Boothece54d52001-09-28 09:40:22 +0000606 buff->cur = (unsigned char *) &args[argc];
Neil Boothb8af0ca2001-09-26 17:52:50 +0000607 arg = args, argc = 0;
Neil Booth93c803682000-10-28 17:59:06 +0000608
Neil Boothb8af0ca2001-09-26 17:52:50 +0000609 /* Collect the tokens making up each argument. We don't yet know
610 how many arguments have been supplied, whether too many or too
611 few. Hence the slightly bizarre usage of "argc" and "arg". */
612 do
Neil Booth93c803682000-10-28 17:59:06 +0000613 {
Neil Boothb8af0ca2001-09-26 17:52:50 +0000614 unsigned int paren_depth = 0;
615 unsigned int ntokens = 0;
616
Neil Booth93c803682000-10-28 17:59:06 +0000617 argc++;
Neil Boothb8af0ca2001-09-26 17:52:50 +0000618 arg->first = (const cpp_token **) buff->cur;
Neil Booth93c803682000-10-28 17:59:06 +0000619
Neil Boothb8af0ca2001-09-26 17:52:50 +0000620 for (;;)
621 {
622 /* Require space for 2 new tokens (including a CPP_EOF). */
Neil Boothece54d52001-09-28 09:40:22 +0000623 if ((unsigned char *) &arg->first[ntokens + 2] > buff->limit)
Neil Boothb8af0ca2001-09-26 17:52:50 +0000624 {
Neil Booth8c3b2692001-09-30 10:03:11 +0000625 buff = _cpp_append_extend_buff (pfile, buff,
626 1000 * sizeof (cpp_token *));
Neil Boothb8af0ca2001-09-26 17:52:50 +0000627 arg->first = (const cpp_token **) buff->cur;
628 }
Neil Booth93c803682000-10-28 17:59:06 +0000629
Neil Boothb8af0ca2001-09-26 17:52:50 +0000630 token = cpp_get_token (pfile);
631
632 if (token->type == CPP_PADDING)
633 {
634 /* Drop leading padding. */
635 if (ntokens == 0)
636 continue;
637 }
638 else if (token->type == CPP_OPEN_PAREN)
639 paren_depth++;
640 else if (token->type == CPP_CLOSE_PAREN)
641 {
642 if (paren_depth-- == 0)
643 break;
644 }
645 else if (token->type == CPP_COMMA)
646 {
647 /* A comma does not terminate an argument within
648 parentheses or as part of a variable argument. */
649 if (paren_depth == 0
650 && ! (macro->variadic && argc == macro->paramc))
651 break;
652 }
653 else if (token->type == CPP_EOF
654 || (token->type == CPP_HASH && token->flags & BOL))
655 break;
Jakub Jelinek765d6002008-01-25 10:01:27 +0100656 else if (token->type == CPP_PRAGMA)
657 {
658 cpp_token *newtok = _cpp_temp_token (pfile);
659
660 /* CPP_PRAGMA token lives in directive_result, which will
661 be overwritten on the next directive. */
662 *newtok = *token;
663 token = newtok;
664 do
665 {
666 if (*pragma_buff == NULL
667 || BUFF_ROOM (*pragma_buff) < sizeof (cpp_token *))
668 {
669 _cpp_buff *next;
670 if (*pragma_buff == NULL)
671 *pragma_buff
672 = _cpp_get_buff (pfile, 32 * sizeof (cpp_token *));
673 else
674 {
675 next = *pragma_buff;
676 *pragma_buff
677 = _cpp_get_buff (pfile,
678 (BUFF_FRONT (*pragma_buff)
679 - (*pragma_buff)->base) * 2);
680 (*pragma_buff)->next = next;
681 }
682 }
683 *(const cpp_token **) BUFF_FRONT (*pragma_buff) = token;
684 BUFF_FRONT (*pragma_buff) += sizeof (cpp_token *);
685 if (token->type == CPP_PRAGMA_EOL)
686 break;
687 token = cpp_get_token (pfile);
688 }
689 while (token->type != CPP_EOF);
690
691 /* In deferred pragmas parsing_args and prevent_expansion
692 had been changed, reset it. */
693 pfile->state.parsing_args = 2;
694 pfile->state.prevent_expansion = 1;
695
696 if (token->type == CPP_EOF)
697 break;
698 else
699 continue;
700 }
Neil Boothb8af0ca2001-09-26 17:52:50 +0000701
702 arg->first[ntokens++] = token;
703 }
704
705 /* Drop trailing padding. */
706 while (ntokens > 0 && arg->first[ntokens - 1]->type == CPP_PADDING)
707 ntokens--;
708
709 arg->count = ntokens;
710 arg->first[ntokens] = &pfile->eof;
711
712 /* Terminate the argument. Excess arguments loop back and
713 overwrite the final legitimate argument, before failing. */
714 if (argc <= macro->paramc)
715 {
Neil Boothece54d52001-09-28 09:40:22 +0000716 buff->cur = (unsigned char *) &arg->first[ntokens + 1];
Neil Boothb8af0ca2001-09-26 17:52:50 +0000717 if (argc != macro->paramc)
718 arg++;
719 }
Neil Booth93c803682000-10-28 17:59:06 +0000720 }
Neil Boothe808ec92002-02-27 07:24:53 +0000721 while (token->type != CPP_CLOSE_PAREN && token->type != CPP_EOF);
Neil Booth93c803682000-10-28 17:59:06 +0000722
Neil Boothe808ec92002-02-27 07:24:53 +0000723 if (token->type == CPP_EOF)
Neil Booth93c803682000-10-28 17:59:06 +0000724 {
Neil Boothece54d52001-09-28 09:40:22 +0000725 /* We still need the CPP_EOF to end directives, and to end
726 pre-expansion of a macro argument. Step back is not
727 unconditional, since we don't want to return a CPP_EOF to our
728 callers at the end of an -include-d file. */
Neil Boothe808ec92002-02-27 07:24:53 +0000729 if (pfile->context->prev || pfile->state.in_directive)
Neil Boothb8af0ca2001-09-26 17:52:50 +0000730 _cpp_backup_tokens (pfile, 1);
John David Anglin0527bc42003-11-01 22:56:54 +0000731 cpp_error (pfile, CPP_DL_ERROR,
Neil Boothebef4e82002-04-14 18:42:47 +0000732 "unterminated argument list invoking macro \"%s\"",
Neil Bootha28c50352001-05-16 22:02:09 +0000733 NODE_NAME (node));
Neil Booth93c803682000-10-28 17:59:06 +0000734 }
Neil Booth1ce676a2002-06-09 20:04:17 +0000735 else
Neil Booth93c803682000-10-28 17:59:06 +0000736 {
Neil Booth1ce676a2002-06-09 20:04:17 +0000737 /* A single empty argument is counted as no argument. */
738 if (argc == 1 && macro->paramc == 0 && args[0].count == 0)
739 argc = 0;
740 if (_cpp_arguments_ok (pfile, macro, node, argc))
Neil Booth58551c22002-08-06 20:35:46 +0000741 {
742 /* GCC has special semantics for , ## b where b is a varargs
743 parameter: we remove the comma if b was omitted entirely.
744 If b was merely an empty argument, the comma is retained.
745 If the macro takes just one (varargs) parameter, then we
746 retain the comma only if we are standards conforming.
747
748 If FIRST is NULL replace_args () swallows the comma. */
749 if (macro->variadic && (argc < macro->paramc
750 || (argc == 1 && args[0].count == 0
751 && !CPP_OPTION (pfile, std))))
752 args[macro->paramc - 1].first = NULL;
753 return base_buff;
754 }
Neil Booth93c803682000-10-28 17:59:06 +0000755 }
756
Neil Booth1ce676a2002-06-09 20:04:17 +0000757 /* An error occurred. */
Neil Boothb8af0ca2001-09-26 17:52:50 +0000758 _cpp_release_buff (pfile, base_buff);
759 return NULL;
Neil Booth93c803682000-10-28 17:59:06 +0000760}
761
Neil Boothd6da8362001-10-08 06:15:14 +0000762/* Search for an opening parenthesis to the macro of NODE, in such a
763 way that, if none is found, we don't lose the information in any
764 intervening padding tokens. If we find the parenthesis, collect
Jakub Jelinek765d6002008-01-25 10:01:27 +0100765 the arguments and return the buffer containing them. PRAGMA_BUFF
766 argument is the same as in collect_args. */
Neil Boothd6da8362001-10-08 06:15:14 +0000767static _cpp_buff *
Jakub Jelinek765d6002008-01-25 10:01:27 +0100768funlike_invocation_p (cpp_reader *pfile, cpp_hashnode *node,
769 _cpp_buff **pragma_buff)
Neil Booth93c803682000-10-28 17:59:06 +0000770{
Neil Boothd6da8362001-10-08 06:15:14 +0000771 const cpp_token *token, *padding = NULL;
Neil Booth93c803682000-10-28 17:59:06 +0000772
Neil Boothd6da8362001-10-08 06:15:14 +0000773 for (;;)
Neil Boothbdcbe492001-09-13 20:05:17 +0000774 {
Neil Boothd6da8362001-10-08 06:15:14 +0000775 token = cpp_get_token (pfile);
776 if (token->type != CPP_PADDING)
777 break;
778 if (padding == NULL
779 || (!(padding->flags & PREV_WHITE) && token->val.source == NULL))
780 padding = token;
Neil Boothbdcbe492001-09-13 20:05:17 +0000781 }
Neil Booth93c803682000-10-28 17:59:06 +0000782
Neil Boothd6da8362001-10-08 06:15:14 +0000783 if (token->type == CPP_OPEN_PAREN)
Neil Booth93c803682000-10-28 17:59:06 +0000784 {
Neil Boothd6da8362001-10-08 06:15:14 +0000785 pfile->state.parsing_args = 2;
Jakub Jelinek765d6002008-01-25 10:01:27 +0100786 return collect_args (pfile, node, pragma_buff);
Neil Booth93c803682000-10-28 17:59:06 +0000787 }
788
Neil Booth9ac3b1b2002-04-21 16:17:55 +0000789 /* CPP_EOF can be the end of macro arguments, or the end of the
790 file. We mustn't back up over the latter. Ugh. */
791 if (token->type != CPP_EOF || token == &pfile->eof)
792 {
793 /* Back up. We may have skipped padding, in which case backing
794 up more than one token when expanding macros is in general
795 too difficult. We re-insert it in its own context. */
796 _cpp_backup_tokens (pfile, 1);
797 if (padding)
Richard Hendersonbc4071d2006-01-04 08:33:38 -0800798 _cpp_push_token_context (pfile, NULL, padding, 1);
Neil Booth9ac3b1b2002-04-21 16:17:55 +0000799 }
Neil Boothd6da8362001-10-08 06:15:14 +0000800
801 return NULL;
Neil Booth93c803682000-10-28 17:59:06 +0000802}
803
Neil Boothd15a58c2002-01-03 18:32:55 +0000804/* Push the context of a macro with hash entry NODE onto the context
805 stack. If we can successfully expand the macro, we push a context
806 containing its yet-to-be-rescanned replacement list and return one.
Jakub Jelinek765d6002008-01-25 10:01:27 +0100807 If there were additionally any unexpanded deferred #pragma directives
808 among macro arguments, push another context containing the
809 pragma tokens before the yet-to-be-rescanned replacement list
810 and return two. Otherwise, we don't push a context and return zero. */
Neil Booth93c803682000-10-28 17:59:06 +0000811static int
Jakub Jelinek765d6002008-01-25 10:01:27 +0100812enter_macro_context (cpp_reader *pfile, cpp_hashnode *node,
813 const cpp_token *result)
Neil Booth93c803682000-10-28 17:59:06 +0000814{
Neil Boothd15a58c2002-01-03 18:32:55 +0000815 /* The presence of a macro invalidates a file's controlling macro. */
Neil Booth644edda2001-10-02 12:57:24 +0000816 pfile->mi_valid = false;
817
Neil Booth36207112002-05-24 19:26:30 +0000818 pfile->state.angled_headers = false;
819
Joseph Myers93d45d92008-04-02 20:42:53 +0100820 if ((node->flags & NODE_BUILTIN) && !(node->flags & NODE_USED))
821 {
822 node->flags |= NODE_USED;
823 if (pfile->cb.used_define)
824 pfile->cb.used_define (pfile, pfile->directive_line, node);
825 }
826
Neil Boothd15a58c2002-01-03 18:32:55 +0000827 /* Handle standard macros. */
Neil Booth644edda2001-10-02 12:57:24 +0000828 if (! (node->flags & NODE_BUILTIN))
Neil Booth93c803682000-10-28 17:59:06 +0000829 {
Neil Booth4ed5bcf2001-09-24 22:53:12 +0000830 cpp_macro *macro = node->value.macro;
Jakub Jelinek765d6002008-01-25 10:01:27 +0100831 _cpp_buff *pragma_buff = NULL;
Neil Booth4ed5bcf2001-09-24 22:53:12 +0000832
Neil Boothd6da8362001-10-08 06:15:14 +0000833 if (macro->fun_like)
834 {
835 _cpp_buff *buff;
836
837 pfile->state.prevent_expansion++;
838 pfile->keep_tokens++;
839 pfile->state.parsing_args = 1;
Jakub Jelinek765d6002008-01-25 10:01:27 +0100840 buff = funlike_invocation_p (pfile, node, &pragma_buff);
Neil Boothd6da8362001-10-08 06:15:14 +0000841 pfile->state.parsing_args = 0;
842 pfile->keep_tokens--;
843 pfile->state.prevent_expansion--;
844
845 if (buff == NULL)
846 {
847 if (CPP_WTRADITIONAL (pfile) && ! node->value.macro->syshdr)
John David Anglin0527bc42003-11-01 22:56:54 +0000848 cpp_error (pfile, CPP_DL_WARNING,
Neil Boothd6da8362001-10-08 06:15:14 +0000849 "function-like macro \"%s\" must be used with arguments in traditional C",
Neil Boothebef4e82002-04-14 18:42:47 +0000850 NODE_NAME (node));
Neil Boothd6da8362001-10-08 06:15:14 +0000851
Jakub Jelinek765d6002008-01-25 10:01:27 +0100852 if (pragma_buff)
853 _cpp_release_buff (pfile, pragma_buff);
854
Neil Boothd6da8362001-10-08 06:15:14 +0000855 return 0;
856 }
857
Neil Boothe808ec92002-02-27 07:24:53 +0000858 if (macro->paramc > 0)
859 replace_args (pfile, node, macro, (macro_arg *) buff->base);
Neil Boothd6da8362001-10-08 06:15:14 +0000860 _cpp_release_buff (pfile, buff);
861 }
Neil Booth4ed5bcf2001-09-24 22:53:12 +0000862
863 /* Disable the macro within its expansion. */
Neil Booth644edda2001-10-02 12:57:24 +0000864 node->flags |= NODE_DISABLED;
Neil Booth4ed5bcf2001-09-24 22:53:12 +0000865
Joseph Myers93d45d92008-04-02 20:42:53 +0100866 if (!(node->flags & NODE_USED))
867 {
868 node->flags |= NODE_USED;
869 if (pfile->cb.used_define)
870 pfile->cb.used_define (pfile, pfile->directive_line, node);
871 }
872
Neil Bootha69cbaa2002-07-23 22:57:49 +0000873 macro->used = 1;
874
Neil Booth4ed5bcf2001-09-24 22:53:12 +0000875 if (macro->paramc == 0)
Richard Hendersonbc4071d2006-01-04 08:33:38 -0800876 _cpp_push_token_context (pfile, node, macro->exp.tokens, macro->count);
Neil Booth644edda2001-10-02 12:57:24 +0000877
Jakub Jelinek765d6002008-01-25 10:01:27 +0100878 if (pragma_buff)
879 {
880 if (!pfile->state.in_directive)
881 _cpp_push_token_context (pfile, NULL,
882 padding_token (pfile, result), 1);
883 do
884 {
885 _cpp_buff *tail = pragma_buff->next;
886 pragma_buff->next = NULL;
887 push_ptoken_context (pfile, NULL, pragma_buff,
888 (const cpp_token **) pragma_buff->base,
889 ((const cpp_token **) BUFF_FRONT (pragma_buff)
890 - (const cpp_token **) pragma_buff->base));
891 pragma_buff = tail;
892 }
893 while (pragma_buff != NULL);
894 return 2;
895 }
896
Neil Booth644edda2001-10-02 12:57:24 +0000897 return 1;
Neil Booth93c803682000-10-28 17:59:06 +0000898 }
Neil Booth644edda2001-10-02 12:57:24 +0000899
Neil Boothd15a58c2002-01-03 18:32:55 +0000900 /* Handle built-in macros and the _Pragma operator. */
Neil Booth644edda2001-10-02 12:57:24 +0000901 return builtin_macro (pfile, node);
Zack Weinberg711b8822000-07-18 00:59:49 +0000902}
903
Neil Boothd15a58c2002-01-03 18:32:55 +0000904/* Replace the parameters in a function-like macro of NODE with the
905 actual ARGS, and place the result in a newly pushed token context.
906 Expand each argument before replacing, unless it is operated upon
907 by the # or ## operators. */
Neil Booth93c803682000-10-28 17:59:06 +0000908static void
Zack Weinberg6cf87ca2003-06-17 06:17:44 +0000909replace_args (cpp_reader *pfile, cpp_hashnode *node, cpp_macro *macro, macro_arg *args)
Neil Booth93c803682000-10-28 17:59:06 +0000910{
911 unsigned int i, total;
912 const cpp_token *src, *limit;
Neil Booth4ed5bcf2001-09-24 22:53:12 +0000913 const cpp_token **dest, **first;
Neil Booth93c803682000-10-28 17:59:06 +0000914 macro_arg *arg;
Neil Booth1e013d22001-09-26 21:44:35 +0000915 _cpp_buff *buff;
Neil Booth93c803682000-10-28 17:59:06 +0000916
Neil Booth93c803682000-10-28 17:59:06 +0000917 /* First, fully macro-expand arguments, calculating the number of
Neil Booth1e013d22001-09-26 21:44:35 +0000918 tokens in the final expansion as we go. The ordering of the if
919 statements below is subtle; we must handle stringification before
920 pasting. */
Neil Booth4ed5bcf2001-09-24 22:53:12 +0000921 total = macro->count;
Neil Booth601328b2002-05-16 05:53:24 +0000922 limit = macro->exp.tokens + macro->count;
Neil Booth4ed5bcf2001-09-24 22:53:12 +0000923
Neil Booth601328b2002-05-16 05:53:24 +0000924 for (src = macro->exp.tokens; src < limit; src++)
Neil Booth93c803682000-10-28 17:59:06 +0000925 if (src->type == CPP_MACRO_ARG)
926 {
Neil Booth4ed5bcf2001-09-24 22:53:12 +0000927 /* Leading and trailing padding tokens. */
928 total += 2;
929
Neil Booth93c803682000-10-28 17:59:06 +0000930 /* We have an argument. If it is not being stringified or
931 pasted it is macro-replaced before insertion. */
Neil Booth6c53ebf2000-11-06 18:43:32 +0000932 arg = &args[src->val.arg_no - 1];
Neil Booth4c2b6472000-11-11 13:19:01 +0000933
Neil Booth93c803682000-10-28 17:59:06 +0000934 if (src->flags & STRINGIFY_ARG)
935 {
936 if (!arg->stringified)
Neil Booth4ed5bcf2001-09-24 22:53:12 +0000937 arg->stringified = stringify_arg (pfile, arg);
Neil Booth93c803682000-10-28 17:59:06 +0000938 }
939 else if ((src->flags & PASTE_LEFT)
Neil Booth601328b2002-05-16 05:53:24 +0000940 || (src > macro->exp.tokens && (src[-1].flags & PASTE_LEFT)))
Neil Booth93c803682000-10-28 17:59:06 +0000941 total += arg->count - 1;
942 else
943 {
944 if (!arg->expanded)
Neil Booth4ed5bcf2001-09-24 22:53:12 +0000945 expand_arg (pfile, arg);
Neil Booth93c803682000-10-28 17:59:06 +0000946 total += arg->expanded_count - 1;
947 }
948 }
949
Neil Booth4ed5bcf2001-09-24 22:53:12 +0000950 /* Now allocate space for the expansion, copy the tokens and replace
951 the arguments. */
Neil Booth1e013d22001-09-26 21:44:35 +0000952 buff = _cpp_get_buff (pfile, total * sizeof (cpp_token *));
953 first = (const cpp_token **) buff->base;
Neil Booth4ed5bcf2001-09-24 22:53:12 +0000954 dest = first;
Neil Booth93c803682000-10-28 17:59:06 +0000955
Neil Booth601328b2002-05-16 05:53:24 +0000956 for (src = macro->exp.tokens; src < limit; src++)
Neil Booth4ed5bcf2001-09-24 22:53:12 +0000957 {
958 unsigned int count;
959 const cpp_token **from, **paste_flag;
Neil Booth93c803682000-10-28 17:59:06 +0000960
Neil Booth4ed5bcf2001-09-24 22:53:12 +0000961 if (src->type != CPP_MACRO_ARG)
962 {
963 *dest++ = src;
964 continue;
965 }
966
967 paste_flag = 0;
968 arg = &args[src->val.arg_no - 1];
969 if (src->flags & STRINGIFY_ARG)
970 count = 1, from = &arg->stringified;
971 else if (src->flags & PASTE_LEFT)
972 count = arg->count, from = arg->first;
Neil Booth601328b2002-05-16 05:53:24 +0000973 else if (src != macro->exp.tokens && (src[-1].flags & PASTE_LEFT))
Neil Booth4ed5bcf2001-09-24 22:53:12 +0000974 {
Neil Booth93c803682000-10-28 17:59:06 +0000975 count = arg->count, from = arg->first;
Neil Booth4ed5bcf2001-09-24 22:53:12 +0000976 if (dest != first)
977 {
Neil Booth4ed5bcf2001-09-24 22:53:12 +0000978 if (dest[-1]->type == CPP_COMMA
979 && macro->variadic
980 && src->val.arg_no == macro->paramc)
981 {
Neil Booth58551c22002-08-06 20:35:46 +0000982 /* Swallow a pasted comma if from == NULL, otherwise
983 drop the paste flag. */
984 if (from == NULL)
Neil Booth4ed5bcf2001-09-24 22:53:12 +0000985 dest--;
986 else
987 paste_flag = dest - 1;
988 }
989 /* Remove the paste flag if the RHS is a placemarker. */
990 else if (count == 0)
991 paste_flag = dest - 1;
992 }
993 }
994 else
995 count = arg->expanded_count, from = arg->expanded;
Neil Booth93c803682000-10-28 17:59:06 +0000996
Neil Booth4ed5bcf2001-09-24 22:53:12 +0000997 /* Padding on the left of an argument (unless RHS of ##). */
Zack Weinberga8d0dda2003-02-21 18:06:30 +0000998 if ((!pfile->state.in_directive || pfile->state.directive_wants_padding)
Neil Booth601328b2002-05-16 05:53:24 +0000999 && src != macro->exp.tokens && !(src[-1].flags & PASTE_LEFT))
Neil Booth4ed5bcf2001-09-24 22:53:12 +00001000 *dest++ = padding_token (pfile, src);
Neil Booth93c803682000-10-28 17:59:06 +00001001
Neil Booth4ed5bcf2001-09-24 22:53:12 +00001002 if (count)
1003 {
1004 memcpy (dest, from, count * sizeof (cpp_token *));
1005 dest += count;
Neil Booth93c803682000-10-28 17:59:06 +00001006
Neil Booth4ed5bcf2001-09-24 22:53:12 +00001007 /* With a non-empty argument on the LHS of ##, the last
1008 token should be flagged PASTE_LEFT. */
1009 if (src->flags & PASTE_LEFT)
1010 paste_flag = dest - 1;
1011 }
Neil Booth4c2b6472000-11-11 13:19:01 +00001012
Neil Booth4ed5bcf2001-09-24 22:53:12 +00001013 /* Avoid paste on RHS (even case count == 0). */
1014 if (!pfile->state.in_directive && !(src->flags & PASTE_LEFT))
1015 *dest++ = &pfile->avoid_paste;
Neil Booth26ec42e2001-01-28 11:22:23 +00001016
Neil Booth4ed5bcf2001-09-24 22:53:12 +00001017 /* Add a new paste flag, or remove an unwanted one. */
1018 if (paste_flag)
1019 {
1020 cpp_token *token = _cpp_temp_token (pfile);
1021 token->type = (*paste_flag)->type;
Jakub Jelinek73096712005-03-04 16:33:23 +01001022 token->val = (*paste_flag)->val;
Neil Booth4ed5bcf2001-09-24 22:53:12 +00001023 if (src->flags & PASTE_LEFT)
1024 token->flags = (*paste_flag)->flags | PASTE_LEFT;
1025 else
1026 token->flags = (*paste_flag)->flags & ~PASTE_LEFT;
1027 *paste_flag = token;
1028 }
1029 }
Neil Booth4c2b6472000-11-11 13:19:01 +00001030
Neil Booth93c803682000-10-28 17:59:06 +00001031 /* Free the expanded arguments. */
1032 for (i = 0; i < macro->paramc; i++)
Neil Booth4ed5bcf2001-09-24 22:53:12 +00001033 if (args[i].expanded)
1034 free (args[i].expanded);
1035
Neil Booth644edda2001-10-02 12:57:24 +00001036 push_ptoken_context (pfile, node, buff, first, dest - first);
Neil Booth93c803682000-10-28 17:59:06 +00001037}
1038
Neil Booth4ed5bcf2001-09-24 22:53:12 +00001039/* Return a special padding token, with padding inherited from SOURCE. */
1040static const cpp_token *
Zack Weinberg6cf87ca2003-06-17 06:17:44 +00001041padding_token (cpp_reader *pfile, const cpp_token *source)
Neil Booth4ed5bcf2001-09-24 22:53:12 +00001042{
1043 cpp_token *result = _cpp_temp_token (pfile);
1044
1045 result->type = CPP_PADDING;
Paolo Bonzinibe0f1e52005-02-14 08:52:24 +00001046
1047 /* Data in GCed data structures cannot be made const so far, so we
1048 need a cast here. */
1049 result->val.source = (cpp_token *) source;
Neil Booth4ed5bcf2001-09-24 22:53:12 +00001050 result->flags = 0;
1051 return result;
1052}
1053
Neil Boothd15a58c2002-01-03 18:32:55 +00001054/* Get a new uninitialized context. Create a new one if we cannot
1055 re-use an old one. */
Neil Booth4ed5bcf2001-09-24 22:53:12 +00001056static cpp_context *
Zack Weinberg6cf87ca2003-06-17 06:17:44 +00001057next_context (cpp_reader *pfile)
Neil Booth4ed5bcf2001-09-24 22:53:12 +00001058{
1059 cpp_context *result = pfile->context->next;
1060
1061 if (result == 0)
1062 {
Bernardo Innocenti72bb2c32004-07-24 20:04:42 +02001063 result = XNEW (cpp_context);
Neil Booth4ed5bcf2001-09-24 22:53:12 +00001064 result->prev = pfile->context;
1065 result->next = 0;
1066 pfile->context->next = result;
1067 }
1068
1069 pfile->context = result;
1070 return result;
1071}
1072
1073/* Push a list of pointers to tokens. */
1074static void
Zack Weinberg6cf87ca2003-06-17 06:17:44 +00001075push_ptoken_context (cpp_reader *pfile, cpp_hashnode *macro, _cpp_buff *buff,
1076 const cpp_token **first, unsigned int count)
Neil Booth93c803682000-10-28 17:59:06 +00001077{
1078 cpp_context *context = next_context (pfile);
Neil Booth93c803682000-10-28 17:59:06 +00001079
Neil Booth4ed5bcf2001-09-24 22:53:12 +00001080 context->direct_p = false;
1081 context->macro = macro;
Neil Booth1e013d22001-09-26 21:44:35 +00001082 context->buff = buff;
Neil Booth82eda772002-06-04 13:07:06 +00001083 FIRST (context).ptoken = first;
1084 LAST (context).ptoken = first + count;
Neil Booth4ed5bcf2001-09-24 22:53:12 +00001085}
1086
1087/* Push a list of tokens. */
Richard Hendersonbc4071d2006-01-04 08:33:38 -08001088void
1089_cpp_push_token_context (cpp_reader *pfile, cpp_hashnode *macro,
1090 const cpp_token *first, unsigned int count)
Neil Booth4ed5bcf2001-09-24 22:53:12 +00001091{
1092 cpp_context *context = next_context (pfile);
1093
1094 context->direct_p = true;
1095 context->macro = macro;
Neil Booth1e013d22001-09-26 21:44:35 +00001096 context->buff = NULL;
Neil Booth82eda772002-06-04 13:07:06 +00001097 FIRST (context).token = first;
1098 LAST (context).token = first + count;
Neil Booth93c803682000-10-28 17:59:06 +00001099}
1100
Neil Boothcbc69f82002-06-05 20:27:12 +00001101/* Push a traditional macro's replacement text. */
1102void
Zack Weinberg6cf87ca2003-06-17 06:17:44 +00001103_cpp_push_text_context (cpp_reader *pfile, cpp_hashnode *macro,
1104 const uchar *start, size_t len)
Neil Boothcbc69f82002-06-05 20:27:12 +00001105{
1106 cpp_context *context = next_context (pfile);
1107
1108 context->direct_p = true;
1109 context->macro = macro;
1110 context->buff = NULL;
1111 CUR (context) = start;
Neil Booth1ce676a2002-06-09 20:04:17 +00001112 RLIMIT (context) = start + len;
Neil Booth974c43f2002-06-13 06:25:28 +00001113 macro->flags |= NODE_DISABLED;
Neil Boothcbc69f82002-06-05 20:27:12 +00001114}
1115
Neil Boothd15a58c2002-01-03 18:32:55 +00001116/* Expand an argument ARG before replacing parameters in a
1117 function-like macro. This works by pushing a context with the
1118 argument's tokens, and then expanding that into a temporary buffer
1119 as if it were a normal part of the token stream. collect_args()
1120 has terminated the argument's tokens with a CPP_EOF so that we know
1121 when we have fully expanded the argument. */
Neil Booth93c803682000-10-28 17:59:06 +00001122static void
Zack Weinberg6cf87ca2003-06-17 06:17:44 +00001123expand_arg (cpp_reader *pfile, macro_arg *arg)
Neil Booth93c803682000-10-28 17:59:06 +00001124{
Neil Booth4ed5bcf2001-09-24 22:53:12 +00001125 unsigned int capacity;
Neil Booth56941bf2002-09-20 19:44:09 +00001126 bool saved_warn_trad;
Neil Booth4ed5bcf2001-09-24 22:53:12 +00001127
Neil Booth4ed5bcf2001-09-24 22:53:12 +00001128 if (arg->count == 0)
1129 return;
Neil Booth93c803682000-10-28 17:59:06 +00001130
Neil Booth56941bf2002-09-20 19:44:09 +00001131 /* Don't warn about funlike macros when pre-expanding. */
1132 saved_warn_trad = CPP_WTRADITIONAL (pfile);
1133 CPP_WTRADITIONAL (pfile) = 0;
1134
Neil Booth93c803682000-10-28 17:59:06 +00001135 /* Loop, reading in the arguments. */
Neil Booth4ed5bcf2001-09-24 22:53:12 +00001136 capacity = 256;
Gabriel Dos Reisc3f829c2005-05-28 15:52:48 +00001137 arg->expanded = XNEWVEC (const cpp_token *, capacity);
Neil Booth93c803682000-10-28 17:59:06 +00001138
Neil Booth1e013d22001-09-26 21:44:35 +00001139 push_ptoken_context (pfile, NULL, NULL, arg->first, arg->count + 1);
Neil Booth4ed5bcf2001-09-24 22:53:12 +00001140 for (;;)
Neil Booth93c803682000-10-28 17:59:06 +00001141 {
Neil Booth4ed5bcf2001-09-24 22:53:12 +00001142 const cpp_token *token;
1143
1144 if (arg->expanded_count + 1 >= capacity)
Neil Booth93c803682000-10-28 17:59:06 +00001145 {
1146 capacity *= 2;
Gabriel Dos Reisc3f829c2005-05-28 15:52:48 +00001147 arg->expanded = XRESIZEVEC (const cpp_token *, arg->expanded,
1148 capacity);
Neil Booth93c803682000-10-28 17:59:06 +00001149 }
Neil Booth4ed5bcf2001-09-24 22:53:12 +00001150
1151 token = cpp_get_token (pfile);
1152
1153 if (token->type == CPP_EOF)
1154 break;
1155
1156 arg->expanded[arg->expanded_count++] = token;
Neil Booth93c803682000-10-28 17:59:06 +00001157 }
Neil Booth93c803682000-10-28 17:59:06 +00001158
Neil Booth1e013d22001-09-26 21:44:35 +00001159 _cpp_pop_context (pfile);
Neil Booth56941bf2002-09-20 19:44:09 +00001160
1161 CPP_WTRADITIONAL (pfile) = saved_warn_trad;
Neil Booth93c803682000-10-28 17:59:06 +00001162}
1163
Neil Boothd15a58c2002-01-03 18:32:55 +00001164/* Pop the current context off the stack, re-enabling the macro if the
1165 context represented a macro's replacement list. The context
1166 structure is not freed so that we can re-use it later. */
Neil Booth93c803682000-10-28 17:59:06 +00001167void
Zack Weinberg6cf87ca2003-06-17 06:17:44 +00001168_cpp_pop_context (cpp_reader *pfile)
Neil Booth93c803682000-10-28 17:59:06 +00001169{
Neil Booth1e013d22001-09-26 21:44:35 +00001170 cpp_context *context = pfile->context;
Neil Booth93c803682000-10-28 17:59:06 +00001171
Neil Booth1e013d22001-09-26 21:44:35 +00001172 if (context->macro)
Neil Booth644edda2001-10-02 12:57:24 +00001173 context->macro->flags &= ~NODE_DISABLED;
Neil Booth1e013d22001-09-26 21:44:35 +00001174
1175 if (context->buff)
1176 _cpp_release_buff (pfile, context->buff);
1177
1178 pfile->context = context->prev;
Neil Booth93c803682000-10-28 17:59:06 +00001179}
1180
Martin Schaffner48c47212003-06-25 23:01:10 +02001181/* External routine to get a token. Also used nearly everywhere
Neil Booth7f2f1a62000-11-14 18:32:06 +00001182 internally, except for places where we know we can safely call
Martin Schaffner48c47212003-06-25 23:01:10 +02001183 _cpp_lex_token directly, such as lexing a directive name.
Neil Booth7f2f1a62000-11-14 18:32:06 +00001184
1185 Macro expansions and directives are transparently handled,
1186 including entering included files. Thus tokens are post-macro
1187 expansion, and after any intervening directives. External callers
1188 see CPP_EOF only at EOF. Internal callers also see it when meeting
1189 a directive inside a macro call, when at the end of a directive and
1190 state.in_directive is still 1, and at the end of argument
1191 pre-expansion. */
Neil Booth4ed5bcf2001-09-24 22:53:12 +00001192const cpp_token *
Zack Weinberg6cf87ca2003-06-17 06:17:44 +00001193cpp_get_token (cpp_reader *pfile)
Neil Booth93c803682000-10-28 17:59:06 +00001194{
Neil Booth4ed5bcf2001-09-24 22:53:12 +00001195 const cpp_token *result;
Tom Tromey5ffeb9132007-09-06 16:24:05 +00001196 bool can_set = pfile->set_invocation_location;
1197 pfile->set_invocation_location = false;
Neil Booth4ed5bcf2001-09-24 22:53:12 +00001198
Neil Booth29b10742000-11-13 18:40:37 +00001199 for (;;)
Neil Booth93c803682000-10-28 17:59:06 +00001200 {
Neil Booth4ed5bcf2001-09-24 22:53:12 +00001201 cpp_hashnode *node;
Neil Booth93c803682000-10-28 17:59:06 +00001202 cpp_context *context = pfile->context;
1203
Neil Booth93c803682000-10-28 17:59:06 +00001204 /* Context->prev == 0 <=> base context. */
Neil Boothbdcbe492001-09-13 20:05:17 +00001205 if (!context->prev)
Neil Booth4ed5bcf2001-09-24 22:53:12 +00001206 result = _cpp_lex_token (pfile);
Neil Booth82eda772002-06-04 13:07:06 +00001207 else if (FIRST (context).token != LAST (context).token)
Neil Booth29b10742000-11-13 18:40:37 +00001208 {
Neil Booth4ed5bcf2001-09-24 22:53:12 +00001209 if (context->direct_p)
Neil Booth82eda772002-06-04 13:07:06 +00001210 result = FIRST (context).token++;
Neil Booth4ed5bcf2001-09-24 22:53:12 +00001211 else
Neil Booth82eda772002-06-04 13:07:06 +00001212 result = *FIRST (context).ptoken++;
Neil Booth4ed5bcf2001-09-24 22:53:12 +00001213
1214 if (result->flags & PASTE_LEFT)
Neil Boothec1a23e2001-01-31 07:48:54 +00001215 {
Neil Booth4ed5bcf2001-09-24 22:53:12 +00001216 paste_all_tokens (pfile, result);
1217 if (pfile->state.in_directive)
1218 continue;
1219 return padding_token (pfile, result);
Neil Boothec1a23e2001-01-31 07:48:54 +00001220 }
Neil Booth29b10742000-11-13 18:40:37 +00001221 }
Neil Booth93c803682000-10-28 17:59:06 +00001222 else
1223 {
Neil Boothbdcbe492001-09-13 20:05:17 +00001224 _cpp_pop_context (pfile);
Neil Booth4ed5bcf2001-09-24 22:53:12 +00001225 if (pfile->state.in_directive)
1226 continue;
1227 return &pfile->avoid_paste;
Neil Booth93c803682000-10-28 17:59:06 +00001228 }
Neil Booth93c803682000-10-28 17:59:06 +00001229
Jason Thorpe477cdac2002-04-07 03:12:23 +00001230 if (pfile->state.in_directive && result->type == CPP_COMMENT)
1231 continue;
1232
Neil Booth4ed5bcf2001-09-24 22:53:12 +00001233 if (result->type != CPP_NAME)
Neil Booth93c803682000-10-28 17:59:06 +00001234 break;
1235
Neil Booth4ed5bcf2001-09-24 22:53:12 +00001236 node = result->val.node;
Neil Booth4c2b6472000-11-11 13:19:01 +00001237
Neil Booth644edda2001-10-02 12:57:24 +00001238 if (node->type != NT_MACRO || (result->flags & NO_EXPAND))
1239 break;
Kazu Hiratadf383482002-05-22 22:02:16 +00001240
Neil Booth644edda2001-10-02 12:57:24 +00001241 if (!(node->flags & NODE_DISABLED))
Neil Booth4ed5bcf2001-09-24 22:53:12 +00001242 {
Jakub Jelinek765d6002008-01-25 10:01:27 +01001243 int ret;
Tom Tromey5ffeb9132007-09-06 16:24:05 +00001244 /* If not in a macro context, and we're going to start an
1245 expansion, record the location. */
1246 if (can_set && !context->macro)
1247 pfile->invocation_location = result->src_loc;
Jakub Jelinek765d6002008-01-25 10:01:27 +01001248 if (pfile->state.prevent_expansion)
1249 break;
1250 ret = enter_macro_context (pfile, node, result);
1251 if (ret)
Neil Boothbd969772001-02-01 19:13:53 +00001252 {
Jakub Jelinek765d6002008-01-25 10:01:27 +01001253 if (pfile->state.in_directive || ret == 2)
Neil Booth4ed5bcf2001-09-24 22:53:12 +00001254 continue;
1255 return padding_token (pfile, result);
Neil Boothbd969772001-02-01 19:13:53 +00001256 }
Neil Booth93c803682000-10-28 17:59:06 +00001257 }
Neil Booth644edda2001-10-02 12:57:24 +00001258 else
1259 {
Neil Boothd15a58c2002-01-03 18:32:55 +00001260 /* Flag this token as always unexpandable. FIXME: move this
1261 to collect_args()?. */
Neil Booth644edda2001-10-02 12:57:24 +00001262 cpp_token *t = _cpp_temp_token (pfile);
1263 t->type = result->type;
1264 t->flags = result->flags | NO_EXPAND;
Jakub Jelinek73096712005-03-04 16:33:23 +01001265 t->val = result->val;
Neil Booth644edda2001-10-02 12:57:24 +00001266 result = t;
1267 }
Neil Bootha5c3ccc2000-10-30 22:29:00 +00001268
Neil Booth644edda2001-10-02 12:57:24 +00001269 break;
Neil Booth93c803682000-10-28 17:59:06 +00001270 }
Neil Booth4ed5bcf2001-09-24 22:53:12 +00001271
1272 return result;
Neil Booth93c803682000-10-28 17:59:06 +00001273}
1274
Tom Tromey5ffeb9132007-09-06 16:24:05 +00001275/* Like cpp_get_token, but also returns a location separate from the
1276 one provided by the returned token. LOC is an out parameter; *LOC
1277 is set to the location "as expected by the user". This matters
1278 when a token results from macro expansion -- the token's location
1279 will indicate where the macro is defined, but *LOC will be the
1280 location of the start of the expansion. */
1281const cpp_token *
1282cpp_get_token_with_location (cpp_reader *pfile, source_location *loc)
1283{
1284 const cpp_token *result;
1285
1286 pfile->set_invocation_location = true;
1287 result = cpp_get_token (pfile);
1288 if (pfile->context->macro)
1289 *loc = pfile->invocation_location;
1290 else
1291 *loc = result->src_loc;
1292
1293 return result;
1294}
1295
Neil Booth7065e132001-02-14 07:38:20 +00001296/* Returns true if we're expanding an object-like macro that was
1297 defined in a system header. Just checks the macro at the top of
1298 the stack. Used for diagnostic suppression. */
1299int
Zack Weinberg6cf87ca2003-06-17 06:17:44 +00001300cpp_sys_macro_p (cpp_reader *pfile)
Neil Booth7065e132001-02-14 07:38:20 +00001301{
Neil Booth644edda2001-10-02 12:57:24 +00001302 cpp_hashnode *node = pfile->context->macro;
Neil Booth7065e132001-02-14 07:38:20 +00001303
Neil Booth644edda2001-10-02 12:57:24 +00001304 return node && node->value.macro && node->value.macro->syshdr;
Neil Booth7065e132001-02-14 07:38:20 +00001305}
1306
Neil Boothaf0d16c2002-04-22 17:48:02 +00001307/* Read each token in, until end of the current file. Directives are
1308 transparently processed. */
Neil Booth93c803682000-10-28 17:59:06 +00001309void
Zack Weinberg6cf87ca2003-06-17 06:17:44 +00001310cpp_scan_nooutput (cpp_reader *pfile)
Neil Booth93c803682000-10-28 17:59:06 +00001311{
Per Bothner22234f52004-02-18 14:02:39 -08001312 /* Request a CPP_EOF token at the end of this file, rather than
1313 transparently continuing with the including file. */
1314 pfile->buffer->return_at_eof = true;
1315
Zack Weinbergc6e83802004-06-05 20:58:06 +00001316 pfile->state.discarding_output++;
1317 pfile->state.prevent_expansion++;
1318
Neil Booth590e1982002-07-01 12:47:54 +00001319 if (CPP_OPTION (pfile, traditional))
1320 while (_cpp_read_logical_line_trad (pfile))
1321 ;
1322 else
1323 while (cpp_get_token (pfile)->type != CPP_EOF)
1324 ;
Zack Weinbergc6e83802004-06-05 20:58:06 +00001325
1326 pfile->state.discarding_output--;
1327 pfile->state.prevent_expansion--;
Neil Booth93c803682000-10-28 17:59:06 +00001328}
1329
Jakub Jelinek1c90c6f2006-06-09 23:13:25 +02001330/* Step back one (or more) tokens. Can only step back more than 1 if
Neil Boothbdcbe492001-09-13 20:05:17 +00001331 they are from the lexer, and not from macro expansion. */
Neil Boothb528a072000-11-12 11:46:21 +00001332void
Zack Weinberg6cf87ca2003-06-17 06:17:44 +00001333_cpp_backup_tokens (cpp_reader *pfile, unsigned int count)
Neil Booth93c803682000-10-28 17:59:06 +00001334{
Neil Boothbdcbe492001-09-13 20:05:17 +00001335 if (pfile->context->prev == NULL)
1336 {
1337 pfile->lookaheads += count;
1338 while (count--)
1339 {
Neil Booth3293c3e2001-11-19 21:04:49 +00001340 pfile->cur_token--;
1341 if (pfile->cur_token == pfile->cur_run->base
1342 /* Possible with -fpreprocessed and no leading #line. */
1343 && pfile->cur_run->prev != NULL)
Neil Boothbdcbe492001-09-13 20:05:17 +00001344 {
Neil Boothbdcbe492001-09-13 20:05:17 +00001345 pfile->cur_run = pfile->cur_run->prev;
1346 pfile->cur_token = pfile->cur_run->limit;
1347 }
1348 }
1349 }
Neil Booth93c803682000-10-28 17:59:06 +00001350 else
1351 {
Neil Boothbdcbe492001-09-13 20:05:17 +00001352 if (count != 1)
1353 abort ();
Neil Booth4ed5bcf2001-09-24 22:53:12 +00001354 if (pfile->context->direct_p)
Neil Booth82eda772002-06-04 13:07:06 +00001355 FIRST (pfile->context).token--;
Neil Booth4ed5bcf2001-09-24 22:53:12 +00001356 else
Neil Booth82eda772002-06-04 13:07:06 +00001357 FIRST (pfile->context).ptoken--;
Neil Booth93c803682000-10-28 17:59:06 +00001358 }
Neil Booth93c803682000-10-28 17:59:06 +00001359}
1360
1361/* #define directive parsing and handling. */
1362
Kazu Hiratada7d8302002-09-22 02:03:17 +00001363/* Returns nonzero if a macro redefinition warning is required. */
Neil Boothcbc69f82002-06-05 20:27:12 +00001364static bool
Zack Weinberg6cf87ca2003-06-17 06:17:44 +00001365warn_of_redefinition (cpp_reader *pfile, const cpp_hashnode *node,
1366 const cpp_macro *macro2)
Neil Booth93c803682000-10-28 17:59:06 +00001367{
1368 const cpp_macro *macro1;
1369 unsigned int i;
1370
Neil Booth618cdda2001-02-25 09:43:03 +00001371 /* Some redefinitions need to be warned about regardless. */
1372 if (node->flags & NODE_WARN)
Neil Boothcbc69f82002-06-05 20:27:12 +00001373 return true;
Neil Booth93c803682000-10-28 17:59:06 +00001374
Neil Booth618cdda2001-02-25 09:43:03 +00001375 /* Redefinition of a macro is allowed if and only if the old and new
Kazu Hirataec5c56d2001-08-01 17:57:27 +00001376 definitions are the same. (6.10.3 paragraph 2). */
Neil Booth93c803682000-10-28 17:59:06 +00001377 macro1 = node->value.macro;
1378
Neil Booth6618c5d2002-06-10 06:03:13 +00001379 /* Don't check count here as it can be different in valid
1380 traditional redefinitions with just whitespace differences. */
1381 if (macro1->paramc != macro2->paramc
Neil Booth93c803682000-10-28 17:59:06 +00001382 || macro1->fun_like != macro2->fun_like
Neil Booth28e0f042000-12-09 12:06:37 +00001383 || macro1->variadic != macro2->variadic)
Neil Boothcbc69f82002-06-05 20:27:12 +00001384 return true;
Neil Booth93c803682000-10-28 17:59:06 +00001385
1386 /* Check parameter spellings. */
1387 for (i = 0; i < macro1->paramc; i++)
1388 if (macro1->params[i] != macro2->params[i])
Neil Boothcbc69f82002-06-05 20:27:12 +00001389 return true;
Neil Booth93c803682000-10-28 17:59:06 +00001390
Neil Boothcbc69f82002-06-05 20:27:12 +00001391 /* Check the replacement text or tokens. */
1392 if (CPP_OPTION (pfile, traditional))
Neil Booth6618c5d2002-06-10 06:03:13 +00001393 return _cpp_expansions_different_trad (macro1, macro2);
Neil Boothcbc69f82002-06-05 20:27:12 +00001394
DJ Deloriea7f36da2003-06-01 14:55:15 -04001395 if (macro1->count != macro2->count)
1396 return true;
1397
1398 for (i = 0; i < macro1->count; i++)
1399 if (!_cpp_equiv_tokens (&macro1->exp.tokens[i], &macro2->exp.tokens[i]))
1400 return true;
Neil Boothcbc69f82002-06-05 20:27:12 +00001401
1402 return false;
Zack Weinberg711b8822000-07-18 00:59:49 +00001403}
1404
Neil Booth93c803682000-10-28 17:59:06 +00001405/* Free the definition of hashnode H. */
Neil Booth93c803682000-10-28 17:59:06 +00001406void
Zack Weinberg6cf87ca2003-06-17 06:17:44 +00001407_cpp_free_definition (cpp_hashnode *h)
Zack Weinberg711b8822000-07-18 00:59:49 +00001408{
Neil Booth93c803682000-10-28 17:59:06 +00001409 /* Macros and assertions no longer have anything to free. */
1410 h->type = NT_VOID;
1411 /* Clear builtin flag in case of redefinition. */
Joseph Myers93d45d92008-04-02 20:42:53 +01001412 h->flags &= ~(NODE_BUILTIN | NODE_DISABLED | NODE_USED);
Neil Booth93c803682000-10-28 17:59:06 +00001413}
Zack Weinberg711b8822000-07-18 00:59:49 +00001414
Neil Booth14baae02001-09-17 18:26:12 +00001415/* Save parameter NODE to the parameter list of macro MACRO. Returns
Kazu Hiratada7d8302002-09-22 02:03:17 +00001416 zero on success, nonzero if the parameter is a duplicate. */
Neil Boothc70f6ed2002-06-07 06:26:32 +00001417bool
Zack Weinberg6cf87ca2003-06-17 06:17:44 +00001418_cpp_save_parameter (cpp_reader *pfile, cpp_macro *macro, cpp_hashnode *node)
Neil Booth93c803682000-10-28 17:59:06 +00001419{
Zack Weinberg4977bab2002-12-16 18:23:00 +00001420 unsigned int len;
Neil Booth93c803682000-10-28 17:59:06 +00001421 /* Constraint 6.10.3.6 - duplicate parameter names. */
Zack Weinberg4977bab2002-12-16 18:23:00 +00001422 if (node->flags & NODE_MACRO_ARG)
Zack Weinberg711b8822000-07-18 00:59:49 +00001423 {
John David Anglin0527bc42003-11-01 22:56:54 +00001424 cpp_error (pfile, CPP_DL_ERROR, "duplicate macro parameter \"%s\"",
Neil Boothebef4e82002-04-14 18:42:47 +00001425 NODE_NAME (node));
Neil Booth23ff0222002-07-17 17:27:14 +00001426 return true;
Neil Booth93c803682000-10-28 17:59:06 +00001427 }
1428
Neil Booth8c3b2692001-09-30 10:03:11 +00001429 if (BUFF_ROOM (pfile->a_buff)
1430 < (macro->paramc + 1) * sizeof (cpp_hashnode *))
1431 _cpp_extend_buff (pfile, &pfile->a_buff, sizeof (cpp_hashnode *));
Neil Booth93c803682000-10-28 17:59:06 +00001432
Neil Booth8c3b2692001-09-30 10:03:11 +00001433 ((cpp_hashnode **) BUFF_FRONT (pfile->a_buff))[macro->paramc++] = node;
Zack Weinberg4977bab2002-12-16 18:23:00 +00001434 node->flags |= NODE_MACRO_ARG;
1435 len = macro->paramc * sizeof (union _cpp_hashnode_value);
1436 if (len > pfile->macro_buffer_len)
1437 {
Gabriel Dos Reisc3f829c2005-05-28 15:52:48 +00001438 pfile->macro_buffer = XRESIZEVEC (unsigned char, pfile->macro_buffer,
1439 len);
Zack Weinberg4977bab2002-12-16 18:23:00 +00001440 pfile->macro_buffer_len = len;
1441 }
1442 ((union _cpp_hashnode_value *) pfile->macro_buffer)[macro->paramc - 1]
1443 = node->value;
1444
1445 node->value.arg_index = macro->paramc;
Neil Booth23ff0222002-07-17 17:27:14 +00001446 return false;
Neil Booth93c803682000-10-28 17:59:06 +00001447}
1448
Neil Booth23ff0222002-07-17 17:27:14 +00001449/* Check the syntax of the parameters in a MACRO definition. Returns
1450 false if an error occurs. */
1451static bool
Zack Weinberg6cf87ca2003-06-17 06:17:44 +00001452parse_params (cpp_reader *pfile, cpp_macro *macro)
Neil Booth93c803682000-10-28 17:59:06 +00001453{
Neil Booth93c803682000-10-28 17:59:06 +00001454 unsigned int prev_ident = 0;
1455
Neil Booth93c803682000-10-28 17:59:06 +00001456 for (;;)
1457 {
Neil Booth345894b2001-09-16 13:44:29 +00001458 const cpp_token *token = _cpp_lex_token (pfile);
Neil Booth93c803682000-10-28 17:59:06 +00001459
Neil Booth345894b2001-09-16 13:44:29 +00001460 switch (token->type)
Zack Weinberg711b8822000-07-18 00:59:49 +00001461 {
1462 default:
Jason Thorpe477cdac2002-04-07 03:12:23 +00001463 /* Allow/ignore comments in parameter lists if we are
1464 preserving comments in macro expansions. */
1465 if (token->type == CPP_COMMENT
1466 && ! CPP_OPTION (pfile, discard_comments_in_macro_exp))
1467 continue;
1468
John David Anglin0527bc42003-11-01 22:56:54 +00001469 cpp_error (pfile, CPP_DL_ERROR,
Neil Boothebef4e82002-04-14 18:42:47 +00001470 "\"%s\" may not appear in macro parameter list",
Neil Booth345894b2001-09-16 13:44:29 +00001471 cpp_token_as_text (pfile, token));
Neil Booth23ff0222002-07-17 17:27:14 +00001472 return false;
Zack Weinberg711b8822000-07-18 00:59:49 +00001473
Zack Weinberg711b8822000-07-18 00:59:49 +00001474 case CPP_NAME:
1475 if (prev_ident)
1476 {
John David Anglin0527bc42003-11-01 22:56:54 +00001477 cpp_error (pfile, CPP_DL_ERROR,
Neil Boothebef4e82002-04-14 18:42:47 +00001478 "macro parameters must be comma-separated");
Neil Booth23ff0222002-07-17 17:27:14 +00001479 return false;
Zack Weinberg711b8822000-07-18 00:59:49 +00001480 }
Zack Weinberg711b8822000-07-18 00:59:49 +00001481 prev_ident = 1;
Neil Booth93c803682000-10-28 17:59:06 +00001482
Neil Boothc70f6ed2002-06-07 06:26:32 +00001483 if (_cpp_save_parameter (pfile, macro, token->val.node))
Neil Booth23ff0222002-07-17 17:27:14 +00001484 return false;
Zack Weinberg711b8822000-07-18 00:59:49 +00001485 continue;
1486
1487 case CPP_CLOSE_PAREN:
Neil Booth93c803682000-10-28 17:59:06 +00001488 if (prev_ident || macro->paramc == 0)
Neil Booth23ff0222002-07-17 17:27:14 +00001489 return true;
Zack Weinberg711b8822000-07-18 00:59:49 +00001490
1491 /* Fall through to pick up the error. */
1492 case CPP_COMMA:
1493 if (!prev_ident)
1494 {
John David Anglin0527bc42003-11-01 22:56:54 +00001495 cpp_error (pfile, CPP_DL_ERROR, "parameter name missing");
Neil Booth23ff0222002-07-17 17:27:14 +00001496 return false;
Zack Weinberg711b8822000-07-18 00:59:49 +00001497 }
1498 prev_ident = 0;
1499 continue;
1500
1501 case CPP_ELLIPSIS:
Neil Booth28e0f042000-12-09 12:06:37 +00001502 macro->variadic = 1;
Zack Weinberg711b8822000-07-18 00:59:49 +00001503 if (!prev_ident)
1504 {
Neil Boothc70f6ed2002-06-07 06:26:32 +00001505 _cpp_save_parameter (pfile, macro,
1506 pfile->spec_nodes.n__VA_ARGS__);
Neil Booth93c803682000-10-28 17:59:06 +00001507 pfile->state.va_args_ok = 1;
Richard Hendersone5b79212004-02-19 14:18:50 -08001508 if (! CPP_OPTION (pfile, c99)
1509 && CPP_OPTION (pfile, pedantic)
1510 && CPP_OPTION (pfile, warn_variadic_macros))
John David Anglin0527bc42003-11-01 22:56:54 +00001511 cpp_error (pfile, CPP_DL_PEDWARN,
Neil Boothebef4e82002-04-14 18:42:47 +00001512 "anonymous variadic macros were introduced in C99");
Zack Weinberg711b8822000-07-18 00:59:49 +00001513 }
Richard Hendersone5b79212004-02-19 14:18:50 -08001514 else if (CPP_OPTION (pfile, pedantic)
1515 && CPP_OPTION (pfile, warn_variadic_macros))
John David Anglin0527bc42003-11-01 22:56:54 +00001516 cpp_error (pfile, CPP_DL_PEDWARN,
Neil Boothebef4e82002-04-14 18:42:47 +00001517 "ISO C does not permit named variadic macros");
Zack Weinberg711b8822000-07-18 00:59:49 +00001518
Neil Booth93c803682000-10-28 17:59:06 +00001519 /* We're at the end, and just expect a closing parenthesis. */
Neil Booth345894b2001-09-16 13:44:29 +00001520 token = _cpp_lex_token (pfile);
1521 if (token->type == CPP_CLOSE_PAREN)
Neil Booth23ff0222002-07-17 17:27:14 +00001522 return true;
Neil Booth93c803682000-10-28 17:59:06 +00001523 /* Fall through. */
1524
1525 case CPP_EOF:
John David Anglin0527bc42003-11-01 22:56:54 +00001526 cpp_error (pfile, CPP_DL_ERROR, "missing ')' in macro parameter list");
Neil Booth23ff0222002-07-17 17:27:14 +00001527 return false;
Zack Weinberg711b8822000-07-18 00:59:49 +00001528 }
Zack Weinberg711b8822000-07-18 00:59:49 +00001529 }
1530}
1531
Neil Booth14baae02001-09-17 18:26:12 +00001532/* Allocate room for a token from a macro's replacement list. */
Neil Booth93c803682000-10-28 17:59:06 +00001533static cpp_token *
Zack Weinberg6cf87ca2003-06-17 06:17:44 +00001534alloc_expansion_token (cpp_reader *pfile, cpp_macro *macro)
Zack Weinberg711b8822000-07-18 00:59:49 +00001535{
Neil Booth8c3b2692001-09-30 10:03:11 +00001536 if (BUFF_ROOM (pfile->a_buff) < (macro->count + 1) * sizeof (cpp_token))
1537 _cpp_extend_buff (pfile, &pfile->a_buff, sizeof (cpp_token));
Zack Weinberg711b8822000-07-18 00:59:49 +00001538
Neil Booth8c3b2692001-09-30 10:03:11 +00001539 return &((cpp_token *) BUFF_FRONT (pfile->a_buff))[macro->count++];
Neil Booth14baae02001-09-17 18:26:12 +00001540}
1541
Neil Boothd15a58c2002-01-03 18:32:55 +00001542/* Lex a token from the expansion of MACRO, but mark parameters as we
1543 find them and warn of traditional stringification. */
Neil Booth14baae02001-09-17 18:26:12 +00001544static cpp_token *
Zack Weinberg6cf87ca2003-06-17 06:17:44 +00001545lex_expansion_token (cpp_reader *pfile, cpp_macro *macro)
Neil Booth14baae02001-09-17 18:26:12 +00001546{
Tom Tromeyee380362007-01-30 15:46:01 +00001547 cpp_token *token, *saved_cur_token;
Neil Booth14baae02001-09-17 18:26:12 +00001548
Tom Tromeyee380362007-01-30 15:46:01 +00001549 saved_cur_token = pfile->cur_token;
Neil Booth14baae02001-09-17 18:26:12 +00001550 pfile->cur_token = alloc_expansion_token (pfile, macro);
1551 token = _cpp_lex_direct (pfile);
Tom Tromeyee380362007-01-30 15:46:01 +00001552 pfile->cur_token = saved_cur_token;
Neil Booth93c803682000-10-28 17:59:06 +00001553
Neil Boothd15a58c2002-01-03 18:32:55 +00001554 /* Is this a parameter? */
Zack Weinberg4977bab2002-12-16 18:23:00 +00001555 if (token->type == CPP_NAME
1556 && (token->val.node->flags & NODE_MACRO_ARG) != 0)
Zack Weinberg711b8822000-07-18 00:59:49 +00001557 {
Neil Booth93c803682000-10-28 17:59:06 +00001558 token->type = CPP_MACRO_ARG;
Zack Weinberg4977bab2002-12-16 18:23:00 +00001559 token->val.arg_no = token->val.node->value.arg_index;
Zack Weinberg711b8822000-07-18 00:59:49 +00001560 }
Neil Booth93c803682000-10-28 17:59:06 +00001561 else if (CPP_WTRADITIONAL (pfile) && macro->paramc > 0
1562 && (token->type == CPP_STRING || token->type == CPP_CHAR))
1563 check_trad_stringification (pfile, macro, &token->val.str);
Zack Weinberg711b8822000-07-18 00:59:49 +00001564
Neil Booth93c803682000-10-28 17:59:06 +00001565 return token;
Zack Weinberg711b8822000-07-18 00:59:49 +00001566}
1567
Neil Boothcbc69f82002-06-05 20:27:12 +00001568static bool
Zack Weinberg6cf87ca2003-06-17 06:17:44 +00001569create_iso_definition (cpp_reader *pfile, cpp_macro *macro)
Zack Weinberg711b8822000-07-18 00:59:49 +00001570{
Neil Boothcbc69f82002-06-05 20:27:12 +00001571 cpp_token *token;
Neil Booth14baae02001-09-17 18:26:12 +00001572 const cpp_token *ctoken;
Simon Martin126e0732007-05-23 20:58:34 +00001573 bool following_paste_op = false;
1574 const char *paste_op_error_msg =
1575 N_("'##' cannot appear at either end of a macro expansion");
Zack Weinberg711b8822000-07-18 00:59:49 +00001576
Neil Booth93c803682000-10-28 17:59:06 +00001577 /* Get the first token of the expansion (or the '(' of a
1578 function-like macro). */
Neil Booth14baae02001-09-17 18:26:12 +00001579 ctoken = _cpp_lex_token (pfile);
1580
1581 if (ctoken->type == CPP_OPEN_PAREN && !(ctoken->flags & PREV_WHITE))
Zack Weinberg711b8822000-07-18 00:59:49 +00001582 {
Neil Boothcbc69f82002-06-05 20:27:12 +00001583 bool ok = parse_params (pfile, macro);
Neil Booth8c3b2692001-09-30 10:03:11 +00001584 macro->params = (cpp_hashnode **) BUFF_FRONT (pfile->a_buff);
1585 if (!ok)
Neil Boothcbc69f82002-06-05 20:27:12 +00001586 return false;
Neil Booth8c3b2692001-09-30 10:03:11 +00001587
Geoffrey Keatingd8044162004-06-09 20:10:13 +00001588 /* Success. Commit or allocate the parameter array. */
1589 if (pfile->hash_table->alloc_subobject)
1590 {
Gabriel Dos Reisc3f829c2005-05-28 15:52:48 +00001591 cpp_hashnode **params =
1592 (cpp_hashnode **) pfile->hash_table->alloc_subobject
1593 (sizeof (cpp_hashnode *) * macro->paramc);
Paolo Bonzinibe0f1e52005-02-14 08:52:24 +00001594 memcpy (params, macro->params,
1595 sizeof (cpp_hashnode *) * macro->paramc);
1596 macro->params = params;
Geoffrey Keatingd8044162004-06-09 20:10:13 +00001597 }
1598 else
1599 BUFF_FRONT (pfile->a_buff) = (uchar *) &macro->params[macro->paramc];
Neil Booth93c803682000-10-28 17:59:06 +00001600 macro->fun_like = 1;
Neil Booth93c803682000-10-28 17:59:06 +00001601 }
Neil Booth14baae02001-09-17 18:26:12 +00001602 else if (ctoken->type != CPP_EOF && !(ctoken->flags & PREV_WHITE))
Jakub Jelinekcae064e2005-04-05 22:07:06 +02001603 {
1604 /* While ISO C99 requires whitespace before replacement text
1605 in a macro definition, ISO C90 with TC1 allows there characters
1606 from the basic source character set. */
1607 if (CPP_OPTION (pfile, c99))
1608 cpp_error (pfile, CPP_DL_PEDWARN,
1609 "ISO C99 requires whitespace after the macro name");
1610 else
1611 {
1612 int warntype = CPP_DL_WARNING;
1613 switch (ctoken->type)
1614 {
1615 case CPP_ATSIGN:
1616 case CPP_AT_NAME:
1617 case CPP_OBJC_STRING:
1618 /* '@' is not in basic character set. */
1619 warntype = CPP_DL_PEDWARN;
1620 break;
1621 case CPP_OTHER:
1622 /* Basic character set sans letters, digits and _. */
1623 if (strchr ("!\"#%&'()*+,-./:;<=>?[\\]^{|}~",
1624 ctoken->val.str.text[0]) == NULL)
1625 warntype = CPP_DL_PEDWARN;
1626 break;
1627 default:
1628 /* All other tokens start with a character from basic
1629 character set. */
1630 break;
1631 }
1632 cpp_error (pfile, warntype,
1633 "missing whitespace after the macro name");
1634 }
1635 }
Neil Booth93c803682000-10-28 17:59:06 +00001636
Neil Booth14baae02001-09-17 18:26:12 +00001637 if (macro->fun_like)
1638 token = lex_expansion_token (pfile, macro);
1639 else
1640 {
1641 token = alloc_expansion_token (pfile, macro);
1642 *token = *ctoken;
1643 }
Neil Booth93c803682000-10-28 17:59:06 +00001644
1645 for (;;)
1646 {
1647 /* Check the stringifying # constraint 6.10.3.2.1 of
1648 function-like macros when lexing the subsequent token. */
1649 if (macro->count > 1 && token[-1].type == CPP_HASH && macro->fun_like)
Zack Weinberg711b8822000-07-18 00:59:49 +00001650 {
Neil Booth93c803682000-10-28 17:59:06 +00001651 if (token->type == CPP_MACRO_ARG)
1652 {
1653 token->flags &= ~PREV_WHITE;
1654 token->flags |= STRINGIFY_ARG;
1655 token->flags |= token[-1].flags & PREV_WHITE;
1656 token[-1] = token[0];
1657 macro->count--;
1658 }
1659 /* Let assembler get away with murder. */
Neil Boothbdb05a72000-11-26 17:31:13 +00001660 else if (CPP_OPTION (pfile, lang) != CLK_ASM)
Neil Booth93c803682000-10-28 17:59:06 +00001661 {
John David Anglin0527bc42003-11-01 22:56:54 +00001662 cpp_error (pfile, CPP_DL_ERROR,
Neil Boothebef4e82002-04-14 18:42:47 +00001663 "'#' is not followed by a macro parameter");
Neil Boothcbc69f82002-06-05 20:27:12 +00001664 return false;
Neil Booth93c803682000-10-28 17:59:06 +00001665 }
1666 }
1667
1668 if (token->type == CPP_EOF)
Simon Martin126e0732007-05-23 20:58:34 +00001669 {
1670 /* Paste operator constraint 6.10.3.3.1:
1671 Token-paste ##, can appear in both object-like and
1672 function-like macros, but not at the end. */
1673 if (following_paste_op)
1674 {
1675 cpp_error (pfile, CPP_DL_ERROR, paste_op_error_msg);
1676 return false;
1677 }
1678 break;
1679 }
Neil Booth93c803682000-10-28 17:59:06 +00001680
1681 /* Paste operator constraint 6.10.3.3.1. */
1682 if (token->type == CPP_PASTE)
1683 {
1684 /* Token-paste ##, can appear in both object-like and
Simon Martin126e0732007-05-23 20:58:34 +00001685 function-like macros, but not at the beginning. */
1686 if (macro->count == 1)
Neil Booth93c803682000-10-28 17:59:06 +00001687 {
Simon Martin126e0732007-05-23 20:58:34 +00001688 cpp_error (pfile, CPP_DL_ERROR, paste_op_error_msg);
Neil Boothcbc69f82002-06-05 20:27:12 +00001689 return false;
Neil Booth93c803682000-10-28 17:59:06 +00001690 }
1691
Simon Martin126e0732007-05-23 20:58:34 +00001692 --macro->count;
Neil Booth93c803682000-10-28 17:59:06 +00001693 token[-1].flags |= PASTE_LEFT;
Neil Booth93c803682000-10-28 17:59:06 +00001694 }
1695
Simon Martin126e0732007-05-23 20:58:34 +00001696 following_paste_op = (token->type == CPP_PASTE);
Neil Booth93c803682000-10-28 17:59:06 +00001697 token = lex_expansion_token (pfile, macro);
1698 }
1699
Neil Booth601328b2002-05-16 05:53:24 +00001700 macro->exp.tokens = (cpp_token *) BUFF_FRONT (pfile->a_buff);
Geoffrey Keatingd8044162004-06-09 20:10:13 +00001701 macro->traditional = 0;
Neil Booth8c3b2692001-09-30 10:03:11 +00001702
Neil Booth4c2b6472000-11-11 13:19:01 +00001703 /* Don't count the CPP_EOF. */
1704 macro->count--;
Neil Booth93c803682000-10-28 17:59:06 +00001705
Neil Boothd15a58c2002-01-03 18:32:55 +00001706 /* Clear whitespace on first token for warn_of_redefinition(). */
Neil Booth8c3b2692001-09-30 10:03:11 +00001707 if (macro->count)
Neil Booth601328b2002-05-16 05:53:24 +00001708 macro->exp.tokens[0].flags &= ~PREV_WHITE;
Neil Booth8c3b2692001-09-30 10:03:11 +00001709
Geoffrey Keatingd8044162004-06-09 20:10:13 +00001710 /* Commit or allocate the memory. */
1711 if (pfile->hash_table->alloc_subobject)
1712 {
Gabriel Dos Reisc3f829c2005-05-28 15:52:48 +00001713 cpp_token *tokns =
1714 (cpp_token *) pfile->hash_table->alloc_subobject (sizeof (cpp_token)
1715 * macro->count);
Geoffrey Keatingd8044162004-06-09 20:10:13 +00001716 memcpy (tokns, macro->exp.tokens, sizeof (cpp_token) * macro->count);
1717 macro->exp.tokens = tokns;
1718 }
1719 else
1720 BUFF_FRONT (pfile->a_buff) = (uchar *) &macro->exp.tokens[macro->count];
Neil Booth8c3b2692001-09-30 10:03:11 +00001721
Neil Boothcbc69f82002-06-05 20:27:12 +00001722 return true;
1723}
Neil Booth44ed91a2000-10-29 11:37:18 +00001724
Kazu Hiratada7d8302002-09-22 02:03:17 +00001725/* Parse a macro and save its expansion. Returns nonzero on success. */
Neil Boothcbc69f82002-06-05 20:27:12 +00001726bool
Zack Weinberg6cf87ca2003-06-17 06:17:44 +00001727_cpp_create_definition (cpp_reader *pfile, cpp_hashnode *node)
Neil Boothcbc69f82002-06-05 20:27:12 +00001728{
1729 cpp_macro *macro;
1730 unsigned int i;
1731 bool ok;
1732
Geoffrey Keatingd8044162004-06-09 20:10:13 +00001733 if (pfile->hash_table->alloc_subobject)
Gabriel Dos Reisc3f829c2005-05-28 15:52:48 +00001734 macro = (cpp_macro *) pfile->hash_table->alloc_subobject
1735 (sizeof (cpp_macro));
Geoffrey Keatingd8044162004-06-09 20:10:13 +00001736 else
1737 macro = (cpp_macro *) _cpp_aligned_alloc (pfile, sizeof (cpp_macro));
Neil Boothcbc69f82002-06-05 20:27:12 +00001738 macro->line = pfile->directive_line;
1739 macro->params = 0;
1740 macro->paramc = 0;
1741 macro->variadic = 0;
Neil Booth23345bb2003-03-14 21:47:50 +00001742 macro->used = !CPP_OPTION (pfile, warn_unused_macros);
Neil Boothcbc69f82002-06-05 20:27:12 +00001743 macro->count = 0;
1744 macro->fun_like = 0;
Neil Booth7065e132001-02-14 07:38:20 +00001745 /* To suppress some diagnostics. */
Per Bothner12f9df42004-02-11 07:29:30 -08001746 macro->syshdr = pfile->buffer && pfile->buffer->sysp != 0;
Neil Booth7065e132001-02-14 07:38:20 +00001747
Neil Boothcbc69f82002-06-05 20:27:12 +00001748 if (CPP_OPTION (pfile, traditional))
1749 ok = _cpp_create_trad_definition (pfile, macro);
1750 else
1751 {
Neil Boothcbc69f82002-06-05 20:27:12 +00001752 ok = create_iso_definition (pfile, macro);
1753
Tom Tromeyee380362007-01-30 15:46:01 +00001754 /* We set the type for SEEN_EOL() in directives.c.
Neil Boothcbc69f82002-06-05 20:27:12 +00001755
1756 Longer term we should lex the whole line before coming here,
1757 and just copy the expansion. */
Neil Boothcbc69f82002-06-05 20:27:12 +00001758
1759 /* Stop the lexer accepting __VA_ARGS__. */
1760 pfile->state.va_args_ok = 0;
1761 }
1762
1763 /* Clear the fast argument lookup indices. */
1764 for (i = macro->paramc; i-- > 0; )
Zack Weinberg4977bab2002-12-16 18:23:00 +00001765 {
1766 struct cpp_hashnode *node = macro->params[i];
1767 node->flags &= ~ NODE_MACRO_ARG;
1768 node->value = ((union _cpp_hashnode_value *) pfile->macro_buffer)[i];
1769 }
Neil Boothcbc69f82002-06-05 20:27:12 +00001770
1771 if (!ok)
1772 return ok;
1773
Neil Boothc2734e02002-07-26 16:29:31 +00001774 if (node->type == NT_MACRO)
Neil Booth93c803682000-10-28 17:59:06 +00001775 {
Neil Bootha69cbaa2002-07-23 22:57:49 +00001776 if (CPP_OPTION (pfile, warn_unused_macros))
1777 _cpp_warn_if_unused_macro (pfile, node, NULL);
1778
Neil Boothcbc69f82002-06-05 20:27:12 +00001779 if (warn_of_redefinition (pfile, node, macro))
Neil Booth93c803682000-10-28 17:59:06 +00001780 {
John David Anglin0527bc42003-11-01 22:56:54 +00001781 cpp_error_with_line (pfile, CPP_DL_PEDWARN, pfile->directive_line, 0,
Neil Boothebef4e82002-04-14 18:42:47 +00001782 "\"%s\" redefined", NODE_NAME (node));
Neil Booth93c803682000-10-28 17:59:06 +00001783
Neil Booth618cdda2001-02-25 09:43:03 +00001784 if (node->type == NT_MACRO && !(node->flags & NODE_BUILTIN))
John David Anglin0527bc42003-11-01 22:56:54 +00001785 cpp_error_with_line (pfile, CPP_DL_PEDWARN,
Neil Boothcbc69f82002-06-05 20:27:12 +00001786 node->value.macro->line, 0,
1787 "this is the location of the previous definition");
Zack Weinberg711b8822000-07-18 00:59:49 +00001788 }
Zack Weinberg711b8822000-07-18 00:59:49 +00001789 }
1790
Neil Boothc2734e02002-07-26 16:29:31 +00001791 if (node->type != NT_VOID)
1792 _cpp_free_definition (node);
1793
Zack Weinberg711b8822000-07-18 00:59:49 +00001794 /* Enter definition in hash table. */
Neil Booth93c803682000-10-28 17:59:06 +00001795 node->type = NT_MACRO;
1796 node->value.macro = macro;
Tom Tromey607f74e2007-11-30 18:24:01 +00001797 if (! ustrncmp (NODE_NAME (node), DSC ("__STDC_"))
Tom Tromeyec460532008-01-22 21:43:49 +00001798 && ustrcmp (NODE_NAME (node), (const uchar *) "__STDC_FORMAT_MACROS")
1799 /* __STDC_LIMIT_MACROS and __STDC_CONSTANT_MACROS are mentioned
1800 in the C standard, as something that one must use in C++.
1801 However DR#593 indicates that these aren't actually mentioned
1802 in the C++ standard. We special-case them anyway. */
1803 && ustrcmp (NODE_NAME (node), (const uchar *) "__STDC_LIMIT_MACROS")
1804 && ustrcmp (NODE_NAME (node), (const uchar *) "__STDC_CONSTANT_MACROS"))
Neil Booth618cdda2001-02-25 09:43:03 +00001805 node->flags |= NODE_WARN;
Zack Weinberg711b8822000-07-18 00:59:49 +00001806
Neil Booth93c803682000-10-28 17:59:06 +00001807 return ok;
Zack Weinberg711b8822000-07-18 00:59:49 +00001808}
1809
Neil Boothd15a58c2002-01-03 18:32:55 +00001810/* Warn if a token in STRING matches one of a function-like MACRO's
1811 parameters. */
Kaveh R. Ghazie1aa5142000-09-10 03:41:50 +00001812static void
Zack Weinberg6cf87ca2003-06-17 06:17:44 +00001813check_trad_stringification (cpp_reader *pfile, const cpp_macro *macro,
1814 const cpp_string *string)
Kaveh R. Ghazie1aa5142000-09-10 03:41:50 +00001815{
Neil Booth93c803682000-10-28 17:59:06 +00001816 unsigned int i, len;
Neil Booth6338b352003-04-23 22:44:06 +00001817 const uchar *p, *q, *limit;
Kazu Hiratadf383482002-05-22 22:02:16 +00001818
Kaveh R. Ghazie1aa5142000-09-10 03:41:50 +00001819 /* Loop over the string. */
Neil Booth6338b352003-04-23 22:44:06 +00001820 limit = string->text + string->len - 1;
1821 for (p = string->text + 1; p < limit; p = q)
Kaveh R. Ghazie1aa5142000-09-10 03:41:50 +00001822 {
Kaveh R. Ghazie1aa5142000-09-10 03:41:50 +00001823 /* Find the start of an identifier. */
Greg McGary61c16b12000-09-15 21:25:02 +00001824 while (p < limit && !is_idstart (*p))
1825 p++;
Kaveh R. Ghazie1aa5142000-09-10 03:41:50 +00001826
1827 /* Find the end of the identifier. */
1828 q = p;
Greg McGary61c16b12000-09-15 21:25:02 +00001829 while (q < limit && is_idchar (*q))
1830 q++;
Neil Booth93c803682000-10-28 17:59:06 +00001831
1832 len = q - p;
1833
Kaveh R. Ghazie1aa5142000-09-10 03:41:50 +00001834 /* Loop over the function macro arguments to see if the
1835 identifier inside the string matches one of them. */
Neil Booth93c803682000-10-28 17:59:06 +00001836 for (i = 0; i < macro->paramc; i++)
1837 {
1838 const cpp_hashnode *node = macro->params[i];
Kaveh R. Ghazie1aa5142000-09-10 03:41:50 +00001839
Neil Booth2a967f32001-05-20 06:26:45 +00001840 if (NODE_LEN (node) == len
1841 && !memcmp (p, NODE_NAME (node), len))
Kaveh R. Ghazie1aa5142000-09-10 03:41:50 +00001842 {
John David Anglin0527bc42003-11-01 22:56:54 +00001843 cpp_error (pfile, CPP_DL_WARNING,
Zack Weinbergf458d1d2002-02-27 18:48:07 +00001844 "macro argument \"%s\" would be stringified in traditional C",
Neil Boothebef4e82002-04-14 18:42:47 +00001845 NODE_NAME (node));
Kaveh R. Ghazie1aa5142000-09-10 03:41:50 +00001846 break;
1847 }
1848 }
1849 }
1850}
Neil Booth93c803682000-10-28 17:59:06 +00001851
Neil Booth70961712001-06-23 11:34:41 +00001852/* Returns the name, arguments and expansion of a macro, in a format
1853 suitable to be read back in again, and therefore also for DWARF 2
1854 debugging info. e.g. "PASTE(X, Y) X ## Y", or "MACNAME EXPANSION".
1855 Caller is expected to generate the "#define" bit if needed. The
Neil Booth93c803682000-10-28 17:59:06 +00001856 returned text is temporary, and automatically freed later. */
Neil Booth93c803682000-10-28 17:59:06 +00001857const unsigned char *
Zack Weinberg6cf87ca2003-06-17 06:17:44 +00001858cpp_macro_definition (cpp_reader *pfile, const cpp_hashnode *node)
Neil Booth93c803682000-10-28 17:59:06 +00001859{
1860 unsigned int i, len;
1861 const cpp_macro *macro = node->value.macro;
1862 unsigned char *buffer;
1863
1864 if (node->type != NT_MACRO || (node->flags & NODE_BUILTIN))
1865 {
John David Anglin0527bc42003-11-01 22:56:54 +00001866 cpp_error (pfile, CPP_DL_ICE,
Neil Boothebef4e82002-04-14 18:42:47 +00001867 "invalid hash type %d in cpp_macro_definition", node->type);
Neil Booth93c803682000-10-28 17:59:06 +00001868 return 0;
1869 }
1870
1871 /* Calculate length. */
Neil Booth8dc901d2002-05-29 19:30:07 +00001872 len = NODE_LEN (node) + 2; /* ' ' and NUL. */
Neil Booth93c803682000-10-28 17:59:06 +00001873 if (macro->fun_like)
1874 {
Jim Blandy64d08262002-04-05 00:12:40 +00001875 len += 4; /* "()" plus possible final ".." of named
1876 varargs (we have + 1 below). */
Neil Booth93c803682000-10-28 17:59:06 +00001877 for (i = 0; i < macro->paramc; i++)
Jim Blandy64d08262002-04-05 00:12:40 +00001878 len += NODE_LEN (macro->params[i]) + 1; /* "," */
Neil Booth93c803682000-10-28 17:59:06 +00001879 }
1880
Eric Christopher6da55c02005-02-15 23:18:04 +00001881 /* This should match below where we fill in the buffer. */
Neil Booth278c4662002-06-19 05:40:08 +00001882 if (CPP_OPTION (pfile, traditional))
1883 len += _cpp_replacement_text_len (macro);
1884 else
Neil Booth93c803682000-10-28 17:59:06 +00001885 {
Neil Booth278c4662002-06-19 05:40:08 +00001886 for (i = 0; i < macro->count; i++)
1887 {
1888 cpp_token *token = &macro->exp.tokens[i];
Neil Booth93c803682000-10-28 17:59:06 +00001889
Neil Booth278c4662002-06-19 05:40:08 +00001890 if (token->type == CPP_MACRO_ARG)
1891 len += NODE_LEN (macro->params[token->val.arg_no - 1]);
1892 else
Eric Christopher6da55c02005-02-15 23:18:04 +00001893 len += cpp_token_len (token);
1894
Neil Booth278c4662002-06-19 05:40:08 +00001895 if (token->flags & STRINGIFY_ARG)
1896 len++; /* "#" */
1897 if (token->flags & PASTE_LEFT)
1898 len += 3; /* " ##" */
Eric Christopher6da55c02005-02-15 23:18:04 +00001899 if (token->flags & PREV_WHITE)
1900 len++; /* " " */
Neil Booth278c4662002-06-19 05:40:08 +00001901 }
Neil Booth93c803682000-10-28 17:59:06 +00001902 }
1903
1904 if (len > pfile->macro_buffer_len)
Alexandre Oliva4b49c362001-01-09 09:30:43 +00001905 {
Gabriel Dos Reisc3f829c2005-05-28 15:52:48 +00001906 pfile->macro_buffer = XRESIZEVEC (unsigned char,
1907 pfile->macro_buffer, len);
Alexandre Oliva4b49c362001-01-09 09:30:43 +00001908 pfile->macro_buffer_len = len;
1909 }
Neil Booth70961712001-06-23 11:34:41 +00001910
1911 /* Fill in the buffer. Start with the macro name. */
Neil Booth93c803682000-10-28 17:59:06 +00001912 buffer = pfile->macro_buffer;
Neil Booth70961712001-06-23 11:34:41 +00001913 memcpy (buffer, NODE_NAME (node), NODE_LEN (node));
1914 buffer += NODE_LEN (node);
Neil Booth93c803682000-10-28 17:59:06 +00001915
1916 /* Parameter names. */
1917 if (macro->fun_like)
1918 {
1919 *buffer++ = '(';
1920 for (i = 0; i < macro->paramc; i++)
1921 {
1922 cpp_hashnode *param = macro->params[i];
1923
1924 if (param != pfile->spec_nodes.n__VA_ARGS__)
1925 {
Neil Bootha28c50352001-05-16 22:02:09 +00001926 memcpy (buffer, NODE_NAME (param), NODE_LEN (param));
1927 buffer += NODE_LEN (param);
Neil Booth93c803682000-10-28 17:59:06 +00001928 }
1929
1930 if (i + 1 < macro->paramc)
Kazu Hiratadf383482002-05-22 22:02:16 +00001931 /* Don't emit a space after the comma here; we're trying
1932 to emit a Dwarf-friendly definition, and the Dwarf spec
1933 forbids spaces in the argument list. */
Jim Blandy64d08262002-04-05 00:12:40 +00001934 *buffer++ = ',';
Neil Booth28e0f042000-12-09 12:06:37 +00001935 else if (macro->variadic)
Neil Booth93c803682000-10-28 17:59:06 +00001936 *buffer++ = '.', *buffer++ = '.', *buffer++ = '.';
1937 }
1938 *buffer++ = ')';
1939 }
1940
Jim Blandye37b38d2002-03-19 21:43:39 +00001941 /* The Dwarf spec requires a space after the macro name, even if the
1942 definition is the empty string. */
1943 *buffer++ = ' ';
1944
Neil Booth278c4662002-06-19 05:40:08 +00001945 if (CPP_OPTION (pfile, traditional))
1946 buffer = _cpp_copy_replacement_text (macro, buffer);
1947 else if (macro->count)
Neil Booth93c803682000-10-28 17:59:06 +00001948 /* Expansion tokens. */
Neil Booth93c803682000-10-28 17:59:06 +00001949 {
Neil Booth93c803682000-10-28 17:59:06 +00001950 for (i = 0; i < macro->count; i++)
1951 {
Neil Booth601328b2002-05-16 05:53:24 +00001952 cpp_token *token = &macro->exp.tokens[i];
Neil Booth93c803682000-10-28 17:59:06 +00001953
1954 if (token->flags & PREV_WHITE)
1955 *buffer++ = ' ';
1956 if (token->flags & STRINGIFY_ARG)
1957 *buffer++ = '#';
1958
1959 if (token->type == CPP_MACRO_ARG)
1960 {
Neil Bootha28c50352001-05-16 22:02:09 +00001961 memcpy (buffer,
Eric Christopher6da55c02005-02-15 23:18:04 +00001962 NODE_NAME (macro->params[token->val.arg_no - 1]),
1963 NODE_LEN (macro->params[token->val.arg_no - 1]));
1964 buffer += NODE_LEN (macro->params[token->val.arg_no - 1]);
Neil Booth93c803682000-10-28 17:59:06 +00001965 }
1966 else
Geoffrey Keating47e20492005-03-12 10:44:06 +00001967 buffer = cpp_spell_token (pfile, token, buffer, false);
Neil Booth93c803682000-10-28 17:59:06 +00001968
1969 if (token->flags & PASTE_LEFT)
1970 {
1971 *buffer++ = ' ';
1972 *buffer++ = '#';
1973 *buffer++ = '#';
1974 /* Next has PREV_WHITE; see _cpp_create_definition. */
1975 }
1976 }
1977 }
1978
1979 *buffer = '\0';
1980 return pfile->macro_buffer;
1981}