1 /* CPP Library - traditional lexical analysis and macro expansion.
2 Copyright (C) 2002, 2004 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
*skip_whitespace (cpp_reader
*, const uchar
*, int);
83 static cpp_hashnode
*lex_identifier (cpp_reader
*, const uchar
*);
84 static const uchar
*copy_comment (cpp_reader
*, const uchar
*, int);
85 static void check_output_buffer (cpp_reader
*, size_t);
86 static void push_replacement_text (cpp_reader
*, cpp_hashnode
*);
87 static bool scan_parameters (cpp_reader
*, cpp_macro
*);
88 static bool recursive_macro (cpp_reader
*, cpp_hashnode
*);
89 static void save_replacement_text (cpp_reader
*, cpp_macro
*, unsigned int);
90 static void maybe_start_funlike (cpp_reader
*, cpp_hashnode
*, const uchar
*,
92 static void save_argument (struct fun_macro
*, size_t);
93 static void replace_args_and_push (cpp_reader
*, struct fun_macro
*);
94 static size_t canonicalize_text (uchar
*, const uchar
*, size_t, uchar
*);
96 /* Ensures we have N bytes' space in the output buffer, and
97 reallocates it if not. */
99 check_output_buffer (cpp_reader
*pfile
, size_t n
)
101 /* We might need two bytes to terminate an unterminated comment, and
102 one more to terminate the line with a NUL. */
105 if (n
> (size_t) (pfile
->out
.limit
- pfile
->out
.cur
))
107 size_t size
= pfile
->out
.cur
- pfile
->out
.base
;
108 size_t new_size
= (size
+ n
) * 3 / 2;
110 pfile
->out
.base
= xrealloc (pfile
->out
.base
, new_size
);
111 pfile
->out
.limit
= pfile
->out
.base
+ new_size
;
112 pfile
->out
.cur
= pfile
->out
.base
+ size
;
116 /* Skip a C-style block comment in a macro as a result of -CC.
117 Buffer->cur points to the initial asterisk of the comment. */
119 skip_macro_block_comment (cpp_reader
*pfile
)
121 const uchar
*cur
= pfile
->buffer
->cur
;
127 /* People like decorating comments with '*', so check for '/'
128 instead for efficiency. */
129 while(! (*cur
++ == '/' && cur
[-2] == '*') )
132 pfile
->buffer
->cur
= cur
;
135 /* CUR points to the asterisk introducing a comment in the current
136 context. IN_DEFINE is true if we are in the replacement text of a
139 The asterisk and following comment is copied to the buffer pointed
140 to by pfile->out.cur, which must be of sufficient size.
141 Unterminated comments are diagnosed, and correctly terminated in
142 the output. pfile->out.cur is updated depending upon IN_DEFINE,
143 -C, -CC and pfile->state.in_directive.
145 Returns a pointer to the first character after the comment in the
148 copy_comment (cpp_reader
*pfile
, const uchar
*cur
, int in_define
)
150 bool unterminated
, copy
= false;
151 source_location src_loc
= pfile
->line
;
152 cpp_buffer
*buffer
= pfile
->buffer
;
155 if (pfile
->context
->prev
)
156 unterminated
= false, skip_macro_block_comment (pfile
);
158 unterminated
= _cpp_skip_block_comment (pfile
);
161 cpp_error_with_line (pfile
, CPP_DL_ERROR
, src_loc
, 0,
162 "unterminated comment");
164 /* Comments in directives become spaces so that tokens are properly
165 separated when the ISO preprocessor re-lexes the line. The
166 exception is #define. */
167 if (pfile
->state
.in_directive
)
171 if (CPP_OPTION (pfile
, discard_comments_in_macro_exp
))
177 pfile
->out
.cur
[-1] = ' ';
179 else if (CPP_OPTION (pfile
, discard_comments
))
186 size_t len
= (size_t) (buffer
->cur
- cur
);
187 memcpy (pfile
->out
.cur
, cur
, len
);
188 pfile
->out
.cur
+= len
;
191 *pfile
->out
.cur
++ = '*';
192 *pfile
->out
.cur
++ = '/';
199 /* CUR points to any character in the input buffer. Skips over all
200 contiguous horizontal white space and NULs, including comments if
201 SKIP_COMMENTS, until reaching the first non-horizontal-whitespace
202 character or the end of the current context. Escaped newlines are
205 The whitespace is copied verbatim to the output buffer, except that
206 comments are handled as described in copy_comment().
207 pfile->out.cur is updated.
209 Returns a pointer to the first character after the whitespace in
212 skip_whitespace (cpp_reader
*pfile
, const uchar
*cur
, int skip_comments
)
214 uchar
*out
= pfile
->out
.cur
;
218 unsigned int c
= *cur
++;
224 if (c
== '/' && *cur
== '*' && skip_comments
)
226 pfile
->out
.cur
= out
;
227 cur
= copy_comment (pfile
, cur
, false /* in_define */);
228 out
= pfile
->out
.cur
;
236 pfile
->out
.cur
= out
;
240 /* Lexes and outputs an identifier starting at CUR, which is assumed
241 to point to a valid first character of an identifier. Returns
242 the hashnode, and updates out.cur. */
243 static cpp_hashnode
*
244 lex_identifier (cpp_reader
*pfile
, const uchar
*cur
)
247 uchar
*out
= pfile
->out
.cur
;
248 cpp_hashnode
*result
;
252 while (is_numchar (*cur
));
254 CUR (pfile
->context
) = cur
;
255 len
= out
- pfile
->out
.cur
;
256 result
= (cpp_hashnode
*) ht_lookup (pfile
->hash_table
, pfile
->out
.cur
,
258 pfile
->out
.cur
= out
;
262 /* Overlays the true file buffer temporarily with text of length LEN
263 starting at START. The true buffer is restored upon calling
266 _cpp_overlay_buffer (cpp_reader
*pfile
, const uchar
*start
, size_t len
)
268 cpp_buffer
*buffer
= pfile
->buffer
;
270 pfile
->overlaid_buffer
= buffer
;
271 pfile
->saved_cur
= buffer
->cur
;
272 pfile
->saved_rlimit
= buffer
->rlimit
;
273 pfile
->saved_line_base
= buffer
->next_line
;
274 pfile
->saved_line
= pfile
->line
;
275 buffer
->need_line
= false;
278 buffer
->line_base
= start
;
279 buffer
->rlimit
= start
+ len
;
282 /* Restores a buffer overlaid by _cpp_overlay_buffer(). */
284 _cpp_remove_overlay (cpp_reader
*pfile
)
286 cpp_buffer
*buffer
= pfile
->overlaid_buffer
;
288 buffer
->cur
= pfile
->saved_cur
;
289 buffer
->rlimit
= pfile
->saved_rlimit
;
290 buffer
->line_base
= pfile
->saved_line_base
;
291 buffer
->need_line
= true;
293 pfile
->overlaid_buffer
= NULL
;
296 /* Reads a logical line into the output buffer. Returns TRUE if there
297 is more text left in the buffer. */
299 _cpp_read_logical_line_trad (cpp_reader
*pfile
)
303 if (pfile
->buffer
->need_line
&& !_cpp_get_fresh_line (pfile
))
306 while (!_cpp_scan_out_logical_line (pfile
, NULL
) || pfile
->state
.skipping
);
308 return pfile
->buffer
!= NULL
;
311 /* Set up state for finding the opening '(' of a function-like
314 maybe_start_funlike (cpp_reader
*pfile
, cpp_hashnode
*node
, const uchar
*start
, struct fun_macro
*macro
)
316 unsigned int n
= node
->value
.macro
->paramc
+ 1;
319 _cpp_release_buff (pfile
, macro
->buff
);
320 macro
->buff
= _cpp_get_buff (pfile
, n
* sizeof (size_t));
321 macro
->args
= (size_t *) BUFF_FRONT (macro
->buff
);
323 macro
->offset
= start
- pfile
->out
.base
;
327 /* Save the OFFSET of the start of the next argument to MACRO. */
329 save_argument (struct fun_macro
*macro
, size_t offset
)
332 if (macro
->argc
<= macro
->node
->value
.macro
->paramc
)
333 macro
->args
[macro
->argc
] = offset
;
336 /* Copies the next logical line in the current buffer (starting at
337 buffer->cur) to the output buffer. The output is guaranteed to
338 terminate with a NUL character. buffer->cur is updated.
340 If MACRO is non-NULL, then we are scanning the replacement list of
341 MACRO, and we call save_replacement_text() every time we meet an
344 _cpp_scan_out_logical_line (cpp_reader
*pfile
, cpp_macro
*macro
)
347 cpp_context
*context
;
350 struct fun_macro fmacro
;
351 unsigned int c
, paren_depth
= 0, quote
;
352 enum ls lex_state
= ls_none
;
354 const uchar
*start_of_input_line
;
359 header_ok
= pfile
->state
.angled_headers
;
360 CUR (pfile
->context
) = pfile
->buffer
->cur
;
361 RLIMIT (pfile
->context
) = pfile
->buffer
->rlimit
;
362 pfile
->out
.cur
= pfile
->out
.base
;
363 pfile
->out
.first_line
= pfile
->line
;
364 /* start_of_input_line is needed to make sure that directives really,
365 really start at the first character of the line. */
366 start_of_input_line
= pfile
->buffer
->cur
;
368 context
= pfile
->context
;
370 check_output_buffer (pfile
, RLIMIT (context
) - cur
);
371 out
= pfile
->out
.cur
;
376 && cur
>= pfile
->buffer
->notes
[pfile
->buffer
->cur_note
].pos
)
378 pfile
->buffer
->cur
= cur
;
379 _cpp_process_line_notes (pfile
, false);
384 /* Whitespace should "continue" out of the switch,
385 non-whitespace should "break" out of it. */
396 /* If this is a macro's expansion, pop it. */
399 pfile
->out
.cur
= out
- 1;
400 _cpp_pop_context (pfile
);
404 /* Omit the newline from the output buffer. */
405 pfile
->out
.cur
= out
- 1;
406 pfile
->buffer
->cur
= cur
;
407 pfile
->buffer
->need_line
= true;
408 CPP_INCREMENT_LINE (pfile
, 0);
410 if ((lex_state
== ls_fun_open
|| lex_state
== ls_fun_close
)
411 && !pfile
->state
.in_directive
412 && _cpp_get_fresh_line (pfile
))
414 /* Newlines in arguments become a space, but we don't
415 clear any in-progress quote. */
416 if (lex_state
== ls_fun_close
)
418 cur
= pfile
->buffer
->cur
;
441 /* Skip escaped quotes here, it's easier than above. */
442 if (*cur
== '\\' || *cur
== '"' || *cur
== '\'')
447 /* Traditional CPP does not recognize comments within
449 if (!quote
&& *cur
== '*')
451 pfile
->out
.cur
= out
;
452 cur
= copy_comment (pfile
, cur
, macro
!= 0);
453 out
= pfile
->out
.cur
;
459 case 'a': case 'b': case 'c': case 'd': case 'e': case 'f':
460 case 'g': case 'h': case 'i': case 'j': case 'k': case 'l':
461 case 'm': case 'n': case 'o': case 'p': case 'q': case 'r':
462 case 's': case 't': case 'u': case 'v': case 'w': case 'x':
464 case 'A': case 'B': case 'C': case 'D': case 'E': case 'F':
465 case 'G': case 'H': case 'I': case 'J': case 'K': case 'L':
466 case 'M': case 'N': case 'O': case 'P': case 'Q': case 'R':
467 case 'S': case 'T': case 'U': case 'V': case 'W': case 'X':
469 if (!pfile
->state
.skipping
&& (quote
== 0 || macro
))
472 uchar
*out_start
= out
- 1;
474 pfile
->out
.cur
= out_start
;
475 node
= lex_identifier (pfile
, cur
- 1);
476 out
= pfile
->out
.cur
;
479 if (node
->type
== NT_MACRO
480 /* Should we expand for ls_answer? */
481 && (lex_state
== ls_none
|| lex_state
== ls_fun_open
)
482 && !pfile
->state
.prevent_expansion
)
484 /* Macros invalidate MI optimization. */
485 pfile
->mi_valid
= false;
486 if (! (node
->flags
& NODE_BUILTIN
)
487 && node
->value
.macro
->fun_like
)
489 maybe_start_funlike (pfile
, node
, out_start
, &fmacro
);
490 lex_state
= ls_fun_open
;
491 fmacro
.line
= pfile
->line
;
494 else if (!recursive_macro (pfile
, node
))
496 /* Remove the object-like macro's name from the
497 output, and push its replacement text. */
498 pfile
->out
.cur
= out_start
;
499 push_replacement_text (pfile
, node
);
504 else if (macro
&& (node
->flags
& NODE_MACRO_ARG
) != 0)
506 /* Found a parameter in the replacement text of a
507 #define. Remove its name from the output. */
508 pfile
->out
.cur
= out_start
;
509 save_replacement_text (pfile
, macro
, node
->value
.arg_index
);
510 out
= pfile
->out
.base
;
512 else if (lex_state
== ls_hash
)
514 lex_state
= ls_predicate
;
517 else if (pfile
->state
.in_expression
518 && node
== pfile
->spec_nodes
.n_defined
)
520 lex_state
= ls_defined
;
530 if (lex_state
== ls_fun_open
)
532 if (recursive_macro (pfile
, fmacro
.node
))
536 lex_state
= ls_fun_close
;
538 out
= pfile
->out
.base
+ fmacro
.offset
;
539 fmacro
.args
[0] = fmacro
.offset
;
542 else if (lex_state
== ls_predicate
)
543 lex_state
= ls_answer
;
544 else if (lex_state
== ls_defined
)
545 lex_state
= ls_defined_close
;
550 if (quote
== 0 && lex_state
== ls_fun_close
&& paren_depth
== 1)
551 save_argument (&fmacro
, out
- pfile
->out
.base
);
558 if (lex_state
== ls_fun_close
&& paren_depth
== 0)
560 cpp_macro
*m
= fmacro
.node
->value
.macro
;
564 save_argument (&fmacro
, out
- pfile
->out
.base
);
566 /* A single zero-length argument is no argument. */
569 && out
== pfile
->out
.base
+ fmacro
.offset
+ 1)
572 if (_cpp_arguments_ok (pfile
, m
, fmacro
.node
, fmacro
.argc
))
574 /* Remove the macro's invocation from the
575 output, and push its replacement text. */
576 pfile
->out
.cur
= (pfile
->out
.base
579 replace_args_and_push (pfile
, &fmacro
);
583 else if (lex_state
== ls_answer
|| lex_state
== ls_defined_close
)
589 if (cur
- 1 == start_of_input_line
590 /* A '#' from a macro doesn't start a directive. */
591 && !pfile
->context
->prev
592 && !pfile
->state
.in_directive
)
594 /* A directive. With the way _cpp_handle_directive
595 currently works, we only want to call it if either we
596 know the directive is OK, or we want it to fail and
597 be removed from the output. If we want it to be
598 passed through (the assembler case) then we must not
599 call _cpp_handle_directive. */
600 pfile
->out
.cur
= out
;
601 cur
= skip_whitespace (pfile
, cur
, true /* skip_comments */);
602 out
= pfile
->out
.cur
;
606 /* Null directive. Ignore it and don't invalidate
607 the MI optimization. */
608 pfile
->buffer
->need_line
= true;
609 CPP_INCREMENT_LINE (pfile
, 0);
617 if (is_numstart (*cur
)
618 && CPP_OPTION (pfile
, lang
) != CLK_ASM
)
620 else if (is_idstart (*cur
))
621 /* Check whether we know this directive, but don't
623 do_it
= lex_identifier (pfile
, cur
)->is_directive
;
625 if (do_it
|| CPP_OPTION (pfile
, lang
) != CLK_ASM
)
627 /* This is a kludge. We want to have the ISO
628 preprocessor lex the next token. */
629 pfile
->buffer
->cur
= cur
;
630 _cpp_handle_directive (pfile
, false /* indented */);
637 if (pfile
->state
.in_expression
)
648 /* Non-whitespace disables MI optimization and stops treating
649 '<' as a quote in #include. */
651 if (!pfile
->state
.in_directive
)
652 pfile
->mi_valid
= false;
654 if (lex_state
== ls_none
)
657 /* Some of these transitions of state are syntax errors. The
658 ISO preprocessor will issue errors later. */
659 if (lex_state
== ls_fun_open
)
662 else if (lex_state
== ls_hash
663 || lex_state
== ls_predicate
664 || lex_state
== ls_defined
)
667 /* ls_answer and ls_defined_close keep going until ')'. */
672 _cpp_release_buff (pfile
, fmacro
.buff
);
674 if (lex_state
== ls_fun_close
)
675 cpp_error_with_line (pfile
, CPP_DL_ERROR
, fmacro
.line
, 0,
676 "unterminated argument list invoking macro \"%s\"",
677 NODE_NAME (fmacro
.node
));
681 /* Push a context holding the replacement text of the macro NODE on
682 the context stack. NODE is either object-like, or a function-like
683 macro with no arguments. */
685 push_replacement_text (cpp_reader
*pfile
, cpp_hashnode
*node
)
691 if (node
->flags
& NODE_BUILTIN
)
693 text
= _cpp_builtin_macro_text (pfile
, node
);
694 len
= ustrlen (text
);
695 buf
= _cpp_unaligned_alloc (pfile
, len
+ 1);
696 memcpy (buf
, text
, len
);
702 cpp_macro
*macro
= node
->value
.macro
;
704 text
= macro
->exp
.text
;
708 _cpp_push_text_context (pfile
, node
, text
, len
);
711 /* Returns TRUE if traditional macro recursion is detected. */
713 recursive_macro (cpp_reader
*pfile
, cpp_hashnode
*node
)
715 bool recursing
= !!(node
->flags
& NODE_DISABLED
);
717 /* Object-like macros that are already expanding are necessarily
720 However, it is possible to have traditional function-like macros
721 that are not infinitely recursive but recurse to any given depth.
722 Further, it is easy to construct examples that get ever longer
723 until the point they stop recursing. So there is no easy way to
724 detect true recursion; instead we assume any expansion more than
725 20 deep since the first invocation of this macro must be
727 if (recursing
&& node
->value
.macro
->fun_like
)
730 cpp_context
*context
= pfile
->context
;
735 if (context
->macro
== node
&& depth
> 20)
737 context
= context
->prev
;
740 recursing
= context
!= NULL
;
744 cpp_error (pfile
, CPP_DL_ERROR
,
745 "detected recursion whilst expanding macro \"%s\"",
751 /* Return the length of the replacement text of a function-like or
752 object-like non-builtin macro. */
754 _cpp_replacement_text_len (const cpp_macro
*macro
)
758 if (macro
->fun_like
&& (macro
->paramc
!= 0))
763 for (exp
= macro
->exp
.text
;;)
765 struct block
*b
= (struct block
*) exp
;
768 if (b
->arg_index
== 0)
770 len
+= NODE_LEN (macro
->params
[b
->arg_index
- 1]);
771 exp
+= BLOCK_LEN (b
->text_len
);
780 /* Copy the replacement text of MACRO to DEST, which must be of
781 sufficient size. It is not NUL-terminated. The next character is
784 _cpp_copy_replacement_text (const cpp_macro
*macro
, uchar
*dest
)
786 if (macro
->fun_like
&& (macro
->paramc
!= 0))
790 for (exp
= macro
->exp
.text
;;)
792 struct block
*b
= (struct block
*) exp
;
795 memcpy (dest
, b
->text
, b
->text_len
);
797 if (b
->arg_index
== 0)
799 param
= macro
->params
[b
->arg_index
- 1];
800 memcpy (dest
, NODE_NAME (param
), NODE_LEN (param
));
801 dest
+= NODE_LEN (param
);
802 exp
+= BLOCK_LEN (b
->text_len
);
807 memcpy (dest
, macro
->exp
.text
, macro
->count
);
808 dest
+= macro
->count
;
814 /* Push a context holding the replacement text of the macro NODE on
815 the context stack. NODE is either object-like, or a function-like
816 macro with no arguments. */
818 replace_args_and_push (cpp_reader
*pfile
, struct fun_macro
*fmacro
)
820 cpp_macro
*macro
= fmacro
->node
->value
.macro
;
822 if (macro
->paramc
== 0)
823 push_replacement_text (pfile
, fmacro
->node
);
831 /* Calculate the length of the argument-replaced text. */
832 for (exp
= macro
->exp
.text
;;)
834 struct block
*b
= (struct block
*) exp
;
837 if (b
->arg_index
== 0)
839 len
+= (fmacro
->args
[b
->arg_index
]
840 - fmacro
->args
[b
->arg_index
- 1] - 1);
841 exp
+= BLOCK_LEN (b
->text_len
);
844 /* Allocate room for the expansion plus \n. */
845 buff
= _cpp_get_buff (pfile
, len
+ 1);
847 /* Copy the expansion and replace arguments. */
848 p
= BUFF_FRONT (buff
);
849 for (exp
= macro
->exp
.text
;;)
851 struct block
*b
= (struct block
*) exp
;
854 memcpy (p
, b
->text
, b
->text_len
);
856 if (b
->arg_index
== 0)
858 arglen
= (fmacro
->args
[b
->arg_index
]
859 - fmacro
->args
[b
->arg_index
- 1] - 1);
860 memcpy (p
, pfile
->out
.base
+ fmacro
->args
[b
->arg_index
- 1],
863 exp
+= BLOCK_LEN (b
->text_len
);
868 _cpp_push_text_context (pfile
, fmacro
->node
, BUFF_FRONT (buff
), len
);
870 /* So we free buffer allocation when macro is left. */
871 pfile
->context
->buff
= buff
;
875 /* Read and record the parameters, if any, of a function-like macro
876 definition. Destroys pfile->out.cur.
878 Returns true on success, false on failure (syntax error or a
879 duplicate parameter). On success, CUR (pfile->context) is just
880 past the closing parenthesis. */
882 scan_parameters (cpp_reader
*pfile
, cpp_macro
*macro
)
884 const uchar
*cur
= CUR (pfile
->context
) + 1;
889 cur
= skip_whitespace (pfile
, cur
, true /* skip_comments */);
891 if (is_idstart (*cur
))
894 if (_cpp_save_parameter (pfile
, macro
, lex_identifier (pfile
, cur
)))
896 cur
= skip_whitespace (pfile
, CUR (pfile
->context
),
897 true /* skip_comments */);
907 ok
= (*cur
== ')' && macro
->paramc
== 0);
912 cpp_error (pfile
, CPP_DL_ERROR
, "syntax error in macro parameter list");
914 CUR (pfile
->context
) = cur
+ (*cur
== ')');
919 /* Save the text from pfile->out.base to pfile->out.cur as
920 the replacement text for the current macro, followed by argument
921 ARG_INDEX, with zero indicating the end of the replacement
924 save_replacement_text (cpp_reader
*pfile
, cpp_macro
*macro
,
925 unsigned int arg_index
)
927 size_t len
= pfile
->out
.cur
- pfile
->out
.base
;
930 if (macro
->paramc
== 0)
932 /* Object-like and function-like macros without parameters
933 simply store their \n-terminated replacement text. */
934 exp
= _cpp_unaligned_alloc (pfile
, len
+ 1);
935 memcpy (exp
, pfile
->out
.base
, len
);
937 macro
->exp
.text
= exp
;
942 /* Store the text's length (unsigned int), the argument index
943 (unsigned short, base 1) and then the text. */
944 size_t blen
= BLOCK_LEN (len
);
947 if (macro
->count
+ blen
> BUFF_ROOM (pfile
->a_buff
))
948 _cpp_extend_buff (pfile
, &pfile
->a_buff
, macro
->count
+ blen
);
950 exp
= BUFF_FRONT (pfile
->a_buff
);
951 block
= (struct block
*) (exp
+ macro
->count
);
952 macro
->exp
.text
= exp
;
954 /* Write out the block information. */
955 block
->text_len
= len
;
956 block
->arg_index
= arg_index
;
957 memcpy (block
->text
, pfile
->out
.base
, len
);
959 /* Lex the rest into the start of the output buffer. */
960 pfile
->out
.cur
= pfile
->out
.base
;
962 macro
->count
+= blen
;
964 /* If we've finished, commit the memory. */
966 BUFF_FRONT (pfile
->a_buff
) += macro
->count
;
970 /* Analyze and save the replacement text of a macro. Returns true on
973 _cpp_create_trad_definition (cpp_reader
*pfile
, cpp_macro
*macro
)
977 cpp_context
*context
= pfile
->context
;
979 /* The context has not been set up for command line defines, and CUR
980 has not been updated for the macro name for in-file defines. */
981 pfile
->out
.cur
= pfile
->out
.base
;
982 CUR (context
) = pfile
->buffer
->cur
;
983 RLIMIT (context
) = pfile
->buffer
->rlimit
;
984 check_output_buffer (pfile
, RLIMIT (context
) - CUR (context
));
986 /* Is this a function-like macro? */
987 if (* CUR (context
) == '(')
989 bool ok
= scan_parameters (pfile
, macro
);
991 /* Remember the params so we can clear NODE_MACRO_ARG flags. */
992 macro
->params
= (cpp_hashnode
**) BUFF_FRONT (pfile
->a_buff
);
994 /* Setting macro to NULL indicates an error occurred, and
995 prevents unnecessary work in _cpp_scan_out_logical_line. */
1000 BUFF_FRONT (pfile
->a_buff
) = (uchar
*) ¯o
->params
[macro
->paramc
];
1001 macro
->fun_like
= 1;
1005 /* Skip leading whitespace in the replacement text. */
1007 = skip_whitespace (pfile
, CUR (context
),
1008 CPP_OPTION (pfile
, discard_comments_in_macro_exp
));
1010 pfile
->state
.prevent_expansion
++;
1011 _cpp_scan_out_logical_line (pfile
, macro
);
1012 pfile
->state
.prevent_expansion
--;
1017 /* Skip trailing white space. */
1018 cur
= pfile
->out
.base
;
1019 limit
= pfile
->out
.cur
;
1020 while (limit
> cur
&& is_space (limit
[-1]))
1022 pfile
->out
.cur
= limit
;
1023 save_replacement_text (pfile
, macro
, 0);
1028 /* Copy SRC of length LEN to DEST, but convert all contiguous
1029 whitespace to a single space, provided it is not in quotes. The
1030 quote currently in effect is pointed to by PQUOTE, and is updated
1031 by the function. Returns the number of bytes copied. */
1033 canonicalize_text (uchar
*dest
, const uchar
*src
, size_t len
, uchar
*pquote
)
1035 uchar
*orig_dest
= dest
;
1036 uchar quote
= *pquote
;
1040 if (is_space (*src
) && !quote
)
1044 while (len
&& is_space (*src
));
1049 if (*src
== '\'' || *src
== '"')
1053 else if (quote
== *src
)
1056 *dest
++ = *src
++, len
--;
1061 return dest
- orig_dest
;
1064 /* Returns true if MACRO1 and MACRO2 have expansions different other
1065 than in the form of their whitespace. */
1067 _cpp_expansions_different_trad (const cpp_macro
*macro1
,
1068 const cpp_macro
*macro2
)
1070 uchar
*p1
= xmalloc (macro1
->count
+ macro2
->count
);
1071 uchar
*p2
= p1
+ macro1
->count
;
1072 uchar quote1
= 0, quote2
= 0;
1076 if (macro1
->paramc
> 0)
1078 const uchar
*exp1
= macro1
->exp
.text
, *exp2
= macro2
->exp
.text
;
1083 struct block
*b1
= (struct block
*) exp1
;
1084 struct block
*b2
= (struct block
*) exp2
;
1086 if (b1
->arg_index
!= b2
->arg_index
)
1089 len1
= canonicalize_text (p1
, b1
->text
, b1
->text_len
, "e1
);
1090 len2
= canonicalize_text (p2
, b2
->text
, b2
->text_len
, "e2
);
1091 if (len1
!= len2
|| memcmp (p1
, p2
, len1
))
1093 if (b1
->arg_index
== 0)
1098 exp1
+= BLOCK_LEN (b1
->text_len
);
1099 exp2
+= BLOCK_LEN (b2
->text_len
);
1104 len1
= canonicalize_text (p1
, macro1
->exp
.text
, macro1
->count
, "e1
);
1105 len2
= canonicalize_text (p2
, macro2
->exp
.text
, macro2
->count
, "e2
);
1106 mismatch
= (len1
!= len2
|| memcmp (p1
, p2
, len1
));