[ARM] Rename FPSCR builtins to correct names
[official-gcc.git] / libcpp / traditional.c
blobe6004357ca36ffe065eb0064b3d9ac932d1610d6
1 /* CPP Library - traditional lexical analysis and macro expansion.
2 Copyright (C) 2002-2017 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
8 later version.
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/>. */
19 #include "config.h"
20 #include "system.h"
21 #include "cpplib.h"
22 #include "internal.h"
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. */
33 struct block
35 unsigned int text_len;
36 unsigned short arg_index;
37 uchar text[1];
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
44 invocation. */
45 struct fun_macro
47 /* Memory buffer holding the trad_arg array. */
48 _cpp_buff *buff;
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. */
54 size_t *args;
56 /* The hashnode of the macro. */
57 cpp_hashnode *node;
59 /* The offset of the macro name in the output buffer. */
60 size_t offset;
62 /* The line the macro name appeared on. */
63 source_location line;
65 /* Number of parameters. */
66 unsigned int paramc;
68 /* Zero-based index of argument being currently lexed. */
69 unsigned int argc;
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 *,
96 struct fun_macro *);
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. */
103 static void
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. */
108 n += 2 + 1;
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. */
123 static void
124 skip_macro_block_comment (cpp_reader *pfile)
126 const uchar *cur = pfile->buffer->cur;
128 cur++;
129 if (*cur == '/')
130 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
142 macro.
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
151 input buffer. */
152 static const uchar *
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;
159 buffer->cur = cur;
160 if (pfile->context->prev)
161 unterminated = false, skip_macro_block_comment (pfile);
162 else
163 unterminated = _cpp_skip_block_comment (pfile);
165 if (unterminated)
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)
174 if (in_define)
176 if (CPP_OPTION (pfile, discard_comments_in_macro_exp))
177 pfile->out.cur--;
178 else
179 copy = true;
181 else
182 pfile->out.cur[-1] = ' ';
184 else if (CPP_OPTION (pfile, discard_comments))
185 pfile->out.cur--;
186 else
187 copy = true;
189 if (copy)
191 size_t len = (size_t) (buffer->cur - cur);
192 memcpy (pfile->out.cur, cur, len);
193 pfile->out.cur += len;
194 if (unterminated)
196 *pfile->out.cur++ = '*';
197 *pfile->out.cur++ = '/';
201 return buffer->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
208 removed.
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
215 the input buffer. */
216 static const uchar *
217 skip_whitespace (cpp_reader *pfile, const uchar *cur, int skip_comments)
219 uchar *out = pfile->out.cur;
221 for (;;)
223 unsigned int c = *cur++;
224 *out++ = c;
226 if (is_nvspace (c))
227 continue;
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;
234 continue;
237 out--;
238 break;
241 pfile->out.cur = out;
242 return cur - 1;
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)
251 size_t len;
252 uchar *out = pfile->out.cur;
253 cpp_hashnode *result;
256 *out++ = *cur++;
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,
262 len, HT_ALLOC));
263 pfile->out.cur = out;
264 return result;
267 /* Overlays the true file buffer temporarily with text of length LEN
268 starting at START. The true buffer is restored upon calling
269 restore_buff(). */
270 void
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;
281 buffer->cur = start;
282 buffer->line_base = start;
283 buffer->rlimit = start + len;
286 /* Restores a buffer overlaid by _cpp_overlay_buffer(). */
287 void
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. */
302 bool
303 _cpp_read_logical_line_trad (cpp_reader *pfile)
307 if (pfile->buffer->need_line && !_cpp_get_fresh_line (pfile))
308 return false;
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. */
317 static inline bool
318 fun_like_macro (cpp_hashnode *node)
320 if (node->flags & NODE_BUILTIN)
321 return node->value.builtin == BT_HAS_ATTRIBUTE;
322 else
323 return node->value.macro->fun_like;
326 /* Set up state for finding the opening '(' of a function-like
327 macro. */
328 static void
329 maybe_start_funlike (cpp_reader *pfile, cpp_hashnode *node, const uchar *start,
330 struct fun_macro *macro)
332 unsigned int n;
333 if (node->flags & NODE_BUILTIN)
334 n = 1;
335 else
336 n = node->value.macro->paramc;
338 if (macro->buff)
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);
342 macro->node = node;
343 macro->offset = start - pfile->out.base;
344 macro->paramc = n;
345 macro->argc = 0;
348 /* Save the OFFSET of the start of the next argument to MACRO. */
349 static void
350 save_argument (struct fun_macro *macro, size_t offset)
352 macro->argc++;
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
363 argument.
365 If BUILTIN_MACRO_ARG is true, this is called to macro expand
366 arguments of builtin function-like macros. */
367 bool
368 _cpp_scan_out_logical_line (cpp_reader *pfile, cpp_macro *macro,
369 bool builtin_macro_arg)
371 bool result = true;
372 cpp_context *context;
373 const uchar *cur;
374 uchar *out;
375 struct fun_macro fmacro;
376 unsigned int c, paren_depth = 0, quote;
377 enum ls lex_state = ls_none;
378 bool header_ok;
379 const uchar *start_of_input_line;
381 fmacro.buff = NULL;
382 fmacro.args = NULL;
383 fmacro.node = NULL;
384 fmacro.offset = 0;
385 fmacro.line = 0;
386 fmacro.paramc = 0;
387 fmacro.argc = 0;
389 quote = 0;
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;
401 new_context:
402 context = pfile->context;
403 cur = CUR (context);
404 check_output_buffer (pfile, RLIMIT (context) - cur);
405 out = pfile->out.cur;
407 for (;;)
409 if (!context->prev
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);
416 c = *cur++;
417 *out++ = c;
419 /* Whitespace should "continue" out of the switch,
420 non-whitespace should "break" out of it. */
421 switch (c)
423 case ' ':
424 case '\t':
425 case '\f':
426 case '\v':
427 case '\0':
428 continue;
430 case '\n':
431 /* If this is a macro's expansion, pop it. */
432 if (context->prev)
434 pfile->out.cur = out - 1;
435 _cpp_pop_context (pfile);
436 goto new_context;
439 /* Omit the newline from the output buffer. */
440 pfile->out.cur = out - 1;
441 pfile->buffer->cur = cur;
442 if (builtin_macro_arg)
443 goto done;
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)
454 out[-1] = ' ';
455 cur = pfile->buffer->cur;
456 continue;
458 goto done;
460 case '<':
461 if (header_ok)
462 quote = '>';
463 break;
464 case '>':
465 if (c == quote)
466 quote = 0;
467 break;
469 case '"':
470 case '\'':
471 if (c == quote)
472 quote = 0;
473 else if (!quote)
474 quote = c;
475 break;
477 case '\\':
478 /* Skip escaped quotes here, it's easier than above. */
479 if (*cur == '\\' || *cur == '"' || *cur == '\'')
480 *out++ = *cur++;
481 break;
483 case '/':
484 /* Traditional CPP does not recognize comments within
485 literals. */
486 if (!quote && *cur == '*')
488 pfile->out.cur = out;
489 cur = copy_comment (pfile, cur, macro != 0);
490 out = pfile->out.cur;
491 continue;
493 break;
495 case '_':
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':
500 case 'y': case 'z':
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':
505 case 'Y': case 'Z':
506 if (!pfile->state.skipping && (quote == 0 || macro))
508 cpp_hashnode *node;
509 uchar *out_start = out - 1;
511 pfile->out.cur = out_start;
512 node = lex_identifier (pfile, cur - 1);
513 out = pfile->out.cur;
514 cur = CUR (context);
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;
528 continue;
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);
536 lex_state = ls_none;
537 goto new_context;
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;
551 continue;
553 else if (pfile->state.in_expression
554 && node == pfile->spec_nodes.n_defined)
556 lex_state = ls_defined;
557 continue;
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;
564 continue;
567 break;
569 case '(':
570 if (quote == 0)
572 paren_depth++;
573 if (lex_state == ls_fun_open)
575 if (recursive_macro (pfile, fmacro.node))
576 lex_state = ls_none;
577 else
579 lex_state = ls_fun_close;
580 paren_depth = 1;
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;
592 break;
594 case ',':
595 if (quote == 0 && lex_state == ls_fun_close && paren_depth == 1)
596 save_argument (&fmacro, out - pfile->out.base);
597 break;
599 case ')':
600 if (quote == 0)
602 paren_depth--;
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. */
625 lex_state = ls_none;
626 save_argument (&fmacro, out - pfile->out.base);
627 cpp_macro m;
628 memset (&m, '\0', sizeof (m));
629 m.paramc = fmacro.paramc;
630 if (_cpp_arguments_ok (pfile, &m, fmacro.node,
631 fmacro.argc))
633 size_t len = fmacro.args[1] - fmacro.args[0];
634 uchar *buf;
636 /* Remove the macro's invocation from the
637 output, and push its replacement text. */
638 pfile->out.cur = pfile->out.base + fmacro.offset;
639 CUR (context) = cur;
640 buf = _cpp_unaligned_alloc (pfile, len + 2);
641 buf[0] = '(';
642 memcpy (buf + 1, pfile->out.base + fmacro.args[0],
643 len);
644 buf[len + 1] = '\n';
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++;
677 const uchar *text
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;
688 CUR (context) = cur;
689 RLIMIT (context) = ctx_rlimit;
690 len = ustrlen (text);
691 buf = _cpp_unaligned_alloc (pfile, len + 1);
692 memcpy (buf, text, len);
693 buf[len] = '\n';
694 text = buf;
695 _cpp_push_text_context (pfile, fmacro.node,
696 text, len);
697 goto new_context;
699 break;
702 cpp_macro *m = fmacro.node->value.macro;
704 m->used = 1;
705 lex_state = ls_none;
706 save_argument (&fmacro, out - pfile->out.base);
708 /* A single zero-length argument is no argument. */
709 if (fmacro.argc == 1
710 && m->paramc == 0
711 && out == pfile->out.base + fmacro.offset + 1)
712 fmacro.argc = 0;
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;
719 CUR (context) = cur;
720 replace_args_and_push (pfile, &fmacro);
721 goto new_context;
724 else if (lex_state == ls_answer || lex_state == ls_defined_close
725 || lex_state == ls_has_include_close)
726 lex_state = ls_none;
728 break;
730 case '#':
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;
746 if (*cur == '\n')
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);
752 result = false;
753 goto done;
755 else
757 bool do_it = false;
759 if (is_numstart (*cur)
760 && CPP_OPTION (pfile, lang) != CLK_ASM)
761 do_it = true;
762 else if (is_idstart (*cur))
763 /* Check whether we know this directive, but don't
764 advance. */
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 */);
773 result = false;
774 goto done;
779 if (pfile->state.in_expression)
781 lex_state = ls_hash;
782 continue;
784 break;
786 default:
787 break;
790 /* Non-whitespace disables MI optimization and stops treating
791 '<' as a quote in #include. */
792 header_ok = false;
793 if (!pfile->state.in_directive)
794 pfile->mi_valid = false;
796 if (lex_state == ls_none)
797 continue;
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)
802 /* Missing '('. */
803 lex_state = ls_none;
804 else if (lex_state == ls_hash
805 || lex_state == ls_predicate
806 || lex_state == ls_defined
807 || lex_state == ls_has_include)
808 lex_state = ls_none;
810 /* ls_answer and ls_defined_close keep going until ')'. */
813 done:
814 if (fmacro.buff)
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));
821 return result;
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. */
827 static void
828 push_replacement_text (cpp_reader *pfile, cpp_hashnode *node)
830 size_t len;
831 const uchar *text;
832 uchar *buf;
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);
840 buf[len] = '\n';
841 text = buf;
843 else
845 cpp_macro *macro = node->value.macro;
846 macro->used = 1;
847 text = macro->exp.text;
848 macro->traditional = 1;
849 len = macro->count;
852 _cpp_push_text_context (pfile, node, text, len);
855 /* Returns TRUE if traditional macro recursion is detected. */
856 static bool
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
862 recursive.
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
870 recursing. */
871 if (recursing && fun_like_macro (node))
873 size_t depth = 0;
874 cpp_context *context = pfile->context;
878 depth++;
879 if (context->c.macro == node && depth > 20)
880 break;
881 context = context->prev;
883 while (context);
884 recursing = context != NULL;
887 if (recursing)
888 cpp_error (pfile, CPP_DL_ERROR,
889 "detected recursion whilst expanding macro \"%s\"",
890 NODE_NAME (node));
892 return recursing;
895 /* Return the length of the replacement text of a function-like or
896 object-like non-builtin macro. */
897 size_t
898 _cpp_replacement_text_len (const cpp_macro *macro)
900 size_t len;
902 if (macro->fun_like && (macro->paramc != 0))
904 const uchar *exp;
906 len = 0;
907 for (exp = macro->exp.text;;)
909 struct block *b = (struct block *) exp;
911 len += b->text_len;
912 if (b->arg_index == 0)
913 break;
914 len += NODE_LEN (macro->params[b->arg_index - 1]);
915 exp += BLOCK_LEN (b->text_len);
918 else
919 len = macro->count;
921 return 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
926 returned. */
927 uchar *
928 _cpp_copy_replacement_text (const cpp_macro *macro, uchar *dest)
930 if (macro->fun_like && (macro->paramc != 0))
932 const uchar *exp;
934 for (exp = macro->exp.text;;)
936 struct block *b = (struct block *) exp;
937 cpp_hashnode *param;
939 memcpy (dest, b->text, b->text_len);
940 dest += b->text_len;
941 if (b->arg_index == 0)
942 break;
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);
949 else
951 memcpy (dest, macro->exp.text, macro->count);
952 dest += macro->count;
955 return dest;
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. */
961 static void
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);
968 else
970 const uchar *exp;
971 uchar *p;
972 _cpp_buff *buff;
973 size_t len = 0;
974 int cxtquote = 0;
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;
983 len += b->text_len;
984 if (b->arg_index == 0)
985 break;
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);
997 len = 0;
998 for (exp = macro->exp.text;;)
1000 struct block *b = (struct block *) exp;
1001 size_t arglen;
1002 int argquote;
1003 uchar *base;
1004 uchar *in;
1006 len += b->text_len;
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--)
1011 if (*in == '"')
1012 cxtquote = ! cxtquote;
1013 *p++ = *in++;
1015 /* Done if no more arguments */
1016 if (b->arg_index == 0)
1017 break;
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];
1021 in = base;
1022 #if 0
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
1029 preserved. */
1030 while (arglen > 0 && is_space (*in))
1032 in++;
1033 arglen--;
1035 #endif
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 */
1044 *p++ = '\\';
1045 len++;
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. */
1052 *p++ = '\\';
1053 len++;
1055 *p++ = *in++;
1056 len++;
1058 exp += BLOCK_LEN (b->text_len);
1061 /* \n-terminate. */
1062 *p = '\n';
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. */
1076 static bool
1077 scan_parameters (cpp_reader *pfile, cpp_macro *macro)
1079 const uchar *cur = CUR (pfile->context) + 1;
1080 bool ok;
1082 for (;;)
1084 cur = skip_whitespace (pfile, cur, true /* skip_comments */);
1086 if (is_idstart (*cur))
1088 struct cpp_hashnode *id = lex_identifier (pfile, cur);
1089 ok = false;
1090 if (_cpp_save_parameter (pfile, macro, id, id))
1091 break;
1092 cur = skip_whitespace (pfile, CUR (pfile->context),
1093 true /* skip_comments */);
1094 if (*cur == ',')
1096 cur++;
1097 continue;
1099 ok = (*cur == ')');
1100 break;
1103 ok = (*cur == ')' && macro->paramc == 0);
1104 break;
1107 if (!ok)
1108 cpp_error (pfile, CPP_DL_ERROR, "syntax error in macro parameter list");
1110 CUR (pfile->context) = cur + (*cur == ')');
1112 return ok;
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
1118 text. */
1119 static void
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;
1124 uchar *exp;
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);
1132 exp[len] = '\n';
1133 macro->exp.text = exp;
1134 macro->traditional = 1;
1135 macro->count = len;
1137 else
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. */
1163 if (arg_index == 0)
1164 BUFF_FRONT (pfile->a_buff) += macro->count;
1168 /* Analyze and save the replacement text of a macro. Returns true on
1169 success. */
1170 bool
1171 _cpp_create_trad_definition (cpp_reader *pfile, cpp_macro *macro)
1173 const uchar *cur;
1174 uchar *limit;
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. */
1194 if (!ok)
1195 macro = NULL;
1196 else
1198 BUFF_FRONT (pfile->a_buff) = (uchar *) &macro->params[macro->paramc];
1199 macro->fun_like = 1;
1203 /* Skip leading whitespace in the replacement text. */
1204 pfile->buffer->cur
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--;
1212 if (!macro)
1213 return false;
1215 /* Skip trailing white space. */
1216 cur = pfile->out.base;
1217 limit = pfile->out.cur;
1218 while (limit > cur && is_space (limit[-1]))
1219 limit--;
1220 pfile->out.cur = limit;
1221 save_replacement_text (pfile, macro, 0);
1223 return true;
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. */
1230 static size_t
1231 canonicalize_text (uchar *dest, const uchar *src, size_t len, uchar *pquote)
1233 uchar *orig_dest = dest;
1234 uchar quote = *pquote;
1236 while (len)
1238 if (is_space (*src) && !quote)
1241 src++, len--;
1242 while (len && is_space (*src));
1243 *dest++ = ' ';
1245 else
1247 if (*src == '\'' || *src == '"')
1249 if (!quote)
1250 quote = *src;
1251 else if (quote == *src)
1252 quote = 0;
1254 *dest++ = *src++, len--;
1258 *pquote = quote;
1259 return dest - orig_dest;
1262 /* Returns true if MACRO1 and MACRO2 have expansions different other
1263 than in the form of their whitespace. */
1264 bool
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;
1271 bool mismatch;
1272 size_t len1, len2;
1274 if (macro1->paramc > 0)
1276 const uchar *exp1 = macro1->exp.text, *exp2 = macro2->exp.text;
1278 mismatch = true;
1279 for (;;)
1281 struct block *b1 = (struct block *) exp1;
1282 struct block *b2 = (struct block *) exp2;
1284 if (b1->arg_index != b2->arg_index)
1285 break;
1287 len1 = canonicalize_text (p1, b1->text, b1->text_len, &quote1);
1288 len2 = canonicalize_text (p2, b2->text, b2->text_len, &quote2);
1289 if (len1 != len2 || memcmp (p1, p2, len1))
1290 break;
1291 if (b1->arg_index == 0)
1293 mismatch = false;
1294 break;
1296 exp1 += BLOCK_LEN (b1->text_len);
1297 exp2 += BLOCK_LEN (b2->text_len);
1300 else
1302 len1 = canonicalize_text (p1, macro1->exp.text, macro1->count, &quote1);
1303 len2 = canonicalize_text (p2, macro2->exp.text, macro2->count, &quote2);
1304 mismatch = (len1 != len2 || memcmp (p1, p2, len1));
1307 free (p1);
1308 return mismatch;