1 /* CPP Library - traditional lexical analysis and macro expansion.
2 Copyright (C) 2002-2020 Free Software Foundation, Inc.
3 Contributed by Neil Booth, May 2002
5 This program is free software; you can redistribute it and/or modify it
6 under the terms of the GNU General Public License as published by the
7 Free Software Foundation; either version 3, or (at your option) any
10 This program is distributed in the hope that it will be useful,
11 but WITHOUT ANY WARRANTY; without even the implied warranty of
12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 GNU General Public License for more details.
15 You should have received a copy of the GNU General Public License
16 along with this program; see the file COPYING3. If not see
17 <http://www.gnu.org/licenses/>. */
24 /* The replacement text of a function-like macro is stored as a
25 contiguous sequence of aligned blocks, each representing the text
26 between subsequent parameters.
28 Each block comprises the text between its surrounding parameters,
29 the length of that text, and the one-based index of the following
30 parameter. The final block in the replacement text is easily
31 recognizable as it has an argument index of zero. */
35 unsigned int text_len
;
36 unsigned short arg_index
;
40 #define BLOCK_HEADER_LEN offsetof (struct block, text)
41 #define BLOCK_LEN(TEXT_LEN) CPP_ALIGN (BLOCK_HEADER_LEN + (TEXT_LEN))
43 /* Structure holding information about a function-like macro
47 /* Memory buffer holding the trad_arg array. */
50 /* An array of size the number of macro parameters + 1, containing
51 the offsets of the start of each macro argument in the output
52 buffer. The argument continues until the character before the
53 start of the next one. */
56 /* The hashnode of the macro. */
59 /* The offset of the macro name in the output buffer. */
62 /* The line the macro name appeared on. */
65 /* Number of parameters. */
68 /* Zero-based index of argument being currently lexed. */
72 /* Lexing state. It is mostly used to prevent macro expansion. */
73 enum ls
{ls_none
= 0, /* Normal state. */
74 ls_fun_open
, /* When looking for '('. */
75 ls_fun_close
, /* When looking for ')'. */
76 ls_defined
, /* After defined. */
77 ls_defined_close
, /* Looking for ')' of defined(). */
78 ls_hash
, /* After # in preprocessor conditional. */
79 ls_predicate
, /* After the predicate, maybe paren? */
80 ls_answer
/* In answer to predicate. */
83 /* Lexing TODO: Maybe handle space in escaped newlines. Stop lex.c
84 from recognizing comments and directives during its lexing pass. */
86 static const uchar
*skip_whitespace (cpp_reader
*, const uchar
*, int);
87 static cpp_hashnode
*lex_identifier (cpp_reader
*, const uchar
*);
88 static const uchar
*copy_comment (cpp_reader
*, const uchar
*, int);
89 static void check_output_buffer (cpp_reader
*, size_t);
90 static void push_replacement_text (cpp_reader
*, cpp_hashnode
*);
91 static bool scan_parameters (cpp_reader
*, unsigned *);
92 static bool recursive_macro (cpp_reader
*, cpp_hashnode
*);
93 static void save_replacement_text (cpp_reader
*, cpp_macro
*, unsigned int);
94 static void maybe_start_funlike (cpp_reader
*, cpp_hashnode
*, const uchar
*,
96 static void save_argument (struct fun_macro
*, size_t);
97 static void replace_args_and_push (cpp_reader
*, struct fun_macro
*);
98 static size_t canonicalize_text (uchar
*, const uchar
*, size_t, uchar
*);
100 /* Ensures we have N bytes' space in the output buffer, and
101 reallocates it if not. */
103 check_output_buffer (cpp_reader
*pfile
, size_t n
)
105 /* We might need two bytes to terminate an unterminated comment, and
106 one more to terminate the line with a NUL. */
109 if (n
> (size_t) (pfile
->out
.limit
- pfile
->out
.cur
))
111 size_t size
= pfile
->out
.cur
- pfile
->out
.base
;
112 size_t new_size
= (size
+ n
) * 3 / 2;
114 pfile
->out
.base
= XRESIZEVEC (unsigned char, pfile
->out
.base
, new_size
);
115 pfile
->out
.limit
= pfile
->out
.base
+ new_size
;
116 pfile
->out
.cur
= pfile
->out
.base
+ size
;
120 /* Skip a C-style block comment in a macro as a result of -CC.
121 PFILE->buffer->cur points to the initial asterisk of the comment,
122 change it to point to after the '*' and '/' characters that terminate it.
123 Return true if the macro has not been termined, in that case set
124 PFILE->buffer->cur to the end of the buffer. */
126 skip_macro_block_comment (cpp_reader
*pfile
)
128 const uchar
*cur
= pfile
->buffer
->cur
;
134 /* People like decorating comments with '*', so check for '/'
135 instead for efficiency. */
136 while (! (*cur
++ == '/' && cur
[-2] == '*'))
139 pfile
->buffer
->cur
= cur
- 1;
143 pfile
->buffer
->cur
= cur
;
147 /* CUR points to the asterisk introducing a comment in the current
148 context. IN_DEFINE is true if we are in the replacement text of a
151 The asterisk and following comment is copied to the buffer pointed
152 to by pfile->out.cur, which must be of sufficient size.
153 Unterminated comments are diagnosed, and correctly terminated in
154 the output. pfile->out.cur is updated depending upon IN_DEFINE,
155 -C, -CC and pfile->state.in_directive.
157 Returns a pointer to the first character after the comment in the
160 copy_comment (cpp_reader
*pfile
, const uchar
*cur
, int in_define
)
162 bool unterminated
, copy
= false;
163 location_t src_loc
= pfile
->line_table
->highest_line
;
164 cpp_buffer
*buffer
= pfile
->buffer
;
167 if (pfile
->context
->prev
)
168 unterminated
= skip_macro_block_comment (pfile
);
170 unterminated
= _cpp_skip_block_comment (pfile
);
173 cpp_error_with_line (pfile
, CPP_DL_ERROR
, src_loc
, 0,
174 "unterminated comment");
176 /* Comments in directives become spaces so that tokens are properly
177 separated when the ISO preprocessor re-lexes the line. The
178 exception is #define. */
179 if (pfile
->state
.in_directive
)
183 if (CPP_OPTION (pfile
, discard_comments_in_macro_exp
))
189 pfile
->out
.cur
[-1] = ' ';
191 else if (CPP_OPTION (pfile
, discard_comments
))
198 size_t len
= (size_t) (buffer
->cur
- cur
);
199 memcpy (pfile
->out
.cur
, cur
, len
);
200 pfile
->out
.cur
+= len
;
203 *pfile
->out
.cur
++ = '*';
204 *pfile
->out
.cur
++ = '/';
211 /* CUR points to any character in the input buffer. Skips over all
212 contiguous horizontal white space and NULs, including comments if
213 SKIP_COMMENTS, until reaching the first non-horizontal-whitespace
214 character or the end of the current context. Escaped newlines are
217 The whitespace is copied verbatim to the output buffer, except that
218 comments are handled as described in copy_comment().
219 pfile->out.cur is updated.
221 Returns a pointer to the first character after the whitespace in
224 skip_whitespace (cpp_reader
*pfile
, const uchar
*cur
, int skip_comments
)
226 uchar
*out
= pfile
->out
.cur
;
230 unsigned int c
= *cur
++;
236 if (c
== '/' && *cur
== '*' && skip_comments
)
238 pfile
->out
.cur
= out
;
239 cur
= copy_comment (pfile
, cur
, false /* in_define */);
240 out
= pfile
->out
.cur
;
248 pfile
->out
.cur
= out
;
252 /* Lexes and outputs an identifier starting at CUR, which is assumed
253 to point to a valid first character of an identifier. Returns
254 the hashnode, and updates out.cur. */
255 static cpp_hashnode
*
256 lex_identifier (cpp_reader
*pfile
, const uchar
*cur
)
259 uchar
*out
= pfile
->out
.cur
;
260 cpp_hashnode
*result
;
264 while (is_numchar (*cur
));
266 CUR (pfile
->context
) = cur
;
267 len
= out
- pfile
->out
.cur
;
268 result
= CPP_HASHNODE (ht_lookup (pfile
->hash_table
, pfile
->out
.cur
,
270 pfile
->out
.cur
= out
;
274 /* Overlays the true file buffer temporarily with text of length LEN
275 starting at START. The true buffer is restored upon calling
278 _cpp_overlay_buffer (cpp_reader
*pfile
, const uchar
*start
, size_t len
)
280 cpp_buffer
*buffer
= pfile
->buffer
;
282 pfile
->overlaid_buffer
= buffer
;
283 pfile
->saved_cur
= buffer
->cur
;
284 pfile
->saved_rlimit
= buffer
->rlimit
;
285 pfile
->saved_line_base
= buffer
->next_line
;
286 buffer
->need_line
= false;
289 buffer
->line_base
= start
;
290 buffer
->rlimit
= start
+ len
;
293 /* Restores a buffer overlaid by _cpp_overlay_buffer(). */
295 _cpp_remove_overlay (cpp_reader
*pfile
)
297 cpp_buffer
*buffer
= pfile
->overlaid_buffer
;
299 buffer
->cur
= pfile
->saved_cur
;
300 buffer
->rlimit
= pfile
->saved_rlimit
;
301 buffer
->line_base
= pfile
->saved_line_base
;
302 buffer
->need_line
= true;
304 pfile
->overlaid_buffer
= NULL
;
307 /* Reads a logical line into the output buffer. Returns TRUE if there
308 is more text left in the buffer. */
310 _cpp_read_logical_line_trad (cpp_reader
*pfile
)
314 if (pfile
->buffer
->need_line
&& !_cpp_get_fresh_line (pfile
))
316 /* Now pop the buffer that _cpp_get_fresh_line did not. */
317 _cpp_pop_buffer (pfile
);
321 while (!_cpp_scan_out_logical_line (pfile
, NULL
, false)
322 || pfile
->state
.skipping
);
324 return pfile
->buffer
!= NULL
;
327 /* Return true if NODE is a fun_like macro. */
329 fun_like_macro (cpp_hashnode
*node
)
331 if (cpp_builtin_macro_p (node
))
332 return (node
->value
.builtin
== BT_HAS_ATTRIBUTE
333 || node
->value
.builtin
== BT_HAS_BUILTIN
);
334 return node
->value
.macro
->fun_like
;
337 /* Set up state for finding the opening '(' of a function-like
340 maybe_start_funlike (cpp_reader
*pfile
, cpp_hashnode
*node
, const uchar
*start
,
341 struct fun_macro
*macro
)
344 if (cpp_builtin_macro_p (node
))
347 n
= node
->value
.macro
->paramc
;
350 _cpp_release_buff (pfile
, macro
->buff
);
351 macro
->buff
= _cpp_get_buff (pfile
, (n
+ 1) * sizeof (size_t));
352 macro
->args
= (size_t *) BUFF_FRONT (macro
->buff
);
354 macro
->offset
= start
- pfile
->out
.base
;
359 /* Save the OFFSET of the start of the next argument to MACRO. */
361 save_argument (struct fun_macro
*macro
, size_t offset
)
364 if (macro
->argc
<= macro
->paramc
)
365 macro
->args
[macro
->argc
] = offset
;
368 /* Copies the next logical line in the current buffer (starting at
369 buffer->cur) to the output buffer. The output is guaranteed to
370 terminate with a NUL character. buffer->cur is updated.
372 If MACRO is non-NULL, then we are scanning the replacement list of
373 MACRO, and we call save_replacement_text() every time we meet an
376 If BUILTIN_MACRO_ARG is true, this is called to macro expand
377 arguments of builtin function-like macros. */
379 _cpp_scan_out_logical_line (cpp_reader
*pfile
, cpp_macro
*macro
,
380 bool builtin_macro_arg
)
383 cpp_context
*context
;
386 struct fun_macro fmacro
;
387 unsigned int c
, paren_depth
= 0, quote
;
388 enum ls lex_state
= ls_none
;
390 const uchar
*start_of_input_line
;
401 header_ok
= pfile
->state
.angled_headers
;
402 CUR (pfile
->context
) = pfile
->buffer
->cur
;
403 RLIMIT (pfile
->context
) = pfile
->buffer
->rlimit
;
404 if (!builtin_macro_arg
)
406 pfile
->out
.cur
= pfile
->out
.base
;
407 pfile
->out
.first_line
= pfile
->line_table
->highest_line
;
409 /* start_of_input_line is needed to make sure that directives really,
410 really start at the first character of the line. */
411 start_of_input_line
= pfile
->buffer
->cur
;
413 context
= pfile
->context
;
415 check_output_buffer (pfile
, RLIMIT (context
) - cur
);
416 out
= pfile
->out
.cur
;
421 && !builtin_macro_arg
422 && cur
>= pfile
->buffer
->notes
[pfile
->buffer
->cur_note
].pos
)
424 pfile
->buffer
->cur
= cur
;
425 _cpp_process_line_notes (pfile
, false);
430 /* Whitespace should "continue" out of the switch,
431 non-whitespace should "break" out of it. */
442 /* If this is a macro's expansion, pop it. */
445 pfile
->out
.cur
= out
- 1;
446 _cpp_pop_context (pfile
);
450 /* Omit the newline from the output buffer. */
451 pfile
->out
.cur
= out
- 1;
452 pfile
->buffer
->cur
= cur
;
453 if (builtin_macro_arg
)
455 pfile
->buffer
->need_line
= true;
456 CPP_INCREMENT_LINE (pfile
, 0);
458 if ((lex_state
== ls_fun_open
|| lex_state
== ls_fun_close
)
459 && !pfile
->state
.in_directive
460 && _cpp_get_fresh_line (pfile
))
462 /* Newlines in arguments become a space, but we don't
463 clear any in-progress quote. */
464 if (lex_state
== ls_fun_close
)
466 cur
= pfile
->buffer
->cur
;
489 /* Skip escaped quotes here, it's easier than above. */
490 if (*cur
== '\\' || *cur
== '"' || *cur
== '\'')
495 /* Traditional CPP does not recognize comments within
497 if (!quote
&& *cur
== '*')
499 pfile
->out
.cur
= out
;
500 cur
= copy_comment (pfile
, cur
, macro
!= 0);
501 out
= pfile
->out
.cur
;
507 case 'a': case 'b': case 'c': case 'd': case 'e': case 'f':
508 case 'g': case 'h': case 'i': case 'j': case 'k': case 'l':
509 case 'm': case 'n': case 'o': case 'p': case 'q': case 'r':
510 case 's': case 't': case 'u': case 'v': case 'w': case 'x':
512 case 'A': case 'B': case 'C': case 'D': case 'E': case 'F':
513 case 'G': case 'H': case 'I': case 'J': case 'K': case 'L':
514 case 'M': case 'N': case 'O': case 'P': case 'Q': case 'R':
515 case 'S': case 'T': case 'U': case 'V': case 'W': case 'X':
517 if (!pfile
->state
.skipping
&& (quote
== 0 || macro
))
520 uchar
*out_start
= out
- 1;
522 pfile
->out
.cur
= out_start
;
523 node
= lex_identifier (pfile
, cur
- 1);
524 out
= pfile
->out
.cur
;
527 if (cpp_macro_p (node
)
528 /* Should we expand for ls_answer? */
529 && (lex_state
== ls_none
|| lex_state
== ls_fun_open
)
530 && !pfile
->state
.prevent_expansion
)
532 /* Macros invalidate MI optimization. */
533 pfile
->mi_valid
= false;
534 if (fun_like_macro (node
))
536 maybe_start_funlike (pfile
, node
, out_start
, &fmacro
);
537 lex_state
= ls_fun_open
;
538 fmacro
.line
= pfile
->line_table
->highest_line
;
541 else if (!recursive_macro (pfile
, node
))
543 /* Remove the object-like macro's name from the
544 output, and push its replacement text. */
545 pfile
->out
.cur
= out_start
;
546 push_replacement_text (pfile
, node
);
551 else if (macro
&& node
->type
== NT_MACRO_ARG
)
553 /* Found a parameter in the replacement text of a
554 #define. Remove its name from the output. */
555 pfile
->out
.cur
= out_start
;
556 save_replacement_text (pfile
, macro
, node
->value
.arg_index
);
557 out
= pfile
->out
.base
;
559 else if (lex_state
== ls_hash
)
561 lex_state
= ls_predicate
;
564 else if (pfile
->state
.in_expression
565 && node
== pfile
->spec_nodes
.n_defined
)
567 lex_state
= ls_defined
;
577 if (lex_state
== ls_fun_open
)
579 if (recursive_macro (pfile
, fmacro
.node
))
583 lex_state
= ls_fun_close
;
585 out
= pfile
->out
.base
+ fmacro
.offset
;
586 fmacro
.args
[0] = fmacro
.offset
;
589 else if (lex_state
== ls_predicate
)
590 lex_state
= ls_answer
;
591 else if (lex_state
== ls_defined
)
592 lex_state
= ls_defined_close
;
597 if (quote
== 0 && lex_state
== ls_fun_close
&& paren_depth
== 1)
598 save_argument (&fmacro
, out
- pfile
->out
.base
);
605 if (lex_state
== ls_fun_close
&& paren_depth
== 0)
607 if (cpp_builtin_macro_p (fmacro
.node
))
609 /* Handle builtin function-like macros like
610 __has_attribute. The already parsed arguments
611 are put into a buffer, which is then preprocessed
612 and the result is fed to _cpp_push_text_context
613 with disabled expansion, where the ISO preprocessor
614 parses it. While in traditional preprocessing
615 macro arguments aren't immediately expanded, they in
616 the end are because the macro with replaced arguments
617 is preprocessed again. For the builtin function-like
618 macros we need the argument immediately though,
619 if we don't preprocess them, they would behave
620 very differently from ISO preprocessor handling
621 of those builtin macros. So, this handling is
622 more similar to traditional preprocessing of
623 #if directives, where we also keep preprocessing
624 until everything is expanded, and then feed the
625 result with disabled expansion to ISO preprocessor
626 for handling the directives. */
628 save_argument (&fmacro
, out
- pfile
->out
.base
);
630 memset (&m
, '\0', sizeof (m
));
631 m
.paramc
= fmacro
.paramc
;
632 if (_cpp_arguments_ok (pfile
, &m
, fmacro
.node
,
635 size_t len
= fmacro
.args
[1] - fmacro
.args
[0];
638 /* Remove the macro's invocation from the
639 output, and push its replacement text. */
640 pfile
->out
.cur
= pfile
->out
.base
+ fmacro
.offset
;
642 buf
= _cpp_unaligned_alloc (pfile
, len
+ 2);
644 memcpy (buf
+ 1, pfile
->out
.base
+ fmacro
.args
[0],
648 const unsigned char *ctx_rlimit
= RLIMIT (context
);
649 const unsigned char *saved_cur
= pfile
->buffer
->cur
;
650 const unsigned char *saved_rlimit
651 = pfile
->buffer
->rlimit
;
652 const unsigned char *saved_line_base
653 = pfile
->buffer
->line_base
;
654 bool saved_need_line
= pfile
->buffer
->need_line
;
655 cpp_buffer
*saved_overlaid_buffer
656 = pfile
->overlaid_buffer
;
657 pfile
->buffer
->cur
= buf
;
658 pfile
->buffer
->line_base
= buf
;
659 pfile
->buffer
->rlimit
= buf
+ len
+ 1;
660 pfile
->buffer
->need_line
= false;
661 pfile
->overlaid_buffer
= pfile
->buffer
;
662 bool saved_in_directive
= pfile
->state
.in_directive
;
663 pfile
->state
.in_directive
= true;
664 cpp_context
*saved_prev_context
= context
->prev
;
665 context
->prev
= NULL
;
667 _cpp_scan_out_logical_line (pfile
, NULL
, true);
669 pfile
->state
.in_directive
= saved_in_directive
;
670 check_output_buffer (pfile
, 1);
671 *pfile
->out
.cur
= '\n';
672 pfile
->buffer
->cur
= pfile
->out
.base
+ fmacro
.offset
;
673 pfile
->buffer
->line_base
= pfile
->buffer
->cur
;
674 pfile
->buffer
->rlimit
= pfile
->out
.cur
;
675 CUR (context
) = pfile
->buffer
->cur
;
676 RLIMIT (context
) = pfile
->buffer
->rlimit
;
678 pfile
->state
.prevent_expansion
++;
680 = _cpp_builtin_macro_text (pfile
, fmacro
.node
);
681 pfile
->state
.prevent_expansion
--;
683 context
->prev
= saved_prev_context
;
684 pfile
->buffer
->cur
= saved_cur
;
685 pfile
->buffer
->rlimit
= saved_rlimit
;
686 pfile
->buffer
->line_base
= saved_line_base
;
687 pfile
->buffer
->need_line
= saved_need_line
;
688 pfile
->overlaid_buffer
= saved_overlaid_buffer
;
689 pfile
->out
.cur
= pfile
->out
.base
+ fmacro
.offset
;
691 RLIMIT (context
) = ctx_rlimit
;
692 len
= ustrlen (text
);
693 buf
= _cpp_unaligned_alloc (pfile
, len
+ 1);
694 memcpy (buf
, text
, len
);
697 _cpp_push_text_context (pfile
, fmacro
.node
,
704 cpp_macro
*m
= fmacro
.node
->value
.macro
;
708 save_argument (&fmacro
, out
- pfile
->out
.base
);
710 /* A single zero-length argument is no argument. */
713 && out
== pfile
->out
.base
+ fmacro
.offset
+ 1)
716 if (_cpp_arguments_ok (pfile
, m
, fmacro
.node
, fmacro
.argc
))
718 /* Remove the macro's invocation from the
719 output, and push its replacement text. */
720 pfile
->out
.cur
= pfile
->out
.base
+ fmacro
.offset
;
722 replace_args_and_push (pfile
, &fmacro
);
726 else if (lex_state
== ls_answer
|| lex_state
== ls_defined_close
)
732 if (cur
- 1 == start_of_input_line
733 /* A '#' from a macro doesn't start a directive. */
734 && !pfile
->context
->prev
735 && !pfile
->state
.in_directive
)
737 /* A directive. With the way _cpp_handle_directive
738 currently works, we only want to call it if either we
739 know the directive is OK, or we want it to fail and
740 be removed from the output. If we want it to be
741 passed through (the assembler case) then we must not
742 call _cpp_handle_directive. */
743 pfile
->out
.cur
= out
;
744 cur
= skip_whitespace (pfile
, cur
, true /* skip_comments */);
745 out
= pfile
->out
.cur
;
749 /* Null directive. Ignore it and don't invalidate
750 the MI optimization. */
751 pfile
->buffer
->need_line
= true;
752 CPP_INCREMENT_LINE (pfile
, 0);
760 if (is_numstart (*cur
)
761 && CPP_OPTION (pfile
, lang
) != CLK_ASM
)
763 else if (is_idstart (*cur
))
764 /* Check whether we know this directive, but don't
766 do_it
= lex_identifier (pfile
, cur
)->is_directive
;
768 if (do_it
|| CPP_OPTION (pfile
, lang
) != CLK_ASM
)
770 /* This is a kludge. We want to have the ISO
771 preprocessor lex the next token. */
772 pfile
->buffer
->cur
= cur
;
773 _cpp_handle_directive (pfile
, false /* indented */);
780 if (pfile
->state
.in_expression
)
791 /* Non-whitespace disables MI optimization and stops treating
792 '<' as a quote in #include. */
794 if (!pfile
->state
.in_directive
)
795 pfile
->mi_valid
= false;
797 if (lex_state
== ls_none
)
800 /* Some of these transitions of state are syntax errors. The
801 ISO preprocessor will issue errors later. */
802 if (lex_state
== ls_fun_open
)
805 else if (lex_state
== ls_hash
806 || lex_state
== ls_predicate
807 || lex_state
== ls_defined
)
810 /* ls_answer and ls_defined_close keep going until ')'. */
815 _cpp_release_buff (pfile
, fmacro
.buff
);
817 if (lex_state
== ls_fun_close
)
818 cpp_error_with_line (pfile
, CPP_DL_ERROR
, fmacro
.line
, 0,
819 "unterminated argument list invoking macro \"%s\"",
820 NODE_NAME (fmacro
.node
));
824 /* Push a context holding the replacement text of the macro NODE on
825 the context stack. NODE is either object-like, or a function-like
826 macro with no arguments. */
828 push_replacement_text (cpp_reader
*pfile
, cpp_hashnode
*node
)
834 if (cpp_builtin_macro_p (node
))
836 text
= _cpp_builtin_macro_text (pfile
, node
);
837 len
= ustrlen (text
);
838 buf
= _cpp_unaligned_alloc (pfile
, len
+ 1);
839 memcpy (buf
, text
, len
);
845 cpp_macro
*macro
= node
->value
.macro
;
847 text
= macro
->exp
.text
;
851 _cpp_push_text_context (pfile
, node
, text
, len
);
854 /* Returns TRUE if traditional macro recursion is detected. */
856 recursive_macro (cpp_reader
*pfile
, cpp_hashnode
*node
)
858 bool recursing
= !!(node
->flags
& NODE_DISABLED
);
860 /* Object-like macros that are already expanding are necessarily
863 However, it is possible to have traditional function-like macros
864 that are not infinitely recursive but recurse to any given depth.
865 Further, it is easy to construct examples that get ever longer
866 until the point they stop recursing. So there is no easy way to
867 detect true recursion; instead we assume any expansion more than
868 20 deep since the first invocation of this macro must be
870 if (recursing
&& fun_like_macro (node
))
873 cpp_context
*context
= pfile
->context
;
878 if (context
->c
.macro
== node
&& depth
> 20)
880 context
= context
->prev
;
883 recursing
= context
!= NULL
;
887 cpp_error (pfile
, CPP_DL_ERROR
,
888 "detected recursion whilst expanding macro \"%s\"",
894 /* Return the length of the replacement text of a function-like or
895 object-like non-builtin macro. */
897 _cpp_replacement_text_len (const cpp_macro
*macro
)
901 if (macro
->fun_like
&& (macro
->paramc
!= 0))
906 for (exp
= macro
->exp
.text
;;)
908 struct block
*b
= (struct block
*) exp
;
911 if (b
->arg_index
== 0)
913 len
+= NODE_LEN (macro
->parm
.params
[b
->arg_index
- 1]);
914 exp
+= BLOCK_LEN (b
->text_len
);
923 /* Copy the replacement text of MACRO to DEST, which must be of
924 sufficient size. It is not NUL-terminated. The next character is
927 _cpp_copy_replacement_text (const cpp_macro
*macro
, uchar
*dest
)
929 if (macro
->fun_like
&& (macro
->paramc
!= 0))
933 for (exp
= macro
->exp
.text
;;)
935 struct block
*b
= (struct block
*) exp
;
938 memcpy (dest
, b
->text
, b
->text_len
);
940 if (b
->arg_index
== 0)
942 param
= macro
->parm
.params
[b
->arg_index
- 1];
943 memcpy (dest
, NODE_NAME (param
), NODE_LEN (param
));
944 dest
+= NODE_LEN (param
);
945 exp
+= BLOCK_LEN (b
->text_len
);
950 memcpy (dest
, macro
->exp
.text
, macro
->count
);
951 dest
+= macro
->count
;
957 /* Push a context holding the replacement text of the macro NODE on
958 the context stack. NODE is either object-like, or a function-like
959 macro with no arguments. */
961 replace_args_and_push (cpp_reader
*pfile
, struct fun_macro
*fmacro
)
963 cpp_macro
*macro
= fmacro
->node
->value
.macro
;
965 if (macro
->paramc
== 0)
966 push_replacement_text (pfile
, fmacro
->node
);
975 /* Get an estimate of the length of the argument-replaced text.
976 This is a worst case estimate, assuming that every replacement
977 text character needs quoting. */
978 for (exp
= macro
->exp
.text
;;)
980 struct block
*b
= (struct block
*) exp
;
983 if (b
->arg_index
== 0)
985 len
+= 2 * (fmacro
->args
[b
->arg_index
]
986 - fmacro
->args
[b
->arg_index
- 1] - 1);
987 exp
+= BLOCK_LEN (b
->text_len
);
990 /* Allocate room for the expansion plus \n. */
991 buff
= _cpp_get_buff (pfile
, len
+ 1);
993 /* Copy the expansion and replace arguments. */
994 /* Accumulate actual length, including quoting as necessary */
995 p
= BUFF_FRONT (buff
);
997 for (exp
= macro
->exp
.text
;;)
999 struct block
*b
= (struct block
*) exp
;
1006 /* Copy the non-argument text literally, keeping
1007 track of whether matching quotes have been seen. */
1008 for (arglen
= b
->text_len
, in
= b
->text
; arglen
> 0; arglen
--)
1011 cxtquote
= ! cxtquote
;
1014 /* Done if no more arguments */
1015 if (b
->arg_index
== 0)
1017 arglen
= (fmacro
->args
[b
->arg_index
]
1018 - fmacro
->args
[b
->arg_index
- 1] - 1);
1019 base
= pfile
->out
.base
+ fmacro
->args
[b
->arg_index
- 1];
1022 /* Skip leading whitespace in the text for the argument to
1023 be substituted. To be compatible with gcc 2.95, we would
1024 also need to trim trailing whitespace. Gcc 2.95 trims
1025 leading and trailing whitespace, which may be a bug. The
1026 current gcc testsuite explicitly checks that this leading
1027 and trailing whitespace in actual arguments is
1029 while (arglen
> 0 && is_space (*in
))
1035 for (argquote
= 0; arglen
> 0; arglen
--)
1037 if (cxtquote
&& *in
== '"')
1039 if (in
> base
&& *(in
-1) != '\\')
1040 argquote
= ! argquote
;
1041 /* Always add backslash before double quote if argument
1042 is expanded in a quoted context */
1046 else if (cxtquote
&& argquote
&& *in
== '\\')
1048 /* Always add backslash before a backslash in an argument
1049 that is expanded in a quoted context and also in the
1050 range of a quoted context in the argument itself. */
1057 exp
+= BLOCK_LEN (b
->text_len
);
1062 _cpp_push_text_context (pfile
, fmacro
->node
, BUFF_FRONT (buff
), len
);
1064 /* So we free buffer allocation when macro is left. */
1065 pfile
->context
->buff
= buff
;
1069 /* Read and record the parameters, if any, of a function-like macro
1070 definition. Destroys pfile->out.cur.
1072 Returns true on success, false on failure (syntax error or a
1073 duplicate parameter). On success, CUR (pfile->context) is just
1074 past the closing parenthesis. */
1076 scan_parameters (cpp_reader
*pfile
, unsigned *n_ptr
)
1078 const uchar
*cur
= CUR (pfile
->context
) + 1;
1081 unsigned nparms
= 0;
1084 cur
= skip_whitespace (pfile
, cur
, true /* skip_comments */);
1086 if (is_idstart (*cur
))
1088 struct cpp_hashnode
*id
= lex_identifier (pfile
, cur
);
1090 if (!_cpp_save_parameter (pfile
, nparms
, id
, id
))
1093 cur
= skip_whitespace (pfile
, CUR (pfile
->context
),
1094 true /* skip_comments */);
1104 ok
= (*cur
== ')' && !nparms
);
1111 cpp_error (pfile
, CPP_DL_ERROR
, "syntax error in macro parameter list");
1113 CUR (pfile
->context
) = cur
+ (*cur
== ')');
1118 /* Save the text from pfile->out.base to pfile->out.cur as
1119 the replacement text for the current macro, followed by argument
1120 ARG_INDEX, with zero indicating the end of the replacement
1123 save_replacement_text (cpp_reader
*pfile
, cpp_macro
*macro
,
1124 unsigned int arg_index
)
1126 size_t len
= pfile
->out
.cur
- pfile
->out
.base
;
1129 if (macro
->paramc
== 0)
1131 /* Object-like and function-like macros without parameters
1132 simply store their \n-terminated replacement text. */
1133 exp
= _cpp_unaligned_alloc (pfile
, len
+ 1);
1134 memcpy (exp
, pfile
->out
.base
, len
);
1136 macro
->exp
.text
= exp
;
1141 /* Store the text's length (unsigned int), the argument index
1142 (unsigned short, base 1) and then the text. */
1143 size_t blen
= BLOCK_LEN (len
);
1144 struct block
*block
;
1146 if (macro
->count
+ blen
> BUFF_ROOM (pfile
->a_buff
))
1147 _cpp_extend_buff (pfile
, &pfile
->a_buff
, macro
->count
+ blen
);
1149 exp
= BUFF_FRONT (pfile
->a_buff
);
1150 block
= (struct block
*) (exp
+ macro
->count
);
1151 macro
->exp
.text
= exp
;
1153 /* Write out the block information. */
1154 block
->text_len
= len
;
1155 block
->arg_index
= arg_index
;
1156 memcpy (block
->text
, pfile
->out
.base
, len
);
1158 /* Lex the rest into the start of the output buffer. */
1159 pfile
->out
.cur
= pfile
->out
.base
;
1161 macro
->count
+= blen
;
1163 /* If we've finished, commit the memory. */
1165 BUFF_FRONT (pfile
->a_buff
) += macro
->count
;
1169 /* Analyze and save the replacement text of a macro. Returns true on
1172 _cpp_create_trad_definition (cpp_reader
*pfile
)
1176 cpp_context
*context
= pfile
->context
;
1177 unsigned nparms
= 0;
1179 cpp_hashnode
**params
= NULL
;
1181 /* The context has not been set up for command line defines, and CUR
1182 has not been updated for the macro name for in-file defines. */
1183 pfile
->out
.cur
= pfile
->out
.base
;
1184 CUR (context
) = pfile
->buffer
->cur
;
1185 RLIMIT (context
) = pfile
->buffer
->rlimit
;
1186 check_output_buffer (pfile
, RLIMIT (context
) - CUR (context
));
1188 /* Is this a function-like macro? */
1189 if (* CUR (context
) == '(')
1192 if (scan_parameters (pfile
, &nparms
))
1193 params
= (cpp_hashnode
**)_cpp_commit_buff
1194 (pfile
, sizeof (cpp_hashnode
*) * nparms
);
1199 cpp_macro
*macro
= NULL
;
1203 macro
= _cpp_new_macro (pfile
, cmk_traditional
,
1204 _cpp_aligned_alloc (pfile
, sizeof (cpp_macro
)));
1205 macro
->parm
.params
= params
;
1206 macro
->paramc
= nparms
;
1207 macro
->fun_like
= fun_like
!= 0;
1210 /* Skip leading whitespace in the replacement text. */
1212 = skip_whitespace (pfile
, CUR (context
),
1213 CPP_OPTION (pfile
, discard_comments_in_macro_exp
));
1215 pfile
->state
.prevent_expansion
++;
1216 _cpp_scan_out_logical_line (pfile
, macro
, false);
1217 pfile
->state
.prevent_expansion
--;
1219 _cpp_unsave_parameters (pfile
, nparms
);
1223 /* Skip trailing white space. */
1224 cur
= pfile
->out
.base
;
1225 limit
= pfile
->out
.cur
;
1226 while (limit
> cur
&& is_space (limit
[-1]))
1228 pfile
->out
.cur
= limit
;
1229 save_replacement_text (pfile
, macro
, 0);
1235 /* Copy SRC of length LEN to DEST, but convert all contiguous
1236 whitespace to a single space, provided it is not in quotes. The
1237 quote currently in effect is pointed to by PQUOTE, and is updated
1238 by the function. Returns the number of bytes copied. */
1240 canonicalize_text (uchar
*dest
, const uchar
*src
, size_t len
, uchar
*pquote
)
1242 uchar
*orig_dest
= dest
;
1243 uchar quote
= *pquote
;
1247 if (is_space (*src
) && !quote
)
1251 while (len
&& is_space (*src
));
1256 if (*src
== '\'' || *src
== '"')
1260 else if (quote
== *src
)
1263 *dest
++ = *src
++, len
--;
1268 return dest
- orig_dest
;
1271 /* Returns true if MACRO1 and MACRO2 have expansions different other
1272 than in the form of their whitespace. */
1274 _cpp_expansions_different_trad (const cpp_macro
*macro1
,
1275 const cpp_macro
*macro2
)
1277 uchar
*p1
= XNEWVEC (uchar
, macro1
->count
+ macro2
->count
);
1278 uchar
*p2
= p1
+ macro1
->count
;
1279 uchar quote1
= 0, quote2
= 0;
1283 if (macro1
->paramc
> 0)
1285 const uchar
*exp1
= macro1
->exp
.text
, *exp2
= macro2
->exp
.text
;
1290 struct block
*b1
= (struct block
*) exp1
;
1291 struct block
*b2
= (struct block
*) exp2
;
1293 if (b1
->arg_index
!= b2
->arg_index
)
1296 len1
= canonicalize_text (p1
, b1
->text
, b1
->text_len
, "e1
);
1297 len2
= canonicalize_text (p2
, b2
->text
, b2
->text_len
, "e2
);
1298 if (len1
!= len2
|| memcmp (p1
, p2
, len1
))
1300 if (b1
->arg_index
== 0)
1305 exp1
+= BLOCK_LEN (b1
->text_len
);
1306 exp2
+= BLOCK_LEN (b2
->text_len
);
1311 len1
= canonicalize_text (p1
, macro1
->exp
.text
, macro1
->count
, "e1
);
1312 len2
= canonicalize_text (p2
, macro2
->exp
.text
, macro2
->count
, "e2
);
1313 mismatch
= (len1
!= len2
|| memcmp (p1
, p2
, len1
));