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
;
1948 temp
->lineno
= CPP_BUFFER (pfile
)->lineno
;
1950 temp
->next
= pfile
->if_stack
;
1951 temp
->control_macro
= control_macro
;
1952 pfile
->if_stack
= temp
;
1954 pfile
->if_stack
->type
= type
;
1957 skip_if_group (pfile
);
1960 ++pfile
->if_stack
->if_succeeded
;
1961 output_line_command (pfile
, same_file
);
1965 /* Subroutine of skip_if_group. Examine one preprocessing directive and
1966 return 0 if skipping should continue, 1 if it should halt. Also
1967 adjusts the if_stack as appropriate.
1968 The `#' has been read, but not the identifier. */
1971 consider_directive_while_skipping (pfile
, stack
)
1973 IF_STACK_FRAME
*stack
;
1975 long ident_len
, ident
;
1976 const struct directive
*kt
;
1977 IF_STACK_FRAME
*temp
;
1979 cpp_skip_hspace (pfile
);
1981 ident
= CPP_WRITTEN (pfile
);
1982 parse_name (pfile
, GETC());
1983 ident_len
= CPP_WRITTEN (pfile
) - ident
;
1985 CPP_SET_WRITTEN (pfile
, ident
);
1987 for (kt
= directive_table
; kt
->length
>= 0; kt
++)
1988 if (kt
->length
== ident_len
1989 && strncmp (pfile
->token_buffer
+ ident
, kt
->name
, kt
->length
) == 0)
1995 temp
= (IF_STACK_FRAME
*) xmalloc (sizeof (IF_STACK_FRAME
));
1996 temp
->next
= pfile
->if_stack
;
1997 pfile
->if_stack
= temp
;
1998 temp
->fname
= CPP_BUFFER(pfile
)->nominal_fname
;
1999 temp
->type
= kt
->type
;
2003 if (CPP_PEDANTIC (pfile
) && pfile
->if_stack
!= stack
)
2004 validate_else (pfile
, "#else");
2007 if (pfile
->if_stack
->type
== T_ELSE
)
2008 cpp_error (pfile
, "`%s' after `#else'", kt
->name
);
2010 if (pfile
->if_stack
== stack
)
2014 pfile
->if_stack
->type
= kt
->type
;
2019 if (CPP_PEDANTIC (pfile
) && pfile
->if_stack
!= stack
)
2020 validate_else (pfile
, "#endif");
2022 if (pfile
->if_stack
== stack
)
2025 temp
= pfile
->if_stack
;
2026 pfile
->if_stack
= temp
->next
;
2034 /* Don't let erroneous code go by. */
2035 if (!CPP_OPTIONS (pfile
)->lang_asm
&& CPP_PEDANTIC (pfile
))
2036 cpp_pedwarn (pfile
, "invalid preprocessor directive name");
2040 /* skip to #endif, #else, or #elif. adjust line numbers, etc.
2041 * leaves input ptr at the sharp sign found.
2044 skip_if_group (pfile
)
2048 IF_STACK_FRAME
*save_if_stack
= pfile
->if_stack
; /* don't pop past here */
2049 U_CHAR
*beg_of_line
;
2052 if (CPP_OPTIONS (pfile
)->output_conditionals
)
2054 CPP_PUTS (pfile
, "#failed\n", 8);
2056 output_line_command (pfile
, same_file
);
2059 old_written
= CPP_WRITTEN (pfile
);
2063 beg_of_line
= CPP_BUFFER (pfile
)->cur
;
2065 if (! CPP_TRADITIONAL (pfile
))
2066 cpp_skip_hspace (pfile
);
2070 if (CPP_OPTIONS (pfile
)->output_conditionals
)
2071 CPP_PUTC (pfile
, c
);
2072 CPP_BUMP_LINE (pfile
);
2077 if (consider_directive_while_skipping (pfile
, save_if_stack
))
2081 return; /* Caller will issue error. */
2084 if (CPP_OPTIONS (pfile
)->output_conditionals
)
2086 CPP_PUTS (pfile
, beg_of_line
, CPP_BUFFER (pfile
)->cur
- beg_of_line
);
2087 copy_rest_of_line (pfile
);
2091 copy_rest_of_line (pfile
);
2092 CPP_SET_WRITTEN (pfile
, old_written
); /* discard it */
2097 return; /* Caller will issue error. */
2101 if (CPP_OPTIONS (pfile
)->output_conditionals
)
2103 CPP_PUTC (pfile
, c
);
2106 CPP_BUMP_LINE (pfile
);
2110 /* Back up to the beginning of this line. Caller will process the
2112 CPP_BUFFER (pfile
)->cur
= beg_of_line
;
2113 pfile
->only_seen_white
= 1;
2114 if (CPP_OPTIONS (pfile
)->output_conditionals
)
2116 CPP_PUTS (pfile
, "#endfailed\n", 11);
2122 * handle a #else directive. Do this by just continuing processing
2123 * without changing if_stack ; this is so that the error message
2124 * for missing #endif's etc. will point to the original #if. It
2125 * is possible that something different would be better.
2129 do_else (pfile
, keyword
)
2131 const struct directive
*keyword ATTRIBUTE_UNUSED
;
2133 cpp_buffer
*ip
= CPP_BUFFER (pfile
);
2135 if (CPP_PEDANTIC (pfile
))
2136 validate_else (pfile
, "#else");
2137 skip_rest_of_line (pfile
);
2139 if (pfile
->if_stack
== CPP_BUFFER (pfile
)->if_stack
) {
2140 cpp_error (pfile
, "`#else' not within a conditional");
2143 /* #ifndef can't have its special treatment for containing the whole file
2144 if it has a #else clause. */
2145 pfile
->if_stack
->control_macro
= 0;
2147 if (pfile
->if_stack
->type
!= T_IF
&& pfile
->if_stack
->type
!= T_ELIF
) {
2148 cpp_error (pfile
, "`#else' after `#else'");
2149 fprintf (stderr
, " (matches line %d", pfile
->if_stack
->lineno
);
2150 if (strcmp (pfile
->if_stack
->fname
, ip
->nominal_fname
) != 0)
2151 fprintf (stderr
, ", file %s", pfile
->if_stack
->fname
);
2152 fprintf (stderr
, ")\n");
2154 pfile
->if_stack
->type
= T_ELSE
;
2157 if (pfile
->if_stack
->if_succeeded
)
2158 skip_if_group (pfile
);
2160 ++pfile
->if_stack
->if_succeeded
; /* continue processing input */
2161 output_line_command (pfile
, same_file
);
2167 * unstack after #endif command
2171 do_endif (pfile
, keyword
)
2173 const struct directive
*keyword ATTRIBUTE_UNUSED
;
2175 if (CPP_PEDANTIC (pfile
))
2176 validate_else (pfile
, "#endif");
2177 skip_rest_of_line (pfile
);
2179 if (pfile
->if_stack
== CPP_BUFFER (pfile
)->if_stack
)
2180 cpp_error (pfile
, "unbalanced `#endif'");
2183 IF_STACK_FRAME
*temp
= pfile
->if_stack
;
2184 pfile
->if_stack
= temp
->next
;
2185 if (temp
->control_macro
!= 0)
2187 /* This #endif matched a #ifndef at the start of the file.
2188 See if it is at the end of the file. */
2191 parse_set_mark (pfile
);
2195 cpp_skip_hspace (pfile
);
2200 parse_goto_mark (pfile
);
2204 /* This #endif ends a #ifndef
2205 that contains all of the file (aside from whitespace).
2206 Arrange not to include the file again
2207 if the macro that was tested is defined. */
2208 struct cpp_buffer
*ip
;
2209 for (ip
= CPP_BUFFER (pfile
); ; ip
= CPP_PREV_BUFFER (ip
))
2210 if (ip
->fname
!= NULL
)
2212 ip
->ihash
->control_macro
= (char *) temp
->control_macro
;
2216 output_line_command (pfile
, same_file
);
2221 /* When an #else or #endif is found while skipping failed conditional,
2222 if -pedantic was specified, this is called to warn about text after
2223 the command name. P points to the first char after the command name. */
2226 validate_else (pfile
, directive
)
2228 const char *directive
;
2231 cpp_skip_hspace (pfile
);
2233 if (c
!= EOF
&& c
!= '\n')
2235 "text following `%s' violates ANSI standard", directive
);
2238 /* Get the next token, and add it to the text in pfile->token_buffer.
2239 Return the kind of token we got. */
2242 cpp_get_token (pfile
)
2245 register int c
, c2
, c3
;
2246 enum cpp_token token
;
2247 struct cpp_options
*opts
= CPP_OPTIONS (pfile
);
2254 if (CPP_BUFFER (pfile
)->manual_pop
)
2255 /* If we've been reading from redirected input, the
2256 frontend will pop the buffer. */
2258 else if (CPP_BUFFER (pfile
)->seen_eof
)
2260 if (CPP_PREV_BUFFER (CPP_BUFFER (pfile
)) == CPP_NULL_BUFFER (pfile
))
2263 cpp_pop_buffer (pfile
);
2268 cpp_buffer
*next_buf
2269 = CPP_PREV_BUFFER (CPP_BUFFER (pfile
));
2270 CPP_BUFFER (pfile
)->seen_eof
= 1;
2271 if (CPP_BUFFER (pfile
)->nominal_fname
2272 && next_buf
!= CPP_NULL_BUFFER (pfile
))
2274 /* We're about to return from an #include file.
2275 Emit #line information now (as part of the CPP_POP) result.
2276 But the #line refers to the file we will pop to. */
2277 cpp_buffer
*cur_buffer
= CPP_BUFFER (pfile
);
2278 CPP_BUFFER (pfile
) = next_buf
;
2279 pfile
->input_stack_listing_current
= 0;
2280 output_line_command (pfile
, leave_file
);
2281 CPP_BUFFER (pfile
) = cur_buffer
;
2291 if (PEEKC () == '=')
2295 if (opts
->put_out_comments
)
2296 c
= copy_comment (pfile
, c
);
2298 c
= skip_comment (pfile
, c
);
2304 /* Comments are equivalent to spaces.
2305 For -traditional, a comment is equivalent to nothing. */
2306 if (opts
->traditional
|| opts
->put_out_comments
)
2310 CPP_PUTC (pfile
, c
);
2314 if (opts
->for_lint
) {
2317 char *lintcmd
= get_lintcmd (ibp
, limit
, &argbp
, &arglen
, &cmdlen
);
2319 if (lintcmd
!= NULL
) {
2320 /* I believe it is always safe to emit this newline: */
2322 bcopy ("#pragma lint ", (char *) obp
, 13);
2324 bcopy (lintcmd
, (char *) obp
, cmdlen
);
2329 bcopy (argbp
, (char *) obp
, arglen
);
2333 /* OK, now bring us back to the state we were in before we entered
2334 this branch. We need #line because the newline for the pragma
2335 could mess things up. */
2336 output_line_command (pfile
, same_file
);
2337 *(obp
++) = ' '; /* just in case, if comments are copied thru */
2345 /* If this is expanding a macro definition, don't recognize
2346 preprocessor directives. */
2349 /* If this is expand_into_temp_buffer, recognize them
2350 only after an actual newline at this level,
2351 not at the beginning of the input level. */
2352 if (ip
->fname
== 0 && beg_of_line
== ip
->buf
)
2358 if (!pfile
->only_seen_white
)
2360 if (handle_directive (pfile
))
2361 return CPP_DIRECTIVE
;
2362 pfile
->only_seen_white
= 0;
2368 parse_string (pfile
, c
);
2369 pfile
->only_seen_white
= 0;
2370 return c
== '\'' ? CPP_CHAR
: CPP_STRING
;
2373 if (!opts
->dollars_in_ident
)
2378 if (opts
->cplusplus
&& PEEKC () == ':')
2386 if (c2
== c
|| c2
== '=')
2395 if (PEEKC () == '=')
2401 if (c2
== '-' && opts
->chill
)
2402 goto comment
; /* Chill style comment */
2403 if (c2
== '-' || c2
== '=')
2407 if (opts
->cplusplus
&& PEEKN (1) == '*')
2409 /* In C++, there's a ->* operator. */
2411 pfile
->only_seen_white
= 0;
2412 CPP_RESERVE (pfile
, 4);
2413 CPP_PUTC_Q (pfile
, c
);
2414 CPP_PUTC_Q (pfile
, GETC ());
2415 CPP_PUTC_Q (pfile
, GETC ());
2416 CPP_NUL_TERMINATE_Q (pfile
);
2424 if (pfile
->parsing_include_directive
)
2428 CPP_PUTC (pfile
, c
);
2432 if (c
== '\n' || c
== EOF
)
2435 "missing '>' in `#include <FILENAME>'");
2440 if (!CPP_BUFFER (pfile
)->has_escapes
)
2442 /* Backslash newline is replaced by nothing. */
2443 CPP_ADJUST_WRITTEN (pfile
, -1);
2444 CPP_BUMP_LINE (pfile
);
2448 /* We might conceivably get \r- or \r<space> in
2449 here. Just delete 'em. */
2451 if (d
!= '-' && d
!= ' ')
2453 "internal error: unrecognized escape \\r%c",
2455 CPP_ADJUST_WRITTEN (pfile
, -1);
2461 /* else fall through */
2466 /* GNU C++ supports MIN and MAX operators <? and >?. */
2467 if (c2
!= c
&& (!opts
->cplusplus
|| c2
!= '?'))
2470 CPP_RESERVE (pfile
, 4);
2471 CPP_PUTC (pfile
, c
);
2472 CPP_PUTC (pfile
, c2
);
2475 CPP_PUTC_Q (pfile
, GETC ());
2476 CPP_NUL_TERMINATE_Q (pfile
);
2477 pfile
->only_seen_white
= 0;
2484 CPP_RESERVE(pfile
, 2);
2485 CPP_PUTC_Q (pfile
, '.');
2490 /* In C++ there's a .* operator. */
2491 if (opts
->cplusplus
&& c2
== '*')
2494 if (c2
== '.' && PEEKN(1) == '.')
2496 CPP_RESERVE(pfile
, 4);
2497 CPP_PUTC_Q (pfile
, '.');
2498 CPP_PUTC_Q (pfile
, '.');
2499 CPP_PUTC_Q (pfile
, '.');
2501 CPP_NUL_TERMINATE_Q (pfile
);
2502 pfile
->only_seen_white
= 0;
2509 pfile
->only_seen_white
= 0;
2510 CPP_RESERVE(pfile
, 3);
2511 CPP_PUTC_Q (pfile
, c
);
2512 CPP_PUTC_Q (pfile
, GETC ());
2513 CPP_NUL_TERMINATE_Q (pfile
);
2518 if ((c2
== '\'' || c2
== '\"') && !CPP_TRADITIONAL (pfile
))
2520 CPP_PUTC (pfile
, c
);
2526 case '0': case '1': case '2': case '3': case '4':
2527 case '5': case '6': case '7': case '8': case '9':
2532 CPP_RESERVE (pfile
, 2);
2533 CPP_PUTC_Q (pfile
, c
);
2537 if (!is_idchar
[c
] && c
!= '.'
2538 && ((c2
!= 'e' && c2
!= 'E'
2539 && ((c2
!= 'p' && c2
!= 'P') || CPP_C89 (pfile
)))
2540 || (c
!= '+' && c
!= '-')))
2545 CPP_NUL_TERMINATE_Q (pfile
);
2546 pfile
->only_seen_white
= 0;
2548 case 'b': case 'c': case 'd': case 'h': case 'o':
2549 case 'B': case 'C': case 'D': case 'H': case 'O':
2550 if (opts
->chill
&& PEEKC () == '\'')
2552 pfile
->only_seen_white
= 0;
2553 CPP_RESERVE (pfile
, 2);
2554 CPP_PUTC_Q (pfile
, c
);
2555 CPP_PUTC_Q (pfile
, '\'');
2561 goto chill_number_eof
;
2564 CPP_PUTC (pfile
, c
);
2568 CPP_RESERVE (pfile
, 2);
2569 CPP_PUTC_Q (pfile
, c
);
2570 CPP_NUL_TERMINATE_Q (pfile
);
2577 CPP_NUL_TERMINATE (pfile
);
2584 case 'a': case 'e': case 'f': case 'g': case 'i': case 'j':
2585 case 'k': case 'l': case 'm': case 'n': case 'p': case 'q':
2586 case 'r': case 's': case 't': case 'u': case 'v': case 'w':
2587 case 'x': case 'y': case 'z':
2588 case 'A': case 'E': case 'F': case 'G': case 'I': case 'J':
2589 case 'K': case 'M': case 'N': case 'P': case 'Q': case 'R':
2590 case 'S': case 'T': case 'U': case 'V': case 'W': case 'X':
2595 unsigned char *ident
;
2596 int before_name_written
= CPP_WRITTEN (pfile
);
2598 parse_name (pfile
, c
);
2599 pfile
->only_seen_white
= 0;
2600 if (pfile
->no_macro_expand
)
2602 ident
= pfile
->token_buffer
+ before_name_written
;
2603 ident_len
= CPP_PWRITTEN (pfile
) - ident
;
2604 hp
= cpp_lookup (pfile
, ident
, ident_len
, -1);
2607 if (hp
->type
== T_DISABLED
)
2609 if (pfile
->output_escapes
)
2610 { /* Return "\r-IDENT", followed by '\0'. */
2612 CPP_RESERVE (pfile
, 3);
2613 ident
= pfile
->token_buffer
+ before_name_written
;
2614 CPP_ADJUST_WRITTEN (pfile
, 2);
2615 for (i
= ident_len
; i
>= 0; i
--) ident
[i
+2] = ident
[i
];
2622 /* If macro wants an arglist, verify that a '(' follows.
2623 first skip all whitespace, copying it to the output
2624 after the macro name. Then, if there is no '(',
2625 decide this is not a macro call and leave things that way. */
2626 if (hp
->type
== T_MACRO
&& hp
->value
.defn
->nargs
>= 0)
2628 int is_macro_call
, macbuf_whitespace
= 0;
2630 parse_set_mark (pfile
);
2633 cpp_skip_hspace (pfile
);
2635 is_macro_call
= c
== '(';
2644 if (CPP_IS_MACRO_BUFFER (CPP_BUFFER (pfile
)))
2646 if (CPP_BUFFER (pfile
)->mark
!=
2647 (CPP_BUFFER (pfile
)->cur
2648 - CPP_BUFFER (pfile
)->buf
))
2649 macbuf_whitespace
= 1;
2651 /* The mark goes away automatically when
2652 the buffer is popped. */
2653 cpp_pop_buffer (pfile
);
2654 parse_set_mark (pfile
);
2662 parse_goto_mark (pfile
);
2663 if (macbuf_whitespace
)
2664 CPP_PUTC (pfile
, ' ');
2667 parse_clear_mark (pfile
);
2671 /* This is now known to be a macro call.
2672 Expand the macro, reading arguments as needed,
2673 and push the expansion on the input stack. */
2674 macroexpand (pfile
, hp
);
2675 CPP_SET_WRITTEN (pfile
, before_name_written
);
2679 case ' ': case '\t': case '\v':
2682 CPP_PUTC (pfile
, c
);
2684 if (c
== EOF
|| !is_hor_space
[c
])
2691 if (CPP_BUFFER (pfile
)->has_escapes
)
2696 if (pfile
->output_escapes
)
2697 CPP_PUTS (pfile
, "\r-", 2);
2698 parse_name (pfile
, GETC ());
2703 CPP_RESERVE (pfile
, 2);
2704 if (pfile
->output_escapes
)
2705 CPP_PUTC_Q (pfile
, '\r');
2706 CPP_PUTC_Q (pfile
, c
);
2712 "internal error: unrecognized escape \\r%c", c
);
2718 /* Backslash newline is ignored. */
2719 CPP_BUMP_LINE (pfile
);
2724 CPP_PUTC (pfile
, c
);
2725 if (pfile
->only_seen_white
== 0)
2726 pfile
->only_seen_white
= 1;
2727 CPP_BUMP_LINE (pfile
);
2728 if (! CPP_OPTIONS (pfile
)->no_line_commands
)
2731 if (CPP_BUFFER (pfile
)->lineno
!= pfile
->lineno
)
2732 output_line_command (pfile
, same_file
);
2736 case '(': token
= CPP_LPAREN
; goto char1
;
2737 case ')': token
= CPP_RPAREN
; goto char1
;
2738 case '{': token
= CPP_LBRACE
; goto char1
;
2739 case '}': token
= CPP_RBRACE
; goto char1
;
2740 case ',': token
= CPP_COMMA
; goto char1
;
2741 case ';': token
= CPP_SEMICOLON
; goto char1
;
2747 pfile
->only_seen_white
= 0;
2748 CPP_PUTC (pfile
, c
);
2754 /* Like cpp_get_token, but skip spaces and comments. */
2757 cpp_get_non_space_token (pfile
)
2760 int old_written
= CPP_WRITTEN (pfile
);
2763 enum cpp_token token
= cpp_get_token (pfile
);
2764 if (token
!= CPP_COMMENT
&& token
!= CPP_POP
2765 && token
!= CPP_HSPACE
&& token
!= CPP_VSPACE
)
2767 CPP_SET_WRITTEN (pfile
, old_written
);
2771 /* Parse an identifier starting with C. */
2774 parse_name (pfile
, c
)
2786 if (c
== '$' && CPP_PEDANTIC (pfile
))
2787 cpp_pedwarn (pfile
, "`$' in identifier");
2789 CPP_RESERVE(pfile
, 2); /* One more for final NUL. */
2790 CPP_PUTC_Q (pfile
, c
);
2795 CPP_NUL_TERMINATE_Q (pfile
);
2799 /* Parse a string starting with C. A single quoted string is treated
2800 like a double -- some programs (e.g., troff) are perverse this way.
2801 (However, a single quoted string is not allowed to extend over
2804 parse_string (pfile
, c
)
2808 long start_line
, start_column
;
2810 cpp_buf_line_and_col (cpp_file_buffer (pfile
), &start_line
, &start_column
);
2812 CPP_PUTC (pfile
, c
);
2818 if (CPP_IS_MACRO_BUFFER (CPP_BUFFER (pfile
)))
2820 /* try harder: this string crosses a macro expansion
2821 boundary. This can happen naturally if -traditional.
2822 Otherwise, only -D can make a macro with an unmatched
2824 cpp_pop_buffer (pfile
);
2827 if (!CPP_TRADITIONAL (pfile
))
2829 cpp_error_with_line (pfile
, start_line
, start_column
,
2830 "unterminated string or character constant");
2831 if (pfile
->multiline_string_line
!= start_line
2832 && pfile
->multiline_string_line
!= 0)
2833 cpp_error_with_line (pfile
,
2834 pfile
->multiline_string_line
, -1,
2835 "possible real start of unterminated constant");
2836 pfile
->multiline_string_line
= 0;
2840 CPP_PUTC (pfile
, cc
);
2844 CPP_BUMP_LINE (pfile
);
2846 /* Traditionally, end of line ends a string constant with
2848 if (CPP_TRADITIONAL (pfile
))
2850 /* Character constants may not extend over multiple lines. */
2853 cpp_error_with_line (pfile
, start_line
, start_column
,
2854 "unterminated character constant");
2857 if (CPP_PEDANTIC (pfile
) && pfile
->multiline_string_line
== 0)
2859 cpp_pedwarn_with_line (pfile
, start_line
, start_column
,
2860 "string constant runs past end of line");
2862 if (pfile
->multiline_string_line
== 0)
2863 pfile
->multiline_string_line
= start_line
;
2867 CPP_ADJUST_WRITTEN (pfile
, -1);
2868 if (CPP_BUFFER (pfile
)->has_escapes
)
2871 "internal error: \\r escape inside string constant");
2875 /* Backslash newline is replaced by nothing at all. */
2876 CPP_BUMP_LINE (pfile
);
2882 CPP_PUTC (pfile
, cc
);
2894 /* Read an assertion into the token buffer, converting to
2895 canonical form: `#predicate(a n swe r)' The next non-whitespace
2896 character to read should be the first letter of the predicate.
2897 Returns 0 for syntax error, 1 for bare predicate, 2 for predicate
2898 with answer (see callers for why). In case of 0, an error has been
2901 parse_assertion (pfile
)
2905 cpp_skip_hspace (pfile
);
2907 if (! is_idstart
[c
])
2909 cpp_error (pfile
, "assertion predicate is not an identifier");
2912 CPP_PUTC(pfile
, '#');
2914 parse_name(pfile
, c
);
2919 if (is_hor_space
[c
] || c
== '\r')
2920 cpp_skip_hspace (pfile
);
2926 CPP_PUTC(pfile
, '(');
2929 while ((c
= GETC()) != ')')
2931 if (is_hor_space
[c
])
2935 CPP_PUTC(pfile
, ' ');
2939 else if (c
== '\n' || c
== EOF
)
2941 if (c
== '\n') FORWARD(-1);
2942 cpp_error (pfile
, "un-terminated assertion answer");
2946 /* \r cannot be a macro escape here. */
2947 CPP_BUMP_LINE (pfile
);
2950 CPP_PUTC (pfile
, c
);
2955 if (pfile
->limit
[-1] == ' ')
2956 pfile
->limit
[-1] = ')';
2957 else if (pfile
->limit
[-1] == '(')
2959 cpp_error (pfile
, "empty token sequence in assertion");
2963 CPP_PUTC (pfile
, ')');
2965 CPP_NUL_TERMINATE (pfile
);
2970 do_assert (pfile
, keyword
)
2972 const struct directive
*keyword ATTRIBUTE_UNUSED
;
2976 HASHNODE
*base
, *this;
2977 int baselen
, thislen
;
2979 if (CPP_PEDANTIC (pfile
) && CPP_OPTIONS (pfile
)->done_initializing
2980 && !CPP_BUFFER (pfile
)->system_header_p
)
2981 cpp_pedwarn (pfile
, "ANSI C does not allow `#assert'");
2983 cpp_skip_hspace (pfile
);
2984 sym
= (char *) CPP_PWRITTEN (pfile
); /* remember where it starts */
2985 ret
= parse_assertion (pfile
);
2990 cpp_error (pfile
, "missing token-sequence in `#assert'");
2994 cpp_skip_hspace (pfile
);
2996 if (c
!= EOF
&& c
!= '\n')
2998 cpp_error (pfile
, "junk at end of `#assert'");
3002 thislen
= strlen (sym
);
3003 baselen
= index (sym
, '(') - sym
;
3004 this = cpp_lookup (pfile
, sym
, thislen
, -1);
3007 cpp_warning (pfile
, "`%s' re-asserted", sym
);
3011 base
= cpp_lookup (pfile
, sym
, baselen
, -1);
3013 base
= cpp_install (pfile
, sym
, baselen
, T_ASSERT
, 0, -1);
3014 else if (base
->type
!= T_ASSERT
)
3016 /* Token clash - but with what?! */
3018 "cpp internal error: base->type != T_ASSERT in do_assert");
3022 this = cpp_install (pfile
, sym
, thislen
, T_ASSERT
,
3023 (char *)base
->value
.aschain
, -1);
3024 base
->value
.aschain
= this;
3026 pfile
->limit
= (unsigned char *) sym
; /* Pop */
3030 skip_rest_of_line (pfile
);
3031 pfile
->limit
= (unsigned char *) sym
; /* Pop */
3036 do_unassert (pfile
, keyword
)
3038 const struct directive
*keyword ATTRIBUTE_UNUSED
;
3042 long baselen
, thislen
;
3043 HASHNODE
*base
, *this, *next
;
3045 if (CPP_PEDANTIC (pfile
) && CPP_OPTIONS (pfile
)->done_initializing
3046 && !CPP_BUFFER (pfile
)->system_header_p
)
3047 cpp_pedwarn (pfile
, "ANSI C does not allow `#unassert'");
3049 cpp_skip_hspace (pfile
);
3051 sym
= (char *) CPP_PWRITTEN (pfile
); /* remember where it starts */
3052 ret
= parse_assertion (pfile
);
3056 cpp_skip_hspace (pfile
);
3058 if (c
!= EOF
&& c
!= '\n')
3059 cpp_error (pfile
, "junk at end of `#unassert'");
3061 thislen
= strlen (sym
);
3064 base
= cpp_lookup (pfile
, sym
, thislen
, -1);
3066 goto error
; /* It isn't an error to #undef what isn't #defined,
3067 so it isn't an error to #unassert what isn't
3068 #asserted either. */
3070 for (this = base
->value
.aschain
; this; this = next
)
3072 next
= this->value
.aschain
;
3073 delete_macro (this);
3075 delete_macro (base
);
3079 baselen
= index (sym
, '(') - sym
;
3080 base
= cpp_lookup (pfile
, sym
, baselen
, -1);
3081 if (! base
) goto error
;
3082 this = cpp_lookup (pfile
, sym
, thislen
, -1);
3083 if (! this) goto error
;
3086 while (next
->value
.aschain
!= this)
3087 next
= next
->value
.aschain
;
3089 next
->value
.aschain
= this->value
.aschain
;
3090 delete_macro (this);
3092 if (base
->value
.aschain
== NULL
)
3093 delete_macro (base
); /* Last answer for this predicate deleted. */
3096 pfile
->limit
= (unsigned char *) sym
; /* Pop */
3099 skip_rest_of_line (pfile
);
3100 pfile
->limit
= (unsigned char *) sym
; /* Pop */
3104 /* Process STR as if it appeared as the body of an #unassert. */
3106 cpp_unassert (pfile
, str
)
3110 if (cpp_push_buffer (pfile
, str
, strlen (str
)) != NULL
)
3112 do_assert (pfile
, NULL
);
3113 cpp_pop_buffer (pfile
);
3118 cpp_read_check_assertion (pfile
)
3121 U_CHAR
*name
= CPP_PWRITTEN (pfile
);
3125 FORWARD (1); /* Skip '#' */
3126 cpp_skip_hspace (pfile
);
3127 if (! parse_assertion (pfile
))
3131 hp
= cpp_lookup (pfile
, name
, CPP_PWRITTEN (pfile
) - name
, -1);
3135 pfile
->limit
= name
;
3139 /* Remember the current position of PFILE. */
3142 parse_set_mark (pfile
)
3145 cpp_buffer
*ip
= CPP_BUFFER (pfile
);
3148 "cpp internal error: ip->mark != -1 in parse_set_mark");
3150 ip
->mark
= ip
->cur
- ip
->buf
;
3153 /* Clear the current mark - we no longer need it. */
3156 parse_clear_mark (pfile
)
3159 cpp_buffer
*ip
= CPP_BUFFER (pfile
);
3162 "cpp internal error: ip->mark == -1 in parse_clear_mark");
3167 /* Backup the current position of PFILE to that saved in its mark,
3168 and clear the mark. */
3171 parse_goto_mark (pfile
)
3174 cpp_buffer
*ip
= CPP_BUFFER (pfile
);
3177 "cpp internal error: ip->mark == -1 in parse_goto_mark");
3179 ip
->cur
= ip
->buf
+ ip
->mark
;
3184 cpp_print_file_and_line (pfile
)
3187 cpp_buffer
*ip
= cpp_file_buffer (pfile
);
3192 cpp_buf_line_and_col (ip
, &line
, &col
);
3193 cpp_file_line_for_message (pfile
, ip
->nominal_fname
,
3194 line
, pfile
->show_column
? col
: -1);
3199 v_cpp_error (pfile
, msgid
, ap
)
3204 cpp_print_containing_files (pfile
);
3205 cpp_print_file_and_line (pfile
);
3206 v_cpp_message (pfile
, 1, msgid
, ap
);
3210 cpp_error
VPROTO ((cpp_reader
* pfile
, const char *msgid
, ...))
3212 #ifndef ANSI_PROTOTYPES
3218 VA_START(ap
, msgid
);
3220 #ifndef ANSI_PROTOTYPES
3221 pfile
= va_arg (ap
, cpp_reader
*);
3222 msgid
= va_arg (ap
, const char *);
3225 v_cpp_error (pfile
, msgid
, ap
);
3229 /* Print error message but don't count it. */
3232 v_cpp_warning (pfile
, msgid
, ap
)
3237 if (CPP_OPTIONS (pfile
)->inhibit_warnings
)
3240 if (CPP_OPTIONS (pfile
)->warnings_are_errors
)
3243 cpp_print_containing_files (pfile
);
3244 cpp_print_file_and_line (pfile
);
3245 v_cpp_message (pfile
, 0, msgid
, ap
);
3249 cpp_warning
VPROTO ((cpp_reader
* pfile
, const char *msgid
, ...))
3251 #ifndef ANSI_PROTOTYPES
3257 VA_START (ap
, msgid
);
3259 #ifndef ANSI_PROTOTYPES
3260 pfile
= va_arg (ap
, cpp_reader
*);
3261 msgid
= va_arg (ap
, const char *);
3264 v_cpp_warning (pfile
, msgid
, ap
);
3268 /* Print an error message and maybe count it. */
3271 cpp_pedwarn
VPROTO ((cpp_reader
* pfile
, const char *msgid
, ...))
3273 #ifndef ANSI_PROTOTYPES
3279 VA_START (ap
, msgid
);
3281 #ifndef ANSI_PROTOTYPES
3282 pfile
= va_arg (ap
, cpp_reader
*);
3283 msgid
= va_arg (ap
, const char *);
3286 if (CPP_OPTIONS (pfile
)->pedantic_errors
)
3287 v_cpp_error (pfile
, msgid
, ap
);
3289 v_cpp_warning (pfile
, msgid
, ap
);
3294 v_cpp_error_with_line (pfile
, line
, column
, msgid
, ap
)
3301 cpp_buffer
*ip
= cpp_file_buffer (pfile
);
3303 cpp_print_containing_files (pfile
);
3306 cpp_file_line_for_message (pfile
, ip
->nominal_fname
, line
, column
);
3308 v_cpp_message (pfile
, 1, msgid
, ap
);
3312 cpp_error_with_line
VPROTO ((cpp_reader
* pfile
, int line
, int column
,
3313 const char *msgid
, ...))
3315 #ifndef ANSI_PROTOTYPES
3323 VA_START (ap
, msgid
);
3325 #ifndef ANSI_PROTOTYPES
3326 pfile
= va_arg (ap
, cpp_reader
*);
3327 line
= va_arg (ap
, int);
3328 column
= va_arg (ap
, int);
3329 msgid
= va_arg (ap
, const char *);
3332 v_cpp_error_with_line(pfile
, line
, column
, msgid
, ap
);
3337 v_cpp_warning_with_line (pfile
, line
, column
, msgid
, ap
)
3346 if (CPP_OPTIONS (pfile
)->inhibit_warnings
)
3349 if (CPP_OPTIONS (pfile
)->warnings_are_errors
)
3352 cpp_print_containing_files (pfile
);
3354 ip
= cpp_file_buffer (pfile
);
3357 cpp_file_line_for_message (pfile
, ip
->nominal_fname
, line
, column
);
3359 v_cpp_message (pfile
, 0, msgid
, ap
);
3363 cpp_warning_with_line
VPROTO ((cpp_reader
* pfile
, int line
, int column
,
3364 const char *msgid
, ...))
3366 #ifndef ANSI_PROTOTYPES
3374 VA_START (ap
, msgid
);
3376 #ifndef ANSI_PROTOTYPES
3377 pfile
= va_arg (ap
, cpp_reader
*);
3378 line
= va_arg (ap
, int);
3379 column
= va_arg (ap
, int);
3380 msgid
= va_arg (ap
, const char *);
3383 v_cpp_warning_with_line (pfile
, line
, column
, msgid
, ap
);
3388 cpp_pedwarn_with_line
VPROTO ((cpp_reader
* pfile
, int line
, int column
,
3389 const char *msgid
, ...))
3391 #ifndef ANSI_PROTOTYPES
3399 VA_START (ap
, msgid
);
3401 #ifndef ANSI_PROTOTYPES
3402 pfile
= va_arg (ap
, cpp_reader
*);
3403 line
= va_arg (ap
, int);
3404 column
= va_arg (ap
, int);
3405 msgid
= va_arg (ap
, const char *);
3408 if (CPP_OPTIONS (pfile
)->pedantic_errors
)
3409 v_cpp_error_with_line (pfile
, column
, line
, msgid
, ap
);
3411 v_cpp_warning_with_line (pfile
, line
, column
, msgid
, ap
);
3415 /* Report a warning (or an error if pedantic_errors)
3416 giving specified file name and line number, not current. */
3419 cpp_pedwarn_with_file_and_line
VPROTO ((cpp_reader
*pfile
, const char *file
,
3420 int line
, const char *msgid
, ...))
3422 #ifndef ANSI_PROTOTYPES
3430 VA_START (ap
, msgid
);
3432 #ifndef ANSI_PROTOTYPES
3433 pfile
= va_arg (ap
, cpp_reader
*);
3434 file
= va_arg (ap
, const char *);
3435 line
= va_arg (ap
, int);
3436 msgid
= va_arg (ap
, const char *);
3439 if (!CPP_OPTIONS (pfile
)->pedantic_errors
3440 && CPP_OPTIONS (pfile
)->inhibit_warnings
)
3443 cpp_file_line_for_message (pfile
, file
, line
, -1);
3444 v_cpp_message (pfile
, CPP_OPTIONS (pfile
)->pedantic_errors
, msgid
, ap
);
3448 /* my_strerror - return the descriptive text associated with an
3452 my_strerror (errnum
)
3458 #ifndef HAVE_STRERROR
3459 result
= (char *) ((errnum
< sys_nerr
) ? sys_errlist
[errnum
] : 0);
3461 result
= strerror (errnum
);
3464 /* VAXCRTL's strerror() takes an optional second argument, which only
3465 matters when the first argument is EVMSERR. However, it's simplest
3466 just to pass it unconditionally. `vaxc$errno' is declared in
3467 <errno.h>, and maintained by the library in parallel with `errno'.
3468 We assume that caller's `errnum' either matches the last setting of
3469 `errno' by the library or else does not have the value `EVMSERR'. */
3471 result
= strerror (errnum
, vaxc$errno
);
3475 result
= "errno = ?";
3480 /* Error including a message from `errno'. */
3483 cpp_error_from_errno (pfile
, name
)
3487 cpp_message_from_errno (pfile
, 1, name
);
3491 cpp_message_from_errno (pfile
, is_error
, name
)
3497 cpp_buffer
*ip
= cpp_file_buffer (pfile
);
3499 cpp_print_containing_files (pfile
);
3502 cpp_file_line_for_message (pfile
, ip
->nominal_fname
, ip
->lineno
, -1);
3504 cpp_message (pfile
, is_error
, "%s: %s", name
, my_strerror (e
));
3508 cpp_perror_with_name (pfile
, name
)
3512 cpp_message (pfile
, 1, "%s: %s: %s", progname
, name
, my_strerror (errno
));
3516 * No pre-compiled header file support.
3518 * Possibly different enum token codes for each C/C++ token.
3520 * Find and cleanup remaining uses of static variables,
3522 * Support -dM flag (dump_all_macros).
3524 * Support for_lint flag.