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