2 Copyright (C) 1986, 87, 89, 92-99, 2000 Free Software Foundation, Inc.
3 Contributed by Per Bothner, 1994-95.
4 Based on CCCP program by Paul Rubin, June 1986
5 Adapted to ANSI C, Richard Stallman, Jan 1987
7 This program is free software; you can redistribute it and/or modify it
8 under the terms of the GNU General Public License as published by the
9 Free Software Foundation; either version 2, or (at your option) any
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
28 #define SKIP_WHITE_SPACE(p) do { while (is_hspace(*p)) p++; } while (0)
30 #define PEEKN(N) (CPP_BUFFER (pfile)->rlimit - CPP_BUFFER (pfile)->cur >= (N) ? CPP_BUFFER (pfile)->cur[N] : EOF)
31 #define FORWARD(N) CPP_FORWARD (CPP_BUFFER (pfile), (N))
32 #define GETC() CPP_BUF_GET (CPP_BUFFER (pfile))
33 #define PEEKC() CPP_BUF_PEEK (CPP_BUFFER (pfile))
34 /* CPP_IS_MACRO_BUFFER is true if the buffer contains macro expansion.
35 (Note that it is false while we're expanding macro *arguments*.) */
36 #define CPP_IS_MACRO_BUFFER(PBUF) ((PBUF)->data != NULL)
38 /* Forward declarations. */
40 static const char *my_strerror
PARAMS ((int));
41 static void validate_else
PARAMS ((cpp_reader
*, const char *));
42 static HOST_WIDEST_INT eval_if_expression
PARAMS ((cpp_reader
*));
44 static void conditional_skip
PARAMS ((cpp_reader
*, int,
45 enum node_type
, U_CHAR
*));
46 static void skip_if_group
PARAMS ((cpp_reader
*));
48 static void parse_name
PARAMS ((cpp_reader
*, int));
49 static void parse_string
PARAMS ((cpp_reader
*, int));
50 static int parse_assertion
PARAMS ((cpp_reader
*));
51 static const char *if_directive_name
PARAMS ((cpp_reader
*,
54 /* External declarations. */
56 extern HOST_WIDEST_INT cpp_parse_expr
PARAMS ((cpp_reader
*));
58 /* `struct directive' defines one #-directive, including how to handle it. */
61 int length
; /* Length of name */
62 int (*func
) /* Function to handle directive */
63 PARAMS ((cpp_reader
*, const struct directive
*));
64 const char *name
; /* Name of directive */
65 enum node_type type
; /* Code which describes which directive. */
68 /* These functions are declared to return int instead of void since they
69 are going to be placed in a table and some old compilers have trouble with
70 pointers to functions returning void. */
72 static int do_define
PARAMS ((cpp_reader
*, const struct directive
*));
73 static int do_line
PARAMS ((cpp_reader
*, const struct directive
*));
74 static int do_include
PARAMS ((cpp_reader
*, const struct directive
*));
75 static int do_undef
PARAMS ((cpp_reader
*, const struct directive
*));
76 static int do_error
PARAMS ((cpp_reader
*, const struct directive
*));
77 static int do_pragma
PARAMS ((cpp_reader
*, const struct directive
*));
78 static int do_ident
PARAMS ((cpp_reader
*, const struct directive
*));
79 static int do_if
PARAMS ((cpp_reader
*, const struct directive
*));
80 static int do_xifdef
PARAMS ((cpp_reader
*, const struct directive
*));
81 static int do_else
PARAMS ((cpp_reader
*, const struct directive
*));
82 static int do_elif
PARAMS ((cpp_reader
*, const struct directive
*));
83 static int do_endif
PARAMS ((cpp_reader
*, const struct directive
*));
85 static int do_sccs
PARAMS ((cpp_reader
*, const struct directive
*));
87 static int do_assert
PARAMS ((cpp_reader
*, const struct directive
*));
88 static int do_unassert
PARAMS ((cpp_reader
*, const struct directive
*));
89 static int do_warning
PARAMS ((cpp_reader
*, const struct directive
*));
90 static enum cpp_token null_underflow
PARAMS ((cpp_reader
*));
91 static int null_cleanup
PARAMS ((cpp_buffer
*, cpp_reader
*));
92 static int skip_comment
PARAMS ((cpp_reader
*, int));
93 static int copy_comment
PARAMS ((cpp_reader
*, int));
94 static void copy_rest_of_line
PARAMS ((cpp_reader
*));
95 static int handle_directive
PARAMS ((cpp_reader
*));
96 static void pass_thru_directive
PARAMS ((const U_CHAR
*, size_t, cpp_reader
*,
97 const struct directive
*));
98 static enum cpp_token get_directive_token
PARAMS ((cpp_reader
*));
99 static int read_line_number
PARAMS ((cpp_reader
*, int *));
100 static void cpp_print_file_and_line
PARAMS ((cpp_reader
*));
101 static void v_cpp_error
PARAMS ((cpp_reader
*, const char *, va_list));
102 static void v_cpp_warning
PARAMS ((cpp_reader
*, const char *, va_list));
103 static void v_cpp_error_with_line
PARAMS ((cpp_reader
*, int, int,
104 const char *, va_list));
105 static void v_cpp_warning_with_line
PARAMS ((cpp_reader
*, int, int, const char *, va_list));
106 static U_CHAR
*detect_if_not_defined
PARAMS ((cpp_reader
*));
107 static int consider_directive_while_skipping
PARAMS ((cpp_reader
*, IF_STACK_FRAME
*));
109 /* Here is the actual list of #-directives.
110 This table is ordered by frequency of occurrence; the numbers
111 at the end are directive counts from all the source code I have
112 lying around (egcs and libc CVS as of 1999-05-18, plus grub-0.5.91,
113 linux-2.2.9, and pcmcia-cs-3.0.9). */
115 static const struct directive directive_table
[] = {
117 { 6, do_define
, "define", T_DEFINE
}, /* 270554 */
118 { 7, do_include
, "include", T_INCLUDE
}, /* 52262 */
119 { 5, do_endif
, "endif", T_ENDIF
}, /* 45855 */
120 { 5, do_xifdef
, "ifdef", T_IFDEF
}, /* 22000 */
121 { 2, do_if
, "if", T_IF
}, /* 18162 */
122 { 4, do_else
, "else", T_ELSE
}, /* 9863 */
123 { 6, do_xifdef
, "ifndef", T_IFNDEF
}, /* 9675 */
124 { 5, do_undef
, "undef", T_UNDEF
}, /* 4837 */
125 { 4, do_line
, "line", T_LINE
}, /* 2465 */
126 { 4, do_elif
, "elif", T_ELIF
}, /* 610 */
127 { 5, do_error
, "error", T_ERROR
}, /* 475 */
128 { 6, do_pragma
, "pragma", T_PRAGMA
}, /* 195 */
130 /* Extensions. All deprecated except #warning and #include_next. */
131 { 7, do_warning
, "warning", T_WARNING
}, /* 22 - GNU */
132 { 12, do_include
, "include_next", T_INCLUDE_NEXT
}, /* 19 - GNU */
133 { 5, do_ident
, "ident", T_IDENT
}, /* 11 - SVR4 */
134 { 6, do_include
, "import", T_IMPORT
}, /* 0 - ObjC */
135 { 6, do_assert
, "assert", T_ASSERT
}, /* 0 - SVR4 */
136 { 8, do_unassert
, "unassert", T_UNASSERT
}, /* 0 - SVR4 */
137 #ifdef SCCS_DIRECTIVE
138 { 4, do_sccs
, "sccs", T_SCCS
}, /* 0 - SVR2? */
140 { -1, 0, "", T_UNUSED
}
143 /* Place into PFILE a quoted string representing the string SRC.
144 Caller must reserve enough space in pfile->token_buffer. */
147 quote_string (pfile
, src
)
153 CPP_PUTC_Q (pfile
, '\"');
155 switch ((c
= *src
++))
159 CPP_PUTC_Q (pfile
, c
);
162 sprintf ((char *)CPP_PWRITTEN (pfile
), "\\%03o", c
);
163 CPP_ADJUST_WRITTEN (pfile
, 4);
169 CPP_PUTC_Q (pfile
, '\\');
170 CPP_PUTC_Q (pfile
, c
);
174 CPP_PUTC_Q (pfile
, '\"');
175 CPP_NUL_TERMINATE_Q (pfile
);
180 /* Re-allocates PFILE->token_buffer so it will hold at least N more chars. */
183 cpp_grow_buffer (pfile
, n
)
187 long old_written
= CPP_WRITTEN (pfile
);
188 pfile
->token_buffer_size
= n
+ 2 * pfile
->token_buffer_size
;
189 pfile
->token_buffer
= (U_CHAR
*)
190 xrealloc(pfile
->token_buffer
, pfile
->token_buffer_size
);
191 CPP_SET_WRITTEN (pfile
, old_written
);
194 /* Process the string STR as if it appeared as the body of a #define
195 If STR is just an identifier, define it with value 1.
196 If STR has anything after the identifier, then it should
197 be identifier=definition. */
200 cpp_define (pfile
, str
)
207 /* Copy the entire option so we can modify it. */
208 count
= strlen (str
) + 3;
209 buf
= (U_CHAR
*) alloca (count
);
210 memcpy (buf
, str
, count
- 2);
211 /* Change the first "=" in the string to a space. If there is none,
212 tack " 1" on the end. */
213 p
= (U_CHAR
*) strchr (buf
, '=');
220 strcpy (&buf
[count
-3], " 1");
222 if (cpp_push_buffer (pfile
, buf
, count
- 1) != NULL
)
224 do_define (pfile
, NULL
);
225 cpp_pop_buffer (pfile
);
229 /* Process the string STR as if it appeared as the body of a #assert. */
231 cpp_assert (pfile
, str
)
235 if (cpp_push_buffer (pfile
, str
, strlen (str
)) != NULL
)
237 do_assert (pfile
, NULL
);
238 cpp_pop_buffer (pfile
);
243 static enum cpp_token
244 null_underflow (pfile
)
245 cpp_reader
*pfile ATTRIBUTE_UNUSED
;
251 null_cleanup (pbuf
, pfile
)
252 cpp_buffer
*pbuf ATTRIBUTE_UNUSED
;
253 cpp_reader
*pfile ATTRIBUTE_UNUSED
;
258 /* Skip a C-style block comment. We know it's a comment, and point is
259 at the second character of the starter. */
261 skip_block_comment (pfile
)
268 cpp_buf_line_and_col (CPP_BUFFER (pfile
), &line
, &col
);
274 cpp_error_with_line (pfile
, line
, col
, "unterminated comment");
277 else if (c
== '\n' || c
== '\r')
278 /* \r cannot be a macro escape marker here. */
279 CPP_BUMP_LINE (pfile
);
280 else if (c
== '/' && prev_c
== '*')
282 else if (c
== '*' && prev_c
== '/'
283 && CPP_OPTIONS (pfile
)->warn_comments
)
284 cpp_warning (pfile
, "`/*' within comment");
290 /* Skip a C++/Chill line comment. We know it's a comment, and point
291 is at the second character of the initiator. */
293 skip_line_comment (pfile
)
301 /* We don't have to worry about EOF in here. */
304 /* Don't consider final '\n' to be part of comment. */
310 /* \r cannot be a macro escape marker here. */
311 CPP_BUMP_LINE (pfile
);
312 if (CPP_OPTIONS (pfile
)->warn_comments
)
313 cpp_warning (pfile
, "backslash-newline within line comment");
318 /* Skip a comment - C, C++, or Chill style. M is the first character
319 of the comment marker. If this really is a comment, skip to its
320 end and return ' '. If this is not a comment, return M (which will
324 skip_comment (pfile
, m
)
328 if (m
== '/' && PEEKC() == '*')
330 skip_block_comment (pfile
);
333 else if (m
== '/' && PEEKC() == '/')
335 if (CPP_BUFFER (pfile
)->system_header_p
)
337 /* We silently allow C++ comments in system headers, irrespective
338 of conformance mode, because lots of busted systems do that
339 and trying to clean it up in fixincludes is a nightmare. */
340 skip_line_comment (pfile
);
343 else if (CPP_OPTIONS (pfile
)->cplusplus_comments
)
345 if (CPP_OPTIONS (pfile
)->c89
346 && CPP_PEDANTIC (pfile
)
347 && ! CPP_BUFFER (pfile
)->warned_cplusplus_comments
)
350 "C++ style comments are not allowed in ISO C89");
352 "(this will be reported only once per input file)");
353 CPP_BUFFER (pfile
)->warned_cplusplus_comments
= 1;
355 skip_line_comment (pfile
);
361 else if (m
== '-' && PEEKC() == '-'
362 && CPP_OPTIONS (pfile
)->chill
)
364 skip_line_comment (pfile
);
371 /* Identical to skip_comment except that it copies the comment into the
372 token_buffer. This is used if put_out_comments. */
374 copy_comment (pfile
, m
)
378 U_CHAR
*start
= CPP_BUFFER (pfile
)->cur
; /* XXX Layering violation */
381 if (skip_comment (pfile
, m
) == m
)
385 for (limit
= CPP_BUFFER (pfile
)->cur
; start
<= limit
; start
++)
387 CPP_PUTC (pfile
, *start
);
391 /* Skip whitespace \-newline and comments. Does not macro-expand. */
394 cpp_skip_hspace (pfile
)
403 else if (is_hspace(c
))
405 if ((c
== '\f' || c
== '\v') && CPP_PEDANTIC (pfile
))
406 cpp_pedwarn (pfile
, "%s in preprocessing directive",
407 c
== '\f' ? "formfeed" : "vertical tab");
411 /* \r is a backslash-newline marker if !has_escapes, and
412 a deletable-whitespace or no-reexpansion marker otherwise. */
413 if (CPP_BUFFER (pfile
)->has_escapes
)
421 CPP_BUFFER (pfile
)->lineno
++;
423 else if (c
== '/' || c
== '-')
425 c
= skip_comment (pfile
, c
);
435 /* Read the rest of the current line.
436 The line is appended to PFILE's output buffer. */
439 copy_rest_of_line (pfile
)
450 CPP_NUL_TERMINATE (pfile
);
454 if (CPP_BUFFER (pfile
)->has_escapes
)
458 CPP_BUFFER (pfile
)->lineno
++;
463 parse_string (pfile
, c
);
466 if (PEEKC() == '*' && CPP_TRADITIONAL (pfile
))
468 CPP_PUTS (pfile
, "/**/", 4);
469 skip_comment (pfile
, c
);
472 /* else fall through */
474 c
= skip_comment (pfile
, c
);
479 if (CPP_PEDANTIC (pfile
))
480 cpp_pedwarn (pfile
, "%s in preprocessing directive",
481 c
== '\f' ? "formfeed" : "vertical tab");
489 /* FIXME: It is almost definitely a performance win to make this do
490 the scan itself. >75% of calls to copy_r_o_l are from here or
491 skip_if_group, which means the common case is to copy stuff into the
492 token_buffer only to discard it. */
494 skip_rest_of_line (pfile
)
497 long old
= CPP_WRITTEN (pfile
);
498 copy_rest_of_line (pfile
);
499 CPP_SET_WRITTEN (pfile
, old
);
502 /* Handle a possible # directive.
503 '#' has already been read. */
506 handle_directive (pfile
)
510 register const struct directive
*kt
;
513 long old_written
= CPP_WRITTEN (pfile
);
515 cpp_skip_hspace (pfile
);
518 /* # followed by a number is equivalent to #line. Do not recognize
519 this form in assembly language source files. Complain about this
520 form if we're being pedantic, but not if this is regurgitated
521 input (preprocessed or fed back in by the C++ frontend). */
522 if (c
>= '0' && c
<= '9')
524 if (CPP_OPTIONS (pfile
)->lang_asm
)
526 skip_rest_of_line (pfile
);
530 if (CPP_PEDANTIC (pfile
)
531 && ! CPP_PREPROCESSED (pfile
)
532 && ! CPP_BUFFER (pfile
)->manual_pop
)
533 cpp_pedwarn (pfile
, "`#' followed by integer");
534 do_line (pfile
, NULL
);
538 /* If we are rescanning preprocessed input, don't obey any directives
540 if (CPP_PREPROCESSED (pfile
))
543 /* Now find the directive name. */
544 CPP_PUTC (pfile
, '#');
545 parse_name (pfile
, GETC());
546 ident
= pfile
->token_buffer
+ old_written
+ 1;
547 ident_length
= CPP_PWRITTEN (pfile
) - ident
;
548 if (ident_length
== 0)
550 /* A line of just `#' becomes blank. */
558 * Decode the keyword and call the appropriate expansion
559 * routine, after moving the input pointer up to the next line.
561 for (kt
= directive_table
; ; kt
++)
565 if (kt
->length
== ident_length
566 && !strncmp (kt
->name
, ident
, ident_length
))
570 CPP_SET_WRITTEN (pfile
, old_written
);
571 (*kt
->func
) (pfile
, kt
);
576 /* Pass a directive through to the output file.
577 BUF points to the contents of the directive, as a contiguous string.
578 LEN is the length of the string pointed to by BUF.
579 KEYWORD is the keyword-table entry for the directive. */
582 pass_thru_directive (buf
, len
, pfile
, keyword
)
586 const struct directive
*keyword
;
588 register unsigned keyword_length
= keyword
->length
;
590 CPP_RESERVE (pfile
, 1 + keyword_length
+ len
);
591 CPP_PUTC_Q (pfile
, '#');
592 CPP_PUTS_Q (pfile
, keyword
->name
, keyword_length
);
593 if (len
!= 0 && buf
[0] != ' ')
594 CPP_PUTC_Q (pfile
, ' ');
595 CPP_PUTS_Q (pfile
, buf
, len
);
598 /* Check a purported macro name SYMNAME, and yield its length. */
601 check_macro_name (pfile
, symname
)
603 const U_CHAR
*symname
;
608 for (p
= symname
; is_idchar(*p
); p
++)
610 sym_length
= p
- symname
;
612 || (sym_length
== 1 && *symname
== 'L' && (*p
== '\'' || *p
== '"')))
613 cpp_error (pfile
, "invalid macro name");
614 else if (!is_idstart(*symname
)
615 || (! strncmp (symname
, "defined", 7) && sym_length
== 7)) {
616 U_CHAR
*msg
; /* what pain... */
617 msg
= (U_CHAR
*) alloca (sym_length
+ 1);
618 bcopy (symname
, msg
, sym_length
);
620 cpp_error (pfile
, "invalid macro name `%s'", msg
);
625 /* Process a #define command.
626 KEYWORD is the keyword-table entry for #define,
627 or NULL for a "predefined" macro,
628 or the keyword-table entry for #pragma in the case of a #pragma poison. */
631 do_define (pfile
, keyword
)
633 const struct directive
*keyword
;
639 U_CHAR
*macro
, *buf
, *end
;
640 enum node_type new_type
;
642 here
= CPP_WRITTEN (pfile
);
643 copy_rest_of_line (pfile
);
645 if (keyword
== NULL
|| keyword
->type
== T_DEFINE
)
650 /* Copy out the line so we can pop the token buffer. */
651 buf
= pfile
->token_buffer
+ here
;
652 end
= CPP_PWRITTEN (pfile
);
653 macro
= (U_CHAR
*) alloca (end
- buf
+ 1);
654 bcopy (buf
, macro
, end
- buf
+ 1);
655 end
= macro
+ (end
- buf
);
657 CPP_SET_WRITTEN (pfile
, here
);
659 mdef
= create_definition (macro
, end
, pfile
, keyword
== NULL
);
663 hashcode
= hashf (mdef
.symnam
, mdef
.symlen
, HASHSIZE
);
665 if ((hp
= cpp_lookup (pfile
, mdef
.symnam
, mdef
.symlen
, hashcode
)) != NULL
)
668 /* Redefining a precompiled key is ok. */
669 if (hp
->type
== T_PCSTRING
)
671 /* Redefining a poisoned identifier is even worse than `not ok'. */
672 else if (hp
->type
== T_POISON
)
674 /* Redefining a macro is ok if the definitions are the same. */
675 else if (hp
->type
== T_MACRO
)
676 ok
= ! compare_defs (pfile
, mdef
.defn
, hp
->value
.defn
);
677 /* Redefining a constant is ok with -D. */
678 else if (hp
->type
== T_CONST
|| hp
->type
== T_STDC
)
679 ok
= ! CPP_OPTIONS (pfile
)->done_initializing
;
680 /* Print the warning or error if it's not ok. */
683 if (hp
->type
== T_POISON
)
684 cpp_error (pfile
, "redefining poisoned `%.*s'",
685 mdef
.symlen
, mdef
.symnam
);
687 cpp_pedwarn (pfile
, "`%.*s' redefined", mdef
.symlen
, mdef
.symnam
);
688 if (hp
->type
== T_MACRO
&& CPP_OPTIONS (pfile
)->done_initializing
)
689 cpp_pedwarn_with_file_and_line (pfile
, hp
->value
.defn
->file
,
690 hp
->value
.defn
->line
,
691 "this is the location of the previous definition");
693 if (hp
->type
!= T_POISON
)
695 /* Replace the old definition. */
697 hp
->value
.defn
= mdef
.defn
;
701 cpp_install (pfile
, mdef
.symnam
, mdef
.symlen
, new_type
,
702 (char *) mdef
.defn
, hashcode
);
704 if (keyword
!= NULL
&& keyword
->type
== T_DEFINE
)
706 if (CPP_OPTIONS (pfile
)->debug_output
707 || CPP_OPTIONS (pfile
)->dump_macros
== dump_definitions
)
708 dump_definition (pfile
, mdef
);
709 else if (CPP_OPTIONS (pfile
)->dump_macros
== dump_names
)
710 pass_thru_directive (mdef
.symnam
, mdef
.symlen
, pfile
, keyword
);
717 /* Allocate a new cpp_buffer for PFILE, and push it on the input buffer stack.
718 If BUFFER != NULL, then use the LENGTH characters in BUFFER
719 as the new input buffer.
720 Return the new buffer, or NULL on failure. */
723 cpp_push_buffer (pfile
, buffer
, length
)
728 cpp_buffer
*buf
= CPP_BUFFER (pfile
);
730 if (++pfile
->buffer_stack_depth
== CPP_STACK_MAX
)
732 cpp_fatal (pfile
, "macro or `#include' recursion too deep");
736 new = (cpp_buffer
*) xcalloc (1, sizeof (cpp_buffer
));
738 new->if_stack
= pfile
->if_stack
;
739 new->cleanup
= null_cleanup
;
740 new->underflow
= null_underflow
;
741 new->buf
= new->cur
= buffer
;
742 new->alimit
= new->rlimit
= buffer
+ length
;
746 CPP_BUFFER (pfile
) = new;
751 cpp_pop_buffer (pfile
)
754 cpp_buffer
*buf
= CPP_BUFFER (pfile
);
755 (*buf
->cleanup
) (buf
, pfile
);
756 CPP_BUFFER (pfile
) = CPP_PREV_BUFFER (buf
);
758 pfile
->buffer_stack_depth
--;
759 return CPP_BUFFER (pfile
);
762 /* Scan until CPP_BUFFER (PFILE) is exhausted into PFILE->token_buffer.
763 Pop the buffer when done. */
766 cpp_scan_buffer (pfile
)
769 cpp_buffer
*buffer
= CPP_BUFFER (pfile
);
770 enum cpp_token token
;
771 if (CPP_OPTIONS (pfile
)->no_output
)
773 long old_written
= CPP_WRITTEN (pfile
);
774 /* In no-output mode, we can ignore everything but directives. */
777 if (! pfile
->only_seen_white
)
778 skip_rest_of_line (pfile
);
779 token
= cpp_get_token (pfile
);
780 if (token
== CPP_EOF
) /* Should not happen ... */
782 if (token
== CPP_POP
&& CPP_BUFFER (pfile
) == buffer
)
784 if (CPP_PREV_BUFFER (CPP_BUFFER (pfile
))
785 != CPP_NULL_BUFFER (pfile
))
786 cpp_pop_buffer (pfile
);
790 CPP_SET_WRITTEN (pfile
, old_written
);
796 token
= cpp_get_token (pfile
);
797 if (token
== CPP_EOF
) /* Should not happen ... */
799 if (token
== CPP_POP
&& CPP_BUFFER (pfile
) == buffer
)
801 if (CPP_PREV_BUFFER (CPP_BUFFER (pfile
))
802 != CPP_NULL_BUFFER (pfile
))
803 cpp_pop_buffer (pfile
);
811 * Rescan a string (which may have escape marks) into pfile's buffer.
812 * Place the result in pfile->token_buffer.
814 * The input is copied before it is scanned, so it is safe to pass
815 * it something from the token_buffer that will get overwritten
816 * (because it follows CPP_WRITTEN). This is used by do_include.
820 cpp_expand_to_buffer (pfile
, buf
, length
)
825 register cpp_buffer
*ip
;
831 cpp_fatal (pfile
, "internal error: length < 0 in cpp_expand_to_buffer");
835 /* Set up the input on the input stack. */
837 buf1
= (U_CHAR
*) alloca (length
+ 1);
838 memcpy (buf1
, buf
, length
);
841 ip
= cpp_push_buffer (pfile
, buf1
, length
);
846 /* Scan the input, create the output. */
847 save_no_output
= CPP_OPTIONS (pfile
)->no_output
;
848 CPP_OPTIONS (pfile
)->no_output
= 0;
849 cpp_scan_buffer (pfile
);
850 CPP_OPTIONS (pfile
)->no_output
= save_no_output
;
852 CPP_NUL_TERMINATE (pfile
);
856 cpp_buf_line_and_col (pbuf
, linep
, colp
)
857 register cpp_buffer
*pbuf
;
862 *linep
= pbuf
->lineno
;
864 *colp
= pbuf
->cur
- pbuf
->line_base
;
874 /* Return the cpp_buffer that corresponds to a file (not a macro). */
877 cpp_file_buffer (pfile
)
880 cpp_buffer
*ip
= CPP_BUFFER (pfile
);
882 for ( ; ip
!= CPP_NULL_BUFFER (pfile
); ip
= CPP_PREV_BUFFER (ip
))
883 if (ip
->fname
!= NULL
)
889 * write out a #line command, for instance, after an #include file.
890 * FILE_CHANGE says whether we are entering a file, leaving, or neither.
894 output_line_command (pfile
, file_change
)
896 enum file_change_code file_change
;
899 cpp_buffer
*ip
= CPP_BUFFER (pfile
);
901 if (ip
->fname
== NULL
)
904 if (CPP_OPTIONS (pfile
)->no_line_commands
905 || CPP_OPTIONS (pfile
)->no_output
)
908 cpp_buf_line_and_col (CPP_BUFFER (pfile
), &line
, NULL
);
910 /* If the current file has not changed, we omit the #line if it would
911 appear to be a no-op, and we output a few newlines instead
912 if we want to increase the line number by a small amount.
913 We cannot do this if pfile->lineno is zero, because that means we
914 haven't output any line commands yet. (The very first line command
915 output is a `same_file' command.) */
916 if (file_change
== same_file
&& pfile
->lineno
!= 0)
918 if (line
== pfile
->lineno
)
921 /* If the inherited line number is a little too small,
922 output some newlines instead of a #line command. */
923 if (line
> pfile
->lineno
&& line
< pfile
->lineno
+ 8)
925 CPP_RESERVE (pfile
, 20);
926 while (line
> pfile
->lineno
)
928 CPP_PUTC_Q (pfile
, '\n');
935 CPP_RESERVE (pfile
, 4 * strlen (ip
->nominal_fname
) + 50);
936 CPP_PUTS_Q (pfile
, "# ", 2);
938 sprintf ((char *) CPP_PWRITTEN (pfile
), "%ld ", line
);
939 CPP_ADJUST_WRITTEN (pfile
, strlen (CPP_PWRITTEN (pfile
)));
941 quote_string (pfile
, ip
->nominal_fname
);
942 if (file_change
!= same_file
)
944 CPP_PUTC_Q (pfile
, ' ');
945 CPP_PUTC_Q (pfile
, file_change
== enter_file
? '1' : '2');
947 /* Tell cc1 if following text comes from a system header file. */
948 if (ip
->system_header_p
)
950 CPP_PUTC_Q (pfile
, ' ');
951 CPP_PUTC_Q (pfile
, '3');
953 #ifndef NO_IMPLICIT_EXTERN_C
954 /* Tell cc1plus if following text should be treated as C. */
955 if (ip
->system_header_p
== 2 && CPP_OPTIONS (pfile
)->cplusplus
)
957 CPP_PUTC_Q (pfile
, ' ');
958 CPP_PUTC_Q (pfile
, '4');
961 CPP_PUTC_Q (pfile
, '\n');
962 pfile
->lineno
= line
;
966 /* Like cpp_get_token, except that it does not read past end-of-line.
967 Also, horizontal space is skipped, and macros are popped. */
969 static enum cpp_token
970 get_directive_token (pfile
)
975 long old_written
= CPP_WRITTEN (pfile
);
976 enum cpp_token token
;
977 cpp_skip_hspace (pfile
);
978 if (PEEKC () == '\n')
980 token
= cpp_get_token (pfile
);
984 if (! CPP_IS_MACRO_BUFFER (CPP_BUFFER (pfile
)))
986 /* ... else fall though ... */
987 case CPP_HSPACE
: case CPP_COMMENT
:
988 CPP_SET_WRITTEN (pfile
, old_written
);
996 /* Handle #include and #import.
997 This function expects to see "fname" or <fname> on the input.
999 The input is normally in part of the output_buffer following
1000 CPP_WRITTEN, and will get overwritten by output_line_command.
1001 I.e. in input file specification has been popped by handle_directive.
1005 do_include (pfile
, keyword
)
1007 const struct directive
*keyword
;
1009 int importing
= (keyword
->type
== T_IMPORT
);
1010 int skip_dirs
= (keyword
->type
== T_INCLUDE_NEXT
);
1011 int angle_brackets
= 0; /* 0 for "...", 1 for <...> */
1012 int before
; /* included before? */
1014 unsigned char *ftok
;
1017 enum cpp_token token
;
1019 /* Chain of dirs to search */
1020 struct include_hash
*ihash
;
1021 struct file_name_list
*search_start
;
1023 long old_written
= CPP_WRITTEN (pfile
);
1027 if (CPP_PEDANTIC (pfile
) && !CPP_BUFFER (pfile
)->system_header_p
)
1030 cpp_pedwarn (pfile
, "ANSI C does not allow `#import'");
1032 cpp_pedwarn (pfile
, "ANSI C does not allow `#include_next'");
1035 if (importing
&& CPP_OPTIONS (pfile
)->warn_import
1036 && !CPP_OPTIONS (pfile
)->inhibit_warnings
1037 && !CPP_BUFFER (pfile
)->system_header_p
&& !pfile
->import_warning
)
1039 pfile
->import_warning
= 1;
1041 "#import is obsolete, use an #ifndef wrapper in the header file");
1044 pfile
->parsing_include_directive
++;
1045 token
= get_directive_token (pfile
);
1046 pfile
->parsing_include_directive
--;
1048 if (token
== CPP_STRING
)
1050 if (pfile
->token_buffer
[old_written
] == '<')
1054 else if (token
== CPP_NAME
)
1056 /* Support '#include xyz' like VAX-C. It is taken as
1057 '#include <xyz.h>' and generates a warning. */
1059 "`#include filename' is obsolete, use `#include <filename.h>'");
1062 /* Append the missing `.h' to the name. */
1063 CPP_PUTS (pfile
, ".h", 2);
1069 "`#%s' expects \"FILENAME\" or <FILENAME>", keyword
->name
);
1070 CPP_SET_WRITTEN (pfile
, old_written
);
1071 skip_rest_of_line (pfile
);
1075 flen
= CPP_WRITTEN (pfile
) - old_written
;
1076 ftok
= (unsigned char *) alloca (flen
+ 1);
1077 memcpy (ftok
, pfile
->token_buffer
+ old_written
, flen
);
1080 if (get_directive_token (pfile
) != CPP_VSPACE
)
1082 cpp_error (pfile
, "junk at end of `#include'");
1083 skip_rest_of_line (pfile
);
1086 CPP_SET_WRITTEN (pfile
, old_written
);
1090 cpp_error (pfile
, "empty file name in `#%s'", keyword
->name
);
1094 if (CPP_OPTIONS (pfile
)->dump_includes
)
1095 pass_thru_directive (ftok
,
1098 - ((token
== CPP_NAME
) ? 2 : 0)
1103 if (token
== CPP_STRING
)
1113 for (fp
= CPP_BUFFER (pfile
);
1114 fp
!= CPP_NULL_BUFFER (pfile
);
1115 fp
= CPP_PREV_BUFFER (fp
))
1116 if (fp
->fname
!= NULL
)
1119 if (fp
== CPP_NULL_BUFFER (pfile
))
1121 cpp_fatal (pfile
, "cpp internal error: fp == NULL_BUFFER in do_include");
1125 /* For #include_next, skip in the search path past the dir in which the
1126 containing file was found. Treat files specified using an absolute path
1127 as if there are no more directories to search. Treat the primary source
1128 file like any other included source, but generate a warning. */
1129 if (skip_dirs
&& CPP_PREV_BUFFER(fp
) != CPP_NULL_BUFFER (pfile
))
1131 if (fp
->ihash
->foundhere
!= ABSOLUTE_PATH
)
1132 search_start
= fp
->ihash
->foundhere
->next
;
1137 cpp_warning (pfile
, "#include_next in primary source file");
1140 search_start
= CPP_OPTIONS (pfile
)->bracket_include
;
1143 if (!CPP_OPTIONS (pfile
)->ignore_srcdir
)
1146 search_start
= fp
->actual_dir
;
1149 search_start
= CPP_OPTIONS (pfile
)->quote_include
;
1155 cpp_error (pfile
, "No include path in which to find %s", ftok
);
1159 fd
= find_include_file (pfile
, ftok
, search_start
, &ihash
, &before
);
1166 if (CPP_OPTIONS (pfile
)->print_deps_missing_files
1167 && CPP_PRINT_DEPS (pfile
) > (angle_brackets
||
1168 (pfile
->system_include_depth
> 0)))
1170 if (!angle_brackets
)
1171 deps_output (pfile
, ftok
, ' ');
1175 struct file_name_list
*ptr
;
1176 /* If requested as a system header, assume it belongs in
1177 the first system header directory. */
1178 if (CPP_OPTIONS (pfile
)->bracket_include
)
1179 ptr
= CPP_OPTIONS (pfile
)->bracket_include
;
1181 ptr
= CPP_OPTIONS (pfile
)->quote_include
;
1183 p
= (char *) alloca (strlen (ptr
->name
)
1184 + strlen (ftok
) + 2);
1185 if (*ptr
->name
!= '\0')
1187 strcpy (p
, ptr
->name
);
1191 deps_output (pfile
, p
, ' ');
1194 /* If -M was specified, and this header file won't be added to
1195 the dependency list, then don't count this as an error,
1196 because we can still produce correct output. Otherwise, we
1197 can't produce correct output, because there may be
1198 dependencies we need inside the missing file, and we don't
1199 know what directory this missing file exists in. */
1200 else if (CPP_PRINT_DEPS (pfile
)
1201 && (CPP_PRINT_DEPS (pfile
)
1202 <= (angle_brackets
|| (pfile
->system_include_depth
> 0))))
1203 cpp_warning (pfile
, "No include path in which to find %s", ftok
);
1205 cpp_error_from_errno (pfile
, ftok
);
1210 /* For -M, add the file to the dependencies on its first inclusion. */
1211 if (!before
&& (CPP_PRINT_DEPS (pfile
)
1212 > (angle_brackets
|| (pfile
->system_include_depth
> 0))))
1213 deps_output (pfile
, ihash
->name
, ' ');
1215 /* Handle -H option. */
1216 if (CPP_OPTIONS(pfile
)->print_include_names
)
1218 fp
= CPP_BUFFER (pfile
);
1219 while ((fp
= CPP_PREV_BUFFER (fp
)) != CPP_NULL_BUFFER (pfile
))
1221 fprintf (stderr
, " %s\n", ihash
->name
);
1224 /* Actually process the file */
1227 ihash
->control_macro
= "";
1229 if (cpp_push_buffer (pfile
, NULL
, 0) == NULL
)
1236 pfile
->system_include_depth
++; /* Decremented in file_cleanup. */
1238 if (finclude (pfile
, fd
, ihash
))
1240 output_line_command (pfile
, enter_file
);
1241 pfile
->only_seen_white
= 2;
1247 /* Subroutine of do_line. Read next token from PFILE without adding it to
1248 the output buffer. If it is a number between 1 and 4, store it in *NUM
1249 and return 1; otherwise, return 0 and complain if we aren't at the end
1250 of the directive. */
1253 read_line_number (pfile
, num
)
1257 long save_written
= CPP_WRITTEN (pfile
);
1258 U_CHAR
*p
= pfile
->token_buffer
+ save_written
;
1259 enum cpp_token token
= get_directive_token (pfile
);
1260 CPP_SET_WRITTEN (pfile
, save_written
);
1262 if (token
== CPP_NUMBER
&& *p
>= '1' && *p
<= '4' && p
[1] == '\0')
1269 if (token
!= CPP_VSPACE
&& token
!= CPP_EOF
&& token
!= CPP_POP
)
1270 cpp_error (pfile
, "invalid format `#line' command");
1275 /* Interpret #line command.
1276 Note that the filename string (if any) is treated as if it were an
1277 include filename. That means no escape handling. */
1280 do_line (pfile
, keyword
)
1282 const struct directive
*keyword ATTRIBUTE_UNUSED
;
1284 cpp_buffer
*ip
= CPP_BUFFER (pfile
);
1286 long old_written
= CPP_WRITTEN (pfile
);
1287 enum file_change_code file_change
= same_file
;
1288 enum cpp_token token
;
1291 token
= get_directive_token (pfile
);
1293 if (token
!= CPP_NUMBER
)
1295 cpp_error (pfile
, "token after `#line' is not an integer");
1296 goto bad_line_directive
;
1299 new_lineno
= strtol (pfile
->token_buffer
+ old_written
, &x
, 10);
1302 cpp_error (pfile
, "token after `#line' is not an integer");
1303 goto bad_line_directive
;
1305 CPP_SET_WRITTEN (pfile
, old_written
);
1307 if (CPP_PEDANTIC (pfile
) && new_lineno
<= 0)
1308 cpp_pedwarn (pfile
, "line number out of range in `#line' command");
1310 token
= get_directive_token (pfile
);
1312 if (token
== CPP_STRING
)
1314 U_CHAR
*fname
= pfile
->token_buffer
+ old_written
+ 1;
1315 U_CHAR
*end_name
= CPP_PWRITTEN (pfile
) - 1;
1316 int action_number
= 0;
1318 if (read_line_number (pfile
, &action_number
))
1320 if (CPP_PEDANTIC (pfile
))
1321 cpp_pedwarn (pfile
, "garbage at end of `#line' command");
1323 if (action_number
== 1)
1325 file_change
= enter_file
;
1326 read_line_number (pfile
, &action_number
);
1328 else if (action_number
== 2)
1330 file_change
= leave_file
;
1331 read_line_number (pfile
, &action_number
);
1333 if (action_number
== 3)
1335 ip
->system_header_p
= 1;
1336 read_line_number (pfile
, &action_number
);
1338 if (action_number
== 4)
1340 ip
->system_header_p
= 2;
1341 read_line_number (pfile
, &action_number
);
1347 if (strcmp (fname
, ip
->nominal_fname
))
1349 const char *newname
, *oldname
;
1350 if (!strcmp (fname
, ip
->fname
))
1351 newname
= ip
->fname
;
1352 else if (ip
->last_nominal_fname
1353 && !strcmp (fname
, ip
->last_nominal_fname
))
1354 newname
= ip
->last_nominal_fname
;
1356 newname
= xstrdup (fname
);
1358 oldname
= ip
->nominal_fname
;
1359 ip
->nominal_fname
= newname
;
1361 if (ip
->last_nominal_fname
1362 && ip
->last_nominal_fname
!= oldname
1363 && ip
->last_nominal_fname
!= newname
1364 && ip
->last_nominal_fname
!= ip
->fname
)
1365 free ((void *) ip
->last_nominal_fname
);
1367 if (newname
== ip
->fname
)
1368 ip
->last_nominal_fname
= NULL
;
1370 ip
->last_nominal_fname
= oldname
;
1373 else if (token
!= CPP_VSPACE
&& token
!= CPP_EOF
)
1375 cpp_error (pfile
, "token after `#line %d' is not a string", new_lineno
);
1376 goto bad_line_directive
;
1379 /* The Newline at the end of this line remains to be processed.
1380 To put the next line at the specified line number,
1381 we must store a line number now that is one less. */
1382 ip
->lineno
= new_lineno
- 1;
1383 CPP_SET_WRITTEN (pfile
, old_written
);
1384 output_line_command (pfile
, file_change
);
1388 skip_rest_of_line (pfile
);
1389 CPP_SET_WRITTEN (pfile
, old_written
);
1393 /* Remove the definition of a symbol from the symbol table.
1394 According to the C standard, it is not an error to undef
1395 something that has no definitions. */
1397 do_undef (pfile
, keyword
)
1399 const struct directive
*keyword
;
1403 U_CHAR
*buf
, *name
, *limit
;
1405 long here
= CPP_WRITTEN (pfile
);
1406 enum cpp_token token
;
1408 cpp_skip_hspace (pfile
);
1410 if (! is_idstart(c
))
1412 cpp_error (pfile
, "token after #undef is not an identifier");
1413 skip_rest_of_line (pfile
);
1417 parse_name (pfile
, c
);
1418 buf
= pfile
->token_buffer
+ here
;
1419 limit
= CPP_PWRITTEN(pfile
);
1421 /* Copy out the token so we can pop the token buffer. */
1422 name
= (U_CHAR
*) alloca (limit
- buf
+ 1);
1423 bcopy(buf
, name
, limit
- buf
);
1424 name
[limit
- buf
] = '\0';
1426 token
= get_directive_token (pfile
);
1427 if (token
!= CPP_VSPACE
&& token
!= CPP_POP
)
1429 cpp_pedwarn (pfile
, "junk on line after #undef");
1430 skip_rest_of_line (pfile
);
1433 CPP_SET_WRITTEN (pfile
, here
);
1435 sym_length
= check_macro_name (pfile
, buf
);
1437 while ((hp
= cpp_lookup (pfile
, name
, sym_length
, -1)) != NULL
)
1439 /* If we are generating additional info for debugging (with -g) we
1440 need to pass through all effective #undef commands. */
1441 if (CPP_OPTIONS (pfile
)->debug_output
&& keyword
)
1442 pass_thru_directive (name
, sym_length
, pfile
, keyword
);
1443 if (hp
->type
== T_POISON
)
1444 cpp_error (pfile
, "cannot undefine poisoned `%s'", hp
->name
);
1447 if (hp
->type
!= T_MACRO
)
1448 cpp_warning (pfile
, "undefining `%s'", hp
->name
);
1456 /* Wrap do_undef for -U processing. */
1458 cpp_undef (pfile
, macro
)
1462 if (cpp_push_buffer (pfile
, macro
, strlen (macro
)))
1464 do_undef (pfile
, NULL
);
1465 cpp_pop_buffer (pfile
);
1471 * Report an error detected by the program we are processing.
1472 * Use the text of the line in the error message.
1473 * (We use error because it prints the filename & line#.)
1477 do_error (pfile
, keyword
)
1479 const struct directive
*keyword ATTRIBUTE_UNUSED
;
1481 long here
= CPP_WRITTEN (pfile
);
1483 copy_rest_of_line (pfile
);
1484 text
= pfile
->token_buffer
+ here
;
1485 SKIP_WHITE_SPACE(text
);
1487 cpp_error (pfile
, "#error %s", text
);
1488 CPP_SET_WRITTEN (pfile
, here
);
1493 * Report a warning detected by the program we are processing.
1494 * Use the text of the line in the warning message, then continue.
1498 do_warning (pfile
, keyword
)
1500 const struct directive
*keyword ATTRIBUTE_UNUSED
;
1503 long here
= CPP_WRITTEN(pfile
);
1504 copy_rest_of_line (pfile
);
1505 text
= pfile
->token_buffer
+ here
;
1506 SKIP_WHITE_SPACE(text
);
1508 if (CPP_PEDANTIC (pfile
) && !CPP_BUFFER (pfile
)->system_header_p
)
1509 cpp_pedwarn (pfile
, "ANSI C does not allow `#warning'");
1511 /* Use `pedwarn' not `warning', because #warning isn't in the C Standard;
1512 if -pedantic-errors is given, #warning should cause an error. */
1513 cpp_pedwarn (pfile
, "#warning %s", text
);
1514 CPP_SET_WRITTEN (pfile
, here
);
1518 /* Report program identification.
1519 This is not precisely what cccp does with #ident, however I believe
1520 it matches `closely enough' (behavior is identical as long as there
1521 are no macros on the #ident line, which is pathological in my opinion). */
1524 do_ident (pfile
, keyword
)
1526 const struct directive
*keyword ATTRIBUTE_UNUSED
;
1528 /* Allow #ident in system headers, since that's not user's fault. */
1529 if (CPP_PEDANTIC (pfile
) && !CPP_BUFFER (pfile
)->system_header_p
)
1530 cpp_pedwarn (pfile
, "ANSI C does not allow `#ident'");
1532 CPP_PUTS (pfile
, "#ident ", 7);
1533 cpp_skip_hspace (pfile
);
1534 copy_rest_of_line (pfile
);
1539 /* Just check for some recognized pragmas that need validation here,
1540 and leave the text in the token buffer to be output. */
1543 do_pragma (pfile
, keyword
)
1545 const struct directive
*keyword ATTRIBUTE_UNUSED
;
1550 CPP_PUTS (pfile
, "#pragma ", 8);
1551 cpp_skip_hspace (pfile
);
1553 here
= CPP_WRITTEN (pfile
);
1554 copy_rest_of_line (pfile
);
1555 buf
= pfile
->token_buffer
+ here
;
1557 if (!strncmp (buf
, "once", 4))
1559 cpp_buffer
*ip
= NULL
;
1561 /* Allow #pragma once in system headers, since that's not the user's
1563 if (!CPP_BUFFER (pfile
)->system_header_p
)
1564 cpp_warning (pfile
, "`#pragma once' is obsolete");
1566 for (ip
= CPP_BUFFER (pfile
); ; ip
= CPP_PREV_BUFFER (ip
))
1568 if (ip
== CPP_NULL_BUFFER (pfile
))
1570 if (ip
->fname
!= NULL
)
1574 if (CPP_PREV_BUFFER (ip
) == CPP_NULL_BUFFER (pfile
))
1575 cpp_warning (pfile
, "`#pragma once' outside include file");
1577 ip
->ihash
->control_macro
= ""; /* never repeat */
1579 else if (!strncmp (buf
, "implementation", 14))
1581 /* Be quiet about `#pragma implementation' for a file only if it hasn't
1582 been included yet. */
1583 struct include_hash
*ptr
;
1584 U_CHAR
*p
= buf
+ 14, *fname
, *fcopy
;
1585 SKIP_WHITE_SPACE (p
);
1586 if (*p
== '\n' || *p
!= '\"')
1590 p
= (U_CHAR
*) index (fname
, '\"');
1592 fcopy
= (U_CHAR
*) alloca (p
- fname
+ 1);
1593 bcopy (fname
, fcopy
, p
- fname
);
1594 fcopy
[p
-fname
] = '\0';
1596 ptr
= include_hash (pfile
, fcopy
, 0);
1599 "`#pragma implementation' for `%s' appears after file is included",
1602 else if (!strncmp (buf
, "poison", 6))
1604 /* Poison these symbols so that all subsequent usage produces an
1606 U_CHAR
*p
= buf
+ 6;
1611 SKIP_WHITE_SPACE (p
);
1612 plen
= strlen(p
) + 1;
1614 syms
= (U_CHAR
*) alloca (plen
);
1615 memcpy (syms
, p
, plen
);
1617 /* As a rule, don't include #pragma poison commands in output,
1618 unless the user asks for them. */
1619 writeit
= (CPP_OPTIONS (pfile
)->debug_output
1620 || CPP_OPTIONS (pfile
)->dump_macros
== dump_definitions
1621 || CPP_OPTIONS (pfile
)->dump_macros
== dump_names
);
1624 CPP_SET_WRITTEN (pfile
, here
);
1626 CPP_SET_WRITTEN (pfile
, here
-8);
1630 CPP_RESERVE (pfile
, plen
+ 7);
1631 CPP_PUTS_Q (pfile
, "poison", 7);
1634 while (*syms
!= '\0')
1638 while (is_idchar(*end
))
1641 if (!is_hspace(*end
) && *end
!= '\0')
1643 cpp_error (pfile
, "invalid #pragma poison directive");
1647 if (cpp_push_buffer (pfile
, syms
, end
- syms
) != NULL
)
1649 do_define (pfile
, keyword
);
1650 cpp_pop_buffer (pfile
);
1654 CPP_PUTC_Q (pfile
, ' ');
1655 CPP_PUTS_Q (pfile
, syms
, end
- syms
);
1658 SKIP_WHITE_SPACE (syms
);
1665 #ifdef SCCS_DIRECTIVE
1666 /* Just ignore #sccs, on systems where we define it at all. */
1669 do_sccs (pfile
, keyword
)
1671 const struct directive
*keyword ATTRIBUTE_UNUSED
;
1673 if (CPP_PEDANTIC (pfile
))
1674 cpp_pedwarn (pfile
, "ANSI C does not allow `#sccs'");
1675 skip_rest_of_line (pfile
);
1681 /* We've found an `#if' directive. If the only thing before it in
1682 this file is white space, and if it is of the form
1683 `#if ! defined SYMBOL', then SYMBOL is a possible controlling macro
1684 for inclusion of this file. (See redundant_include_p in cppfiles.c
1685 for an explanation of controlling macros.) If so, return a
1686 malloc'd copy of SYMBOL. Otherwise, return NULL. */
1689 detect_if_not_defined (pfile
)
1692 U_CHAR
*control_macro
= 0;
1694 if (pfile
->only_seen_white
== 2)
1697 enum cpp_token token
;
1700 int need_rparen
= 0;
1702 /* Save state required for restore. */
1703 pfile
->no_macro_expand
++;
1704 parse_set_mark (pfile
);
1705 base_offset
= CPP_WRITTEN (pfile
);
1708 if (get_directive_token (pfile
) != CPP_OTHER
1709 || CPP_WRITTEN (pfile
) != (size_t) base_offset
+ 1
1710 || CPP_PWRITTEN (pfile
)[-1] != '!')
1713 /* ...then `defined', */
1714 token_offset
= CPP_WRITTEN (pfile
);
1715 token
= get_directive_token (pfile
);
1716 if (token
!= CPP_NAME
)
1718 ident
= pfile
->token_buffer
+ token_offset
;
1719 CPP_NUL_TERMINATE (pfile
);
1720 if (strcmp (ident
, "defined"))
1723 /* ...then an optional '(' and the name, */
1724 token_offset
= CPP_WRITTEN (pfile
);
1725 token
= get_directive_token (pfile
);
1726 if (token
== CPP_LPAREN
)
1728 token_offset
= CPP_WRITTEN (pfile
);
1729 token
= get_directive_token (pfile
);
1730 if (token
!= CPP_NAME
)
1734 else if (token
!= CPP_NAME
)
1737 ident
= pfile
->token_buffer
+ token_offset
;
1738 CPP_NUL_TERMINATE (pfile
);
1740 /* ...then the ')', if necessary, */
1741 if ((!need_rparen
|| get_directive_token (pfile
) == CPP_RPAREN
)
1742 /* ...and make sure there's nothing else on the line. */
1743 && get_directive_token (pfile
) == CPP_VSPACE
)
1744 control_macro
= xstrdup (ident
);
1747 CPP_SET_WRITTEN (pfile
, base_offset
);
1748 pfile
->no_macro_expand
--;
1749 parse_goto_mark (pfile
);
1752 return control_macro
;
1756 * handle #if command by
1757 * 1) inserting special `defined' keyword into the hash table
1758 * that gets turned into 0 or 1 by special_symbol (thus,
1759 * if the luser has a symbol called `defined' already, it won't
1760 * work inside the #if command)
1761 * 2) rescan the input into a temporary output buffer
1762 * 3) pass the output buffer to the yacc parser and collect a value
1763 * 4) clean up the mess left from steps 1 and 2.
1764 * 5) call conditional_skip to skip til the next #endif (etc.),
1765 * or not, depending on the value from step 3.
1769 do_if (pfile
, keyword
)
1771 const struct directive
*keyword ATTRIBUTE_UNUSED
;
1773 U_CHAR
*control_macro
= detect_if_not_defined (pfile
);
1774 HOST_WIDEST_INT value
= eval_if_expression (pfile
);
1775 conditional_skip (pfile
, value
== 0, T_IF
, control_macro
);
1780 * handle a #elif directive by not changing if_stack either.
1781 * see the comment above do_else.
1785 do_elif (pfile
, keyword
)
1787 const struct directive
*keyword ATTRIBUTE_UNUSED
;
1789 if (pfile
->if_stack
== CPP_BUFFER (pfile
)->if_stack
) {
1790 cpp_error (pfile
, "`#elif' not within a conditional");
1793 if (pfile
->if_stack
->type
!= T_IF
&& pfile
->if_stack
->type
!= T_ELIF
) {
1794 cpp_error (pfile
, "`#elif' after `#else'");
1796 fprintf (stderr
, " (matches line %d", pfile
->if_stack
->lineno
);
1798 if (pfile
->if_stack
->fname
!= NULL
&& CPP_BUFFER (pfile
)->fname
!= NULL
1799 && strcmp (pfile
->if_stack
->fname
,
1800 CPP_BUFFER (pfile
)->nominal_fname
) != 0)
1801 fprintf (stderr
, ", file %s", pfile
->if_stack
->fname
);
1802 fprintf (stderr
, ")\n");
1804 pfile
->if_stack
->type
= T_ELIF
;
1807 if (pfile
->if_stack
->if_succeeded
)
1808 skip_if_group (pfile
);
1810 HOST_WIDEST_INT value
= eval_if_expression (pfile
);
1812 skip_if_group (pfile
);
1814 ++pfile
->if_stack
->if_succeeded
; /* continue processing input */
1815 output_line_command (pfile
, same_file
);
1822 * evaluate a #if expression in BUF, of length LENGTH,
1823 * then parse the result as a C expression and return the value as an int.
1826 static HOST_WIDEST_INT
1827 eval_if_expression (pfile
)
1830 HOST_WIDEST_INT value
;
1831 long old_written
= CPP_WRITTEN (pfile
);
1833 pfile
->pcp_inside_if
= 1;
1834 value
= cpp_parse_expr (pfile
);
1835 pfile
->pcp_inside_if
= 0;
1837 CPP_SET_WRITTEN (pfile
, old_written
); /* Pop */
1843 * routine to handle ifdef/ifndef. Try to look up the symbol,
1844 * then do or don't skip to the #endif/#else/#elif depending
1845 * on what directive is actually being processed.
1849 do_xifdef (pfile
, keyword
)
1851 const struct directive
*keyword
;
1854 cpp_buffer
*ip
= CPP_BUFFER (pfile
);
1857 enum cpp_token token
;
1858 int start_of_file
= 0;
1859 U_CHAR
*control_macro
= 0;
1860 int old_written
= CPP_WRITTEN (pfile
);
1862 /* Detect a #ifndef at start of file (not counting comments). */
1863 if (ip
->fname
!= 0 && keyword
->type
== T_IFNDEF
)
1864 start_of_file
= pfile
->only_seen_white
== 2;
1866 pfile
->no_macro_expand
++;
1867 token
= get_directive_token (pfile
);
1868 pfile
->no_macro_expand
--;
1870 ident
= pfile
->token_buffer
+ old_written
;
1871 ident_length
= CPP_WRITTEN (pfile
) - old_written
;
1872 CPP_SET_WRITTEN (pfile
, old_written
); /* Pop */
1874 if (token
== CPP_VSPACE
|| token
== CPP_POP
|| token
== CPP_EOF
)
1876 skip
= (keyword
->type
== T_IFDEF
);
1877 if (! CPP_TRADITIONAL (pfile
))
1878 cpp_pedwarn (pfile
, "`#%s' with no argument", keyword
->name
);
1880 else if (token
== CPP_NAME
)
1882 HASHNODE
*hp
= cpp_lookup (pfile
, ident
, ident_length
, -1);
1883 skip
= (hp
== NULL
) ^ (keyword
->type
== T_IFNDEF
);
1884 if (start_of_file
&& !skip
)
1886 control_macro
= (U_CHAR
*) xmalloc (ident_length
+ 1);
1887 bcopy (ident
, control_macro
, ident_length
+ 1);
1889 if (hp
!= NULL
&& hp
->type
== T_POISON
)
1891 cpp_error (pfile
, "attempt to use poisoned `%s'", hp
->name
);
1897 skip
= (keyword
->type
== T_IFDEF
);
1898 if (! CPP_TRADITIONAL (pfile
))
1899 cpp_error (pfile
, "`#%s' with invalid argument", keyword
->name
);
1902 if (!CPP_TRADITIONAL (pfile
))
1904 cpp_skip_hspace (pfile
);
1906 if (c
!= EOF
&& c
!= '\n')
1907 cpp_pedwarn (pfile
, "garbage at end of `#%s' argument", keyword
->name
);
1909 skip_rest_of_line (pfile
);
1913 /* Output a precondition for this macro. */
1914 if (hp
&& hp
->value
.defn
->predefined
)
1915 fprintf (pcp_outfile
, "#define %s\n", hp
->name
);
1918 fprintf (pcp_outfile
, "#undef ");
1919 while (is_idchar(*cp
)) /* Ick! */
1920 fputc (*cp
++, pcp_outfile
);
1921 putc ('\n', pcp_outfile
);
1925 conditional_skip (pfile
, skip
, T_IF
, control_macro
);
1929 /* Push TYPE on stack; then, if SKIP is nonzero, skip ahead.
1930 If this is a #ifndef starting at the beginning of a file,
1931 CONTROL_MACRO is the macro name tested by the #ifndef.
1932 Otherwise, CONTROL_MACRO is 0. */
1935 conditional_skip (pfile
, skip
, type
, control_macro
)
1938 enum node_type type
;
1939 U_CHAR
*control_macro
;
1941 IF_STACK_FRAME
*temp
;
1943 temp
= (IF_STACK_FRAME
*) xcalloc (1, sizeof (IF_STACK_FRAME
));
1944 temp
->fname
= CPP_BUFFER (pfile
)->nominal_fname
;
1945 temp
->lineno
= CPP_BUFFER (pfile
)->lineno
;
1946 temp
->next
= pfile
->if_stack
;
1947 temp
->control_macro
= control_macro
;
1948 pfile
->if_stack
= temp
;
1950 pfile
->if_stack
->type
= type
;
1953 skip_if_group (pfile
);
1956 ++pfile
->if_stack
->if_succeeded
;
1957 output_line_command (pfile
, same_file
);
1961 /* Subroutine of skip_if_group. Examine one preprocessing directive and
1962 return 0 if skipping should continue, 1 if it should halt. Also
1963 adjusts the if_stack as appropriate.
1964 The `#' has been read, but not the identifier. */
1967 consider_directive_while_skipping (pfile
, stack
)
1969 IF_STACK_FRAME
*stack
;
1971 long ident_len
, ident
;
1972 const struct directive
*kt
;
1973 IF_STACK_FRAME
*temp
;
1975 cpp_skip_hspace (pfile
);
1977 ident
= CPP_WRITTEN (pfile
);
1978 parse_name (pfile
, GETC());
1979 ident_len
= CPP_WRITTEN (pfile
) - ident
;
1981 CPP_SET_WRITTEN (pfile
, ident
);
1983 for (kt
= directive_table
; kt
->length
>= 0; kt
++)
1984 if (kt
->length
== ident_len
1985 && strncmp (pfile
->token_buffer
+ ident
, kt
->name
, kt
->length
) == 0)
1991 temp
= (IF_STACK_FRAME
*) xmalloc (sizeof (IF_STACK_FRAME
));
1992 temp
->next
= pfile
->if_stack
;
1993 pfile
->if_stack
= temp
;
1994 temp
->fname
= CPP_BUFFER(pfile
)->nominal_fname
;
1995 temp
->type
= kt
->type
;
1999 if (pfile
->if_stack
!= stack
)
2000 validate_else (pfile
, "#else");
2003 if (pfile
->if_stack
->type
== T_ELSE
)
2004 cpp_error (pfile
, "`%s' after `#else'", kt
->name
);
2006 if (pfile
->if_stack
== stack
)
2010 pfile
->if_stack
->type
= kt
->type
;
2015 if (pfile
->if_stack
!= stack
)
2016 validate_else (pfile
, "#endif");
2018 if (pfile
->if_stack
== stack
)
2021 temp
= pfile
->if_stack
;
2022 pfile
->if_stack
= temp
->next
;
2030 /* Don't let erroneous code go by. */
2031 if (!CPP_OPTIONS (pfile
)->lang_asm
&& CPP_PEDANTIC (pfile
))
2032 cpp_pedwarn (pfile
, "invalid preprocessor directive name");
2036 /* skip to #endif, #else, or #elif. adjust line numbers, etc.
2037 * leaves input ptr at the sharp sign found.
2040 skip_if_group (pfile
)
2044 IF_STACK_FRAME
*save_if_stack
= pfile
->if_stack
; /* don't pop past here */
2045 U_CHAR
*beg_of_line
;
2048 if (CPP_OPTIONS (pfile
)->output_conditionals
)
2050 CPP_PUTS (pfile
, "#failed\n", 8);
2052 output_line_command (pfile
, same_file
);
2055 old_written
= CPP_WRITTEN (pfile
);
2059 beg_of_line
= CPP_BUFFER (pfile
)->cur
;
2061 if (! CPP_TRADITIONAL (pfile
))
2062 cpp_skip_hspace (pfile
);
2066 if (CPP_OPTIONS (pfile
)->output_conditionals
)
2067 CPP_PUTC (pfile
, c
);
2068 CPP_BUMP_LINE (pfile
);
2073 if (consider_directive_while_skipping (pfile
, save_if_stack
))
2077 return; /* Caller will issue error. */
2080 if (CPP_OPTIONS (pfile
)->output_conditionals
)
2082 CPP_PUTS (pfile
, beg_of_line
, CPP_BUFFER (pfile
)->cur
- beg_of_line
);
2083 copy_rest_of_line (pfile
);
2087 copy_rest_of_line (pfile
);
2088 CPP_SET_WRITTEN (pfile
, old_written
); /* discard it */
2093 return; /* Caller will issue error. */
2097 if (CPP_OPTIONS (pfile
)->output_conditionals
)
2099 CPP_PUTC (pfile
, c
);
2102 CPP_BUMP_LINE (pfile
);
2106 /* Back up to the beginning of this line. Caller will process the
2108 CPP_BUFFER (pfile
)->cur
= beg_of_line
;
2109 pfile
->only_seen_white
= 1;
2110 if (CPP_OPTIONS (pfile
)->output_conditionals
)
2112 CPP_PUTS (pfile
, "#endfailed\n", 11);
2118 * handle a #else directive. Do this by just continuing processing
2119 * without changing if_stack ; this is so that the error message
2120 * for missing #endif's etc. will point to the original #if. It
2121 * is possible that something different would be better.
2125 do_else (pfile
, keyword
)
2127 const struct directive
*keyword ATTRIBUTE_UNUSED
;
2129 cpp_buffer
*ip
= CPP_BUFFER (pfile
);
2131 validate_else (pfile
, "#else");
2132 skip_rest_of_line (pfile
);
2134 if (pfile
->if_stack
== CPP_BUFFER (pfile
)->if_stack
) {
2135 cpp_error (pfile
, "`#else' not within a conditional");
2138 /* #ifndef can't have its special treatment for containing the whole file
2139 if it has a #else clause. */
2140 pfile
->if_stack
->control_macro
= 0;
2142 if (pfile
->if_stack
->type
!= T_IF
&& pfile
->if_stack
->type
!= T_ELIF
) {
2143 cpp_error (pfile
, "`#else' after `#else'");
2144 fprintf (stderr
, " (matches line %d", pfile
->if_stack
->lineno
);
2145 if (strcmp (pfile
->if_stack
->fname
, ip
->nominal_fname
) != 0)
2146 fprintf (stderr
, ", file %s", pfile
->if_stack
->fname
);
2147 fprintf (stderr
, ")\n");
2149 pfile
->if_stack
->type
= T_ELSE
;
2152 if (pfile
->if_stack
->if_succeeded
)
2153 skip_if_group (pfile
);
2155 ++pfile
->if_stack
->if_succeeded
; /* continue processing input */
2156 output_line_command (pfile
, same_file
);
2162 * unstack after #endif command
2166 do_endif (pfile
, keyword
)
2168 const struct directive
*keyword ATTRIBUTE_UNUSED
;
2170 validate_else (pfile
, "#endif");
2171 skip_rest_of_line (pfile
);
2173 if (pfile
->if_stack
== CPP_BUFFER (pfile
)->if_stack
)
2174 cpp_error (pfile
, "`#endif' not within a conditional");
2177 IF_STACK_FRAME
*temp
= pfile
->if_stack
;
2178 pfile
->if_stack
= temp
->next
;
2179 if (temp
->control_macro
!= 0)
2181 /* This #endif matched a #ifndef at the start of the file.
2182 See if it is at the end of the file. */
2185 parse_set_mark (pfile
);
2189 cpp_skip_hspace (pfile
);
2194 parse_goto_mark (pfile
);
2198 /* This #endif ends a #ifndef
2199 that contains all of the file (aside from whitespace).
2200 Arrange not to include the file again
2201 if the macro that was tested is defined. */
2202 struct cpp_buffer
*ip
;
2203 for (ip
= CPP_BUFFER (pfile
); ; ip
= CPP_PREV_BUFFER (ip
))
2204 if (ip
->fname
!= NULL
)
2206 ip
->ihash
->control_macro
= (char *) temp
->control_macro
;
2210 output_line_command (pfile
, same_file
);
2215 /* Issue -pedantic warning for text which is not a comment following
2216 an #else or #endif. Do not warn in system headers, as this is harmless
2217 and very common on old systems. */
2220 validate_else (pfile
, directive
)
2222 const char *directive
;
2224 if (! CPP_PEDANTIC (pfile
) || CPP_BUFFER (pfile
)->system_header_p
)
2227 cpp_skip_hspace (pfile
);
2228 if (PEEKC () != '\n')
2230 "text following `%s' violates ANSI standard", directive
);
2233 /* Convert T_IF, etc. to a string. Used in error messages. */
2235 if_directive_name (pfile
, ifs
)
2237 struct if_stack
*ifs
;
2241 case T_IF
: return "#if";
2242 case T_IFDEF
: return "#ifdef";
2243 case T_IFNDEF
: return "#ifndef";
2244 case T_ELIF
: return "#elif";
2245 case T_ELSE
: return "#else";
2247 cpp_fatal (pfile
, "impossible if_stack->type value %d", ifs
->type
);
2252 /* Get the next token, and add it to the text in pfile->token_buffer.
2253 Return the kind of token we got. */
2256 cpp_get_token (pfile
)
2259 register int c
, c2
, c3
;
2260 enum cpp_token token
;
2261 struct cpp_options
*opts
= CPP_OPTIONS (pfile
);
2267 if (CPP_BUFFER (pfile
)->manual_pop
)
2268 /* If we've been reading from redirected input, the
2269 frontend will pop the buffer. */
2271 else if (CPP_BUFFER (pfile
)->seen_eof
)
2273 if (CPP_PREV_BUFFER (CPP_BUFFER (pfile
)) == CPP_NULL_BUFFER (pfile
))
2276 cpp_pop_buffer (pfile
);
2281 cpp_buffer
*next_buf
= CPP_PREV_BUFFER (CPP_BUFFER (pfile
));
2282 struct if_stack
*ifs
, *nifs
;
2284 /* Unwind the conditional stack and generate error messages. */
2285 for (ifs
= pfile
->if_stack
;
2286 ifs
!= CPP_BUFFER (pfile
)->if_stack
;
2289 cpp_error_with_line (pfile
, ifs
->lineno
, -1,
2290 "unterminated `%s' conditional",
2291 if_directive_name (pfile
, ifs
));
2296 pfile
->if_stack
= ifs
;
2298 if (CPP_BUFFER (pfile
)->nominal_fname
2299 && next_buf
!= CPP_NULL_BUFFER (pfile
))
2301 /* We're about to return from an #include file.
2302 Emit #line information now (as part of the CPP_POP) result.
2303 But the #line refers to the file we will pop to. */
2304 cpp_buffer
*cur_buffer
= CPP_BUFFER (pfile
);
2305 CPP_BUFFER (pfile
) = next_buf
;
2306 pfile
->input_stack_listing_current
= 0;
2307 output_line_command (pfile
, leave_file
);
2308 CPP_BUFFER (pfile
) = cur_buffer
;
2311 CPP_BUFFER (pfile
)->seen_eof
= 1;
2320 if (PEEKC () == '=')
2324 if (opts
->put_out_comments
)
2325 c
= copy_comment (pfile
, c
);
2327 c
= skip_comment (pfile
, c
);
2331 /* Comments are equivalent to spaces.
2332 For -traditional, a comment is equivalent to nothing. */
2333 if (opts
->traditional
|| opts
->put_out_comments
)
2337 CPP_PUTC (pfile
, c
);
2341 if (opts
->for_lint
) {
2344 char *lintcmd
= get_lintcmd (ibp
, limit
, &argbp
, &arglen
, &cmdlen
);
2346 if (lintcmd
!= NULL
) {
2347 /* I believe it is always safe to emit this newline: */
2349 bcopy ("#pragma lint ", (char *) obp
, 13);
2351 bcopy (lintcmd
, (char *) obp
, cmdlen
);
2356 bcopy (argbp
, (char *) obp
, arglen
);
2360 /* OK, now bring us back to the state we were in before we entered
2361 this branch. We need #line because the newline for the pragma
2362 could mess things up. */
2363 output_line_command (pfile
, same_file
);
2364 *(obp
++) = ' '; /* just in case, if comments are copied thru */
2372 /* If this is expanding a macro definition, don't recognize
2373 preprocessor directives. */
2376 /* If this is expand_into_temp_buffer, recognize them
2377 only after an actual newline at this level,
2378 not at the beginning of the input level. */
2379 if (ip
->fname
== 0 && beg_of_line
== ip
->buf
)
2385 if (!pfile
->only_seen_white
)
2387 /* -traditional directives are recognized only with the # in
2389 XXX Layering violation. */
2390 if (CPP_TRADITIONAL (pfile
)
2391 && CPP_BUFFER (pfile
)->cur
- CPP_BUFFER (pfile
)->line_base
!= 1)
2393 if (handle_directive (pfile
))
2394 return CPP_DIRECTIVE
;
2395 pfile
->only_seen_white
= 0;
2401 parse_string (pfile
, c
);
2402 pfile
->only_seen_white
= 0;
2403 return c
== '\'' ? CPP_CHAR
: CPP_STRING
;
2406 if (!opts
->dollars_in_ident
)
2411 if (opts
->cplusplus
&& PEEKC () == ':')
2419 if (c2
== c
|| c2
== '=')
2428 if (PEEKC () == '=')
2434 if (c2
== '-' && opts
->chill
)
2435 goto comment
; /* Chill style comment */
2436 if (c2
== '-' || c2
== '=')
2440 if (opts
->cplusplus
&& PEEKN (1) == '*')
2442 /* In C++, there's a ->* operator. */
2444 pfile
->only_seen_white
= 0;
2445 CPP_RESERVE (pfile
, 4);
2446 CPP_PUTC_Q (pfile
, c
);
2447 CPP_PUTC_Q (pfile
, GETC ());
2448 CPP_PUTC_Q (pfile
, GETC ());
2449 CPP_NUL_TERMINATE_Q (pfile
);
2457 if (pfile
->parsing_include_directive
)
2461 CPP_PUTC (pfile
, c
);
2465 if (c
== '\n' || c
== EOF
)
2468 "missing '>' in `#include <FILENAME>'");
2473 if (!CPP_BUFFER (pfile
)->has_escapes
)
2475 /* Backslash newline is replaced by nothing. */
2476 CPP_ADJUST_WRITTEN (pfile
, -1);
2477 CPP_BUMP_LINE (pfile
);
2481 /* We might conceivably get \r- or \r<space> in
2482 here. Just delete 'em. */
2484 if (d
!= '-' && d
!= ' ')
2486 "internal error: unrecognized escape \\r%c",
2488 CPP_ADJUST_WRITTEN (pfile
, -1);
2494 /* else fall through */
2499 /* GNU C++ supports MIN and MAX operators <? and >?. */
2500 if (c2
!= c
&& (!opts
->cplusplus
|| c2
!= '?'))
2503 CPP_RESERVE (pfile
, 4);
2504 CPP_PUTC (pfile
, c
);
2505 CPP_PUTC (pfile
, c2
);
2508 CPP_PUTC_Q (pfile
, GETC ());
2509 CPP_NUL_TERMINATE_Q (pfile
);
2510 pfile
->only_seen_white
= 0;
2517 CPP_RESERVE(pfile
, 2);
2518 CPP_PUTC_Q (pfile
, '.');
2523 /* In C++ there's a .* operator. */
2524 if (opts
->cplusplus
&& c2
== '*')
2527 if (c2
== '.' && PEEKN(1) == '.')
2529 CPP_RESERVE(pfile
, 4);
2530 CPP_PUTC_Q (pfile
, '.');
2531 CPP_PUTC_Q (pfile
, '.');
2532 CPP_PUTC_Q (pfile
, '.');
2534 CPP_NUL_TERMINATE_Q (pfile
);
2535 pfile
->only_seen_white
= 0;
2542 pfile
->only_seen_white
= 0;
2543 CPP_RESERVE(pfile
, 3);
2544 CPP_PUTC_Q (pfile
, c
);
2545 CPP_PUTC_Q (pfile
, GETC ());
2546 CPP_NUL_TERMINATE_Q (pfile
);
2551 if ((c2
== '\'' || c2
== '\"') && !CPP_TRADITIONAL (pfile
))
2553 CPP_PUTC (pfile
, c
);
2559 case '0': case '1': case '2': case '3': case '4':
2560 case '5': case '6': case '7': case '8': case '9':
2565 CPP_RESERVE (pfile
, 2);
2566 CPP_PUTC_Q (pfile
, c
);
2570 if (!is_idchar(c
) && c
!= '.'
2571 && ((c2
!= 'e' && c2
!= 'E'
2572 && ((c2
!= 'p' && c2
!= 'P') || CPP_C89 (pfile
)))
2573 || (c
!= '+' && c
!= '-')))
2578 CPP_NUL_TERMINATE_Q (pfile
);
2579 pfile
->only_seen_white
= 0;
2581 case 'b': case 'c': case 'd': case 'h': case 'o':
2582 case 'B': case 'C': case 'D': case 'H': case 'O':
2583 if (opts
->chill
&& PEEKC () == '\'')
2585 pfile
->only_seen_white
= 0;
2586 CPP_RESERVE (pfile
, 2);
2587 CPP_PUTC_Q (pfile
, c
);
2588 CPP_PUTC_Q (pfile
, '\'');
2594 goto chill_number_eof
;
2597 CPP_PUTC (pfile
, c
);
2601 CPP_RESERVE (pfile
, 2);
2602 CPP_PUTC_Q (pfile
, c
);
2603 CPP_NUL_TERMINATE_Q (pfile
);
2610 CPP_NUL_TERMINATE (pfile
);
2617 case 'a': case 'e': case 'f': case 'g': case 'i': case 'j':
2618 case 'k': case 'l': case 'm': case 'n': case 'p': case 'q':
2619 case 'r': case 's': case 't': case 'u': case 'v': case 'w':
2620 case 'x': case 'y': case 'z':
2621 case 'A': case 'E': case 'F': case 'G': case 'I': case 'J':
2622 case 'K': case 'M': case 'N': case 'P': case 'Q': case 'R':
2623 case 'S': case 'T': case 'U': case 'V': case 'W': case 'X':
2628 unsigned char *ident
;
2629 int before_name_written
= CPP_WRITTEN (pfile
);
2631 parse_name (pfile
, c
);
2632 pfile
->only_seen_white
= 0;
2633 if (pfile
->no_macro_expand
)
2635 ident
= pfile
->token_buffer
+ before_name_written
;
2636 ident_len
= CPP_PWRITTEN (pfile
) - ident
;
2637 hp
= cpp_lookup (pfile
, ident
, ident_len
, -1);
2640 if (hp
->type
== T_DISABLED
)
2642 if (pfile
->output_escapes
)
2643 { /* Return "\r-IDENT", followed by '\0'. */
2645 CPP_RESERVE (pfile
, 3);
2646 ident
= pfile
->token_buffer
+ before_name_written
;
2647 CPP_ADJUST_WRITTEN (pfile
, 2);
2648 for (i
= ident_len
; i
>= 0; i
--) ident
[i
+2] = ident
[i
];
2655 /* If macro wants an arglist, verify that a '(' follows.
2656 first skip all whitespace, copying it to the output
2657 after the macro name. Then, if there is no '(',
2658 decide this is not a macro call and leave things that way. */
2659 if (hp
->type
== T_MACRO
&& hp
->value
.defn
->nargs
>= 0)
2661 int is_macro_call
, macbuf_whitespace
= 0;
2663 parse_set_mark (pfile
);
2666 cpp_skip_hspace (pfile
);
2668 is_macro_call
= c
== '(';
2677 if (CPP_IS_MACRO_BUFFER (CPP_BUFFER (pfile
)))
2679 if (CPP_BUFFER (pfile
)->mark
!=
2680 (CPP_BUFFER (pfile
)->cur
2681 - CPP_BUFFER (pfile
)->buf
))
2682 macbuf_whitespace
= 1;
2684 /* The mark goes away automatically when
2685 the buffer is popped. */
2686 cpp_pop_buffer (pfile
);
2687 parse_set_mark (pfile
);
2695 parse_goto_mark (pfile
);
2696 if (macbuf_whitespace
)
2697 CPP_PUTC (pfile
, ' ');
2700 parse_clear_mark (pfile
);
2704 /* This is now known to be a macro call.
2705 Expand the macro, reading arguments as needed,
2706 and push the expansion on the input stack. */
2707 macroexpand (pfile
, hp
);
2708 CPP_SET_WRITTEN (pfile
, before_name_written
);
2712 case ' ': case '\t': case '\v':
2715 CPP_PUTC (pfile
, c
);
2717 if (c
== EOF
|| !is_hspace(c
))
2724 if (CPP_BUFFER (pfile
)->has_escapes
)
2729 if (pfile
->output_escapes
)
2730 CPP_PUTS (pfile
, "\r-", 2);
2731 parse_name (pfile
, GETC ());
2736 CPP_RESERVE (pfile
, 2);
2737 if (pfile
->output_escapes
)
2738 CPP_PUTC_Q (pfile
, '\r');
2739 CPP_PUTC_Q (pfile
, c
);
2745 "internal error: unrecognized escape \\r%c", c
);
2751 /* Backslash newline is ignored. */
2752 CPP_BUMP_LINE (pfile
);
2757 CPP_PUTC (pfile
, c
);
2758 if (pfile
->only_seen_white
== 0)
2759 pfile
->only_seen_white
= 1;
2760 CPP_BUMP_LINE (pfile
);
2761 if (! CPP_OPTIONS (pfile
)->no_line_commands
)
2764 if (CPP_BUFFER (pfile
)->lineno
!= pfile
->lineno
)
2765 output_line_command (pfile
, same_file
);
2769 case '(': token
= CPP_LPAREN
; goto char1
;
2770 case ')': token
= CPP_RPAREN
; goto char1
;
2771 case '{': token
= CPP_LBRACE
; goto char1
;
2772 case '}': token
= CPP_RBRACE
; goto char1
;
2773 case ',': token
= CPP_COMMA
; goto char1
;
2774 case ';': token
= CPP_SEMICOLON
; goto char1
;
2780 pfile
->only_seen_white
= 0;
2781 CPP_PUTC (pfile
, c
);
2787 /* Like cpp_get_token, but skip spaces and comments. */
2790 cpp_get_non_space_token (pfile
)
2793 int old_written
= CPP_WRITTEN (pfile
);
2796 enum cpp_token token
= cpp_get_token (pfile
);
2797 if (token
!= CPP_COMMENT
&& token
!= CPP_POP
2798 && token
!= CPP_HSPACE
&& token
!= CPP_VSPACE
)
2800 CPP_SET_WRITTEN (pfile
, old_written
);
2804 /* Parse an identifier starting with C. */
2807 parse_name (pfile
, c
)
2819 if (c
== '$' && CPP_PEDANTIC (pfile
))
2820 cpp_pedwarn (pfile
, "`$' in identifier");
2822 CPP_RESERVE(pfile
, 2); /* One more for final NUL. */
2823 CPP_PUTC_Q (pfile
, c
);
2828 CPP_NUL_TERMINATE_Q (pfile
);
2832 /* Parse a string starting with C. A single quoted string is treated
2833 like a double -- some programs (e.g., troff) are perverse this way.
2834 (However, a single quoted string is not allowed to extend over
2837 parse_string (pfile
, c
)
2841 long start_line
, start_column
;
2843 cpp_buf_line_and_col (cpp_file_buffer (pfile
), &start_line
, &start_column
);
2845 CPP_PUTC (pfile
, c
);
2851 if (CPP_IS_MACRO_BUFFER (CPP_BUFFER (pfile
)))
2853 /* try harder: this string crosses a macro expansion
2854 boundary. This can happen naturally if -traditional.
2855 Otherwise, only -D can make a macro with an unmatched
2857 cpp_pop_buffer (pfile
);
2861 cpp_error_with_line (pfile
, start_line
, start_column
,
2862 "unterminated string or character constant");
2863 if (pfile
->multiline_string_line
!= start_line
2864 && pfile
->multiline_string_line
!= 0)
2865 cpp_error_with_line (pfile
,
2866 pfile
->multiline_string_line
, -1,
2867 "possible real start of unterminated constant");
2868 pfile
->multiline_string_line
= 0;
2871 CPP_PUTC (pfile
, cc
);
2875 CPP_BUMP_LINE (pfile
);
2878 /* In Fortran and assembly language, silently terminate
2879 strings of either variety at end of line. This is a
2880 kludge around not knowing where comments are in these
2882 if (CPP_OPTIONS (pfile
)->lang_fortran
2883 || CPP_OPTIONS (pfile
)->lang_asm
)
2885 /* Character constants may not extend over multiple lines.
2886 In Standard C, neither may strings. We accept multiline
2887 strings as an extension. */
2890 cpp_error_with_line (pfile
, start_line
, start_column
,
2891 "unterminated character constant");
2894 if (CPP_PEDANTIC (pfile
) && pfile
->multiline_string_line
== 0)
2895 cpp_pedwarn_with_line (pfile
, start_line
, start_column
,
2896 "string constant runs past end of line");
2897 if (pfile
->multiline_string_line
== 0)
2898 pfile
->multiline_string_line
= start_line
;
2902 CPP_ADJUST_WRITTEN (pfile
, -1);
2903 if (CPP_BUFFER (pfile
)->has_escapes
)
2906 "internal error: \\r escape inside string constant");
2910 /* Backslash newline is replaced by nothing at all. */
2911 CPP_BUMP_LINE (pfile
);
2917 CPP_PUTC (pfile
, cc
);
2929 /* Read an assertion into the token buffer, converting to
2930 canonical form: `#predicate(a n swe r)' The next non-whitespace
2931 character to read should be the first letter of the predicate.
2932 Returns 0 for syntax error, 1 for bare predicate, 2 for predicate
2933 with answer (see callers for why). In case of 0, an error has been
2936 parse_assertion (pfile
)
2940 cpp_skip_hspace (pfile
);
2942 if (! is_idstart(c
))
2944 cpp_error (pfile
, "assertion predicate is not an identifier");
2947 CPP_PUTC(pfile
, '#');
2949 parse_name(pfile
, c
);
2954 if (is_hspace(c
) || c
== '\r')
2955 cpp_skip_hspace (pfile
);
2961 CPP_PUTC(pfile
, '(');
2964 while ((c
= GETC()) != ')')
2970 CPP_PUTC(pfile
, ' ');
2974 else if (c
== '\n' || c
== EOF
)
2976 if (c
== '\n') FORWARD(-1);
2977 cpp_error (pfile
, "un-terminated assertion answer");
2981 /* \r cannot be a macro escape here. */
2982 CPP_BUMP_LINE (pfile
);
2985 CPP_PUTC (pfile
, c
);
2990 if (pfile
->limit
[-1] == ' ')
2991 pfile
->limit
[-1] = ')';
2992 else if (pfile
->limit
[-1] == '(')
2994 cpp_error (pfile
, "empty token sequence in assertion");
2998 CPP_PUTC (pfile
, ')');
3000 CPP_NUL_TERMINATE (pfile
);
3005 do_assert (pfile
, keyword
)
3007 const struct directive
*keyword ATTRIBUTE_UNUSED
;
3011 HASHNODE
*base
, *this;
3012 int baselen
, thislen
;
3014 if (CPP_PEDANTIC (pfile
) && CPP_OPTIONS (pfile
)->done_initializing
3015 && !CPP_BUFFER (pfile
)->system_header_p
)
3016 cpp_pedwarn (pfile
, "ANSI C does not allow `#assert'");
3018 cpp_skip_hspace (pfile
);
3019 sym
= (char *) CPP_PWRITTEN (pfile
); /* remember where it starts */
3020 ret
= parse_assertion (pfile
);
3025 cpp_error (pfile
, "missing token-sequence in `#assert'");
3029 cpp_skip_hspace (pfile
);
3031 if (c
!= EOF
&& c
!= '\n')
3033 cpp_error (pfile
, "junk at end of `#assert'");
3037 thislen
= strlen (sym
);
3038 baselen
= index (sym
, '(') - sym
;
3039 this = cpp_lookup (pfile
, sym
, thislen
, -1);
3042 cpp_warning (pfile
, "`%s' re-asserted", sym
);
3046 base
= cpp_lookup (pfile
, sym
, baselen
, -1);
3048 base
= cpp_install (pfile
, sym
, baselen
, T_ASSERT
, 0, -1);
3049 else if (base
->type
!= T_ASSERT
)
3051 /* Token clash - but with what?! */
3053 "cpp internal error: base->type != T_ASSERT in do_assert");
3057 this = cpp_install (pfile
, sym
, thislen
, T_ASSERT
,
3058 (char *)base
->value
.aschain
, -1);
3059 base
->value
.aschain
= this;
3061 pfile
->limit
= (unsigned char *) sym
; /* Pop */
3065 skip_rest_of_line (pfile
);
3066 pfile
->limit
= (unsigned char *) sym
; /* Pop */
3071 do_unassert (pfile
, keyword
)
3073 const struct directive
*keyword ATTRIBUTE_UNUSED
;
3077 long baselen
, thislen
;
3078 HASHNODE
*base
, *this, *next
;
3080 if (CPP_PEDANTIC (pfile
) && CPP_OPTIONS (pfile
)->done_initializing
3081 && !CPP_BUFFER (pfile
)->system_header_p
)
3082 cpp_pedwarn (pfile
, "ANSI C does not allow `#unassert'");
3084 cpp_skip_hspace (pfile
);
3086 sym
= (char *) CPP_PWRITTEN (pfile
); /* remember where it starts */
3087 ret
= parse_assertion (pfile
);
3091 cpp_skip_hspace (pfile
);
3093 if (c
!= EOF
&& c
!= '\n')
3094 cpp_error (pfile
, "junk at end of `#unassert'");
3096 thislen
= strlen (sym
);
3099 base
= cpp_lookup (pfile
, sym
, thislen
, -1);
3101 goto error
; /* It isn't an error to #undef what isn't #defined,
3102 so it isn't an error to #unassert what isn't
3103 #asserted either. */
3105 for (this = base
->value
.aschain
; this; this = next
)
3107 next
= this->value
.aschain
;
3108 delete_macro (this);
3110 delete_macro (base
);
3114 baselen
= index (sym
, '(') - sym
;
3115 base
= cpp_lookup (pfile
, sym
, baselen
, -1);
3116 if (! base
) goto error
;
3117 this = cpp_lookup (pfile
, sym
, thislen
, -1);
3118 if (! this) goto error
;
3121 while (next
->value
.aschain
!= this)
3122 next
= next
->value
.aschain
;
3124 next
->value
.aschain
= this->value
.aschain
;
3125 delete_macro (this);
3127 if (base
->value
.aschain
== NULL
)
3128 delete_macro (base
); /* Last answer for this predicate deleted. */
3131 pfile
->limit
= (unsigned char *) sym
; /* Pop */
3134 skip_rest_of_line (pfile
);
3135 pfile
->limit
= (unsigned char *) sym
; /* Pop */
3139 /* Process STR as if it appeared as the body of an #unassert. */
3141 cpp_unassert (pfile
, str
)
3145 if (cpp_push_buffer (pfile
, str
, strlen (str
)) != NULL
)
3147 do_assert (pfile
, NULL
);
3148 cpp_pop_buffer (pfile
);
3153 cpp_read_check_assertion (pfile
)
3156 U_CHAR
*name
= CPP_PWRITTEN (pfile
);
3160 FORWARD (1); /* Skip '#' */
3161 cpp_skip_hspace (pfile
);
3162 if (! parse_assertion (pfile
))
3166 hp
= cpp_lookup (pfile
, name
, CPP_PWRITTEN (pfile
) - name
, -1);
3170 pfile
->limit
= name
;
3174 /* Remember the current position of PFILE. */
3177 parse_set_mark (pfile
)
3180 cpp_buffer
*ip
= CPP_BUFFER (pfile
);
3183 "cpp internal error: ip->mark != -1 in parse_set_mark");
3185 ip
->mark
= ip
->cur
- ip
->buf
;
3188 /* Clear the current mark - we no longer need it. */
3191 parse_clear_mark (pfile
)
3194 cpp_buffer
*ip
= CPP_BUFFER (pfile
);
3197 "cpp internal error: ip->mark == -1 in parse_clear_mark");
3202 /* Backup the current position of PFILE to that saved in its mark,
3203 and clear the mark. */
3206 parse_goto_mark (pfile
)
3209 cpp_buffer
*ip
= CPP_BUFFER (pfile
);
3212 "cpp internal error: ip->mark == -1 in parse_goto_mark");
3214 ip
->cur
= ip
->buf
+ ip
->mark
;
3219 cpp_print_file_and_line (pfile
)
3222 cpp_buffer
*ip
= cpp_file_buffer (pfile
);
3227 cpp_buf_line_and_col (ip
, &line
, &col
);
3228 cpp_file_line_for_message (pfile
, ip
->nominal_fname
,
3229 line
, pfile
->show_column
? col
: -1);
3234 v_cpp_error (pfile
, msgid
, ap
)
3239 cpp_print_containing_files (pfile
);
3240 cpp_print_file_and_line (pfile
);
3241 v_cpp_message (pfile
, 1, msgid
, ap
);
3245 cpp_error
VPARAMS ((cpp_reader
* pfile
, const char *msgid
, ...))
3247 #ifndef ANSI_PROTOTYPES
3253 VA_START(ap
, msgid
);
3255 #ifndef ANSI_PROTOTYPES
3256 pfile
= va_arg (ap
, cpp_reader
*);
3257 msgid
= va_arg (ap
, const char *);
3260 v_cpp_error (pfile
, msgid
, ap
);
3264 /* Print error message but don't count it. */
3267 v_cpp_warning (pfile
, msgid
, ap
)
3272 if (CPP_OPTIONS (pfile
)->inhibit_warnings
)
3275 if (CPP_OPTIONS (pfile
)->warnings_are_errors
)
3278 cpp_print_containing_files (pfile
);
3279 cpp_print_file_and_line (pfile
);
3280 v_cpp_message (pfile
, 0, msgid
, ap
);
3284 cpp_warning
VPARAMS ((cpp_reader
* pfile
, const char *msgid
, ...))
3286 #ifndef ANSI_PROTOTYPES
3292 VA_START (ap
, msgid
);
3294 #ifndef ANSI_PROTOTYPES
3295 pfile
= va_arg (ap
, cpp_reader
*);
3296 msgid
= va_arg (ap
, const char *);
3299 v_cpp_warning (pfile
, msgid
, ap
);
3303 /* Print an error message and maybe count it. */
3306 cpp_pedwarn
VPARAMS ((cpp_reader
* pfile
, const char *msgid
, ...))
3308 #ifndef ANSI_PROTOTYPES
3314 VA_START (ap
, msgid
);
3316 #ifndef ANSI_PROTOTYPES
3317 pfile
= va_arg (ap
, cpp_reader
*);
3318 msgid
= va_arg (ap
, const char *);
3321 if (CPP_OPTIONS (pfile
)->pedantic_errors
)
3322 v_cpp_error (pfile
, msgid
, ap
);
3324 v_cpp_warning (pfile
, msgid
, ap
);
3329 v_cpp_error_with_line (pfile
, line
, column
, msgid
, ap
)
3336 cpp_buffer
*ip
= cpp_file_buffer (pfile
);
3338 cpp_print_containing_files (pfile
);
3341 cpp_file_line_for_message (pfile
, ip
->nominal_fname
, line
, column
);
3343 v_cpp_message (pfile
, 1, msgid
, ap
);
3347 cpp_error_with_line
VPARAMS ((cpp_reader
* pfile
, int line
, int column
,
3348 const char *msgid
, ...))
3350 #ifndef ANSI_PROTOTYPES
3358 VA_START (ap
, msgid
);
3360 #ifndef ANSI_PROTOTYPES
3361 pfile
= va_arg (ap
, cpp_reader
*);
3362 line
= va_arg (ap
, int);
3363 column
= va_arg (ap
, int);
3364 msgid
= va_arg (ap
, const char *);
3367 v_cpp_error_with_line(pfile
, line
, column
, msgid
, ap
);
3372 v_cpp_warning_with_line (pfile
, line
, column
, msgid
, ap
)
3381 if (CPP_OPTIONS (pfile
)->inhibit_warnings
)
3384 if (CPP_OPTIONS (pfile
)->warnings_are_errors
)
3387 cpp_print_containing_files (pfile
);
3389 ip
= cpp_file_buffer (pfile
);
3392 cpp_file_line_for_message (pfile
, ip
->nominal_fname
, line
, column
);
3394 v_cpp_message (pfile
, 0, msgid
, ap
);
3398 cpp_warning_with_line
VPARAMS ((cpp_reader
* pfile
, int line
, int column
,
3399 const char *msgid
, ...))
3401 #ifndef ANSI_PROTOTYPES
3409 VA_START (ap
, msgid
);
3411 #ifndef ANSI_PROTOTYPES
3412 pfile
= va_arg (ap
, cpp_reader
*);
3413 line
= va_arg (ap
, int);
3414 column
= va_arg (ap
, int);
3415 msgid
= va_arg (ap
, const char *);
3418 v_cpp_warning_with_line (pfile
, line
, column
, msgid
, ap
);
3423 cpp_pedwarn_with_line
VPARAMS ((cpp_reader
* pfile
, int line
, int column
,
3424 const char *msgid
, ...))
3426 #ifndef ANSI_PROTOTYPES
3434 VA_START (ap
, msgid
);
3436 #ifndef ANSI_PROTOTYPES
3437 pfile
= va_arg (ap
, cpp_reader
*);
3438 line
= va_arg (ap
, int);
3439 column
= va_arg (ap
, int);
3440 msgid
= va_arg (ap
, const char *);
3443 if (CPP_OPTIONS (pfile
)->pedantic_errors
)
3444 v_cpp_error_with_line (pfile
, column
, line
, msgid
, ap
);
3446 v_cpp_warning_with_line (pfile
, line
, column
, msgid
, ap
);
3450 /* Report a warning (or an error if pedantic_errors)
3451 giving specified file name and line number, not current. */
3454 cpp_pedwarn_with_file_and_line
VPARAMS ((cpp_reader
*pfile
, const char *file
,
3455 int line
, const char *msgid
, ...))
3457 #ifndef ANSI_PROTOTYPES
3465 VA_START (ap
, msgid
);
3467 #ifndef ANSI_PROTOTYPES
3468 pfile
= va_arg (ap
, cpp_reader
*);
3469 file
= va_arg (ap
, const char *);
3470 line
= va_arg (ap
, int);
3471 msgid
= va_arg (ap
, const char *);
3474 if (!CPP_OPTIONS (pfile
)->pedantic_errors
3475 && CPP_OPTIONS (pfile
)->inhibit_warnings
)
3477 cpp_file_line_for_message (pfile
, file
, line
, -1);
3478 v_cpp_message (pfile
, CPP_OPTIONS (pfile
)->pedantic_errors
, msgid
, ap
);
3482 /* my_strerror - return the descriptive text associated with an
3486 my_strerror (errnum
)
3492 #ifndef HAVE_STRERROR
3493 result
= (char *) ((errnum
< sys_nerr
) ? sys_errlist
[errnum
] : 0);
3495 result
= strerror (errnum
);
3498 /* VAXCRTL's strerror() takes an optional second argument, which only
3499 matters when the first argument is EVMSERR. However, it's simplest
3500 just to pass it unconditionally. `vaxc$errno' is declared in
3501 <errno.h>, and maintained by the library in parallel with `errno'.
3502 We assume that caller's `errnum' either matches the last setting of
3503 `errno' by the library or else does not have the value `EVMSERR'. */
3505 result
= strerror (errnum
, vaxc$errno
);
3509 result
= "errno = ?";
3514 /* Error including a message from `errno'. */
3517 cpp_error_from_errno (pfile
, name
)
3521 cpp_message_from_errno (pfile
, 1, name
);
3525 cpp_message_from_errno (pfile
, is_error
, name
)
3531 cpp_buffer
*ip
= cpp_file_buffer (pfile
);
3533 cpp_print_containing_files (pfile
);
3536 cpp_file_line_for_message (pfile
, ip
->nominal_fname
, ip
->lineno
, -1);
3538 cpp_message (pfile
, is_error
, "%s: %s", name
, my_strerror (e
));
3542 cpp_perror_with_name (pfile
, name
)
3546 cpp_message (pfile
, 1, "%s: %s: %s", progname
, name
, my_strerror (errno
));
3550 * No pre-compiled header file support.
3552 * Possibly different enum token codes for each C/C++ token.
3554 * Find and cleanup remaining uses of static variables,
3556 * Support -dM flag (dump_all_macros).
3558 * Support for_lint flag.