2 Copyright (C) 1986, 87, 89, 92-98, 1999 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_hor_space[*p]) p++; } while (0)
29 #define SKIP_ALL_WHITE_SPACE(p) do { while (is_space[*p]) p++; } while (0)
31 #define PEEKN(N) (CPP_BUFFER (pfile)->rlimit - CPP_BUFFER (pfile)->cur >= (N) ? CPP_BUFFER (pfile)->cur[N] : EOF)
32 #define FORWARD(N) CPP_FORWARD (CPP_BUFFER (pfile), (N))
33 #define GETC() CPP_BUF_GET (CPP_BUFFER (pfile))
34 #define PEEKC() CPP_BUF_PEEK (CPP_BUFFER (pfile))
35 /* CPP_IS_MACRO_BUFFER is true if the buffer contains macro expansion.
36 (Note that it is false while we're expanding macro *arguments*.) */
37 #define CPP_IS_MACRO_BUFFER(PBUF) ((PBUF)->data != NULL)
39 /* Forward declarations. */
41 static const char *my_strerror
PROTO ((int));
42 static void validate_else
PROTO ((cpp_reader
*, const char *));
43 static HOST_WIDEST_INT eval_if_expression
PROTO ((cpp_reader
*));
45 static void conditional_skip
PROTO ((cpp_reader
*, int,
46 enum node_type
, U_CHAR
*));
47 static void skip_if_group
PROTO ((cpp_reader
*));
49 static void parse_name
PARAMS ((cpp_reader
*, int));
50 static void parse_string
PARAMS ((cpp_reader
*, int));
51 static int parse_assertion
PARAMS ((cpp_reader
*));
53 /* External declarations. */
55 extern HOST_WIDEST_INT cpp_parse_expr
PARAMS ((cpp_reader
*));
57 /* `struct directive' defines one #-directive, including how to handle it. */
60 int length
; /* Length of name */
61 int (*func
) /* Function to handle directive */
62 PARAMS ((cpp_reader
*, const struct directive
*));
63 const char *name
; /* Name of directive */
64 enum node_type type
; /* Code which describes which directive. */
67 /* These functions are declared to return int instead of void since they
68 are going to be placed in a table and some old compilers have trouble with
69 pointers to functions returning void. */
71 static int do_define
PARAMS ((cpp_reader
*, const struct directive
*));
72 static int do_line
PARAMS ((cpp_reader
*, const struct directive
*));
73 static int do_include
PARAMS ((cpp_reader
*, const struct directive
*));
74 static int do_undef
PARAMS ((cpp_reader
*, const struct directive
*));
75 static int do_error
PARAMS ((cpp_reader
*, const struct directive
*));
76 static int do_pragma
PARAMS ((cpp_reader
*, const struct directive
*));
77 static int do_ident
PARAMS ((cpp_reader
*, const struct directive
*));
78 static int do_if
PARAMS ((cpp_reader
*, const struct directive
*));
79 static int do_xifdef
PARAMS ((cpp_reader
*, const struct directive
*));
80 static int do_else
PARAMS ((cpp_reader
*, const struct directive
*));
81 static int do_elif
PARAMS ((cpp_reader
*, const struct directive
*));
82 static int do_endif
PARAMS ((cpp_reader
*, const struct directive
*));
84 static int do_sccs
PARAMS ((cpp_reader
*, const struct directive
*));
86 static int do_assert
PARAMS ((cpp_reader
*, const struct directive
*));
87 static int do_unassert
PARAMS ((cpp_reader
*, const struct directive
*));
88 static int do_warning
PARAMS ((cpp_reader
*, const struct directive
*));
89 static enum cpp_token null_underflow
PARAMS ((cpp_reader
*));
90 static int null_cleanup
PARAMS ((cpp_buffer
*, cpp_reader
*));
91 static int skip_comment
PARAMS ((cpp_reader
*, int));
92 static int copy_comment
PARAMS ((cpp_reader
*, int));
93 static void copy_rest_of_line
PARAMS ((cpp_reader
*));
94 static int handle_directive
PARAMS ((cpp_reader
*));
95 static void pass_thru_directive
PARAMS ((const U_CHAR
*, size_t, cpp_reader
*,
96 const struct directive
*));
97 static enum cpp_token get_directive_token
PARAMS ((cpp_reader
*));
98 static int read_line_number
PARAMS ((cpp_reader
*, int *));
99 static void cpp_print_file_and_line
PARAMS ((cpp_reader
*));
100 static void v_cpp_error
PARAMS ((cpp_reader
*, const char *, va_list));
101 static void v_cpp_warning
PARAMS ((cpp_reader
*, const char *, va_list));
102 static void v_cpp_error_with_line
PARAMS ((cpp_reader
*, int, int,
103 const char *, va_list));
104 static void v_cpp_warning_with_line
PARAMS ((cpp_reader
*, int, int, const char *, va_list));
105 static U_CHAR
*detect_if_not_defined
PARAMS ((cpp_reader
*));
106 static int consider_directive_while_skipping
PARAMS ((cpp_reader
*, IF_STACK_FRAME
*));
108 /* Here is the actual list of #-directives.
109 This table is ordered by frequency of occurrence; the numbers
110 at the end are directive counts from all the source code I have
111 lying around (egcs and libc CVS as of 1999-05-18, plus grub-0.5.91,
112 linux-2.2.9, and pcmcia-cs-3.0.9). */
114 static const struct directive directive_table
[] = {
116 { 6, do_define
, "define", T_DEFINE
}, /* 270554 */
117 { 7, do_include
, "include", T_INCLUDE
}, /* 52262 */
118 { 5, do_endif
, "endif", T_ENDIF
}, /* 45855 */
119 { 5, do_xifdef
, "ifdef", T_IFDEF
}, /* 22000 */
120 { 2, do_if
, "if", T_IF
}, /* 18162 */
121 { 4, do_else
, "else", T_ELSE
}, /* 9863 */
122 { 6, do_xifdef
, "ifndef", T_IFNDEF
}, /* 9675 */
123 { 5, do_undef
, "undef", T_UNDEF
}, /* 4837 */
124 { 4, do_line
, "line", T_LINE
}, /* 2465 */
125 { 4, do_elif
, "elif", T_ELIF
}, /* 610 */
126 { 5, do_error
, "error", T_ERROR
}, /* 475 */
127 { 6, do_pragma
, "pragma", T_PRAGMA
}, /* 195 */
129 /* Extensions. All deprecated except #warning and #include_next. */
130 { 7, do_warning
, "warning", T_WARNING
}, /* 22 - GNU */
131 { 12, do_include
, "include_next", T_INCLUDE_NEXT
}, /* 19 - GNU */
132 { 5, do_ident
, "ident", T_IDENT
}, /* 11 - SVR4 */
133 { 6, do_include
, "import", T_IMPORT
}, /* 0 - ObjC */
134 { 6, do_assert
, "assert", T_ASSERT
}, /* 0 - SVR4 */
135 { 8, do_unassert
, "unassert", T_UNASSERT
}, /* 0 - SVR4 */
136 #ifdef SCCS_DIRECTIVE
137 { 4, do_sccs
, "sccs", T_SCCS
}, /* 0 - SVR2? */
139 { -1, 0, "", T_UNUSED
}
142 /* Place into PFILE a quoted string representing the string SRC.
143 Caller must reserve enough space in pfile->token_buffer. */
146 quote_string (pfile
, src
)
152 CPP_PUTC_Q (pfile
, '\"');
154 switch ((c
= *src
++))
158 CPP_PUTC_Q (pfile
, c
);
161 sprintf ((char *)CPP_PWRITTEN (pfile
), "\\%03o", c
);
162 CPP_ADJUST_WRITTEN (pfile
, 4);
168 CPP_PUTC_Q (pfile
, '\\');
169 CPP_PUTC_Q (pfile
, c
);
173 CPP_PUTC_Q (pfile
, '\"');
174 CPP_NUL_TERMINATE_Q (pfile
);
179 /* Re-allocates PFILE->token_buffer so it will hold at least N more chars. */
182 cpp_grow_buffer (pfile
, n
)
186 long old_written
= CPP_WRITTEN (pfile
);
187 pfile
->token_buffer_size
= n
+ 2 * pfile
->token_buffer_size
;
188 pfile
->token_buffer
= (U_CHAR
*)
189 xrealloc(pfile
->token_buffer
, pfile
->token_buffer_size
);
190 CPP_SET_WRITTEN (pfile
, old_written
);
193 /* Process the string STR as if it appeared as the body of a #define
194 If STR is just an identifier, define it with value 1.
195 If STR has anything after the identifier, then it should
196 be identifier=definition. */
199 cpp_define (pfile
, str
)
206 /* Copy the entire option so we can modify it. */
207 count
= strlen (str
) + 3;
208 buf
= (U_CHAR
*) alloca (count
);
209 memcpy (buf
, str
, count
- 2);
210 /* Change the first "=" in the string to a space. If there is none,
211 tack " 1" on the end. */
212 p
= (U_CHAR
*) strchr (buf
, '=');
219 strcpy (&buf
[count
-3], " 1");
221 if (cpp_push_buffer (pfile
, buf
, count
- 1) != NULL
)
223 do_define (pfile
, NULL
);
224 cpp_pop_buffer (pfile
);
228 /* Process the string STR as if it appeared as the body of a #assert. */
230 cpp_assert (pfile
, str
)
234 if (cpp_push_buffer (pfile
, str
, strlen (str
)) != NULL
)
236 do_assert (pfile
, NULL
);
237 cpp_pop_buffer (pfile
);
242 static enum cpp_token
243 null_underflow (pfile
)
244 cpp_reader
*pfile ATTRIBUTE_UNUSED
;
250 null_cleanup (pbuf
, pfile
)
251 cpp_buffer
*pbuf ATTRIBUTE_UNUSED
;
252 cpp_reader
*pfile ATTRIBUTE_UNUSED
;
257 /* Skip a comment - C, C++, or Chill style. M is the first character
258 of the comment marker. If this really is a comment, skip to its
259 end and return ' '. If we hit end-of-file before end-of-comment,
260 return EOF. If this is not a comment, return M (which will be
264 skip_comment (pfile
, m
)
268 if (m
== '/' && PEEKC() == '*')
274 cpp_buf_line_and_col (CPP_BUFFER (pfile
), &line
, &col
);
280 cpp_error_with_line (pfile
, line
, col
, "unterminated comment");
283 else if (c
== '\n' || c
== '\r')
284 /* \r cannot be a macro escape marker here. */
285 CPP_BUMP_LINE (pfile
);
286 else if (c
== '/' && prev_c
== '*')
288 else if (c
== '*' && prev_c
== '/'
289 && CPP_OPTIONS (pfile
)->warn_comments
)
290 cpp_warning (pfile
, "`/*' within comment");
295 else if ((m
== '/' && PEEKC() == '/'
296 && CPP_OPTIONS (pfile
)->cplusplus_comments
)
297 || (m
== '-' && PEEKC() == '-'
298 && CPP_OPTIONS (pfile
)->chill
))
305 return ' '; /* Allow // to be terminated by EOF. */
308 /* Don't consider final '\n' to be part of comment. */
313 /* \r cannot be a macro escape marker here. */
314 CPP_BUMP_LINE (pfile
);
321 /* Identical to skip_comment except that it copies the comment into the
322 token_buffer. This is used if put_out_comments. */
324 copy_comment (pfile
, m
)
328 if (m
== '/' && PEEKC() == '*')
333 CPP_PUTC (pfile
, '/');
334 CPP_PUTC (pfile
, '*');
336 cpp_buf_line_and_col (CPP_BUFFER (pfile
), &line
, &col
);
342 cpp_error_with_line (pfile
, line
, col
, "unterminated comment");
343 /* We must pretend this was a legitimate comment, so that the
344 output in token_buffer is not passed back tagged CPP_POP. */
349 /* \r cannot be a macro escape marker here. */
350 CPP_BUMP_LINE (pfile
);
358 CPP_BUMP_LINE (pfile
);
360 else if (c
== '/' && prev_c
== '*')
362 else if (c
== '*' && prev_c
== '/'
363 && CPP_OPTIONS (pfile
)->warn_comments
)
364 cpp_warning (pfile
, "`/*' within comment");
369 else if ((m
== '/' && PEEKC() == '/'
370 && CPP_OPTIONS (pfile
)->cplusplus_comments
)
371 || (m
== '-' && PEEKC() == '-'
372 && CPP_OPTIONS (pfile
)->chill
))
381 return ' '; /* Allow line comments to be terminated by EOF. */
384 /* Don't consider final '\n' to be part of comment. */
389 /* \r cannot be a macro escape marker here. */
390 CPP_BUMP_LINE (pfile
);
400 /* Skip whitespace \-newline and comments. Does not macro-expand. */
403 cpp_skip_hspace (pfile
)
412 else if (is_hor_space
[c
])
414 if ((c
== '\f' || c
== '\v') && CPP_PEDANTIC (pfile
))
415 cpp_pedwarn (pfile
, "%s in preprocessing directive",
416 c
== '\f' ? "formfeed" : "vertical tab");
420 /* \r is a backslash-newline marker if !has_escapes, and
421 a deletable-whitespace or no-reexpansion marker otherwise. */
422 if (CPP_BUFFER (pfile
)->has_escapes
)
430 CPP_BUFFER (pfile
)->lineno
++;
432 else if (c
== '/' || c
== '-')
434 c
= skip_comment (pfile
, c
);
446 /* Read the rest of the current line.
447 The line is appended to PFILE's output buffer. */
450 copy_rest_of_line (pfile
)
461 CPP_NUL_TERMINATE (pfile
);
465 if (CPP_BUFFER (pfile
)->has_escapes
)
469 CPP_BUFFER (pfile
)->lineno
++;
474 parse_string (pfile
, c
);
477 if (PEEKC() == '*' && CPP_TRADITIONAL (pfile
))
479 CPP_PUTS (pfile
, "/**/", 4);
480 skip_comment (pfile
, c
);
483 /* else fall through */
485 c
= skip_comment (pfile
, c
);
490 if (CPP_PEDANTIC (pfile
))
491 cpp_pedwarn (pfile
, "%s in preprocessing directive",
492 c
== '\f' ? "formfeed" : "vertical tab");
500 /* FIXME: It is almost definitely a performance win to make this do
501 the scan itself. >75% of calls to copy_r_o_l are from here or
502 skip_if_group, which means the common case is to copy stuff into the
503 token_buffer only to discard it. */
505 skip_rest_of_line (pfile
)
508 long old
= CPP_WRITTEN (pfile
);
509 copy_rest_of_line (pfile
);
510 CPP_SET_WRITTEN (pfile
, old
);
513 /* Handle a possible # directive.
514 '#' has already been read. */
517 handle_directive (pfile
)
521 register const struct directive
*kt
;
524 long old_written
= CPP_WRITTEN (pfile
);
526 cpp_skip_hspace (pfile
);
529 if (c
>= '0' && c
<= '9')
531 /* Handle # followed by a line number. */
532 if (CPP_PEDANTIC (pfile
))
533 cpp_pedwarn (pfile
, "`#' followed by integer");
534 do_line (pfile
, NULL
);
538 /* Now find the directive name. */
539 CPP_PUTC (pfile
, '#');
540 parse_name (pfile
, GETC());
541 ident
= pfile
->token_buffer
+ old_written
+ 1;
542 ident_length
= CPP_PWRITTEN (pfile
) - ident
;
543 if (ident_length
== 0)
545 /* A line of just `#' becomes blank. */
553 * Decode the keyword and call the appropriate expansion
554 * routine, after moving the input pointer up to the next line.
556 for (kt
= directive_table
; ; kt
++)
560 if (kt
->length
== ident_length
561 && !strncmp (kt
->name
, ident
, ident_length
))
565 CPP_SET_WRITTEN (pfile
, old_written
);
566 (*kt
->func
) (pfile
, kt
);
571 /* Pass a directive through to the output file.
572 BUF points to the contents of the directive, as a contiguous string.
573 LEN is the length of the string pointed to by BUF.
574 KEYWORD is the keyword-table entry for the directive. */
577 pass_thru_directive (buf
, len
, pfile
, keyword
)
581 const struct directive
*keyword
;
583 register unsigned keyword_length
= keyword
->length
;
585 CPP_RESERVE (pfile
, 1 + keyword_length
+ len
);
586 CPP_PUTC_Q (pfile
, '#');
587 CPP_PUTS_Q (pfile
, keyword
->name
, keyword_length
);
588 if (len
!= 0 && buf
[0] != ' ')
589 CPP_PUTC_Q (pfile
, ' ');
590 CPP_PUTS_Q (pfile
, buf
, len
);
593 /* Check a purported macro name SYMNAME, and yield its length.
594 ASSERTION is nonzero if this is really for an assertion name. */
597 check_macro_name (pfile
, symname
, assertion
)
599 const U_CHAR
*symname
;
605 for (p
= symname
; is_idchar
[*p
]; p
++)
607 sym_length
= p
- symname
;
609 || (sym_length
== 1 && *symname
== 'L' && (*p
== '\'' || *p
== '"')))
611 assertion
? "invalid assertion name" : "invalid macro name");
612 else if (!is_idstart
[*symname
]
613 || (! strncmp (symname
, "defined", 7) && sym_length
== 7)) {
614 U_CHAR
*msg
; /* what pain... */
615 msg
= (U_CHAR
*) alloca (sym_length
+ 1);
616 bcopy (symname
, msg
, sym_length
);
620 ? "invalid assertion name `%s'"
621 : "invalid macro name `%s'"),
627 /* Process a #define command.
628 KEYWORD is the keyword-table entry for #define,
629 or NULL for a "predefined" macro,
630 or the keyword-table entry for #pragma in the case of a #pragma poison. */
633 do_define (pfile
, keyword
)
635 const struct directive
*keyword
;
641 U_CHAR
*macro
, *buf
, *end
;
642 enum node_type new_type
;
644 here
= CPP_WRITTEN (pfile
);
645 copy_rest_of_line (pfile
);
647 if (keyword
== NULL
|| keyword
->type
== T_DEFINE
)
652 /* Copy out the line so we can pop the token buffer. */
653 buf
= pfile
->token_buffer
+ here
;
654 end
= CPP_PWRITTEN (pfile
);
655 macro
= (U_CHAR
*) alloca (end
- buf
+ 1);
656 bcopy (buf
, macro
, end
- buf
+ 1);
657 end
= macro
+ (end
- buf
);
659 CPP_SET_WRITTEN (pfile
, here
);
661 mdef
= create_definition (macro
, end
, pfile
, keyword
== NULL
);
665 hashcode
= hashf (mdef
.symnam
, mdef
.symlen
, HASHSIZE
);
667 if ((hp
= cpp_lookup (pfile
, mdef
.symnam
, mdef
.symlen
, hashcode
)) != NULL
)
670 /* Redefining a precompiled key is ok. */
671 if (hp
->type
== T_PCSTRING
)
673 /* Redefining a poisoned identifier is even worse than `not ok'. */
674 else if (hp
->type
== T_POISON
)
676 /* Redefining a macro is ok if the definitions are the same. */
677 else if (hp
->type
== T_MACRO
)
678 ok
= ! compare_defs (pfile
, mdef
.defn
, hp
->value
.defn
);
679 /* Redefining a constant is ok with -D. */
680 else if (hp
->type
== T_CONST
|| hp
->type
== T_STDC
)
681 ok
= ! CPP_OPTIONS (pfile
)->done_initializing
;
682 /* Print the warning or error if it's not ok. */
685 if (hp
->type
== T_POISON
)
686 cpp_error (pfile
, "redefining poisoned `%.*s'",
687 mdef
.symlen
, mdef
.symnam
);
689 cpp_pedwarn (pfile
, "`%.*s' redefined", mdef
.symlen
, mdef
.symnam
);
690 if (hp
->type
== T_MACRO
)
691 cpp_pedwarn_with_file_and_line (pfile
, hp
->value
.defn
->file
,
692 hp
->value
.defn
->line
,
693 "this is the location of the previous definition");
695 if (hp
->type
!= T_POISON
)
697 /* Replace the old definition. */
699 hp
->value
.defn
= mdef
.defn
;
703 cpp_install (pfile
, mdef
.symnam
, mdef
.symlen
, new_type
,
704 (char *) mdef
.defn
, hashcode
);
706 if (keyword
!= NULL
&& keyword
->type
== T_DEFINE
)
708 if (CPP_OPTIONS (pfile
)->debug_output
709 || CPP_OPTIONS (pfile
)->dump_macros
== dump_definitions
)
710 dump_definition (pfile
, mdef
);
711 else if (CPP_OPTIONS (pfile
)->dump_macros
== dump_names
)
712 pass_thru_directive (mdef
.symnam
, mdef
.symlen
, pfile
, keyword
);
719 /* Allocate a new cpp_buffer for PFILE, and push it on the input buffer stack.
720 If BUFFER != NULL, then use the LENGTH characters in BUFFER
721 as the new input buffer.
722 Return the new buffer, or NULL on failure. */
725 cpp_push_buffer (pfile
, buffer
, length
)
730 cpp_buffer
*buf
= CPP_BUFFER (pfile
);
732 if (++pfile
->buffer_stack_depth
== CPP_STACK_MAX
)
734 cpp_fatal (pfile
, "macro or `#include' recursion too deep");
738 new = (cpp_buffer
*) xcalloc (1, sizeof (cpp_buffer
));
740 new->if_stack
= pfile
->if_stack
;
741 new->cleanup
= null_cleanup
;
742 new->underflow
= null_underflow
;
743 new->buf
= new->cur
= buffer
;
744 new->alimit
= new->rlimit
= buffer
+ length
;
748 CPP_BUFFER (pfile
) = new;
753 cpp_pop_buffer (pfile
)
756 cpp_buffer
*buf
= CPP_BUFFER (pfile
);
757 (*buf
->cleanup
) (buf
, pfile
);
758 CPP_BUFFER (pfile
) = CPP_PREV_BUFFER (buf
);
760 pfile
->buffer_stack_depth
--;
761 return CPP_BUFFER (pfile
);
764 /* Scan until CPP_BUFFER (PFILE) is exhausted into PFILE->token_buffer.
765 Pop the buffer when done. */
768 cpp_scan_buffer (pfile
)
771 cpp_buffer
*buffer
= CPP_BUFFER (pfile
);
772 enum cpp_token token
;
773 if (CPP_OPTIONS (pfile
)->no_output
)
775 long old_written
= CPP_WRITTEN (pfile
);
776 /* In no-output mode, we can ignore everything but directives. */
779 if (! pfile
->only_seen_white
)
780 skip_rest_of_line (pfile
);
781 token
= cpp_get_token (pfile
);
782 if (token
== CPP_EOF
) /* Should not happen ... */
784 if (token
== CPP_POP
&& CPP_BUFFER (pfile
) == buffer
)
786 if (CPP_PREV_BUFFER (CPP_BUFFER (pfile
))
787 != CPP_NULL_BUFFER (pfile
))
788 cpp_pop_buffer (pfile
);
792 CPP_SET_WRITTEN (pfile
, old_written
);
798 token
= cpp_get_token (pfile
);
799 if (token
== CPP_EOF
) /* Should not happen ... */
801 if (token
== CPP_POP
&& CPP_BUFFER (pfile
) == buffer
)
803 if (CPP_PREV_BUFFER (CPP_BUFFER (pfile
))
804 != CPP_NULL_BUFFER (pfile
))
805 cpp_pop_buffer (pfile
);
813 * Rescan a string (which may have escape marks) into pfile's buffer.
814 * Place the result in pfile->token_buffer.
816 * The input is copied before it is scanned, so it is safe to pass
817 * it something from the token_buffer that will get overwritten
818 * (because it follows CPP_WRITTEN). This is used by do_include.
822 cpp_expand_to_buffer (pfile
, buf
, length
)
827 register cpp_buffer
*ip
;
833 cpp_fatal (pfile
, "internal error: length < 0 in cpp_expand_to_buffer");
837 /* Set up the input on the input stack. */
839 buf1
= (U_CHAR
*) alloca (length
+ 1);
840 memcpy (buf1
, buf
, length
);
843 ip
= cpp_push_buffer (pfile
, buf1
, length
);
848 /* Scan the input, create the output. */
849 save_no_output
= CPP_OPTIONS (pfile
)->no_output
;
850 CPP_OPTIONS (pfile
)->no_output
= 0;
851 cpp_scan_buffer (pfile
);
852 CPP_OPTIONS (pfile
)->no_output
= save_no_output
;
854 CPP_NUL_TERMINATE (pfile
);
858 cpp_buf_line_and_col (pbuf
, linep
, colp
)
859 register cpp_buffer
*pbuf
;
864 *linep
= pbuf
->lineno
;
866 *colp
= pbuf
->cur
- pbuf
->line_base
;
876 /* Return the cpp_buffer that corresponds to a file (not a macro). */
879 cpp_file_buffer (pfile
)
882 cpp_buffer
*ip
= CPP_BUFFER (pfile
);
884 for ( ; ip
!= CPP_NULL_BUFFER (pfile
); ip
= CPP_PREV_BUFFER (ip
))
885 if (ip
->fname
!= NULL
)
891 * write out a #line command, for instance, after an #include file.
892 * FILE_CHANGE says whether we are entering a file, leaving, or neither.
896 output_line_command (pfile
, file_change
)
898 enum file_change_code file_change
;
901 cpp_buffer
*ip
= CPP_BUFFER (pfile
);
903 if (ip
->fname
== NULL
)
906 if (CPP_OPTIONS (pfile
)->no_line_commands
907 || CPP_OPTIONS (pfile
)->no_output
)
910 cpp_buf_line_and_col (CPP_BUFFER (pfile
), &line
, NULL
);
912 /* If the current file has not changed, we omit the #line if it would
913 appear to be a no-op, and we output a few newlines instead
914 if we want to increase the line number by a small amount.
915 We cannot do this if pfile->lineno is zero, because that means we
916 haven't output any line commands yet. (The very first line command
917 output is a `same_file' command.) */
918 if (file_change
== same_file
&& pfile
->lineno
!= 0)
920 if (line
== pfile
->lineno
)
923 /* If the inherited line number is a little too small,
924 output some newlines instead of a #line command. */
925 if (line
> pfile
->lineno
&& line
< pfile
->lineno
+ 8)
927 CPP_RESERVE (pfile
, 20);
928 while (line
> pfile
->lineno
)
930 CPP_PUTC_Q (pfile
, '\n');
937 CPP_RESERVE (pfile
, 4 * strlen (ip
->nominal_fname
) + 50);
938 CPP_PUTS_Q (pfile
, "# ", 2);
940 sprintf ((char *) CPP_PWRITTEN (pfile
), "%ld ", line
);
941 CPP_ADJUST_WRITTEN (pfile
, strlen (CPP_PWRITTEN (pfile
)));
943 quote_string (pfile
, ip
->nominal_fname
);
944 if (file_change
!= same_file
)
946 CPP_PUTC_Q (pfile
, ' ');
947 CPP_PUTC_Q (pfile
, file_change
== enter_file
? '1' : '2');
949 /* Tell cc1 if following text comes from a system header file. */
950 if (ip
->system_header_p
)
952 CPP_PUTC_Q (pfile
, ' ');
953 CPP_PUTC_Q (pfile
, '3');
955 #ifndef NO_IMPLICIT_EXTERN_C
956 /* Tell cc1plus if following text should be treated as C. */
957 if (ip
->system_header_p
== 2 && CPP_OPTIONS (pfile
)->cplusplus
)
959 CPP_PUTC_Q (pfile
, ' ');
960 CPP_PUTC_Q (pfile
, '4');
963 CPP_PUTC_Q (pfile
, '\n');
964 pfile
->lineno
= line
;
968 /* Like cpp_get_token, except that it does not read past end-of-line.
969 Also, horizontal space is skipped, and macros are popped. */
971 static enum cpp_token
972 get_directive_token (pfile
)
977 long old_written
= CPP_WRITTEN (pfile
);
978 enum cpp_token token
;
979 cpp_skip_hspace (pfile
);
980 if (PEEKC () == '\n')
982 token
= cpp_get_token (pfile
);
986 if (! CPP_IS_MACRO_BUFFER (CPP_BUFFER (pfile
)))
988 /* ... else fall though ... */
989 case CPP_HSPACE
: case CPP_COMMENT
:
990 CPP_SET_WRITTEN (pfile
, old_written
);
998 /* Handle #include and #import.
999 This function expects to see "fname" or <fname> on the input.
1001 The input is normally in part of the output_buffer following
1002 CPP_WRITTEN, and will get overwritten by output_line_command.
1003 I.e. in input file specification has been popped by handle_directive.
1007 do_include (pfile
, keyword
)
1009 const struct directive
*keyword
;
1011 int importing
= (keyword
->type
== T_IMPORT
);
1012 int skip_dirs
= (keyword
->type
== T_INCLUDE_NEXT
);
1013 int angle_brackets
= 0; /* 0 for "...", 1 for <...> */
1014 int before
; /* included before? */
1016 unsigned char *ftok
;
1019 enum cpp_token token
;
1021 /* Chain of dirs to search */
1022 struct include_hash
*ihash
;
1023 struct file_name_list
*search_start
;
1025 long old_written
= CPP_WRITTEN (pfile
);
1029 if (CPP_PEDANTIC (pfile
) && !CPP_BUFFER (pfile
)->system_header_p
)
1032 cpp_pedwarn (pfile
, "ANSI C does not allow `#import'");
1034 cpp_pedwarn (pfile
, "ANSI C does not allow `#include_next'");
1037 if (importing
&& CPP_OPTIONS (pfile
)->warn_import
1038 && !CPP_OPTIONS (pfile
)->inhibit_warnings
1039 && !CPP_BUFFER (pfile
)->system_header_p
&& !pfile
->import_warning
)
1041 pfile
->import_warning
= 1;
1043 "#import is obsolete, use an #ifndef wrapper in the header file");
1046 pfile
->parsing_include_directive
++;
1047 token
= get_directive_token (pfile
);
1048 pfile
->parsing_include_directive
--;
1050 if (token
== CPP_STRING
)
1052 if (pfile
->token_buffer
[old_written
] == '<')
1056 else if (token
== CPP_NAME
)
1058 /* Support '#include xyz' like VAX-C. It is taken as
1059 '#include <xyz.h>' and generates a warning. */
1061 "`#include filename' is obsolete, use `#include <filename.h>'");
1064 /* Append the missing `.h' to the name. */
1065 CPP_PUTS (pfile
, ".h", 2);
1071 "`#%s' expects \"FILENAME\" or <FILENAME>", keyword
->name
);
1072 CPP_SET_WRITTEN (pfile
, old_written
);
1073 skip_rest_of_line (pfile
);
1077 flen
= CPP_WRITTEN (pfile
) - old_written
;
1078 ftok
= (unsigned char *) alloca (flen
+ 1);
1079 memcpy (ftok
, pfile
->token_buffer
+ old_written
, flen
);
1082 if (get_directive_token (pfile
) != CPP_VSPACE
)
1084 cpp_error (pfile
, "junk at end of `#include'");
1085 skip_rest_of_line (pfile
);
1088 CPP_SET_WRITTEN (pfile
, old_written
);
1092 cpp_error (pfile
, "empty file name in `#%s'", keyword
->name
);
1096 if (CPP_OPTIONS (pfile
)->dump_includes
)
1097 pass_thru_directive (ftok
,
1100 - ((token
== CPP_NAME
) ? 2 : 0)
1105 if (token
== CPP_STRING
)
1115 for (fp
= CPP_BUFFER (pfile
);
1116 fp
!= CPP_NULL_BUFFER (pfile
);
1117 fp
= CPP_PREV_BUFFER (fp
))
1118 if (fp
->fname
!= NULL
)
1121 if (fp
== CPP_NULL_BUFFER (pfile
))
1123 cpp_fatal (pfile
, "cpp internal error: fp == NULL_BUFFER in do_include");
1127 /* For #include_next, skip in the search path past the dir in which the
1128 containing file was found. Treat files specified using an absolute path
1129 as if there are no more directories to search. Treat the primary source
1130 file like any other included source, but generate a warning. */
1131 if (skip_dirs
&& CPP_PREV_BUFFER(fp
) != CPP_NULL_BUFFER (pfile
))
1133 if (fp
->ihash
->foundhere
!= ABSOLUTE_PATH
)
1134 search_start
= fp
->ihash
->foundhere
->next
;
1139 cpp_warning (pfile
, "#include_next in primary source file");
1142 search_start
= CPP_OPTIONS (pfile
)->bracket_include
;
1145 if (!CPP_OPTIONS (pfile
)->ignore_srcdir
)
1148 search_start
= fp
->actual_dir
;
1151 search_start
= CPP_OPTIONS (pfile
)->quote_include
;
1157 cpp_error (pfile
, "No include path in which to find %s", ftok
);
1161 fd
= find_include_file (pfile
, ftok
, search_start
, &ihash
, &before
);
1168 if (CPP_OPTIONS (pfile
)->print_deps_missing_files
1169 && CPP_PRINT_DEPS (pfile
) > (angle_brackets
||
1170 (pfile
->system_include_depth
> 0)))
1172 if (!angle_brackets
)
1173 deps_output (pfile
, ftok
, ' ');
1177 struct file_name_list
*ptr
;
1178 /* If requested as a system header, assume it belongs in
1179 the first system header directory. */
1180 if (CPP_OPTIONS (pfile
)->bracket_include
)
1181 ptr
= CPP_OPTIONS (pfile
)->bracket_include
;
1183 ptr
= CPP_OPTIONS (pfile
)->quote_include
;
1185 p
= (char *) alloca (strlen (ptr
->name
)
1186 + strlen (ftok
) + 2);
1187 if (*ptr
->name
!= '\0')
1189 strcpy (p
, ptr
->name
);
1193 deps_output (pfile
, p
, ' ');
1196 /* If -M was specified, and this header file won't be added to
1197 the dependency list, then don't count this as an error,
1198 because we can still produce correct output. Otherwise, we
1199 can't produce correct output, because there may be
1200 dependencies we need inside the missing file, and we don't
1201 know what directory this missing file exists in. */
1202 else if (CPP_PRINT_DEPS (pfile
)
1203 && (CPP_PRINT_DEPS (pfile
)
1204 <= (angle_brackets
|| (pfile
->system_include_depth
> 0))))
1205 cpp_warning (pfile
, "No include path in which to find %s", ftok
);
1207 cpp_error_from_errno (pfile
, ftok
);
1212 /* For -M, add the file to the dependencies on its first inclusion. */
1213 if (!before
&& (CPP_PRINT_DEPS (pfile
)
1214 > (angle_brackets
|| (pfile
->system_include_depth
> 0))))
1215 deps_output (pfile
, ihash
->name
, ' ');
1217 /* Handle -H option. */
1218 if (CPP_OPTIONS(pfile
)->print_include_names
)
1220 fp
= CPP_BUFFER (pfile
);
1221 while ((fp
= CPP_PREV_BUFFER (fp
)) != CPP_NULL_BUFFER (pfile
))
1223 fprintf (stderr
, " %s\n", ihash
->name
);
1226 /* Actually process the file */
1229 ihash
->control_macro
= "";
1231 if (cpp_push_buffer (pfile
, NULL
, 0) == NULL
)
1238 pfile
->system_include_depth
++; /* Decremented in file_cleanup. */
1240 if (finclude (pfile
, fd
, ihash
))
1242 output_line_command (pfile
, enter_file
);
1243 pfile
->only_seen_white
= 2;
1249 /* Subroutine of do_line. Read next token from PFILE without adding it to
1250 the output buffer. If it is a number between 1 and 4, store it in *NUM
1251 and return 1; otherwise, return 0 and complain if we aren't at the end
1252 of the directive. */
1255 read_line_number (pfile
, num
)
1259 long save_written
= CPP_WRITTEN (pfile
);
1260 U_CHAR
*p
= pfile
->token_buffer
+ save_written
;
1261 enum cpp_token token
= get_directive_token (pfile
);
1262 CPP_SET_WRITTEN (pfile
, save_written
);
1264 if (token
== CPP_NUMBER
&& *p
>= '1' && *p
<= '4' && p
[1] == '\0')
1271 if (token
!= CPP_VSPACE
&& token
!= CPP_EOF
&& token
!= CPP_POP
)
1272 cpp_error (pfile
, "invalid format `#line' command");
1277 /* Interpret #line command.
1278 Note that the filename string (if any) is treated as if it were an
1279 include filename. That means no escape handling. */
1282 do_line (pfile
, keyword
)
1284 const struct directive
*keyword ATTRIBUTE_UNUSED
;
1286 cpp_buffer
*ip
= CPP_BUFFER (pfile
);
1288 long old_written
= CPP_WRITTEN (pfile
);
1289 enum file_change_code file_change
= same_file
;
1290 enum cpp_token token
;
1293 token
= get_directive_token (pfile
);
1295 if (token
!= CPP_NUMBER
)
1297 cpp_error (pfile
, "token after `#line' is not an integer");
1298 goto bad_line_directive
;
1301 new_lineno
= strtol (pfile
->token_buffer
+ old_written
, &x
, 10);
1304 cpp_error (pfile
, "token after `#line' is not an integer");
1305 goto bad_line_directive
;
1307 CPP_SET_WRITTEN (pfile
, old_written
);
1309 if (CPP_PEDANTIC (pfile
) && new_lineno
<= 0)
1310 cpp_pedwarn (pfile
, "line number out of range in `#line' command");
1312 token
= get_directive_token (pfile
);
1314 if (token
== CPP_STRING
)
1316 U_CHAR
*fname
= pfile
->token_buffer
+ old_written
+ 1;
1317 U_CHAR
*end_name
= CPP_PWRITTEN (pfile
) - 1;
1318 int action_number
= 0;
1320 if (read_line_number (pfile
, &action_number
))
1322 if (CPP_PEDANTIC (pfile
))
1323 cpp_pedwarn (pfile
, "garbage at end of `#line' command");
1325 if (action_number
== 1)
1327 file_change
= enter_file
;
1328 read_line_number (pfile
, &action_number
);
1330 else if (action_number
== 2)
1332 file_change
= leave_file
;
1333 read_line_number (pfile
, &action_number
);
1335 if (action_number
== 3)
1337 ip
->system_header_p
= 1;
1338 read_line_number (pfile
, &action_number
);
1340 if (action_number
== 4)
1342 ip
->system_header_p
= 2;
1343 read_line_number (pfile
, &action_number
);
1349 if (strcmp (fname
, ip
->nominal_fname
))
1351 char *newname
, *oldname
;
1352 if (!strcmp (fname
, ip
->fname
))
1353 newname
= ip
->fname
;
1354 else if (ip
->last_nominal_fname
1355 && !strcmp (fname
, ip
->last_nominal_fname
))
1356 newname
= ip
->last_nominal_fname
;
1358 newname
= xstrdup (fname
);
1360 oldname
= ip
->nominal_fname
;
1361 ip
->nominal_fname
= newname
;
1363 if (ip
->last_nominal_fname
1364 && ip
->last_nominal_fname
!= oldname
1365 && ip
->last_nominal_fname
!= newname
1366 && ip
->last_nominal_fname
!= ip
->fname
)
1367 free (ip
->last_nominal_fname
);
1369 if (newname
== ip
->fname
)
1370 ip
->last_nominal_fname
= NULL
;
1372 ip
->last_nominal_fname
= oldname
;
1375 else if (token
!= CPP_VSPACE
&& token
!= CPP_EOF
)
1377 cpp_error (pfile
, "token after `#line %d' is not a string", new_lineno
);
1378 goto bad_line_directive
;
1381 /* The Newline at the end of this line remains to be processed.
1382 To put the next line at the specified line number,
1383 we must store a line number now that is one less. */
1384 ip
->lineno
= new_lineno
- 1;
1385 CPP_SET_WRITTEN (pfile
, old_written
);
1386 output_line_command (pfile
, file_change
);
1390 skip_rest_of_line (pfile
);
1391 CPP_SET_WRITTEN (pfile
, old_written
);
1395 /* Remove the definition of a symbol from the symbol table.
1396 According to the C standard, it is not an error to undef
1397 something that has no definitions. */
1399 do_undef (pfile
, keyword
)
1401 const struct directive
*keyword
;
1405 U_CHAR
*buf
, *name
, *limit
;
1407 long here
= CPP_WRITTEN (pfile
);
1408 enum cpp_token token
;
1410 cpp_skip_hspace (pfile
);
1412 if (! is_idstart
[c
])
1414 cpp_error (pfile
, "token after #undef is not an identifier");
1415 skip_rest_of_line (pfile
);
1419 parse_name (pfile
, c
);
1420 buf
= pfile
->token_buffer
+ here
;
1421 limit
= CPP_PWRITTEN(pfile
);
1423 /* Copy out the token so we can pop the token buffer. */
1424 name
= (U_CHAR
*) alloca (limit
- buf
+ 1);
1425 bcopy(buf
, name
, limit
- buf
);
1426 name
[limit
- buf
] = '\0';
1428 token
= get_directive_token (pfile
);
1429 if (token
!= CPP_VSPACE
&& token
!= CPP_POP
)
1431 cpp_pedwarn (pfile
, "junk on line after #undef");
1432 skip_rest_of_line (pfile
);
1435 CPP_SET_WRITTEN (pfile
, here
);
1437 sym_length
= check_macro_name (pfile
, buf
, 0);
1439 while ((hp
= cpp_lookup (pfile
, name
, sym_length
, -1)) != NULL
)
1441 /* If we are generating additional info for debugging (with -g) we
1442 need to pass through all effective #undef commands. */
1443 if (CPP_OPTIONS (pfile
)->debug_output
&& keyword
)
1444 pass_thru_directive (name
, sym_length
, pfile
, keyword
);
1445 if (hp
->type
== T_POISON
)
1446 cpp_error (pfile
, "cannot undefine poisoned `%s'", hp
->name
);
1449 if (hp
->type
!= T_MACRO
)
1450 cpp_warning (pfile
, "undefining `%s'", hp
->name
);
1458 /* Wrap do_undef for -U processing. */
1460 cpp_undef (pfile
, macro
)
1464 if (cpp_push_buffer (pfile
, macro
, strlen (macro
)))
1466 do_undef (pfile
, NULL
);
1467 cpp_pop_buffer (pfile
);
1473 * Report an error detected by the program we are processing.
1474 * Use the text of the line in the error message.
1475 * (We use error because it prints the filename & line#.)
1479 do_error (pfile
, keyword
)
1481 const struct directive
*keyword ATTRIBUTE_UNUSED
;
1483 long here
= CPP_WRITTEN (pfile
);
1485 copy_rest_of_line (pfile
);
1486 text
= pfile
->token_buffer
+ here
;
1487 SKIP_WHITE_SPACE(text
);
1489 cpp_error (pfile
, "#error %s", text
);
1490 CPP_SET_WRITTEN (pfile
, here
);
1495 * Report a warning detected by the program we are processing.
1496 * Use the text of the line in the warning message, then continue.
1500 do_warning (pfile
, keyword
)
1502 const struct directive
*keyword ATTRIBUTE_UNUSED
;
1505 long here
= CPP_WRITTEN(pfile
);
1506 copy_rest_of_line (pfile
);
1507 text
= pfile
->token_buffer
+ here
;
1508 SKIP_WHITE_SPACE(text
);
1510 if (CPP_PEDANTIC (pfile
) && !CPP_BUFFER (pfile
)->system_header_p
)
1511 cpp_pedwarn (pfile
, "ANSI C does not allow `#warning'");
1513 /* Use `pedwarn' not `warning', because #warning isn't in the C Standard;
1514 if -pedantic-errors is given, #warning should cause an error. */
1515 cpp_pedwarn (pfile
, "#warning %s", text
);
1516 CPP_SET_WRITTEN (pfile
, here
);
1520 /* Report program identification.
1521 This is not precisely what cccp does with #ident, however I believe
1522 it matches `closely enough' (behavior is identical as long as there
1523 are no macros on the #ident line, which is pathological in my opinion). */
1526 do_ident (pfile
, keyword
)
1528 const struct directive
*keyword ATTRIBUTE_UNUSED
;
1530 /* Allow #ident in system headers, since that's not user's fault. */
1531 if (CPP_PEDANTIC (pfile
) && !CPP_BUFFER (pfile
)->system_header_p
)
1532 cpp_pedwarn (pfile
, "ANSI C does not allow `#ident'");
1534 CPP_PUTS (pfile
, "#ident ", 7);
1535 cpp_skip_hspace (pfile
);
1536 copy_rest_of_line (pfile
);
1541 /* Just check for some recognized pragmas that need validation here,
1542 and leave the text in the token buffer to be output. */
1545 do_pragma (pfile
, keyword
)
1547 const struct directive
*keyword ATTRIBUTE_UNUSED
;
1552 CPP_PUTS (pfile
, "#pragma ", 8);
1553 cpp_skip_hspace (pfile
);
1555 here
= CPP_WRITTEN (pfile
);
1556 copy_rest_of_line (pfile
);
1557 buf
= pfile
->token_buffer
+ here
;
1559 if (!strncmp (buf
, "once", 4))
1561 cpp_buffer
*ip
= NULL
;
1563 /* Allow #pragma once in system headers, since that's not the user's
1565 if (!CPP_BUFFER (pfile
)->system_header_p
)
1566 cpp_warning (pfile
, "`#pragma once' is obsolete");
1568 for (ip
= CPP_BUFFER (pfile
); ; ip
= CPP_PREV_BUFFER (ip
))
1570 if (ip
== CPP_NULL_BUFFER (pfile
))
1572 if (ip
->fname
!= NULL
)
1576 if (CPP_PREV_BUFFER (ip
) == CPP_NULL_BUFFER (pfile
))
1577 cpp_warning (pfile
, "`#pragma once' outside include file");
1579 ip
->ihash
->control_macro
= ""; /* never repeat */
1581 else if (!strncmp (buf
, "implementation", 14))
1583 /* Be quiet about `#pragma implementation' for a file only if it hasn't
1584 been included yet. */
1585 struct include_hash
*ptr
;
1586 U_CHAR
*p
= buf
+ 14, *fname
, *fcopy
;
1587 SKIP_WHITE_SPACE (p
);
1588 if (*p
== '\n' || *p
!= '\"')
1592 p
= (U_CHAR
*) index (fname
, '\"');
1594 fcopy
= (U_CHAR
*) alloca (p
- fname
+ 1);
1595 bcopy (fname
, fcopy
, p
- fname
);
1596 fcopy
[p
-fname
] = '\0';
1598 ptr
= include_hash (pfile
, fcopy
, 0);
1601 "`#pragma implementation' for `%s' appears after file is included",
1604 else if (!strncmp (buf
, "poison", 6))
1606 /* Poison these symbols so that all subsequent usage produces an
1608 U_CHAR
*p
= buf
+ 6;
1613 SKIP_WHITE_SPACE (p
);
1614 plen
= strlen(p
) + 1;
1616 syms
= (U_CHAR
*) alloca (plen
);
1617 memcpy (syms
, p
, plen
);
1619 /* As a rule, don't include #pragma poison commands in output,
1620 unless the user asks for them. */
1621 writeit
= (CPP_OPTIONS (pfile
)->debug_output
1622 || CPP_OPTIONS (pfile
)->dump_macros
== dump_definitions
1623 || CPP_OPTIONS (pfile
)->dump_macros
== dump_names
);
1626 CPP_SET_WRITTEN (pfile
, here
);
1628 CPP_SET_WRITTEN (pfile
, here
-8);
1632 CPP_RESERVE (pfile
, plen
+ 7);
1633 CPP_PUTS_Q (pfile
, "poison", 7);
1636 while (*syms
!= '\0')
1640 while (is_idchar
[*end
])
1643 if (!is_hor_space
[*end
] && *end
!= '\0')
1645 cpp_error (pfile
, "invalid #pragma poison directive");
1649 if (cpp_push_buffer (pfile
, syms
, end
- syms
) != NULL
)
1651 do_define (pfile
, keyword
);
1652 cpp_pop_buffer (pfile
);
1656 CPP_PUTC_Q (pfile
, ' ');
1657 CPP_PUTS_Q (pfile
, syms
, end
- syms
);
1660 SKIP_WHITE_SPACE (syms
);
1667 #ifdef SCCS_DIRECTIVE
1668 /* Just ignore #sccs, on systems where we define it at all. */
1671 do_sccs (pfile
, keyword
)
1673 const struct directive
*keyword ATTRIBUTE_UNUSED
;
1675 if (CPP_PEDANTIC (pfile
))
1676 cpp_pedwarn (pfile
, "ANSI C does not allow `#sccs'");
1677 skip_rest_of_line (pfile
);
1683 /* We've found an `#if' directive. If the only thing before it in
1684 this file is white space, and if it is of the form
1685 `#if ! defined SYMBOL', then SYMBOL is a possible controlling macro
1686 for inclusion of this file. (See redundant_include_p in cppfiles.c
1687 for an explanation of controlling macros.) If so, return a
1688 malloc'd copy of SYMBOL. Otherwise, return NULL. */
1691 detect_if_not_defined (pfile
)
1694 U_CHAR
*control_macro
= 0;
1696 if (pfile
->only_seen_white
== 2)
1699 enum cpp_token token
;
1702 int need_rparen
= 0;
1704 /* Save state required for restore. */
1705 pfile
->no_macro_expand
++;
1706 parse_set_mark (pfile
);
1707 base_offset
= CPP_WRITTEN (pfile
);
1710 if (get_directive_token (pfile
) != CPP_OTHER
1711 || CPP_WRITTEN (pfile
) != (size_t) base_offset
+ 1
1712 || CPP_PWRITTEN (pfile
)[-1] != '!')
1715 /* ...then `defined', */
1716 token_offset
= CPP_WRITTEN (pfile
);
1717 token
= get_directive_token (pfile
);
1718 if (token
!= CPP_NAME
)
1720 ident
= pfile
->token_buffer
+ token_offset
;
1721 CPP_NUL_TERMINATE (pfile
);
1722 if (strcmp (ident
, "defined"))
1725 /* ...then an optional '(' and the name, */
1726 token_offset
= CPP_WRITTEN (pfile
);
1727 token
= get_directive_token (pfile
);
1728 if (token
== CPP_LPAREN
)
1730 token_offset
= CPP_WRITTEN (pfile
);
1731 token
= get_directive_token (pfile
);
1732 if (token
!= CPP_NAME
)
1736 else if (token
!= CPP_NAME
)
1739 ident
= pfile
->token_buffer
+ token_offset
;
1740 CPP_NUL_TERMINATE (pfile
);
1742 /* ...then the ')', if necessary, */
1743 if ((!need_rparen
|| get_directive_token (pfile
) == CPP_RPAREN
)
1744 /* ...and make sure there's nothing else on the line. */
1745 && get_directive_token (pfile
) == CPP_VSPACE
)
1746 control_macro
= xstrdup (ident
);
1749 CPP_SET_WRITTEN (pfile
, base_offset
);
1750 pfile
->no_macro_expand
--;
1751 parse_goto_mark (pfile
);
1754 return control_macro
;
1758 * handle #if command by
1759 * 1) inserting special `defined' keyword into the hash table
1760 * that gets turned into 0 or 1 by special_symbol (thus,
1761 * if the luser has a symbol called `defined' already, it won't
1762 * work inside the #if command)
1763 * 2) rescan the input into a temporary output buffer
1764 * 3) pass the output buffer to the yacc parser and collect a value
1765 * 4) clean up the mess left from steps 1 and 2.
1766 * 5) call conditional_skip to skip til the next #endif (etc.),
1767 * or not, depending on the value from step 3.
1771 do_if (pfile
, keyword
)
1773 const struct directive
*keyword ATTRIBUTE_UNUSED
;
1775 U_CHAR
*control_macro
= detect_if_not_defined (pfile
);
1776 HOST_WIDEST_INT value
= eval_if_expression (pfile
);
1777 conditional_skip (pfile
, value
== 0, T_IF
, control_macro
);
1782 * handle a #elif directive by not changing if_stack either.
1783 * see the comment above do_else.
1787 do_elif (pfile
, keyword
)
1789 const struct directive
*keyword ATTRIBUTE_UNUSED
;
1791 if (pfile
->if_stack
== CPP_BUFFER (pfile
)->if_stack
) {
1792 cpp_error (pfile
, "`#elif' not within a conditional");
1795 if (pfile
->if_stack
->type
!= T_IF
&& pfile
->if_stack
->type
!= T_ELIF
) {
1796 cpp_error (pfile
, "`#elif' after `#else'");
1798 fprintf (stderr
, " (matches line %d", pfile
->if_stack
->lineno
);
1800 if (pfile
->if_stack
->fname
!= NULL
&& CPP_BUFFER (pfile
)->fname
!= NULL
1801 && strcmp (pfile
->if_stack
->fname
,
1802 CPP_BUFFER (pfile
)->nominal_fname
) != 0)
1803 fprintf (stderr
, ", file %s", pfile
->if_stack
->fname
);
1804 fprintf (stderr
, ")\n");
1806 pfile
->if_stack
->type
= T_ELIF
;
1809 if (pfile
->if_stack
->if_succeeded
)
1810 skip_if_group (pfile
);
1812 HOST_WIDEST_INT value
= eval_if_expression (pfile
);
1814 skip_if_group (pfile
);
1816 ++pfile
->if_stack
->if_succeeded
; /* continue processing input */
1817 output_line_command (pfile
, same_file
);
1824 * evaluate a #if expression in BUF, of length LENGTH,
1825 * then parse the result as a C expression and return the value as an int.
1828 static HOST_WIDEST_INT
1829 eval_if_expression (pfile
)
1832 HOST_WIDEST_INT value
;
1833 long old_written
= CPP_WRITTEN (pfile
);
1835 pfile
->pcp_inside_if
= 1;
1836 value
= cpp_parse_expr (pfile
);
1837 pfile
->pcp_inside_if
= 0;
1839 CPP_SET_WRITTEN (pfile
, old_written
); /* Pop */
1845 * routine to handle ifdef/ifndef. Try to look up the symbol,
1846 * then do or don't skip to the #endif/#else/#elif depending
1847 * on what directive is actually being processed.
1851 do_xifdef (pfile
, keyword
)
1853 const struct directive
*keyword
;
1856 cpp_buffer
*ip
= CPP_BUFFER (pfile
);
1859 enum cpp_token token
;
1860 int start_of_file
= 0;
1861 U_CHAR
*control_macro
= 0;
1862 int old_written
= CPP_WRITTEN (pfile
);
1864 /* Detect a #ifndef at start of file (not counting comments). */
1865 if (ip
->fname
!= 0 && keyword
->type
== T_IFNDEF
)
1866 start_of_file
= pfile
->only_seen_white
== 2;
1868 pfile
->no_macro_expand
++;
1869 token
= get_directive_token (pfile
);
1870 pfile
->no_macro_expand
--;
1872 ident
= pfile
->token_buffer
+ old_written
;
1873 ident_length
= CPP_WRITTEN (pfile
) - old_written
;
1874 CPP_SET_WRITTEN (pfile
, old_written
); /* Pop */
1876 if (token
== CPP_VSPACE
|| token
== CPP_POP
|| token
== CPP_EOF
)
1878 skip
= (keyword
->type
== T_IFDEF
);
1879 if (! CPP_TRADITIONAL (pfile
))
1880 cpp_pedwarn (pfile
, "`#%s' with no argument", keyword
->name
);
1882 else if (token
== CPP_NAME
)
1884 HASHNODE
*hp
= cpp_lookup (pfile
, ident
, ident_length
, -1);
1885 skip
= (hp
== NULL
) ^ (keyword
->type
== T_IFNDEF
);
1886 if (start_of_file
&& !skip
)
1888 control_macro
= (U_CHAR
*) xmalloc (ident_length
+ 1);
1889 bcopy (ident
, control_macro
, ident_length
+ 1);
1891 if (hp
!= NULL
&& hp
->type
== T_POISON
)
1893 cpp_error (pfile
, "attempt to use poisoned `%s'", hp
->name
);
1899 skip
= (keyword
->type
== T_IFDEF
);
1900 if (! CPP_TRADITIONAL (pfile
))
1901 cpp_error (pfile
, "`#%s' with invalid argument", keyword
->name
);
1904 if (!CPP_TRADITIONAL (pfile
))
1906 cpp_skip_hspace (pfile
);
1908 if (c
!= EOF
&& c
!= '\n')
1909 cpp_pedwarn (pfile
, "garbage at end of `#%s' argument", keyword
->name
);
1911 skip_rest_of_line (pfile
);
1915 /* Output a precondition for this macro. */
1916 if (hp
&& hp
->value
.defn
->predefined
)
1917 fprintf (pcp_outfile
, "#define %s\n", hp
->name
);
1920 fprintf (pcp_outfile
, "#undef ");
1921 while (is_idchar
[*cp
]) /* Ick! */
1922 fputc (*cp
++, pcp_outfile
);
1923 putc ('\n', pcp_outfile
);
1927 conditional_skip (pfile
, skip
, T_IF
, control_macro
);
1931 /* Push TYPE on stack; then, if SKIP is nonzero, skip ahead.
1932 If this is a #ifndef starting at the beginning of a file,
1933 CONTROL_MACRO is the macro name tested by the #ifndef.
1934 Otherwise, CONTROL_MACRO is 0. */
1937 conditional_skip (pfile
, skip
, type
, control_macro
)
1940 enum node_type type
;
1941 U_CHAR
*control_macro
;
1943 IF_STACK_FRAME
*temp
;
1945 temp
= (IF_STACK_FRAME
*) xcalloc (1, sizeof (IF_STACK_FRAME
));
1946 temp
->fname
= CPP_BUFFER (pfile
)->nominal_fname
;
1947 temp
->lineno
= CPP_BUFFER (pfile
)->lineno
;
1948 temp
->next
= pfile
->if_stack
;
1949 temp
->control_macro
= control_macro
;
1950 pfile
->if_stack
= temp
;
1952 pfile
->if_stack
->type
= type
;
1955 skip_if_group (pfile
);
1958 ++pfile
->if_stack
->if_succeeded
;
1959 output_line_command (pfile
, same_file
);
1963 /* Subroutine of skip_if_group. Examine one preprocessing directive and
1964 return 0 if skipping should continue, 1 if it should halt. Also
1965 adjusts the if_stack as appropriate.
1966 The `#' has been read, but not the identifier. */
1969 consider_directive_while_skipping (pfile
, stack
)
1971 IF_STACK_FRAME
*stack
;
1973 long ident_len
, ident
;
1974 const struct directive
*kt
;
1975 IF_STACK_FRAME
*temp
;
1977 cpp_skip_hspace (pfile
);
1979 ident
= CPP_WRITTEN (pfile
);
1980 parse_name (pfile
, GETC());
1981 ident_len
= CPP_WRITTEN (pfile
) - ident
;
1983 CPP_SET_WRITTEN (pfile
, ident
);
1985 for (kt
= directive_table
; kt
->length
>= 0; kt
++)
1986 if (kt
->length
== ident_len
1987 && strncmp (pfile
->token_buffer
+ ident
, kt
->name
, kt
->length
) == 0)
1993 temp
= (IF_STACK_FRAME
*) xmalloc (sizeof (IF_STACK_FRAME
));
1994 temp
->next
= pfile
->if_stack
;
1995 pfile
->if_stack
= temp
;
1996 temp
->fname
= CPP_BUFFER(pfile
)->nominal_fname
;
1997 temp
->type
= kt
->type
;
2001 if (CPP_PEDANTIC (pfile
) && pfile
->if_stack
!= stack
)
2002 validate_else (pfile
, "#else");
2005 if (pfile
->if_stack
->type
== T_ELSE
)
2006 cpp_error (pfile
, "`%s' after `#else'", kt
->name
);
2008 if (pfile
->if_stack
== stack
)
2012 pfile
->if_stack
->type
= kt
->type
;
2017 if (CPP_PEDANTIC (pfile
) && pfile
->if_stack
!= stack
)
2018 validate_else (pfile
, "#endif");
2020 if (pfile
->if_stack
== stack
)
2023 temp
= pfile
->if_stack
;
2024 pfile
->if_stack
= temp
->next
;
2032 /* Don't let erroneous code go by. */
2033 if (!CPP_OPTIONS (pfile
)->lang_asm
&& CPP_PEDANTIC (pfile
))
2034 cpp_pedwarn (pfile
, "invalid preprocessor directive name");
2038 /* skip to #endif, #else, or #elif. adjust line numbers, etc.
2039 * leaves input ptr at the sharp sign found.
2042 skip_if_group (pfile
)
2046 IF_STACK_FRAME
*save_if_stack
= pfile
->if_stack
; /* don't pop past here */
2047 U_CHAR
*beg_of_line
;
2050 if (CPP_OPTIONS (pfile
)->output_conditionals
)
2052 CPP_PUTS (pfile
, "#failed\n", 8);
2054 output_line_command (pfile
, same_file
);
2057 old_written
= CPP_WRITTEN (pfile
);
2061 beg_of_line
= CPP_BUFFER (pfile
)->cur
;
2063 if (! CPP_TRADITIONAL (pfile
))
2064 cpp_skip_hspace (pfile
);
2068 if (CPP_OPTIONS (pfile
)->output_conditionals
)
2069 CPP_PUTC (pfile
, c
);
2070 CPP_BUMP_LINE (pfile
);
2075 if (consider_directive_while_skipping (pfile
, save_if_stack
))
2079 return; /* Caller will issue error. */
2082 if (CPP_OPTIONS (pfile
)->output_conditionals
)
2084 CPP_PUTS (pfile
, beg_of_line
, CPP_BUFFER (pfile
)->cur
- beg_of_line
);
2085 copy_rest_of_line (pfile
);
2089 copy_rest_of_line (pfile
);
2090 CPP_SET_WRITTEN (pfile
, old_written
); /* discard it */
2095 return; /* Caller will issue error. */
2099 if (CPP_OPTIONS (pfile
)->output_conditionals
)
2101 CPP_PUTC (pfile
, c
);
2104 CPP_BUMP_LINE (pfile
);
2108 /* Back up to the beginning of this line. Caller will process the
2110 CPP_BUFFER (pfile
)->cur
= beg_of_line
;
2111 pfile
->only_seen_white
= 1;
2112 if (CPP_OPTIONS (pfile
)->output_conditionals
)
2114 CPP_PUTS (pfile
, "#endfailed\n", 11);
2120 * handle a #else directive. Do this by just continuing processing
2121 * without changing if_stack ; this is so that the error message
2122 * for missing #endif's etc. will point to the original #if. It
2123 * is possible that something different would be better.
2127 do_else (pfile
, keyword
)
2129 const struct directive
*keyword ATTRIBUTE_UNUSED
;
2131 cpp_buffer
*ip
= CPP_BUFFER (pfile
);
2133 if (CPP_PEDANTIC (pfile
))
2134 validate_else (pfile
, "#else");
2135 skip_rest_of_line (pfile
);
2137 if (pfile
->if_stack
== CPP_BUFFER (pfile
)->if_stack
) {
2138 cpp_error (pfile
, "`#else' not within a conditional");
2141 /* #ifndef can't have its special treatment for containing the whole file
2142 if it has a #else clause. */
2143 pfile
->if_stack
->control_macro
= 0;
2145 if (pfile
->if_stack
->type
!= T_IF
&& pfile
->if_stack
->type
!= T_ELIF
) {
2146 cpp_error (pfile
, "`#else' after `#else'");
2147 fprintf (stderr
, " (matches line %d", pfile
->if_stack
->lineno
);
2148 if (strcmp (pfile
->if_stack
->fname
, ip
->nominal_fname
) != 0)
2149 fprintf (stderr
, ", file %s", pfile
->if_stack
->fname
);
2150 fprintf (stderr
, ")\n");
2152 pfile
->if_stack
->type
= T_ELSE
;
2155 if (pfile
->if_stack
->if_succeeded
)
2156 skip_if_group (pfile
);
2158 ++pfile
->if_stack
->if_succeeded
; /* continue processing input */
2159 output_line_command (pfile
, same_file
);
2165 * unstack after #endif command
2169 do_endif (pfile
, keyword
)
2171 const struct directive
*keyword ATTRIBUTE_UNUSED
;
2173 if (CPP_PEDANTIC (pfile
))
2174 validate_else (pfile
, "#endif");
2175 skip_rest_of_line (pfile
);
2177 if (pfile
->if_stack
== CPP_BUFFER (pfile
)->if_stack
)
2178 cpp_error (pfile
, "`#endif' not within a conditional");
2181 IF_STACK_FRAME
*temp
= pfile
->if_stack
;
2182 pfile
->if_stack
= temp
->next
;
2183 if (temp
->control_macro
!= 0)
2185 /* This #endif matched a #ifndef at the start of the file.
2186 See if it is at the end of the file. */
2189 parse_set_mark (pfile
);
2193 cpp_skip_hspace (pfile
);
2198 parse_goto_mark (pfile
);
2202 /* This #endif ends a #ifndef
2203 that contains all of the file (aside from whitespace).
2204 Arrange not to include the file again
2205 if the macro that was tested is defined. */
2206 struct cpp_buffer
*ip
;
2207 for (ip
= CPP_BUFFER (pfile
); ; ip
= CPP_PREV_BUFFER (ip
))
2208 if (ip
->fname
!= NULL
)
2210 ip
->ihash
->control_macro
= (char *) temp
->control_macro
;
2214 output_line_command (pfile
, same_file
);
2219 /* When an #else or #endif is found while skipping failed conditional,
2220 if -pedantic was specified, this is called to warn about text after
2221 the command name. P points to the first char after the command name. */
2224 validate_else (pfile
, directive
)
2226 const char *directive
;
2229 cpp_skip_hspace (pfile
);
2231 if (c
!= EOF
&& c
!= '\n')
2233 "text following `%s' violates ANSI standard", directive
);
2236 /* Convert T_IF, etc. to a string. Used in error messages. */
2238 if_directive_name (pfile
, ifs
)
2240 struct if_stack
*ifs
;
2244 case T_IF
: return "#if";
2245 case T_IFDEF
: return "#ifdef";
2246 case T_IFNDEF
: return "#ifndef";
2247 case T_ELIF
: return "#elif";
2248 case T_ELSE
: return "#else";
2250 cpp_fatal (pfile
, "impossible if_stack->type value %d", ifs
->type
);
2255 /* Get the next token, and add it to the text in pfile->token_buffer.
2256 Return the kind of token we got. */
2259 cpp_get_token (pfile
)
2262 register int c
, c2
, c3
;
2263 enum cpp_token token
;
2264 struct cpp_options
*opts
= CPP_OPTIONS (pfile
);
2271 if (CPP_BUFFER (pfile
)->manual_pop
)
2272 /* If we've been reading from redirected input, the
2273 frontend will pop the buffer. */
2275 else if (CPP_BUFFER (pfile
)->seen_eof
)
2277 if (CPP_PREV_BUFFER (CPP_BUFFER (pfile
)) == CPP_NULL_BUFFER (pfile
))
2280 cpp_pop_buffer (pfile
);
2285 cpp_buffer
*next_buf
= CPP_PREV_BUFFER (CPP_BUFFER (pfile
));
2286 struct if_stack
*ifs
, *nifs
;
2288 /* Unwind the conditional stack and generate error messages. */
2289 for (ifs
= pfile
->if_stack
;
2290 ifs
!= CPP_BUFFER (pfile
)->if_stack
;
2293 cpp_error_with_line (pfile
, ifs
->lineno
, -1,
2294 "unterminated `%s' conditional",
2295 if_directive_name (pfile
, ifs
));
2300 pfile
->if_stack
= ifs
;
2302 if (CPP_BUFFER (pfile
)->nominal_fname
2303 && next_buf
!= CPP_NULL_BUFFER (pfile
))
2305 /* We're about to return from an #include file.
2306 Emit #line information now (as part of the CPP_POP) result.
2307 But the #line refers to the file we will pop to. */
2308 cpp_buffer
*cur_buffer
= CPP_BUFFER (pfile
);
2309 CPP_BUFFER (pfile
) = next_buf
;
2310 pfile
->input_stack_listing_current
= 0;
2311 output_line_command (pfile
, leave_file
);
2312 CPP_BUFFER (pfile
) = cur_buffer
;
2315 CPP_BUFFER (pfile
)->seen_eof
= 1;
2324 if (PEEKC () == '=')
2328 if (opts
->put_out_comments
)
2329 c
= copy_comment (pfile
, c
);
2331 c
= skip_comment (pfile
, c
);
2337 /* Comments are equivalent to spaces.
2338 For -traditional, a comment is equivalent to nothing. */
2339 if (opts
->traditional
|| opts
->put_out_comments
)
2343 CPP_PUTC (pfile
, c
);
2347 if (opts
->for_lint
) {
2350 char *lintcmd
= get_lintcmd (ibp
, limit
, &argbp
, &arglen
, &cmdlen
);
2352 if (lintcmd
!= NULL
) {
2353 /* I believe it is always safe to emit this newline: */
2355 bcopy ("#pragma lint ", (char *) obp
, 13);
2357 bcopy (lintcmd
, (char *) obp
, cmdlen
);
2362 bcopy (argbp
, (char *) obp
, arglen
);
2366 /* OK, now bring us back to the state we were in before we entered
2367 this branch. We need #line because the newline for the pragma
2368 could mess things up. */
2369 output_line_command (pfile
, same_file
);
2370 *(obp
++) = ' '; /* just in case, if comments are copied thru */
2378 /* If this is expanding a macro definition, don't recognize
2379 preprocessor directives. */
2382 /* If this is expand_into_temp_buffer, recognize them
2383 only after an actual newline at this level,
2384 not at the beginning of the input level. */
2385 if (ip
->fname
== 0 && beg_of_line
== ip
->buf
)
2391 if (!pfile
->only_seen_white
)
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_hor_space
[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
);
2877 /* Character constants may not extend over multiple lines.
2878 In ANSI, neither may strings. We accept multiline strings
2882 cpp_error_with_line (pfile
, start_line
, start_column
,
2883 "unterminated character constant");
2886 if (CPP_PEDANTIC (pfile
) && pfile
->multiline_string_line
== 0)
2888 cpp_pedwarn_with_line (pfile
, start_line
, start_column
,
2889 "string constant runs past end of line");
2891 if (pfile
->multiline_string_line
== 0)
2892 pfile
->multiline_string_line
= start_line
;
2896 CPP_ADJUST_WRITTEN (pfile
, -1);
2897 if (CPP_BUFFER (pfile
)->has_escapes
)
2900 "internal error: \\r escape inside string constant");
2904 /* Backslash newline is replaced by nothing at all. */
2905 CPP_BUMP_LINE (pfile
);
2911 CPP_PUTC (pfile
, cc
);
2923 /* Read an assertion into the token buffer, converting to
2924 canonical form: `#predicate(a n swe r)' The next non-whitespace
2925 character to read should be the first letter of the predicate.
2926 Returns 0 for syntax error, 1 for bare predicate, 2 for predicate
2927 with answer (see callers for why). In case of 0, an error has been
2930 parse_assertion (pfile
)
2934 cpp_skip_hspace (pfile
);
2936 if (! is_idstart
[c
])
2938 cpp_error (pfile
, "assertion predicate is not an identifier");
2941 CPP_PUTC(pfile
, '#');
2943 parse_name(pfile
, c
);
2948 if (is_hor_space
[c
] || c
== '\r')
2949 cpp_skip_hspace (pfile
);
2955 CPP_PUTC(pfile
, '(');
2958 while ((c
= GETC()) != ')')
2960 if (is_hor_space
[c
])
2964 CPP_PUTC(pfile
, ' ');
2968 else if (c
== '\n' || c
== EOF
)
2970 if (c
== '\n') FORWARD(-1);
2971 cpp_error (pfile
, "un-terminated assertion answer");
2975 /* \r cannot be a macro escape here. */
2976 CPP_BUMP_LINE (pfile
);
2979 CPP_PUTC (pfile
, c
);
2984 if (pfile
->limit
[-1] == ' ')
2985 pfile
->limit
[-1] = ')';
2986 else if (pfile
->limit
[-1] == '(')
2988 cpp_error (pfile
, "empty token sequence in assertion");
2992 CPP_PUTC (pfile
, ')');
2994 CPP_NUL_TERMINATE (pfile
);
2999 do_assert (pfile
, keyword
)
3001 const struct directive
*keyword ATTRIBUTE_UNUSED
;
3005 HASHNODE
*base
, *this;
3006 int baselen
, thislen
;
3008 if (CPP_PEDANTIC (pfile
) && CPP_OPTIONS (pfile
)->done_initializing
3009 && !CPP_BUFFER (pfile
)->system_header_p
)
3010 cpp_pedwarn (pfile
, "ANSI C does not allow `#assert'");
3012 cpp_skip_hspace (pfile
);
3013 sym
= (char *) CPP_PWRITTEN (pfile
); /* remember where it starts */
3014 ret
= parse_assertion (pfile
);
3019 cpp_error (pfile
, "missing token-sequence in `#assert'");
3023 cpp_skip_hspace (pfile
);
3025 if (c
!= EOF
&& c
!= '\n')
3027 cpp_error (pfile
, "junk at end of `#assert'");
3031 thislen
= strlen (sym
);
3032 baselen
= index (sym
, '(') - sym
;
3033 this = cpp_lookup (pfile
, sym
, thislen
, -1);
3036 cpp_warning (pfile
, "`%s' re-asserted", sym
);
3040 base
= cpp_lookup (pfile
, sym
, baselen
, -1);
3042 base
= cpp_install (pfile
, sym
, baselen
, T_ASSERT
, 0, -1);
3043 else if (base
->type
!= T_ASSERT
)
3045 /* Token clash - but with what?! */
3047 "cpp internal error: base->type != T_ASSERT in do_assert");
3051 this = cpp_install (pfile
, sym
, thislen
, T_ASSERT
,
3052 (char *)base
->value
.aschain
, -1);
3053 base
->value
.aschain
= this;
3055 pfile
->limit
= (unsigned char *) sym
; /* Pop */
3059 skip_rest_of_line (pfile
);
3060 pfile
->limit
= (unsigned char *) sym
; /* Pop */
3065 do_unassert (pfile
, keyword
)
3067 const struct directive
*keyword ATTRIBUTE_UNUSED
;
3071 long baselen
, thislen
;
3072 HASHNODE
*base
, *this, *next
;
3074 if (CPP_PEDANTIC (pfile
) && CPP_OPTIONS (pfile
)->done_initializing
3075 && !CPP_BUFFER (pfile
)->system_header_p
)
3076 cpp_pedwarn (pfile
, "ANSI C does not allow `#unassert'");
3078 cpp_skip_hspace (pfile
);
3080 sym
= (char *) CPP_PWRITTEN (pfile
); /* remember where it starts */
3081 ret
= parse_assertion (pfile
);
3085 cpp_skip_hspace (pfile
);
3087 if (c
!= EOF
&& c
!= '\n')
3088 cpp_error (pfile
, "junk at end of `#unassert'");
3090 thislen
= strlen (sym
);
3093 base
= cpp_lookup (pfile
, sym
, thislen
, -1);
3095 goto error
; /* It isn't an error to #undef what isn't #defined,
3096 so it isn't an error to #unassert what isn't
3097 #asserted either. */
3099 for (this = base
->value
.aschain
; this; this = next
)
3101 next
= this->value
.aschain
;
3102 delete_macro (this);
3104 delete_macro (base
);
3108 baselen
= index (sym
, '(') - sym
;
3109 base
= cpp_lookup (pfile
, sym
, baselen
, -1);
3110 if (! base
) goto error
;
3111 this = cpp_lookup (pfile
, sym
, thislen
, -1);
3112 if (! this) goto error
;
3115 while (next
->value
.aschain
!= this)
3116 next
= next
->value
.aschain
;
3118 next
->value
.aschain
= this->value
.aschain
;
3119 delete_macro (this);
3121 if (base
->value
.aschain
== NULL
)
3122 delete_macro (base
); /* Last answer for this predicate deleted. */
3125 pfile
->limit
= (unsigned char *) sym
; /* Pop */
3128 skip_rest_of_line (pfile
);
3129 pfile
->limit
= (unsigned char *) sym
; /* Pop */
3133 /* Process STR as if it appeared as the body of an #unassert. */
3135 cpp_unassert (pfile
, str
)
3139 if (cpp_push_buffer (pfile
, str
, strlen (str
)) != NULL
)
3141 do_assert (pfile
, NULL
);
3142 cpp_pop_buffer (pfile
);
3147 cpp_read_check_assertion (pfile
)
3150 U_CHAR
*name
= CPP_PWRITTEN (pfile
);
3154 FORWARD (1); /* Skip '#' */
3155 cpp_skip_hspace (pfile
);
3156 if (! parse_assertion (pfile
))
3160 hp
= cpp_lookup (pfile
, name
, CPP_PWRITTEN (pfile
) - name
, -1);
3164 pfile
->limit
= name
;
3168 /* Remember the current position of PFILE. */
3171 parse_set_mark (pfile
)
3174 cpp_buffer
*ip
= CPP_BUFFER (pfile
);
3177 "cpp internal error: ip->mark != -1 in parse_set_mark");
3179 ip
->mark
= ip
->cur
- ip
->buf
;
3182 /* Clear the current mark - we no longer need it. */
3185 parse_clear_mark (pfile
)
3188 cpp_buffer
*ip
= CPP_BUFFER (pfile
);
3191 "cpp internal error: ip->mark == -1 in parse_clear_mark");
3196 /* Backup the current position of PFILE to that saved in its mark,
3197 and clear the mark. */
3200 parse_goto_mark (pfile
)
3203 cpp_buffer
*ip
= CPP_BUFFER (pfile
);
3206 "cpp internal error: ip->mark == -1 in parse_goto_mark");
3208 ip
->cur
= ip
->buf
+ ip
->mark
;
3213 cpp_print_file_and_line (pfile
)
3216 cpp_buffer
*ip
= cpp_file_buffer (pfile
);
3221 cpp_buf_line_and_col (ip
, &line
, &col
);
3222 cpp_file_line_for_message (pfile
, ip
->nominal_fname
,
3223 line
, pfile
->show_column
? col
: -1);
3228 v_cpp_error (pfile
, msgid
, ap
)
3233 cpp_print_containing_files (pfile
);
3234 cpp_print_file_and_line (pfile
);
3235 v_cpp_message (pfile
, 1, msgid
, ap
);
3239 cpp_error
VPROTO ((cpp_reader
* pfile
, const char *msgid
, ...))
3241 #ifndef ANSI_PROTOTYPES
3247 VA_START(ap
, msgid
);
3249 #ifndef ANSI_PROTOTYPES
3250 pfile
= va_arg (ap
, cpp_reader
*);
3251 msgid
= va_arg (ap
, const char *);
3254 v_cpp_error (pfile
, msgid
, ap
);
3258 /* Print error message but don't count it. */
3261 v_cpp_warning (pfile
, msgid
, ap
)
3266 if (CPP_OPTIONS (pfile
)->inhibit_warnings
)
3269 if (CPP_OPTIONS (pfile
)->warnings_are_errors
)
3272 cpp_print_containing_files (pfile
);
3273 cpp_print_file_and_line (pfile
);
3274 v_cpp_message (pfile
, 0, msgid
, ap
);
3278 cpp_warning
VPROTO ((cpp_reader
* pfile
, const char *msgid
, ...))
3280 #ifndef ANSI_PROTOTYPES
3286 VA_START (ap
, msgid
);
3288 #ifndef ANSI_PROTOTYPES
3289 pfile
= va_arg (ap
, cpp_reader
*);
3290 msgid
= va_arg (ap
, const char *);
3293 v_cpp_warning (pfile
, msgid
, ap
);
3297 /* Print an error message and maybe count it. */
3300 cpp_pedwarn
VPROTO ((cpp_reader
* pfile
, const char *msgid
, ...))
3302 #ifndef ANSI_PROTOTYPES
3308 VA_START (ap
, msgid
);
3310 #ifndef ANSI_PROTOTYPES
3311 pfile
= va_arg (ap
, cpp_reader
*);
3312 msgid
= va_arg (ap
, const char *);
3315 if (CPP_OPTIONS (pfile
)->pedantic_errors
)
3316 v_cpp_error (pfile
, msgid
, ap
);
3318 v_cpp_warning (pfile
, msgid
, ap
);
3323 v_cpp_error_with_line (pfile
, line
, column
, msgid
, ap
)
3330 cpp_buffer
*ip
= cpp_file_buffer (pfile
);
3332 cpp_print_containing_files (pfile
);
3335 cpp_file_line_for_message (pfile
, ip
->nominal_fname
, line
, column
);
3337 v_cpp_message (pfile
, 1, msgid
, ap
);
3341 cpp_error_with_line
VPROTO ((cpp_reader
* pfile
, int line
, int column
,
3342 const char *msgid
, ...))
3344 #ifndef ANSI_PROTOTYPES
3352 VA_START (ap
, msgid
);
3354 #ifndef ANSI_PROTOTYPES
3355 pfile
= va_arg (ap
, cpp_reader
*);
3356 line
= va_arg (ap
, int);
3357 column
= va_arg (ap
, int);
3358 msgid
= va_arg (ap
, const char *);
3361 v_cpp_error_with_line(pfile
, line
, column
, msgid
, ap
);
3366 v_cpp_warning_with_line (pfile
, line
, column
, msgid
, ap
)
3375 if (CPP_OPTIONS (pfile
)->inhibit_warnings
)
3378 if (CPP_OPTIONS (pfile
)->warnings_are_errors
)
3381 cpp_print_containing_files (pfile
);
3383 ip
= cpp_file_buffer (pfile
);
3386 cpp_file_line_for_message (pfile
, ip
->nominal_fname
, line
, column
);
3388 v_cpp_message (pfile
, 0, msgid
, ap
);
3392 cpp_warning_with_line
VPROTO ((cpp_reader
* pfile
, int line
, int column
,
3393 const char *msgid
, ...))
3395 #ifndef ANSI_PROTOTYPES
3403 VA_START (ap
, msgid
);
3405 #ifndef ANSI_PROTOTYPES
3406 pfile
= va_arg (ap
, cpp_reader
*);
3407 line
= va_arg (ap
, int);
3408 column
= va_arg (ap
, int);
3409 msgid
= va_arg (ap
, const char *);
3412 v_cpp_warning_with_line (pfile
, line
, column
, msgid
, ap
);
3417 cpp_pedwarn_with_line
VPROTO ((cpp_reader
* pfile
, int line
, int column
,
3418 const char *msgid
, ...))
3420 #ifndef ANSI_PROTOTYPES
3428 VA_START (ap
, msgid
);
3430 #ifndef ANSI_PROTOTYPES
3431 pfile
= va_arg (ap
, cpp_reader
*);
3432 line
= va_arg (ap
, int);
3433 column
= va_arg (ap
, int);
3434 msgid
= va_arg (ap
, const char *);
3437 if (CPP_OPTIONS (pfile
)->pedantic_errors
)
3438 v_cpp_error_with_line (pfile
, column
, line
, msgid
, ap
);
3440 v_cpp_warning_with_line (pfile
, line
, column
, msgid
, ap
);
3444 /* Report a warning (or an error if pedantic_errors)
3445 giving specified file name and line number, not current. */
3448 cpp_pedwarn_with_file_and_line
VPROTO ((cpp_reader
*pfile
, const char *file
,
3449 int line
, const char *msgid
, ...))
3451 #ifndef ANSI_PROTOTYPES
3459 VA_START (ap
, msgid
);
3461 #ifndef ANSI_PROTOTYPES
3462 pfile
= va_arg (ap
, cpp_reader
*);
3463 file
= va_arg (ap
, const char *);
3464 line
= va_arg (ap
, int);
3465 msgid
= va_arg (ap
, const char *);
3468 if (!CPP_OPTIONS (pfile
)->pedantic_errors
3469 && CPP_OPTIONS (pfile
)->inhibit_warnings
)
3472 cpp_file_line_for_message (pfile
, file
, line
, -1);
3473 v_cpp_message (pfile
, CPP_OPTIONS (pfile
)->pedantic_errors
, msgid
, ap
);
3477 /* my_strerror - return the descriptive text associated with an
3481 my_strerror (errnum
)
3487 #ifndef HAVE_STRERROR
3488 result
= (char *) ((errnum
< sys_nerr
) ? sys_errlist
[errnum
] : 0);
3490 result
= strerror (errnum
);
3493 /* VAXCRTL's strerror() takes an optional second argument, which only
3494 matters when the first argument is EVMSERR. However, it's simplest
3495 just to pass it unconditionally. `vaxc$errno' is declared in
3496 <errno.h>, and maintained by the library in parallel with `errno'.
3497 We assume that caller's `errnum' either matches the last setting of
3498 `errno' by the library or else does not have the value `EVMSERR'. */
3500 result
= strerror (errnum
, vaxc$errno
);
3504 result
= "errno = ?";
3509 /* Error including a message from `errno'. */
3512 cpp_error_from_errno (pfile
, name
)
3516 cpp_message_from_errno (pfile
, 1, name
);
3520 cpp_message_from_errno (pfile
, is_error
, name
)
3526 cpp_buffer
*ip
= cpp_file_buffer (pfile
);
3528 cpp_print_containing_files (pfile
);
3531 cpp_file_line_for_message (pfile
, ip
->nominal_fname
, ip
->lineno
, -1);
3533 cpp_message (pfile
, is_error
, "%s: %s", name
, my_strerror (e
));
3537 cpp_perror_with_name (pfile
, name
)
3541 cpp_message (pfile
, 1, "%s: %s: %s", progname
, name
, my_strerror (errno
));
3545 * No pre-compiled header file support.
3547 * Possibly different enum token codes for each C/C++ token.
3549 * Find and cleanup remaining uses of static variables,
3551 * Support -dM flag (dump_all_macros).
3553 * Support for_lint flag.