blob: e051fbc7757b7e1d36bd11ed00c029c8e1e3a987 [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,
Joseph Myers148e4212009-03-29 23:56:07 +01004 2006, 2007, 2008, 2009 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
Jakub Jelinek748086b2009-04-09 17:00:19 +020011Free Software Foundation; either version 3, or (at your option) any
Zack Weinberg711b8822000-07-18 00:59:49 +000012later 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
Jakub Jelinek748086b2009-04-09 17:00:19 +020020along with this program; see the file COPYING3. If not see
21<http://www.gnu.org/licenses/>.
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;
Manuel López-Ibáñez1bb64662008-07-21 09:33:38 +0000121 linenum_type 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. */
Manuel López-Ibáñez1bb64662008-07-21 09:33:38 +0000203 number = SOURCE_LINE (map,
204 CPP_OPTION (pfile, traditional)
205 ? pfile->line_table->highest_line
206 : pfile->cur_token[-1].src_loc);
Neil Booth644edda2001-10-02 12:57:24 +0000207 break;
Neil Booth93c803682000-10-28 17:59:06 +0000208
Zack Weinberg5279d732002-05-16 19:03:02 +0000209 /* __STDC__ has the value 1 under normal circumstances.
210 However, if (a) we are in a system header, (b) the option
Zack Weinberg2a1dc0d2002-05-21 21:55:37 +0000211 stdc_0_in_system_headers is true (set by target config), and
212 (c) we are not in strictly conforming mode, then it has the
Jakub Jelinek83900992006-01-23 22:50:15 +0100213 value 0. (b) and (c) are already checked in cpp_init_builtins. */
Neil Booth93c803682000-10-28 17:59:06 +0000214 case BT_STDC:
Jakub Jelinek83900992006-01-23 22:50:15 +0100215 if (cpp_in_system_header (pfile))
216 number = 0;
217 else
218 number = 1;
Neil Booth644edda2001-10-02 12:57:24 +0000219 break;
Neil Booth93c803682000-10-28 17:59:06 +0000220
221 case BT_DATE:
222 case BT_TIME:
Neil Booth278c4662002-06-19 05:40:08 +0000223 if (pfile->date == NULL)
Neil Booth93c803682000-10-28 17:59:06 +0000224 {
Neil Booth4ed5bcf2001-09-24 22:53:12 +0000225 /* Allocate __DATE__ and __TIME__ strings from permanent
226 storage. We only do this once, and don't generate them
227 at init time, because time() and localtime() are very
228 slow on some systems. */
Zack Weinberg56da7202002-08-02 04:18:16 +0000229 time_t tt;
230 struct tm *tb = NULL;
Neil Booth93c803682000-10-28 17:59:06 +0000231
Zack Weinberg56da7202002-08-02 04:18:16 +0000232 /* (time_t) -1 is a legitimate value for "number of seconds
233 since the Epoch", so we have to do a little dance to
234 distinguish that from a genuine error. */
235 errno = 0;
236 tt = time(NULL);
237 if (tt != (time_t)-1 || errno == 0)
238 tb = localtime (&tt);
Neil Booth4ed5bcf2001-09-24 22:53:12 +0000239
Zack Weinberg56da7202002-08-02 04:18:16 +0000240 if (tb)
241 {
242 pfile->date = _cpp_unaligned_alloc (pfile,
243 sizeof ("\"Oct 11 1347\""));
244 sprintf ((char *) pfile->date, "\"%s %2d %4d\"",
Zack Weinberg6cf87ca2003-06-17 06:17:44 +0000245 monthnames[tb->tm_mon], tb->tm_mday,
246 tb->tm_year + 1900);
Zack Weinberg56da7202002-08-02 04:18:16 +0000247
248 pfile->time = _cpp_unaligned_alloc (pfile,
249 sizeof ("\"12:34:56\""));
250 sprintf ((char *) pfile->time, "\"%02d:%02d:%02d\"",
251 tb->tm_hour, tb->tm_min, tb->tm_sec);
252 }
253 else
254 {
John David Anglin0527bc42003-11-01 22:56:54 +0000255 cpp_errno (pfile, CPP_DL_WARNING,
Zack Weinberg56da7202002-08-02 04:18:16 +0000256 "could not determine date and time");
257
Kris Van Heesb6baa672008-04-18 13:58:08 +0000258 pfile->date = UC"\"??? ?? ????\"";
259 pfile->time = UC"\"??:??:??\"";
Zack Weinberg56da7202002-08-02 04:18:16 +0000260 }
Neil Booth93c803682000-10-28 17:59:06 +0000261 }
Neil Booth93c803682000-10-28 17:59:06 +0000262
Neil Booth644edda2001-10-02 12:57:24 +0000263 if (node->value.builtin == BT_DATE)
Neil Booth278c4662002-06-19 05:40:08 +0000264 result = pfile->date;
Neil Booth644edda2001-10-02 12:57:24 +0000265 else
Neil Booth278c4662002-06-19 05:40:08 +0000266 result = pfile->time;
Neil Booth644edda2001-10-02 12:57:24 +0000267 break;
Ollie Wilda7020452007-05-24 20:55:36 +0000268
269 case BT_COUNTER:
Ollie Wildccfc4c92007-07-30 18:29:20 +0000270 if (CPP_OPTION (pfile, directives_only) && pfile->state.in_directive)
271 cpp_error (pfile, CPP_DL_ERROR,
272 "__COUNTER__ expanded inside directive with -fdirectives-only");
Ollie Wilda7020452007-05-24 20:55:36 +0000273 number = pfile->counter++;
274 break;
Neil Booth278c4662002-06-19 05:40:08 +0000275 }
Neil Booth644edda2001-10-02 12:57:24 +0000276
Neil Booth278c4662002-06-19 05:40:08 +0000277 if (result == NULL)
278 {
279 /* 21 bytes holds all NUL-terminated unsigned 64-bit numbers. */
280 result = _cpp_unaligned_alloc (pfile, 21);
281 sprintf ((char *) result, "%u", number);
282 }
283
284 return result;
285}
286
287/* Convert builtin macros like __FILE__ to a token and push it on the
Zack Weinberg21b11492004-09-09 19:16:56 +0000288 context stack. Also handles _Pragma, for which a new token may not
289 be created. Returns 1 if it generates a new token context, 0 to
Neil Booth278c4662002-06-19 05:40:08 +0000290 return the token to the caller. */
291static int
Zack Weinberg6cf87ca2003-06-17 06:17:44 +0000292builtin_macro (cpp_reader *pfile, cpp_hashnode *node)
Neil Booth278c4662002-06-19 05:40:08 +0000293{
294 const uchar *buf;
Neil Booth26aea072003-04-19 00:22:51 +0000295 size_t len;
296 char *nbuf;
Neil Booth278c4662002-06-19 05:40:08 +0000297
298 if (node->value.builtin == BT_PRAGMA)
299 {
Neil Booth644edda2001-10-02 12:57:24 +0000300 /* Don't interpret _Pragma within directives. The standard is
301 not clear on this, but to me this makes most sense. */
302 if (pfile->state.in_directive)
303 return 0;
304
Tom Tromey5b9a40d2007-10-31 14:50:13 +0000305 return _cpp_do__Pragma (pfile);
Neil Booth93c803682000-10-28 17:59:06 +0000306 }
Neil Booth644edda2001-10-02 12:57:24 +0000307
Neil Booth278c4662002-06-19 05:40:08 +0000308 buf = _cpp_builtin_macro_text (pfile, node);
Neil Booth26aea072003-04-19 00:22:51 +0000309 len = ustrlen (buf);
Gabriel Dos Reisc3f829c2005-05-28 15:52:48 +0000310 nbuf = (char *) alloca (len + 1);
Neil Booth26aea072003-04-19 00:22:51 +0000311 memcpy (nbuf, buf, len);
312 nbuf[len]='\n';
Neil Booth278c4662002-06-19 05:40:08 +0000313
Per Bothner40de9f72003-10-02 07:30:34 +0000314 cpp_push_buffer (pfile, (uchar *) nbuf, len, /* from_stage3 */ true);
Neil Booth26aea072003-04-19 00:22:51 +0000315 _cpp_clean_line (pfile);
Neil Booth278c4662002-06-19 05:40:08 +0000316
317 /* Set pfile->cur_token as required by _cpp_lex_direct. */
318 pfile->cur_token = _cpp_temp_token (pfile);
Richard Hendersonbc4071d2006-01-04 08:33:38 -0800319 _cpp_push_token_context (pfile, NULL, _cpp_lex_direct (pfile), 1);
Neil Booth278c4662002-06-19 05:40:08 +0000320 if (pfile->buffer->cur != pfile->buffer->rlimit)
John David Anglin0527bc42003-11-01 22:56:54 +0000321 cpp_error (pfile, CPP_DL_ICE, "invalid built-in macro \"%s\"",
Neil Booth278c4662002-06-19 05:40:08 +0000322 NODE_NAME (node));
323 _cpp_pop_buffer (pfile);
324
Neil Booth644edda2001-10-02 12:57:24 +0000325 return 1;
Neil Booth93c803682000-10-28 17:59:06 +0000326}
327
Neil Boothd15a58c2002-01-03 18:32:55 +0000328/* Copies SRC, of length LEN, to DEST, adding backslashes before all
Andrew Pinski651ed942005-11-04 00:23:01 +0000329 backslashes and double quotes. DEST must be of sufficient size.
330 Returns a pointer to the end of the string. */
Neil Booth562a5c22002-04-21 18:46:42 +0000331uchar *
Zack Weinberg6cf87ca2003-06-17 06:17:44 +0000332cpp_quote_string (uchar *dest, const uchar *src, unsigned int len)
Neil Booth93c803682000-10-28 17:59:06 +0000333{
334 while (len--)
335 {
Neil Booth562a5c22002-04-21 18:46:42 +0000336 uchar c = *src++;
Neil Booth93c803682000-10-28 17:59:06 +0000337
338 if (c == '\\' || c == '"')
339 {
340 *dest++ = '\\';
341 *dest++ = c;
342 }
343 else
Andrew Pinski651ed942005-11-04 00:23:01 +0000344 *dest++ = c;
Neil Booth93c803682000-10-28 17:59:06 +0000345 }
346
347 return dest;
348}
349
Neil Boothd15a58c2002-01-03 18:32:55 +0000350/* Convert a token sequence ARG to a single string token according to
351 the rules of the ISO C #-operator. */
Neil Booth4ed5bcf2001-09-24 22:53:12 +0000352static const cpp_token *
Zack Weinberg6cf87ca2003-06-17 06:17:44 +0000353stringify_arg (cpp_reader *pfile, macro_arg *arg)
Neil Booth93c803682000-10-28 17:59:06 +0000354{
Neil Booth6338b352003-04-23 22:44:06 +0000355 unsigned char *dest;
Neil Boothece54d52001-09-28 09:40:22 +0000356 unsigned int i, escape_it, backslash_count = 0;
Neil Booth4ed5bcf2001-09-24 22:53:12 +0000357 const cpp_token *source = NULL;
Neil Boothece54d52001-09-28 09:40:22 +0000358 size_t len;
Neil Booth93c803682000-10-28 17:59:06 +0000359
Neil Booth6338b352003-04-23 22:44:06 +0000360 if (BUFF_ROOM (pfile->u_buff) < 3)
361 _cpp_extend_buff (pfile, &pfile->u_buff, 3);
362 dest = BUFF_FRONT (pfile->u_buff);
363 *dest++ = '"';
364
Neil Booth93c803682000-10-28 17:59:06 +0000365 /* Loop, reading in the argument's tokens. */
366 for (i = 0; i < arg->count; i++)
367 {
Neil Booth4ed5bcf2001-09-24 22:53:12 +0000368 const cpp_token *token = arg->first[i];
Neil Booth4ed5bcf2001-09-24 22:53:12 +0000369
370 if (token->type == CPP_PADDING)
371 {
Joseph Myers18f41a12009-04-12 23:20:02 +0100372 if (source == NULL
373 || (!(source->flags & PREV_WHITE)
374 && token->val.source == NULL))
Neil Booth4ed5bcf2001-09-24 22:53:12 +0000375 source = token->val.source;
376 continue;
377 }
Neil Booth93c803682000-10-28 17:59:06 +0000378
Kris Van Heesb6baa672008-04-18 13:58:08 +0000379 escape_it = (token->type == CPP_STRING || token->type == CPP_CHAR
380 || token->type == CPP_WSTRING || token->type == CPP_STRING
381 || token->type == CPP_STRING32 || token->type == CPP_CHAR32
382 || token->type == CPP_STRING16 || token->type == CPP_CHAR16);
Neil Booth93c803682000-10-28 17:59:06 +0000383
Neil Boothece54d52001-09-28 09:40:22 +0000384 /* Room for each char being written in octal, initial space and
Neil Booth6338b352003-04-23 22:44:06 +0000385 final quote and NUL. */
Neil Booth4ed5bcf2001-09-24 22:53:12 +0000386 len = cpp_token_len (token);
Neil Booth93c803682000-10-28 17:59:06 +0000387 if (escape_it)
Neil Booth93c803682000-10-28 17:59:06 +0000388 len *= 4;
Neil Booth6338b352003-04-23 22:44:06 +0000389 len += 3;
Neil Booth93c803682000-10-28 17:59:06 +0000390
Neil Boothece54d52001-09-28 09:40:22 +0000391 if ((size_t) (BUFF_LIMIT (pfile->u_buff) - dest) < len)
Neil Booth93c803682000-10-28 17:59:06 +0000392 {
Neil Boothece54d52001-09-28 09:40:22 +0000393 size_t len_so_far = dest - BUFF_FRONT (pfile->u_buff);
Neil Booth8c3b2692001-09-30 10:03:11 +0000394 _cpp_extend_buff (pfile, &pfile->u_buff, len);
Neil Boothece54d52001-09-28 09:40:22 +0000395 dest = BUFF_FRONT (pfile->u_buff) + len_so_far;
Neil Booth93c803682000-10-28 17:59:06 +0000396 }
397
Neil Booth4ed5bcf2001-09-24 22:53:12 +0000398 /* Leading white space? */
Neil Booth6338b352003-04-23 22:44:06 +0000399 if (dest - 1 != BUFF_FRONT (pfile->u_buff))
Neil Booth4ed5bcf2001-09-24 22:53:12 +0000400 {
401 if (source == NULL)
402 source = token;
403 if (source->flags & PREV_WHITE)
404 *dest++ = ' ';
405 }
406 source = NULL;
Neil Booth93c803682000-10-28 17:59:06 +0000407
408 if (escape_it)
409 {
Neil Boothece54d52001-09-28 09:40:22 +0000410 _cpp_buff *buff = _cpp_get_buff (pfile, len);
411 unsigned char *buf = BUFF_FRONT (buff);
Geoffrey Keating47e20492005-03-12 10:44:06 +0000412 len = cpp_spell_token (pfile, token, buf, true) - buf;
Zack Weinbergdcc229e2002-03-14 18:17:18 +0000413 dest = cpp_quote_string (dest, buf, len);
Neil Boothece54d52001-09-28 09:40:22 +0000414 _cpp_release_buff (pfile, buff);
Neil Booth93c803682000-10-28 17:59:06 +0000415 }
416 else
Geoffrey Keating47e20492005-03-12 10:44:06 +0000417 dest = cpp_spell_token (pfile, token, dest, true);
Neil Booth93c803682000-10-28 17:59:06 +0000418
Neil Booth10676942003-04-22 19:28:00 +0000419 if (token->type == CPP_OTHER && token->val.str.text[0] == '\\')
Neil Booth93c803682000-10-28 17:59:06 +0000420 backslash_count++;
421 else
422 backslash_count = 0;
423 }
424
425 /* Ignore the final \ of invalid string literals. */
426 if (backslash_count & 1)
427 {
John David Anglin0527bc42003-11-01 22:56:54 +0000428 cpp_error (pfile, CPP_DL_WARNING,
Neil Boothebef4e82002-04-14 18:42:47 +0000429 "invalid string literal, ignoring final '\\'");
Neil Boothece54d52001-09-28 09:40:22 +0000430 dest--;
Neil Booth93c803682000-10-28 17:59:06 +0000431 }
432
Neil Booth4ed5bcf2001-09-24 22:53:12 +0000433 /* Commit the memory, including NUL, and return the token. */
Neil Booth6338b352003-04-23 22:44:06 +0000434 *dest++ = '"';
Neil Boothece54d52001-09-28 09:40:22 +0000435 len = dest - BUFF_FRONT (pfile->u_buff);
436 BUFF_FRONT (pfile->u_buff) = dest + 1;
437 return new_string_token (pfile, dest - len, len);
Neil Booth93c803682000-10-28 17:59:06 +0000438}
439
Kazu Hiratada7d8302002-09-22 02:03:17 +0000440/* Try to paste two tokens. On success, return nonzero. In any
Neil Boothc9e7a602001-09-27 12:59:38 +0000441 case, PLHS is updated to point to the pasted token, which is
442 guaranteed to not have the PASTE_LEFT flag set. */
443static bool
Zack Weinberg6cf87ca2003-06-17 06:17:44 +0000444paste_tokens (cpp_reader *pfile, const cpp_token **plhs, const cpp_token *rhs)
Neil Boothd63eefb2000-11-20 23:59:26 +0000445{
Jakub Jelinekde000d22006-10-12 11:25:59 +0200446 unsigned char *buf, *end, *lhsend;
Tom Tromeyfca35e12007-05-02 19:33:44 +0000447 cpp_token *lhs;
Neil Boothc9e7a602001-09-27 12:59:38 +0000448 unsigned int len;
Neil Boothd63eefb2000-11-20 23:59:26 +0000449
Tom Tromeyfca35e12007-05-02 19:33:44 +0000450 len = cpp_token_len (*plhs) + cpp_token_len (rhs) + 1;
Gabriel Dos Reisc3f829c2005-05-28 15:52:48 +0000451 buf = (unsigned char *) alloca (len);
Tom Tromeyfca35e12007-05-02 19:33:44 +0000452 end = lhsend = cpp_spell_token (pfile, *plhs, buf, false);
Neil Boothd63eefb2000-11-20 23:59:26 +0000453
Neil Boothc9e7a602001-09-27 12:59:38 +0000454 /* Avoid comment headers, since they are still processed in stage 3.
455 It is simpler to insert a space here, rather than modifying the
456 lexer to ignore comments in some circumstances. Simply returning
457 false doesn't work, since we want to clear the PASTE_LEFT flag. */
Tom Tromeyfca35e12007-05-02 19:33:44 +0000458 if ((*plhs)->type == CPP_DIV && rhs->type != CPP_EQ)
Neil Boothc9e7a602001-09-27 12:59:38 +0000459 *end++ = ' ';
Tom Tromeyf373b442007-11-01 18:20:48 +0000460 /* In one obscure case we might see padding here. */
461 if (rhs->type != CPP_PADDING)
462 end = cpp_spell_token (pfile, rhs, end, false);
Neil Booth26aea072003-04-19 00:22:51 +0000463 *end = '\n';
Neil Boothd63eefb2000-11-20 23:59:26 +0000464
Per Bothner40de9f72003-10-02 07:30:34 +0000465 cpp_push_buffer (pfile, buf, end - buf, /* from_stage3 */ true);
Neil Booth26aea072003-04-19 00:22:51 +0000466 _cpp_clean_line (pfile);
Neil Boothd63eefb2000-11-20 23:59:26 +0000467
Neil Boothc9e7a602001-09-27 12:59:38 +0000468 /* Set pfile->cur_token as required by _cpp_lex_direct. */
469 pfile->cur_token = _cpp_temp_token (pfile);
Tom Tromeyfca35e12007-05-02 19:33:44 +0000470 lhs = _cpp_lex_direct (pfile);
Jakub Jelinekde000d22006-10-12 11:25:59 +0200471 if (pfile->buffer->cur != pfile->buffer->rlimit)
472 {
Tom Tromeyfca35e12007-05-02 19:33:44 +0000473 source_location saved_loc = lhs->src_loc;
474
Jakub Jelinekde000d22006-10-12 11:25:59 +0200475 _cpp_pop_buffer (pfile);
476 _cpp_backup_tokens (pfile, 1);
477 *lhsend = '\0';
Neil Boothd63eefb2000-11-20 23:59:26 +0000478
Tom Tromeyfca35e12007-05-02 19:33:44 +0000479 /* We have to remove the PASTE_LEFT flag from the old lhs, but
480 we want to keep the new location. */
481 *lhs = **plhs;
482 *plhs = lhs;
483 lhs->src_loc = saved_loc;
484 lhs->flags &= ~PASTE_LEFT;
485
Jakub Jelinekde000d22006-10-12 11:25:59 +0200486 /* Mandatory error for all apart from assembler. */
487 if (CPP_OPTION (pfile, lang) != CLK_ASM)
488 cpp_error (pfile, CPP_DL_ERROR,
489 "pasting \"%s\" and \"%s\" does not give a valid preprocessing token",
490 buf, cpp_token_as_text (pfile, rhs));
491 return false;
492 }
493
Tom Tromeyfca35e12007-05-02 19:33:44 +0000494 *plhs = lhs;
Jakub Jelinekde000d22006-10-12 11:25:59 +0200495 _cpp_pop_buffer (pfile);
496 return true;
Neil Boothd63eefb2000-11-20 23:59:26 +0000497}
498
Neil Boothd15a58c2002-01-03 18:32:55 +0000499/* Handles an arbitrarily long sequence of ## operators, with initial
500 operand LHS. This implementation is left-associative,
501 non-recursive, and finishes a paste before handling succeeding
502 ones. If a paste fails, we back up to the RHS of the failing ##
503 operator before pushing the context containing the result of prior
504 successful pastes, with the effect that the RHS appears in the
505 output stream after the pasted LHS normally. */
Neil Booth93c803682000-10-28 17:59:06 +0000506static void
Zack Weinberg6cf87ca2003-06-17 06:17:44 +0000507paste_all_tokens (cpp_reader *pfile, const cpp_token *lhs)
Neil Booth93c803682000-10-28 17:59:06 +0000508{
Neil Booth4ed5bcf2001-09-24 22:53:12 +0000509 const cpp_token *rhs;
510 cpp_context *context = pfile->context;
511
Neil Booth93c803682000-10-28 17:59:06 +0000512 do
513 {
514 /* Take the token directly from the current context. We can do
515 this, because we are in the replacement list of either an
516 object-like macro, or a function-like macro with arguments
517 inserted. In either case, the constraints to #define
Neil Boothd63eefb2000-11-20 23:59:26 +0000518 guarantee we have at least one more token. */
Neil Booth4ed5bcf2001-09-24 22:53:12 +0000519 if (context->direct_p)
Neil Booth82eda772002-06-04 13:07:06 +0000520 rhs = FIRST (context).token++;
Neil Booth4ed5bcf2001-09-24 22:53:12 +0000521 else
Neil Booth82eda772002-06-04 13:07:06 +0000522 rhs = *FIRST (context).ptoken++;
Neil Booth4ed5bcf2001-09-24 22:53:12 +0000523
524 if (rhs->type == CPP_PADDING)
Tom Tromeyf373b442007-11-01 18:20:48 +0000525 {
526 if (rhs->flags & PASTE_LEFT)
527 abort ();
528 }
Neil Boothc9e7a602001-09-27 12:59:38 +0000529 if (!paste_tokens (pfile, &lhs, rhs))
Jakub Jelinekde000d22006-10-12 11:25:59 +0200530 break;
Neil Booth93c803682000-10-28 17:59:06 +0000531 }
532 while (rhs->flags & PASTE_LEFT);
533
Neil Boothc9e7a602001-09-27 12:59:38 +0000534 /* Put the resulting token in its own context. */
Richard Hendersonbc4071d2006-01-04 08:33:38 -0800535 _cpp_push_token_context (pfile, NULL, lhs, 1);
Neil Booth93c803682000-10-28 17:59:06 +0000536}
537
Neil Booth1ce676a2002-06-09 20:04:17 +0000538/* Returns TRUE if the number of arguments ARGC supplied in an
539 invocation of the MACRO referenced by NODE is valid. An empty
540 invocation to a macro with no parameters should pass ARGC as zero.
541
542 Note that MACRO cannot necessarily be deduced from NODE, in case
543 NODE was redefined whilst collecting arguments. */
544bool
Zack Weinberg6cf87ca2003-06-17 06:17:44 +0000545_cpp_arguments_ok (cpp_reader *pfile, cpp_macro *macro, const cpp_hashnode *node, unsigned int argc)
Neil Booth1ce676a2002-06-09 20:04:17 +0000546{
547 if (argc == macro->paramc)
548 return true;
549
550 if (argc < macro->paramc)
551 {
552 /* As an extension, a rest argument is allowed to not appear in
553 the invocation at all.
554 e.g. #define debug(format, args...) something
555 debug("string");
556
557 This is exactly the same as if there had been an empty rest
558 argument - debug("string", ). */
559
560 if (argc + 1 == macro->paramc && macro->variadic)
561 {
562 if (CPP_PEDANTIC (pfile) && ! macro->syshdr)
John David Anglin0527bc42003-11-01 22:56:54 +0000563 cpp_error (pfile, CPP_DL_PEDWARN,
Neil Booth1ce676a2002-06-09 20:04:17 +0000564 "ISO C99 requires rest arguments to be used");
565 return true;
566 }
567
John David Anglin0527bc42003-11-01 22:56:54 +0000568 cpp_error (pfile, CPP_DL_ERROR,
Neil Booth1ce676a2002-06-09 20:04:17 +0000569 "macro \"%s\" requires %u arguments, but only %u given",
570 NODE_NAME (node), macro->paramc, argc);
571 }
572 else
John David Anglin0527bc42003-11-01 22:56:54 +0000573 cpp_error (pfile, CPP_DL_ERROR,
Neil Booth1ce676a2002-06-09 20:04:17 +0000574 "macro \"%s\" passed %u arguments, but takes just %u",
575 NODE_NAME (node), argc, macro->paramc);
576
577 return false;
578}
579
Neil Boothd15a58c2002-01-03 18:32:55 +0000580/* Reads and returns the arguments to a function-like macro
581 invocation. Assumes the opening parenthesis has been processed.
582 If there is an error, emits an appropriate diagnostic and returns
583 NULL. Each argument is terminated by a CPP_EOF token, for the
Jakub Jelinek765d6002008-01-25 10:01:27 +0100584 future benefit of expand_arg(). If there are any deferred
585 #pragma directives among macro arguments, store pointers to the
586 CPP_PRAGMA ... CPP_PRAGMA_EOL tokens into *PRAGMA_BUFF buffer. */
Neil Boothb8af0ca2001-09-26 17:52:50 +0000587static _cpp_buff *
Jakub Jelinek765d6002008-01-25 10:01:27 +0100588collect_args (cpp_reader *pfile, const cpp_hashnode *node,
589 _cpp_buff **pragma_buff)
Neil Booth93c803682000-10-28 17:59:06 +0000590{
Neil Boothb8af0ca2001-09-26 17:52:50 +0000591 _cpp_buff *buff, *base_buff;
592 cpp_macro *macro;
593 macro_arg *args, *arg;
594 const cpp_token *token;
595 unsigned int argc;
Neil Booth93c803682000-10-28 17:59:06 +0000596
Neil Boothb8af0ca2001-09-26 17:52:50 +0000597 macro = node->value.macro;
598 if (macro->paramc)
599 argc = macro->paramc;
600 else
601 argc = 1;
602 buff = _cpp_get_buff (pfile, argc * (50 * sizeof (cpp_token *)
603 + sizeof (macro_arg)));
604 base_buff = buff;
605 args = (macro_arg *) buff->base;
606 memset (args, 0, argc * sizeof (macro_arg));
Neil Boothece54d52001-09-28 09:40:22 +0000607 buff->cur = (unsigned char *) &args[argc];
Neil Boothb8af0ca2001-09-26 17:52:50 +0000608 arg = args, argc = 0;
Neil Booth93c803682000-10-28 17:59:06 +0000609
Neil Boothb8af0ca2001-09-26 17:52:50 +0000610 /* Collect the tokens making up each argument. We don't yet know
611 how many arguments have been supplied, whether too many or too
612 few. Hence the slightly bizarre usage of "argc" and "arg". */
613 do
Neil Booth93c803682000-10-28 17:59:06 +0000614 {
Neil Boothb8af0ca2001-09-26 17:52:50 +0000615 unsigned int paren_depth = 0;
616 unsigned int ntokens = 0;
617
Neil Booth93c803682000-10-28 17:59:06 +0000618 argc++;
Neil Boothb8af0ca2001-09-26 17:52:50 +0000619 arg->first = (const cpp_token **) buff->cur;
Neil Booth93c803682000-10-28 17:59:06 +0000620
Neil Boothb8af0ca2001-09-26 17:52:50 +0000621 for (;;)
622 {
623 /* Require space for 2 new tokens (including a CPP_EOF). */
Neil Boothece54d52001-09-28 09:40:22 +0000624 if ((unsigned char *) &arg->first[ntokens + 2] > buff->limit)
Neil Boothb8af0ca2001-09-26 17:52:50 +0000625 {
Neil Booth8c3b2692001-09-30 10:03:11 +0000626 buff = _cpp_append_extend_buff (pfile, buff,
627 1000 * sizeof (cpp_token *));
Neil Boothb8af0ca2001-09-26 17:52:50 +0000628 arg->first = (const cpp_token **) buff->cur;
629 }
Neil Booth93c803682000-10-28 17:59:06 +0000630
Neil Boothb8af0ca2001-09-26 17:52:50 +0000631 token = cpp_get_token (pfile);
632
633 if (token->type == CPP_PADDING)
634 {
635 /* Drop leading padding. */
636 if (ntokens == 0)
637 continue;
638 }
639 else if (token->type == CPP_OPEN_PAREN)
640 paren_depth++;
641 else if (token->type == CPP_CLOSE_PAREN)
642 {
643 if (paren_depth-- == 0)
644 break;
645 }
646 else if (token->type == CPP_COMMA)
647 {
648 /* A comma does not terminate an argument within
649 parentheses or as part of a variable argument. */
650 if (paren_depth == 0
651 && ! (macro->variadic && argc == macro->paramc))
652 break;
653 }
654 else if (token->type == CPP_EOF
655 || (token->type == CPP_HASH && token->flags & BOL))
656 break;
Jakub Jelinek765d6002008-01-25 10:01:27 +0100657 else if (token->type == CPP_PRAGMA)
658 {
659 cpp_token *newtok = _cpp_temp_token (pfile);
660
661 /* CPP_PRAGMA token lives in directive_result, which will
662 be overwritten on the next directive. */
663 *newtok = *token;
664 token = newtok;
665 do
666 {
667 if (*pragma_buff == NULL
668 || BUFF_ROOM (*pragma_buff) < sizeof (cpp_token *))
669 {
670 _cpp_buff *next;
671 if (*pragma_buff == NULL)
672 *pragma_buff
673 = _cpp_get_buff (pfile, 32 * sizeof (cpp_token *));
674 else
675 {
676 next = *pragma_buff;
677 *pragma_buff
678 = _cpp_get_buff (pfile,
679 (BUFF_FRONT (*pragma_buff)
680 - (*pragma_buff)->base) * 2);
681 (*pragma_buff)->next = next;
682 }
683 }
684 *(const cpp_token **) BUFF_FRONT (*pragma_buff) = token;
685 BUFF_FRONT (*pragma_buff) += sizeof (cpp_token *);
686 if (token->type == CPP_PRAGMA_EOL)
687 break;
688 token = cpp_get_token (pfile);
689 }
690 while (token->type != CPP_EOF);
691
692 /* In deferred pragmas parsing_args and prevent_expansion
693 had been changed, reset it. */
694 pfile->state.parsing_args = 2;
695 pfile->state.prevent_expansion = 1;
696
697 if (token->type == CPP_EOF)
698 break;
699 else
700 continue;
701 }
Neil Boothb8af0ca2001-09-26 17:52:50 +0000702
703 arg->first[ntokens++] = token;
704 }
705
706 /* Drop trailing padding. */
707 while (ntokens > 0 && arg->first[ntokens - 1]->type == CPP_PADDING)
708 ntokens--;
709
710 arg->count = ntokens;
711 arg->first[ntokens] = &pfile->eof;
712
713 /* Terminate the argument. Excess arguments loop back and
714 overwrite the final legitimate argument, before failing. */
715 if (argc <= macro->paramc)
716 {
Neil Boothece54d52001-09-28 09:40:22 +0000717 buff->cur = (unsigned char *) &arg->first[ntokens + 1];
Neil Boothb8af0ca2001-09-26 17:52:50 +0000718 if (argc != macro->paramc)
719 arg++;
720 }
Neil Booth93c803682000-10-28 17:59:06 +0000721 }
Neil Boothe808ec92002-02-27 07:24:53 +0000722 while (token->type != CPP_CLOSE_PAREN && token->type != CPP_EOF);
Neil Booth93c803682000-10-28 17:59:06 +0000723
Neil Boothe808ec92002-02-27 07:24:53 +0000724 if (token->type == CPP_EOF)
Neil Booth93c803682000-10-28 17:59:06 +0000725 {
Neil Boothece54d52001-09-28 09:40:22 +0000726 /* We still need the CPP_EOF to end directives, and to end
727 pre-expansion of a macro argument. Step back is not
728 unconditional, since we don't want to return a CPP_EOF to our
729 callers at the end of an -include-d file. */
Neil Boothe808ec92002-02-27 07:24:53 +0000730 if (pfile->context->prev || pfile->state.in_directive)
Neil Boothb8af0ca2001-09-26 17:52:50 +0000731 _cpp_backup_tokens (pfile, 1);
John David Anglin0527bc42003-11-01 22:56:54 +0000732 cpp_error (pfile, CPP_DL_ERROR,
Neil Boothebef4e82002-04-14 18:42:47 +0000733 "unterminated argument list invoking macro \"%s\"",
Neil Bootha28c50352001-05-16 22:02:09 +0000734 NODE_NAME (node));
Neil Booth93c803682000-10-28 17:59:06 +0000735 }
Neil Booth1ce676a2002-06-09 20:04:17 +0000736 else
Neil Booth93c803682000-10-28 17:59:06 +0000737 {
Neil Booth1ce676a2002-06-09 20:04:17 +0000738 /* A single empty argument is counted as no argument. */
739 if (argc == 1 && macro->paramc == 0 && args[0].count == 0)
740 argc = 0;
741 if (_cpp_arguments_ok (pfile, macro, node, argc))
Neil Booth58551c22002-08-06 20:35:46 +0000742 {
743 /* GCC has special semantics for , ## b where b is a varargs
744 parameter: we remove the comma if b was omitted entirely.
745 If b was merely an empty argument, the comma is retained.
746 If the macro takes just one (varargs) parameter, then we
747 retain the comma only if we are standards conforming.
748
749 If FIRST is NULL replace_args () swallows the comma. */
750 if (macro->variadic && (argc < macro->paramc
751 || (argc == 1 && args[0].count == 0
752 && !CPP_OPTION (pfile, std))))
753 args[macro->paramc - 1].first = NULL;
754 return base_buff;
755 }
Neil Booth93c803682000-10-28 17:59:06 +0000756 }
757
Neil Booth1ce676a2002-06-09 20:04:17 +0000758 /* An error occurred. */
Neil Boothb8af0ca2001-09-26 17:52:50 +0000759 _cpp_release_buff (pfile, base_buff);
760 return NULL;
Neil Booth93c803682000-10-28 17:59:06 +0000761}
762
Neil Boothd6da8362001-10-08 06:15:14 +0000763/* Search for an opening parenthesis to the macro of NODE, in such a
764 way that, if none is found, we don't lose the information in any
765 intervening padding tokens. If we find the parenthesis, collect
Jakub Jelinek765d6002008-01-25 10:01:27 +0100766 the arguments and return the buffer containing them. PRAGMA_BUFF
767 argument is the same as in collect_args. */
Neil Boothd6da8362001-10-08 06:15:14 +0000768static _cpp_buff *
Jakub Jelinek765d6002008-01-25 10:01:27 +0100769funlike_invocation_p (cpp_reader *pfile, cpp_hashnode *node,
770 _cpp_buff **pragma_buff)
Neil Booth93c803682000-10-28 17:59:06 +0000771{
Neil Boothd6da8362001-10-08 06:15:14 +0000772 const cpp_token *token, *padding = NULL;
Neil Booth93c803682000-10-28 17:59:06 +0000773
Neil Boothd6da8362001-10-08 06:15:14 +0000774 for (;;)
Neil Boothbdcbe492001-09-13 20:05:17 +0000775 {
Neil Boothd6da8362001-10-08 06:15:14 +0000776 token = cpp_get_token (pfile);
777 if (token->type != CPP_PADDING)
778 break;
779 if (padding == NULL
780 || (!(padding->flags & PREV_WHITE) && token->val.source == NULL))
781 padding = token;
Neil Boothbdcbe492001-09-13 20:05:17 +0000782 }
Neil Booth93c803682000-10-28 17:59:06 +0000783
Neil Boothd6da8362001-10-08 06:15:14 +0000784 if (token->type == CPP_OPEN_PAREN)
Neil Booth93c803682000-10-28 17:59:06 +0000785 {
Neil Boothd6da8362001-10-08 06:15:14 +0000786 pfile->state.parsing_args = 2;
Jakub Jelinek765d6002008-01-25 10:01:27 +0100787 return collect_args (pfile, node, pragma_buff);
Neil Booth93c803682000-10-28 17:59:06 +0000788 }
789
Neil Booth9ac3b1b2002-04-21 16:17:55 +0000790 /* CPP_EOF can be the end of macro arguments, or the end of the
791 file. We mustn't back up over the latter. Ugh. */
792 if (token->type != CPP_EOF || token == &pfile->eof)
793 {
794 /* Back up. We may have skipped padding, in which case backing
795 up more than one token when expanding macros is in general
796 too difficult. We re-insert it in its own context. */
797 _cpp_backup_tokens (pfile, 1);
798 if (padding)
Richard Hendersonbc4071d2006-01-04 08:33:38 -0800799 _cpp_push_token_context (pfile, NULL, padding, 1);
Neil Booth9ac3b1b2002-04-21 16:17:55 +0000800 }
Neil Boothd6da8362001-10-08 06:15:14 +0000801
802 return NULL;
Neil Booth93c803682000-10-28 17:59:06 +0000803}
804
Joseph Myersaa508502009-04-19 18:10:56 +0100805/* Return the real number of tokens in the expansion of MACRO. */
806static inline unsigned int
807macro_real_token_count (const cpp_macro *macro)
808{
809 unsigned int i;
810 if (__builtin_expect (!macro->extra_tokens, true))
811 return macro->count;
812 for (i = 0; i < macro->count; i++)
813 if (macro->exp.tokens[i].type == CPP_PASTE)
814 return i;
815 abort ();
816}
817
Neil Boothd15a58c2002-01-03 18:32:55 +0000818/* Push the context of a macro with hash entry NODE onto the context
819 stack. If we can successfully expand the macro, we push a context
820 containing its yet-to-be-rescanned replacement list and return one.
Jakub Jelinek765d6002008-01-25 10:01:27 +0100821 If there were additionally any unexpanded deferred #pragma directives
822 among macro arguments, push another context containing the
823 pragma tokens before the yet-to-be-rescanned replacement list
824 and return two. Otherwise, we don't push a context and return zero. */
Neil Booth93c803682000-10-28 17:59:06 +0000825static int
Jakub Jelinek765d6002008-01-25 10:01:27 +0100826enter_macro_context (cpp_reader *pfile, cpp_hashnode *node,
827 const cpp_token *result)
Neil Booth93c803682000-10-28 17:59:06 +0000828{
Neil Boothd15a58c2002-01-03 18:32:55 +0000829 /* The presence of a macro invalidates a file's controlling macro. */
Neil Booth644edda2001-10-02 12:57:24 +0000830 pfile->mi_valid = false;
831
Neil Booth36207112002-05-24 19:26:30 +0000832 pfile->state.angled_headers = false;
833
Joseph Myers93d45d92008-04-02 20:42:53 +0100834 if ((node->flags & NODE_BUILTIN) && !(node->flags & NODE_USED))
835 {
836 node->flags |= NODE_USED;
837 if (pfile->cb.used_define)
838 pfile->cb.used_define (pfile, pfile->directive_line, node);
839 }
840
Neil Boothd15a58c2002-01-03 18:32:55 +0000841 /* Handle standard macros. */
Neil Booth644edda2001-10-02 12:57:24 +0000842 if (! (node->flags & NODE_BUILTIN))
Neil Booth93c803682000-10-28 17:59:06 +0000843 {
Neil Booth4ed5bcf2001-09-24 22:53:12 +0000844 cpp_macro *macro = node->value.macro;
Jakub Jelinek765d6002008-01-25 10:01:27 +0100845 _cpp_buff *pragma_buff = NULL;
Neil Booth4ed5bcf2001-09-24 22:53:12 +0000846
Neil Boothd6da8362001-10-08 06:15:14 +0000847 if (macro->fun_like)
848 {
849 _cpp_buff *buff;
850
851 pfile->state.prevent_expansion++;
852 pfile->keep_tokens++;
853 pfile->state.parsing_args = 1;
Jakub Jelinek765d6002008-01-25 10:01:27 +0100854 buff = funlike_invocation_p (pfile, node, &pragma_buff);
Neil Boothd6da8362001-10-08 06:15:14 +0000855 pfile->state.parsing_args = 0;
856 pfile->keep_tokens--;
857 pfile->state.prevent_expansion--;
858
859 if (buff == NULL)
860 {
861 if (CPP_WTRADITIONAL (pfile) && ! node->value.macro->syshdr)
John David Anglin0527bc42003-11-01 22:56:54 +0000862 cpp_error (pfile, CPP_DL_WARNING,
Neil Boothd6da8362001-10-08 06:15:14 +0000863 "function-like macro \"%s\" must be used with arguments in traditional C",
Neil Boothebef4e82002-04-14 18:42:47 +0000864 NODE_NAME (node));
Neil Boothd6da8362001-10-08 06:15:14 +0000865
Jakub Jelinek765d6002008-01-25 10:01:27 +0100866 if (pragma_buff)
867 _cpp_release_buff (pfile, pragma_buff);
868
Neil Boothd6da8362001-10-08 06:15:14 +0000869 return 0;
870 }
871
Neil Boothe808ec92002-02-27 07:24:53 +0000872 if (macro->paramc > 0)
873 replace_args (pfile, node, macro, (macro_arg *) buff->base);
Neil Boothd6da8362001-10-08 06:15:14 +0000874 _cpp_release_buff (pfile, buff);
875 }
Neil Booth4ed5bcf2001-09-24 22:53:12 +0000876
877 /* Disable the macro within its expansion. */
Neil Booth644edda2001-10-02 12:57:24 +0000878 node->flags |= NODE_DISABLED;
Neil Booth4ed5bcf2001-09-24 22:53:12 +0000879
Joseph Myers93d45d92008-04-02 20:42:53 +0100880 if (!(node->flags & NODE_USED))
881 {
882 node->flags |= NODE_USED;
883 if (pfile->cb.used_define)
884 pfile->cb.used_define (pfile, pfile->directive_line, node);
885 }
886
Neil Bootha69cbaa2002-07-23 22:57:49 +0000887 macro->used = 1;
888
Neil Booth4ed5bcf2001-09-24 22:53:12 +0000889 if (macro->paramc == 0)
Joseph Myersaa508502009-04-19 18:10:56 +0100890 _cpp_push_token_context (pfile, node, macro->exp.tokens,
891 macro_real_token_count (macro));
Neil Booth644edda2001-10-02 12:57:24 +0000892
Jakub Jelinek765d6002008-01-25 10:01:27 +0100893 if (pragma_buff)
894 {
895 if (!pfile->state.in_directive)
896 _cpp_push_token_context (pfile, NULL,
897 padding_token (pfile, result), 1);
898 do
899 {
900 _cpp_buff *tail = pragma_buff->next;
901 pragma_buff->next = NULL;
902 push_ptoken_context (pfile, NULL, pragma_buff,
903 (const cpp_token **) pragma_buff->base,
904 ((const cpp_token **) BUFF_FRONT (pragma_buff)
905 - (const cpp_token **) pragma_buff->base));
906 pragma_buff = tail;
907 }
908 while (pragma_buff != NULL);
909 return 2;
910 }
911
Neil Booth644edda2001-10-02 12:57:24 +0000912 return 1;
Neil Booth93c803682000-10-28 17:59:06 +0000913 }
Neil Booth644edda2001-10-02 12:57:24 +0000914
Neil Boothd15a58c2002-01-03 18:32:55 +0000915 /* Handle built-in macros and the _Pragma operator. */
Neil Booth644edda2001-10-02 12:57:24 +0000916 return builtin_macro (pfile, node);
Zack Weinberg711b8822000-07-18 00:59:49 +0000917}
918
Neil Boothd15a58c2002-01-03 18:32:55 +0000919/* Replace the parameters in a function-like macro of NODE with the
920 actual ARGS, and place the result in a newly pushed token context.
921 Expand each argument before replacing, unless it is operated upon
922 by the # or ## operators. */
Neil Booth93c803682000-10-28 17:59:06 +0000923static void
Zack Weinberg6cf87ca2003-06-17 06:17:44 +0000924replace_args (cpp_reader *pfile, cpp_hashnode *node, cpp_macro *macro, macro_arg *args)
Neil Booth93c803682000-10-28 17:59:06 +0000925{
926 unsigned int i, total;
927 const cpp_token *src, *limit;
Neil Booth4ed5bcf2001-09-24 22:53:12 +0000928 const cpp_token **dest, **first;
Neil Booth93c803682000-10-28 17:59:06 +0000929 macro_arg *arg;
Neil Booth1e013d22001-09-26 21:44:35 +0000930 _cpp_buff *buff;
Joseph Myersaa508502009-04-19 18:10:56 +0100931 unsigned int count;
Neil Booth93c803682000-10-28 17:59:06 +0000932
Neil Booth93c803682000-10-28 17:59:06 +0000933 /* First, fully macro-expand arguments, calculating the number of
Neil Booth1e013d22001-09-26 21:44:35 +0000934 tokens in the final expansion as we go. The ordering of the if
935 statements below is subtle; we must handle stringification before
936 pasting. */
Joseph Myersaa508502009-04-19 18:10:56 +0100937 count = macro_real_token_count (macro);
938 total = count;
939 limit = macro->exp.tokens + count;
Neil Booth4ed5bcf2001-09-24 22:53:12 +0000940
Neil Booth601328b2002-05-16 05:53:24 +0000941 for (src = macro->exp.tokens; src < limit; src++)
Neil Booth93c803682000-10-28 17:59:06 +0000942 if (src->type == CPP_MACRO_ARG)
943 {
Neil Booth4ed5bcf2001-09-24 22:53:12 +0000944 /* Leading and trailing padding tokens. */
945 total += 2;
946
Neil Booth93c803682000-10-28 17:59:06 +0000947 /* We have an argument. If it is not being stringified or
948 pasted it is macro-replaced before insertion. */
Joseph Myers9a0c6182009-05-10 15:27:32 +0100949 arg = &args[src->val.macro_arg.arg_no - 1];
Neil Booth4c2b6472000-11-11 13:19:01 +0000950
Neil Booth93c803682000-10-28 17:59:06 +0000951 if (src->flags & STRINGIFY_ARG)
952 {
953 if (!arg->stringified)
Neil Booth4ed5bcf2001-09-24 22:53:12 +0000954 arg->stringified = stringify_arg (pfile, arg);
Neil Booth93c803682000-10-28 17:59:06 +0000955 }
956 else if ((src->flags & PASTE_LEFT)
Neil Booth601328b2002-05-16 05:53:24 +0000957 || (src > macro->exp.tokens && (src[-1].flags & PASTE_LEFT)))
Neil Booth93c803682000-10-28 17:59:06 +0000958 total += arg->count - 1;
959 else
960 {
961 if (!arg->expanded)
Neil Booth4ed5bcf2001-09-24 22:53:12 +0000962 expand_arg (pfile, arg);
Neil Booth93c803682000-10-28 17:59:06 +0000963 total += arg->expanded_count - 1;
964 }
965 }
966
Neil Booth4ed5bcf2001-09-24 22:53:12 +0000967 /* Now allocate space for the expansion, copy the tokens and replace
968 the arguments. */
Neil Booth1e013d22001-09-26 21:44:35 +0000969 buff = _cpp_get_buff (pfile, total * sizeof (cpp_token *));
970 first = (const cpp_token **) buff->base;
Neil Booth4ed5bcf2001-09-24 22:53:12 +0000971 dest = first;
Neil Booth93c803682000-10-28 17:59:06 +0000972
Neil Booth601328b2002-05-16 05:53:24 +0000973 for (src = macro->exp.tokens; src < limit; src++)
Neil Booth4ed5bcf2001-09-24 22:53:12 +0000974 {
975 unsigned int count;
976 const cpp_token **from, **paste_flag;
Neil Booth93c803682000-10-28 17:59:06 +0000977
Neil Booth4ed5bcf2001-09-24 22:53:12 +0000978 if (src->type != CPP_MACRO_ARG)
979 {
980 *dest++ = src;
981 continue;
982 }
983
984 paste_flag = 0;
Joseph Myers9a0c6182009-05-10 15:27:32 +0100985 arg = &args[src->val.macro_arg.arg_no - 1];
Neil Booth4ed5bcf2001-09-24 22:53:12 +0000986 if (src->flags & STRINGIFY_ARG)
987 count = 1, from = &arg->stringified;
988 else if (src->flags & PASTE_LEFT)
989 count = arg->count, from = arg->first;
Neil Booth601328b2002-05-16 05:53:24 +0000990 else if (src != macro->exp.tokens && (src[-1].flags & PASTE_LEFT))
Neil Booth4ed5bcf2001-09-24 22:53:12 +0000991 {
Neil Booth93c803682000-10-28 17:59:06 +0000992 count = arg->count, from = arg->first;
Neil Booth4ed5bcf2001-09-24 22:53:12 +0000993 if (dest != first)
994 {
Neil Booth4ed5bcf2001-09-24 22:53:12 +0000995 if (dest[-1]->type == CPP_COMMA
996 && macro->variadic
Joseph Myers9a0c6182009-05-10 15:27:32 +0100997 && src->val.macro_arg.arg_no == macro->paramc)
Neil Booth4ed5bcf2001-09-24 22:53:12 +0000998 {
Neil Booth58551c22002-08-06 20:35:46 +0000999 /* Swallow a pasted comma if from == NULL, otherwise
1000 drop the paste flag. */
1001 if (from == NULL)
Neil Booth4ed5bcf2001-09-24 22:53:12 +00001002 dest--;
1003 else
1004 paste_flag = dest - 1;
1005 }
1006 /* Remove the paste flag if the RHS is a placemarker. */
1007 else if (count == 0)
1008 paste_flag = dest - 1;
1009 }
1010 }
1011 else
1012 count = arg->expanded_count, from = arg->expanded;
Neil Booth93c803682000-10-28 17:59:06 +00001013
Neil Booth4ed5bcf2001-09-24 22:53:12 +00001014 /* Padding on the left of an argument (unless RHS of ##). */
Zack Weinberga8d0dda2003-02-21 18:06:30 +00001015 if ((!pfile->state.in_directive || pfile->state.directive_wants_padding)
Neil Booth601328b2002-05-16 05:53:24 +00001016 && src != macro->exp.tokens && !(src[-1].flags & PASTE_LEFT))
Neil Booth4ed5bcf2001-09-24 22:53:12 +00001017 *dest++ = padding_token (pfile, src);
Neil Booth93c803682000-10-28 17:59:06 +00001018
Neil Booth4ed5bcf2001-09-24 22:53:12 +00001019 if (count)
1020 {
1021 memcpy (dest, from, count * sizeof (cpp_token *));
1022 dest += count;
Neil Booth93c803682000-10-28 17:59:06 +00001023
Neil Booth4ed5bcf2001-09-24 22:53:12 +00001024 /* With a non-empty argument on the LHS of ##, the last
1025 token should be flagged PASTE_LEFT. */
1026 if (src->flags & PASTE_LEFT)
1027 paste_flag = dest - 1;
1028 }
Andrew Haleye85edc92008-07-03 10:31:50 +00001029 else if (CPP_PEDANTIC (pfile) && ! macro->syshdr
1030 && ! CPP_OPTION (pfile, c99)
1031 && ! cpp_in_system_header (pfile))
1032 {
1033 cpp_error (pfile, CPP_DL_PEDWARN,
1034 "invoking macro %s argument %d: "
1035 "empty macro arguments are undefined"
1036 " in ISO C90 and ISO C++98",
1037 NODE_NAME (node),
Joseph Myers9a0c6182009-05-10 15:27:32 +01001038 src->val.macro_arg.arg_no);
Andrew Haleye85edc92008-07-03 10:31:50 +00001039 }
Neil Booth4c2b6472000-11-11 13:19:01 +00001040
Neil Booth4ed5bcf2001-09-24 22:53:12 +00001041 /* Avoid paste on RHS (even case count == 0). */
1042 if (!pfile->state.in_directive && !(src->flags & PASTE_LEFT))
1043 *dest++ = &pfile->avoid_paste;
Neil Booth26ec42e2001-01-28 11:22:23 +00001044
Neil Booth4ed5bcf2001-09-24 22:53:12 +00001045 /* Add a new paste flag, or remove an unwanted one. */
1046 if (paste_flag)
1047 {
1048 cpp_token *token = _cpp_temp_token (pfile);
1049 token->type = (*paste_flag)->type;
Jakub Jelinek73096712005-03-04 16:33:23 +01001050 token->val = (*paste_flag)->val;
Neil Booth4ed5bcf2001-09-24 22:53:12 +00001051 if (src->flags & PASTE_LEFT)
1052 token->flags = (*paste_flag)->flags | PASTE_LEFT;
1053 else
1054 token->flags = (*paste_flag)->flags & ~PASTE_LEFT;
1055 *paste_flag = token;
1056 }
1057 }
Neil Booth4c2b6472000-11-11 13:19:01 +00001058
Neil Booth93c803682000-10-28 17:59:06 +00001059 /* Free the expanded arguments. */
1060 for (i = 0; i < macro->paramc; i++)
Neil Booth4ed5bcf2001-09-24 22:53:12 +00001061 if (args[i].expanded)
1062 free (args[i].expanded);
1063
Neil Booth644edda2001-10-02 12:57:24 +00001064 push_ptoken_context (pfile, node, buff, first, dest - first);
Neil Booth93c803682000-10-28 17:59:06 +00001065}
1066
Neil Booth4ed5bcf2001-09-24 22:53:12 +00001067/* Return a special padding token, with padding inherited from SOURCE. */
1068static const cpp_token *
Zack Weinberg6cf87ca2003-06-17 06:17:44 +00001069padding_token (cpp_reader *pfile, const cpp_token *source)
Neil Booth4ed5bcf2001-09-24 22:53:12 +00001070{
1071 cpp_token *result = _cpp_temp_token (pfile);
1072
1073 result->type = CPP_PADDING;
Paolo Bonzinibe0f1e52005-02-14 08:52:24 +00001074
1075 /* Data in GCed data structures cannot be made const so far, so we
1076 need a cast here. */
1077 result->val.source = (cpp_token *) source;
Neil Booth4ed5bcf2001-09-24 22:53:12 +00001078 result->flags = 0;
1079 return result;
1080}
1081
Neil Boothd15a58c2002-01-03 18:32:55 +00001082/* Get a new uninitialized context. Create a new one if we cannot
1083 re-use an old one. */
Neil Booth4ed5bcf2001-09-24 22:53:12 +00001084static cpp_context *
Zack Weinberg6cf87ca2003-06-17 06:17:44 +00001085next_context (cpp_reader *pfile)
Neil Booth4ed5bcf2001-09-24 22:53:12 +00001086{
1087 cpp_context *result = pfile->context->next;
1088
1089 if (result == 0)
1090 {
Bernardo Innocenti72bb2c32004-07-24 20:04:42 +02001091 result = XNEW (cpp_context);
Neil Booth4ed5bcf2001-09-24 22:53:12 +00001092 result->prev = pfile->context;
1093 result->next = 0;
1094 pfile->context->next = result;
1095 }
1096
1097 pfile->context = result;
1098 return result;
1099}
1100
1101/* Push a list of pointers to tokens. */
1102static void
Zack Weinberg6cf87ca2003-06-17 06:17:44 +00001103push_ptoken_context (cpp_reader *pfile, cpp_hashnode *macro, _cpp_buff *buff,
1104 const cpp_token **first, unsigned int count)
Neil Booth93c803682000-10-28 17:59:06 +00001105{
1106 cpp_context *context = next_context (pfile);
Neil Booth93c803682000-10-28 17:59:06 +00001107
Neil Booth4ed5bcf2001-09-24 22:53:12 +00001108 context->direct_p = false;
1109 context->macro = macro;
Neil Booth1e013d22001-09-26 21:44:35 +00001110 context->buff = buff;
Neil Booth82eda772002-06-04 13:07:06 +00001111 FIRST (context).ptoken = first;
1112 LAST (context).ptoken = first + count;
Neil Booth4ed5bcf2001-09-24 22:53:12 +00001113}
1114
1115/* Push a list of tokens. */
Richard Hendersonbc4071d2006-01-04 08:33:38 -08001116void
1117_cpp_push_token_context (cpp_reader *pfile, cpp_hashnode *macro,
1118 const cpp_token *first, unsigned int count)
Neil Booth4ed5bcf2001-09-24 22:53:12 +00001119{
1120 cpp_context *context = next_context (pfile);
1121
1122 context->direct_p = true;
1123 context->macro = macro;
Neil Booth1e013d22001-09-26 21:44:35 +00001124 context->buff = NULL;
Neil Booth82eda772002-06-04 13:07:06 +00001125 FIRST (context).token = first;
1126 LAST (context).token = first + count;
Neil Booth93c803682000-10-28 17:59:06 +00001127}
1128
Neil Boothcbc69f82002-06-05 20:27:12 +00001129/* Push a traditional macro's replacement text. */
1130void
Zack Weinberg6cf87ca2003-06-17 06:17:44 +00001131_cpp_push_text_context (cpp_reader *pfile, cpp_hashnode *macro,
1132 const uchar *start, size_t len)
Neil Boothcbc69f82002-06-05 20:27:12 +00001133{
1134 cpp_context *context = next_context (pfile);
1135
1136 context->direct_p = true;
1137 context->macro = macro;
1138 context->buff = NULL;
1139 CUR (context) = start;
Neil Booth1ce676a2002-06-09 20:04:17 +00001140 RLIMIT (context) = start + len;
Neil Booth974c43f2002-06-13 06:25:28 +00001141 macro->flags |= NODE_DISABLED;
Neil Boothcbc69f82002-06-05 20:27:12 +00001142}
1143
Neil Boothd15a58c2002-01-03 18:32:55 +00001144/* Expand an argument ARG before replacing parameters in a
1145 function-like macro. This works by pushing a context with the
1146 argument's tokens, and then expanding that into a temporary buffer
1147 as if it were a normal part of the token stream. collect_args()
1148 has terminated the argument's tokens with a CPP_EOF so that we know
1149 when we have fully expanded the argument. */
Neil Booth93c803682000-10-28 17:59:06 +00001150static void
Zack Weinberg6cf87ca2003-06-17 06:17:44 +00001151expand_arg (cpp_reader *pfile, macro_arg *arg)
Neil Booth93c803682000-10-28 17:59:06 +00001152{
Neil Booth4ed5bcf2001-09-24 22:53:12 +00001153 unsigned int capacity;
Neil Booth56941bf2002-09-20 19:44:09 +00001154 bool saved_warn_trad;
Neil Booth4ed5bcf2001-09-24 22:53:12 +00001155
Neil Booth4ed5bcf2001-09-24 22:53:12 +00001156 if (arg->count == 0)
1157 return;
Neil Booth93c803682000-10-28 17:59:06 +00001158
Neil Booth56941bf2002-09-20 19:44:09 +00001159 /* Don't warn about funlike macros when pre-expanding. */
1160 saved_warn_trad = CPP_WTRADITIONAL (pfile);
1161 CPP_WTRADITIONAL (pfile) = 0;
1162
Neil Booth93c803682000-10-28 17:59:06 +00001163 /* Loop, reading in the arguments. */
Neil Booth4ed5bcf2001-09-24 22:53:12 +00001164 capacity = 256;
Gabriel Dos Reisc3f829c2005-05-28 15:52:48 +00001165 arg->expanded = XNEWVEC (const cpp_token *, capacity);
Neil Booth93c803682000-10-28 17:59:06 +00001166
Neil Booth1e013d22001-09-26 21:44:35 +00001167 push_ptoken_context (pfile, NULL, NULL, arg->first, arg->count + 1);
Neil Booth4ed5bcf2001-09-24 22:53:12 +00001168 for (;;)
Neil Booth93c803682000-10-28 17:59:06 +00001169 {
Neil Booth4ed5bcf2001-09-24 22:53:12 +00001170 const cpp_token *token;
1171
1172 if (arg->expanded_count + 1 >= capacity)
Neil Booth93c803682000-10-28 17:59:06 +00001173 {
1174 capacity *= 2;
Gabriel Dos Reisc3f829c2005-05-28 15:52:48 +00001175 arg->expanded = XRESIZEVEC (const cpp_token *, arg->expanded,
1176 capacity);
Neil Booth93c803682000-10-28 17:59:06 +00001177 }
Neil Booth4ed5bcf2001-09-24 22:53:12 +00001178
1179 token = cpp_get_token (pfile);
1180
1181 if (token->type == CPP_EOF)
1182 break;
1183
1184 arg->expanded[arg->expanded_count++] = token;
Neil Booth93c803682000-10-28 17:59:06 +00001185 }
Neil Booth93c803682000-10-28 17:59:06 +00001186
Neil Booth1e013d22001-09-26 21:44:35 +00001187 _cpp_pop_context (pfile);
Neil Booth56941bf2002-09-20 19:44:09 +00001188
1189 CPP_WTRADITIONAL (pfile) = saved_warn_trad;
Neil Booth93c803682000-10-28 17:59:06 +00001190}
1191
Neil Boothd15a58c2002-01-03 18:32:55 +00001192/* Pop the current context off the stack, re-enabling the macro if the
1193 context represented a macro's replacement list. The context
1194 structure is not freed so that we can re-use it later. */
Neil Booth93c803682000-10-28 17:59:06 +00001195void
Zack Weinberg6cf87ca2003-06-17 06:17:44 +00001196_cpp_pop_context (cpp_reader *pfile)
Neil Booth93c803682000-10-28 17:59:06 +00001197{
Neil Booth1e013d22001-09-26 21:44:35 +00001198 cpp_context *context = pfile->context;
Neil Booth93c803682000-10-28 17:59:06 +00001199
Neil Booth1e013d22001-09-26 21:44:35 +00001200 if (context->macro)
Neil Booth644edda2001-10-02 12:57:24 +00001201 context->macro->flags &= ~NODE_DISABLED;
Neil Booth1e013d22001-09-26 21:44:35 +00001202
1203 if (context->buff)
1204 _cpp_release_buff (pfile, context->buff);
1205
1206 pfile->context = context->prev;
Neil Booth93c803682000-10-28 17:59:06 +00001207}
1208
Martin Schaffner48c47212003-06-25 23:01:10 +02001209/* External routine to get a token. Also used nearly everywhere
Neil Booth7f2f1a62000-11-14 18:32:06 +00001210 internally, except for places where we know we can safely call
Martin Schaffner48c47212003-06-25 23:01:10 +02001211 _cpp_lex_token directly, such as lexing a directive name.
Neil Booth7f2f1a62000-11-14 18:32:06 +00001212
1213 Macro expansions and directives are transparently handled,
1214 including entering included files. Thus tokens are post-macro
1215 expansion, and after any intervening directives. External callers
1216 see CPP_EOF only at EOF. Internal callers also see it when meeting
1217 a directive inside a macro call, when at the end of a directive and
1218 state.in_directive is still 1, and at the end of argument
1219 pre-expansion. */
Neil Booth4ed5bcf2001-09-24 22:53:12 +00001220const cpp_token *
Zack Weinberg6cf87ca2003-06-17 06:17:44 +00001221cpp_get_token (cpp_reader *pfile)
Neil Booth93c803682000-10-28 17:59:06 +00001222{
Neil Booth4ed5bcf2001-09-24 22:53:12 +00001223 const cpp_token *result;
Tom Tromey5ffeb9132007-09-06 16:24:05 +00001224 bool can_set = pfile->set_invocation_location;
1225 pfile->set_invocation_location = false;
Neil Booth4ed5bcf2001-09-24 22:53:12 +00001226
Neil Booth29b10742000-11-13 18:40:37 +00001227 for (;;)
Neil Booth93c803682000-10-28 17:59:06 +00001228 {
Neil Booth4ed5bcf2001-09-24 22:53:12 +00001229 cpp_hashnode *node;
Neil Booth93c803682000-10-28 17:59:06 +00001230 cpp_context *context = pfile->context;
1231
Neil Booth93c803682000-10-28 17:59:06 +00001232 /* Context->prev == 0 <=> base context. */
Neil Boothbdcbe492001-09-13 20:05:17 +00001233 if (!context->prev)
Neil Booth4ed5bcf2001-09-24 22:53:12 +00001234 result = _cpp_lex_token (pfile);
Neil Booth82eda772002-06-04 13:07:06 +00001235 else if (FIRST (context).token != LAST (context).token)
Neil Booth29b10742000-11-13 18:40:37 +00001236 {
Neil Booth4ed5bcf2001-09-24 22:53:12 +00001237 if (context->direct_p)
Neil Booth82eda772002-06-04 13:07:06 +00001238 result = FIRST (context).token++;
Neil Booth4ed5bcf2001-09-24 22:53:12 +00001239 else
Neil Booth82eda772002-06-04 13:07:06 +00001240 result = *FIRST (context).ptoken++;
Neil Booth4ed5bcf2001-09-24 22:53:12 +00001241
1242 if (result->flags & PASTE_LEFT)
Neil Boothec1a23e2001-01-31 07:48:54 +00001243 {
Neil Booth4ed5bcf2001-09-24 22:53:12 +00001244 paste_all_tokens (pfile, result);
1245 if (pfile->state.in_directive)
1246 continue;
1247 return padding_token (pfile, result);
Neil Boothec1a23e2001-01-31 07:48:54 +00001248 }
Neil Booth29b10742000-11-13 18:40:37 +00001249 }
Neil Booth93c803682000-10-28 17:59:06 +00001250 else
1251 {
Neil Boothbdcbe492001-09-13 20:05:17 +00001252 _cpp_pop_context (pfile);
Neil Booth4ed5bcf2001-09-24 22:53:12 +00001253 if (pfile->state.in_directive)
1254 continue;
1255 return &pfile->avoid_paste;
Neil Booth93c803682000-10-28 17:59:06 +00001256 }
Neil Booth93c803682000-10-28 17:59:06 +00001257
Jason Thorpe477cdac2002-04-07 03:12:23 +00001258 if (pfile->state.in_directive && result->type == CPP_COMMENT)
1259 continue;
1260
Neil Booth4ed5bcf2001-09-24 22:53:12 +00001261 if (result->type != CPP_NAME)
Neil Booth93c803682000-10-28 17:59:06 +00001262 break;
1263
Joseph Myers9a0c6182009-05-10 15:27:32 +01001264 node = result->val.node.node;
Neil Booth4c2b6472000-11-11 13:19:01 +00001265
Neil Booth644edda2001-10-02 12:57:24 +00001266 if (node->type != NT_MACRO || (result->flags & NO_EXPAND))
1267 break;
Kazu Hiratadf383482002-05-22 22:02:16 +00001268
Neil Booth644edda2001-10-02 12:57:24 +00001269 if (!(node->flags & NODE_DISABLED))
Neil Booth4ed5bcf2001-09-24 22:53:12 +00001270 {
Ben Elliston5950c3c2008-07-14 05:09:48 +00001271 int ret = 0;
Tom Tromey5ffeb9132007-09-06 16:24:05 +00001272 /* If not in a macro context, and we're going to start an
1273 expansion, record the location. */
1274 if (can_set && !context->macro)
1275 pfile->invocation_location = result->src_loc;
Jakub Jelinek765d6002008-01-25 10:01:27 +01001276 if (pfile->state.prevent_expansion)
1277 break;
Ben Elliston5950c3c2008-07-14 05:09:48 +00001278
1279 /* Conditional macros require that a predicate be evaluated
1280 first. */
Jakub Jelineka37a7b82009-03-30 17:00:52 +02001281 if ((node->flags & NODE_CONDITIONAL) != 0)
1282 {
1283 if (pfile->cb.macro_to_expand)
1284 {
1285 bool whitespace_after;
1286 const cpp_token *peek_tok = cpp_peek_token (pfile, 0);
1287
1288 whitespace_after = (peek_tok->type == CPP_PADDING
1289 || (peek_tok->flags & PREV_WHITE));
1290 node = pfile->cb.macro_to_expand (pfile, result);
1291 if (node)
1292 ret = enter_macro_context (pfile, node, result);
1293 else if (whitespace_after)
1294 {
1295 /* If macro_to_expand hook returned NULL and it
1296 ate some tokens, see if we don't need to add
1297 a padding token in between this and the
1298 next token. */
1299 peek_tok = cpp_peek_token (pfile, 0);
1300 if (peek_tok->type != CPP_PADDING
1301 && (peek_tok->flags & PREV_WHITE) == 0)
1302 _cpp_push_token_context (pfile, NULL,
1303 padding_token (pfile,
1304 peek_tok), 1);
1305 }
1306 }
1307 }
1308 else
1309 ret = enter_macro_context (pfile, node, result);
1310 if (ret)
Ben Elliston5950c3c2008-07-14 05:09:48 +00001311 {
Jakub Jelinek765d6002008-01-25 10:01:27 +01001312 if (pfile->state.in_directive || ret == 2)
Neil Booth4ed5bcf2001-09-24 22:53:12 +00001313 continue;
1314 return padding_token (pfile, result);
Neil Boothbd969772001-02-01 19:13:53 +00001315 }
Neil Booth93c803682000-10-28 17:59:06 +00001316 }
Neil Booth644edda2001-10-02 12:57:24 +00001317 else
1318 {
Neil Boothd15a58c2002-01-03 18:32:55 +00001319 /* Flag this token as always unexpandable. FIXME: move this
1320 to collect_args()?. */
Neil Booth644edda2001-10-02 12:57:24 +00001321 cpp_token *t = _cpp_temp_token (pfile);
1322 t->type = result->type;
1323 t->flags = result->flags | NO_EXPAND;
Jakub Jelinek73096712005-03-04 16:33:23 +01001324 t->val = result->val;
Neil Booth644edda2001-10-02 12:57:24 +00001325 result = t;
1326 }
Neil Bootha5c3ccc2000-10-30 22:29:00 +00001327
Neil Booth644edda2001-10-02 12:57:24 +00001328 break;
Neil Booth93c803682000-10-28 17:59:06 +00001329 }
Neil Booth4ed5bcf2001-09-24 22:53:12 +00001330
1331 return result;
Neil Booth93c803682000-10-28 17:59:06 +00001332}
1333
Tom Tromey5ffeb9132007-09-06 16:24:05 +00001334/* Like cpp_get_token, but also returns a location separate from the
1335 one provided by the returned token. LOC is an out parameter; *LOC
1336 is set to the location "as expected by the user". This matters
1337 when a token results from macro expansion -- the token's location
1338 will indicate where the macro is defined, but *LOC will be the
1339 location of the start of the expansion. */
1340const cpp_token *
1341cpp_get_token_with_location (cpp_reader *pfile, source_location *loc)
1342{
1343 const cpp_token *result;
1344
1345 pfile->set_invocation_location = true;
1346 result = cpp_get_token (pfile);
1347 if (pfile->context->macro)
1348 *loc = pfile->invocation_location;
1349 else
1350 *loc = result->src_loc;
1351
1352 return result;
1353}
1354
Neil Booth7065e132001-02-14 07:38:20 +00001355/* Returns true if we're expanding an object-like macro that was
1356 defined in a system header. Just checks the macro at the top of
1357 the stack. Used for diagnostic suppression. */
1358int
Zack Weinberg6cf87ca2003-06-17 06:17:44 +00001359cpp_sys_macro_p (cpp_reader *pfile)
Neil Booth7065e132001-02-14 07:38:20 +00001360{
Neil Booth644edda2001-10-02 12:57:24 +00001361 cpp_hashnode *node = pfile->context->macro;
Neil Booth7065e132001-02-14 07:38:20 +00001362
Neil Booth644edda2001-10-02 12:57:24 +00001363 return node && node->value.macro && node->value.macro->syshdr;
Neil Booth7065e132001-02-14 07:38:20 +00001364}
1365
Neil Boothaf0d16c2002-04-22 17:48:02 +00001366/* Read each token in, until end of the current file. Directives are
1367 transparently processed. */
Neil Booth93c803682000-10-28 17:59:06 +00001368void
Zack Weinberg6cf87ca2003-06-17 06:17:44 +00001369cpp_scan_nooutput (cpp_reader *pfile)
Neil Booth93c803682000-10-28 17:59:06 +00001370{
Per Bothner22234f52004-02-18 14:02:39 -08001371 /* Request a CPP_EOF token at the end of this file, rather than
1372 transparently continuing with the including file. */
1373 pfile->buffer->return_at_eof = true;
1374
Zack Weinbergc6e83802004-06-05 20:58:06 +00001375 pfile->state.discarding_output++;
1376 pfile->state.prevent_expansion++;
1377
Neil Booth590e1982002-07-01 12:47:54 +00001378 if (CPP_OPTION (pfile, traditional))
1379 while (_cpp_read_logical_line_trad (pfile))
1380 ;
1381 else
1382 while (cpp_get_token (pfile)->type != CPP_EOF)
1383 ;
Zack Weinbergc6e83802004-06-05 20:58:06 +00001384
1385 pfile->state.discarding_output--;
1386 pfile->state.prevent_expansion--;
Neil Booth93c803682000-10-28 17:59:06 +00001387}
1388
Ben Elliston5950c3c2008-07-14 05:09:48 +00001389/* Step back one or more tokens obtained from the lexer. */
1390void
1391_cpp_backup_tokens_direct (cpp_reader *pfile, unsigned int count)
1392{
1393 pfile->lookaheads += count;
1394 while (count--)
1395 {
1396 pfile->cur_token--;
1397 if (pfile->cur_token == pfile->cur_run->base
1398 /* Possible with -fpreprocessed and no leading #line. */
1399 && pfile->cur_run->prev != NULL)
1400 {
1401 pfile->cur_run = pfile->cur_run->prev;
1402 pfile->cur_token = pfile->cur_run->limit;
1403 }
1404 }
1405}
1406
Jakub Jelinek1c90c6f2006-06-09 23:13:25 +02001407/* Step back one (or more) tokens. Can only step back more than 1 if
Neil Boothbdcbe492001-09-13 20:05:17 +00001408 they are from the lexer, and not from macro expansion. */
Neil Boothb528a072000-11-12 11:46:21 +00001409void
Zack Weinberg6cf87ca2003-06-17 06:17:44 +00001410_cpp_backup_tokens (cpp_reader *pfile, unsigned int count)
Neil Booth93c803682000-10-28 17:59:06 +00001411{
Neil Boothbdcbe492001-09-13 20:05:17 +00001412 if (pfile->context->prev == NULL)
Ben Elliston5950c3c2008-07-14 05:09:48 +00001413 _cpp_backup_tokens_direct (pfile, count);
Neil Booth93c803682000-10-28 17:59:06 +00001414 else
1415 {
Neil Boothbdcbe492001-09-13 20:05:17 +00001416 if (count != 1)
1417 abort ();
Neil Booth4ed5bcf2001-09-24 22:53:12 +00001418 if (pfile->context->direct_p)
Neil Booth82eda772002-06-04 13:07:06 +00001419 FIRST (pfile->context).token--;
Neil Booth4ed5bcf2001-09-24 22:53:12 +00001420 else
Neil Booth82eda772002-06-04 13:07:06 +00001421 FIRST (pfile->context).ptoken--;
Neil Booth93c803682000-10-28 17:59:06 +00001422 }
Neil Booth93c803682000-10-28 17:59:06 +00001423}
1424
1425/* #define directive parsing and handling. */
1426
Kazu Hiratada7d8302002-09-22 02:03:17 +00001427/* Returns nonzero if a macro redefinition warning is required. */
Neil Boothcbc69f82002-06-05 20:27:12 +00001428static bool
Zack Weinberg6cf87ca2003-06-17 06:17:44 +00001429warn_of_redefinition (cpp_reader *pfile, const cpp_hashnode *node,
1430 const cpp_macro *macro2)
Neil Booth93c803682000-10-28 17:59:06 +00001431{
1432 const cpp_macro *macro1;
1433 unsigned int i;
1434
Neil Booth618cdda2001-02-25 09:43:03 +00001435 /* Some redefinitions need to be warned about regardless. */
1436 if (node->flags & NODE_WARN)
Neil Boothcbc69f82002-06-05 20:27:12 +00001437 return true;
Neil Booth93c803682000-10-28 17:59:06 +00001438
Simon Baldwinc047ce92008-09-18 15:39:08 +00001439 /* Suppress warnings for builtins that lack the NODE_WARN flag. */
1440 if (node->flags & NODE_BUILTIN)
1441 return false;
1442
Ben Elliston5950c3c2008-07-14 05:09:48 +00001443 /* Redefinitions of conditional (context-sensitive) macros, on
1444 the other hand, must be allowed silently. */
1445 if (node->flags & NODE_CONDITIONAL)
1446 return false;
1447
Neil Booth618cdda2001-02-25 09:43:03 +00001448 /* Redefinition of a macro is allowed if and only if the old and new
Kazu Hirataec5c56d2001-08-01 17:57:27 +00001449 definitions are the same. (6.10.3 paragraph 2). */
Neil Booth93c803682000-10-28 17:59:06 +00001450 macro1 = node->value.macro;
1451
Neil Booth6618c5d2002-06-10 06:03:13 +00001452 /* Don't check count here as it can be different in valid
1453 traditional redefinitions with just whitespace differences. */
1454 if (macro1->paramc != macro2->paramc
Neil Booth93c803682000-10-28 17:59:06 +00001455 || macro1->fun_like != macro2->fun_like
Neil Booth28e0f042000-12-09 12:06:37 +00001456 || macro1->variadic != macro2->variadic)
Neil Boothcbc69f82002-06-05 20:27:12 +00001457 return true;
Neil Booth93c803682000-10-28 17:59:06 +00001458
1459 /* Check parameter spellings. */
1460 for (i = 0; i < macro1->paramc; i++)
1461 if (macro1->params[i] != macro2->params[i])
Neil Boothcbc69f82002-06-05 20:27:12 +00001462 return true;
Neil Booth93c803682000-10-28 17:59:06 +00001463
Neil Boothcbc69f82002-06-05 20:27:12 +00001464 /* Check the replacement text or tokens. */
1465 if (CPP_OPTION (pfile, traditional))
Neil Booth6618c5d2002-06-10 06:03:13 +00001466 return _cpp_expansions_different_trad (macro1, macro2);
Neil Boothcbc69f82002-06-05 20:27:12 +00001467
DJ Deloriea7f36da2003-06-01 14:55:15 -04001468 if (macro1->count != macro2->count)
1469 return true;
1470
1471 for (i = 0; i < macro1->count; i++)
1472 if (!_cpp_equiv_tokens (&macro1->exp.tokens[i], &macro2->exp.tokens[i]))
1473 return true;
Neil Boothcbc69f82002-06-05 20:27:12 +00001474
1475 return false;
Zack Weinberg711b8822000-07-18 00:59:49 +00001476}
1477
Neil Booth93c803682000-10-28 17:59:06 +00001478/* Free the definition of hashnode H. */
Neil Booth93c803682000-10-28 17:59:06 +00001479void
Zack Weinberg6cf87ca2003-06-17 06:17:44 +00001480_cpp_free_definition (cpp_hashnode *h)
Zack Weinberg711b8822000-07-18 00:59:49 +00001481{
Neil Booth93c803682000-10-28 17:59:06 +00001482 /* Macros and assertions no longer have anything to free. */
1483 h->type = NT_VOID;
1484 /* Clear builtin flag in case of redefinition. */
Joseph Myers93d45d92008-04-02 20:42:53 +01001485 h->flags &= ~(NODE_BUILTIN | NODE_DISABLED | NODE_USED);
Neil Booth93c803682000-10-28 17:59:06 +00001486}
Zack Weinberg711b8822000-07-18 00:59:49 +00001487
Neil Booth14baae02001-09-17 18:26:12 +00001488/* Save parameter NODE to the parameter list of macro MACRO. Returns
Kazu Hiratada7d8302002-09-22 02:03:17 +00001489 zero on success, nonzero if the parameter is a duplicate. */
Neil Boothc70f6ed2002-06-07 06:26:32 +00001490bool
Zack Weinberg6cf87ca2003-06-17 06:17:44 +00001491_cpp_save_parameter (cpp_reader *pfile, cpp_macro *macro, cpp_hashnode *node)
Neil Booth93c803682000-10-28 17:59:06 +00001492{
Zack Weinberg4977bab2002-12-16 18:23:00 +00001493 unsigned int len;
Neil Booth93c803682000-10-28 17:59:06 +00001494 /* Constraint 6.10.3.6 - duplicate parameter names. */
Zack Weinberg4977bab2002-12-16 18:23:00 +00001495 if (node->flags & NODE_MACRO_ARG)
Zack Weinberg711b8822000-07-18 00:59:49 +00001496 {
John David Anglin0527bc42003-11-01 22:56:54 +00001497 cpp_error (pfile, CPP_DL_ERROR, "duplicate macro parameter \"%s\"",
Neil Boothebef4e82002-04-14 18:42:47 +00001498 NODE_NAME (node));
Neil Booth23ff0222002-07-17 17:27:14 +00001499 return true;
Neil Booth93c803682000-10-28 17:59:06 +00001500 }
1501
Neil Booth8c3b2692001-09-30 10:03:11 +00001502 if (BUFF_ROOM (pfile->a_buff)
1503 < (macro->paramc + 1) * sizeof (cpp_hashnode *))
1504 _cpp_extend_buff (pfile, &pfile->a_buff, sizeof (cpp_hashnode *));
Neil Booth93c803682000-10-28 17:59:06 +00001505
Neil Booth8c3b2692001-09-30 10:03:11 +00001506 ((cpp_hashnode **) BUFF_FRONT (pfile->a_buff))[macro->paramc++] = node;
Zack Weinberg4977bab2002-12-16 18:23:00 +00001507 node->flags |= NODE_MACRO_ARG;
1508 len = macro->paramc * sizeof (union _cpp_hashnode_value);
1509 if (len > pfile->macro_buffer_len)
1510 {
Gabriel Dos Reisc3f829c2005-05-28 15:52:48 +00001511 pfile->macro_buffer = XRESIZEVEC (unsigned char, pfile->macro_buffer,
1512 len);
Zack Weinberg4977bab2002-12-16 18:23:00 +00001513 pfile->macro_buffer_len = len;
1514 }
1515 ((union _cpp_hashnode_value *) pfile->macro_buffer)[macro->paramc - 1]
1516 = node->value;
1517
1518 node->value.arg_index = macro->paramc;
Neil Booth23ff0222002-07-17 17:27:14 +00001519 return false;
Neil Booth93c803682000-10-28 17:59:06 +00001520}
1521
Neil Booth23ff0222002-07-17 17:27:14 +00001522/* Check the syntax of the parameters in a MACRO definition. Returns
1523 false if an error occurs. */
1524static bool
Zack Weinberg6cf87ca2003-06-17 06:17:44 +00001525parse_params (cpp_reader *pfile, cpp_macro *macro)
Neil Booth93c803682000-10-28 17:59:06 +00001526{
Neil Booth93c803682000-10-28 17:59:06 +00001527 unsigned int prev_ident = 0;
1528
Neil Booth93c803682000-10-28 17:59:06 +00001529 for (;;)
1530 {
Neil Booth345894b2001-09-16 13:44:29 +00001531 const cpp_token *token = _cpp_lex_token (pfile);
Neil Booth93c803682000-10-28 17:59:06 +00001532
Neil Booth345894b2001-09-16 13:44:29 +00001533 switch (token->type)
Zack Weinberg711b8822000-07-18 00:59:49 +00001534 {
1535 default:
Jason Thorpe477cdac2002-04-07 03:12:23 +00001536 /* Allow/ignore comments in parameter lists if we are
1537 preserving comments in macro expansions. */
1538 if (token->type == CPP_COMMENT
1539 && ! CPP_OPTION (pfile, discard_comments_in_macro_exp))
1540 continue;
1541
John David Anglin0527bc42003-11-01 22:56:54 +00001542 cpp_error (pfile, CPP_DL_ERROR,
Neil Boothebef4e82002-04-14 18:42:47 +00001543 "\"%s\" may not appear in macro parameter list",
Neil Booth345894b2001-09-16 13:44:29 +00001544 cpp_token_as_text (pfile, token));
Neil Booth23ff0222002-07-17 17:27:14 +00001545 return false;
Zack Weinberg711b8822000-07-18 00:59:49 +00001546
Zack Weinberg711b8822000-07-18 00:59:49 +00001547 case CPP_NAME:
1548 if (prev_ident)
1549 {
John David Anglin0527bc42003-11-01 22:56:54 +00001550 cpp_error (pfile, CPP_DL_ERROR,
Neil Boothebef4e82002-04-14 18:42:47 +00001551 "macro parameters must be comma-separated");
Neil Booth23ff0222002-07-17 17:27:14 +00001552 return false;
Zack Weinberg711b8822000-07-18 00:59:49 +00001553 }
Zack Weinberg711b8822000-07-18 00:59:49 +00001554 prev_ident = 1;
Neil Booth93c803682000-10-28 17:59:06 +00001555
Joseph Myers9a0c6182009-05-10 15:27:32 +01001556 if (_cpp_save_parameter (pfile, macro, token->val.node.node))
Neil Booth23ff0222002-07-17 17:27:14 +00001557 return false;
Zack Weinberg711b8822000-07-18 00:59:49 +00001558 continue;
1559
1560 case CPP_CLOSE_PAREN:
Neil Booth93c803682000-10-28 17:59:06 +00001561 if (prev_ident || macro->paramc == 0)
Neil Booth23ff0222002-07-17 17:27:14 +00001562 return true;
Zack Weinberg711b8822000-07-18 00:59:49 +00001563
1564 /* Fall through to pick up the error. */
1565 case CPP_COMMA:
1566 if (!prev_ident)
1567 {
John David Anglin0527bc42003-11-01 22:56:54 +00001568 cpp_error (pfile, CPP_DL_ERROR, "parameter name missing");
Neil Booth23ff0222002-07-17 17:27:14 +00001569 return false;
Zack Weinberg711b8822000-07-18 00:59:49 +00001570 }
1571 prev_ident = 0;
1572 continue;
1573
1574 case CPP_ELLIPSIS:
Neil Booth28e0f042000-12-09 12:06:37 +00001575 macro->variadic = 1;
Zack Weinberg711b8822000-07-18 00:59:49 +00001576 if (!prev_ident)
1577 {
Neil Boothc70f6ed2002-06-07 06:26:32 +00001578 _cpp_save_parameter (pfile, macro,
1579 pfile->spec_nodes.n__VA_ARGS__);
Neil Booth93c803682000-10-28 17:59:06 +00001580 pfile->state.va_args_ok = 1;
Richard Hendersone5b79212004-02-19 14:18:50 -08001581 if (! CPP_OPTION (pfile, c99)
1582 && CPP_OPTION (pfile, pedantic)
1583 && CPP_OPTION (pfile, warn_variadic_macros))
John David Anglin0527bc42003-11-01 22:56:54 +00001584 cpp_error (pfile, CPP_DL_PEDWARN,
Neil Boothebef4e82002-04-14 18:42:47 +00001585 "anonymous variadic macros were introduced in C99");
Zack Weinberg711b8822000-07-18 00:59:49 +00001586 }
Richard Hendersone5b79212004-02-19 14:18:50 -08001587 else if (CPP_OPTION (pfile, pedantic)
1588 && CPP_OPTION (pfile, warn_variadic_macros))
John David Anglin0527bc42003-11-01 22:56:54 +00001589 cpp_error (pfile, CPP_DL_PEDWARN,
Neil Boothebef4e82002-04-14 18:42:47 +00001590 "ISO C does not permit named variadic macros");
Zack Weinberg711b8822000-07-18 00:59:49 +00001591
Neil Booth93c803682000-10-28 17:59:06 +00001592 /* We're at the end, and just expect a closing parenthesis. */
Neil Booth345894b2001-09-16 13:44:29 +00001593 token = _cpp_lex_token (pfile);
1594 if (token->type == CPP_CLOSE_PAREN)
Neil Booth23ff0222002-07-17 17:27:14 +00001595 return true;
Neil Booth93c803682000-10-28 17:59:06 +00001596 /* Fall through. */
1597
1598 case CPP_EOF:
John David Anglin0527bc42003-11-01 22:56:54 +00001599 cpp_error (pfile, CPP_DL_ERROR, "missing ')' in macro parameter list");
Neil Booth23ff0222002-07-17 17:27:14 +00001600 return false;
Zack Weinberg711b8822000-07-18 00:59:49 +00001601 }
Zack Weinberg711b8822000-07-18 00:59:49 +00001602 }
1603}
1604
Neil Booth14baae02001-09-17 18:26:12 +00001605/* Allocate room for a token from a macro's replacement list. */
Neil Booth93c803682000-10-28 17:59:06 +00001606static cpp_token *
Zack Weinberg6cf87ca2003-06-17 06:17:44 +00001607alloc_expansion_token (cpp_reader *pfile, cpp_macro *macro)
Zack Weinberg711b8822000-07-18 00:59:49 +00001608{
Neil Booth8c3b2692001-09-30 10:03:11 +00001609 if (BUFF_ROOM (pfile->a_buff) < (macro->count + 1) * sizeof (cpp_token))
1610 _cpp_extend_buff (pfile, &pfile->a_buff, sizeof (cpp_token));
Zack Weinberg711b8822000-07-18 00:59:49 +00001611
Neil Booth8c3b2692001-09-30 10:03:11 +00001612 return &((cpp_token *) BUFF_FRONT (pfile->a_buff))[macro->count++];
Neil Booth14baae02001-09-17 18:26:12 +00001613}
1614
Neil Boothd15a58c2002-01-03 18:32:55 +00001615/* Lex a token from the expansion of MACRO, but mark parameters as we
1616 find them and warn of traditional stringification. */
Neil Booth14baae02001-09-17 18:26:12 +00001617static cpp_token *
Zack Weinberg6cf87ca2003-06-17 06:17:44 +00001618lex_expansion_token (cpp_reader *pfile, cpp_macro *macro)
Neil Booth14baae02001-09-17 18:26:12 +00001619{
Tom Tromeyee380362007-01-30 15:46:01 +00001620 cpp_token *token, *saved_cur_token;
Neil Booth14baae02001-09-17 18:26:12 +00001621
Tom Tromeyee380362007-01-30 15:46:01 +00001622 saved_cur_token = pfile->cur_token;
Neil Booth14baae02001-09-17 18:26:12 +00001623 pfile->cur_token = alloc_expansion_token (pfile, macro);
1624 token = _cpp_lex_direct (pfile);
Tom Tromeyee380362007-01-30 15:46:01 +00001625 pfile->cur_token = saved_cur_token;
Neil Booth93c803682000-10-28 17:59:06 +00001626
Neil Boothd15a58c2002-01-03 18:32:55 +00001627 /* Is this a parameter? */
Zack Weinberg4977bab2002-12-16 18:23:00 +00001628 if (token->type == CPP_NAME
Joseph Myers9a0c6182009-05-10 15:27:32 +01001629 && (token->val.node.node->flags & NODE_MACRO_ARG) != 0)
Zack Weinberg711b8822000-07-18 00:59:49 +00001630 {
Neil Booth93c803682000-10-28 17:59:06 +00001631 token->type = CPP_MACRO_ARG;
Joseph Myers9a0c6182009-05-10 15:27:32 +01001632 token->val.macro_arg.arg_no = token->val.node.node->value.arg_index;
Zack Weinberg711b8822000-07-18 00:59:49 +00001633 }
Neil Booth93c803682000-10-28 17:59:06 +00001634 else if (CPP_WTRADITIONAL (pfile) && macro->paramc > 0
1635 && (token->type == CPP_STRING || token->type == CPP_CHAR))
1636 check_trad_stringification (pfile, macro, &token->val.str);
Zack Weinberg711b8822000-07-18 00:59:49 +00001637
Neil Booth93c803682000-10-28 17:59:06 +00001638 return token;
Zack Weinberg711b8822000-07-18 00:59:49 +00001639}
1640
Neil Boothcbc69f82002-06-05 20:27:12 +00001641static bool
Zack Weinberg6cf87ca2003-06-17 06:17:44 +00001642create_iso_definition (cpp_reader *pfile, cpp_macro *macro)
Zack Weinberg711b8822000-07-18 00:59:49 +00001643{
Neil Boothcbc69f82002-06-05 20:27:12 +00001644 cpp_token *token;
Neil Booth14baae02001-09-17 18:26:12 +00001645 const cpp_token *ctoken;
Simon Martin126e0732007-05-23 20:58:34 +00001646 bool following_paste_op = false;
1647 const char *paste_op_error_msg =
1648 N_("'##' cannot appear at either end of a macro expansion");
Joseph Myersaa508502009-04-19 18:10:56 +01001649 unsigned int num_extra_tokens = 0;
Zack Weinberg711b8822000-07-18 00:59:49 +00001650
Neil Booth93c803682000-10-28 17:59:06 +00001651 /* Get the first token of the expansion (or the '(' of a
1652 function-like macro). */
Neil Booth14baae02001-09-17 18:26:12 +00001653 ctoken = _cpp_lex_token (pfile);
1654
1655 if (ctoken->type == CPP_OPEN_PAREN && !(ctoken->flags & PREV_WHITE))
Zack Weinberg711b8822000-07-18 00:59:49 +00001656 {
Neil Boothcbc69f82002-06-05 20:27:12 +00001657 bool ok = parse_params (pfile, macro);
Neil Booth8c3b2692001-09-30 10:03:11 +00001658 macro->params = (cpp_hashnode **) BUFF_FRONT (pfile->a_buff);
1659 if (!ok)
Neil Boothcbc69f82002-06-05 20:27:12 +00001660 return false;
Neil Booth8c3b2692001-09-30 10:03:11 +00001661
Geoffrey Keatingd8044162004-06-09 20:10:13 +00001662 /* Success. Commit or allocate the parameter array. */
1663 if (pfile->hash_table->alloc_subobject)
1664 {
Gabriel Dos Reisc3f829c2005-05-28 15:52:48 +00001665 cpp_hashnode **params =
1666 (cpp_hashnode **) pfile->hash_table->alloc_subobject
1667 (sizeof (cpp_hashnode *) * macro->paramc);
Paolo Bonzinibe0f1e52005-02-14 08:52:24 +00001668 memcpy (params, macro->params,
1669 sizeof (cpp_hashnode *) * macro->paramc);
1670 macro->params = params;
Geoffrey Keatingd8044162004-06-09 20:10:13 +00001671 }
1672 else
1673 BUFF_FRONT (pfile->a_buff) = (uchar *) &macro->params[macro->paramc];
Neil Booth93c803682000-10-28 17:59:06 +00001674 macro->fun_like = 1;
Neil Booth93c803682000-10-28 17:59:06 +00001675 }
Neil Booth14baae02001-09-17 18:26:12 +00001676 else if (ctoken->type != CPP_EOF && !(ctoken->flags & PREV_WHITE))
Jakub Jelinekcae064e2005-04-05 22:07:06 +02001677 {
1678 /* While ISO C99 requires whitespace before replacement text
1679 in a macro definition, ISO C90 with TC1 allows there characters
1680 from the basic source character set. */
1681 if (CPP_OPTION (pfile, c99))
1682 cpp_error (pfile, CPP_DL_PEDWARN,
1683 "ISO C99 requires whitespace after the macro name");
1684 else
1685 {
1686 int warntype = CPP_DL_WARNING;
1687 switch (ctoken->type)
1688 {
1689 case CPP_ATSIGN:
1690 case CPP_AT_NAME:
1691 case CPP_OBJC_STRING:
1692 /* '@' is not in basic character set. */
1693 warntype = CPP_DL_PEDWARN;
1694 break;
1695 case CPP_OTHER:
1696 /* Basic character set sans letters, digits and _. */
1697 if (strchr ("!\"#%&'()*+,-./:;<=>?[\\]^{|}~",
1698 ctoken->val.str.text[0]) == NULL)
1699 warntype = CPP_DL_PEDWARN;
1700 break;
1701 default:
1702 /* All other tokens start with a character from basic
1703 character set. */
1704 break;
1705 }
1706 cpp_error (pfile, warntype,
1707 "missing whitespace after the macro name");
1708 }
1709 }
Neil Booth93c803682000-10-28 17:59:06 +00001710
Neil Booth14baae02001-09-17 18:26:12 +00001711 if (macro->fun_like)
1712 token = lex_expansion_token (pfile, macro);
1713 else
1714 {
1715 token = alloc_expansion_token (pfile, macro);
1716 *token = *ctoken;
1717 }
Neil Booth93c803682000-10-28 17:59:06 +00001718
1719 for (;;)
1720 {
1721 /* Check the stringifying # constraint 6.10.3.2.1 of
1722 function-like macros when lexing the subsequent token. */
1723 if (macro->count > 1 && token[-1].type == CPP_HASH && macro->fun_like)
Zack Weinberg711b8822000-07-18 00:59:49 +00001724 {
Neil Booth93c803682000-10-28 17:59:06 +00001725 if (token->type == CPP_MACRO_ARG)
1726 {
Joseph Myersaa508502009-04-19 18:10:56 +01001727 if (token->flags & PREV_WHITE)
1728 token->flags |= SP_PREV_WHITE;
1729 if (token[-1].flags & DIGRAPH)
1730 token->flags |= SP_DIGRAPH;
Neil Booth93c803682000-10-28 17:59:06 +00001731 token->flags &= ~PREV_WHITE;
1732 token->flags |= STRINGIFY_ARG;
1733 token->flags |= token[-1].flags & PREV_WHITE;
1734 token[-1] = token[0];
1735 macro->count--;
1736 }
1737 /* Let assembler get away with murder. */
Neil Boothbdb05a72000-11-26 17:31:13 +00001738 else if (CPP_OPTION (pfile, lang) != CLK_ASM)
Neil Booth93c803682000-10-28 17:59:06 +00001739 {
John David Anglin0527bc42003-11-01 22:56:54 +00001740 cpp_error (pfile, CPP_DL_ERROR,
Neil Boothebef4e82002-04-14 18:42:47 +00001741 "'#' is not followed by a macro parameter");
Neil Boothcbc69f82002-06-05 20:27:12 +00001742 return false;
Neil Booth93c803682000-10-28 17:59:06 +00001743 }
1744 }
1745
1746 if (token->type == CPP_EOF)
Simon Martin126e0732007-05-23 20:58:34 +00001747 {
1748 /* Paste operator constraint 6.10.3.3.1:
1749 Token-paste ##, can appear in both object-like and
1750 function-like macros, but not at the end. */
1751 if (following_paste_op)
1752 {
1753 cpp_error (pfile, CPP_DL_ERROR, paste_op_error_msg);
1754 return false;
1755 }
1756 break;
1757 }
Neil Booth93c803682000-10-28 17:59:06 +00001758
1759 /* Paste operator constraint 6.10.3.3.1. */
1760 if (token->type == CPP_PASTE)
1761 {
1762 /* Token-paste ##, can appear in both object-like and
Simon Martin126e0732007-05-23 20:58:34 +00001763 function-like macros, but not at the beginning. */
1764 if (macro->count == 1)
Neil Booth93c803682000-10-28 17:59:06 +00001765 {
Simon Martin126e0732007-05-23 20:58:34 +00001766 cpp_error (pfile, CPP_DL_ERROR, paste_op_error_msg);
Neil Boothcbc69f82002-06-05 20:27:12 +00001767 return false;
Neil Booth93c803682000-10-28 17:59:06 +00001768 }
1769
Joseph Myersaa508502009-04-19 18:10:56 +01001770 if (token[-1].flags & PASTE_LEFT)
1771 {
1772 macro->extra_tokens = 1;
1773 num_extra_tokens++;
Joseph Myers9a0c6182009-05-10 15:27:32 +01001774 token->val.token_no = macro->count - 1;
Joseph Myersaa508502009-04-19 18:10:56 +01001775 }
1776 else
1777 {
1778 --macro->count;
1779 token[-1].flags |= PASTE_LEFT;
1780 if (token->flags & DIGRAPH)
1781 token[-1].flags |= SP_DIGRAPH;
1782 if (token->flags & PREV_WHITE)
1783 token[-1].flags |= SP_PREV_WHITE;
1784 }
Neil Booth93c803682000-10-28 17:59:06 +00001785 }
1786
Simon Martin126e0732007-05-23 20:58:34 +00001787 following_paste_op = (token->type == CPP_PASTE);
Neil Booth93c803682000-10-28 17:59:06 +00001788 token = lex_expansion_token (pfile, macro);
1789 }
1790
Neil Booth601328b2002-05-16 05:53:24 +00001791 macro->exp.tokens = (cpp_token *) BUFF_FRONT (pfile->a_buff);
Geoffrey Keatingd8044162004-06-09 20:10:13 +00001792 macro->traditional = 0;
Neil Booth8c3b2692001-09-30 10:03:11 +00001793
Neil Booth4c2b6472000-11-11 13:19:01 +00001794 /* Don't count the CPP_EOF. */
1795 macro->count--;
Neil Booth93c803682000-10-28 17:59:06 +00001796
Neil Boothd15a58c2002-01-03 18:32:55 +00001797 /* Clear whitespace on first token for warn_of_redefinition(). */
Neil Booth8c3b2692001-09-30 10:03:11 +00001798 if (macro->count)
Neil Booth601328b2002-05-16 05:53:24 +00001799 macro->exp.tokens[0].flags &= ~PREV_WHITE;
Neil Booth8c3b2692001-09-30 10:03:11 +00001800
Geoffrey Keatingd8044162004-06-09 20:10:13 +00001801 /* Commit or allocate the memory. */
1802 if (pfile->hash_table->alloc_subobject)
1803 {
Gabriel Dos Reisc3f829c2005-05-28 15:52:48 +00001804 cpp_token *tokns =
1805 (cpp_token *) pfile->hash_table->alloc_subobject (sizeof (cpp_token)
1806 * macro->count);
Joseph Myersaa508502009-04-19 18:10:56 +01001807 if (num_extra_tokens)
1808 {
1809 /* Place second and subsequent ## or %:%: tokens in
1810 sequences of consecutive such tokens at the end of the
1811 list to preserve information about where they appear, how
1812 they are spelt and whether they are preceded by
1813 whitespace without otherwise interfering with macro
1814 expansion. */
1815 cpp_token *normal_dest = tokns;
1816 cpp_token *extra_dest = tokns + macro->count - num_extra_tokens;
1817 unsigned int i;
1818 for (i = 0; i < macro->count; i++)
1819 {
1820 if (macro->exp.tokens[i].type == CPP_PASTE)
1821 *extra_dest++ = macro->exp.tokens[i];
1822 else
1823 *normal_dest++ = macro->exp.tokens[i];
1824 }
1825 }
1826 else
1827 memcpy (tokns, macro->exp.tokens, sizeof (cpp_token) * macro->count);
Geoffrey Keatingd8044162004-06-09 20:10:13 +00001828 macro->exp.tokens = tokns;
1829 }
1830 else
1831 BUFF_FRONT (pfile->a_buff) = (uchar *) &macro->exp.tokens[macro->count];
Neil Booth8c3b2692001-09-30 10:03:11 +00001832
Neil Boothcbc69f82002-06-05 20:27:12 +00001833 return true;
1834}
Neil Booth44ed91a2000-10-29 11:37:18 +00001835
Kazu Hiratada7d8302002-09-22 02:03:17 +00001836/* Parse a macro and save its expansion. Returns nonzero on success. */
Neil Boothcbc69f82002-06-05 20:27:12 +00001837bool
Zack Weinberg6cf87ca2003-06-17 06:17:44 +00001838_cpp_create_definition (cpp_reader *pfile, cpp_hashnode *node)
Neil Boothcbc69f82002-06-05 20:27:12 +00001839{
1840 cpp_macro *macro;
1841 unsigned int i;
1842 bool ok;
1843
Geoffrey Keatingd8044162004-06-09 20:10:13 +00001844 if (pfile->hash_table->alloc_subobject)
Gabriel Dos Reisc3f829c2005-05-28 15:52:48 +00001845 macro = (cpp_macro *) pfile->hash_table->alloc_subobject
1846 (sizeof (cpp_macro));
Geoffrey Keatingd8044162004-06-09 20:10:13 +00001847 else
1848 macro = (cpp_macro *) _cpp_aligned_alloc (pfile, sizeof (cpp_macro));
Neil Boothcbc69f82002-06-05 20:27:12 +00001849 macro->line = pfile->directive_line;
1850 macro->params = 0;
1851 macro->paramc = 0;
1852 macro->variadic = 0;
Neil Booth23345bb2003-03-14 21:47:50 +00001853 macro->used = !CPP_OPTION (pfile, warn_unused_macros);
Neil Boothcbc69f82002-06-05 20:27:12 +00001854 macro->count = 0;
1855 macro->fun_like = 0;
Joseph Myersaa508502009-04-19 18:10:56 +01001856 macro->extra_tokens = 0;
Neil Booth7065e132001-02-14 07:38:20 +00001857 /* To suppress some diagnostics. */
Per Bothner12f9df42004-02-11 07:29:30 -08001858 macro->syshdr = pfile->buffer && pfile->buffer->sysp != 0;
Neil Booth7065e132001-02-14 07:38:20 +00001859
Neil Boothcbc69f82002-06-05 20:27:12 +00001860 if (CPP_OPTION (pfile, traditional))
1861 ok = _cpp_create_trad_definition (pfile, macro);
1862 else
1863 {
Neil Boothcbc69f82002-06-05 20:27:12 +00001864 ok = create_iso_definition (pfile, macro);
1865
Tom Tromeyee380362007-01-30 15:46:01 +00001866 /* We set the type for SEEN_EOL() in directives.c.
Neil Boothcbc69f82002-06-05 20:27:12 +00001867
1868 Longer term we should lex the whole line before coming here,
1869 and just copy the expansion. */
Neil Boothcbc69f82002-06-05 20:27:12 +00001870
1871 /* Stop the lexer accepting __VA_ARGS__. */
1872 pfile->state.va_args_ok = 0;
1873 }
1874
1875 /* Clear the fast argument lookup indices. */
1876 for (i = macro->paramc; i-- > 0; )
Zack Weinberg4977bab2002-12-16 18:23:00 +00001877 {
1878 struct cpp_hashnode *node = macro->params[i];
1879 node->flags &= ~ NODE_MACRO_ARG;
1880 node->value = ((union _cpp_hashnode_value *) pfile->macro_buffer)[i];
1881 }
Neil Boothcbc69f82002-06-05 20:27:12 +00001882
1883 if (!ok)
1884 return ok;
1885
Neil Boothc2734e02002-07-26 16:29:31 +00001886 if (node->type == NT_MACRO)
Neil Booth93c803682000-10-28 17:59:06 +00001887 {
Neil Bootha69cbaa2002-07-23 22:57:49 +00001888 if (CPP_OPTION (pfile, warn_unused_macros))
1889 _cpp_warn_if_unused_macro (pfile, node, NULL);
1890
Neil Boothcbc69f82002-06-05 20:27:12 +00001891 if (warn_of_redefinition (pfile, node, macro))
Neil Booth93c803682000-10-28 17:59:06 +00001892 {
Joseph Myers148e4212009-03-29 23:56:07 +01001893 bool warned;
1894 warned = cpp_error_with_line (pfile, CPP_DL_PEDWARN,
1895 pfile->directive_line, 0,
1896 "\"%s\" redefined", NODE_NAME (node));
Neil Booth93c803682000-10-28 17:59:06 +00001897
Joseph Myers148e4212009-03-29 23:56:07 +01001898 if (warned && node->type == NT_MACRO && !(node->flags & NODE_BUILTIN))
1899 cpp_error_with_line (pfile, CPP_DL_NOTE,
Neil Boothcbc69f82002-06-05 20:27:12 +00001900 node->value.macro->line, 0,
1901 "this is the location of the previous definition");
Zack Weinberg711b8822000-07-18 00:59:49 +00001902 }
Zack Weinberg711b8822000-07-18 00:59:49 +00001903 }
1904
Neil Boothc2734e02002-07-26 16:29:31 +00001905 if (node->type != NT_VOID)
1906 _cpp_free_definition (node);
1907
Zack Weinberg711b8822000-07-18 00:59:49 +00001908 /* Enter definition in hash table. */
Neil Booth93c803682000-10-28 17:59:06 +00001909 node->type = NT_MACRO;
1910 node->value.macro = macro;
Tom Tromey607f74e2007-11-30 18:24:01 +00001911 if (! ustrncmp (NODE_NAME (node), DSC ("__STDC_"))
Tom Tromeyec460532008-01-22 21:43:49 +00001912 && ustrcmp (NODE_NAME (node), (const uchar *) "__STDC_FORMAT_MACROS")
1913 /* __STDC_LIMIT_MACROS and __STDC_CONSTANT_MACROS are mentioned
1914 in the C standard, as something that one must use in C++.
1915 However DR#593 indicates that these aren't actually mentioned
1916 in the C++ standard. We special-case them anyway. */
1917 && ustrcmp (NODE_NAME (node), (const uchar *) "__STDC_LIMIT_MACROS")
1918 && ustrcmp (NODE_NAME (node), (const uchar *) "__STDC_CONSTANT_MACROS"))
Neil Booth618cdda2001-02-25 09:43:03 +00001919 node->flags |= NODE_WARN;
Zack Weinberg711b8822000-07-18 00:59:49 +00001920
Ben Elliston5950c3c2008-07-14 05:09:48 +00001921 /* If user defines one of the conditional macros, remove the
1922 conditional flag */
1923 node->flags &= ~NODE_CONDITIONAL;
1924
Neil Booth93c803682000-10-28 17:59:06 +00001925 return ok;
Zack Weinberg711b8822000-07-18 00:59:49 +00001926}
1927
Neil Boothd15a58c2002-01-03 18:32:55 +00001928/* Warn if a token in STRING matches one of a function-like MACRO's
1929 parameters. */
Kaveh R. Ghazie1aa5142000-09-10 03:41:50 +00001930static void
Zack Weinberg6cf87ca2003-06-17 06:17:44 +00001931check_trad_stringification (cpp_reader *pfile, const cpp_macro *macro,
1932 const cpp_string *string)
Kaveh R. Ghazie1aa5142000-09-10 03:41:50 +00001933{
Neil Booth93c803682000-10-28 17:59:06 +00001934 unsigned int i, len;
Neil Booth6338b352003-04-23 22:44:06 +00001935 const uchar *p, *q, *limit;
Kazu Hiratadf383482002-05-22 22:02:16 +00001936
Kaveh R. Ghazie1aa5142000-09-10 03:41:50 +00001937 /* Loop over the string. */
Neil Booth6338b352003-04-23 22:44:06 +00001938 limit = string->text + string->len - 1;
1939 for (p = string->text + 1; p < limit; p = q)
Kaveh R. Ghazie1aa5142000-09-10 03:41:50 +00001940 {
Kaveh R. Ghazie1aa5142000-09-10 03:41:50 +00001941 /* Find the start of an identifier. */
Greg McGary61c16b12000-09-15 21:25:02 +00001942 while (p < limit && !is_idstart (*p))
1943 p++;
Kaveh R. Ghazie1aa5142000-09-10 03:41:50 +00001944
1945 /* Find the end of the identifier. */
1946 q = p;
Greg McGary61c16b12000-09-15 21:25:02 +00001947 while (q < limit && is_idchar (*q))
1948 q++;
Neil Booth93c803682000-10-28 17:59:06 +00001949
1950 len = q - p;
1951
Kaveh R. Ghazie1aa5142000-09-10 03:41:50 +00001952 /* Loop over the function macro arguments to see if the
1953 identifier inside the string matches one of them. */
Neil Booth93c803682000-10-28 17:59:06 +00001954 for (i = 0; i < macro->paramc; i++)
1955 {
1956 const cpp_hashnode *node = macro->params[i];
Kaveh R. Ghazie1aa5142000-09-10 03:41:50 +00001957
Neil Booth2a967f32001-05-20 06:26:45 +00001958 if (NODE_LEN (node) == len
1959 && !memcmp (p, NODE_NAME (node), len))
Kaveh R. Ghazie1aa5142000-09-10 03:41:50 +00001960 {
John David Anglin0527bc42003-11-01 22:56:54 +00001961 cpp_error (pfile, CPP_DL_WARNING,
Zack Weinbergf458d1d2002-02-27 18:48:07 +00001962 "macro argument \"%s\" would be stringified in traditional C",
Neil Boothebef4e82002-04-14 18:42:47 +00001963 NODE_NAME (node));
Kaveh R. Ghazie1aa5142000-09-10 03:41:50 +00001964 break;
1965 }
1966 }
1967 }
1968}
Neil Booth93c803682000-10-28 17:59:06 +00001969
Neil Booth70961712001-06-23 11:34:41 +00001970/* Returns the name, arguments and expansion of a macro, in a format
1971 suitable to be read back in again, and therefore also for DWARF 2
1972 debugging info. e.g. "PASTE(X, Y) X ## Y", or "MACNAME EXPANSION".
1973 Caller is expected to generate the "#define" bit if needed. The
Neil Booth93c803682000-10-28 17:59:06 +00001974 returned text is temporary, and automatically freed later. */
Neil Booth93c803682000-10-28 17:59:06 +00001975const unsigned char *
Zack Weinberg6cf87ca2003-06-17 06:17:44 +00001976cpp_macro_definition (cpp_reader *pfile, const cpp_hashnode *node)
Neil Booth93c803682000-10-28 17:59:06 +00001977{
1978 unsigned int i, len;
1979 const cpp_macro *macro = node->value.macro;
1980 unsigned char *buffer;
1981
1982 if (node->type != NT_MACRO || (node->flags & NODE_BUILTIN))
1983 {
John David Anglin0527bc42003-11-01 22:56:54 +00001984 cpp_error (pfile, CPP_DL_ICE,
Neil Boothebef4e82002-04-14 18:42:47 +00001985 "invalid hash type %d in cpp_macro_definition", node->type);
Neil Booth93c803682000-10-28 17:59:06 +00001986 return 0;
1987 }
1988
1989 /* Calculate length. */
Neil Booth8dc901d2002-05-29 19:30:07 +00001990 len = NODE_LEN (node) + 2; /* ' ' and NUL. */
Neil Booth93c803682000-10-28 17:59:06 +00001991 if (macro->fun_like)
1992 {
Jim Blandy64d08262002-04-05 00:12:40 +00001993 len += 4; /* "()" plus possible final ".." of named
1994 varargs (we have + 1 below). */
Neil Booth93c803682000-10-28 17:59:06 +00001995 for (i = 0; i < macro->paramc; i++)
Jim Blandy64d08262002-04-05 00:12:40 +00001996 len += NODE_LEN (macro->params[i]) + 1; /* "," */
Neil Booth93c803682000-10-28 17:59:06 +00001997 }
1998
Eric Christopher6da55c02005-02-15 23:18:04 +00001999 /* This should match below where we fill in the buffer. */
Neil Booth278c4662002-06-19 05:40:08 +00002000 if (CPP_OPTION (pfile, traditional))
2001 len += _cpp_replacement_text_len (macro);
2002 else
Neil Booth93c803682000-10-28 17:59:06 +00002003 {
Joseph Myersaa508502009-04-19 18:10:56 +01002004 unsigned int count = macro_real_token_count (macro);
2005 for (i = 0; i < count; i++)
Neil Booth278c4662002-06-19 05:40:08 +00002006 {
2007 cpp_token *token = &macro->exp.tokens[i];
Neil Booth93c803682000-10-28 17:59:06 +00002008
Neil Booth278c4662002-06-19 05:40:08 +00002009 if (token->type == CPP_MACRO_ARG)
Joseph Myers9a0c6182009-05-10 15:27:32 +01002010 len += NODE_LEN (macro->params[token->val.macro_arg.arg_no - 1]);
Neil Booth278c4662002-06-19 05:40:08 +00002011 else
Eric Christopher6da55c02005-02-15 23:18:04 +00002012 len += cpp_token_len (token);
2013
Neil Booth278c4662002-06-19 05:40:08 +00002014 if (token->flags & STRINGIFY_ARG)
2015 len++; /* "#" */
2016 if (token->flags & PASTE_LEFT)
2017 len += 3; /* " ##" */
Eric Christopher6da55c02005-02-15 23:18:04 +00002018 if (token->flags & PREV_WHITE)
2019 len++; /* " " */
Neil Booth278c4662002-06-19 05:40:08 +00002020 }
Neil Booth93c803682000-10-28 17:59:06 +00002021 }
2022
2023 if (len > pfile->macro_buffer_len)
Alexandre Oliva4b49c362001-01-09 09:30:43 +00002024 {
Gabriel Dos Reisc3f829c2005-05-28 15:52:48 +00002025 pfile->macro_buffer = XRESIZEVEC (unsigned char,
2026 pfile->macro_buffer, len);
Alexandre Oliva4b49c362001-01-09 09:30:43 +00002027 pfile->macro_buffer_len = len;
2028 }
Neil Booth70961712001-06-23 11:34:41 +00002029
2030 /* Fill in the buffer. Start with the macro name. */
Neil Booth93c803682000-10-28 17:59:06 +00002031 buffer = pfile->macro_buffer;
Neil Booth70961712001-06-23 11:34:41 +00002032 memcpy (buffer, NODE_NAME (node), NODE_LEN (node));
2033 buffer += NODE_LEN (node);
Neil Booth93c803682000-10-28 17:59:06 +00002034
2035 /* Parameter names. */
2036 if (macro->fun_like)
2037 {
2038 *buffer++ = '(';
2039 for (i = 0; i < macro->paramc; i++)
2040 {
2041 cpp_hashnode *param = macro->params[i];
2042
2043 if (param != pfile->spec_nodes.n__VA_ARGS__)
2044 {
Neil Bootha28c50352001-05-16 22:02:09 +00002045 memcpy (buffer, NODE_NAME (param), NODE_LEN (param));
2046 buffer += NODE_LEN (param);
Neil Booth93c803682000-10-28 17:59:06 +00002047 }
2048
2049 if (i + 1 < macro->paramc)
Kazu Hiratadf383482002-05-22 22:02:16 +00002050 /* Don't emit a space after the comma here; we're trying
2051 to emit a Dwarf-friendly definition, and the Dwarf spec
2052 forbids spaces in the argument list. */
Jim Blandy64d08262002-04-05 00:12:40 +00002053 *buffer++ = ',';
Neil Booth28e0f042000-12-09 12:06:37 +00002054 else if (macro->variadic)
Neil Booth93c803682000-10-28 17:59:06 +00002055 *buffer++ = '.', *buffer++ = '.', *buffer++ = '.';
2056 }
2057 *buffer++ = ')';
2058 }
2059
Jim Blandye37b38d2002-03-19 21:43:39 +00002060 /* The Dwarf spec requires a space after the macro name, even if the
2061 definition is the empty string. */
2062 *buffer++ = ' ';
2063
Neil Booth278c4662002-06-19 05:40:08 +00002064 if (CPP_OPTION (pfile, traditional))
2065 buffer = _cpp_copy_replacement_text (macro, buffer);
2066 else if (macro->count)
Neil Booth93c803682000-10-28 17:59:06 +00002067 /* Expansion tokens. */
Neil Booth93c803682000-10-28 17:59:06 +00002068 {
Joseph Myersaa508502009-04-19 18:10:56 +01002069 unsigned int count = macro_real_token_count (macro);
2070 for (i = 0; i < count; i++)
Neil Booth93c803682000-10-28 17:59:06 +00002071 {
Neil Booth601328b2002-05-16 05:53:24 +00002072 cpp_token *token = &macro->exp.tokens[i];
Neil Booth93c803682000-10-28 17:59:06 +00002073
2074 if (token->flags & PREV_WHITE)
2075 *buffer++ = ' ';
2076 if (token->flags & STRINGIFY_ARG)
2077 *buffer++ = '#';
2078
2079 if (token->type == CPP_MACRO_ARG)
2080 {
Neil Bootha28c50352001-05-16 22:02:09 +00002081 memcpy (buffer,
Joseph Myers9a0c6182009-05-10 15:27:32 +01002082 NODE_NAME (macro->params[token->val.macro_arg.arg_no - 1]),
2083 NODE_LEN (macro->params[token->val.macro_arg.arg_no - 1]));
2084 buffer += NODE_LEN (macro->params[token->val.macro_arg.arg_no - 1]);
Neil Booth93c803682000-10-28 17:59:06 +00002085 }
2086 else
Geoffrey Keating47e20492005-03-12 10:44:06 +00002087 buffer = cpp_spell_token (pfile, token, buffer, false);
Neil Booth93c803682000-10-28 17:59:06 +00002088
2089 if (token->flags & PASTE_LEFT)
2090 {
2091 *buffer++ = ' ';
2092 *buffer++ = '#';
2093 *buffer++ = '#';
2094 /* Next has PREV_WHITE; see _cpp_create_definition. */
2095 }
2096 }
2097 }
2098
2099 *buffer = '\0';
2100 return pfile->macro_buffer;
2101}