1 /* CPP Library - traditional lexical analysis and macro expansion.
2 Copyright (C) 2002-2016 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. */
81 ls_has_include
, /* After __has_include__. */
82 ls_has_include_close
}; /* Looking for ')' of __has_include__. */
84 /* Lexing TODO: Maybe handle space in escaped newlines. Stop lex.c
85 from recognizing comments and directives during its lexing pass. */
87 static const uchar
*skip_whitespace (cpp_reader
*, const uchar
*, int);
88 static cpp_hashnode
*lex_identifier (cpp_reader
*, const uchar
*);
89 static const uchar
*copy_comment (cpp_reader
*, const uchar
*, int);
90 static void check_output_buffer (cpp_reader
*, size_t);
91 static void push_replacement_text (cpp_reader
*, cpp_hashnode
*);
92 static bool scan_parameters (cpp_reader
*, cpp_macro
*);
93 static bool recursive_macro (cpp_reader
*, cpp_hashnode
*);
94 static void save_replacement_text (cpp_reader
*, cpp_macro
*, unsigned int);
95 static void maybe_start_funlike (cpp_reader
*, cpp_hashnode
*, const uchar
*,
97 static void save_argument (struct fun_macro
*, size_t);
98 static void replace_args_and_push (cpp_reader
*, struct fun_macro
*);
99 static size_t canonicalize_text (uchar
*, const uchar
*, size_t, uchar
*);
101 /* Ensures we have N bytes' space in the output buffer, and
102 reallocates it if not. */
104 check_output_buffer (cpp_reader
*pfile
, size_t n
)
106 /* We might need two bytes to terminate an unterminated comment, and
107 one more to terminate the line with a NUL. */
110 if (n
> (size_t) (pfile
->out
.limit
- pfile
->out
.cur
))
112 size_t size
= pfile
->out
.cur
- pfile
->out
.base
;
113 size_t new_size
= (size
+ n
) * 3 / 2;
115 pfile
->out
.base
= XRESIZEVEC (unsigned char, pfile
->out
.base
, new_size
);
116 pfile
->out
.limit
= pfile
->out
.base
+ new_size
;
117 pfile
->out
.cur
= pfile
->out
.base
+ size
;
121 /* Skip a C-style block comment in a macro as a result of -CC.
122 Buffer->cur points to the initial asterisk of the comment. */
124 skip_macro_block_comment (cpp_reader
*pfile
)
126 const uchar
*cur
= pfile
->buffer
->cur
;
132 /* People like decorating comments with '*', so check for '/'
133 instead for efficiency. */
134 while(! (*cur
++ == '/' && cur
[-2] == '*') )
137 pfile
->buffer
->cur
= cur
;
140 /* CUR points to the asterisk introducing a comment in the current
141 context. IN_DEFINE is true if we are in the replacement text of a
144 The asterisk and following comment is copied to the buffer pointed
145 to by pfile->out.cur, which must be of sufficient size.
146 Unterminated comments are diagnosed, and correctly terminated in
147 the output. pfile->out.cur is updated depending upon IN_DEFINE,
148 -C, -CC and pfile->state.in_directive.
150 Returns a pointer to the first character after the comment in the
153 copy_comment (cpp_reader
*pfile
, const uchar
*cur
, int in_define
)
155 bool unterminated
, copy
= false;
156 source_location src_loc
= pfile
->line_table
->highest_line
;
157 cpp_buffer
*buffer
= pfile
->buffer
;
160 if (pfile
->context
->prev
)
161 unterminated
= false, skip_macro_block_comment (pfile
);
163 unterminated
= _cpp_skip_block_comment (pfile
);
166 cpp_error_with_line (pfile
, CPP_DL_ERROR
, src_loc
, 0,
167 "unterminated comment");
169 /* Comments in directives become spaces so that tokens are properly
170 separated when the ISO preprocessor re-lexes the line. The
171 exception is #define. */
172 if (pfile
->state
.in_directive
)
176 if (CPP_OPTION (pfile
, discard_comments_in_macro_exp
))
182 pfile
->out
.cur
[-1] = ' ';
184 else if (CPP_OPTION (pfile
, discard_comments
))
191 size_t len
= (size_t) (buffer
->cur
- cur
);
192 memcpy (pfile
->out
.cur
, cur
, len
);
193 pfile
->out
.cur
+= len
;
196 *pfile
->out
.cur
++ = '*';
197 *pfile
->out
.cur
++ = '/';
204 /* CUR points to any character in the input buffer. Skips over all
205 contiguous horizontal white space and NULs, including comments if
206 SKIP_COMMENTS, until reaching the first non-horizontal-whitespace
207 character or the end of the current context. Escaped newlines are
210 The whitespace is copied verbatim to the output buffer, except that
211 comments are handled as described in copy_comment().
212 pfile->out.cur is updated.
214 Returns a pointer to the first character after the whitespace in
217 skip_whitespace (cpp_reader
*pfile
, const uchar
*cur
, int skip_comments
)
219 uchar
*out
= pfile
->out
.cur
;
223 unsigned int c
= *cur
++;
229 if (c
== '/' && *cur
== '*' && skip_comments
)
231 pfile
->out
.cur
= out
;
232 cur
= copy_comment (pfile
, cur
, false /* in_define */);
233 out
= pfile
->out
.cur
;
241 pfile
->out
.cur
= out
;
245 /* Lexes and outputs an identifier starting at CUR, which is assumed
246 to point to a valid first character of an identifier. Returns
247 the hashnode, and updates out.cur. */
248 static cpp_hashnode
*
249 lex_identifier (cpp_reader
*pfile
, const uchar
*cur
)
252 uchar
*out
= pfile
->out
.cur
;
253 cpp_hashnode
*result
;
257 while (is_numchar (*cur
));
259 CUR (pfile
->context
) = cur
;
260 len
= out
- pfile
->out
.cur
;
261 result
= CPP_HASHNODE (ht_lookup (pfile
->hash_table
, pfile
->out
.cur
,
263 pfile
->out
.cur
= out
;
267 /* Overlays the true file buffer temporarily with text of length LEN
268 starting at START. The true buffer is restored upon calling
271 _cpp_overlay_buffer (cpp_reader
*pfile
, const uchar
*start
, size_t len
)
273 cpp_buffer
*buffer
= pfile
->buffer
;
275 pfile
->overlaid_buffer
= buffer
;
276 pfile
->saved_cur
= buffer
->cur
;
277 pfile
->saved_rlimit
= buffer
->rlimit
;
278 pfile
->saved_line_base
= buffer
->next_line
;
279 buffer
->need_line
= false;
282 buffer
->line_base
= start
;
283 buffer
->rlimit
= start
+ len
;
286 /* Restores a buffer overlaid by _cpp_overlay_buffer(). */
288 _cpp_remove_overlay (cpp_reader
*pfile
)
290 cpp_buffer
*buffer
= pfile
->overlaid_buffer
;
292 buffer
->cur
= pfile
->saved_cur
;
293 buffer
->rlimit
= pfile
->saved_rlimit
;
294 buffer
->line_base
= pfile
->saved_line_base
;
295 buffer
->need_line
= true;
297 pfile
->overlaid_buffer
= NULL
;
300 /* Reads a logical line into the output buffer. Returns TRUE if there
301 is more text left in the buffer. */
303 _cpp_read_logical_line_trad (cpp_reader
*pfile
)
307 if (pfile
->buffer
->need_line
&& !_cpp_get_fresh_line (pfile
))
310 while (!_cpp_scan_out_logical_line (pfile
, NULL
, false)
311 || pfile
->state
.skipping
);
313 return pfile
->buffer
!= NULL
;
316 /* Return true if NODE is a fun_like macro. */
318 fun_like_macro (cpp_hashnode
*node
)
320 if (node
->flags
& NODE_BUILTIN
)
321 return node
->value
.builtin
== BT_HAS_ATTRIBUTE
;
323 return node
->value
.macro
->fun_like
;
326 /* Set up state for finding the opening '(' of a function-like
329 maybe_start_funlike (cpp_reader
*pfile
, cpp_hashnode
*node
, const uchar
*start
,
330 struct fun_macro
*macro
)
333 if (node
->flags
& NODE_BUILTIN
)
336 n
= node
->value
.macro
->paramc
;
339 _cpp_release_buff (pfile
, macro
->buff
);
340 macro
->buff
= _cpp_get_buff (pfile
, (n
+ 1) * sizeof (size_t));
341 macro
->args
= (size_t *) BUFF_FRONT (macro
->buff
);
343 macro
->offset
= start
- pfile
->out
.base
;
348 /* Save the OFFSET of the start of the next argument to MACRO. */
350 save_argument (struct fun_macro
*macro
, size_t offset
)
353 if (macro
->argc
<= macro
->paramc
)
354 macro
->args
[macro
->argc
] = offset
;
357 /* Copies the next logical line in the current buffer (starting at
358 buffer->cur) to the output buffer. The output is guaranteed to
359 terminate with a NUL character. buffer->cur is updated.
361 If MACRO is non-NULL, then we are scanning the replacement list of
362 MACRO, and we call save_replacement_text() every time we meet an
365 If BUILTIN_MACRO_ARG is true, this is called to macro expand
366 arguments of builtin function-like macros. */
368 _cpp_scan_out_logical_line (cpp_reader
*pfile
, cpp_macro
*macro
,
369 bool builtin_macro_arg
)
372 cpp_context
*context
;
375 struct fun_macro fmacro
;
376 unsigned int c
, paren_depth
= 0, quote
;
377 enum ls lex_state
= ls_none
;
379 const uchar
*start_of_input_line
;
390 header_ok
= pfile
->state
.angled_headers
;
391 CUR (pfile
->context
) = pfile
->buffer
->cur
;
392 RLIMIT (pfile
->context
) = pfile
->buffer
->rlimit
;
393 if (!builtin_macro_arg
)
395 pfile
->out
.cur
= pfile
->out
.base
;
396 pfile
->out
.first_line
= pfile
->line_table
->highest_line
;
398 /* start_of_input_line is needed to make sure that directives really,
399 really start at the first character of the line. */
400 start_of_input_line
= pfile
->buffer
->cur
;
402 context
= pfile
->context
;
404 check_output_buffer (pfile
, RLIMIT (context
) - cur
);
405 out
= pfile
->out
.cur
;
410 && !builtin_macro_arg
411 && cur
>= pfile
->buffer
->notes
[pfile
->buffer
->cur_note
].pos
)
413 pfile
->buffer
->cur
= cur
;
414 _cpp_process_line_notes (pfile
, false);
419 /* Whitespace should "continue" out of the switch,
420 non-whitespace should "break" out of it. */
431 /* If this is a macro's expansion, pop it. */
434 pfile
->out
.cur
= out
- 1;
435 _cpp_pop_context (pfile
);
439 /* Omit the newline from the output buffer. */
440 pfile
->out
.cur
= out
- 1;
441 pfile
->buffer
->cur
= cur
;
442 if (builtin_macro_arg
)
444 pfile
->buffer
->need_line
= true;
445 CPP_INCREMENT_LINE (pfile
, 0);
447 if ((lex_state
== ls_fun_open
|| lex_state
== ls_fun_close
)
448 && !pfile
->state
.in_directive
449 && _cpp_get_fresh_line (pfile
))
451 /* Newlines in arguments become a space, but we don't
452 clear any in-progress quote. */
453 if (lex_state
== ls_fun_close
)
455 cur
= pfile
->buffer
->cur
;
478 /* Skip escaped quotes here, it's easier than above. */
479 if (*cur
== '\\' || *cur
== '"' || *cur
== '\'')
484 /* Traditional CPP does not recognize comments within
486 if (!quote
&& *cur
== '*')
488 pfile
->out
.cur
= out
;
489 cur
= copy_comment (pfile
, cur
, macro
!= 0);
490 out
= pfile
->out
.cur
;
496 case 'a': case 'b': case 'c': case 'd': case 'e': case 'f':
497 case 'g': case 'h': case 'i': case 'j': case 'k': case 'l':
498 case 'm': case 'n': case 'o': case 'p': case 'q': case 'r':
499 case 's': case 't': case 'u': case 'v': case 'w': case 'x':
501 case 'A': case 'B': case 'C': case 'D': case 'E': case 'F':
502 case 'G': case 'H': case 'I': case 'J': case 'K': case 'L':
503 case 'M': case 'N': case 'O': case 'P': case 'Q': case 'R':
504 case 'S': case 'T': case 'U': case 'V': case 'W': case 'X':
506 if (!pfile
->state
.skipping
&& (quote
== 0 || macro
))
509 uchar
*out_start
= out
- 1;
511 pfile
->out
.cur
= out_start
;
512 node
= lex_identifier (pfile
, cur
- 1);
513 out
= pfile
->out
.cur
;
516 if (node
->type
== NT_MACRO
517 /* Should we expand for ls_answer? */
518 && (lex_state
== ls_none
|| lex_state
== ls_fun_open
)
519 && !pfile
->state
.prevent_expansion
)
521 /* Macros invalidate MI optimization. */
522 pfile
->mi_valid
= false;
523 if (fun_like_macro (node
))
525 maybe_start_funlike (pfile
, node
, out_start
, &fmacro
);
526 lex_state
= ls_fun_open
;
527 fmacro
.line
= pfile
->line_table
->highest_line
;
530 else if (!recursive_macro (pfile
, node
))
532 /* Remove the object-like macro's name from the
533 output, and push its replacement text. */
534 pfile
->out
.cur
= out_start
;
535 push_replacement_text (pfile
, node
);
540 else if (macro
&& (node
->flags
& NODE_MACRO_ARG
) != 0)
542 /* Found a parameter in the replacement text of a
543 #define. Remove its name from the output. */
544 pfile
->out
.cur
= out_start
;
545 save_replacement_text (pfile
, macro
, node
->value
.arg_index
);
546 out
= pfile
->out
.base
;
548 else if (lex_state
== ls_hash
)
550 lex_state
= ls_predicate
;
553 else if (pfile
->state
.in_expression
554 && node
== pfile
->spec_nodes
.n_defined
)
556 lex_state
= ls_defined
;
559 else if (pfile
->state
.in_expression
560 && (node
== pfile
->spec_nodes
.n__has_include__
561 || node
== pfile
->spec_nodes
.n__has_include_next__
))
563 lex_state
= ls_has_include
;
573 if (lex_state
== ls_fun_open
)
575 if (recursive_macro (pfile
, fmacro
.node
))
579 lex_state
= ls_fun_close
;
581 out
= pfile
->out
.base
+ fmacro
.offset
;
582 fmacro
.args
[0] = fmacro
.offset
;
585 else if (lex_state
== ls_predicate
)
586 lex_state
= ls_answer
;
587 else if (lex_state
== ls_defined
)
588 lex_state
= ls_defined_close
;
589 else if (lex_state
== ls_has_include
)
590 lex_state
= ls_has_include_close
;
595 if (quote
== 0 && lex_state
== ls_fun_close
&& paren_depth
== 1)
596 save_argument (&fmacro
, out
- pfile
->out
.base
);
603 if (lex_state
== ls_fun_close
&& paren_depth
== 0)
605 if (fmacro
.node
->flags
& NODE_BUILTIN
)
607 /* Handle builtin function-like macros like
608 __has_attribute. The already parsed arguments
609 are put into a buffer, which is then preprocessed
610 and the result is fed to _cpp_push_text_context
611 with disabled expansion, where the ISO preprocessor
612 parses it. While in traditional preprocessing
613 macro arguments aren't immediately expanded, they in
614 the end are because the macro with replaced arguments
615 is preprocessed again. For the builtin function-like
616 macros we need the argument immediately though,
617 if we don't preprocess them, they would behave
618 very differently from ISO preprocessor handling
619 of those builtin macros. So, this handling is
620 more similar to traditional preprocessing of
621 #if directives, where we also keep preprocessing
622 until everything is expanded, and then feed the
623 result with disabled expansion to ISO preprocessor
624 for handling the directives. */
626 save_argument (&fmacro
, out
- pfile
->out
.base
);
628 memset (&m
, '\0', sizeof (m
));
629 m
.paramc
= fmacro
.paramc
;
630 if (_cpp_arguments_ok (pfile
, &m
, fmacro
.node
,
633 size_t len
= fmacro
.args
[1] - fmacro
.args
[0];
636 /* Remove the macro's invocation from the
637 output, and push its replacement text. */
638 pfile
->out
.cur
= pfile
->out
.base
+ fmacro
.offset
;
640 buf
= _cpp_unaligned_alloc (pfile
, len
+ 2);
642 memcpy (buf
+ 1, pfile
->out
.base
+ fmacro
.args
[0],
646 const unsigned char *ctx_rlimit
= RLIMIT (context
);
647 const unsigned char *saved_cur
= pfile
->buffer
->cur
;
648 const unsigned char *saved_rlimit
649 = pfile
->buffer
->rlimit
;
650 const unsigned char *saved_line_base
651 = pfile
->buffer
->line_base
;
652 bool saved_need_line
= pfile
->buffer
->need_line
;
653 cpp_buffer
*saved_overlaid_buffer
654 = pfile
->overlaid_buffer
;
655 pfile
->buffer
->cur
= buf
;
656 pfile
->buffer
->line_base
= buf
;
657 pfile
->buffer
->rlimit
= buf
+ len
+ 1;
658 pfile
->buffer
->need_line
= false;
659 pfile
->overlaid_buffer
= pfile
->buffer
;
660 bool saved_in_directive
= pfile
->state
.in_directive
;
661 pfile
->state
.in_directive
= true;
662 cpp_context
*saved_prev_context
= context
->prev
;
663 context
->prev
= NULL
;
665 _cpp_scan_out_logical_line (pfile
, NULL
, true);
667 pfile
->state
.in_directive
= saved_in_directive
;
668 check_output_buffer (pfile
, 1);
669 *pfile
->out
.cur
= '\n';
670 pfile
->buffer
->cur
= pfile
->out
.base
+ fmacro
.offset
;
671 pfile
->buffer
->line_base
= pfile
->buffer
->cur
;
672 pfile
->buffer
->rlimit
= pfile
->out
.cur
;
673 CUR (context
) = pfile
->buffer
->cur
;
674 RLIMIT (context
) = pfile
->buffer
->rlimit
;
676 pfile
->state
.prevent_expansion
++;
678 = _cpp_builtin_macro_text (pfile
, fmacro
.node
);
679 pfile
->state
.prevent_expansion
--;
681 context
->prev
= saved_prev_context
;
682 pfile
->buffer
->cur
= saved_cur
;
683 pfile
->buffer
->rlimit
= saved_rlimit
;
684 pfile
->buffer
->line_base
= saved_line_base
;
685 pfile
->buffer
->need_line
= saved_need_line
;
686 pfile
->overlaid_buffer
= saved_overlaid_buffer
;
687 pfile
->out
.cur
= pfile
->out
.base
+ fmacro
.offset
;
689 RLIMIT (context
) = ctx_rlimit
;
690 len
= ustrlen (text
);
691 buf
= _cpp_unaligned_alloc (pfile
, len
+ 1);
692 memcpy (buf
, text
, len
);
695 _cpp_push_text_context (pfile
, fmacro
.node
,
702 cpp_macro
*m
= fmacro
.node
->value
.macro
;
706 save_argument (&fmacro
, out
- pfile
->out
.base
);
708 /* A single zero-length argument is no argument. */
711 && out
== pfile
->out
.base
+ fmacro
.offset
+ 1)
714 if (_cpp_arguments_ok (pfile
, m
, fmacro
.node
, fmacro
.argc
))
716 /* Remove the macro's invocation from the
717 output, and push its replacement text. */
718 pfile
->out
.cur
= pfile
->out
.base
+ fmacro
.offset
;
720 replace_args_and_push (pfile
, &fmacro
);
724 else if (lex_state
== ls_answer
|| lex_state
== ls_defined_close
725 || lex_state
== ls_has_include_close
)
731 if (cur
- 1 == start_of_input_line
732 /* A '#' from a macro doesn't start a directive. */
733 && !pfile
->context
->prev
734 && !pfile
->state
.in_directive
)
736 /* A directive. With the way _cpp_handle_directive
737 currently works, we only want to call it if either we
738 know the directive is OK, or we want it to fail and
739 be removed from the output. If we want it to be
740 passed through (the assembler case) then we must not
741 call _cpp_handle_directive. */
742 pfile
->out
.cur
= out
;
743 cur
= skip_whitespace (pfile
, cur
, true /* skip_comments */);
744 out
= pfile
->out
.cur
;
748 /* Null directive. Ignore it and don't invalidate
749 the MI optimization. */
750 pfile
->buffer
->need_line
= true;
751 CPP_INCREMENT_LINE (pfile
, 0);
759 if (is_numstart (*cur
)
760 && CPP_OPTION (pfile
, lang
) != CLK_ASM
)
762 else if (is_idstart (*cur
))
763 /* Check whether we know this directive, but don't
765 do_it
= lex_identifier (pfile
, cur
)->is_directive
;
767 if (do_it
|| CPP_OPTION (pfile
, lang
) != CLK_ASM
)
769 /* This is a kludge. We want to have the ISO
770 preprocessor lex the next token. */
771 pfile
->buffer
->cur
= cur
;
772 _cpp_handle_directive (pfile
, false /* indented */);
779 if (pfile
->state
.in_expression
)
790 /* Non-whitespace disables MI optimization and stops treating
791 '<' as a quote in #include. */
793 if (!pfile
->state
.in_directive
)
794 pfile
->mi_valid
= false;
796 if (lex_state
== ls_none
)
799 /* Some of these transitions of state are syntax errors. The
800 ISO preprocessor will issue errors later. */
801 if (lex_state
== ls_fun_open
)
804 else if (lex_state
== ls_hash
805 || lex_state
== ls_predicate
806 || lex_state
== ls_defined
807 || lex_state
== ls_has_include
)
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 (node
->flags
& NODE_BUILTIN
)
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
;
848 macro
->traditional
= 1;
852 _cpp_push_text_context (pfile
, node
, text
, len
);
855 /* Returns TRUE if traditional macro recursion is detected. */
857 recursive_macro (cpp_reader
*pfile
, cpp_hashnode
*node
)
859 bool recursing
= !!(node
->flags
& NODE_DISABLED
);
861 /* Object-like macros that are already expanding are necessarily
864 However, it is possible to have traditional function-like macros
865 that are not infinitely recursive but recurse to any given depth.
866 Further, it is easy to construct examples that get ever longer
867 until the point they stop recursing. So there is no easy way to
868 detect true recursion; instead we assume any expansion more than
869 20 deep since the first invocation of this macro must be
871 if (recursing
&& fun_like_macro (node
))
874 cpp_context
*context
= pfile
->context
;
879 if (context
->c
.macro
== node
&& depth
> 20)
881 context
= context
->prev
;
884 recursing
= context
!= NULL
;
888 cpp_error (pfile
, CPP_DL_ERROR
,
889 "detected recursion whilst expanding macro \"%s\"",
895 /* Return the length of the replacement text of a function-like or
896 object-like non-builtin macro. */
898 _cpp_replacement_text_len (const cpp_macro
*macro
)
902 if (macro
->fun_like
&& (macro
->paramc
!= 0))
907 for (exp
= macro
->exp
.text
;;)
909 struct block
*b
= (struct block
*) exp
;
912 if (b
->arg_index
== 0)
914 len
+= NODE_LEN (macro
->params
[b
->arg_index
- 1]);
915 exp
+= BLOCK_LEN (b
->text_len
);
924 /* Copy the replacement text of MACRO to DEST, which must be of
925 sufficient size. It is not NUL-terminated. The next character is
928 _cpp_copy_replacement_text (const cpp_macro
*macro
, uchar
*dest
)
930 if (macro
->fun_like
&& (macro
->paramc
!= 0))
934 for (exp
= macro
->exp
.text
;;)
936 struct block
*b
= (struct block
*) exp
;
939 memcpy (dest
, b
->text
, b
->text_len
);
941 if (b
->arg_index
== 0)
943 param
= macro
->params
[b
->arg_index
- 1];
944 memcpy (dest
, NODE_NAME (param
), NODE_LEN (param
));
945 dest
+= NODE_LEN (param
);
946 exp
+= BLOCK_LEN (b
->text_len
);
951 memcpy (dest
, macro
->exp
.text
, macro
->count
);
952 dest
+= macro
->count
;
958 /* Push a context holding the replacement text of the macro NODE on
959 the context stack. NODE is either object-like, or a function-like
960 macro with no arguments. */
962 replace_args_and_push (cpp_reader
*pfile
, struct fun_macro
*fmacro
)
964 cpp_macro
*macro
= fmacro
->node
->value
.macro
;
966 if (macro
->paramc
== 0)
967 push_replacement_text (pfile
, fmacro
->node
);
976 /* Get an estimate of the length of the argument-replaced text.
977 This is a worst case estimate, assuming that every replacement
978 text character needs quoting. */
979 for (exp
= macro
->exp
.text
;;)
981 struct block
*b
= (struct block
*) exp
;
984 if (b
->arg_index
== 0)
986 len
+= 2 * (fmacro
->args
[b
->arg_index
]
987 - fmacro
->args
[b
->arg_index
- 1] - 1);
988 exp
+= BLOCK_LEN (b
->text_len
);
991 /* Allocate room for the expansion plus \n. */
992 buff
= _cpp_get_buff (pfile
, len
+ 1);
994 /* Copy the expansion and replace arguments. */
995 /* Accumulate actual length, including quoting as necessary */
996 p
= BUFF_FRONT (buff
);
998 for (exp
= macro
->exp
.text
;;)
1000 struct block
*b
= (struct block
*) exp
;
1007 /* Copy the non-argument text literally, keeping
1008 track of whether matching quotes have been seen. */
1009 for (arglen
= b
->text_len
, in
= b
->text
; arglen
> 0; arglen
--)
1012 cxtquote
= ! cxtquote
;
1015 /* Done if no more arguments */
1016 if (b
->arg_index
== 0)
1018 arglen
= (fmacro
->args
[b
->arg_index
]
1019 - fmacro
->args
[b
->arg_index
- 1] - 1);
1020 base
= pfile
->out
.base
+ fmacro
->args
[b
->arg_index
- 1];
1023 /* Skip leading whitespace in the text for the argument to
1024 be substituted. To be compatible with gcc 2.95, we would
1025 also need to trim trailing whitespace. Gcc 2.95 trims
1026 leading and trailing whitespace, which may be a bug. The
1027 current gcc testsuite explicitly checks that this leading
1028 and trailing whitespace in actual arguments is
1030 while (arglen
> 0 && is_space (*in
))
1036 for (argquote
= 0; arglen
> 0; arglen
--)
1038 if (cxtquote
&& *in
== '"')
1040 if (in
> base
&& *(in
-1) != '\\')
1041 argquote
= ! argquote
;
1042 /* Always add backslash before double quote if argument
1043 is expanded in a quoted context */
1047 else if (cxtquote
&& argquote
&& *in
== '\\')
1049 /* Always add backslash before a backslash in an argument
1050 that is expanded in a quoted context and also in the
1051 range of a quoted context in the argument itself. */
1058 exp
+= BLOCK_LEN (b
->text_len
);
1063 _cpp_push_text_context (pfile
, fmacro
->node
, BUFF_FRONT (buff
), len
);
1065 /* So we free buffer allocation when macro is left. */
1066 pfile
->context
->buff
= buff
;
1070 /* Read and record the parameters, if any, of a function-like macro
1071 definition. Destroys pfile->out.cur.
1073 Returns true on success, false on failure (syntax error or a
1074 duplicate parameter). On success, CUR (pfile->context) is just
1075 past the closing parenthesis. */
1077 scan_parameters (cpp_reader
*pfile
, cpp_macro
*macro
)
1079 const uchar
*cur
= CUR (pfile
->context
) + 1;
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
, macro
, id
, id
))
1092 cur
= skip_whitespace (pfile
, CUR (pfile
->context
),
1093 true /* skip_comments */);
1103 ok
= (*cur
== ')' && macro
->paramc
== 0);
1108 cpp_error (pfile
, CPP_DL_ERROR
, "syntax error in macro parameter list");
1110 CUR (pfile
->context
) = cur
+ (*cur
== ')');
1115 /* Save the text from pfile->out.base to pfile->out.cur as
1116 the replacement text for the current macro, followed by argument
1117 ARG_INDEX, with zero indicating the end of the replacement
1120 save_replacement_text (cpp_reader
*pfile
, cpp_macro
*macro
,
1121 unsigned int arg_index
)
1123 size_t len
= pfile
->out
.cur
- pfile
->out
.base
;
1126 if (macro
->paramc
== 0)
1128 /* Object-like and function-like macros without parameters
1129 simply store their \n-terminated replacement text. */
1130 exp
= _cpp_unaligned_alloc (pfile
, len
+ 1);
1131 memcpy (exp
, pfile
->out
.base
, len
);
1133 macro
->exp
.text
= exp
;
1134 macro
->traditional
= 1;
1139 /* Store the text's length (unsigned int), the argument index
1140 (unsigned short, base 1) and then the text. */
1141 size_t blen
= BLOCK_LEN (len
);
1142 struct block
*block
;
1144 if (macro
->count
+ blen
> BUFF_ROOM (pfile
->a_buff
))
1145 _cpp_extend_buff (pfile
, &pfile
->a_buff
, macro
->count
+ blen
);
1147 exp
= BUFF_FRONT (pfile
->a_buff
);
1148 block
= (struct block
*) (exp
+ macro
->count
);
1149 macro
->exp
.text
= exp
;
1150 macro
->traditional
= 1;
1152 /* Write out the block information. */
1153 block
->text_len
= len
;
1154 block
->arg_index
= arg_index
;
1155 memcpy (block
->text
, pfile
->out
.base
, len
);
1157 /* Lex the rest into the start of the output buffer. */
1158 pfile
->out
.cur
= pfile
->out
.base
;
1160 macro
->count
+= blen
;
1162 /* If we've finished, commit the memory. */
1164 BUFF_FRONT (pfile
->a_buff
) += macro
->count
;
1168 /* Analyze and save the replacement text of a macro. Returns true on
1171 _cpp_create_trad_definition (cpp_reader
*pfile
, cpp_macro
*macro
)
1175 cpp_context
*context
= pfile
->context
;
1177 /* The context has not been set up for command line defines, and CUR
1178 has not been updated for the macro name for in-file defines. */
1179 pfile
->out
.cur
= pfile
->out
.base
;
1180 CUR (context
) = pfile
->buffer
->cur
;
1181 RLIMIT (context
) = pfile
->buffer
->rlimit
;
1182 check_output_buffer (pfile
, RLIMIT (context
) - CUR (context
));
1184 /* Is this a function-like macro? */
1185 if (* CUR (context
) == '(')
1187 bool ok
= scan_parameters (pfile
, macro
);
1189 /* Remember the params so we can clear NODE_MACRO_ARG flags. */
1190 macro
->params
= (cpp_hashnode
**) BUFF_FRONT (pfile
->a_buff
);
1192 /* Setting macro to NULL indicates an error occurred, and
1193 prevents unnecessary work in _cpp_scan_out_logical_line. */
1198 BUFF_FRONT (pfile
->a_buff
) = (uchar
*) ¯o
->params
[macro
->paramc
];
1199 macro
->fun_like
= 1;
1203 /* Skip leading whitespace in the replacement text. */
1205 = skip_whitespace (pfile
, CUR (context
),
1206 CPP_OPTION (pfile
, discard_comments_in_macro_exp
));
1208 pfile
->state
.prevent_expansion
++;
1209 _cpp_scan_out_logical_line (pfile
, macro
, false);
1210 pfile
->state
.prevent_expansion
--;
1215 /* Skip trailing white space. */
1216 cur
= pfile
->out
.base
;
1217 limit
= pfile
->out
.cur
;
1218 while (limit
> cur
&& is_space (limit
[-1]))
1220 pfile
->out
.cur
= limit
;
1221 save_replacement_text (pfile
, macro
, 0);
1226 /* Copy SRC of length LEN to DEST, but convert all contiguous
1227 whitespace to a single space, provided it is not in quotes. The
1228 quote currently in effect is pointed to by PQUOTE, and is updated
1229 by the function. Returns the number of bytes copied. */
1231 canonicalize_text (uchar
*dest
, const uchar
*src
, size_t len
, uchar
*pquote
)
1233 uchar
*orig_dest
= dest
;
1234 uchar quote
= *pquote
;
1238 if (is_space (*src
) && !quote
)
1242 while (len
&& is_space (*src
));
1247 if (*src
== '\'' || *src
== '"')
1251 else if (quote
== *src
)
1254 *dest
++ = *src
++, len
--;
1259 return dest
- orig_dest
;
1262 /* Returns true if MACRO1 and MACRO2 have expansions different other
1263 than in the form of their whitespace. */
1265 _cpp_expansions_different_trad (const cpp_macro
*macro1
,
1266 const cpp_macro
*macro2
)
1268 uchar
*p1
= XNEWVEC (uchar
, macro1
->count
+ macro2
->count
);
1269 uchar
*p2
= p1
+ macro1
->count
;
1270 uchar quote1
= 0, quote2
= 0;
1274 if (macro1
->paramc
> 0)
1276 const uchar
*exp1
= macro1
->exp
.text
, *exp2
= macro2
->exp
.text
;
1281 struct block
*b1
= (struct block
*) exp1
;
1282 struct block
*b2
= (struct block
*) exp2
;
1284 if (b1
->arg_index
!= b2
->arg_index
)
1287 len1
= canonicalize_text (p1
, b1
->text
, b1
->text_len
, "e1
);
1288 len2
= canonicalize_text (p2
, b2
->text
, b2
->text_len
, "e2
);
1289 if (len1
!= len2
|| memcmp (p1
, p2
, len1
))
1291 if (b1
->arg_index
== 0)
1296 exp1
+= BLOCK_LEN (b1
->text_len
);
1297 exp2
+= BLOCK_LEN (b2
->text_len
);
1302 len1
= canonicalize_text (p1
, macro1
->exp
.text
, macro1
->count
, "e1
);
1303 len2
= canonicalize_text (p2
, macro2
->exp
.text
, macro2
->count
, "e2
);
1304 mismatch
= (len1
!= len2
|| memcmp (p1
, p2
, len1
));