Mercurial > hg > CbC > CbC_gcc

comparison libcpp/macro.c @ 0:a06113de4d67

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
first commit
author kent <kent@cr.ie.u-ryukyu.ac.jp>
date Fri, 17 Jul 2009 14:47:48 +0900
parents
children 855418dad1a3
comparison
equal deleted inserted replaced
-1:000000000000 0:a06113de4d67
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 (&macro1->exp.tokens[i], &macro2->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 *) &macro->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 *) &macro->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 = &macro->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 = &macro->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 }