1 /* CPP Library - traditional lexical analysis and macro expansion.
2 Copyright (C) 2002 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 2, 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; if not, write to the Free Software
17 Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
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 /* Zero-based index of argument being currently lexed. */
69 /* Lexing state. It is mostly used to prevent macro expansion. */
70 enum ls
{ls_none
= 0, /* Normal state. */
71 ls_fun_open
, /* When looking for '('. */
72 ls_fun_close
, /* When looking for ')'. */
73 ls_defined
, /* After defined. */
74 ls_defined_close
, /* Looking for ')' of defined(). */
75 ls_hash
, /* After # in preprocessor conditional. */
76 ls_predicate
, /* After the predicate, maybe paren? */
77 ls_answer
}; /* In answer to predicate. */
79 /* Lexing TODO: Maybe handle space in escaped newlines. Stop cpplex.c
80 from recognizing comments and directives during its lexing pass. */
82 static const uchar
*handle_newline
PARAMS ((cpp_reader
*, const uchar
*));
83 static const uchar
*skip_escaped_newlines
PARAMS ((cpp_reader
*,
85 static const uchar
*skip_whitespace
PARAMS ((cpp_reader
*, const uchar
*,
87 static cpp_hashnode
*lex_identifier
PARAMS ((cpp_reader
*, const uchar
*));
88 static const uchar
*copy_comment
PARAMS ((cpp_reader
*, const uchar
*, int));
89 static void scan_out_logical_line
PARAMS ((cpp_reader
*pfile
, cpp_macro
*));
90 static void check_output_buffer
PARAMS ((cpp_reader
*, size_t));
91 static void push_replacement_text
PARAMS ((cpp_reader
*, cpp_hashnode
*));
92 static bool scan_parameters
PARAMS ((cpp_reader
*, cpp_macro
*));
93 static bool recursive_macro
PARAMS ((cpp_reader
*, cpp_hashnode
*));
94 static void save_replacement_text
PARAMS ((cpp_reader
*, cpp_macro
*,
96 static void maybe_start_funlike
PARAMS ((cpp_reader
*, cpp_hashnode
*,
97 const uchar
*, struct fun_macro
*));
98 static void save_argument
PARAMS ((struct fun_macro
*, size_t));
99 static void replace_args_and_push
PARAMS ((cpp_reader
*, struct fun_macro
*));
100 static size_t canonicalize_text
PARAMS ((uchar
*, const uchar
*, size_t,
103 /* Ensures we have N bytes' space in the output buffer, and
104 reallocates it if not. */
106 check_output_buffer (pfile
, n
)
110 /* We might need two bytes to terminate an unterminated comment, and
111 one more to terminate the line with a NUL. */
114 if (n
> (size_t) (pfile
->out
.limit
- pfile
->out
.cur
))
116 size_t size
= pfile
->out
.cur
- pfile
->out
.base
;
117 size_t new_size
= (size
+ n
) * 3 / 2;
120 = (uchar
*) xrealloc (pfile
->out
.base
, new_size
);
121 pfile
->out
.limit
= pfile
->out
.base
+ new_size
;
122 pfile
->out
.cur
= pfile
->out
.base
+ size
;
126 /* To be called whenever a newline character is encountered in the
127 input file, at CUR. Handles DOS, Mac and Unix ends of line, and
128 increments pfile->line.
130 Returns a pointer the character after the newline sequence. */
132 handle_newline (pfile
, cur
)
137 if (cur
[0] + cur
[1] == '\r' + '\n')
142 /* CUR points to any character in the current context, not necessarily
143 a backslash. Advances CUR until all escaped newlines are skipped,
144 and returns the new position without updating the context.
146 Warns if a file buffer ends in an escaped newline. */
148 skip_escaped_newlines (pfile
, cur
)
152 const uchar
*orig_cur
= cur
;
154 while (*cur
== '\\' && is_vspace (cur
[1]))
155 cur
= handle_newline (pfile
, cur
+ 1);
157 if (cur
!= orig_cur
&& cur
== RLIMIT (pfile
->context
) && pfile
->buffer
->inc
)
158 cpp_error (pfile
, DL_PEDWARN
, "backslash-newline at end of file");
163 /* CUR points to the asterisk introducing a comment in the current
164 context. IN_DEFINE is true if we are in the replacement text of a
167 The asterisk and following comment is copied to the buffer pointed
168 to by pfile->out.cur, which must be of sufficient size.
169 Unterminated comments are diagnosed, and correctly terminated in
170 the output. pfile->out.cur is updated depending upon IN_DEFINE,
171 -C, -CC and pfile->state.in_directive.
173 Returns a pointer to the first character after the comment in the
176 copy_comment (pfile
, cur
, in_define
)
181 unsigned int from_line
= pfile
->line
;
182 const uchar
*limit
= RLIMIT (pfile
->context
);
183 uchar
*out
= pfile
->out
.cur
;
187 unsigned int c
= *cur
++;
192 /* An immediate slash does not terminate the comment. */
193 if (out
[-2] == '*' && out
- 2 > pfile
->out
.cur
)
196 if (*cur
== '*' && cur
[1] != '/'
197 && CPP_OPTION (pfile
, warn_comments
))
198 cpp_error_with_line (pfile
, DL_WARNING
, pfile
->line
, 0,
199 "\"/*\" within comment");
201 else if (is_vspace (c
))
203 cur
= handle_newline (pfile
, cur
- 1);
204 /* Canonicalize newline sequences and skip escaped ones. */
213 cpp_error_with_line (pfile
, DL_ERROR
, from_line
, 0, "unterminated comment");
218 /* Comments in directives become spaces so that tokens are properly
219 separated when the ISO preprocessor re-lexes the line. The
220 exception is #define. */
221 if (pfile
->state
.in_directive
)
225 if (CPP_OPTION (pfile
, discard_comments_in_macro_exp
))
228 pfile
->out
.cur
= out
;
231 pfile
->out
.cur
[-1] = ' ';
233 else if (CPP_OPTION (pfile
, discard_comments
))
236 pfile
->out
.cur
= out
;
241 /* CUR points to any character in the input buffer. Skips over all
242 contiguous horizontal white space and NULs, including comments if
243 SKIP_COMMENTS, until reaching the first non-horizontal-whitespace
244 character or the end of the current context. Escaped newlines are
247 The whitespace is copied verbatim to the output buffer, except that
248 comments are handled as described in copy_comment().
249 pfile->out.cur is updated.
251 Returns a pointer to the first character after the whitespace in
254 skip_whitespace (pfile
, cur
, skip_comments
)
259 uchar
*out
= pfile
->out
.cur
;
263 unsigned int c
= *cur
++;
266 if (is_nvspace (c
) && c
)
269 if (!c
&& cur
- 1 != RLIMIT (pfile
->context
))
272 if (c
== '/' && skip_comments
)
274 const uchar
*tmp
= skip_escaped_newlines (pfile
, cur
);
277 pfile
->out
.cur
= out
;
278 cur
= copy_comment (pfile
, tmp
, false /* in_define */);
279 out
= pfile
->out
.cur
;
285 if (c
== '\\' && is_vspace (*cur
))
287 cur
= skip_escaped_newlines (pfile
, cur
- 1);
294 pfile
->out
.cur
= out
;
298 /* Lexes and outputs an identifier starting at CUR, which is assumed
299 to point to a valid first character of an identifier. Returns
300 the hashnode, and updates out.cur. */
301 static cpp_hashnode
*
302 lex_identifier (pfile
, cur
)
307 uchar
*out
= pfile
->out
.cur
;
308 cpp_hashnode
*result
;
314 while (is_numchar (*cur
));
315 cur
= skip_escaped_newlines (pfile
, cur
);
317 while (is_numchar (*cur
));
319 CUR (pfile
->context
) = cur
;
320 len
= out
- pfile
->out
.cur
;
321 result
= (cpp_hashnode
*) ht_lookup (pfile
->hash_table
, pfile
->out
.cur
,
323 pfile
->out
.cur
= out
;
327 /* Overlays the true file buffer temporarily with text of length LEN
328 starting at START. The true buffer is restored upon calling
331 _cpp_overlay_buffer (pfile
, start
, len
)
336 cpp_buffer
*buffer
= pfile
->buffer
;
338 pfile
->overlaid_buffer
= buffer
;
339 buffer
->saved_cur
= buffer
->cur
;
340 buffer
->saved_rlimit
= buffer
->rlimit
;
343 buffer
->rlimit
= start
+ len
;
345 pfile
->saved_line
= pfile
->line
;
348 /* Restores a buffer overlaid by _cpp_overlay_buffer(). */
350 _cpp_remove_overlay (pfile
)
353 cpp_buffer
*buffer
= pfile
->overlaid_buffer
;
355 buffer
->cur
= buffer
->saved_cur
;
356 buffer
->rlimit
= buffer
->saved_rlimit
;
358 pfile
->line
= pfile
->saved_line
;
361 /* Reads a logical line into the output buffer. Returns TRUE if there
362 is more text left in the buffer. */
364 _cpp_read_logical_line_trad (pfile
)
369 if (pfile
->buffer
->cur
== pfile
->buffer
->rlimit
)
373 /* Don't pop the last buffer. */
374 if (pfile
->buffer
->prev
)
376 stop
= pfile
->buffer
->return_at_eof
;
377 _cpp_pop_buffer (pfile
);
384 scan_out_logical_line (pfile
, NULL
);
386 while (pfile
->state
.skipping
);
391 /* Set up state for finding the opening '(' of a function-like
394 maybe_start_funlike (pfile
, node
, start
, macro
)
398 struct fun_macro
*macro
;
400 unsigned int n
= node
->value
.macro
->paramc
+ 1;
403 _cpp_release_buff (pfile
, macro
->buff
);
404 macro
->buff
= _cpp_get_buff (pfile
, n
* sizeof (size_t));
405 macro
->args
= (size_t *) BUFF_FRONT (macro
->buff
);
407 macro
->offset
= start
- pfile
->out
.base
;
411 /* Save the OFFSET of the start of the next argument to MACRO. */
413 save_argument (macro
, offset
)
414 struct fun_macro
*macro
;
418 if (macro
->argc
<= macro
->node
->value
.macro
->paramc
)
419 macro
->args
[macro
->argc
] = offset
;
422 /* Copies the next logical line in the current buffer (starting at
423 buffer->cur) to the output buffer. The output is guaranteed to
424 terminate with a NUL character. buffer->cur is updated.
426 If MACRO is non-NULL, then we are scanning the replacement list of
427 MACRO, and we call save_replacement_text() every time we meet an
430 scan_out_logical_line (pfile
, macro
)
434 cpp_context
*context
;
437 struct fun_macro fmacro
;
438 unsigned int c
, paren_depth
= 0, quote
;
439 enum ls lex_state
= ls_none
;
446 header_ok
= pfile
->state
.angled_headers
;
447 CUR (pfile
->context
) = pfile
->buffer
->cur
;
448 RLIMIT (pfile
->context
) = pfile
->buffer
->rlimit
;
449 pfile
->out
.cur
= pfile
->out
.base
;
450 pfile
->out
.first_line
= pfile
->line
;
452 context
= pfile
->context
;
454 check_output_buffer (pfile
, RLIMIT (context
) - cur
);
455 out
= pfile
->out
.cur
;
462 /* Whitespace should "continue" out of the switch,
463 non-whitespace should "break" out of it. */
473 if (cur
- 1 != RLIMIT (context
))
476 /* If this is a macro's expansion, pop it. */
479 pfile
->out
.cur
= out
- 1;
480 _cpp_pop_context (pfile
);
484 /* Premature end of file. Fake a new line. */
486 if (!pfile
->buffer
->from_stage3
)
487 cpp_error (pfile
, DL_PEDWARN
, "no newline at end of file");
491 case '\r': case '\n':
492 cur
= handle_newline (pfile
, cur
- 1);
493 if ((lex_state
== ls_fun_open
|| lex_state
== ls_fun_close
)
494 && !pfile
->state
.in_directive
)
496 /* Newlines in arguments become a space, but we don't
497 clear any in-progress quote. */
498 if (lex_state
== ls_fun_close
)
522 if (is_vspace (*cur
))
525 cur
= skip_escaped_newlines (pfile
, cur
- 1);
530 /* Skip escaped quotes here, it's easier than above, but
531 take care to first skip escaped newlines. */
532 cur
= skip_escaped_newlines (pfile
, cur
);
533 if (*cur
== '\\' || *cur
== '"' || *cur
== '\'')
539 /* Traditional CPP does not recognize comments within
543 cur
= skip_escaped_newlines (pfile
, cur
);
546 pfile
->out
.cur
= out
;
547 cur
= copy_comment (pfile
, cur
, macro
!= 0);
548 out
= pfile
->out
.cur
;
555 case 'a': case 'b': case 'c': case 'd': case 'e': case 'f':
556 case 'g': case 'h': case 'i': case 'j': case 'k': case 'l':
557 case 'm': case 'n': case 'o': case 'p': case 'q': case 'r':
558 case 's': case 't': case 'u': case 'v': case 'w': case 'x':
560 case 'A': case 'B': case 'C': case 'D': case 'E': case 'F':
561 case 'G': case 'H': case 'I': case 'J': case 'K': case 'L':
562 case 'M': case 'N': case 'O': case 'P': case 'Q': case 'R':
563 case 'S': case 'T': case 'U': case 'V': case 'W': case 'X':
565 if (!pfile
->state
.skipping
&& (quote
== 0 || macro
))
568 uchar
*out_start
= out
- 1;
570 pfile
->out
.cur
= out_start
;
571 node
= lex_identifier (pfile
, cur
- 1);
572 out
= pfile
->out
.cur
;
575 if (node
->type
== NT_MACRO
576 /* Should we expand for ls_answer? */
577 && (lex_state
== ls_none
|| lex_state
== ls_fun_open
)
578 && !pfile
->state
.prevent_expansion
)
580 /* Macros invalidate MI optimization. */
581 pfile
->mi_valid
= false;
582 if (! (node
->flags
& NODE_BUILTIN
)
583 && node
->value
.macro
->fun_like
)
585 maybe_start_funlike (pfile
, node
, out_start
, &fmacro
);
586 lex_state
= ls_fun_open
;
587 fmacro
.line
= pfile
->line
;
590 else if (!recursive_macro (pfile
, node
))
592 /* Remove the object-like macro's name from the
593 output, and push its replacement text. */
594 pfile
->out
.cur
= out_start
;
595 push_replacement_text (pfile
, node
);
600 else if (macro
&& node
->arg_index
)
602 /* Found a parameter in the replacement text of a
603 #define. Remove its name from the output. */
604 pfile
->out
.cur
= out_start
;
605 save_replacement_text (pfile
, macro
, node
->arg_index
);
606 out
= pfile
->out
.base
;
608 else if (lex_state
== ls_hash
)
610 lex_state
= ls_predicate
;
613 else if (pfile
->state
.in_expression
614 && node
== pfile
->spec_nodes
.n_defined
)
616 lex_state
= ls_defined
;
626 if (lex_state
== ls_fun_open
)
628 if (recursive_macro (pfile
, fmacro
.node
))
632 lex_state
= ls_fun_close
;
634 out
= pfile
->out
.base
+ fmacro
.offset
;
635 fmacro
.args
[0] = fmacro
.offset
;
638 else if (lex_state
== ls_predicate
)
639 lex_state
= ls_answer
;
640 else if (lex_state
== ls_defined
)
641 lex_state
= ls_defined_close
;
646 if (quote
== 0 && lex_state
== ls_fun_close
&& paren_depth
== 1)
647 save_argument (&fmacro
, out
- pfile
->out
.base
);
654 if (lex_state
== ls_fun_close
&& paren_depth
== 0)
656 cpp_macro
*m
= fmacro
.node
->value
.macro
;
660 save_argument (&fmacro
, out
- pfile
->out
.base
);
662 /* A single zero-length argument is no argument. */
665 && out
== pfile
->out
.base
+ fmacro
.offset
+ 1)
668 if (_cpp_arguments_ok (pfile
, m
, fmacro
.node
, fmacro
.argc
))
670 /* Remove the macro's invocation from the
671 output, and push its replacement text. */
672 pfile
->out
.cur
= (pfile
->out
.base
675 replace_args_and_push (pfile
, &fmacro
);
679 else if (lex_state
== ls_answer
|| lex_state
== ls_defined_close
)
685 if (out
- 1 == pfile
->out
.base
&& !pfile
->state
.in_directive
)
687 /* A directive. With the way _cpp_handle_directive
688 currently works, we only want to call it if either we
689 know the directive is OK, or we want it to fail and
690 be removed from the output. If we want it to be
691 passed through (the assembler case) then we must not
692 call _cpp_handle_directive. */
693 pfile
->out
.cur
= out
;
694 cur
= skip_whitespace (pfile
, cur
, true /* skip_comments */);
695 out
= pfile
->out
.cur
;
697 if (is_vspace (*cur
))
699 /* Null directive. Ignore it and don't invalidate
700 the MI optimization. */
701 out
= pfile
->out
.base
;
708 if (is_numstart (*cur
))
710 else if (is_idstart (*cur
))
711 /* Check whether we know this directive, but don't
713 do_it
= lex_identifier (pfile
, cur
)->directive_index
!= 0;
715 if (do_it
|| CPP_OPTION (pfile
, lang
) != CLK_ASM
)
717 /* This is a kludge. We want to have the ISO
718 preprocessor lex the next token. */
719 pfile
->buffer
->cur
= cur
;
720 _cpp_handle_directive (pfile
, false /* indented */);
721 /* #include changes pfile->buffer so we need to
722 update the limits of the current context. */
723 goto start_logical_line
;
728 if (pfile
->state
.in_expression
)
739 /* Non-whitespace disables MI optimization and stops treating
740 '<' as a quote in #include. */
742 if (!pfile
->state
.in_directive
)
743 pfile
->mi_valid
= false;
745 if (lex_state
== ls_none
)
748 /* Some of these transitions of state are syntax errors. The
749 ISO preprocessor will issue errors later. */
750 if (lex_state
== ls_fun_open
)
753 else if (lex_state
== ls_hash
754 || lex_state
== ls_predicate
755 || lex_state
== ls_defined
)
758 /* ls_answer and ls_defined_close keep going until ')'. */
763 pfile
->buffer
->cur
= cur
;
764 pfile
->out
.cur
= out
- 1;
766 _cpp_release_buff (pfile
, fmacro
.buff
);
768 if (lex_state
== ls_fun_close
)
769 cpp_error_with_line (pfile
, DL_ERROR
, fmacro
.line
, 0,
770 "unterminated argument list invoking macro \"%s\"",
771 NODE_NAME (fmacro
.node
));
774 /* Push a context holding the replacement text of the macro NODE on
775 the context stack. NODE is either object-like, or a function-like
776 macro with no arguments. */
778 push_replacement_text (pfile
, node
)
785 if (node
->flags
& NODE_BUILTIN
)
787 text
= _cpp_builtin_macro_text (pfile
, node
);
788 len
= ustrlen (text
);
792 cpp_macro
*macro
= node
->value
.macro
;
794 text
= macro
->exp
.text
;
798 _cpp_push_text_context (pfile
, node
, text
, len
);
801 /* Returns TRUE if traditional macro recursion is detected. */
803 recursive_macro (pfile
, node
)
807 bool recursing
= !!(node
->flags
& NODE_DISABLED
);
809 /* Object-like macros that are already expanding are necessarily
812 However, it is possible to have traditional function-like macros
813 that are not infinitely recursive but recurse to any given depth.
814 Further, it is easy to construct examples that get ever longer
815 until the point they stop recursing. So there is no easy way to
816 detect true recursion; instead we assume any expansion more than
817 20 deep since the first invocation of this macro must be
819 if (recursing
&& node
->value
.macro
->fun_like
)
822 cpp_context
*context
= pfile
->context
;
827 if (context
->macro
== node
&& depth
> 20)
829 context
= context
->prev
;
832 recursing
= context
!= NULL
;
836 cpp_error (pfile
, DL_ERROR
,
837 "detected recursion whilst expanding macro \"%s\"",
843 /* Return the length of the replacement text of a function-like or
844 object-like non-builtin macro. */
846 _cpp_replacement_text_len (macro
)
847 const cpp_macro
*macro
;
856 for (exp
= macro
->exp
.text
;;)
858 struct block
*b
= (struct block
*) exp
;
861 if (b
->arg_index
== 0)
863 len
+= NODE_LEN (macro
->params
[b
->arg_index
- 1]);
864 exp
+= BLOCK_LEN (b
->text_len
);
873 /* Copy the replacement text of MACRO to DEST, which must be of
874 sufficient size. It is not NUL-terminated. The next character is
877 _cpp_copy_replacement_text (macro
, dest
)
878 const cpp_macro
*macro
;
885 for (exp
= macro
->exp
.text
;;)
887 struct block
*b
= (struct block
*) exp
;
890 memcpy (dest
, b
->text
, b
->text_len
);
892 if (b
->arg_index
== 0)
894 param
= macro
->params
[b
->arg_index
- 1];
895 memcpy (dest
, NODE_NAME (param
), NODE_LEN (param
));
896 dest
+= NODE_LEN (param
);
897 exp
+= BLOCK_LEN (b
->text_len
);
902 memcpy (dest
, macro
->exp
.text
, macro
->count
);
903 dest
+= macro
->count
;
909 /* Push a context holding the replacement text of the macro NODE on
910 the context stack. NODE is either object-like, or a function-like
911 macro with no arguments. */
913 replace_args_and_push (pfile
, fmacro
)
915 struct fun_macro
*fmacro
;
917 cpp_macro
*macro
= fmacro
->node
->value
.macro
;
919 if (macro
->paramc
== 0)
920 push_replacement_text (pfile
, fmacro
->node
);
928 /* Calculate the length of the argument-replaced text. */
929 for (exp
= macro
->exp
.text
;;)
931 struct block
*b
= (struct block
*) exp
;
934 if (b
->arg_index
== 0)
936 len
+= (fmacro
->args
[b
->arg_index
]
937 - fmacro
->args
[b
->arg_index
- 1] - 1);
938 exp
+= BLOCK_LEN (b
->text_len
);
941 /* Allocate room for the expansion plus NUL. */
942 buff
= _cpp_get_buff (pfile
, len
+ 1);
944 /* Copy the expansion and replace arguments. */
945 p
= BUFF_FRONT (buff
);
946 for (exp
= macro
->exp
.text
;;)
948 struct block
*b
= (struct block
*) exp
;
951 memcpy (p
, b
->text
, b
->text_len
);
953 if (b
->arg_index
== 0)
955 arglen
= (fmacro
->args
[b
->arg_index
]
956 - fmacro
->args
[b
->arg_index
- 1] - 1);
957 memcpy (p
, pfile
->out
.base
+ fmacro
->args
[b
->arg_index
- 1],
960 exp
+= BLOCK_LEN (b
->text_len
);
965 _cpp_push_text_context (pfile
, fmacro
->node
, BUFF_FRONT (buff
), len
);
967 /* So we free buffer allocation when macro is left. */
968 pfile
->context
->buff
= buff
;
972 /* Read and record the parameters, if any, of a function-like macro
973 definition. Destroys pfile->out.cur.
975 Returns true on success, false on failure (syntax error or a
976 duplicate parameter). On success, CUR (pfile->context) is just
977 past the closing parenthesis. */
979 scan_parameters (pfile
, macro
)
983 const uchar
*cur
= CUR (pfile
->context
) + 1;
988 cur
= skip_whitespace (pfile
, cur
, true /* skip_comments */);
990 if (is_idstart (*cur
))
993 if (_cpp_save_parameter (pfile
, macro
, lex_identifier (pfile
, cur
)))
995 cur
= skip_whitespace (pfile
, CUR (pfile
->context
),
996 true /* skip_comments */);
1006 ok
= (*cur
== ')' && macro
->paramc
== 0);
1010 CUR (pfile
->context
) = cur
+ (*cur
== ')');
1015 /* Save the text from pfile->out.base to pfile->out.cur as
1016 the replacement text for the current macro, followed by argument
1017 ARG_INDEX, with zero indicating the end of the replacement
1020 save_replacement_text (pfile
, macro
, arg_index
)
1023 unsigned int arg_index
;
1025 size_t len
= pfile
->out
.cur
- pfile
->out
.base
;
1028 if (macro
->paramc
== 0)
1030 /* Object-like and function-like macros without parameters
1031 simply store their NUL-terminated replacement text. */
1032 exp
= _cpp_unaligned_alloc (pfile
, len
+ 1);
1033 memcpy (exp
, pfile
->out
.base
, len
);
1035 macro
->exp
.text
= exp
;
1040 /* Store the text's length (unsigned int), the argument index
1041 (unsigned short, base 1) and then the text. */
1042 size_t blen
= BLOCK_LEN (len
);
1043 struct block
*block
;
1045 if (macro
->count
+ blen
> BUFF_ROOM (pfile
->a_buff
))
1046 _cpp_extend_buff (pfile
, &pfile
->a_buff
, macro
->count
+ blen
);
1048 exp
= BUFF_FRONT (pfile
->a_buff
);
1049 block
= (struct block
*) (exp
+ macro
->count
);
1050 macro
->exp
.text
= exp
;
1052 /* Write out the block information. */
1053 block
->text_len
= len
;
1054 block
->arg_index
= arg_index
;
1055 memcpy (block
->text
, pfile
->out
.base
, len
);
1057 /* Lex the rest into the start of the output buffer. */
1058 pfile
->out
.cur
= pfile
->out
.base
;
1060 macro
->count
+= blen
;
1062 /* If we've finished, commit the memory. */
1064 BUFF_FRONT (pfile
->a_buff
) += macro
->count
;
1068 /* Analyze and save the replacement text of a macro. Returns true on
1071 _cpp_create_trad_definition (pfile
, macro
)
1077 cpp_context
*context
= pfile
->context
;
1079 /* The context has not been set up for command line defines, and CUR
1080 has not been updated for the macro name for in-file defines. */
1081 pfile
->out
.cur
= pfile
->out
.base
;
1082 CUR (context
) = pfile
->buffer
->cur
;
1083 RLIMIT (context
) = pfile
->buffer
->rlimit
;
1084 check_output_buffer (pfile
, RLIMIT (context
) - CUR (context
));
1086 /* Is this a function-like macro? */
1087 if (* CUR (context
) == '(')
1089 /* Setting macro to NULL indicates an error occurred, and
1090 prevents unnecessary work in scan_out_logical_line. */
1091 if (!scan_parameters (pfile
, macro
))
1095 /* Success. Commit the parameter array. */
1096 macro
->params
= (cpp_hashnode
**) BUFF_FRONT (pfile
->a_buff
);
1097 BUFF_FRONT (pfile
->a_buff
) = (uchar
*) ¯o
->params
[macro
->paramc
];
1098 macro
->fun_like
= 1;
1102 /* Skip leading whitespace in the replacement text. */
1104 = skip_whitespace (pfile
, CUR (context
),
1105 CPP_OPTION (pfile
, discard_comments_in_macro_exp
));
1107 pfile
->state
.prevent_expansion
++;
1108 scan_out_logical_line (pfile
, macro
);
1109 pfile
->state
.prevent_expansion
--;
1114 /* Skip trailing white space. */
1115 cur
= pfile
->out
.base
;
1116 limit
= pfile
->out
.cur
;
1117 while (limit
> cur
&& is_space (limit
[-1]))
1119 pfile
->out
.cur
= limit
;
1120 save_replacement_text (pfile
, macro
, 0);
1125 /* Copy SRC of length LEN to DEST, but convert all contiguous
1126 whitespace to a single space, provided it is not in quotes. The
1127 quote currently in effect is pointed to by PQUOTE, and is updated
1128 by the function. Returns the number of bytes copied. */
1130 canonicalize_text (dest
, src
, len
, pquote
)
1136 uchar
*orig_dest
= dest
;
1137 uchar quote
= *pquote
;
1141 if (is_space (*src
) && !quote
)
1145 while (len
&& is_space (*src
));
1150 if (*src
== '\'' || *src
== '"')
1154 else if (quote
== *src
)
1157 *dest
++ = *src
++, len
--;
1162 return dest
- orig_dest
;
1165 /* Returns true if MACRO1 and MACRO2 have expansions different other
1166 than in the form of their whitespace. */
1168 _cpp_expansions_different_trad (macro1
, macro2
)
1169 const cpp_macro
*macro1
, *macro2
;
1171 uchar
*p1
= xmalloc (macro1
->count
+ macro2
->count
);
1172 uchar
*p2
= p1
+ macro1
->count
;
1173 uchar quote1
= 0, quote2
= 0;
1177 if (macro1
->paramc
> 0)
1179 const uchar
*exp1
= macro1
->exp
.text
, *exp2
= macro2
->exp
.text
;
1184 struct block
*b1
= (struct block
*) exp1
;
1185 struct block
*b2
= (struct block
*) exp2
;
1187 if (b1
->arg_index
!= b2
->arg_index
)
1190 len1
= canonicalize_text (p1
, b1
->text
, b1
->text_len
, "e1
);
1191 len2
= canonicalize_text (p2
, b2
->text
, b2
->text_len
, "e2
);
1192 if (len1
!= len2
|| memcmp (p1
, p2
, len1
))
1194 if (b1
->arg_index
== 0)
1199 exp1
+= BLOCK_LEN (b1
->text_len
);
1200 exp2
+= BLOCK_LEN (b2
->text_len
);
1205 len1
= canonicalize_text (p1
, macro1
->exp
.text
, macro1
->count
, "e1
);
1206 len2
= canonicalize_text (p2
, macro2
->exp
.text
, macro2
->count
, "e2
);
1207 mismatch
= (len1
!= len2
|| memcmp (p1
, p2
, len1
));