* Makefile.in (cppexp.o): Depend on cpphash.h.
[official-gcc.git] / gcc / cpplib.c
blobe274df9d2343f45e4c036f441d6e5a6589b13680
1 /* CPP Library.
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
10 later version.
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. */
21 #include "config.h"
22 #include "system.h"
24 #include "cpplib.h"
25 #include "cpphash.h"
26 #include "intl.h"
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. */
59 struct directive {
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 *));
83 #ifdef SCCS_DIRECTIVE
84 static int do_sccs PARAMS ((cpp_reader *, const struct directive *));
85 #endif
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[] = {
115 /* In C89 */
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? */
138 #endif
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. */
145 void
146 quote_string (pfile, src)
147 cpp_reader *pfile;
148 const char *src;
150 U_CHAR c;
152 CPP_PUTC_Q (pfile, '\"');
153 for (;;)
154 switch ((c = *src++))
156 default:
157 if (ISPRINT (c))
158 CPP_PUTC_Q (pfile, c);
159 else
161 sprintf ((char *)CPP_PWRITTEN (pfile), "\\%03o", c);
162 CPP_ADJUST_WRITTEN (pfile, 4);
164 break;
166 case '\"':
167 case '\\':
168 CPP_PUTC_Q (pfile, '\\');
169 CPP_PUTC_Q (pfile, c);
170 break;
172 case '\0':
173 CPP_PUTC_Q (pfile, '\"');
174 CPP_NUL_TERMINATE_Q (pfile);
175 return;
179 /* Re-allocates PFILE->token_buffer so it will hold at least N more chars. */
181 void
182 cpp_grow_buffer (pfile, n)
183 cpp_reader *pfile;
184 long 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. */
198 void
199 cpp_define (pfile, str)
200 cpp_reader *pfile;
201 U_CHAR *str;
203 U_CHAR *buf, *p;
204 size_t count;
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, '=');
213 if (p)
215 *p = ' ';
216 count -= 2;
218 else
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. */
229 void
230 cpp_assert (pfile, str)
231 cpp_reader *pfile;
232 U_CHAR *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;
246 return CPP_EOF;
249 static int
250 null_cleanup (pbuf, pfile)
251 cpp_buffer *pbuf ATTRIBUTE_UNUSED;
252 cpp_reader *pfile ATTRIBUTE_UNUSED;
254 return 0;
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
261 '/' or '-'). */
263 static int
264 skip_comment (pfile, m)
265 cpp_reader *pfile;
266 int m;
268 if (m == '/' && PEEKC() == '*')
270 int c, prev_c = -1;
271 long line, col;
273 FORWARD(1);
274 cpp_buf_line_and_col (CPP_BUFFER (pfile), &line, &col);
275 for (;;)
277 c = GETC ();
278 if (c == EOF)
280 cpp_error_with_line (pfile, line, col, "unterminated comment");
281 return EOF;
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 == '*')
287 return ' ';
288 else if (c == '*' && prev_c == '/'
289 && CPP_OPTIONS (pfile)->warn_comments)
290 cpp_warning (pfile, "`/*' within comment");
292 prev_c = c;
295 else if ((m == '/' && PEEKC() == '/'
296 && CPP_OPTIONS (pfile)->cplusplus_comments)
297 || (m == '-' && PEEKC() == '-'
298 && CPP_OPTIONS (pfile)->chill))
300 FORWARD(1);
301 for (;;)
303 int c = GETC ();
304 if (c == EOF)
305 return ' '; /* Allow // to be terminated by EOF. */
306 if (c == '\n')
308 /* Don't consider final '\n' to be part of comment. */
309 FORWARD(-1);
310 return ' ';
312 else if (c == '\r')
313 /* \r cannot be a macro escape marker here. */
314 CPP_BUMP_LINE (pfile);
317 else
318 return m;
321 /* Identical to skip_comment except that it copies the comment into the
322 token_buffer. This is used if put_out_comments. */
323 static int
324 copy_comment (pfile, m)
325 cpp_reader *pfile;
326 int m;
328 if (m == '/' && PEEKC() == '*')
330 int c, prev_c = -1;
331 long line, col;
333 CPP_PUTC (pfile, '/');
334 CPP_PUTC (pfile, '*');
335 FORWARD(1);
336 cpp_buf_line_and_col (CPP_BUFFER (pfile), &line, &col);
337 for (;;)
339 c = GETC ();
340 if (c == EOF)
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. */
345 return ' ';
347 else if (c == '\r')
349 /* \r cannot be a macro escape marker here. */
350 CPP_BUMP_LINE (pfile);
351 continue;
354 CPP_PUTC (pfile, c);
355 if (c == '\n')
357 pfile->lineno++;
358 CPP_BUMP_LINE (pfile);
360 else if (c == '/' && prev_c == '*')
361 return ' ';
362 else if (c == '*' && prev_c == '/'
363 && CPP_OPTIONS (pfile)->warn_comments)
364 cpp_warning (pfile, "`/*' within comment");
366 prev_c = c;
369 else if ((m == '/' && PEEKC() == '/'
370 && CPP_OPTIONS (pfile)->cplusplus_comments)
371 || (m == '-' && PEEKC() == '-'
372 && CPP_OPTIONS (pfile)->chill))
374 CPP_PUTC (pfile, m);
375 CPP_PUTC (pfile, m);
376 FORWARD(1);
377 for (;;)
379 int c = GETC ();
380 if (c == EOF)
381 return ' '; /* Allow line comments to be terminated by EOF. */
382 else if (c == '\n')
384 /* Don't consider final '\n' to be part of comment. */
385 FORWARD(-1);
386 return ' ';
388 else if (c == '\r')
389 /* \r cannot be a macro escape marker here. */
390 CPP_BUMP_LINE (pfile);
392 CPP_PUTC (pfile, c);
395 else
396 return m;
400 /* Skip whitespace \-newline and comments. Does not macro-expand. */
402 void
403 cpp_skip_hspace (pfile)
404 cpp_reader *pfile;
406 int c;
407 while (1)
409 c = GETC();
410 if (c == EOF)
411 return;
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");
418 else if (c == '\r')
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)
424 if (PEEKC() == ' ')
425 FORWARD(1);
426 else
427 break;
429 else
430 CPP_BUFFER (pfile)->lineno++;
432 else if (c == '/' || c == '-')
434 c = skip_comment (pfile, c);
435 if (c == EOF)
436 return;
437 else if (c != ' ')
438 break;
440 else
441 break;
443 FORWARD(-1);
446 /* Read the rest of the current line.
447 The line is appended to PFILE's output buffer. */
449 static void
450 copy_rest_of_line (pfile)
451 cpp_reader *pfile;
453 for (;;)
455 int c = GETC();
456 switch (c)
458 case '\n':
459 FORWARD(-1);
460 case EOF:
461 CPP_NUL_TERMINATE (pfile);
462 return;
464 case '\r':
465 if (CPP_BUFFER (pfile)->has_escapes)
466 break;
467 else
469 CPP_BUFFER (pfile)->lineno++;
470 continue;
472 case '\'':
473 case '\"':
474 parse_string (pfile, c);
475 continue;
476 case '/':
477 if (PEEKC() == '*' && CPP_TRADITIONAL (pfile))
479 CPP_PUTS (pfile, "/**/", 4);
480 skip_comment (pfile, c);
481 continue;
483 /* else fall through */
484 case '-':
485 c = skip_comment (pfile, c);
486 break;
488 case '\f':
489 case '\v':
490 if (CPP_PEDANTIC (pfile))
491 cpp_pedwarn (pfile, "%s in preprocessing directive",
492 c == '\f' ? "formfeed" : "vertical tab");
493 break;
496 CPP_PUTC (pfile, c);
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. */
504 void
505 skip_rest_of_line (pfile)
506 cpp_reader *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. */
516 static int
517 handle_directive (pfile)
518 cpp_reader *pfile;
520 int c;
521 register const struct directive *kt;
522 int ident_length;
523 U_CHAR *ident;
524 long old_written = CPP_WRITTEN (pfile);
526 cpp_skip_hspace (pfile);
528 c = PEEKC ();
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);
535 return 1;
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. */
546 if (PEEKC() == '\n')
547 return 1;
548 else
549 return 0;
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++)
558 if (kt->length <= 0)
559 return 0;
560 if (kt->length == ident_length
561 && !strncmp (kt->name, ident, ident_length))
562 break;
565 CPP_SET_WRITTEN (pfile, old_written);
566 (*kt->func) (pfile, kt);
568 return 1;
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. */
576 static void
577 pass_thru_directive (buf, len, pfile, keyword)
578 const U_CHAR *buf;
579 size_t len;
580 cpp_reader *pfile;
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)
598 cpp_reader *pfile;
599 const U_CHAR *symname;
600 int assertion;
602 const U_CHAR *p;
603 int sym_length;
605 for (p = symname; is_idchar[*p]; p++)
607 sym_length = p - symname;
608 if (sym_length == 0
609 || (sym_length == 1 && *symname == 'L' && (*p == '\'' || *p == '"')))
610 cpp_error (pfile,
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);
617 msg[sym_length] = 0;
618 cpp_error (pfile,
619 (assertion
620 ? "invalid assertion name `%s'"
621 : "invalid macro name `%s'"),
622 msg);
624 return sym_length;
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. */
632 static int
633 do_define (pfile, keyword)
634 cpp_reader *pfile;
635 const struct directive *keyword;
637 int hashcode;
638 MACRODEF mdef;
639 HASHNODE *hp;
640 long here;
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)
648 new_type = T_MACRO;
649 else
650 new_type = T_POISON;
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);
662 if (mdef.defn == 0)
663 return 0;
665 hashcode = hashf (mdef.symnam, mdef.symlen, HASHSIZE);
667 if ((hp = cpp_lookup (pfile, mdef.symnam, mdef.symlen, hashcode)) != NULL)
669 int ok = 0;
670 /* Redefining a precompiled key is ok. */
671 if (hp->type == T_PCSTRING)
672 ok = 1;
673 /* Redefining a poisoned identifier is even worse than `not ok'. */
674 else if (hp->type == T_POISON)
675 ok = -1;
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. */
683 if (ok <= 0)
685 if (hp->type == T_POISON)
686 cpp_error (pfile, "redefining poisoned `%.*s'",
687 mdef.symlen, mdef.symnam);
688 else
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. */
698 hp->type = new_type;
699 hp->value.defn = mdef.defn;
702 else
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);
715 return 0;
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. */
724 cpp_buffer *
725 cpp_push_buffer (pfile, buffer, length)
726 cpp_reader *pfile;
727 U_CHAR *buffer;
728 long length;
730 cpp_buffer *buf = CPP_BUFFER (pfile);
731 cpp_buffer *new;
732 if (++pfile->buffer_stack_depth == CPP_STACK_MAX)
734 cpp_fatal (pfile, "macro or `#include' recursion too deep");
735 return NULL;
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;
745 new->prev = buf;
746 new->mark = -1;
748 CPP_BUFFER (pfile) = new;
749 return new;
752 cpp_buffer *
753 cpp_pop_buffer (pfile)
754 cpp_reader *pfile;
756 cpp_buffer *buf = CPP_BUFFER (pfile);
757 (*buf->cleanup) (buf, pfile);
758 CPP_BUFFER (pfile) = CPP_PREV_BUFFER (buf);
759 free (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. */
767 void
768 cpp_scan_buffer (pfile)
769 cpp_reader *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. */
777 for (;;)
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 ... */
783 break;
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);
789 break;
792 CPP_SET_WRITTEN (pfile, old_written);
794 else
796 for (;;)
798 token = cpp_get_token (pfile);
799 if (token == CPP_EOF) /* Should not happen ... */
800 break;
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);
806 break;
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.
821 void
822 cpp_expand_to_buffer (pfile, buf, length)
823 cpp_reader *pfile;
824 const U_CHAR *buf;
825 int length;
827 register cpp_buffer *ip;
828 U_CHAR *buf1;
829 int save_no_output;
831 if (length < 0)
833 cpp_fatal (pfile, "internal error: length < 0 in cpp_expand_to_buffer");
834 return;
837 /* Set up the input on the input stack. */
839 buf1 = (U_CHAR *) alloca (length + 1);
840 memcpy (buf1, buf, length);
841 buf1[length] = 0;
843 ip = cpp_push_buffer (pfile, buf1, length);
844 if (ip == NULL)
845 return;
846 ip->has_escapes = 1;
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);
857 void
858 cpp_buf_line_and_col (pbuf, linep, colp)
859 register cpp_buffer *pbuf;
860 long *linep, *colp;
862 if (pbuf)
864 *linep = pbuf->lineno;
865 if (colp)
866 *colp = pbuf->cur - pbuf->line_base;
868 else
870 *linep = 0;
871 if (colp)
872 *colp = 0;
876 /* Return the cpp_buffer that corresponds to a file (not a macro). */
878 cpp_buffer *
879 cpp_file_buffer (pfile)
880 cpp_reader *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)
886 return ip;
887 return 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.
895 void
896 output_line_command (pfile, file_change)
897 cpp_reader *pfile;
898 enum file_change_code file_change;
900 long line;
901 cpp_buffer *ip = CPP_BUFFER (pfile);
903 if (ip->fname == NULL)
904 return;
906 if (CPP_OPTIONS (pfile)->no_line_commands
907 || CPP_OPTIONS (pfile)->no_output)
908 return;
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)
921 return;
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');
931 pfile->lineno++;
933 return;
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');
962 #endif
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)
973 cpp_reader *pfile;
975 for (;;)
977 long old_written = CPP_WRITTEN (pfile);
978 enum cpp_token token;
979 cpp_skip_hspace (pfile);
980 if (PEEKC () == '\n')
981 return CPP_VSPACE;
982 token = cpp_get_token (pfile);
983 switch (token)
985 case CPP_POP:
986 if (! CPP_IS_MACRO_BUFFER (CPP_BUFFER (pfile)))
987 return token;
988 /* ... else fall though ... */
989 case CPP_HSPACE: case CPP_COMMENT:
990 CPP_SET_WRITTEN (pfile, old_written);
991 break;
992 default:
993 return token;
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.
1004 This is safe. */
1006 static int
1007 do_include (pfile, keyword)
1008 cpp_reader *pfile;
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? */
1015 long flen;
1016 unsigned char *ftok;
1017 cpp_buffer *fp;
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);
1027 int fd;
1029 if (CPP_PEDANTIC (pfile) && !CPP_BUFFER (pfile)->system_header_p)
1031 if (importing)
1032 cpp_pedwarn (pfile, "ANSI C does not allow `#import'");
1033 if (skip_dirs)
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;
1042 cpp_warning (pfile,
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] == '<')
1053 angle_brackets = 1;
1055 #ifdef VMS
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. */
1060 cpp_warning (pfile,
1061 "`#include filename' is obsolete, use `#include <filename.h>'");
1062 angle_brackets = 1;
1064 /* Append the missing `.h' to the name. */
1065 CPP_PUTS (pfile, ".h", 2);
1067 #endif
1068 else
1070 cpp_error (pfile,
1071 "`#%s' expects \"FILENAME\" or <FILENAME>", keyword->name);
1072 CPP_SET_WRITTEN (pfile, old_written);
1073 skip_rest_of_line (pfile);
1074 return 0;
1077 flen = CPP_WRITTEN (pfile) - old_written;
1078 ftok = (unsigned char *) alloca (flen + 1);
1079 memcpy (ftok, pfile->token_buffer + old_written, flen);
1080 ftok[flen] = '\0';
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);
1090 if (flen == 0)
1092 cpp_error (pfile, "empty file name in `#%s'", keyword->name);
1093 return 0;
1096 if (CPP_OPTIONS (pfile)->dump_includes)
1097 pass_thru_directive (ftok,
1098 flen
1099 #ifdef VMS
1100 - ((token == CPP_NAME) ? 2 : 0)
1101 #endif
1102 , pfile, keyword);
1104 #ifdef VMS
1105 if (token == CPP_STRING)
1106 #endif
1108 ftok++;
1109 flen -= 2;
1110 ftok[flen] = '\0';
1113 search_start = 0;
1115 for (fp = CPP_BUFFER (pfile);
1116 fp != CPP_NULL_BUFFER (pfile);
1117 fp = CPP_PREV_BUFFER (fp))
1118 if (fp->fname != NULL)
1119 break;
1121 if (fp == CPP_NULL_BUFFER (pfile))
1123 cpp_fatal (pfile, "cpp internal error: fp == NULL_BUFFER in do_include");
1124 return 0;
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;
1136 else
1138 if (skip_dirs)
1139 cpp_warning (pfile, "#include_next in primary source file");
1141 if (angle_brackets)
1142 search_start = CPP_OPTIONS (pfile)->bracket_include;
1143 else
1145 if (!CPP_OPTIONS (pfile)->ignore_srcdir)
1147 if (fp)
1148 search_start = fp->actual_dir;
1150 else
1151 search_start = CPP_OPTIONS (pfile)->quote_include;
1155 if (!search_start)
1157 cpp_error (pfile, "No include path in which to find %s", ftok);
1158 return 0;
1161 fd = find_include_file (pfile, ftok, search_start, &ihash, &before);
1163 if (fd == -2)
1164 return 0;
1166 if (fd == -1)
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, ' ');
1174 else
1176 char *p;
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;
1182 else
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);
1190 strcat (p, "/");
1192 strcat (p, ftok);
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);
1206 else
1207 cpp_error_from_errno (pfile, ftok);
1209 return 0;
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))
1222 putc ('.', stderr);
1223 fprintf (stderr, " %s\n", ihash->name);
1226 /* Actually process the file */
1228 if (importing)
1229 ihash->control_macro = "";
1231 if (cpp_push_buffer (pfile, NULL, 0) == NULL)
1233 close (fd);
1234 return 0;
1237 if (angle_brackets)
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;
1246 return 0;
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. */
1254 static int
1255 read_line_number (pfile, num)
1256 cpp_reader *pfile;
1257 int *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')
1266 *num = p[0] - '0';
1267 return 1;
1269 else
1271 if (token != CPP_VSPACE && token != CPP_EOF && token != CPP_POP)
1272 cpp_error (pfile, "invalid format `#line' command");
1273 return 0;
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. */
1281 static int
1282 do_line (pfile, keyword)
1283 cpp_reader *pfile;
1284 const struct directive *keyword ATTRIBUTE_UNUSED;
1286 cpp_buffer *ip = CPP_BUFFER (pfile);
1287 int new_lineno;
1288 long old_written = CPP_WRITTEN (pfile);
1289 enum file_change_code file_change = same_file;
1290 enum cpp_token token;
1291 char *x;
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);
1302 if (x[0] != '\0')
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);
1347 *end_name = '\0';
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;
1357 else
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;
1371 else
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);
1387 return 0;
1389 bad_line_directive:
1390 skip_rest_of_line (pfile);
1391 CPP_SET_WRITTEN (pfile, old_written);
1392 return 0;
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. */
1398 static int
1399 do_undef (pfile, keyword)
1400 cpp_reader *pfile;
1401 const struct directive *keyword;
1403 int sym_length;
1404 HASHNODE *hp;
1405 U_CHAR *buf, *name, *limit;
1406 int c;
1407 long here = CPP_WRITTEN (pfile);
1408 enum cpp_token token;
1410 cpp_skip_hspace (pfile);
1411 c = GETC();
1412 if (! is_idstart[c])
1414 cpp_error (pfile, "token after #undef is not an identifier");
1415 skip_rest_of_line (pfile);
1416 return 1;
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);
1447 else
1449 if (hp->type != T_MACRO)
1450 cpp_warning (pfile, "undefining `%s'", hp->name);
1451 delete_macro (hp);
1455 return 0;
1458 /* Wrap do_undef for -U processing. */
1459 void
1460 cpp_undef (pfile, macro)
1461 cpp_reader *pfile;
1462 U_CHAR *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#.)
1478 static int
1479 do_error (pfile, keyword)
1480 cpp_reader *pfile;
1481 const struct directive *keyword ATTRIBUTE_UNUSED;
1483 long here = CPP_WRITTEN (pfile);
1484 U_CHAR *text;
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);
1491 return 0;
1495 * Report a warning detected by the program we are processing.
1496 * Use the text of the line in the warning message, then continue.
1499 static int
1500 do_warning (pfile, keyword)
1501 cpp_reader *pfile;
1502 const struct directive *keyword ATTRIBUTE_UNUSED;
1504 U_CHAR *text;
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);
1517 return 0;
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). */
1525 static int
1526 do_ident (pfile, keyword)
1527 cpp_reader *pfile;
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);
1538 return 0;
1541 /* Just check for some recognized pragmas that need validation here,
1542 and leave the text in the token buffer to be output. */
1544 static int
1545 do_pragma (pfile, keyword)
1546 cpp_reader *pfile;
1547 const struct directive *keyword ATTRIBUTE_UNUSED;
1549 long here;
1550 U_CHAR *buf;
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
1564 fault. */
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))
1571 return 0;
1572 if (ip->fname != NULL)
1573 break;
1576 if (CPP_PREV_BUFFER (ip) == CPP_NULL_BUFFER (pfile))
1577 cpp_warning (pfile, "`#pragma once' outside include file");
1578 else
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 != '\"')
1589 return 0;
1591 fname = p + 1;
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);
1599 if (ptr)
1600 cpp_warning (pfile,
1601 "`#pragma implementation' for `%s' appears after file is included",
1602 fcopy);
1604 else if (!strncmp (buf, "poison", 6))
1606 /* Poison these symbols so that all subsequent usage produces an
1607 error message. */
1608 U_CHAR *p = buf + 6;
1609 size_t plen;
1610 U_CHAR *syms;
1611 int writeit;
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);
1625 if (writeit)
1626 CPP_SET_WRITTEN (pfile, here);
1627 else
1628 CPP_SET_WRITTEN (pfile, here-8);
1630 if (writeit)
1632 CPP_RESERVE (pfile, plen + 7);
1633 CPP_PUTS_Q (pfile, "poison", 7);
1636 while (*syms != '\0')
1638 U_CHAR *end = syms;
1640 while (is_idchar[*end])
1641 end++;
1643 if (!is_hor_space[*end] && *end != '\0')
1645 cpp_error (pfile, "invalid #pragma poison directive");
1646 return 1;
1649 if (cpp_push_buffer (pfile, syms, end - syms) != NULL)
1651 do_define (pfile, keyword);
1652 cpp_pop_buffer (pfile);
1654 if (writeit)
1656 CPP_PUTC_Q (pfile, ' ');
1657 CPP_PUTS_Q (pfile, syms, end - syms);
1659 syms = end;
1660 SKIP_WHITE_SPACE (syms);
1664 return 0;
1667 #ifdef SCCS_DIRECTIVE
1668 /* Just ignore #sccs, on systems where we define it at all. */
1670 static int
1671 do_sccs (pfile, keyword)
1672 cpp_reader *pfile;
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);
1678 return 0;
1680 #endif
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. */
1690 static U_CHAR *
1691 detect_if_not_defined (pfile)
1692 cpp_reader *pfile;
1694 U_CHAR *control_macro = 0;
1696 if (pfile->only_seen_white == 2)
1698 char *ident;
1699 enum cpp_token token;
1700 int base_offset;
1701 int token_offset;
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);
1709 /* Look for `!', */
1710 if (get_directive_token (pfile) != CPP_OTHER
1711 || CPP_WRITTEN (pfile) != (size_t) base_offset + 1
1712 || CPP_PWRITTEN (pfile)[-1] != '!')
1713 goto restore;
1715 /* ...then `defined', */
1716 token_offset = CPP_WRITTEN (pfile);
1717 token = get_directive_token (pfile);
1718 if (token != CPP_NAME)
1719 goto restore;
1720 ident = pfile->token_buffer + token_offset;
1721 CPP_NUL_TERMINATE (pfile);
1722 if (strcmp (ident, "defined"))
1723 goto restore;
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)
1733 goto restore;
1734 need_rparen = 1;
1736 else if (token != CPP_NAME)
1737 goto restore;
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);
1748 restore:
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.
1770 static int
1771 do_if (pfile, keyword)
1772 cpp_reader *pfile;
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);
1778 return 0;
1782 * handle a #elif directive by not changing if_stack either.
1783 * see the comment above do_else.
1786 static int
1787 do_elif (pfile, keyword)
1788 cpp_reader *pfile;
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");
1793 return 0;
1794 } else {
1795 if (pfile->if_stack->type != T_IF && pfile->if_stack->type != T_ELIF) {
1796 cpp_error (pfile, "`#elif' after `#else'");
1797 #if 0
1798 fprintf (stderr, " (matches line %d", pfile->if_stack->lineno);
1799 #endif
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);
1811 else {
1812 HOST_WIDEST_INT value = eval_if_expression (pfile);
1813 if (value == 0)
1814 skip_if_group (pfile);
1815 else {
1816 ++pfile->if_stack->if_succeeded; /* continue processing input */
1817 output_line_command (pfile, same_file);
1820 return 0;
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)
1830 cpp_reader *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 */
1841 return value;
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.
1850 static int
1851 do_xifdef (pfile, keyword)
1852 cpp_reader *pfile;
1853 const struct directive *keyword;
1855 int skip;
1856 cpp_buffer *ip = CPP_BUFFER (pfile);
1857 U_CHAR *ident;
1858 int ident_length;
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);
1894 skip = !skip;
1897 else
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))
1905 { int c;
1906 cpp_skip_hspace (pfile);
1907 c = PEEKC ();
1908 if (c != EOF && c != '\n')
1909 cpp_pedwarn (pfile, "garbage at end of `#%s' argument", keyword->name);
1911 skip_rest_of_line (pfile);
1913 #if 0
1914 if (pcp_outfile) {
1915 /* Output a precondition for this macro. */
1916 if (hp && hp->value.defn->predefined)
1917 fprintf (pcp_outfile, "#define %s\n", hp->name);
1918 else {
1919 U_CHAR *cp = buf;
1920 fprintf (pcp_outfile, "#undef ");
1921 while (is_idchar[*cp]) /* Ick! */
1922 fputc (*cp++, pcp_outfile);
1923 putc ('\n', pcp_outfile);
1925 #endif
1927 conditional_skip (pfile, skip, T_IF, control_macro);
1928 return 0;
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. */
1936 static void
1937 conditional_skip (pfile, skip, type, control_macro)
1938 cpp_reader *pfile;
1939 int skip;
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 #if 0
1948 temp->lineno = CPP_BUFFER (pfile)->lineno;
1949 #endif
1950 temp->next = pfile->if_stack;
1951 temp->control_macro = control_macro;
1952 pfile->if_stack = temp;
1954 pfile->if_stack->type = type;
1956 if (skip != 0) {
1957 skip_if_group (pfile);
1958 return;
1959 } else {
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. */
1970 static int
1971 consider_directive_while_skipping (pfile, stack)
1972 cpp_reader *pfile;
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)
1990 switch (kt->type)
1992 case T_IF:
1993 case T_IFDEF:
1994 case T_IFNDEF:
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;
2000 return 0;
2002 case T_ELSE:
2003 if (CPP_PEDANTIC (pfile) && pfile->if_stack != stack)
2004 validate_else (pfile, "#else");
2005 /* fall through */
2006 case T_ELIF:
2007 if (pfile->if_stack->type == T_ELSE)
2008 cpp_error (pfile, "`%s' after `#else'", kt->name);
2010 if (pfile->if_stack == stack)
2011 return 1;
2012 else
2014 pfile->if_stack->type = kt->type;
2015 return 0;
2018 case T_ENDIF:
2019 if (CPP_PEDANTIC (pfile) && pfile->if_stack != stack)
2020 validate_else (pfile, "#endif");
2022 if (pfile->if_stack == stack)
2023 return 1;
2025 temp = pfile->if_stack;
2026 pfile->if_stack = temp->next;
2027 free (temp);
2028 return 0;
2030 default:
2031 return 0;
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");
2037 return 0;
2040 /* skip to #endif, #else, or #elif. adjust line numbers, etc.
2041 * leaves input ptr at the sharp sign found.
2043 static void
2044 skip_if_group (pfile)
2045 cpp_reader *pfile;
2047 int c;
2048 IF_STACK_FRAME *save_if_stack = pfile->if_stack; /* don't pop past here */
2049 U_CHAR *beg_of_line;
2050 long old_written;
2052 if (CPP_OPTIONS (pfile)->output_conditionals)
2054 CPP_PUTS (pfile, "#failed\n", 8);
2055 pfile->lineno++;
2056 output_line_command (pfile, same_file);
2059 old_written = CPP_WRITTEN (pfile);
2061 for (;;)
2063 beg_of_line = CPP_BUFFER (pfile)->cur;
2065 if (! CPP_TRADITIONAL (pfile))
2066 cpp_skip_hspace (pfile);
2067 c = GETC();
2068 if (c == '\n')
2070 if (CPP_OPTIONS (pfile)->output_conditionals)
2071 CPP_PUTC (pfile, c);
2072 CPP_BUMP_LINE (pfile);
2073 continue;
2075 else if (c == '#')
2077 if (consider_directive_while_skipping (pfile, save_if_stack))
2078 break;
2080 else if (c == EOF)
2081 return; /* Caller will issue error. */
2083 FORWARD(-1);
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);
2089 else
2091 copy_rest_of_line (pfile);
2092 CPP_SET_WRITTEN (pfile, old_written); /* discard it */
2095 c = GETC();
2096 if (c == EOF)
2097 return; /* Caller will issue error. */
2098 else
2100 /* \n */
2101 if (CPP_OPTIONS (pfile)->output_conditionals)
2103 CPP_PUTC (pfile, c);
2104 pfile->lineno++;
2106 CPP_BUMP_LINE (pfile);
2110 /* Back up to the beginning of this line. Caller will process the
2111 directive. */
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);
2117 pfile->lineno++;
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.
2128 static int
2129 do_else (pfile, keyword)
2130 cpp_reader *pfile;
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");
2141 return 0;
2142 } else {
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);
2159 else {
2160 ++pfile->if_stack->if_succeeded; /* continue processing input */
2161 output_line_command (pfile, same_file);
2163 return 0;
2167 * unstack after #endif command
2170 static int
2171 do_endif (pfile, keyword)
2172 cpp_reader *pfile;
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'");
2181 else
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. */
2189 int c;
2191 parse_set_mark (pfile);
2193 for (;;)
2195 cpp_skip_hspace (pfile);
2196 c = GETC ();
2197 if (c != '\n')
2198 break;
2200 parse_goto_mark (pfile);
2202 if (c == EOF)
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)
2211 break;
2212 ip->ihash->control_macro = (char *) temp->control_macro;
2215 free (temp);
2216 output_line_command (pfile, same_file);
2218 return 0;
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. */
2225 static void
2226 validate_else (pfile, directive)
2227 cpp_reader *pfile;
2228 const char *directive;
2230 int c;
2231 cpp_skip_hspace (pfile);
2232 c = PEEKC ();
2233 if (c != EOF && c != '\n')
2234 cpp_pedwarn (pfile,
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. */
2241 enum cpp_token
2242 cpp_get_token (pfile)
2243 cpp_reader *pfile;
2245 register int c, c2, c3;
2246 enum cpp_token token;
2247 struct cpp_options *opts = CPP_OPTIONS (pfile);
2249 get_next:
2250 c = GETC();
2251 if (c == EOF)
2253 handle_eof:
2254 if (CPP_BUFFER (pfile)->manual_pop)
2255 /* If we've been reading from redirected input, the
2256 frontend will pop the buffer. */
2257 return CPP_EOF;
2258 else if (CPP_BUFFER (pfile)->seen_eof)
2260 if (CPP_PREV_BUFFER (CPP_BUFFER (pfile)) == CPP_NULL_BUFFER (pfile))
2261 return CPP_EOF;
2263 cpp_pop_buffer (pfile);
2264 goto get_next;
2266 else
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;
2283 return CPP_POP;
2286 else
2288 switch (c)
2290 case '/':
2291 if (PEEKC () == '=')
2292 goto op2;
2294 comment:
2295 if (opts->put_out_comments)
2296 c = copy_comment (pfile, c);
2297 else
2298 c = skip_comment (pfile, c);
2299 if (c == EOF)
2300 goto handle_eof;
2301 else if (c != ' ')
2302 goto randomchar;
2304 /* Comments are equivalent to spaces.
2305 For -traditional, a comment is equivalent to nothing. */
2306 if (opts->traditional || opts->put_out_comments)
2307 return CPP_COMMENT;
2308 else
2310 CPP_PUTC (pfile, c);
2311 return CPP_HSPACE;
2313 #if 0
2314 if (opts->for_lint) {
2315 U_CHAR *argbp;
2316 int cmdlen, arglen;
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: */
2321 obp[-1] = '\n';
2322 bcopy ("#pragma lint ", (char *) obp, 13);
2323 obp += 13;
2324 bcopy (lintcmd, (char *) obp, cmdlen);
2325 obp += cmdlen;
2327 if (arglen != 0) {
2328 *(obp++) = ' ';
2329 bcopy (argbp, (char *) obp, arglen);
2330 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 */
2338 *(obp++) = '/';
2341 #endif
2343 case '#':
2344 #if 0
2345 /* If this is expanding a macro definition, don't recognize
2346 preprocessor directives. */
2347 if (ip->macro != 0)
2348 goto randomchar;
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)
2353 goto randomchar;
2354 if (ident_length)
2355 goto specialchar;
2356 #endif
2358 if (!pfile->only_seen_white)
2359 goto randomchar;
2360 if (handle_directive (pfile))
2361 return CPP_DIRECTIVE;
2362 pfile->only_seen_white = 0;
2363 return CPP_OTHER;
2365 case '\"':
2366 case '\'':
2367 string:
2368 parse_string (pfile, c);
2369 pfile->only_seen_white = 0;
2370 return c == '\'' ? CPP_CHAR : CPP_STRING;
2372 case '$':
2373 if (!opts->dollars_in_ident)
2374 goto randomchar;
2375 goto letter;
2377 case ':':
2378 if (opts->cplusplus && PEEKC () == ':')
2379 goto op2;
2380 goto randomchar;
2382 case '&':
2383 case '+':
2384 case '|':
2385 c2 = PEEKC ();
2386 if (c2 == c || c2 == '=')
2387 goto op2;
2388 goto randomchar;
2390 case '*':
2391 case '!':
2392 case '%':
2393 case '=':
2394 case '^':
2395 if (PEEKC () == '=')
2396 goto op2;
2397 goto randomchar;
2399 case '-':
2400 c2 = PEEKC ();
2401 if (c2 == '-' && opts->chill)
2402 goto comment; /* Chill style comment */
2403 if (c2 == '-' || c2 == '=')
2404 goto op2;
2405 if (c2 == '>')
2407 if (opts->cplusplus && PEEKN (1) == '*')
2409 /* In C++, there's a ->* operator. */
2410 token = CPP_OTHER;
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);
2417 return token;
2419 goto op2;
2421 goto randomchar;
2423 case '<':
2424 if (pfile->parsing_include_directive)
2426 for (;;)
2428 CPP_PUTC (pfile, c);
2429 if (c == '>')
2430 break;
2431 c = GETC ();
2432 if (c == '\n' || c == EOF)
2434 cpp_error (pfile,
2435 "missing '>' in `#include <FILENAME>'");
2436 break;
2438 else if (c == '\r')
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);
2446 else
2448 /* We might conceivably get \r- or \r<space> in
2449 here. Just delete 'em. */
2450 int d = GETC();
2451 if (d != '-' && d != ' ')
2452 cpp_fatal (pfile,
2453 "internal error: unrecognized escape \\r%c",
2455 CPP_ADJUST_WRITTEN (pfile, -1);
2459 return CPP_STRING;
2461 /* else fall through */
2462 case '>':
2463 c2 = PEEKC ();
2464 if (c2 == '=')
2465 goto op2;
2466 /* GNU C++ supports MIN and MAX operators <? and >?. */
2467 if (c2 != c && (!opts->cplusplus || c2 != '?'))
2468 goto randomchar;
2469 FORWARD(1);
2470 CPP_RESERVE (pfile, 4);
2471 CPP_PUTC (pfile, c);
2472 CPP_PUTC (pfile, c2);
2473 c3 = PEEKC ();
2474 if (c3 == '=')
2475 CPP_PUTC_Q (pfile, GETC ());
2476 CPP_NUL_TERMINATE_Q (pfile);
2477 pfile->only_seen_white = 0;
2478 return CPP_OTHER;
2480 case '.':
2481 c2 = PEEKC ();
2482 if (ISDIGIT(c2))
2484 CPP_RESERVE(pfile, 2);
2485 CPP_PUTC_Q (pfile, '.');
2486 c = GETC ();
2487 goto number;
2490 /* In C++ there's a .* operator. */
2491 if (opts->cplusplus && c2 == '*')
2492 goto op2;
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, '.');
2500 FORWARD (2);
2501 CPP_NUL_TERMINATE_Q (pfile);
2502 pfile->only_seen_white = 0;
2503 return CPP_3DOTS;
2505 goto randomchar;
2507 op2:
2508 token = CPP_OTHER;
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);
2514 return token;
2516 case 'L':
2517 c2 = PEEKC ();
2518 if ((c2 == '\'' || c2 == '\"') && !CPP_TRADITIONAL (pfile))
2520 CPP_PUTC (pfile, c);
2521 c = GETC ();
2522 goto string;
2524 goto letter;
2526 case '0': case '1': case '2': case '3': case '4':
2527 case '5': case '6': case '7': case '8': case '9':
2528 number:
2529 c2 = '.';
2530 for (;;)
2532 CPP_RESERVE (pfile, 2);
2533 CPP_PUTC_Q (pfile, c);
2534 c = PEEKC ();
2535 if (c == EOF)
2536 break;
2537 if (!is_idchar[c] && c != '.'
2538 && ((c2 != 'e' && c2 != 'E'
2539 && ((c2 != 'p' && c2 != 'P') || CPP_C89 (pfile)))
2540 || (c != '+' && c != '-')))
2541 break;
2542 FORWARD(1);
2543 c2= c;
2545 CPP_NUL_TERMINATE_Q (pfile);
2546 pfile->only_seen_white = 0;
2547 return CPP_NUMBER;
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, '\'');
2556 FORWARD(1);
2557 for (;;)
2559 c = GETC();
2560 if (c == EOF)
2561 goto chill_number_eof;
2562 if (!is_idchar[c])
2563 break;
2564 CPP_PUTC (pfile, c);
2566 if (c == '\'')
2568 CPP_RESERVE (pfile, 2);
2569 CPP_PUTC_Q (pfile, c);
2570 CPP_NUL_TERMINATE_Q (pfile);
2571 return CPP_STRING;
2573 else
2575 FORWARD(-1);
2576 chill_number_eof:
2577 CPP_NUL_TERMINATE (pfile);
2578 return CPP_NUMBER;
2581 else
2582 goto letter;
2583 case '_':
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':
2591 case 'Y': case 'Z':
2592 letter:
2594 HASHNODE *hp;
2595 unsigned char *ident;
2596 int before_name_written = CPP_WRITTEN (pfile);
2597 int ident_len;
2598 parse_name (pfile, c);
2599 pfile->only_seen_white = 0;
2600 if (pfile->no_macro_expand)
2601 return CPP_NAME;
2602 ident = pfile->token_buffer + before_name_written;
2603 ident_len = CPP_PWRITTEN (pfile) - ident;
2604 hp = cpp_lookup (pfile, ident, ident_len, -1);
2605 if (!hp)
2606 return CPP_NAME;
2607 if (hp->type == T_DISABLED)
2609 if (pfile->output_escapes)
2610 { /* Return "\r-IDENT", followed by '\0'. */
2611 int i;
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];
2616 ident[0] = '\r';
2617 ident[1] = '-';
2619 return CPP_NAME;
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);
2631 for (;;)
2633 cpp_skip_hspace (pfile);
2634 c = PEEKC ();
2635 is_macro_call = c == '(';
2636 if (c != EOF)
2638 if (c != '\n')
2639 break;
2640 FORWARD (1);
2642 else
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);
2656 else
2657 break;
2660 if (!is_macro_call)
2662 parse_goto_mark (pfile);
2663 if (macbuf_whitespace)
2664 CPP_PUTC (pfile, ' ');
2666 else
2667 parse_clear_mark (pfile);
2668 if (!is_macro_call)
2669 return CPP_NAME;
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);
2677 goto get_next;
2679 case ' ': case '\t': case '\v':
2680 for (;;)
2682 CPP_PUTC (pfile, c);
2683 c = PEEKC ();
2684 if (c == EOF || !is_hor_space[c])
2685 break;
2686 FORWARD(1);
2688 return CPP_HSPACE;
2690 case '\r':
2691 if (CPP_BUFFER (pfile)->has_escapes)
2693 c = GETC ();
2694 if (c == '-')
2696 if (pfile->output_escapes)
2697 CPP_PUTS (pfile, "\r-", 2);
2698 parse_name (pfile, GETC ());
2699 return CPP_NAME;
2701 else if (c == ' ')
2703 CPP_RESERVE (pfile, 2);
2704 if (pfile->output_escapes)
2705 CPP_PUTC_Q (pfile, '\r');
2706 CPP_PUTC_Q (pfile, c);
2707 return CPP_HSPACE;
2709 else
2711 cpp_fatal (pfile,
2712 "internal error: unrecognized escape \\r%c", c);
2713 goto get_next;
2716 else
2718 /* Backslash newline is ignored. */
2719 CPP_BUMP_LINE (pfile);
2720 goto get_next;
2723 case '\n':
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)
2730 pfile->lineno++;
2731 if (CPP_BUFFER (pfile)->lineno != pfile->lineno)
2732 output_line_command (pfile, same_file);
2734 return CPP_VSPACE;
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;
2743 randomchar:
2744 default:
2745 token = CPP_OTHER;
2746 char1:
2747 pfile->only_seen_white = 0;
2748 CPP_PUTC (pfile, c);
2749 return token;
2754 /* Like cpp_get_token, but skip spaces and comments. */
2756 enum cpp_token
2757 cpp_get_non_space_token (pfile)
2758 cpp_reader *pfile;
2760 int old_written = CPP_WRITTEN (pfile);
2761 for (;;)
2763 enum cpp_token token = cpp_get_token (pfile);
2764 if (token != CPP_COMMENT && token != CPP_POP
2765 && token != CPP_HSPACE && token != CPP_VSPACE)
2766 return token;
2767 CPP_SET_WRITTEN (pfile, old_written);
2771 /* Parse an identifier starting with C. */
2773 static void
2774 parse_name (pfile, c)
2775 cpp_reader *pfile;
2776 int c;
2778 for (;;)
2780 if (! is_idchar[c])
2782 FORWARD (-1);
2783 break;
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);
2791 c = GETC();
2792 if (c == EOF)
2793 break;
2795 CPP_NUL_TERMINATE_Q (pfile);
2796 return;
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
2802 multiple lines.) */
2803 static void
2804 parse_string (pfile, c)
2805 cpp_reader *pfile;
2806 int 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);
2813 while (1)
2815 int cc = GETC();
2816 if (cc == EOF)
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
2823 quote. */
2824 cpp_pop_buffer (pfile);
2825 continue;
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;
2838 break;
2840 CPP_PUTC (pfile, cc);
2841 switch (cc)
2843 case '\n':
2844 CPP_BUMP_LINE (pfile);
2845 pfile->lineno++;
2846 /* Traditionally, end of line ends a string constant with
2847 no error. */
2848 if (CPP_TRADITIONAL (pfile))
2849 return;
2850 /* Character constants may not extend over multiple lines. */
2851 if (c == '\'')
2853 cpp_error_with_line (pfile, start_line, start_column,
2854 "unterminated character constant");
2855 return;
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;
2864 break;
2866 case '\r':
2867 CPP_ADJUST_WRITTEN (pfile, -1);
2868 if (CPP_BUFFER (pfile)->has_escapes)
2870 cpp_fatal (pfile,
2871 "internal error: \\r escape inside string constant");
2872 FORWARD(1);
2874 else
2875 /* Backslash newline is replaced by nothing at all. */
2876 CPP_BUMP_LINE (pfile);
2877 break;
2879 case '\\':
2880 cc = GETC();
2881 if (cc != EOF)
2882 CPP_PUTC (pfile, cc);
2883 break;
2885 case '\"':
2886 case '\'':
2887 if (cc == c)
2888 return;
2889 break;
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
2899 printed. */
2900 static int
2901 parse_assertion (pfile)
2902 cpp_reader *pfile;
2904 int c, dropwhite;
2905 cpp_skip_hspace (pfile);
2906 c = PEEKC();
2907 if (! is_idstart[c])
2909 cpp_error (pfile, "assertion predicate is not an identifier");
2910 return 0;
2912 CPP_PUTC(pfile, '#');
2913 FORWARD(1);
2914 parse_name(pfile, c);
2916 c = PEEKC();
2917 if (c != '(')
2919 if (is_hor_space[c] || c == '\r')
2920 cpp_skip_hspace (pfile);
2921 c = PEEKC();
2923 if (c != '(')
2924 return 1;
2926 CPP_PUTC(pfile, '(');
2927 FORWARD(1);
2928 dropwhite = 1;
2929 while ((c = GETC()) != ')')
2931 if (is_hor_space[c])
2933 if (! dropwhite)
2935 CPP_PUTC(pfile, ' ');
2936 dropwhite = 1;
2939 else if (c == '\n' || c == EOF)
2941 if (c == '\n') FORWARD(-1);
2942 cpp_error (pfile, "un-terminated assertion answer");
2943 return 0;
2945 else if (c == '\r')
2946 /* \r cannot be a macro escape here. */
2947 CPP_BUMP_LINE (pfile);
2948 else
2950 CPP_PUTC (pfile, c);
2951 dropwhite = 0;
2955 if (pfile->limit[-1] == ' ')
2956 pfile->limit[-1] = ')';
2957 else if (pfile->limit[-1] == '(')
2959 cpp_error (pfile, "empty token sequence in assertion");
2960 return 0;
2962 else
2963 CPP_PUTC (pfile, ')');
2965 CPP_NUL_TERMINATE (pfile);
2966 return 2;
2969 static int
2970 do_assert (pfile, keyword)
2971 cpp_reader *pfile;
2972 const struct directive *keyword ATTRIBUTE_UNUSED;
2974 char *sym;
2975 int ret, c;
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);
2986 if (ret == 0)
2987 goto error;
2988 else if (ret == 1)
2990 cpp_error (pfile, "missing token-sequence in `#assert'");
2991 goto error;
2994 cpp_skip_hspace (pfile);
2995 c = PEEKC();
2996 if (c != EOF && c != '\n')
2998 cpp_error (pfile, "junk at end of `#assert'");
2999 goto error;
3002 thislen = strlen (sym);
3003 baselen = index (sym, '(') - sym;
3004 this = cpp_lookup (pfile, sym, thislen, -1);
3005 if (this)
3007 cpp_warning (pfile, "`%s' re-asserted", sym);
3008 goto error;
3011 base = cpp_lookup (pfile, sym, baselen, -1);
3012 if (! base)
3013 base = cpp_install (pfile, sym, baselen, T_ASSERT, 0, -1);
3014 else if (base->type != T_ASSERT)
3016 /* Token clash - but with what?! */
3017 cpp_fatal (pfile,
3018 "cpp internal error: base->type != T_ASSERT in do_assert");
3019 goto error;
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 */
3027 return 0;
3029 error:
3030 skip_rest_of_line (pfile);
3031 pfile->limit = (unsigned char *) sym; /* Pop */
3032 return 0;
3035 static int
3036 do_unassert (pfile, keyword)
3037 cpp_reader *pfile;
3038 const struct directive *keyword ATTRIBUTE_UNUSED;
3040 int c, ret;
3041 char *sym;
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);
3053 if (ret == 0)
3054 goto error;
3056 cpp_skip_hspace (pfile);
3057 c = PEEKC ();
3058 if (c != EOF && c != '\n')
3059 cpp_error (pfile, "junk at end of `#unassert'");
3061 thislen = strlen (sym);
3062 if (ret == 1)
3064 base = cpp_lookup (pfile, sym, thislen, -1);
3065 if (! base)
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);
3077 else
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;
3085 next = base;
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 */
3097 return 0;
3098 error:
3099 skip_rest_of_line (pfile);
3100 pfile->limit = (unsigned char *) sym; /* Pop */
3101 return 0;
3104 /* Process STR as if it appeared as the body of an #unassert. */
3105 void
3106 cpp_unassert (pfile, str)
3107 cpp_reader *pfile;
3108 unsigned char *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)
3119 cpp_reader *pfile;
3121 U_CHAR *name = CPP_PWRITTEN (pfile);
3122 int result;
3123 HASHNODE *hp;
3125 FORWARD (1); /* Skip '#' */
3126 cpp_skip_hspace (pfile);
3127 if (! parse_assertion (pfile))
3128 result = 0;
3129 else
3131 hp = cpp_lookup (pfile, name, CPP_PWRITTEN (pfile) - name, -1);
3132 result = (hp != 0);
3135 pfile->limit = name;
3136 return result;
3139 /* Remember the current position of PFILE. */
3141 void
3142 parse_set_mark (pfile)
3143 cpp_reader *pfile;
3145 cpp_buffer *ip = CPP_BUFFER (pfile);
3146 if (ip->mark != -1)
3147 cpp_fatal (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. */
3155 void
3156 parse_clear_mark (pfile)
3157 cpp_reader *pfile;
3159 cpp_buffer *ip = CPP_BUFFER (pfile);
3160 if (ip->mark == -1)
3161 cpp_fatal (pfile,
3162 "cpp internal error: ip->mark == -1 in parse_clear_mark");
3164 ip->mark = -1;
3167 /* Backup the current position of PFILE to that saved in its mark,
3168 and clear the mark. */
3170 void
3171 parse_goto_mark (pfile)
3172 cpp_reader *pfile;
3174 cpp_buffer *ip = CPP_BUFFER (pfile);
3175 if (ip->mark == -1)
3176 cpp_fatal (pfile,
3177 "cpp internal error: ip->mark == -1 in parse_goto_mark");
3179 ip->cur = ip->buf + ip->mark;
3180 ip->mark = -1;
3183 static void
3184 cpp_print_file_and_line (pfile)
3185 cpp_reader *pfile;
3187 cpp_buffer *ip = cpp_file_buffer (pfile);
3189 if (ip != NULL)
3191 long line, col;
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);
3198 static void
3199 v_cpp_error (pfile, msgid, ap)
3200 cpp_reader *pfile;
3201 const char *msgid;
3202 va_list ap;
3204 cpp_print_containing_files (pfile);
3205 cpp_print_file_and_line (pfile);
3206 v_cpp_message (pfile, 1, msgid, ap);
3209 void
3210 cpp_error VPROTO ((cpp_reader * pfile, const char *msgid, ...))
3212 #ifndef ANSI_PROTOTYPES
3213 cpp_reader *pfile;
3214 const char *msgid;
3215 #endif
3216 va_list ap;
3218 VA_START(ap, msgid);
3220 #ifndef ANSI_PROTOTYPES
3221 pfile = va_arg (ap, cpp_reader *);
3222 msgid = va_arg (ap, const char *);
3223 #endif
3225 v_cpp_error (pfile, msgid, ap);
3226 va_end(ap);
3229 /* Print error message but don't count it. */
3231 static void
3232 v_cpp_warning (pfile, msgid, ap)
3233 cpp_reader *pfile;
3234 const char *msgid;
3235 va_list ap;
3237 if (CPP_OPTIONS (pfile)->inhibit_warnings)
3238 return;
3240 if (CPP_OPTIONS (pfile)->warnings_are_errors)
3241 pfile->errors++;
3243 cpp_print_containing_files (pfile);
3244 cpp_print_file_and_line (pfile);
3245 v_cpp_message (pfile, 0, msgid, ap);
3248 void
3249 cpp_warning VPROTO ((cpp_reader * pfile, const char *msgid, ...))
3251 #ifndef ANSI_PROTOTYPES
3252 cpp_reader *pfile;
3253 const char *msgid;
3254 #endif
3255 va_list ap;
3257 VA_START (ap, msgid);
3259 #ifndef ANSI_PROTOTYPES
3260 pfile = va_arg (ap, cpp_reader *);
3261 msgid = va_arg (ap, const char *);
3262 #endif
3264 v_cpp_warning (pfile, msgid, ap);
3265 va_end(ap);
3268 /* Print an error message and maybe count it. */
3270 void
3271 cpp_pedwarn VPROTO ((cpp_reader * pfile, const char *msgid, ...))
3273 #ifndef ANSI_PROTOTYPES
3274 cpp_reader *pfile;
3275 const char *msgid;
3276 #endif
3277 va_list ap;
3279 VA_START (ap, msgid);
3281 #ifndef ANSI_PROTOTYPES
3282 pfile = va_arg (ap, cpp_reader *);
3283 msgid = va_arg (ap, const char *);
3284 #endif
3286 if (CPP_OPTIONS (pfile)->pedantic_errors)
3287 v_cpp_error (pfile, msgid, ap);
3288 else
3289 v_cpp_warning (pfile, msgid, ap);
3290 va_end(ap);
3293 static void
3294 v_cpp_error_with_line (pfile, line, column, msgid, ap)
3295 cpp_reader * pfile;
3296 int line;
3297 int column;
3298 const char * msgid;
3299 va_list ap;
3301 cpp_buffer *ip = cpp_file_buffer (pfile);
3303 cpp_print_containing_files (pfile);
3305 if (ip != NULL)
3306 cpp_file_line_for_message (pfile, ip->nominal_fname, line, column);
3308 v_cpp_message (pfile, 1, msgid, ap);
3311 void
3312 cpp_error_with_line VPROTO ((cpp_reader * pfile, int line, int column,
3313 const char *msgid, ...))
3315 #ifndef ANSI_PROTOTYPES
3316 cpp_reader *pfile;
3317 int line;
3318 int column;
3319 const char *msgid;
3320 #endif
3321 va_list ap;
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 *);
3330 #endif
3332 v_cpp_error_with_line(pfile, line, column, msgid, ap);
3333 va_end(ap);
3336 static void
3337 v_cpp_warning_with_line (pfile, line, column, msgid, ap)
3338 cpp_reader * pfile;
3339 int line;
3340 int column;
3341 const char *msgid;
3342 va_list ap;
3344 cpp_buffer *ip;
3346 if (CPP_OPTIONS (pfile)->inhibit_warnings)
3347 return;
3349 if (CPP_OPTIONS (pfile)->warnings_are_errors)
3350 pfile->errors++;
3352 cpp_print_containing_files (pfile);
3354 ip = cpp_file_buffer (pfile);
3356 if (ip != NULL)
3357 cpp_file_line_for_message (pfile, ip->nominal_fname, line, column);
3359 v_cpp_message (pfile, 0, msgid, ap);
3362 void
3363 cpp_warning_with_line VPROTO ((cpp_reader * pfile, int line, int column,
3364 const char *msgid, ...))
3366 #ifndef ANSI_PROTOTYPES
3367 cpp_reader *pfile;
3368 int line;
3369 int column;
3370 const char *msgid;
3371 #endif
3372 va_list ap;
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 *);
3381 #endif
3383 v_cpp_warning_with_line (pfile, line, column, msgid, ap);
3384 va_end(ap);
3387 void
3388 cpp_pedwarn_with_line VPROTO ((cpp_reader * pfile, int line, int column,
3389 const char *msgid, ...))
3391 #ifndef ANSI_PROTOTYPES
3392 cpp_reader *pfile;
3393 int line;
3394 int column;
3395 const char *msgid;
3396 #endif
3397 va_list ap;
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 *);
3406 #endif
3408 if (CPP_OPTIONS (pfile)->pedantic_errors)
3409 v_cpp_error_with_line (pfile, column, line, msgid, ap);
3410 else
3411 v_cpp_warning_with_line (pfile, line, column, msgid, ap);
3412 va_end(ap);
3415 /* Report a warning (or an error if pedantic_errors)
3416 giving specified file name and line number, not current. */
3418 void
3419 cpp_pedwarn_with_file_and_line VPROTO ((cpp_reader *pfile, const char *file,
3420 int line, const char *msgid, ...))
3422 #ifndef ANSI_PROTOTYPES
3423 cpp_reader *pfile;
3424 const char *file;
3425 int line;
3426 const char *msgid;
3427 #endif
3428 va_list ap;
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 *);
3437 #endif
3439 if (!CPP_OPTIONS (pfile)->pedantic_errors
3440 && CPP_OPTIONS (pfile)->inhibit_warnings)
3441 return;
3442 if (file != NULL)
3443 cpp_file_line_for_message (pfile, file, line, -1);
3444 v_cpp_message (pfile, CPP_OPTIONS (pfile)->pedantic_errors, msgid, ap);
3445 va_end(ap);
3448 /* my_strerror - return the descriptive text associated with an
3449 `errno' code. */
3451 static const char *
3452 my_strerror (errnum)
3453 int errnum;
3455 const char *result;
3457 #ifndef VMS
3458 #ifndef HAVE_STRERROR
3459 result = (char *) ((errnum < sys_nerr) ? sys_errlist[errnum] : 0);
3460 #else
3461 result = strerror (errnum);
3462 #endif
3463 #else /* VMS */
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);
3472 #endif
3474 if (!result)
3475 result = "errno = ?";
3477 return result;
3480 /* Error including a message from `errno'. */
3482 void
3483 cpp_error_from_errno (pfile, name)
3484 cpp_reader *pfile;
3485 const char *name;
3487 cpp_message_from_errno (pfile, 1, name);
3490 void
3491 cpp_message_from_errno (pfile, is_error, name)
3492 cpp_reader *pfile;
3493 int is_error;
3494 const char *name;
3496 int e = errno;
3497 cpp_buffer *ip = cpp_file_buffer (pfile);
3499 cpp_print_containing_files (pfile);
3501 if (ip != NULL)
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));
3507 void
3508 cpp_perror_with_name (pfile, name)
3509 cpp_reader *pfile;
3510 const char *name;
3512 cpp_message (pfile, 1, "%s: %s: %s", progname, name, my_strerror (errno));
3515 /* TODO:
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.