2 Copyright (C) 1986, 87, 89, 92-6, 1997 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.
21 In other words, you are welcome to use, share and improve this program.
22 You are forbidden to forbid anyone else to use, share and improve
23 what you give them. Help stamp out software-hoarding! */
27 #include "../src/config.h"
35 /* The macro EMACS is defined when cpp is distributed as part of Emacs,
36 for the sake of machines with limited C compilers. */
39 #endif /* not EMACS */
41 #ifndef STANDARD_INCLUDE_DIR
42 #define STANDARD_INCLUDE_DIR "/usr/include"
45 #if 0 /* We can't get ptrdiff_t, so I arranged not to need PTR_INT_TYPE. */
47 #define PTR_INT_TYPE ptrdiff_t
49 #define PTR_INT_TYPE long
60 /* By default, colon separates directories in a path. */
61 #ifndef PATH_SEPARATOR
62 #define PATH_SEPARATOR ':'
74 #include <sys/time.h> /* for __DATE__ and __TIME__ */
75 #include <sys/resource.h>
77 #include <sys/times.h>
83 /* This defines "errno" properly for VMS, and gives us EACCES. */
86 extern char *index ();
87 extern char *rindex ();
95 #define MIN(X,Y) ((X) < (Y) ? (X) : (Y))
96 #define MAX(X,Y) ((X) > (Y) ? (X) : (Y))
98 /* Find the largest host integer type and set its size and type. */
100 #ifndef HOST_BITS_PER_WIDE_INT
102 #if HOST_BITS_PER_LONG > HOST_BITS_PER_INT
103 #define HOST_BITS_PER_WIDE_INT HOST_BITS_PER_LONG
104 #define HOST_WIDE_INT long
106 #define HOST_BITS_PER_WIDE_INT HOST_BITS_PER_INT
107 #define HOST_WIDE_INT int
113 #define S_ISREG(m) (((m) & S_IFMT) == S_IFREG)
117 #define S_ISDIR(m) (((m) & S_IFMT) == S_IFDIR)
120 /* Define a generic NULL if one hasn't already been defined. */
127 #if defined (USE_PROTOTYPES) ? USE_PROTOTYPES : defined (__STDC__)
128 #define GENERIC_PTR void *
130 #define GENERIC_PTR char *
135 #define NULL_PTR ((GENERIC_PTR) 0)
138 #ifndef INCLUDE_LEN_FUDGE
139 #define INCLUDE_LEN_FUDGE 0
142 /* Symbols to predefine. */
144 #ifdef CPP_PREDEFINES
145 static char *predefs = CPP_PREDEFINES;
147 static char *predefs = "";
150 /* We let tm.h override the types used here, to handle trivial differences
151 such as the choice of unsigned int or long unsigned int for size_t.
152 When machines start needing nontrivial differences in the size type,
153 it would be best to do something here to figure out automatically
154 from other information what type to use. */
156 /* The string value for __SIZE_TYPE__. */
159 #define SIZE_TYPE "long unsigned int"
162 /* The string value for __PTRDIFF_TYPE__. */
165 #define PTRDIFF_TYPE "long int"
168 /* The string value for __WCHAR_TYPE__. */
171 #define WCHAR_TYPE "int"
173 #define CPP_WCHAR_TYPE(PFILE) \
174 (CPP_OPTIONS (PFILE)->cplusplus ? "__wchar_t" : WCHAR_TYPE)
176 /* The string value for __USER_LABEL_PREFIX__ */
178 #ifndef USER_LABEL_PREFIX
179 #define USER_LABEL_PREFIX ""
182 /* The string value for __REGISTER_PREFIX__ */
184 #ifndef REGISTER_PREFIX
185 #define REGISTER_PREFIX ""
188 /* In the definition of a #assert name, this structure forms
189 a list of the individual values asserted.
190 Each value is itself a list of "tokens".
191 These are strings that are compared by name. */
193 struct tokenlist_list {
194 struct tokenlist_list *next;
195 struct arglist *tokens;
198 struct assertion_hashnode {
199 struct assertion_hashnode *next; /* double links for easy deletion */
200 struct assertion_hashnode *prev;
201 /* also, a back pointer to this node's hash
202 chain is kept, in case the node is the head
203 of the chain and gets deleted. */
204 struct assertion_hashnode **bucket_hdr;
205 int length; /* length of token, for quick comparison */
206 U_CHAR *name; /* the actual name */
207 /* List of token-sequences. */
208 struct tokenlist_list *value;
211 #define SKIP_WHITE_SPACE(p) do { while (is_hor_space[*p]) p++; } while (0)
212 #define SKIP_ALL_WHITE_SPACE(p) do { while (is_space[*p]) p++; } while (0)
214 #define PEEKN(N) (CPP_BUFFER (pfile)->rlimit - CPP_BUFFER (pfile)->cur >= (N) ? CPP_BUFFER (pfile)->cur[N] : EOF)
215 #define FORWARD(N) CPP_FORWARD (CPP_BUFFER (pfile), (N))
216 #define GETC() CPP_BUF_GET (CPP_BUFFER (pfile))
217 #define PEEKC() CPP_BUF_PEEK (CPP_BUFFER (pfile))
218 /* CPP_IS_MACRO_BUFFER is true if the buffer contains macro expansion.
219 (Note that it is false while we're expanding marco *arguments*.) */
220 #define CPP_IS_MACRO_BUFFER(PBUF) ((PBUF)->cleanup == macro_cleanup)
222 /* Move all backslash-newline pairs out of embarrassing places.
223 Exchange all such pairs following BP
224 with any potentially-embarrassing characters that follow them.
225 Potentially-embarrassing characters are / and *
226 (because a backslash-newline inside a comment delimiter
227 would cause it not to be recognized). */
229 #define NEWLINE_FIX \
230 do {while (PEEKC() == '\\' && PEEKN(1) == '\n') FORWARD(2); } while(0)
232 /* Same, but assume we've already read the potential '\\' into C. */
233 #define NEWLINE_FIX1(C) do { \
234 while ((C) == '\\' && PEEKC() == '\n') { FORWARD(1); (C) = GETC(); }\
238 struct cpp_pending *next;
243 /* Forward declarations. */
245 extern char *xmalloc ();
247 static void add_import ();
248 static void append_include_chain ();
249 static void make_undef ();
250 static void make_assertion ();
251 static void path_include ();
252 static void initialize_builtins ();
253 static void initialize_char_syntax ();
254 static void dump_arg_n ();
255 static void dump_defn_1 ();
256 extern void delete_macro ();
257 static void trigraph_pcp ();
258 static int finclude ();
259 static void validate_else ();
260 static int comp_def_part ();
262 extern void fancy_abort ();
264 static void pipe_closed ();
265 static void print_containing_files ();
266 static int lookup_import ();
267 static int redundant_include_p ();
268 static is_system_include ();
269 static struct file_name_map *read_name_map ();
270 static char *read_filename_string ();
271 static int open_include_file ();
272 static int check_preconditions ();
273 static void pcfinclude ();
274 static void pcstring_used ();
275 static int check_macro_name ();
276 static int compare_defs ();
277 static int compare_token_lists ();
278 static HOST_WIDE_INT eval_if_expression ();
279 static int change_newlines ();
281 static int file_size_and_mode ();
282 static struct arglist *read_token_list ();
283 static void free_token_list ();
284 static int safe_read ();
285 static void push_macro_expansion PARAMS ((cpp_reader *,
286 U_CHAR *, int, HASHNODE *));
287 static struct cpp_pending *nreverse_pending PARAMS ((struct cpp_pending *));
288 extern char *xrealloc ();
289 static char *xcalloc ();
290 static char *savestring ();
292 static void conditional_skip ();
293 static void skip_if_group ();
295 /* Last arg to output_line_command. */
296 enum file_change_code {same_file, enter_file, leave_file};
298 /* External declarations. */
300 extern HOST_WIDE_INT cpp_parse_expr PARAMS ((cpp_reader *));
302 extern char *getenv ();
303 extern FILE *fdopen ();
304 extern char *version_string;
305 extern struct tm *localtime ();
307 /* These functions are declared to return int instead of void since they
308 are going to be placed in a table and some old compilers have trouble with
309 pointers to functions returning void. */
311 static int do_define ();
312 static int do_line ();
313 static int do_include ();
314 static int do_undef ();
315 static int do_error ();
316 static int do_pragma ();
317 static int do_ident ();
319 static int do_xifdef ();
320 static int do_else ();
321 static int do_elif ();
322 static int do_endif ();
323 static int do_sccs ();
324 static int do_once ();
325 static int do_assert ();
326 static int do_unassert ();
327 static int do_warning ();
329 struct file_name_list
331 struct file_name_list *next;
333 /* If the following is nonzero, it is a macro name.
334 Don't include the file again if that macro is defined. */
335 U_CHAR *control_macro;
336 /* If the following is nonzero, it is a C-language system include
338 int c_system_include_path;
339 /* Mapping of file names for this directory. */
340 struct file_name_map *name_map;
341 /* Non-zero if name_map is valid. */
345 /* If a buffer's dir field is SELF_DIR_DUMMY, it means the file was found
346 via the same directory as the file that #included it. */
347 #define SELF_DIR_DUMMY ((struct file_name_list *) (~0))
349 /* #include "file" looks in source file dir, then stack. */
350 /* #include <file> just looks in the stack. */
351 /* -I directories are added to the end, then the defaults are added. */
353 static struct default_include {
354 char *fname; /* The name of the directory. */
355 int cplusplus; /* Only look here if we're compiling C++. */
356 int cxx_aware; /* Includes in this directory don't need to
357 be wrapped in extern "C" when compiling
359 } include_defaults_array[]
360 #ifdef INCLUDE_DEFAULTS
364 /* Pick up GNU C++ specific include files. */
365 { GPLUSPLUS_INCLUDE_DIR, 1, 1 },
366 { OLD_GPLUSPLUS_INCLUDE_DIR, 1, 1 },
368 /* This is the dir for fixincludes. Put it just before
369 the files that we fix. */
370 { GCC_INCLUDE_DIR, 0, 0 },
371 /* For cross-compilation, this dir name is generated
372 automatically in Makefile.in. */
373 { CROSS_INCLUDE_DIR, 0, 0 },
374 #ifdef TOOL_INCLUDE_DIR
375 /* This is another place that the target system's headers might be. */
376 { TOOL_INCLUDE_DIR, 0, 1 },
378 #else /* not CROSS_COMPILE */
379 #ifdef LOCAL_INCLUDE_DIR
380 /* This should be /usr/local/include and should come before
381 the fixincludes-fixed header files. */
382 { LOCAL_INCLUDE_DIR, 0, 1 },
384 #ifdef TOOL_INCLUDE_DIR
385 /* This is here ahead of GCC_INCLUDE_DIR because assert.h goes here.
386 Likewise, behind LOCAL_INCLUDE_DIR, where glibc puts its assert.h. */
387 { TOOL_INCLUDE_DIR, 0, 1 },
389 /* This is the dir for fixincludes. Put it just before
390 the files that we fix. */
391 { GCC_INCLUDE_DIR, 0, 0 },
392 /* Some systems have an extra dir of include files. */
393 #ifdef SYSTEM_INCLUDE_DIR
394 { SYSTEM_INCLUDE_DIR, 0, 0 },
396 { STANDARD_INCLUDE_DIR, 0, 0 },
397 #endif /* not CROSS_COMPILE */
400 #endif /* no INCLUDE_DEFAULTS */
402 /* `struct directive' defines one #-directive, including how to handle it. */
405 int length; /* Length of name */
406 int (*func)(); /* Function to handle directive */
407 char *name; /* Name of directive */
408 enum node_type type; /* Code which describes which directive. */
409 char command_reads_line; /* One if rest of line is read by func. */
410 char traditional_comments; /* Nonzero: keep comments if -traditional. */
411 char pass_thru; /* Copy preprocessed directive to output file.*/
414 /* Here is the actual list of #-directives, most-often-used first.
415 The initialize_builtins function assumes #define is the very first. */
417 static struct directive directive_table[] = {
418 { 6, do_define, "define", T_DEFINE, 0, 1},
419 { 5, do_xifdef, "ifdef", T_IFDEF, 1},
420 { 6, do_xifdef, "ifndef", T_IFNDEF, 1},
421 { 7, do_include, "include", T_INCLUDE, 1},
422 { 12, do_include, "include_next", T_INCLUDE_NEXT, 1},
423 { 6, do_include, "import", T_IMPORT, 1},
424 { 5, do_endif, "endif", T_ENDIF, 1},
425 { 4, do_else, "else", T_ELSE, 1},
426 { 2, do_if, "if", T_IF, 1},
427 { 4, do_elif, "elif", T_ELIF, 1},
428 { 5, do_undef, "undef", T_UNDEF},
429 { 5, do_error, "error", T_ERROR},
430 { 7, do_warning, "warning", T_WARNING},
431 { 6, do_pragma, "pragma", T_PRAGMA, 0, 0, 1},
432 { 4, do_line, "line", T_LINE, 1},
433 { 5, do_ident, "ident", T_IDENT, 1, 0, 1},
434 #ifdef SCCS_DIRECTIVE
435 { 4, do_sccs, "sccs", T_SCCS},
437 { 6, do_assert, "assert", T_ASSERT, 1},
438 { 8, do_unassert, "unassert", T_UNASSERT, 1},
439 { -1, 0, "", T_UNUSED},
442 /* table to tell if char can be part of a C identifier. */
443 U_CHAR is_idchar[256];
444 /* table to tell if char can be first char of a c identifier. */
445 U_CHAR is_idstart[256];
446 /* table to tell if c is horizontal space. */
447 U_CHAR is_hor_space[256];
448 /* table to tell if c is horizontal or vertical space. */
449 static U_CHAR is_space[256];
451 /* Initialize syntactic classifications of characters. */
454 initialize_char_syntax (opts)
455 struct cpp_options *opts;
460 * Set up is_idchar and is_idstart tables. These should be
461 * faster than saying (is_alpha (c) || c == '_'), etc.
462 * Set up these things before calling any routines tthat
465 for (i = 'a'; i <= 'z'; i++) {
466 is_idchar[i - 'a' + 'A'] = 1;
468 is_idstart[i - 'a' + 'A'] = 1;
471 for (i = '0'; i <= '9'; i++)
475 is_idchar['$'] = opts->dollars_in_ident;
476 is_idstart['$'] = opts->dollars_in_ident;
478 /* horizontal space table */
479 is_hor_space[' '] = 1;
480 is_hor_space['\t'] = 1;
481 is_hor_space['\v'] = 1;
482 is_hor_space['\f'] = 1;
483 is_hor_space['\r'] = 1;
494 /* Place into PFILE a quoted string representing the string SRC.
495 Caller must reserve enough space in pfile->token_buffer. */
498 quote_string (pfile, src)
504 CPP_PUTC_Q (pfile, '\"');
506 switch ((c = *src++))
510 CPP_PUTC_Q (pfile, c);
513 sprintf (CPP_PWRITTEN (pfile), "\\%03o", c);
514 CPP_ADJUST_WRITTEN (pfile, 4);
520 CPP_PUTC_Q (pfile, '\\');
521 CPP_PUTC_Q (pfile, c);
525 CPP_PUTC_Q (pfile, '\"');
526 CPP_NUL_TERMINATE_Q (pfile);
531 /* Re-allocates PFILE->token_buffer so it will hold at least N more chars. */
534 cpp_grow_buffer (pfile, n)
538 long old_written = CPP_WRITTEN (pfile);
539 pfile->token_buffer_size = n + 2 * pfile->token_buffer_size;
540 pfile->token_buffer = (U_CHAR *)
541 xrealloc(pfile->token_buffer, pfile->token_buffer_size);
542 CPP_SET_WRITTEN (pfile, old_written);
547 * process a given definition string, for initialization
548 * If STR is just an identifier, define it with value 1.
549 * If STR has anything after the identifier, then it should
550 * be identifier=definition.
554 cpp_define (pfile, str)
564 cpp_error (pfile, "malformed option `-D %s'", str);
567 while (is_idchar[*++p])
571 buf = (U_CHAR *) alloca (p - buf + 4);
572 strcpy ((char *)buf, str);
573 strcat ((char *)buf, " 1");
577 cpp_error (pfile, "malformed option `-D %s'", str);
583 /* Copy the entire option so we can modify it. */
584 buf = (U_CHAR *) alloca (2 * strlen (str) + 1);
585 strncpy (buf, str, p - str);
586 /* Change the = to a space. */
588 /* Scan for any backslash-newline and remove it. */
593 if (*p == '\\' && p[1] == '\n')
601 do_define (pfile, NULL, buf, buf + strlen (buf));
604 /* Process the string STR as if it appeared as the body of a #assert.
605 OPTION is the option name for which STR was the argument. */
608 make_assertion (pfile, option, str)
613 struct directive *kt;
616 /* Copy the entire option so we can modify it. */
617 buf = (U_CHAR *) alloca (strlen (str) + 1);
618 strcpy ((char *) buf, str);
619 /* Scan for any backslash-newline and remove it. */
623 if (*p == '\\' && p[1] == '\n')
632 if (!is_idstart[*p]) {
633 cpp_error (pfile, "malformed option `%s %s'", option, str);
636 while (is_idchar[*++p])
638 while (*p == ' ' || *p == '\t') p++;
639 if (! (*p == 0 || *p == '(')) {
640 cpp_error (pfile, "malformed option `%s %s'", option, str);
644 if (cpp_push_buffer (pfile, buf, strlen (buf)) != NULL)
646 do_assert (pfile, NULL, NULL, NULL);
647 cpp_pop_buffer (pfile);
651 /* Append a chain of `struct file_name_list's
652 to the end of the main include chain.
653 FIRST is the beginning of the chain to append, and LAST is the end. */
656 append_include_chain (pfile, first, last)
658 struct file_name_list *first, *last;
660 struct cpp_options *opts = CPP_OPTIONS (pfile);
661 struct file_name_list *dir;
666 if (opts->include == 0)
667 opts->include = first;
669 opts->last_include->next = first;
671 if (opts->first_bracket_include == 0)
672 opts->first_bracket_include = first;
674 for (dir = first; ; dir = dir->next) {
675 int len = strlen (dir->fname) + INCLUDE_LEN_FUDGE;
676 if (len > pfile->max_include_len)
677 pfile->max_include_len = len;
683 opts->last_include = last;
686 /* Add output to `deps_buffer' for the -M switch.
687 STRING points to the text to be output.
688 SPACER is ':' for targets, ' ' for dependencies, zero for text
689 to be inserted literally. */
692 deps_output (pfile, string, spacer)
697 int size = strlen (string);
702 #ifndef MAX_OUTPUT_COLUMNS
703 #define MAX_OUTPUT_COLUMNS 72
706 && pfile->deps_column > 0
707 && (pfile->deps_column + size) > MAX_OUTPUT_COLUMNS)
709 deps_output (pfile, " \\\n ", 0);
710 pfile->deps_column = 0;
713 if (pfile->deps_size + size + 8 > pfile->deps_allocated_size)
715 pfile->deps_allocated_size = (pfile->deps_size + size + 50) * 2;
716 pfile->deps_buffer = (char *) xrealloc (pfile->deps_buffer,
717 pfile->deps_allocated_size);
719 if (spacer == ' ' && pfile->deps_column > 0)
720 pfile->deps_buffer[pfile->deps_size++] = ' ';
721 bcopy (string, &pfile->deps_buffer[pfile->deps_size], size);
722 pfile->deps_size += size;
723 pfile->deps_column += size;
725 pfile->deps_buffer[pfile->deps_size++] = ':';
726 pfile->deps_buffer[pfile->deps_size] = 0;
729 /* Given a colon-separated list of file names PATH,
730 add all the names to the search path for include files. */
733 path_include (pfile, path)
745 struct file_name_list *dirtmp;
747 /* Find the end of this name. */
748 while (*q != 0 && *q != PATH_SEPARATOR) q++;
750 /* An empty name in the path stands for the current directory. */
751 name = (char *) xmalloc (2);
755 /* Otherwise use the directory that is named. */
756 name = (char *) xmalloc (q - p + 1);
757 bcopy (p, name, q - p);
761 dirtmp = (struct file_name_list *)
762 xmalloc (sizeof (struct file_name_list));
763 dirtmp->next = 0; /* New one goes on the end */
764 dirtmp->control_macro = 0;
765 dirtmp->c_system_include_path = 0;
766 dirtmp->fname = name;
767 dirtmp->got_name_map = 0;
768 append_include_chain (pfile, dirtmp, dirtmp);
770 /* Advance past this name. */
774 /* Skip the colon. */
780 cpp_options_init (opts)
783 bzero ((char *) opts, sizeof *opts);
784 opts->in_fname = NULL;
785 opts->out_fname = NULL;
787 /* Initialize is_idchar to allow $. */
788 opts->dollars_in_ident = 1;
789 initialize_char_syntax (opts);
791 opts->no_line_commands = 0;
792 opts->no_trigraphs = 1;
793 opts->put_out_comments = 0;
794 opts->print_include_names = 0;
795 opts->dump_macros = dump_none;
798 opts->cplusplus_comments = 0;
805 opts->pedantic_errors = 0;
806 opts->inhibit_warnings = 0;
807 opts->warn_comments = 0;
808 opts->warn_import = 1;
809 opts->warnings_are_errors = 0;
813 null_underflow (pfile)
820 null_cleanup (pbuf, pfile)
828 macro_cleanup (pbuf, pfile)
832 HASHNODE *macro = (HASHNODE *) pbuf->data;
833 if (macro->type == T_DISABLED)
834 macro->type = T_MACRO;
835 if (macro->type != T_MACRO || pbuf->buf != macro->value.defn->expansion)
841 file_cleanup (pbuf, pfile)
853 /* Assuming we have read '/'.
854 If this is the start of a comment (followed by '*' or '/'),
855 skip to the end of the comment, and return ' '.
856 Return EOF if we reached the end of file before the end of the comment.
857 If not the start of a comment, return '/'. */
860 skip_comment (pfile, linep)
865 while (PEEKC() == '\\' && PEEKN(1) == '\n')
880 while (c == '\\' && PEEKC() == '\n')
884 FORWARD(1), c = GETC();
886 if (prev_c == '*' && c == '/')
888 if (c == '\n' && linep)
892 else if (PEEKC() == '/' && CPP_OPTIONS (pfile)->cplusplus_comments)
899 return ' '; /* Allow // to be terminated by EOF. */
900 while (c == '\\' && PEEKC() == '\n')
909 /* Don't consider final '\n' to be part of comment. */
919 /* Skip whitespace \-newline and comments. Does not macro-expand. */
922 cpp_skip_hspace (pfile)
932 if ((c == '\f' || c == '\v') && CPP_PEDANTIC (pfile))
933 cpp_pedwarn (pfile, "%s in preprocessing directive",
934 c == '\f' ? "formfeed" : "vertical tab");
940 c = skip_comment (pfile, NULL);
943 if (c == EOF || c == '/')
946 else if (c == '\\' && PEEKN(1) == '\n') {
949 else if (c == '@' && CPP_BUFFER (pfile)->has_escapes
950 && is_hor_space[PEEKN(1)])
956 /* Read the rest of the current line.
957 The line is appended to PFILE's output buffer. */
960 copy_rest_of_line (pfile)
963 struct cpp_options *opts = CPP_OPTIONS (pfile);
980 goto scan_directive_token;
984 if (nextc == '*' || (opts->cplusplus_comments && nextc == '*'))
985 goto scan_directive_token;
989 if (CPP_PEDANTIC (pfile))
990 cpp_pedwarn (pfile, "%s in preprocessing directive",
991 c == '\f' ? "formfeed" : "vertical tab");
997 scan_directive_token:
999 cpp_get_token (pfile);
1002 CPP_PUTC (pfile, c);
1005 CPP_NUL_TERMINATE (pfile);
1009 skip_rest_of_line (pfile)
1012 long old = CPP_WRITTEN (pfile);
1013 copy_rest_of_line (pfile);
1014 CPP_SET_WRITTEN (pfile, old);
1017 /* Handle a possible # directive.
1018 '#' has already been read. */
1021 handle_directive (pfile)
1024 register struct directive *kt;
1027 U_CHAR *ident, *line_end;
1028 long old_written = CPP_WRITTEN (pfile);
1030 cpp_skip_hspace (pfile);
1033 if (c >= '0' && c <= '9')
1035 /* Handle # followed by a line number. */
1036 if (CPP_PEDANTIC (pfile))
1037 cpp_pedwarn (pfile, "`#' followed by integer");
1038 do_line (pfile, NULL);
1039 goto done_a_directive;
1042 /* Now find the directive name. */
1043 CPP_PUTC (pfile, '#');
1044 parse_name (pfile, GETC());
1045 ident = pfile->token_buffer + old_written + 1;
1046 ident_length = CPP_PWRITTEN (pfile) - ident;
1047 if (ident_length == 0 && PEEKC() == '\n')
1049 /* A line of just `#' becomes blank. */
1050 goto done_a_directive;
1054 if (ident_length == 0 || !is_idstart[*ident]) {
1056 while (is_idchar[*p]) {
1057 if (*p < '0' || *p > '9')
1061 /* Avoid error for `###' and similar cases unless -pedantic. */
1063 while (*p == '#' || is_hor_space[*p]) p++;
1065 if (pedantic && !lang_asm)
1066 cpp_warning (pfile, "invalid preprocessor directive");
1072 cpp_error (pfile, "invalid preprocessor directive name");
1078 * Decode the keyword and call the appropriate expansion
1079 * routine, after moving the input pointer up to the next line.
1081 for (kt = directive_table; ; kt++) {
1082 if (kt->length <= 0)
1083 goto not_a_directive;
1084 if (kt->length == ident_length && !strncmp (kt->name, ident, ident_length))
1088 if (kt->command_reads_line)
1092 /* Nonzero means do not delete comments within the directive.
1093 #define needs this when -traditional. */
1094 int comments = CPP_TRADITIONAL (pfile) && kt->traditional_comments;
1095 int save_put_out_comments = CPP_OPTIONS (pfile)->put_out_comments;
1096 CPP_OPTIONS (pfile)->put_out_comments = comments;
1097 after_ident = CPP_WRITTEN (pfile);
1098 copy_rest_of_line (pfile);
1099 CPP_OPTIONS (pfile)->put_out_comments = save_put_out_comments;
1102 /* For #pragma and #define, we may want to pass through the directive.
1103 Other directives may create output, but we don't want the directive
1104 itself out, so we pop it now. For example #include may write a #line
1105 command (see comment in do_include), and conditionals may emit
1106 #failed ... #endfailed stuff. But note that popping the buffer
1107 means the parameters to kt->func may point after pfile->limit
1108 so these parameters are invalid as soon as something gets appended
1109 to the token_buffer. */
1111 line_end = CPP_PWRITTEN (pfile);
1112 if (!kt->pass_thru && kt->type != T_DEFINE)
1113 CPP_SET_WRITTEN (pfile, old_written);
1115 (*kt->func) (pfile, kt, pfile->token_buffer + after_ident, line_end);
1117 || (kt->type == T_DEFINE
1118 && CPP_OPTIONS (pfile)->dump_macros == dump_definitions))
1120 /* Just leave the entire #define in the output stack. */
1122 else if (kt->type == T_DEFINE
1123 && CPP_OPTIONS (pfile)->dump_macros == dump_names)
1125 U_CHAR *p = pfile->token_buffer + old_written + 7; /* Skip "#define". */
1126 SKIP_WHITE_SPACE (p);
1127 while (is_idchar[*p]) p++;
1129 CPP_PUTC (pfile, '\n');
1131 else if (kt->type == T_DEFINE)
1132 CPP_SET_WRITTEN (pfile, old_written);
1140 /* Pass a directive through to the output file.
1141 BUF points to the contents of the directive, as a contiguous string.
1142 LIMIT points to the first character past the end of the directive.
1143 KEYWORD is the keyword-table entry for the directive. */
1146 pass_thru_directive (buf, limit, pfile, keyword)
1147 U_CHAR *buf, *limit;
1149 struct directive *keyword;
1151 register unsigned keyword_length = keyword->length;
1153 CPP_RESERVE (pfile, 1 + keyword_length + (limit - buf));
1154 CPP_PUTC_Q (pfile, '#');
1155 CPP_PUTS_Q (pfile, keyword->name, keyword_length);
1156 if (limit != buf && buf[0] != ' ')
1157 CPP_PUTC_Q (pfile, ' ');
1158 CPP_PUTS_Q (pfile, buf, limit - buf);
1160 CPP_PUTS_Q (pfile, '\n');
1161 /* Count the line we have just made in the output,
1162 to get in sync properly. */
1167 /* The arglist structure is built by do_define to tell
1168 collect_definition where the argument names begin. That
1169 is, for a define like "#define f(x,y,z) foo+x-bar*y", the arglist
1170 would contain pointers to the strings x, y, and z.
1171 Collect_definition would then build a DEFINITION node,
1172 with reflist nodes pointing to the places x, y, and z had
1173 appeared. So the arglist is just convenience data passed
1174 between these two routines. It is not kept around after
1175 the current #define has been processed and entered into the
1179 struct arglist *next;
1186 /* Read a replacement list for a macro with parameters.
1187 Build the DEFINITION structure.
1188 Reads characters of text starting at BUF until END.
1189 ARGLIST specifies the formal parameters to look for
1190 in the text of the definition; NARGS is the number of args
1191 in that list, or -1 for a macro name that wants no argument list.
1192 MACRONAME is the macro name itself (so we can avoid recursive expansion)
1193 and NAMELEN is its length in characters.
1195 Note that comments, backslash-newlines, and leading white space
1196 have already been deleted from the argument. */
1199 collect_expansion (pfile, buf, limit, nargs, arglist)
1201 U_CHAR *buf, *limit;
1203 struct arglist *arglist;
1206 register U_CHAR *p, *lastp, *exp_p;
1207 struct reflist *endpat = NULL;
1208 /* Pointer to first nonspace after last ## seen. */
1210 /* Pointer to first nonspace after last single-# seen. */
1211 U_CHAR *stringify = 0;
1213 int expected_delimiter = '\0';
1215 /* Scan thru the replacement list, ignoring comments and quoted
1216 strings, picking up on the macro calls. It does a linear search
1217 thru the arg list on every potential symbol. Profiling might say
1218 that something smarter should happen. */
1223 /* Find the beginning of the trailing whitespace. */
1225 while (p < limit && is_space[limit[-1]]) limit--;
1227 /* Allocate space for the text in the macro definition.
1228 Leading and trailing whitespace chars need 2 bytes each.
1229 Each other input char may or may not need 1 byte,
1230 so this is an upper bound. The extra 5 are for invented
1231 leading and trailing newline-marker and final null. */
1232 maxsize = (sizeof (DEFINITION)
1234 /* Occurrences of '@' get doubled, so allocate extra space for them. */
1238 defn = (DEFINITION *) xcalloc (1, maxsize);
1240 defn->nargs = nargs;
1241 exp_p = defn->expansion = (U_CHAR *) defn + sizeof (DEFINITION);
1246 /* Add one initial space escape-marker to prevent accidental
1247 token-pasting (often removed by macroexpand). */
1251 if (limit - p >= 2 && p[0] == '#' && p[1] == '#') {
1252 cpp_error (pfile, "`##' at start of macro definition");
1256 /* Process the main body of the definition. */
1258 int skipped_arg = 0;
1259 register U_CHAR c = *p++;
1263 if (!CPP_TRADITIONAL (pfile)) {
1267 if (expected_delimiter != '\0') {
1268 if (c == expected_delimiter)
1269 expected_delimiter = '\0';
1271 expected_delimiter = c;
1275 if (p < limit && expected_delimiter) {
1276 /* In a string, backslash goes through
1277 and makes next char ordinary. */
1283 /* An '@' in a string or character constant stands for itself,
1284 and does not need to be escaped. */
1285 if (!expected_delimiter)
1290 /* # is ordinary inside a string. */
1291 if (expected_delimiter)
1293 if (p < limit && *p == '#') {
1294 /* ##: concatenate preceding and following tokens. */
1295 /* Take out the first #, discard preceding whitespace. */
1297 while (exp_p > lastp && is_hor_space[exp_p[-1]])
1299 /* Skip the second #. */
1301 /* Discard following whitespace. */
1302 SKIP_WHITE_SPACE (p);
1305 cpp_error (pfile, "`##' at end of macro definition");
1306 } else if (nargs >= 0) {
1307 /* Single #: stringify following argument ref.
1308 Don't leave the # in the expansion. */
1310 SKIP_WHITE_SPACE (p);
1311 if (p == limit || ! is_idstart[*p]
1312 || (*p == 'L' && p + 1 < limit && (p[1] == '\'' || p[1] == '"')))
1314 "`#' operator is not followed by a macro argument name");
1321 /* In -traditional mode, recognize arguments inside strings and
1322 and character constants, and ignore special properties of #.
1323 Arguments inside strings are considered "stringified", but no
1324 extra quote marks are supplied. */
1328 if (expected_delimiter != '\0') {
1329 if (c == expected_delimiter)
1330 expected_delimiter = '\0';
1332 expected_delimiter = c;
1336 /* Backslash quotes delimiters and itself, but not macro args. */
1337 if (expected_delimiter != 0 && p < limit
1338 && (*p == expected_delimiter || *p == '\\')) {
1345 if (expected_delimiter != '\0') /* No comments inside strings. */
1348 /* If we find a comment that wasn't removed by handle_directive,
1349 this must be -traditional. So replace the comment with
1353 while (p < limit && !(p[-2] == '*' && p[-1] == '/'))
1356 /* Mark this as a concatenation-point, as if it had been ##. */
1364 /* Handle the start of a symbol. */
1365 if (is_idchar[c] && nargs > 0) {
1366 U_CHAR *id_beg = p - 1;
1370 while (p != limit && is_idchar[*p]) p++;
1371 id_len = p - id_beg;
1374 && ! (id_len == 1 && c == 'L' && (*p == '\'' || *p == '"'))) {
1375 register struct arglist *arg;
1377 for (arg = arglist; arg != NULL; arg = arg->next) {
1378 struct reflist *tpat;
1380 if (arg->name[0] == c
1381 && arg->length == id_len
1382 && strncmp (arg->name, id_beg, id_len) == 0) {
1383 if (expected_delimiter && CPP_OPTIONS (pfile)->warn_stringify) {
1384 if (CPP_TRADITIONAL (pfile)) {
1385 cpp_warning (pfile, "macro argument `%.*s' is stringified.",
1389 "macro arg `%.*s' would be stringified with -traditional.",
1393 /* If ANSI, don't actually substitute inside a string. */
1394 if (!CPP_TRADITIONAL (pfile) && expected_delimiter)
1396 /* make a pat node for this arg and append it to the end of
1398 tpat = (struct reflist *) xmalloc (sizeof (struct reflist));
1400 tpat->raw_before = concat == id_beg;
1401 tpat->raw_after = 0;
1402 tpat->rest_args = arg->rest_args;
1403 tpat->stringify = (CPP_TRADITIONAL (pfile)
1404 ? expected_delimiter != '\0'
1405 : stringify == id_beg);
1408 defn->pattern = tpat;
1410 endpat->next = tpat;
1413 tpat->argno = arg->argno;
1414 tpat->nchars = exp_p - lastp;
1416 register U_CHAR *p1 = p;
1417 SKIP_WHITE_SPACE (p1);
1418 if (p1 + 2 <= limit && p1[0] == '#' && p1[1] == '#')
1419 tpat->raw_after = 1;
1421 lastp = exp_p; /* place to start copying from next time */
1428 /* If this was not a macro arg, copy it into the expansion. */
1429 if (! skipped_arg) {
1430 register U_CHAR *lim1 = p;
1434 if (stringify == id_beg)
1436 "`#' operator should be followed by a macro argument name");
1441 if (!CPP_TRADITIONAL (pfile) && expected_delimiter == 0)
1443 /* If ANSI, put in a "@ " marker to prevent token pasting.
1444 But not if "inside a string" (which in ANSI mode
1445 happens only for -D option). */
1452 defn->length = exp_p - defn->expansion;
1454 /* Crash now if we overrun the allocated size. */
1455 if (defn->length + 1 > maxsize)
1459 /* This isn't worth the time it takes. */
1460 /* give back excess storage */
1461 defn->expansion = (U_CHAR *) xrealloc (defn->expansion, defn->length + 1);
1468 * special extension string that can be added to the last macro argument to
1469 * allow it to absorb the "rest" of the arguments when expanded. Ex:
1470 * #define wow(a, b...) process (b, a, b)
1471 * { wow (1, 2, 3); } -> { process (2, 3, 1, 2, 3); }
1472 * { wow (one, two); } -> { process (two, one, two); }
1473 * if this "rest_arg" is used with the concat token '##' and if it is not
1474 * supplied then the token attached to with ## will not be outputted. Ex:
1475 * #define wow (a, b...) process (b ## , a, ## b)
1476 * { wow (1, 2); } -> { process (2, 1, 2); }
1477 * { wow (one); } -> { process (one); {
1479 static char rest_extension[] = "...";
1480 #define REST_EXTENSION_LENGTH (sizeof (rest_extension) - 1)
1482 /* Create a DEFINITION node from a #define directive. Arguments are
1483 as for do_define. */
1486 create_definition (buf, limit, pfile, predefinition)
1487 U_CHAR *buf, *limit;
1491 U_CHAR *bp; /* temp ptr into input buffer */
1492 U_CHAR *symname; /* remember where symbol name starts */
1493 int sym_length; /* and how long it is */
1496 char *file = CPP_BUFFER (pfile) ? CPP_BUFFER (pfile)->nominal_fname : "";
1498 int arglengths = 0; /* Accumulate lengths of arg names
1499 plus number of args. */
1501 cpp_buf_line_and_col (CPP_BUFFER (pfile), &line, &col);
1505 while (is_hor_space[*bp])
1508 symname = bp; /* remember where it starts */
1510 sym_length = check_macro_name (pfile, bp, "macro");
1513 /* Lossage will occur if identifiers or control keywords are broken
1514 across lines using backslash. This is not the right place to take
1518 struct arglist *arg_ptrs = NULL;
1521 bp++; /* skip '(' */
1522 SKIP_WHITE_SPACE (bp);
1524 /* Loop over macro argument names. */
1525 while (*bp != ')') {
1526 struct arglist *temp;
1528 temp = (struct arglist *) alloca (sizeof (struct arglist));
1530 temp->next = arg_ptrs;
1531 temp->argno = argno++;
1532 temp->rest_args = 0;
1536 cpp_pedwarn (pfile, "another parameter follows `%s'", rest_extension);
1538 if (!is_idstart[*bp])
1539 cpp_pedwarn (pfile, "invalid character in macro parameter name");
1541 /* Find the end of the arg name. */
1542 while (is_idchar[*bp]) {
1544 /* do we have a "special" rest-args extension here? */
1545 if (limit - bp > REST_EXTENSION_LENGTH &&
1546 strncmp (rest_extension, bp, REST_EXTENSION_LENGTH) == 0) {
1548 temp->rest_args = 1;
1552 temp->length = bp - temp->name;
1554 bp += REST_EXTENSION_LENGTH;
1555 arglengths += temp->length + 2;
1556 SKIP_WHITE_SPACE (bp);
1557 if (temp->length == 0 || (*bp != ',' && *bp != ')')) {
1558 cpp_error (pfile, "badly punctuated parameter list in `#define'");
1563 SKIP_WHITE_SPACE (bp);
1566 cpp_error (pfile, "unterminated parameter list in `#define'");
1570 struct arglist *otemp;
1572 for (otemp = temp->next; otemp != NULL; otemp = otemp->next)
1573 if (temp->length == otemp->length &&
1574 strncmp (temp->name, otemp->name, temp->length) == 0) {
1577 name = (U_CHAR *) alloca (temp->length + 1);
1578 (void) strncpy (name, temp->name, temp->length);
1579 name[temp->length] = '\0';
1581 "duplicate argument name `%s' in `#define'", name);
1587 ++bp; /* skip paren */
1588 SKIP_WHITE_SPACE (bp);
1589 /* now everything from bp before limit is the definition. */
1590 defn = collect_expansion (pfile, bp, limit, argno, arg_ptrs);
1591 defn->rest_args = rest_args;
1593 /* Now set defn->args.argnames to the result of concatenating
1594 the argument names in reverse order
1595 with comma-space between them. */
1596 defn->args.argnames = (U_CHAR *) xmalloc (arglengths + 1);
1598 struct arglist *temp;
1600 for (temp = arg_ptrs; temp; temp = temp->next) {
1601 bcopy (temp->name, &defn->args.argnames[i], temp->length);
1603 if (temp->next != 0) {
1604 defn->args.argnames[i++] = ',';
1605 defn->args.argnames[i++] = ' ';
1608 defn->args.argnames[i] = 0;
1611 /* Simple expansion or empty definition. */
1615 if (is_hor_space[*bp]) {
1617 SKIP_WHITE_SPACE (bp);
1620 case '!': case '"': case '#': case '%': case '&': case '\'':
1621 case ')': case '*': case '+': case ',': case '-': case '.':
1622 case '/': case ':': case ';': case '<': case '=': case '>':
1623 case '?': case '[': case '\\': case ']': case '^': case '{':
1624 case '|': case '}': case '~':
1625 cpp_warning (pfile, "missing white space after `#define %.*s'",
1626 sym_length, symname);
1630 cpp_pedwarn (pfile, "missing white space after `#define %.*s'",
1631 sym_length, symname);
1636 /* now everything from bp before limit is the definition. */
1637 defn = collect_expansion (pfile, bp, limit, -1, NULL_PTR);
1638 defn->args.argnames = (U_CHAR *) "";
1644 /* OP is null if this is a predefinition */
1645 defn->predefined = predefinition;
1647 mdef.symnam = symname;
1648 mdef.symlen = sym_length;
1657 /* Check a purported macro name SYMNAME, and yield its length.
1658 USAGE is the kind of name this is intended for. */
1661 check_macro_name (pfile, symname, usage)
1669 for (p = symname; is_idchar[*p]; p++)
1671 sym_length = p - symname;
1673 || (sym_length == 1 && *symname == 'L' && (*p == '\'' || *p == '"')))
1674 cpp_error (pfile, "invalid %s name", usage);
1675 else if (!is_idstart[*symname]) {
1676 U_CHAR *msg; /* what pain... */
1677 msg = (U_CHAR *) alloca (sym_length + 1);
1678 bcopy (symname, msg, sym_length);
1679 msg[sym_length] = 0;
1680 cpp_error (pfile, "invalid %s name `%s'", usage, msg);
1682 if (! strncmp (symname, "defined", 7) && sym_length == 7)
1683 cpp_error (pfile, "invalid %s name `defined'", usage);
1688 /* Return zero if two DEFINITIONs are isomorphic. */
1691 compare_defs (d1, d2)
1692 DEFINITION *d1, *d2;
1694 register struct reflist *a1, *a2;
1695 register U_CHAR *p1 = d1->expansion;
1696 register U_CHAR *p2 = d2->expansion;
1699 if (d1->nargs != d2->nargs)
1701 if (strcmp ((char *)d1->args.argnames, (char *)d2->args.argnames))
1703 for (a1 = d1->pattern, a2 = d2->pattern; a1 && a2;
1704 a1 = a1->next, a2 = a2->next) {
1705 if (!((a1->nchars == a2->nchars && ! strncmp (p1, p2, a1->nchars))
1706 || ! comp_def_part (first, p1, a1->nchars, p2, a2->nchars, 0))
1707 || a1->argno != a2->argno
1708 || a1->stringify != a2->stringify
1709 || a1->raw_before != a2->raw_before
1710 || a1->raw_after != a2->raw_after)
1718 if (comp_def_part (first, p1, d1->length - (p1 - d1->expansion),
1719 p2, d2->length - (p2 - d2->expansion), 1))
1724 /* Return 1 if two parts of two macro definitions are effectively different.
1725 One of the parts starts at BEG1 and has LEN1 chars;
1726 the other has LEN2 chars at BEG2.
1727 Any sequence of whitespace matches any other sequence of whitespace.
1728 FIRST means these parts are the first of a macro definition;
1729 so ignore leading whitespace entirely.
1730 LAST means these parts are the last of a macro definition;
1731 so ignore trailing whitespace entirely. */
1734 comp_def_part (first, beg1, len1, beg2, len2, last)
1736 U_CHAR *beg1, *beg2;
1740 register U_CHAR *end1 = beg1 + len1;
1741 register U_CHAR *end2 = beg2 + len2;
1743 while (beg1 != end1 && is_space[*beg1]) beg1++;
1744 while (beg2 != end2 && is_space[*beg2]) beg2++;
1747 while (beg1 != end1 && is_space[end1[-1]]) end1--;
1748 while (beg2 != end2 && is_space[end2[-1]]) end2--;
1750 while (beg1 != end1 && beg2 != end2) {
1751 if (is_space[*beg1] && is_space[*beg2]) {
1752 while (beg1 != end1 && is_space[*beg1]) beg1++;
1753 while (beg2 != end2 && is_space[*beg2]) beg2++;
1754 } else if (*beg1 == *beg2) {
1758 return (beg1 != end1) || (beg2 != end2);
1761 /* Process a #define command.
1762 BUF points to the contents of the #define command, as a contiguous string.
1763 LIMIT points to the first character past the end of the definition.
1764 KEYWORD is the keyword-table entry for #define,
1765 or NULL for a "predefined" macro. */
1768 do_define (pfile, keyword, buf, limit)
1770 struct directive *keyword;
1771 U_CHAR *buf, *limit;
1778 /* If this is a precompiler run (with -pcp) pass thru #define commands. */
1779 if (pcp_outfile && keyword)
1780 pass_thru_directive (buf, limit, pfile, keyword);
1783 mdef = create_definition (buf, limit, pfile, keyword == NULL);
1787 hashcode = hashf (mdef.symnam, mdef.symlen, HASHSIZE);
1789 if ((hp = cpp_lookup (pfile, mdef.symnam, mdef.symlen, hashcode)) != NULL)
1792 /* Redefining a precompiled key is ok. */
1793 if (hp->type == T_PCSTRING)
1795 /* Redefining a macro is ok if the definitions are the same. */
1796 else if (hp->type == T_MACRO)
1797 ok = ! compare_defs (mdef.defn, hp->value.defn);
1798 /* Redefining a constant is ok with -D. */
1799 else if (hp->type == T_CONST)
1800 ok = ! CPP_OPTIONS (pfile)->done_initializing;
1801 /* Print the warning if it's not ok. */
1804 U_CHAR *msg; /* what pain... */
1806 /* If we are passing through #define and #undef directives, do
1807 that for this re-definition now. */
1808 if (CPP_OPTIONS (pfile)->debug_output && keyword)
1809 pass_thru_directive (buf, limit, pfile, keyword);
1811 msg = (U_CHAR *) alloca (mdef.symlen + 22);
1813 bcopy (mdef.symnam, msg + 1, mdef.symlen);
1814 strcpy ((char *) (msg + mdef.symlen + 1), "' redefined");
1815 cpp_pedwarn (pfile, msg);
1816 if (hp->type == T_MACRO)
1817 cpp_pedwarn_with_file_and_line (pfile, hp->value.defn->file, hp->value.defn->line,
1818 "this is the location of the previous definition");
1820 /* Replace the old definition. */
1822 hp->value.defn = mdef.defn;
1826 /* If we are passing through #define and #undef directives, do
1827 that for this new definition now. */
1828 if (CPP_OPTIONS (pfile)->debug_output && keyword)
1829 pass_thru_directive (buf, limit, pfile, keyword);
1830 install (mdef.symnam, mdef.symlen, T_MACRO, 0,
1831 (char *) mdef.defn, hashcode);
1841 /* This structure represents one parsed argument in a macro call.
1842 `raw' points to the argument text as written (`raw_length' is its length).
1843 `expanded' points to the argument's macro-expansion
1844 (its length is `expand_length').
1845 `stringified_length' is the length the argument would have
1847 `use_count' is the number of times this macro arg is substituted
1848 into the macro. If the actual use count exceeds 10,
1849 the value stored is 10. */
1851 /* raw and expanded are relative to ARG_BASE */
1852 #define ARG_BASE ((pfile)->token_buffer)
1855 /* Strings relative to pfile->token_buffer */
1856 long raw, expanded, stringified;
1857 int raw_length, expand_length;
1858 int stringified_length;
1863 /* Allocate a new cpp_buffer for PFILE, and push it on the input buffer stack.
1864 If BUFFER != NULL, then use the LENGTH characters in BUFFER
1865 as the new input buffer.
1866 Return the new buffer, or NULL on failure. */
1869 cpp_push_buffer (pfile, buffer, length)
1874 register cpp_buffer *buf = CPP_BUFFER (pfile);
1875 if (buf == pfile->buffer_stack)
1877 cpp_fatal (pfile, "%s: macro or `#include' recursion too deep",
1882 bzero ((char *) buf, sizeof (cpp_buffer));
1883 CPP_BUFFER (pfile) = buf;
1884 buf->if_stack = pfile->if_stack;
1885 buf->cleanup = null_cleanup;
1886 buf->underflow = null_underflow;
1887 buf->buf = buf->cur = buffer;
1888 buf->alimit = buf->rlimit = buffer + length;
1894 cpp_pop_buffer (pfile)
1897 cpp_buffer *buf = CPP_BUFFER (pfile);
1898 (*buf->cleanup) (buf, pfile);
1899 return ++CPP_BUFFER (pfile);
1902 /* Scan until CPP_BUFFER (PFILE) is exhausted into PFILE->token_buffer.
1903 Pop the buffer when done. */
1906 cpp_scan_buffer (pfile)
1909 cpp_buffer *buffer = CPP_BUFFER (pfile);
1912 enum cpp_token token = cpp_get_token (pfile);
1913 if (token == CPP_EOF) /* Should not happen ... */
1915 if (token == CPP_POP && CPP_BUFFER (pfile) == buffer)
1917 cpp_pop_buffer (pfile);
1924 * Rescan a string (which may have escape marks) into pfile's buffer.
1925 * Place the result in pfile->token_buffer.
1927 * The input is copied before it is scanned, so it is safe to pass
1928 * it something from the token_buffer that will get overwritten
1929 * (because it follows CPP_WRITTEN). This is used by do_include.
1933 cpp_expand_to_buffer (pfile, buf, length)
1938 register cpp_buffer *ip;
1940 U_CHAR *limit = buf + length;
1943 int odepth = indepth;
1949 /* Set up the input on the input stack. */
1951 buf1 = (U_CHAR *) alloca (length + 1);
1953 register U_CHAR *p1 = buf;
1954 register U_CHAR *p2 = buf1;
1961 ip = cpp_push_buffer (pfile, buf1, length);
1964 ip->has_escapes = 1;
1966 ip->lineno = obuf.lineno = 1;
1969 /* Scan the input, create the output. */
1970 cpp_scan_buffer (pfile);
1973 if (indepth != odepth)
1977 CPP_NUL_TERMINATE (pfile);
1982 adjust_position (buf, limit, linep, colp)
1992 (*linep)++, (*colp) = 1;
1998 /* Move line_base forward, updating lineno and colno. */
2001 update_position (pbuf)
2002 register cpp_buffer *pbuf;
2004 unsigned char *old_pos = pbuf->buf + pbuf->line_base;
2005 unsigned char *new_pos = pbuf->cur;
2006 register struct parse_marker *mark;
2007 for (mark = pbuf->marks; mark != NULL; mark = mark->next)
2009 if (pbuf->buf + mark->position < new_pos)
2010 new_pos = pbuf->buf + mark->position;
2012 pbuf->line_base += new_pos - old_pos;
2013 adjust_position (old_pos, new_pos, &pbuf->lineno, &pbuf->colno);
2017 cpp_buf_line_and_col (pbuf, linep, colp)
2018 register cpp_buffer *pbuf;
2026 *linep = pbuf->lineno;
2027 *colp = pbuf->colno;
2028 adjust_position (pbuf->buf + pbuf->line_base, pbuf->cur, linep, colp);
2037 /* Return the cpp_buffer that corresponds to a file (not a macro). */
2040 cpp_file_buffer (pfile)
2043 cpp_buffer *ip = CPP_BUFFER (pfile);
2045 for ( ; ip != CPP_NULL_BUFFER (pfile); ip = CPP_PREV_BUFFER (ip))
2046 if (ip->fname != NULL)
2052 count_newlines (buf, limit)
2053 register U_CHAR *buf;
2054 register U_CHAR *limit;
2056 register long count = 0;
2067 * write out a #line command, for instance, after an #include file.
2068 * If CONDITIONAL is nonzero, we can omit the #line if it would
2069 * appear to be a no-op, and we can output a few newlines instead
2070 * if we want to increase the line number by a small amount.
2071 * FILE_CHANGE says whether we are entering a file, leaving, or neither.
2075 output_line_command (pfile, conditional, file_change)
2078 enum file_change_code file_change;
2081 char *line_cmd_buf, *line_end;
2083 cpp_buffer *ip = CPP_BUFFER (pfile);
2085 if (ip->fname == NULL)
2088 update_position (ip);
2090 if (CPP_OPTIONS (pfile)->no_line_commands
2091 || CPP_OPTIONS (pfile)->no_output)
2094 line = CPP_BUFFER (pfile)->lineno;
2095 col = CPP_BUFFER (pfile)->colno;
2096 adjust_position (CPP_LINE_BASE (ip), ip->cur, &line, &col);
2098 if (CPP_OPTIONS (pfile)->no_line_commands)
2102 if (line == pfile->lineno)
2105 /* If the inherited line number is a little too small,
2106 output some newlines instead of a #line command. */
2107 if (line > pfile->lineno && line < pfile->lineno + 8) {
2108 CPP_RESERVE (pfile, 20);
2109 while (line > pfile->lineno) {
2110 CPP_PUTC_Q (pfile, '\n');
2118 /* Don't output a line number of 0 if we can help it. */
2119 if (ip->lineno == 0 && ip->bufp - ip->buf < ip->length
2120 && *ip->bufp == '\n') {
2126 CPP_RESERVE (pfile, 4 * strlen (ip->nominal_fname) + 50);
2128 #ifdef OUTPUT_LINE_COMMANDS
2129 static char sharp_line[] = "#line ";
2131 static char sharp_line[] = "# ";
2133 CPP_PUTS_Q (pfile, sharp_line, sizeof(sharp_line)-1);
2136 sprintf (CPP_PWRITTEN (pfile), "%d ", line);
2137 CPP_ADJUST_WRITTEN (pfile, strlen (CPP_PWRITTEN (pfile)));
2139 quote_string (pfile, ip->nominal_fname);
2140 if (file_change != same_file) {
2141 CPP_PUTC_Q (pfile, ' ');
2142 CPP_PUTC_Q (pfile, file_change == enter_file ? '1' : '2');
2144 /* Tell cc1 if following text comes from a system header file. */
2145 if (ip->system_header_p) {
2146 CPP_PUTC_Q (pfile, ' ');
2147 CPP_PUTC_Q (pfile, '3');
2149 #ifndef NO_IMPLICIT_EXTERN_C
2150 /* Tell cc1plus if following text should be treated as C. */
2151 if (ip->system_header_p == 2 && CPP_OPTIONS (pfile)->cplusplus) {
2152 CPP_PUTC_Q (pfile, ' ');
2153 CPP_PUTC_Q (pfile, '4');
2156 CPP_PUTC_Q (pfile, '\n');
2157 pfile->lineno = line;
2161 * Parse a macro argument and append the info on PFILE's token_buffer.
2162 * REST_ARGS means to absorb the rest of the args.
2163 * Return nonzero to indicate a syntax error.
2166 static enum cpp_token
2167 macarg (pfile, rest_args)
2172 enum cpp_token token;
2173 long arg_start = CPP_WRITTEN (pfile);
2174 char save_put_out_comments = CPP_OPTIONS (pfile)->put_out_comments;
2175 CPP_OPTIONS (pfile)->put_out_comments = 0;
2177 /* Try to parse as much of the argument as exists at this
2178 input stack level. */
2179 pfile->no_macro_expand++;
2182 token = cpp_get_token (pfile);
2188 /* If we've hit end of file, it's an error (reported by caller).
2189 Ditto if it's the end of cpp_expand_to_buffer text.
2190 If we've hit end of macro, just continue. */
2191 if (! CPP_IS_MACRO_BUFFER (CPP_BUFFER (pfile)))
2202 /* if we've returned to lowest level and
2203 we aren't absorbing all args */
2204 if (paren == 0 && rest_args == 0)
2208 /* Remove ',' or ')' from argument buffer. */
2209 CPP_ADJUST_WRITTEN (pfile, -1);
2216 CPP_OPTIONS (pfile)->put_out_comments = save_put_out_comments;
2217 pfile->no_macro_expand--;
2222 /* Turn newlines to spaces in the string of length LENGTH at START,
2223 except inside of string constants.
2224 The string is copied into itself with its beginning staying fixed. */
2227 change_newlines (start, length)
2231 register U_CHAR *ibp;
2232 register U_CHAR *obp;
2233 register U_CHAR *limit;
2237 limit = start + length;
2240 while (ibp < limit) {
2241 *obp++ = c = *ibp++;
2246 /* Notice and skip strings, so that we don't delete newlines in them. */
2249 while (ibp < limit) {
2250 *obp++ = c = *ibp++;
2253 if (c == '\n' && quotec == '\'')
2269 if (!pfile->timebuf) {
2270 time_t t = time ((time_t *) 0);
2271 pfile->timebuf = localtime (&t);
2273 return pfile->timebuf;
2276 static char *monthnames[] = {"Jan", "Feb", "Mar", "Apr", "May", "Jun",
2277 "Jul", "Aug", "Sep", "Oct", "Nov", "Dec",
2281 * expand things like __FILE__. Place the expansion into the output
2282 * buffer *without* rescanning.
2286 special_symbol (hp, pfile)
2293 cpp_buffer *ip = NULL;
2296 int paren = 0; /* For special `defined' keyword */
2299 if (pcp_outfile && pcp_inside_if
2300 && hp->type != T_SPEC_DEFINED && hp->type != T_CONST)
2302 "Predefined macro `%s' used inside `#if' during precompilation",
2306 for (ip = CPP_BUFFER (pfile); ; ip = CPP_PREV_BUFFER (ip))
2308 if (ip == CPP_NULL_BUFFER (pfile))
2310 cpp_error (pfile, "cccp error: not in any file?!");
2311 return; /* the show must go on */
2313 if (ip->fname != NULL)
2323 if (hp->type == T_BASE_FILE)
2325 while (CPP_PREV_BUFFER (ip) != CPP_NULL_BUFFER (pfile))
2326 ip = CPP_PREV_BUFFER (ip);
2328 string = ip->nominal_fname;
2332 CPP_RESERVE (pfile, 3 + 4 * strlen (string));
2333 quote_string (pfile, string);
2337 case T_INCLUDE_LEVEL:
2339 ip = CPP_BUFFER (pfile);
2340 for (; ip != CPP_NULL_BUFFER (pfile); ip = CPP_PREV_BUFFER (ip))
2341 if (ip->fname != NULL)
2344 buf = (char *) alloca (8); /* Eight bytes ought to be more than enough */
2345 sprintf (buf, "%d", true_indepth - 1);
2349 buf = (char *) alloca (3 + strlen (version_string));
2350 sprintf (buf, "\"%s\"", version_string);
2353 #ifndef NO_BUILTIN_SIZE_TYPE
2359 #ifndef NO_BUILTIN_PTRDIFF_TYPE
2360 case T_PTRDIFF_TYPE:
2366 buf = CPP_WCHAR_TYPE (pfile);
2369 case T_USER_LABEL_PREFIX_TYPE:
2370 buf = USER_LABEL_PREFIX;
2373 case T_REGISTER_PREFIX_TYPE:
2374 buf = REGISTER_PREFIX;
2378 buf = (char *) alloca (4 * sizeof (int));
2379 sprintf (buf, "%d", hp->value.ival);
2381 if (pcp_inside_if && pcp_outfile)
2382 /* Output a precondition for this macro use */
2383 fprintf (pcp_outfile, "#define %s %d\n", hp->name, hp->value.ival);
2389 long line = ip->lineno;
2390 long col = ip->colno;
2391 adjust_position (CPP_LINE_BASE (ip), ip->cur, &line, &col);
2393 buf = (char *) alloca (10);
2394 sprintf (buf, "%d", line);
2400 buf = (char *) alloca (20);
2401 timebuf = timestamp (pfile);
2402 if (hp->type == T_DATE)
2403 sprintf (buf, "\"%s %2d %4d\"", monthnames[timebuf->tm_mon],
2404 timebuf->tm_mday, timebuf->tm_year + 1900);
2406 sprintf (buf, "\"%02d:%02d:%02d\"", timebuf->tm_hour, timebuf->tm_min,
2410 case T_SPEC_DEFINED:
2411 buf = " 0 "; /* Assume symbol is not defined */
2412 ip = CPP_BUFFER (pfile);
2413 SKIP_WHITE_SPACE (ip->cur);
2414 if (*ip->cur == '(')
2417 ip->cur++; /* Skip over the paren */
2418 SKIP_WHITE_SPACE (ip->cur);
2421 if (!is_idstart[*ip->cur])
2423 if (ip->cur[0] == 'L' && (ip->cur[1] == '\'' || ip->cur[1] == '"'))
2425 if (hp = cpp_lookup (pfile, ip->cur, -1, -1))
2428 if (pcp_outfile && pcp_inside_if
2429 && (hp->type == T_CONST
2430 || (hp->type == T_MACRO && hp->value.defn->predefined)))
2431 /* Output a precondition for this macro use. */
2432 fprintf (pcp_outfile, "#define %s\n", hp->name);
2438 if (pcp_outfile && pcp_inside_if)
2440 /* Output a precondition for this macro use */
2441 U_CHAR *cp = ip->bufp;
2442 fprintf (pcp_outfile, "#undef ");
2443 while (is_idchar[*cp]) /* Ick! */
2444 fputc (*cp++, pcp_outfile);
2445 putc ('\n', pcp_outfile);
2448 while (is_idchar[*ip->cur])
2450 SKIP_WHITE_SPACE (ip->cur);
2453 if (*ip->cur != ')')
2461 cpp_error (pfile, "`defined' without an identifier");
2465 cpp_error (pfile, "cccp error: invalid special hash type"); /* time for gdb */
2469 CPP_RESERVE (pfile, len + 1);
2470 CPP_PUTS_Q (pfile, buf, len);
2471 CPP_NUL_TERMINATE_Q (pfile);
2476 /* Write out a #define command for the special named MACRO_NAME
2477 to PFILE's token_buffer. */
2480 dump_special_to_buffer (pfile, macro_name)
2484 static char define_directive[] = "#define ";
2485 int macro_name_length = strlen (macro_name);
2486 output_line_command (pfile, 0, same_file);
2487 CPP_RESERVE (pfile, sizeof(define_directive) + macro_name_length);
2488 CPP_PUTS_Q (pfile, define_directive, sizeof(define_directive)-1);
2489 CPP_PUTS_Q (pfile, macro_name, macro_name_length);
2490 CPP_PUTC_Q (pfile, ' ');
2491 cpp_expand_to_buffer (pfile, macro_name, macro_name_length);
2492 CPP_PUTC (pfile, '\n');
2495 /* Initialize the built-in macros. */
2498 initialize_builtins (pfile)
2501 install ("__LINE__", -1, T_SPECLINE, 0, 0, -1);
2502 install ("__DATE__", -1, T_DATE, 0, 0, -1);
2503 install ("__FILE__", -1, T_FILE, 0, 0, -1);
2504 install ("__BASE_FILE__", -1, T_BASE_FILE, 0, 0, -1);
2505 install ("__INCLUDE_LEVEL__", -1, T_INCLUDE_LEVEL, 0, 0, -1);
2506 install ("__VERSION__", -1, T_VERSION, 0, 0, -1);
2507 #ifndef NO_BUILTIN_SIZE_TYPE
2508 install ("__SIZE_TYPE__", -1, T_SIZE_TYPE, 0, 0, -1);
2510 #ifndef NO_BUILTIN_PTRDIFF_TYPE
2511 install ("__PTRDIFF_TYPE__ ", -1, T_PTRDIFF_TYPE, 0, 0, -1);
2513 install ("__WCHAR_TYPE__", -1, T_WCHAR_TYPE, 0, 0, -1);
2514 install ("__USER_LABEL_PREFIX__", -1, T_USER_LABEL_PREFIX_TYPE, 0, 0, -1);
2515 install ("__REGISTER_PREFIX__", -1, T_REGISTER_PREFIX_TYPE, 0, 0, -1);
2516 install ("__TIME__", -1, T_TIME, 0, 0, -1);
2517 if (!CPP_TRADITIONAL (pfile))
2518 install ("__STDC__", -1, T_CONST, STDC_VALUE, 0, -1);
2519 if (CPP_OPTIONS (pfile)->objc)
2520 install ("__OBJC__", -1, T_CONST, 1, 0, -1);
2521 /* This is supplied using a -D by the compiler driver
2522 so that it is present only when truly compiling with GNU C. */
2523 /* install ("__GNUC__", -1, T_CONST, 2, 0, -1); */
2525 if (CPP_OPTIONS (pfile)->debug_output)
2527 dump_special_to_buffer (pfile, "__BASE_FILE__");
2528 dump_special_to_buffer (pfile, "__VERSION__");
2529 #ifndef NO_BUILTIN_SIZE_TYPE
2530 dump_special_to_buffer (pfile, "__SIZE_TYPE__");
2532 #ifndef NO_BUILTIN_PTRDIFF_TYPE
2533 dump_special_to_buffer (pfile, "__PTRDIFF_TYPE__");
2535 dump_special_to_buffer (pfile, "__WCHAR_TYPE__");
2536 dump_special_to_buffer (pfile, "__DATE__");
2537 dump_special_to_buffer (pfile, "__TIME__");
2538 if (!CPP_TRADITIONAL (pfile))
2539 dump_special_to_buffer (pfile, "__STDC__");
2540 if (CPP_OPTIONS (pfile)->objc)
2541 dump_special_to_buffer (pfile, "__OBJC__");
2545 /* Return 1 iff a token ending in C1 followed directly by a token C2
2546 could cause mis-tokenization. */
2549 unsafe_chars (c1, c2)
2555 if (c2 == c1 || c2 == '=')
2559 case '0': case '1': case '2': case '3': case '4':
2560 case '5': case '6': case '7': case '8': case '9':
2561 case 'e': case 'E': case 'p': case 'P':
2562 if (c2 == '-' || c2 == '+')
2563 return 1; /* could extend a pre-processing number */
2566 if (c2 == '\'' || c2 == '\"')
2567 return 1; /* Could turn into L"xxx" or L'xxx'. */
2571 case 'a': case 'b': case 'c': case 'd': case 'f':
2572 case 'g': case 'h': case 'i': case 'j': case 'k': case 'l':
2573 case 'm': case 'n': case 'o': case 'q': case 'r':
2574 case 's': case 't': case 'u': case 'v': case 'w': case 'x':
2576 case 'A': case 'B': case 'C': case 'D': case 'F':
2577 case 'G': case 'H': case 'I': case 'J': case 'K':
2578 case 'M': case 'N': case 'O': case 'Q': case 'R':
2579 case 'S': case 'T': case 'U': case 'V': case 'W': case 'X':
2581 /* We're in the middle of either a name or a pre-processing number. */
2582 return (is_idchar[c2] || c2 == '.');
2583 case '<': case '>': case '!': case '%': case '#': case ':':
2584 case '^': case '&': case '|': case '*': case '/': case '=':
2585 return (c2 == c1 || c2 == '=');
2590 /* Expand a macro call.
2591 HP points to the symbol that is the macro being called.
2592 Put the result of expansion onto the input stack
2593 so that subsequent input by our caller will use it.
2595 If macro wants arguments, caller has already verified that
2596 an argument list follows; arguments come from the input stack. */
2599 macroexpand (pfile, hp)
2604 DEFINITION *defn = hp->value.defn;
2605 register U_CHAR *xbuf;
2606 long start_line, start_column;
2608 struct argdata *args;
2609 long old_written = CPP_WRITTEN (pfile);
2611 int start_line = instack[indepth].lineno;
2613 int rest_args, rest_zero;
2617 CHECK_DEPTH (return;);
2621 /* This macro is being used inside a #if, which means it must be */
2622 /* recorded as a precondition. */
2623 if (pcp_inside_if && pcp_outfile && defn->predefined)
2624 dump_single_macro (hp, pcp_outfile);
2627 pfile->output_escapes++;
2628 cpp_buf_line_and_col (cpp_file_buffer (pfile), &start_line, &start_column);
2630 nargs = defn->nargs;
2634 enum cpp_token token;
2636 args = (struct argdata *) alloca ((nargs + 1) * sizeof (struct argdata));
2638 for (i = 0; i < nargs; i++)
2640 args[i].raw = args[i].expanded = 0;
2641 args[i].raw_length = 0;
2642 args[i].expand_length = args[i].stringified_length = -1;
2643 args[i].use_count = 0;
2646 /* Parse all the macro args that are supplied. I counts them.
2647 The first NARGS args are stored in ARGS.
2648 The rest are discarded. If rest_args is set then we assume
2649 macarg absorbed the rest of the args. */
2653 FORWARD(1); /* Discard the open-parenthesis before the first arg. */
2658 if (i < nargs || (nargs == 0 && i == 0))
2660 /* if we are working on last arg which absorbs rest of args... */
2661 if (i == nargs - 1 && defn->rest_args)
2663 args[i].raw = CPP_WRITTEN (pfile);
2664 token = macarg (pfile, rest_args);
2665 args[i].raw_length = CPP_WRITTEN (pfile) - args[i].raw;
2666 args[i].newlines = 0; /* FIXME */
2669 token = macarg (pfile, 0);
2670 if (token == CPP_EOF || token == CPP_POP)
2672 cpp_error_with_line (pfile, start_line, start_column,
2673 "unterminated macro call");
2677 } while (token == CPP_COMMA);
2679 /* If we got one arg but it was just whitespace, call that 0 args. */
2682 register U_CHAR *bp = ARG_BASE + args[0].raw;
2683 register U_CHAR *lim = bp + args[0].raw_length;
2684 /* cpp.texi says for foo ( ) we provide one argument.
2685 However, if foo wants just 0 arguments, treat this as 0. */
2687 while (bp != lim && is_space[*bp]) bp++;
2692 /* Don't output an error message if we have already output one for
2693 a parse error above. */
2695 if (nargs == 0 && i > 0)
2697 cpp_error (pfile, "arguments given to macro `%s'", hp->name);
2701 /* traditional C allows foo() if foo wants one argument. */
2702 if (nargs == 1 && i == 0 && CPP_TRADITIONAL (pfile))
2704 /* the rest args token is allowed to absorb 0 tokens */
2705 else if (i == nargs - 1 && defn->rest_args)
2708 cpp_error (pfile, "macro `%s' used without args", hp->name);
2710 cpp_error (pfile, "macro `%s' used with just one arg", hp->name);
2712 cpp_error (pfile, "macro `%s' used with only %d args",
2718 "macro `%s' used with too many (%d) args", hp->name, i);
2722 /* If macro wants zero args, we parsed the arglist for checking only.
2723 Read directly from the macro definition. */
2726 xbuf = defn->expansion;
2727 xbuf_len = defn->length;
2731 register U_CHAR *exp = defn->expansion;
2732 register int offset; /* offset in expansion,
2733 copied a piece at a time */
2734 register int totlen; /* total amount of exp buffer filled so far */
2736 register struct reflist *ap, *last_ap;
2738 /* Macro really takes args. Compute the expansion of this call. */
2740 /* Compute length in characters of the macro's expansion.
2741 Also count number of times each arg is used. */
2742 xbuf_len = defn->length;
2743 for (ap = defn->pattern; ap != NULL; ap = ap->next)
2747 register struct argdata *arg = &args[ap->argno];
2748 /* Stringify it it hasn't already been */
2749 if (arg->stringified_length < 0)
2751 int arglen = arg->raw_length;
2755 /* Initially need_space is -1. Otherwise, 1 means the
2756 previous character was a space, but we suppressed it;
2757 0 means the previous character was a non-space. */
2758 int need_space = -1;
2760 arg->stringified = CPP_WRITTEN (pfile);
2761 if (!CPP_TRADITIONAL (pfile))
2762 CPP_PUTC (pfile, '\"'); /* insert beginning quote */
2763 for (; i < arglen; i++)
2765 c = (ARG_BASE + arg->raw)[i];
2769 /* Internal sequences of whitespace are replaced by
2770 one space except within an string or char token.*/
2773 if (CPP_WRITTEN (pfile) > arg->stringified
2774 && (CPP_PWRITTEN (pfile))[-1] == '@')
2776 /* "@ " escape markers are removed */
2777 CPP_ADJUST_WRITTEN (pfile, -1);
2780 if (need_space == 0)
2784 else if (need_space > 0)
2785 CPP_PUTC (pfile, ' ');
2800 else if (c == '\"' || c == '\'')
2804 /* Escape these chars */
2805 if (c == '\"' || (in_string && c == '\\'))
2806 CPP_PUTC (pfile, '\\');
2808 CPP_PUTC (pfile, c);
2811 CPP_RESERVE (pfile, 4);
2812 sprintf (CPP_PWRITTEN (pfile), "\\%03o",
2814 CPP_ADJUST_WRITTEN (pfile, 4);
2817 if (!CPP_TRADITIONAL (pfile))
2818 CPP_PUTC (pfile, '\"'); /* insert ending quote */
2819 arg->stringified_length
2820 = CPP_WRITTEN (pfile) - arg->stringified;
2822 xbuf_len += args[ap->argno].stringified_length;
2824 else if (ap->raw_before || ap->raw_after || CPP_TRADITIONAL (pfile))
2825 /* Add 4 for two newline-space markers to prevent
2826 token concatenation. */
2827 xbuf_len += args[ap->argno].raw_length + 4;
2830 /* We have an ordinary (expanded) occurrence of the arg.
2831 So compute its expansion, if we have not already. */
2832 if (args[ap->argno].expand_length < 0)
2834 args[ap->argno].expanded = CPP_WRITTEN (pfile);
2835 cpp_expand_to_buffer (pfile,
2836 ARG_BASE + args[ap->argno].raw,
2837 args[ap->argno].raw_length);
2839 args[ap->argno].expand_length
2840 = CPP_WRITTEN (pfile) - args[ap->argno].expanded;
2843 /* Add 4 for two newline-space markers to prevent
2844 token concatenation. */
2845 xbuf_len += args[ap->argno].expand_length + 4;
2847 if (args[ap->argno].use_count < 10)
2848 args[ap->argno].use_count++;
2851 xbuf = (U_CHAR *) xmalloc (xbuf_len + 1);
2853 /* Generate in XBUF the complete expansion
2854 with arguments substituted in.
2855 TOTLEN is the total size generated so far.
2856 OFFSET is the index in the definition
2857 of where we are copying from. */
2858 offset = totlen = 0;
2859 for (last_ap = NULL, ap = defn->pattern; ap != NULL;
2860 last_ap = ap, ap = ap->next)
2862 register struct argdata *arg = &args[ap->argno];
2863 int count_before = totlen;
2865 /* Add chars to XBUF. */
2866 for (i = 0; i < ap->nchars; i++, offset++)
2867 xbuf[totlen++] = exp[offset];
2869 /* If followed by an empty rest arg with concatenation,
2870 delete the last run of nonwhite chars. */
2871 if (rest_zero && totlen > count_before
2872 && ((ap->rest_args && ap->raw_before)
2873 || (last_ap != NULL && last_ap->rest_args
2874 && last_ap->raw_after)))
2876 /* Delete final whitespace. */
2877 while (totlen > count_before && is_space[xbuf[totlen - 1]])
2880 /* Delete the nonwhites before them. */
2881 while (totlen > count_before && ! is_space[xbuf[totlen - 1]])
2885 if (ap->stringify != 0)
2887 bcopy (ARG_BASE + arg->stringified,
2888 xbuf + totlen, arg->stringified_length);
2889 totlen += arg->stringified_length;
2891 else if (ap->raw_before || ap->raw_after || CPP_TRADITIONAL (pfile))
2893 U_CHAR *p1 = ARG_BASE + arg->raw;
2894 U_CHAR *l1 = p1 + arg->raw_length;
2897 while (p1 != l1 && is_space[*p1]) p1++;
2898 while (p1 != l1 && is_idchar[*p1])
2899 xbuf[totlen++] = *p1++;
2900 /* Delete any no-reexpansion marker that follows
2901 an identifier at the beginning of the argument
2902 if the argument is concatenated with what precedes it. */
2903 if (p1[0] == '@' && p1[1] == '-')
2908 /* Arg is concatenated after: delete trailing whitespace,
2909 whitespace markers, and no-reexpansion markers. */
2912 if (is_space[l1[-1]]) l1--;
2913 else if (l1[-1] == '-')
2915 U_CHAR *p2 = l1 - 1;
2916 /* If a `-' is preceded by an odd number of newlines then it
2917 and the last newline are a no-reexpansion marker. */
2918 while (p2 != p1 && p2[-1] == '\n') p2--;
2919 if ((l1 - 1 - p2) & 1) {
2928 bcopy (p1, xbuf + totlen, l1 - p1);
2933 U_CHAR *expanded = ARG_BASE + arg->expanded;
2934 if (!ap->raw_before && totlen > 0 && arg->expand_length
2935 && !CPP_TRADITIONAL(pfile)
2936 && unsafe_chars (xbuf[totlen-1], expanded[0]))
2938 xbuf[totlen++] = '@';
2939 xbuf[totlen++] = ' ';
2942 bcopy (expanded, xbuf + totlen, arg->expand_length);
2943 totlen += arg->expand_length;
2945 if (!ap->raw_after && totlen > 0 && offset < defn->length
2946 && !CPP_TRADITIONAL(pfile)
2947 && unsafe_chars (xbuf[totlen-1], exp[offset]))
2949 xbuf[totlen++] = '@';
2950 xbuf[totlen++] = ' ';
2953 /* If a macro argument with newlines is used multiple times,
2954 then only expand the newlines once. This avoids creating
2955 output lines which don't correspond to any input line,
2956 which confuses gdb and gcov. */
2957 if (arg->use_count > 1 && arg->newlines > 0)
2959 /* Don't bother doing change_newlines for subsequent
2963 = change_newlines (expanded, arg->expand_length);
2967 if (totlen > xbuf_len)
2971 /* if there is anything left of the definition
2972 after handling the arg list, copy that in too. */
2974 for (i = offset; i < defn->length; i++)
2976 /* if we've reached the end of the macro */
2979 if (! (rest_zero && last_ap != NULL && last_ap->rest_args
2980 && last_ap->raw_after))
2981 xbuf[totlen++] = exp[i];
2989 pfile->output_escapes--;
2991 /* Now put the expansion on the input stack
2992 so our caller will commence reading from it. */
2993 push_macro_expansion (pfile, xbuf, xbuf_len, hp);
2994 CPP_BUFFER (pfile)->has_escapes = 1;
2996 /* Pop the space we've used in the token_buffer for argument expansion. */
2997 CPP_SET_WRITTEN (pfile, old_written);
2999 /* Recursive macro use sometimes works traditionally.
3000 #define foo(x,y) bar (x (y,0), y)
3003 if (!CPP_TRADITIONAL (pfile))
3004 hp->type = T_DISABLED;
3008 push_macro_expansion (pfile, xbuf, xbuf_len, hp)
3010 register U_CHAR *xbuf;
3014 register cpp_buffer *mbuf = cpp_push_buffer (pfile, xbuf, xbuf_len);
3017 mbuf->cleanup = macro_cleanup;
3020 /* The first chars of the expansion should be a "@ " added by
3021 collect_expansion. This is to prevent accidental token-pasting
3022 between the text preceding the macro invocation, and the macro
3025 We would like to avoid adding unneeded spaces (for the sake of
3026 tools that use cpp, such as imake). In some common cases we can
3027 tell that it is safe to omit the space.
3029 The character before the macro invocation cannot have been an
3030 idchar (or else it would have been pasted with the idchars of
3031 the macro name). Therefore, if the first non-space character
3032 of the expansion is an idchar, we do not need the extra space
3033 to prevent token pasting.
3035 Also, we don't need the extra space if the first char is '(',
3036 or some other (less common) characters. */
3038 if (xbuf[0] == '@' && xbuf[1] == ' '
3039 && (is_idchar[xbuf[2]] || xbuf[2] == '(' || xbuf[2] == '\''
3040 || xbuf[2] == '\"'))
3044 /* Like cpp_get_token, except that it does not read past end-of-line.
3045 Also, horizontal space is skipped, and macros are popped. */
3047 static enum cpp_token
3048 get_directive_token (pfile)
3053 long old_written = CPP_WRITTEN (pfile);
3054 enum cpp_token token;
3055 cpp_skip_hspace (pfile);
3056 if (PEEKC () == '\n')
3058 token = cpp_get_token (pfile);
3062 if (! CPP_IS_MACRO_BUFFER (CPP_BUFFER (pfile)))
3064 /* ... else fall though ... */
3065 case CPP_HSPACE: case CPP_COMMENT:
3066 CPP_SET_WRITTEN (pfile, old_written);
3074 /* Handle #include and #import.
3075 This function expects to see "fname" or <fname> on the input.
3077 The input is normally in part of the output_buffer following
3078 CPP_WRITTEN, and will get overwritten by output_line_command.
3079 I.e. in input file specification has been popped by handle_directive.
3083 do_include (pfile, keyword, unused1, unused2)
3085 struct directive *keyword;
3086 U_CHAR *unused1, *unused2;
3088 int importing = (keyword->type == T_IMPORT);
3089 int skip_dirs = (keyword->type == T_INCLUDE_NEXT);
3090 char *fname; /* Dynamically allocated fname buffer */
3093 U_CHAR *fbeg, *fend; /* Beginning and end of fname */
3094 enum cpp_token token;
3096 /* Chain of dirs to search */
3097 struct file_name_list *search_start = CPP_OPTIONS (pfile)->include;
3098 struct file_name_list dsp[1]; /* First in chain, if #include "..." */
3099 struct file_name_list *searchptr = 0;
3100 long old_written = CPP_WRITTEN (pfile);
3104 int f; /* file number */
3106 int retried = 0; /* Have already tried macro
3107 expanding the include line */
3108 int angle_brackets = 0; /* 0 for "...", 1 for <...> */
3113 f= -1; /* JF we iz paranoid! */
3115 if (CPP_PEDANTIC (pfile) && !CPP_BUFFER (pfile)->system_header_p)
3118 cpp_pedwarn (pfile, "ANSI C does not allow `#import'");
3120 cpp_pedwarn (pfile, "ANSI C does not allow `#include_next'");
3123 if (importing && CPP_OPTIONS (pfile)->warn_import
3124 && !CPP_OPTIONS (pfile)->inhibit_warnings
3125 && !CPP_BUFFER (pfile)->system_header_p && !pfile->import_warning)
3127 pfile->import_warning = 1;
3128 cpp_warning (pfile, "using `#import' is not recommended");
3129 fprintf (stderr, "The fact that a certain header file need not be processed more than once\n");
3130 fprintf (stderr, "should be indicated in the header file, not where it is used.\n");
3131 fprintf (stderr, "The best way to do this is with a conditional of this form:\n\n");
3132 fprintf (stderr, " #ifndef _FOO_H_INCLUDED\n");
3133 fprintf (stderr, " #define _FOO_H_INCLUDED\n");
3134 fprintf (stderr, " ... <real contents of file> ...\n");
3135 fprintf (stderr, " #endif /* Not _FOO_H_INCLUDED */\n\n");
3136 fprintf (stderr, "Then users can use `#include' any number of times.\n");
3137 fprintf (stderr, "GNU C automatically avoids processing the file more than once\n");
3138 fprintf (stderr, "when it is equipped with such a conditional.\n");
3141 pfile->parsing_include_directive++;
3142 token = get_directive_token (pfile);
3143 pfile->parsing_include_directive--;
3145 if (token == CPP_STRING)
3147 /* FIXME - check no trailing garbage */
3148 fbeg = pfile->token_buffer + old_written + 1;
3149 fend = CPP_PWRITTEN (pfile) - 1;
3150 if (fbeg[-1] == '<')
3153 /* If -I-, start with the first -I dir after the -I-. */
3154 if (CPP_OPTIONS (pfile)->first_bracket_include)
3155 search_start = CPP_OPTIONS (pfile)->first_bracket_include;
3157 /* If -I- was specified, don't search current dir, only spec'd ones. */
3158 else if (! CPP_OPTIONS (pfile)->ignore_srcdir)
3160 cpp_buffer *fp = CPP_BUFFER (pfile);
3161 /* We have "filename". Figure out directory this source
3162 file is coming from and put it on the front of the list. */
3164 for ( ; fp != CPP_NULL_BUFFER (pfile); fp = CPP_PREV_BUFFER (fp))
3169 if ((nam = fp->nominal_fname) != NULL)
3171 /* Found a named file. Figure out dir of the file,
3172 and put it in front of the search list. */
3173 dsp[0].next = search_start;
3176 ep = rindex (nam, '/');
3178 ep = rindex (nam, ']');
3179 if (ep == NULL) ep = rindex (nam, '>');
3180 if (ep == NULL) ep = rindex (nam, ':');
3181 if (ep != NULL) ep++;
3186 dsp[0].fname = (char *) alloca (n + 1);
3187 strncpy (dsp[0].fname, nam, n);
3188 dsp[0].fname[n] = '\0';
3189 if (n + INCLUDE_LEN_FUDGE > pfile->max_include_len)
3190 pfile->max_include_len = n + INCLUDE_LEN_FUDGE;
3194 dsp[0].fname = 0; /* Current directory */
3196 dsp[0].got_name_map = 0;
3203 else if (token == CPP_NAME)
3206 * Support '#include xyz' like VAX-C to allow for easy use of all the
3207 * decwindow include files. It defaults to '#include <xyz.h>' (so the
3208 * code from case '<' is repeated here) and generates a warning.
3211 "VAX-C-style include specification found, use '#include <filename.h>' !");
3213 /* If -I-, start with the first -I dir after the -I-. */
3214 if (CPP_OPTIONS (pfile)->first_bracket_include)
3215 search_start = CPP_OPTIONS (pfile)->first_bracket_include;
3216 fbeg = pfile->token_buffer + old_written;
3217 fend = CPP_PWRITTEN (pfile);
3223 "`#%s' expects \"FILENAME\" or <FILENAME>", keyword->name);
3224 CPP_SET_WRITTEN (pfile, old_written);
3225 skip_rest_of_line (pfile);
3231 token = get_directive_token (pfile);
3232 if (token != CPP_VSPACE)
3234 cpp_error (pfile, "junk at end of `#include'");
3235 while (token != CPP_VSPACE && token != CPP_EOF && token != CPP_POP)
3236 token = get_directive_token (pfile);
3239 /* For #include_next, skip in the search path
3240 past the dir in which the containing file was found. */
3243 cpp_buffer *fp = CPP_BUFFER (pfile);
3244 for (; fp != CPP_NULL_BUFFER (pfile); fp = CPP_PREV_BUFFER (fp))
3245 if (fp->fname != NULL)
3247 /* fp->dir is null if the containing file was specified with
3248 an absolute file name. In that case, don't skip anything. */
3249 if (fp->dir == SELF_DIR_DUMMY)
3250 search_start = CPP_OPTIONS (pfile)->include;
3252 search_start = fp->dir->next;
3257 CPP_SET_WRITTEN (pfile, old_written);
3263 cpp_error (pfile, "empty file name in `#%s'", keyword->name);
3267 /* Allocate this permanently, because it gets stored in the definitions
3269 fname = (char *) xmalloc (pfile->max_include_len + flen + 4);
3270 /* + 2 above for slash and terminating null. */
3271 /* + 2 added for '.h' on VMS (to support '#include filename') */
3273 /* If specified file name is absolute, just open it. */
3276 strncpy (fname, fbeg, flen);
3278 if (redundant_include_p (pfile, fname))
3281 f = lookup_import (pfile, fname, NULL_PTR);
3283 f = open_include_file (pfile, fname, NULL_PTR);
3285 return 0; /* Already included this file */
3287 /* Search directory path, trying to open the file.
3288 Copy each filename tried into FNAME. */
3290 for (searchptr = search_start; searchptr; searchptr = searchptr->next) {
3291 if (searchptr->fname) {
3292 /* The empty string in a search path is ignored.
3293 This makes it possible to turn off entirely
3294 a standard piece of the list. */
3295 if (searchptr->fname[0] == 0)
3297 strcpy (fname, searchptr->fname);
3298 strcat (fname, "/");
3299 fname[strlen (fname) + flen] = 0;
3303 strncat (fname, fbeg, flen);
3305 /* Change this 1/2 Unix 1/2 VMS file specification into a
3306 full VMS file specification */
3307 if (searchptr->fname && (searchptr->fname[0] != 0)) {
3308 /* Fix up the filename */
3309 hack_vms_include_specification (fname);
3311 /* This is a normal VMS filespec, so use it unchanged. */
3312 strncpy (fname, fbeg, flen);
3314 /* if it's '#include filename', add the missing .h */
3315 if (index(fname,'.')==NULL) {
3316 strcat (fname, ".h");
3320 /* ??? There are currently 3 separate mechanisms for avoiding processing
3321 of redundant include files: #import, #pragma once, and
3322 redundant_include_p. It would be nice if they were unified. */
3323 if (redundant_include_p (pfile, fname))
3326 f = lookup_import (pfile, fname, searchptr);
3328 f = open_include_file (pfile, fname, searchptr);
3330 return 0; /* Already included this file */
3332 else if (f == -1 && errno == EACCES)
3333 cpp_warning (pfile, "Header file %s exists, but is not readable",
3343 /* A file that was not found. */
3344 strncpy (fname, fbeg, flen);
3346 /* If generating dependencies and -MG was specified, we assume missing
3347 files are leaf files, living in the same directory as the source file
3348 or other similar place; these missing files may be generated from
3349 other files and may not exist yet (eg: y.tab.h). */
3351 if (CPP_OPTIONS(pfile)->print_deps_missing_files
3352 && CPP_PRINT_DEPS (pfile)
3353 > (angle_brackets || (pfile->system_include_depth > 0)))
3355 /* If it was requested as a system header file,
3356 then assume it belongs in the first place to look for such. */
3359 for (searchptr = search_start; searchptr;
3360 searchptr = searchptr->next)
3362 if (searchptr->fname)
3366 if (searchptr->fname[0] == 0)
3368 p = (char *) alloca (strlen (searchptr->fname)
3369 + strlen (fname) + 2);
3370 strcpy (p, searchptr->fname);
3373 deps_output (pfile, p, ' ');
3380 /* Otherwise, omit the directory, as if the file existed
3381 in the directory with the source. */
3382 deps_output (pfile, fname, ' ');
3385 /* If -M was specified, and this header file won't be added to the
3386 dependency list, then don't count this as an error, because we can
3387 still produce correct output. Otherwise, we can't produce correct
3388 output, because there may be dependencies we need inside the missing
3389 file, and we don't know what directory this missing file exists in.*/
3390 else if (CPP_PRINT_DEPS (pfile)
3391 && (CPP_PRINT_DEPS (pfile)
3392 <= (angle_brackets || (pfile->system_include_depth > 0))))
3393 cpp_warning (pfile, "No include path in which to find %s", fname);
3394 else if (search_start)
3395 cpp_error_from_errno (pfile, fname);
3397 cpp_error (pfile, "No include path in which to find %s", fname);
3400 /* Check to see if this include file is a once-only include file.
3403 struct file_name_list *ptr;
3405 for (ptr = pfile->dont_repeat_files; ptr; ptr = ptr->next) {
3406 if (!strcmp (ptr->fname, fname)) {
3408 return 0; /* This file was once'd. */
3412 for (ptr = pfile->all_include_files; ptr; ptr = ptr->next) {
3413 if (!strcmp (ptr->fname, fname))
3414 break; /* This file was included before. */
3418 /* This is the first time for this file. */
3419 /* Add it to list of files included. */
3421 ptr = (struct file_name_list *) xmalloc (sizeof (struct file_name_list));
3422 ptr->control_macro = 0;
3423 ptr->c_system_include_path = 0;
3424 ptr->next = pfile->all_include_files;
3425 pfile->all_include_files = ptr;
3426 ptr->fname = savestring (fname);
3427 ptr->got_name_map = 0;
3429 /* For -M, add this file to the dependencies. */
3430 if (CPP_PRINT_DEPS (pfile)
3431 > (angle_brackets || (pfile->system_include_depth > 0)))
3432 deps_output (pfile, fname, ' ');
3435 /* Handle -H option. */
3436 if (CPP_OPTIONS(pfile)->print_include_names)
3438 cpp_buffer *buf = CPP_BUFFER (pfile);
3439 while ((buf = CPP_PREV_BUFFER (buf)) != CPP_NULL_BUFFER (pfile))
3441 fprintf (stderr, "%s\n", fname);
3445 pfile->system_include_depth++;
3447 /* Actually process the file. */
3449 /* Record file on "seen" list for #import. */
3450 add_import (pfile, f, fname);
3452 pcftry = (char *) alloca (strlen (fname) + 30);
3464 sprintf (pcftry, "%s%d", fname, pcfnum++);
3466 pcf = open (pcftry, O_RDONLY, 0666);
3472 if (bcmp ((char *) &stat_f.st_ino, (char *) &s.st_ino,
3474 || stat_f.st_dev != s.st_dev)
3476 pcfbuf = check_precompiled (pcf, fname, &pcfbuflimit);
3477 /* Don't need it any more. */
3482 /* Don't need it at all. */
3487 } while (pcf != -1 && !pcfbuf);
3491 /* Actually process the file */
3492 if (cpp_push_buffer (pfile, NULL, 0) == NULL)
3494 if (finclude (pfile, f, fname, is_system_include (pfile, fname),
3495 searchptr != dsp ? searchptr : SELF_DIR_DUMMY))
3497 output_line_command (pfile, 0, enter_file);
3498 pfile->only_seen_white = 2;
3502 pfile->system_include_depth--;
3507 /* Return nonzero if there is no need to include file NAME
3508 because it has already been included and it contains a conditional
3509 to make a repeated include do nothing. */
3512 redundant_include_p (pfile, name)
3516 struct file_name_list *l = pfile->all_include_files;
3517 for (; l; l = l->next)
3518 if (! strcmp (name, l->fname)
3520 && cpp_lookup (pfile, l->control_macro, -1, -1))
3525 /* Return nonzero if the given FILENAME is an absolute pathname which
3526 designates a file within one of the known "system" include file
3527 directories. We assume here that if the given FILENAME looks like
3528 it is the name of a file which resides either directly in a "system"
3529 include file directory, or within any subdirectory thereof, then the
3530 given file must be a "system" include file. This function tells us
3531 if we should suppress pedantic errors/warnings for the given FILENAME.
3533 The value is 2 if the file is a C-language system header file
3534 for which C++ should (on most systems) assume `extern "C"'. */
3537 is_system_include (pfile, filename)
3539 register char *filename;
3541 struct file_name_list *searchptr;
3543 for (searchptr = CPP_OPTIONS (pfile)->first_system_include; searchptr;
3544 searchptr = searchptr->next)
3545 if (searchptr->fname) {
3546 register char *sys_dir = searchptr->fname;
3547 register unsigned length = strlen (sys_dir);
3549 if (! strncmp (sys_dir, filename, length) && filename[length] == '/')
3551 if (searchptr->c_system_include_path)
3562 * Install a name in the assertion hash table.
3564 * If LEN is >= 0, it is the length of the name.
3565 * Otherwise, compute the length by scanning the entire name.
3567 * If HASH is >= 0, it is the precomputed hash code.
3568 * Otherwise, compute the hash code.
3571 static ASSERTION_HASHNODE *
3572 assertion_install (pfile, name, len, hash)
3578 register ASSERTION_HASHNODE *hp;
3579 register int i, bucket;
3580 register U_CHAR *p, *q;
3582 i = sizeof (ASSERTION_HASHNODE) + len + 1;
3583 hp = (ASSERTION_HASHNODE *) xmalloc (i);
3585 hp->bucket_hdr = &pfile->assertion_hashtab[bucket];
3586 hp->next = pfile->assertion_hashtab[bucket];
3587 pfile->assertion_hashtab[bucket] = hp;
3589 if (hp->next != NULL)
3590 hp->next->prev = hp;
3593 hp->name = ((U_CHAR *) hp) + sizeof (ASSERTION_HASHNODE);
3596 for (i = 0; i < len; i++)
3602 * find the most recent hash node for name name (ending with first
3603 * non-identifier char) installed by install
3605 * If LEN is >= 0, it is the length of the name.
3606 * Otherwise, compute the length by scanning the entire name.
3608 * If HASH is >= 0, it is the precomputed hash code.
3609 * Otherwise, compute the hash code.
3612 static ASSERTION_HASHNODE *
3613 assertion_lookup (pfile, name, len, hash)
3619 register ASSERTION_HASHNODE *bucket;
3621 bucket = pfile->assertion_hashtab[hash];
3623 if (bucket->length == len && strncmp (bucket->name, name, len) == 0)
3625 bucket = bucket->next;
3631 delete_assertion (hp)
3632 ASSERTION_HASHNODE *hp;
3634 struct tokenlist_list *tail;
3635 if (hp->prev != NULL)
3636 hp->prev->next = hp->next;
3637 if (hp->next != NULL)
3638 hp->next->prev = hp->prev;
3640 for (tail = hp->value; tail; )
3642 struct tokenlist_list *next = tail->next;
3643 free_token_list (tail->tokens);
3648 /* Make sure that the bucket chain header that
3649 the deleted guy was on points to the right thing afterwards. */
3650 if (hp == *hp->bucket_hdr)
3651 *hp->bucket_hdr = hp->next;
3656 /* Convert a character string literal into a nul-terminated string.
3657 The input string is [IN ... LIMIT).
3658 The result is placed in RESULT. RESULT can be the same as IN.
3659 The value returned in the end of the string written to RESULT,
3660 or NULL on error. */
3663 convert_string (pfile, result, in, limit, handle_escapes)
3665 register U_CHAR *result, *in, *limit;
3685 char *bpc = (char *) in;
3686 int i = (U_CHAR) cpp_parse_escape (pfile, &bpc);
3687 in = (U_CHAR *) bpc;
3689 *result++ = (U_CHAR)c;
3692 /* else fall through */
3702 * interpret #line command. Remembers previously seen fnames
3703 * in its very own hash table.
3705 #define FNAME_HASHSIZE 37
3708 do_line (pfile, keyword)
3710 struct directive *keyword;
3712 cpp_buffer *ip = CPP_BUFFER (pfile);
3714 long old_written = CPP_WRITTEN (pfile);
3715 enum file_change_code file_change = same_file;
3716 enum cpp_token token;
3719 token = get_directive_token (pfile);
3721 if (token != CPP_NUMBER
3722 || !isdigit(pfile->token_buffer[old_written]))
3724 cpp_error (pfile, "invalid format `#line' command");
3725 goto bad_line_directive;
3728 /* The Newline at the end of this line remains to be processed.
3729 To put the next line at the specified line number,
3730 we must store a line number now that is one less. */
3731 new_lineno = atoi (pfile->token_buffer + old_written) - 1;
3732 CPP_SET_WRITTEN (pfile, old_written);
3734 /* NEW_LINENO is one less than the actual line number here. */
3735 if (CPP_PEDANTIC (pfile) && new_lineno < 0)
3736 cpp_pedwarn (pfile, "line number out of range in `#line' command");
3738 #if 0 /* #line 10"foo.c" is supposed to be allowed. */
3739 if (PEEKC() && !is_space[PEEKC()]) {
3740 cpp_error (pfile, "invalid format `#line' command");
3741 goto bad_line_directive;
3745 token = get_directive_token (pfile);
3747 if (token == CPP_STRING) {
3748 U_CHAR *fname = pfile->token_buffer + old_written;
3750 static HASHNODE *fname_table[FNAME_HASHSIZE];
3751 HASHNODE *hp, **hash_bucket;
3756 /* Turn the file name, which is a character string literal,
3757 into a null-terminated string. Do this in place. */
3758 end_name = convert_string (pfile, fname, fname, CPP_PWRITTEN (pfile), 1);
3759 if (end_name == NULL)
3761 cpp_error (pfile, "invalid format `#line' command");
3762 goto bad_line_directive;
3765 fname_length = end_name - fname;
3767 num_start = CPP_WRITTEN (pfile);
3768 token = get_directive_token (pfile);
3769 if (token != CPP_VSPACE && token != CPP_EOF && token != CPP_POP) {
3770 p = pfile->token_buffer + num_start;
3771 if (CPP_PEDANTIC (pfile))
3772 cpp_pedwarn (pfile, "garbage at end of `#line' command");
3774 if (token != CPP_NUMBER || *p < '0' || *p > '4' || p[1] != '\0')
3776 cpp_error (pfile, "invalid format `#line' command");
3777 goto bad_line_directive;
3780 file_change = enter_file;
3782 file_change = leave_file;
3784 ip->system_header_p = 1;
3785 else /* if (*p == 4) */
3786 ip->system_header_p = 2;
3788 CPP_SET_WRITTEN (pfile, num_start);
3789 token = get_directive_token (pfile);
3790 p = pfile->token_buffer + num_start;
3791 if (token == CPP_NUMBER && p[1] == '\0' && (*p == '3' || *p== '4')) {
3792 ip->system_header_p = *p == 3 ? 1 : 2;
3793 token = get_directive_token (pfile);
3795 if (token != CPP_VSPACE) {
3796 cpp_error (pfile, "invalid format `#line' command");
3797 goto bad_line_directive;
3802 &fname_table[hashf (fname, fname_length, FNAME_HASHSIZE)];
3803 for (hp = *hash_bucket; hp != NULL; hp = hp->next)
3804 if (hp->length == fname_length &&
3805 strncmp (hp->value.cpval, fname, fname_length) == 0) {
3806 ip->nominal_fname = hp->value.cpval;
3810 /* Didn't find it; cons up a new one. */
3811 hp = (HASHNODE *) xcalloc (1, sizeof (HASHNODE) + fname_length + 1);
3812 hp->next = *hash_bucket;
3815 hp->length = fname_length;
3816 ip->nominal_fname = hp->value.cpval = ((char *) hp) + sizeof (HASHNODE);
3817 bcopy (fname, hp->value.cpval, fname_length);
3820 else if (token != CPP_VSPACE && token != CPP_EOF) {
3821 cpp_error (pfile, "invalid format `#line' command");
3822 goto bad_line_directive;
3825 ip->lineno = new_lineno;
3827 skip_rest_of_line (pfile);
3828 CPP_SET_WRITTEN (pfile, old_written);
3829 output_line_command (pfile, 0, file_change);
3834 * remove the definition of a symbol from the symbol table.
3835 * according to un*x /lib/cpp, it is not an error to undef
3836 * something that has no definitions, so it isn't one here either.
3840 do_undef (pfile, keyword, buf, limit)
3842 struct directive *keyword;
3843 U_CHAR *buf, *limit;
3847 U_CHAR *orig_buf = buf;
3850 /* If this is a precompiler run (with -pcp) pass thru #undef commands. */
3851 if (pcp_outfile && keyword)
3852 pass_thru_directive (buf, limit, pfile, keyword);
3855 SKIP_WHITE_SPACE (buf);
3856 sym_length = check_macro_name (pfile, buf, "macro");
3858 while ((hp = cpp_lookup (pfile, buf, sym_length, -1)) != NULL)
3860 /* If we are generating additional info for debugging (with -g) we
3861 need to pass through all effective #undef commands. */
3862 if (CPP_OPTIONS (pfile)->debug_output && keyword)
3863 pass_thru_directive (orig_buf, limit, pfile, keyword);
3864 if (hp->type != T_MACRO)
3865 cpp_warning (pfile, "undefining `%s'", hp->name);
3869 if (CPP_PEDANTIC (pfile)) {
3871 SKIP_WHITE_SPACE (buf);
3873 cpp_pedwarn (pfile, "garbage after `#undef' directive");
3879 * Report an error detected by the program we are processing.
3880 * Use the text of the line in the error message.
3881 * (We use error because it prints the filename & line#.)
3885 do_error (pfile, keyword, buf, limit)
3887 struct directive *keyword;
3888 U_CHAR *buf, *limit;
3890 int length = limit - buf;
3891 U_CHAR *copy = (U_CHAR *) alloca (length + 1);
3892 bcopy (buf, copy, length);
3894 SKIP_WHITE_SPACE (copy);
3895 cpp_error (pfile, "#error %s", copy);
3900 * Report a warning detected by the program we are processing.
3901 * Use the text of the line in the warning message, then continue.
3902 * (We use error because it prints the filename & line#.)
3906 do_warning (pfile, keyword, buf, limit)
3908 struct directive *keyword;
3909 U_CHAR *buf, *limit;
3911 int length = limit - buf;
3912 U_CHAR *copy = (U_CHAR *) alloca (length + 1);
3913 bcopy (buf, copy, length);
3915 SKIP_WHITE_SPACE (copy);
3916 /* Use `pedwarn' not `warning', because #warning isn't in the C Standard;
3917 if -pedantic-errors is given, #warning should cause an error. */
3918 cpp_pedwarn (pfile, "#warning %s", copy);
3922 /* Remember the name of the current file being read from so that we can
3923 avoid ever including it again. */
3929 cpp_buffer *ip = NULL;
3930 struct file_name_list *new;
3932 for (ip = CPP_BUFFER (pfile); ; ip = CPP_PREV_BUFFER (ip))
3934 if (ip == CPP_NULL_BUFFER (pfile))
3936 if (ip->fname != NULL)
3941 new = (struct file_name_list *) xmalloc (sizeof (struct file_name_list));
3942 new->next = pfile->dont_repeat_files;
3943 pfile->dont_repeat_files = new;
3944 new->fname = savestring (ip->fname);
3945 new->control_macro = 0;
3946 new->got_name_map = 0;
3947 new->c_system_include_path = 0;
3952 /* #ident has already been copied to the output file, so just ignore it. */
3955 do_ident (pfile, keyword, buf, limit)
3957 struct directive *keyword;
3958 U_CHAR *buf, *limit;
3960 /* long old_written = CPP_WRITTEN (pfile);*/
3963 /* Allow #ident in system headers, since that's not user's fault. */
3964 if (CPP_PEDANTIC (pfile) && !CPP_BUFFER (pfile)->system_header_p)
3965 cpp_pedwarn (pfile, "ANSI C does not allow `#ident'");
3967 /* Leave rest of line to be read by later calls to cpp_get_token. */
3972 /* #pragma and its argument line have already been copied to the output file.
3973 Just check for some recognized pragmas that need validation here. */
3976 do_pragma (pfile, keyword, buf, limit)
3978 struct directive *keyword;
3979 U_CHAR *buf, *limit;
3981 while (*buf == ' ' || *buf == '\t')
3983 if (!strncmp (buf, "once", 4)) {
3984 /* Allow #pragma once in system headers, since that's not the user's
3986 if (!CPP_BUFFER (pfile)->system_header_p)
3987 cpp_warning (pfile, "`#pragma once' is obsolete");
3991 if (!strncmp (buf, "implementation", 14)) {
3992 /* Be quiet about `#pragma implementation' for a file only if it hasn't
3993 been included yet. */
3994 struct file_name_list *ptr;
3995 U_CHAR *p = buf + 14, *fname, *inc_fname;
3997 SKIP_WHITE_SPACE (p);
3998 if (*p == '\n' || *p != '\"')
4002 p = (U_CHAR *) index (fname, '\"');
4003 fname_len = p != NULL ? p - fname : strlen (fname);
4005 for (ptr = pfile->all_include_files; ptr; ptr = ptr->next) {
4006 inc_fname = (U_CHAR *) rindex (ptr->fname, '/');
4007 inc_fname = inc_fname ? inc_fname + 1 : (U_CHAR *) ptr->fname;
4008 if (inc_fname && !strncmp (inc_fname, fname, fname_len))
4010 "`#pragma implementation' for `%s' appears after file is included",
4019 /* This was a fun hack, but #pragma seems to start to be useful.
4020 By failing to recognize it, we pass it through unchanged to cc1. */
4023 * the behavior of the #pragma directive is implementation defined.
4024 * this implementation defines it as follows.
4031 if (open ("/dev/tty", O_RDONLY, 0666) != 0)
4034 if (open ("/dev/tty", O_WRONLY, 0666) != 1)
4036 execl ("/usr/games/hack", "#pragma", 0);
4037 execl ("/usr/games/rogue", "#pragma", 0);
4038 execl ("/usr/new/emacs", "-f", "hanoi", "9", "-kill", 0);
4039 execl ("/usr/local/emacs", "-f", "hanoi", "9", "-kill", 0);
4041 fatal ("You are in a maze of twisty compiler features, all different");
4045 /* Just ignore #sccs, on systems where we define it at all. */
4048 do_sccs (pfile, keyword, buf, limit)
4050 struct directive *keyword;
4051 U_CHAR *buf, *limit;
4053 if (CPP_PEDANTIC (pfile))
4054 cpp_pedwarn (pfile, "ANSI C does not allow `#sccs'");
4059 * handle #if command by
4060 * 1) inserting special `defined' keyword into the hash table
4061 * that gets turned into 0 or 1 by special_symbol (thus,
4062 * if the luser has a symbol called `defined' already, it won't
4063 * work inside the #if command)
4064 * 2) rescan the input into a temporary output buffer
4065 * 3) pass the output buffer to the yacc parser and collect a value
4066 * 4) clean up the mess left from steps 1 and 2.
4067 * 5) call conditional_skip to skip til the next #endif (etc.),
4068 * or not, depending on the value from step 3.
4072 do_if (pfile, keyword, buf, limit)
4074 struct directive *keyword;
4075 U_CHAR *buf, *limit;
4077 HOST_WIDE_INT value = eval_if_expression (pfile, buf, limit - buf);
4078 conditional_skip (pfile, value == 0, T_IF, NULL_PTR);
4083 * handle a #elif directive by not changing if_stack either.
4084 * see the comment above do_else.
4088 do_elif (pfile, keyword, buf, limit)
4090 struct directive *keyword;
4091 U_CHAR *buf, *limit;
4093 if (pfile->if_stack == CPP_BUFFER (pfile)->if_stack) {
4094 cpp_error (pfile, "`#elif' not within a conditional");
4097 if (pfile->if_stack->type != T_IF && pfile->if_stack->type != T_ELIF) {
4098 cpp_error (pfile, "`#elif' after `#else'");
4100 fprintf (stderr, " (matches line %d", pfile->if_stack->lineno);
4102 if (pfile->if_stack->fname != NULL && CPP_BUFFER (pfile)->fname != NULL
4103 && strcmp (pfile->if_stack->fname,
4104 CPP_BUFFER (pfile)->nominal_fname) != 0)
4105 fprintf (stderr, ", file %s", pfile->if_stack->fname);
4106 fprintf (stderr, ")\n");
4108 pfile->if_stack->type = T_ELIF;
4111 if (pfile->if_stack->if_succeeded)
4112 skip_if_group (pfile, 0);
4114 HOST_WIDE_INT value = eval_if_expression (pfile, buf, limit - buf);
4116 skip_if_group (pfile, 0);
4118 ++pfile->if_stack->if_succeeded; /* continue processing input */
4119 output_line_command (pfile, 1, same_file);
4126 * evaluate a #if expression in BUF, of length LENGTH,
4127 * then parse the result as a C expression and return the value as an int.
4130 static HOST_WIDE_INT
4131 eval_if_expression (pfile, buf, length)
4136 HASHNODE *save_defined;
4137 HOST_WIDE_INT value;
4138 long old_written = CPP_WRITTEN (pfile);
4140 save_defined = install ("defined", -1, T_SPEC_DEFINED, 0, 0, -1);
4141 pfile->pcp_inside_if = 1;
4143 value = cpp_parse_expr (pfile);
4144 pfile->pcp_inside_if = 0;
4145 delete_macro (save_defined); /* clean up special symbol */
4147 CPP_SET_WRITTEN (pfile, old_written); /* Pop */
4153 * routine to handle ifdef/ifndef. Try to look up the symbol,
4154 * then do or don't skip to the #endif/#else/#elif depending
4155 * on what directive is actually being processed.
4159 do_xifdef (pfile, keyword, unused1, unused2)
4161 struct directive *keyword;
4162 U_CHAR *unused1, *unused2;
4165 cpp_buffer *ip = CPP_BUFFER (pfile);
4168 enum cpp_token token;
4169 int start_of_file = 0;
4170 U_CHAR *control_macro = 0;
4171 int old_written = CPP_WRITTEN (pfile);
4173 /* Detect a #ifndef at start of file (not counting comments). */
4174 if (ip->fname != 0 && keyword->type == T_IFNDEF)
4175 start_of_file = pfile->only_seen_white == 2;
4177 pfile->no_macro_expand++;
4178 token = get_directive_token (pfile);
4179 pfile->no_macro_expand--;
4181 ident = pfile->token_buffer + old_written;
4182 ident_length = CPP_WRITTEN (pfile) - old_written;
4183 CPP_SET_WRITTEN (pfile, old_written); /* Pop */
4185 if (token == CPP_VSPACE || token == CPP_POP || token == CPP_EOF)
4187 skip = (keyword->type == T_IFDEF);
4188 if (! CPP_TRADITIONAL (pfile))
4189 cpp_pedwarn (pfile, "`#%s' with no argument", keyword->name);
4191 else if (token == CPP_NAME)
4193 HASHNODE *hp = cpp_lookup (pfile, ident, ident_length, -1);
4194 skip = (hp == NULL) ^ (keyword->type == T_IFNDEF);
4195 if (start_of_file && !skip)
4197 control_macro = (U_CHAR *) xmalloc (ident_length + 1);
4198 bcopy (ident, control_macro, ident_length + 1);
4203 skip = (keyword->type == T_IFDEF);
4204 if (! CPP_TRADITIONAL (pfile))
4205 cpp_error (pfile, "`#%s' with invalid argument", keyword->name);
4208 if (!CPP_TRADITIONAL (pfile))
4210 cpp_skip_hspace (pfile);
4212 if (c != EOF && c != '\n')
4213 cpp_pedwarn (pfile, "garbage at end of `#%s' argument", keyword->name);
4215 skip_rest_of_line (pfile);
4219 /* Output a precondition for this macro. */
4220 if (hp && hp->value.defn->predefined)
4221 fprintf (pcp_outfile, "#define %s\n", hp->name);
4224 fprintf (pcp_outfile, "#undef ");
4225 while (is_idchar[*cp]) /* Ick! */
4226 fputc (*cp++, pcp_outfile);
4227 putc ('\n', pcp_outfile);
4231 conditional_skip (pfile, skip, T_IF, control_macro);
4235 /* Push TYPE on stack; then, if SKIP is nonzero, skip ahead.
4236 If this is a #ifndef starting at the beginning of a file,
4237 CONTROL_MACRO is the macro name tested by the #ifndef.
4238 Otherwise, CONTROL_MACRO is 0. */
4241 conditional_skip (pfile, skip, type, control_macro)
4244 enum node_type type;
4245 U_CHAR *control_macro;
4247 IF_STACK_FRAME *temp;
4249 temp = (IF_STACK_FRAME *) xcalloc (1, sizeof (IF_STACK_FRAME));
4250 temp->fname = CPP_BUFFER (pfile)->nominal_fname;
4252 temp->lineno = CPP_BUFFER (pfile)->lineno;
4254 temp->next = pfile->if_stack;
4255 temp->control_macro = control_macro;
4256 pfile->if_stack = temp;
4258 pfile->if_stack->type = type;
4261 skip_if_group (pfile, 0);
4264 ++pfile->if_stack->if_succeeded;
4265 output_line_command (pfile, 1, same_file);
4270 * skip to #endif, #else, or #elif. adjust line numbers, etc.
4271 * leaves input ptr at the sharp sign found.
4272 * If ANY is nonzero, return at next directive of any sort.
4276 skip_if_group (pfile, any)
4281 int at_beg_of_line = 1;
4282 struct directive *kt;
4283 IF_STACK_FRAME *save_if_stack = pfile->if_stack; /* don't pop past here */
4285 U_CHAR *beg_of_line = bp;
4287 register int ident_length;
4288 U_CHAR *ident, *after_ident;
4289 struct parse_marker line_start_mark;
4291 parse_set_mark (&line_start_mark, pfile);
4293 if (CPP_OPTIONS (pfile)->output_conditionals) {
4294 static char failed[] = "#failed\n";
4295 CPP_PUTS (pfile, failed, sizeof(failed)-1);
4297 output_line_command (pfile, 1, same_file);
4301 if (CPP_OPTIONS (pfile)->output_conditionals)
4303 cpp_buffer *pbuf = CPP_BUFFER (pfile);
4304 U_CHAR *start_line = pbuf->buf + line_start_mark.position;
4305 CPP_PUTS (pfile, start_line, pbuf->cur - start_line);
4307 parse_move_mark (&line_start_mark, pfile);
4308 if (!CPP_TRADITIONAL (pfile))
4309 cpp_skip_hspace (pfile);
4313 int old_written = CPP_WRITTEN (pfile);
4314 cpp_skip_hspace (pfile);
4316 parse_name (pfile, GETC());
4317 ident_length = CPP_WRITTEN (pfile) - old_written;
4318 ident = pfile->token_buffer + old_written;
4319 pfile->limit = ident;
4321 if (ident_length == 0)
4322 goto not_a_directive;
4324 /* Handle # followed by a line number. */
4326 /* Avoid error for `###' and similar cases unless -pedantic. */
4329 for (kt = directive_table; kt->length >= 0; kt++)
4331 IF_STACK_FRAME *temp;
4332 if (ident_length == kt->length
4333 && strncmp (ident, kt->name, kt->length) == 0)
4335 /* If we are asked to return on next directive, do so now. */
4345 = (IF_STACK_FRAME *) xcalloc (1, sizeof (IF_STACK_FRAME));
4346 temp->next = pfile->if_stack;
4347 pfile->if_stack = temp;
4349 temp->lineno = CPP_BUFFER(pfile)->lineno;
4351 temp->fname = CPP_BUFFER(pfile)->nominal_fname;
4352 temp->type = kt->type;
4356 if (CPP_PEDANTIC (pfile) && pfile->if_stack != save_if_stack)
4357 validate_else (pfile,
4358 kt->type == T_ELSE ? "#else" : "#endif");
4360 if (pfile->if_stack == CPP_BUFFER (pfile)->if_stack)
4363 "`#%s' not within a conditional", kt->name);
4366 else if (pfile->if_stack == save_if_stack)
4367 goto done; /* found what we came for */
4369 if (kt->type != T_ENDIF)
4371 if (pfile->if_stack->type == T_ELSE)
4372 cpp_error (pfile, "`#else' or `#elif' after `#else'");
4373 pfile->if_stack->type = kt->type;
4377 temp = pfile->if_stack;
4378 pfile->if_stack = temp->next;
4385 /* Don't let erroneous code go by. */
4386 if (kt->length < 0 && !CPP_OPTIONS (pfile)->lang_asm
4387 && CPP_PEDANTIC (pfile))
4388 cpp_pedwarn (pfile, "invalid preprocessor directive name");
4392 /* We're in the middle of a line. Skip the rest of it. */
4399 case '/': /* possible comment */
4400 c = skip_comment (pfile, NULL);
4407 old = CPP_WRITTEN (pfile);
4408 cpp_get_token (pfile);
4409 CPP_SET_WRITTEN (pfile, old);
4412 /* Char after backslash loses its special meaning. */
4413 if (PEEKC() == '\n')
4423 if (CPP_OPTIONS (pfile)->output_conditionals) {
4424 static char end_failed[] = "#endfailed\n";
4425 CPP_PUTS (pfile, end_failed, sizeof(end_failed)-1);
4428 pfile->only_seen_white = 1;
4429 parse_goto_mark (&line_start_mark, pfile);
4430 parse_clear_mark (&line_start_mark);
4434 * handle a #else directive. Do this by just continuing processing
4435 * without changing if_stack ; this is so that the error message
4436 * for missing #endif's etc. will point to the original #if. It
4437 * is possible that something different would be better.
4441 do_else (pfile, keyword, buf, limit)
4443 struct directive *keyword;
4444 U_CHAR *buf, *limit;
4446 cpp_buffer *ip = CPP_BUFFER (pfile);
4448 if (CPP_PEDANTIC (pfile))
4449 validate_else (pfile, "#else");
4450 skip_rest_of_line (pfile);
4452 if (pfile->if_stack == CPP_BUFFER (pfile)->if_stack) {
4453 cpp_error (pfile, "`#else' not within a conditional");
4456 /* #ifndef can't have its special treatment for containing the whole file
4457 if it has a #else clause. */
4458 pfile->if_stack->control_macro = 0;
4460 if (pfile->if_stack->type != T_IF && pfile->if_stack->type != T_ELIF) {
4461 cpp_error (pfile, "`#else' after `#else'");
4462 fprintf (stderr, " (matches line %d", pfile->if_stack->lineno);
4463 if (strcmp (pfile->if_stack->fname, ip->nominal_fname) != 0)
4464 fprintf (stderr, ", file %s", pfile->if_stack->fname);
4465 fprintf (stderr, ")\n");
4467 pfile->if_stack->type = T_ELSE;
4470 if (pfile->if_stack->if_succeeded)
4471 skip_if_group (pfile, 0);
4473 ++pfile->if_stack->if_succeeded; /* continue processing input */
4474 output_line_command (pfile, 1, same_file);
4480 * unstack after #endif command
4484 do_endif (pfile, keyword, buf, limit)
4486 struct directive *keyword;
4487 U_CHAR *buf, *limit;
4489 if (CPP_PEDANTIC (pfile))
4490 validate_else (pfile, "#endif");
4491 skip_rest_of_line (pfile);
4493 if (pfile->if_stack == CPP_BUFFER (pfile)->if_stack)
4494 cpp_error (pfile, "unbalanced `#endif'");
4497 IF_STACK_FRAME *temp = pfile->if_stack;
4498 pfile->if_stack = temp->next;
4499 if (temp->control_macro != 0)
4501 /* This #endif matched a #ifndef at the start of the file.
4502 See if it is at the end of the file. */
4503 struct parse_marker start_mark;
4506 parse_set_mark (&start_mark, pfile);
4510 cpp_skip_hspace (pfile);
4515 parse_goto_mark (&start_mark, pfile);
4516 parse_clear_mark (&start_mark);
4520 /* If we get here, this #endif ends a #ifndef
4521 that contains all of the file (aside from whitespace).
4522 Arrange not to include the file again
4523 if the macro that was tested is defined.
4525 Do not do this for the top-level file in a -include or any
4526 file in a -imacros. */
4530 && ! (indepth == 1 && pfile->no_record_file)
4531 && ! (pfile->no_record_file && no_output))
4534 struct file_name_list *ifile = pfile->all_include_files;
4536 for ( ; ifile != NULL; ifile = ifile->next)
4538 if (!strcmp (ifile->fname, CPP_BUFFER (pfile)->fname))
4540 ifile->control_macro = temp->control_macro;
4548 output_line_command (pfile, 1, same_file);
4553 /* When an #else or #endif is found while skipping failed conditional,
4554 if -pedantic was specified, this is called to warn about text after
4555 the command name. P points to the first char after the command name. */
4558 validate_else (pfile, directive)
4563 cpp_skip_hspace (pfile);
4565 if (c != EOF && c != '\n')
4567 "text following `%s' violates ANSI standard", directive);
4570 /* Get the next token, and add it to the text in pfile->token_buffer.
4571 Return the kind of token we got. */
4574 cpp_get_token (pfile)
4577 register int c, c2, c3;
4579 long start_line, start_column;
4580 enum cpp_token token;
4581 struct cpp_options *opts = CPP_OPTIONS (pfile);
4582 CPP_BUFFER (pfile)->prev = CPP_BUFFER (pfile)->cur;
4588 if (CPP_BUFFER (pfile)->seen_eof)
4590 if (cpp_pop_buffer (pfile) != CPP_NULL_BUFFER (pfile))
4597 cpp_buffer *next_buf
4598 = CPP_PREV_BUFFER (CPP_BUFFER (pfile));
4599 CPP_BUFFER (pfile)->seen_eof = 1;
4600 if (CPP_BUFFER (pfile)->nominal_fname
4601 && next_buf != CPP_NULL_BUFFER (pfile))
4603 /* We're about to return from an #include file.
4604 Emit #line information now (as part of the CPP_POP) result.
4605 But the #line refers to the file we will pop to. */
4606 cpp_buffer *cur_buffer = CPP_BUFFER (pfile);
4607 CPP_BUFFER (pfile) = next_buf;
4608 pfile->input_stack_listing_current = 0;
4609 output_line_command (pfile, 0, leave_file);
4610 CPP_BUFFER (pfile) = cur_buffer;
4620 struct parse_marker start_mark;
4622 if (PEEKC () == '=')
4624 if (opts->put_out_comments)
4625 parse_set_mark (&start_mark, pfile);
4627 cpp_buf_line_and_col (cpp_file_buffer (pfile),
4628 &start_line, &start_column);
4629 c = skip_comment (pfile, &newlines);
4630 if (opts->put_out_comments && (c == '/' || c == EOF))
4631 parse_clear_mark (&start_mark);
4636 cpp_error_with_line (pfile, start_line, start_column,
4637 "unterminated comment");
4640 c = '/'; /* Initial letter of comment. */
4642 /* Comments are equivalent to spaces.
4643 For -traditional, a comment is equivalent to nothing. */
4644 if (opts->put_out_comments)
4646 cpp_buffer *pbuf = CPP_BUFFER (pfile);
4648 U_CHAR *start = pbuf->buf + start_mark.position;
4649 int len = pbuf->cur - start;
4650 CPP_RESERVE(pfile, 1 + len);
4651 CPP_PUTC_Q (pfile, c);
4652 CPP_PUTS_Q (pfile, start, len);
4653 pfile->lineno += newlines;
4654 parse_clear_mark (&start_mark);
4657 else if (CPP_TRADITIONAL (pfile))
4664 /* This may not work if cpp_get_token is called recursively,
4665 since many places look for horizontal space. */
4668 /* Copy the newlines into the output buffer, in order to
4669 avoid the pain of a #line every time a multiline comment
4671 CPP_RESERVE(pfile, newlines);
4672 while (--newlines >= 0)
4674 CPP_PUTC_Q (pfile, '\n');
4680 CPP_RESERVE(pfile, 1);
4681 CPP_PUTC_Q (pfile, ' ');
4685 if (opts->for_lint) {
4688 char *lintcmd = get_lintcmd (ibp, limit, &argbp, &arglen, &cmdlen);
4690 if (lintcmd != NULL) {
4691 /* I believe it is always safe to emit this newline: */
4693 bcopy ("#pragma lint ", (char *) obp, 13);
4695 bcopy (lintcmd, (char *) obp, cmdlen);
4700 bcopy (argbp, (char *) obp, arglen);
4704 /* OK, now bring us back to the state we were in before we entered
4705 this branch. We need #line b/c the newline for the pragma
4706 could fuck things up. */
4707 output_line_command (pfile, 0, same_file);
4708 *(obp++) = ' '; /* just in case, if comments are copied thru */
4716 /* If this is expanding a macro definition, don't recognize
4717 preprocessor directives. */
4720 /* If this is expand_into_temp_buffer, recognize them
4721 only after an actual newline at this level,
4722 not at the beginning of the input level. */
4723 if (ip->fname == 0 && beg_of_line == ip->buf)
4729 if (!pfile->only_seen_white)
4731 if (handle_directive (pfile))
4732 return CPP_DIRECTIVE;
4733 pfile->only_seen_white = 0;
4738 /* A single quoted string is treated like a double -- some
4739 programs (e.g., troff) are perverse this way */
4740 cpp_buf_line_and_col (cpp_file_buffer (pfile),
4741 &start_line, &start_column);
4742 old_written = CPP_WRITTEN (pfile);
4744 CPP_PUTC (pfile, c);
4750 if (CPP_IS_MACRO_BUFFER (CPP_BUFFER (pfile)))
4752 /* try harder: this string crosses a macro expansion
4753 boundary. This can happen naturally if -traditional.
4754 Otherwise, only -D can make a macro with an unmatched
4756 cpp_buffer *next_buf
4757 = CPP_PREV_BUFFER (CPP_BUFFER (pfile));
4758 (*CPP_BUFFER (pfile)->cleanup)
4759 (CPP_BUFFER (pfile), pfile);
4760 CPP_BUFFER (pfile) = next_buf;
4763 if (!CPP_TRADITIONAL (pfile))
4765 cpp_error_with_line (pfile, start_line, start_column,
4766 "unterminated string or character constant");
4767 if (pfile->multiline_string_line != start_line
4768 && pfile->multiline_string_line != 0)
4769 cpp_error_with_line (pfile,
4770 pfile->multiline_string_line, -1,
4771 "possible real start of unterminated constant");
4772 pfile->multiline_string_line = 0;
4776 CPP_PUTC (pfile, cc);
4780 /* Traditionally, end of line ends a string constant with
4781 no error. So exit the loop and record the new line. */
4782 if (CPP_TRADITIONAL (pfile))
4786 cpp_error_with_line (pfile, start_line, start_column,
4787 "unterminated character constant");
4790 if (CPP_PEDANTIC (pfile)
4791 && pfile->multiline_string_line == 0)
4793 cpp_pedwarn_with_line (pfile, start_line, start_column,
4794 "string constant runs past end of line");
4796 if (pfile->multiline_string_line == 0)
4797 pfile->multiline_string_line = start_line;
4804 /* Backslash newline is replaced by nothing at all. */
4805 CPP_ADJUST_WRITTEN (pfile, -1);
4810 /* ANSI stupidly requires that in \\ the second \
4811 is *not* prevented from combining with a newline. */
4814 CPP_PUTC (pfile, cc);
4826 pfile->lineno += count_newlines (pfile->token_buffer + old_written,
4827 CPP_PWRITTEN (pfile));
4828 pfile->only_seen_white = 0;
4829 return c == '\'' ? CPP_CHAR : CPP_STRING;
4832 if (!opts->dollars_in_ident)
4837 if (opts->cplusplus && PEEKC () == ':')
4846 if (c2 == c || c2 == '=')
4856 if (PEEKC () == '=')
4863 if (c2 == '-' && opts->chill)
4865 /* Chill style comment */
4866 if (opts->put_out_comments)
4867 parse_set_mark (&start_mark, pfile);
4868 FORWARD(1); /* Skip second '-'. */
4876 /* Don't consider final '\n' to be part of comment. */
4882 goto return_comment;
4884 if (c2 == '-' || c2 == '=' || c2 == '>')
4889 if (pfile->parsing_include_directive)
4893 CPP_PUTC (pfile, c);
4898 if (c == '\n' || c == EOF)
4901 "missing '>' in `#include <FILENAME>'");
4907 /* else fall through */
4916 CPP_RESERVE (pfile, 4);
4917 CPP_PUTC (pfile, c);
4918 CPP_PUTC (pfile, c2);
4922 CPP_PUTC_Q (pfile, GETC ());
4923 CPP_NUL_TERMINATE_Q (pfile);
4924 pfile->only_seen_white = 0;
4928 if (CPP_BUFFER (pfile)->has_escapes)
4933 if (pfile->output_escapes)
4934 CPP_PUTS (pfile, "@-", 2);
4935 parse_name (pfile, GETC ());
4938 else if (is_space [c])
4940 CPP_RESERVE (pfile, 2);
4941 if (pfile->output_escapes)
4942 CPP_PUTC_Q (pfile, '@');
4943 CPP_PUTC_Q (pfile, c);
4947 if (pfile->output_escapes)
4949 CPP_PUTS (pfile, "@@", 2);
4959 CPP_RESERVE(pfile, 2);
4960 CPP_PUTC_Q (pfile, '.');
4964 /* FIXME - misses the case "..\\\n." */
4965 if (c2 == '.' && PEEKN(1) == '.')
4967 CPP_RESERVE(pfile, 4);
4968 CPP_PUTC_Q (pfile, '.');
4969 CPP_PUTC_Q (pfile, '.');
4970 CPP_PUTC_Q (pfile, '.');
4972 CPP_NUL_TERMINATE_Q (pfile);
4973 pfile->only_seen_white = 0;
4980 pfile->only_seen_white = 0;
4982 CPP_RESERVE(pfile, 3);
4983 CPP_PUTC_Q (pfile, c);
4984 CPP_PUTC_Q (pfile, GETC ());
4985 CPP_NUL_TERMINATE_Q (pfile);
4991 if ((c2 == '\'' || c2 == '\"') && !CPP_TRADITIONAL (pfile))
4993 CPP_PUTC (pfile, c);
4999 case '0': case '1': case '2': case '3': case '4':
5000 case '5': case '6': case '7': case '8': case '9':
5005 CPP_RESERVE (pfile, 2);
5006 CPP_PUTC_Q (pfile, c);
5011 if (!is_idchar[c] && c != '.'
5012 && ((c2 != 'e' && c2 != 'E'
5013 && ((c2 != 'p' && c2 != 'P') || CPP_C89 (pfile)))
5014 || (c != '+' && c != '-')))
5019 CPP_NUL_TERMINATE_Q (pfile);
5020 pfile->only_seen_white = 0;
5022 case 'b': case 'c': case 'd': case 'h': case 'o':
5023 case 'B': case 'C': case 'D': case 'H': case 'O':
5024 if (opts->chill && PEEKC () == '\'')
5026 pfile->only_seen_white = 0;
5027 CPP_RESERVE (pfile, 2);
5028 CPP_PUTC_Q (pfile, c);
5029 CPP_PUTC_Q (pfile, '\'');
5035 goto chill_number_eof;
5038 if (c == '\\' && PEEKC() == '\n')
5045 CPP_PUTC (pfile, c);
5049 CPP_RESERVE (pfile, 2);
5050 CPP_PUTC_Q (pfile, c);
5051 CPP_NUL_TERMINATE_Q (pfile);
5058 CPP_NUL_TERMINATE (pfile);
5065 case 'a': case 'e': case 'f': case 'g': case 'i': case 'j':
5066 case 'k': case 'l': case 'm': case 'n': case 'p': case 'q':
5067 case 'r': case 's': case 't': case 'u': case 'v': case 'w':
5068 case 'x': case 'y': case 'z':
5069 case 'A': case 'E': case 'F': case 'G': case 'I': case 'J':
5070 case 'K': case 'M': case 'N': case 'P': case 'Q': case 'R':
5071 case 'S': case 'T': case 'U': case 'V': case 'W': case 'X':
5076 unsigned char *ident;
5077 int before_name_written = CPP_WRITTEN (pfile);
5079 parse_name (pfile, c);
5080 pfile->only_seen_white = 0;
5081 if (pfile->no_macro_expand)
5083 ident = pfile->token_buffer + before_name_written;
5084 ident_len = CPP_PWRITTEN (pfile) - ident;
5085 hp = cpp_lookup (pfile, ident, ident_len, -1);
5088 if (hp->type == T_DISABLED)
5090 if (pfile->output_escapes)
5091 { /* Return "@-IDENT", followed by '\0'. */
5093 CPP_RESERVE (pfile, 3);
5094 ident = pfile->token_buffer + before_name_written;
5095 CPP_ADJUST_WRITTEN (pfile, 2);
5096 for (i = ident_len; i >= 0; i--) ident[i+2] = ident[i];
5103 /* If macro wants an arglist, verify that a '(' follows.
5104 first skip all whitespace, copying it to the output
5105 after the macro name. Then, if there is no '(',
5106 decide this is not a macro call and leave things that way. */
5107 if (hp->type == T_MACRO && hp->value.defn->nargs >= 0)
5109 struct parse_marker macro_mark;
5111 while (CPP_IS_MACRO_BUFFER (CPP_BUFFER (pfile)))
5113 cpp_buffer *next_buf;
5114 cpp_skip_hspace (pfile);
5115 if (PEEKC () != EOF)
5117 next_buf = CPP_PREV_BUFFER (CPP_BUFFER (pfile));
5118 (*CPP_BUFFER (pfile)->cleanup) (CPP_BUFFER (pfile), pfile);
5119 CPP_BUFFER (pfile) = next_buf;
5121 parse_set_mark (¯o_mark, pfile);
5124 cpp_skip_hspace (pfile);
5126 is_macro_call = c == '(';
5132 parse_goto_mark (¯o_mark, pfile);
5133 parse_clear_mark (¯o_mark);
5137 /* This is now known to be a macro call. */
5139 /* it might not actually be a macro. */
5140 if (hp->type != T_MACRO) {
5141 int xbuf_len; U_CHAR *xbuf;
5142 CPP_SET_WRITTEN (pfile, before_name_written);
5143 special_symbol (hp, pfile);
5144 xbuf_len = CPP_WRITTEN (pfile) - before_name_written;
5145 xbuf = (U_CHAR *) xmalloc (xbuf_len + 1);
5146 CPP_SET_WRITTEN (pfile, before_name_written);
5147 bcopy (CPP_PWRITTEN (pfile), xbuf, xbuf_len + 1);
5148 push_macro_expansion (pfile, xbuf, xbuf_len, hp);
5152 /* Expand the macro, reading arguments as needed,
5153 and push the expansion on the input stack. */
5154 macroexpand (pfile, hp);
5155 CPP_SET_WRITTEN (pfile, before_name_written);
5158 /* An extra "@ " is added to the end of a macro expansion
5159 to prevent accidental token pasting. We prefer to avoid
5160 unneeded extra spaces (for the sake of cpp-using tools like
5161 imake). Here we remove the space if it is safe to do so. */
5162 if (pfile->buffer->rlimit - pfile->buffer->cur >= 3
5163 && pfile->buffer->rlimit[-2] == '@'
5164 && pfile->buffer->rlimit[-1] == ' ')
5166 int c1 = pfile->buffer->rlimit[-3];
5167 int c2 = CPP_BUF_PEEK (CPP_PREV_BUFFER (CPP_BUFFER (pfile)));
5168 if (c2 == EOF || ! unsafe_chars (c1, c2))
5169 pfile->buffer->rlimit -= 2;
5174 case ' ': case '\t': case '\v': case '\r':
5177 CPP_PUTC (pfile, c);
5179 if (c == EOF || !is_hor_space[c])
5193 CPP_PUTC (pfile, c);
5194 if (pfile->only_seen_white == 0)
5195 pfile->only_seen_white = 1;
5197 output_line_command (pfile, 1, same_file);
5200 case '(': token = CPP_LPAREN; goto char1;
5201 case ')': token = CPP_RPAREN; goto char1;
5202 case '{': token = CPP_LBRACE; goto char1;
5203 case '}': token = CPP_RBRACE; goto char1;
5204 case ',': token = CPP_COMMA; goto char1;
5205 case ';': token = CPP_SEMICOLON; goto char1;
5211 pfile->only_seen_white = 0;
5212 CPP_PUTC (pfile, c);
5218 /* Like cpp_get_token, but skip spaces and comments. */
5221 cpp_get_non_space_token (pfile)
5224 int old_written = CPP_WRITTEN (pfile);
5227 enum cpp_token token = cpp_get_token (pfile);
5228 if (token != CPP_COMMENT && token != CPP_POP
5229 && token != CPP_HSPACE && token != CPP_VSPACE)
5231 CPP_SET_WRITTEN (pfile, old_written);
5235 /* Parse an identifier starting with C. */
5238 parse_name (pfile, c)
5239 cpp_reader *pfile; int c;
5245 if (c == '\\' && PEEKC() == '\n')
5254 if (c == '$' && CPP_PEDANTIC (pfile))
5255 cpp_pedwarn ("`$' in identifier");
5257 CPP_RESERVE(pfile, 2); /* One more for final NUL. */
5258 CPP_PUTC_Q (pfile, c);
5263 CPP_NUL_TERMINATE_Q (pfile);
5268 /* Maintain and search list of included files, for #import. */
5270 /* Hash a file name for import_hash_table. */
5278 while (*f) val += *f++;
5279 return (val%IMPORT_HASH_SIZE);
5282 /* Search for file FILENAME in import_hash_table.
5283 Return -2 if found, either a matching name or a matching inode.
5284 Otherwise, open the file and return a file descriptor if successful
5285 or -1 if unsuccessful. */
5288 lookup_import (pfile, filename, searchptr)
5291 struct file_name_list *searchptr;
5293 struct import_file *i;
5299 hashval = import_hash (filename);
5301 /* Attempt to find file in list of already included files */
5302 i = pfile->import_hash_table[hashval];
5305 if (!strcmp (filename, i->name))
5306 return -2; /* return found */
5309 /* Open it and try a match on inode/dev */
5310 fd = open_include_file (pfile, filename, searchptr);
5314 for (h = 0; h < IMPORT_HASH_SIZE; h++) {
5315 i = pfile->import_hash_table[h];
5317 /* Compare the inode and the device.
5318 Supposedly on some systems the inode is not a scalar. */
5319 if (!bcmp ((char *) &i->inode, (char *) &sb.st_ino, sizeof (sb.st_ino))
5320 && i->dev == sb.st_dev) {
5322 return -2; /* return found */
5327 return fd; /* Not found, return open file */
5330 /* Add the file FNAME, open on descriptor FD, to import_hash_table. */
5333 add_import (pfile, fd, fname)
5338 struct import_file *i;
5342 hashval = import_hash (fname);
5344 i = (struct import_file *)xmalloc (sizeof (struct import_file));
5345 i->name = (char *)xmalloc (strlen (fname)+1);
5346 strcpy (i->name, fname);
5347 bcopy ((char *) &sb.st_ino, (char *) &i->inode, sizeof (sb.st_ino));
5349 i->next = pfile->import_hash_table[hashval];
5350 pfile->import_hash_table[hashval] = i;
5353 /* The file_name_map structure holds a mapping of file names for a
5354 particular directory. This mapping is read from the file named
5355 FILE_NAME_MAP_FILE in that directory. Such a file can be used to
5356 map filenames on a file system with severe filename restrictions,
5357 such as DOS. The format of the file name map file is just a series
5358 of lines with two tokens on each line. The first token is the name
5359 to map, and the second token is the actual name to use. */
5361 struct file_name_map
5363 struct file_name_map *map_next;
5368 #define FILE_NAME_MAP_FILE "header.gcc"
5370 /* Read a space delimited string of unlimited length from a stdio
5374 read_filename_string (ch, f)
5382 set = alloc = xmalloc (len + 1);
5386 while ((ch = getc (f)) != EOF && ! is_space[ch])
5388 if (set - alloc == len)
5391 alloc = xrealloc (alloc, len + 1);
5392 set = alloc + len / 2;
5402 /* This structure holds a linked list of file name maps, one per directory. */
5404 struct file_name_map_list
5406 struct file_name_map_list *map_list_next;
5407 char *map_list_name;
5408 struct file_name_map *map_list_map;
5411 /* Read the file name map file for DIRNAME. */
5413 static struct file_name_map *
5414 read_name_map (pfile, dirname)
5418 register struct file_name_map_list *map_list_ptr;
5422 for (map_list_ptr = CPP_OPTIONS (pfile)->map_list; map_list_ptr;
5423 map_list_ptr = map_list_ptr->map_list_next)
5424 if (! strcmp (map_list_ptr->map_list_name, dirname))
5425 return map_list_ptr->map_list_map;
5427 map_list_ptr = ((struct file_name_map_list *)
5428 xmalloc (sizeof (struct file_name_map_list)));
5429 map_list_ptr->map_list_name = savestring (dirname);
5430 map_list_ptr->map_list_map = NULL;
5432 name = (char *) alloca (strlen (dirname) + strlen (FILE_NAME_MAP_FILE) + 2);
5433 strcpy (name, dirname);
5436 strcat (name, FILE_NAME_MAP_FILE);
5437 f = fopen (name, "r");
5439 map_list_ptr->map_list_map = NULL;
5443 int dirlen = strlen (dirname);
5445 while ((ch = getc (f)) != EOF)
5448 struct file_name_map *ptr;
5452 from = read_filename_string (ch, f);
5453 while ((ch = getc (f)) != EOF && is_hor_space[ch])
5455 to = read_filename_string (ch, f);
5457 ptr = ((struct file_name_map *)
5458 xmalloc (sizeof (struct file_name_map)));
5459 ptr->map_from = from;
5461 /* Make the real filename absolute. */
5466 ptr->map_to = xmalloc (dirlen + strlen (to) + 2);
5467 strcpy (ptr->map_to, dirname);
5468 ptr->map_to[dirlen] = '/';
5469 strcpy (ptr->map_to + dirlen + 1, to);
5473 ptr->map_next = map_list_ptr->map_list_map;
5474 map_list_ptr->map_list_map = ptr;
5476 while ((ch = getc (f)) != '\n')
5483 map_list_ptr->map_list_next = CPP_OPTIONS (pfile)->map_list;
5484 CPP_OPTIONS (pfile)->map_list = map_list_ptr;
5486 return map_list_ptr->map_list_map;
5489 /* Try to open include file FILENAME. SEARCHPTR is the directory
5490 being tried from the include file search path. This function maps
5491 filenames on file systems based on information read by
5495 open_include_file (pfile, filename, searchptr)
5498 struct file_name_list *searchptr;
5500 register struct file_name_map *map;
5501 register char *from;
5504 if (searchptr && ! searchptr->got_name_map)
5506 searchptr->name_map = read_name_map (pfile,
5508 ? searchptr->fname : ".");
5509 searchptr->got_name_map = 1;
5512 /* First check the mapping for the directory we are using. */
5513 if (searchptr && searchptr->name_map)
5516 if (searchptr->fname)
5517 from += strlen (searchptr->fname) + 1;
5518 for (map = searchptr->name_map; map; map = map->map_next)
5520 if (! strcmp (map->map_from, from))
5522 /* Found a match. */
5523 return open (map->map_to, O_RDONLY, 0666);
5528 /* Try to find a mapping file for the particular directory we are
5529 looking in. Thus #include <sys/types.h> will look up sys/types.h
5530 in /usr/include/header.gcc and look up types.h in
5531 /usr/include/sys/header.gcc. */
5532 p = rindex (filename, '/');
5537 && strlen (searchptr->fname) == p - filename
5538 && ! strncmp (searchptr->fname, filename, p - filename))
5540 /* FILENAME is in SEARCHPTR, which we've already checked. */
5541 return open (filename, O_RDONLY, 0666);
5551 dir = (char *) alloca (p - filename + 1);
5552 bcopy (filename, dir, p - filename);
5553 dir[p - filename] = '\0';
5556 for (map = read_name_map (pfile, dir); map; map = map->map_next)
5557 if (! strcmp (map->map_from, from))
5558 return open (map->map_to, O_RDONLY, 0666);
5560 return open (filename, O_RDONLY, 0666);
5563 /* Process the contents of include file FNAME, already open on descriptor F,
5565 SYSTEM_HEADER_P is 1 if this file resides in any one of the known
5566 "system" include directories (as decided by the `is_system_include'
5568 DIRPTR is the link in the dir path through which this file was found,
5569 or 0 if the file name was absolute or via the current directory.
5570 Return 1 on success, 0 on failure.
5572 The caller is responsible for the cpp_push_buffer. */
5575 finclude (pfile, f, fname, system_header_p, dirptr)
5579 int system_header_p;
5580 struct file_name_list *dirptr;
5586 cpp_buffer *fp; /* For input stack frame */
5587 int missing_newline = 0;
5589 if (file_size_and_mode (f, &st_mode, &st_size) < 0)
5591 cpp_perror_with_name (pfile, fname);
5593 cpp_pop_buffer (pfile);
5597 fp = CPP_BUFFER (pfile);
5598 fp->nominal_fname = fp->fname = fname;
5603 fp->system_header_p = system_header_p;
5606 fp->cleanup = file_cleanup;
5608 if (S_ISREG (st_mode)) {
5609 fp->buf = (U_CHAR *) xmalloc (st_size + 2);
5610 fp->alimit = fp->buf + st_size + 2;
5613 /* Read the file contents, knowing that st_size is an upper bound
5614 on the number of bytes we can read. */
5615 length = safe_read (f, fp->buf, st_size);
5616 fp->rlimit = fp->buf + length;
5617 if (length < 0) goto nope;
5619 else if (S_ISDIR (st_mode)) {
5620 cpp_error (pfile, "directory `%s' specified in #include", fname);
5624 /* Cannot count its file size before reading.
5625 First read the entire file into heap and
5626 copy them into buffer on stack. */
5631 fp->buf = (U_CHAR *) xmalloc (bsize + 2);
5634 i = safe_read (f, fp->buf + st_size, bsize - st_size);
5636 goto nope; /* error! */
5638 if (st_size != bsize)
5639 break; /* End of file */
5641 fp->buf = (U_CHAR *) xrealloc (fp->buf, bsize + 2);
5647 if ((length > 0 && fp->buf[length - 1] != '\n')
5648 /* Backslash-newline at end is not good enough. */
5649 || (length > 1 && fp->buf[length - 2] == '\\')) {
5650 fp->buf[length++] = '\n';
5652 missing_newline = 1;
5655 fp->buf[length] = '\0';
5656 fp->rlimit = fp->buf + length;
5658 /* Close descriptor now, so nesting does not use lots of descriptors. */
5661 /* Must do this before calling trigraph_pcp, so that the correct file name
5662 will be printed in warning messages. */
5664 pfile->input_stack_listing_current = 0;
5674 if (missing_newline)
5677 if (CPP_PEDANTIC (pfile) && missing_newline)
5678 pedwarn ("file does not end in newline");
5681 input_file_stack_tick++;
5688 cpp_perror_with_name (pfile, fname);
5694 /* This is called after options have been processed.
5695 * Check options for consistency, and setup for processing input
5696 * from the file named FNAME. (Use standard input if FNAME==NULL.)
5697 * Return 1 on succes, 0 on failure.
5701 cpp_start_read (pfile, fname)
5705 struct cpp_options *opts = CPP_OPTIONS (pfile);
5706 struct cpp_pending *pend;
5711 /* The code looks at the defaults through this pointer, rather than through
5712 the constant structure above. This pointer gets changed if an environment
5713 variable specifies other defaults. */
5714 struct default_include *include_defaults = include_defaults_array;
5716 /* Add dirs from CPATH after dirs from -I. */
5717 /* There seems to be confusion about what CPATH should do,
5718 so for the moment it is not documented. */
5719 /* Some people say that CPATH should replace the standard include dirs,
5720 but that seems pointless: it comes before them, so it overrides them
5722 p = (char *) getenv ("CPATH");
5723 if (p != 0 && ! opts->no_standard_includes)
5724 path_include (pfile, p);
5726 /* Now that dollars_in_ident is known, initialize is_idchar. */
5727 initialize_char_syntax (opts);
5729 /* Do partial setup of input buffer for the sake of generating
5730 early #line directives (when -g is in effect). */
5731 fp = cpp_push_buffer (pfile, NULL, 0);
5734 if (opts->in_fname == NULL)
5735 opts->in_fname = "";
5736 fp->nominal_fname = fp->fname = opts->in_fname;
5739 /* Install __LINE__, etc. Must follow initialize_char_syntax
5740 and option processing. */
5741 initialize_builtins (pfile);
5743 /* Do standard #defines and assertions
5744 that identify system and machine type. */
5746 if (!opts->inhibit_predefs) {
5747 char *p = (char *) alloca (strlen (predefs) + 1);
5748 strcpy (p, predefs);
5751 while (*p == ' ' || *p == '\t')
5753 /* Handle -D options. */
5754 if (p[0] == '-' && p[1] == 'D') {
5756 while (*p && *p != ' ' && *p != '\t')
5760 if (opts->debug_output)
5761 output_line_command (pfile, 0, same_file);
5762 cpp_define (pfile, q);
5763 while (*p == ' ' || *p == '\t')
5765 } else if (p[0] == '-' && p[1] == 'A') {
5766 /* Handle -A options (assertions). */
5775 past_name = assertion;
5776 /* Locate end of name. */
5777 while (*past_name && *past_name != ' '
5778 && *past_name != '\t' && *past_name != '(')
5780 /* Locate `(' at start of value. */
5782 while (*value && (*value == ' ' || *value == '\t'))
5784 if (*value++ != '(')
5786 while (*value && (*value == ' ' || *value == '\t'))
5789 /* Locate end of value. */
5790 while (*past_value && *past_value != ' '
5791 && *past_value != '\t' && *past_value != ')')
5793 termination = past_value;
5794 while (*termination && (*termination == ' ' || *termination == '\t'))
5796 if (*termination++ != ')')
5798 if (*termination && *termination != ' ' && *termination != '\t')
5800 /* Temporarily null-terminate the value. */
5801 save_char = *termination;
5802 *termination = '\0';
5803 /* Install the assertion. */
5804 make_assertion (pfile, "-A", assertion);
5805 *termination = (char) save_char;
5807 while (*p == ' ' || *p == '\t')
5815 /* Now handle the command line options. */
5817 /* Do -U's, -D's and -A's in the order they were seen. */
5818 /* First reverse the list. */
5819 opts->pending = nreverse_pending (opts->pending);
5821 for (pend = opts->pending; pend; pend = pend->next)
5823 if (pend->cmd != NULL && pend->cmd[0] == '-')
5825 switch (pend->cmd[1])
5828 if (opts->debug_output)
5829 output_line_command (pfile, 0, same_file);
5830 do_undef (pfile, NULL, pend->arg, pend->arg + strlen (pend->arg));
5833 if (opts->debug_output)
5834 output_line_command (pfile, 0, same_file);
5835 cpp_define (pfile, pend->arg);
5838 make_assertion (pfile, "-A", pend->arg);
5844 opts->done_initializing = 1;
5846 { /* Read the appropriate environment variable and if it exists
5847 replace include_defaults with the listed path. */
5849 switch ((opts->objc << 1) + opts->cplusplus)
5852 epath = getenv ("C_INCLUDE_PATH");
5855 epath = getenv ("CPLUS_INCLUDE_PATH");
5858 epath = getenv ("OBJC_INCLUDE_PATH");
5861 epath = getenv ("OBJCPLUS_INCLUDE_PATH");
5864 /* If the environment var for this language is set,
5865 add to the default list of include directories. */
5867 char *nstore = (char *) alloca (strlen (epath) + 2);
5869 char *startp, *endp;
5871 for (num_dirs = 1, startp = epath; *startp; startp++)
5872 if (*startp == PATH_SEPARATOR)
5875 = (struct default_include *) xmalloc ((num_dirs
5876 * sizeof (struct default_include))
5877 + sizeof (include_defaults_array));
5878 startp = endp = epath;
5881 /* Handle cases like c:/usr/lib:d:/gcc/lib */
5882 if ((*endp == PATH_SEPARATOR)
5884 strncpy (nstore, startp, endp-startp);
5886 strcpy (nstore, ".");
5888 nstore[endp-startp] = '\0';
5890 include_defaults[num_dirs].fname = savestring (nstore);
5891 include_defaults[num_dirs].cplusplus = opts->cplusplus;
5892 include_defaults[num_dirs].cxx_aware = 1;
5896 endp = startp = endp + 1;
5900 /* Put the usual defaults back in at the end. */
5901 bcopy ((char *) include_defaults_array,
5902 (char *) &include_defaults[num_dirs],
5903 sizeof (include_defaults_array));
5907 append_include_chain (pfile, opts->before_system, opts->last_before_system);
5908 opts->first_system_include = opts->before_system;
5910 /* Unless -fnostdinc,
5911 tack on the standard include file dirs to the specified list */
5912 if (!opts->no_standard_includes) {
5913 struct default_include *p = include_defaults;
5914 char *specd_prefix = opts->include_prefix;
5915 char *default_prefix = savestring (GCC_INCLUDE_DIR);
5916 int default_len = 0;
5917 /* Remove the `include' from /usr/local/lib/gcc.../include. */
5918 if (!strcmp (default_prefix + strlen (default_prefix) - 8, "/include")) {
5919 default_len = strlen (default_prefix) - 7;
5920 default_prefix[default_len] = 0;
5922 /* Search "translated" versions of GNU directories.
5923 These have /usr/local/lib/gcc... replaced by specd_prefix. */
5924 if (specd_prefix != 0 && default_len != 0)
5925 for (p = include_defaults; p->fname; p++) {
5926 /* Some standard dirs are only for C++. */
5928 || (opts->cplusplus && !opts->no_standard_cplusplus_includes)) {
5929 /* Does this dir start with the prefix? */
5930 if (!strncmp (p->fname, default_prefix, default_len)) {
5931 /* Yes; change prefix and add to search list. */
5932 struct file_name_list *new
5933 = (struct file_name_list *) xmalloc (sizeof (struct file_name_list));
5934 int this_len = strlen (specd_prefix) + strlen (p->fname) - default_len;
5935 char *str = (char *) xmalloc (this_len + 1);
5936 strcpy (str, specd_prefix);
5937 strcat (str, p->fname + default_len);
5939 new->control_macro = 0;
5940 new->c_system_include_path = !p->cxx_aware;
5941 new->got_name_map = 0;
5942 append_include_chain (pfile, new, new);
5943 if (opts->first_system_include == 0)
5944 opts->first_system_include = new;
5948 /* Search ordinary names for GNU include directories. */
5949 for (p = include_defaults; p->fname; p++) {
5950 /* Some standard dirs are only for C++. */
5952 || (opts->cplusplus && !opts->no_standard_cplusplus_includes)) {
5953 struct file_name_list *new
5954 = (struct file_name_list *) xmalloc (sizeof (struct file_name_list));
5955 new->control_macro = 0;
5956 new->c_system_include_path = !p->cxx_aware;
5957 new->fname = p->fname;
5958 new->got_name_map = 0;
5959 append_include_chain (pfile, new, new);
5960 if (opts->first_system_include == 0)
5961 opts->first_system_include = new;
5966 /* Tack the after_include chain at the end of the include chain. */
5967 append_include_chain (pfile, opts->after_include, opts->last_after_include);
5968 if (opts->first_system_include == 0)
5969 opts->first_system_include = opts->after_include;
5971 /* With -v, print the list of dirs to search. */
5972 if (opts->verbose) {
5973 struct file_name_list *p;
5974 fprintf (stderr, "#include \"...\" search starts here:\n");
5975 for (p = opts->include; p; p = p->next) {
5976 if (p == opts->first_bracket_include)
5977 fprintf (stderr, "#include <...> search starts here:\n");
5978 fprintf (stderr, " %s\n", p->fname);
5980 fprintf (stderr, "End of search list.\n");
5983 /* Scan the -imacros files before the main input.
5984 Much like #including them, but with no_output set
5985 so that only their macro definitions matter. */
5987 opts->no_output++; pfile->no_record_file++;
5988 for (pend = opts->pending; pend; pend = pend->next)
5990 if (pend->cmd != NULL && strcmp (pend->cmd, "-imacros") == 0)
5992 int fd = open (pend->arg, O_RDONLY, 0666);
5995 cpp_perror_with_name (pfile, pend->arg);
5998 if (!cpp_push_buffer (pfile, NULL, 0))
6000 finclude (pfile, fd, pend->arg, 0, NULL_PTR);
6001 cpp_scan_buffer (pfile);
6004 opts->no_output--; pfile->no_record_file--;
6006 /* Copy the entire contents of the main input file into
6007 the stacked input buffer previously allocated for it. */
6008 if (fname == NULL || *fname == 0) {
6011 } else if ((f = open (fname, O_RDONLY, 0666)) < 0)
6012 cpp_pfatal_with_name (pfile, fname);
6014 /* -MG doesn't select the form of output and must be specified with one of
6015 -M or -MM. -MG doesn't make sense with -MD or -MMD since they don't
6016 inhibit compilation. */
6017 if (opts->print_deps_missing_files
6018 && (opts->print_deps == 0 || !opts->no_output))
6020 cpp_fatal (pfile, "-MG must be specified with one of -M or -MM");
6024 /* Either of two environment variables can specify output of deps.
6025 Its value is either "OUTPUT_FILE" or "OUTPUT_FILE DEPS_TARGET",
6026 where OUTPUT_FILE is the file to write deps info to
6027 and DEPS_TARGET is the target to mention in the deps. */
6029 if (opts->print_deps == 0
6030 && (getenv ("SUNPRO_DEPENDENCIES") != 0
6031 || getenv ("DEPENDENCIES_OUTPUT") != 0)) {
6032 char *spec = getenv ("DEPENDENCIES_OUTPUT");
6038 spec = getenv ("SUNPRO_DEPENDENCIES");
6039 opts->print_deps = 2;
6042 opts->print_deps = 1;
6045 /* Find the space before the DEPS_TARGET, if there is one. */
6046 /* This should use index. (mrs) */
6047 while (*s != 0 && *s != ' ') s++;
6050 opts->deps_target = s + 1;
6051 output_file = (char *) xmalloc (s - spec + 1);
6052 bcopy (spec, output_file, s - spec);
6053 output_file[s - spec] = 0;
6057 opts->deps_target = 0;
6061 opts->deps_file = output_file;
6062 opts->print_deps_append = 1;
6065 /* For -M, print the expected object file name
6066 as the target of this Make-rule. */
6067 if (opts->print_deps)
6069 pfile->deps_allocated_size = 200;
6070 pfile->deps_buffer = (char *) xmalloc (pfile->deps_allocated_size);
6071 pfile->deps_buffer[0] = 0;
6072 pfile->deps_size = 0;
6073 pfile->deps_column = 0;
6075 if (opts->deps_target)
6076 deps_output (pfile, opts->deps_target, ':');
6077 else if (*opts->in_fname == 0)
6078 deps_output (pfile, "-", ':');
6084 /* Discard all directory prefixes from filename. */
6085 if ((q = rindex (opts->in_fname, '/')) != NULL
6086 #ifdef DIR_SEPARATOR
6087 && (q = rindex (opts->in_fname, DIR_SEPARATOR)) != NULL
6094 /* Copy remainder to mungable area. */
6095 p = (char *) alloca (strlen(q) + 8);
6098 /* Output P, but remove known suffixes. */
6102 && p[len - 2] == '.'
6103 && index("cCsSm", p[len - 1]))
6106 && p[len - 3] == '.'
6107 && p[len - 2] == 'c'
6108 && p[len - 1] == 'c')
6111 && p[len - 4] == '.'
6112 && p[len - 3] == 'c'
6113 && p[len - 2] == 'x'
6114 && p[len - 1] == 'x')
6117 && p[len - 4] == '.'
6118 && p[len - 3] == 'c'
6119 && p[len - 2] == 'p'
6120 && p[len - 1] == 'p')
6123 /* Supply our own suffix. */
6130 deps_output (pfile, p, ':');
6131 deps_output (pfile, opts->in_fname, ' ');
6136 /* Make sure data ends with a newline. And put a null after it. */
6138 if ((fp->length > 0 && fp->buf[fp->length - 1] != '\n')
6139 /* Backslash-newline at end is not good enough. */
6140 || (fp->length > 1 && fp->buf[fp->length - 2] == '\\')) {
6141 fp->buf[fp->length++] = '\n';
6142 missing_newline = 1;
6144 fp->buf[fp->length] = '\0';
6146 /* Unless inhibited, convert trigraphs in the input. */
6152 /* Scan the -include files before the main input.
6153 We push these in reverse order, so that the first one is handled first. */
6155 pfile->no_record_file++;
6156 opts->pending = nreverse_pending (opts->pending);
6157 for (pend = opts->pending; pend; pend = pend->next)
6159 if (pend->cmd != NULL && strcmp (pend->cmd, "-include") == 0)
6161 int fd = open (pend->arg, O_RDONLY, 0666);
6164 cpp_perror_with_name (pfile, pend->arg);
6167 if (!cpp_push_buffer (pfile, NULL, 0))
6169 finclude (pfile, fd, pend->arg, 0, NULL_PTR);
6172 pfile->no_record_file--;
6174 /* Free the pending list. */
6175 for (pend = opts->pending; pend; )
6177 struct cpp_pending *next = pend->next;
6181 opts->pending = NULL;
6184 /* Scan the input, processing macros and directives. */
6186 rescan (&outbuf, 0);
6188 if (missing_newline)
6191 if (CPP_PEDANTIC (pfile) && missing_newline)
6192 pedwarn ("file does not end in newline");
6195 if (finclude (pfile, f, fname, 0, NULL_PTR))
6196 output_line_command (pfile, 0, same_file);
6201 cpp_reader_init (pfile)
6204 bzero ((char *) pfile, sizeof (cpp_reader));
6205 pfile->get_token = cpp_get_token;
6207 pfile->token_buffer_size = 200;
6208 pfile->token_buffer = (U_CHAR *) xmalloc (pfile->token_buffer_size);
6209 CPP_SET_WRITTEN (pfile, 0);
6211 pfile->system_include_depth = 0;
6212 pfile->dont_repeat_files = 0;
6213 pfile->all_include_files = 0;
6214 pfile->max_include_len = 0;
6215 pfile->timebuf = NULL;
6216 pfile->only_seen_white = 1;
6217 pfile->buffer = CPP_NULL_BUFFER(pfile);
6220 static struct cpp_pending *
6221 nreverse_pending (list)
6222 struct cpp_pending *list;
6225 register struct cpp_pending *prev = 0, *next, *pend;
6226 for (pend = list; pend; pend = next)
6236 push_pending (pfile, cmd, arg)
6241 struct cpp_pending *pend
6242 = (struct cpp_pending *) xmalloc (sizeof (struct cpp_pending));
6245 pend->next = CPP_OPTIONS (pfile)->pending;
6246 CPP_OPTIONS (pfile)->pending = pend;
6249 /* Handle command-line options in (argc, argv).
6250 Can be called multiple times, to handle multiple sets of options.
6251 Returns if an unrecognized option is seen.
6252 Returns number of handled arguments. */
6255 cpp_handle_options (pfile, argc, argv)
6261 struct cpp_options *opts = CPP_OPTIONS (pfile);
6262 for (i = 0; i < argc; i++) {
6263 if (argv[i][0] != '-') {
6264 if (opts->out_fname != NULL)
6266 cpp_fatal (pfile, "Usage: %s [switches] input output", argv[0]);
6269 else if (opts->in_fname != NULL)
6270 opts->out_fname = argv[i];
6272 opts->in_fname = argv[i];
6274 switch (argv[i][1]) {
6277 cpp_fatal (pfile, "Filename missing after `%s' option", argv[i]);
6280 cpp_fatal (pfile, "Directory name missing after `%s' option", argv[i]);
6284 if (!strcmp (argv[i], "-include")
6285 || !strcmp (argv[i], "-imacros")) {
6287 goto missing_filename;
6289 push_pending (pfile, argv[i], argv[i+1]), i++;
6291 if (!strcmp (argv[i], "-iprefix")) {
6293 goto missing_filename;
6295 opts->include_prefix = argv[++i];
6297 if (!strcmp (argv[i], "-ifoutput")) {
6298 opts->output_conditionals = 1;
6300 if (!strcmp (argv[i], "-isystem")) {
6301 struct file_name_list *dirtmp;
6304 goto missing_filename;
6306 dirtmp = (struct file_name_list *)
6307 xmalloc (sizeof (struct file_name_list));
6309 dirtmp->control_macro = 0;
6310 dirtmp->c_system_include_path = 1;
6311 dirtmp->fname = (char *) xmalloc (strlen (argv[i+1]) + 1);
6312 strcpy (dirtmp->fname, argv[++i]);
6313 dirtmp->got_name_map = 0;
6315 if (opts->before_system == 0)
6316 opts->before_system = dirtmp;
6318 opts->last_before_system->next = dirtmp;
6319 opts->last_before_system = dirtmp; /* Tail follows the last one */
6321 /* Add directory to end of path for includes,
6322 with the default prefix at the front of its name. */
6323 if (!strcmp (argv[i], "-iwithprefix")) {
6324 struct file_name_list *dirtmp;
6327 if (opts->include_prefix != 0)
6328 prefix = opts->include_prefix;
6330 prefix = savestring (GCC_INCLUDE_DIR);
6331 /* Remove the `include' from /usr/local/lib/gcc.../include. */
6332 if (!strcmp (prefix + strlen (prefix) - 8, "/include"))
6333 prefix[strlen (prefix) - 7] = 0;
6336 dirtmp = (struct file_name_list *)
6337 xmalloc (sizeof (struct file_name_list));
6338 dirtmp->next = 0; /* New one goes on the end */
6339 dirtmp->control_macro = 0;
6340 dirtmp->c_system_include_path = 0;
6342 goto missing_dirname;
6344 dirtmp->fname = (char *) xmalloc (strlen (argv[i+1])
6345 + strlen (prefix) + 1);
6346 strcpy (dirtmp->fname, prefix);
6347 strcat (dirtmp->fname, argv[++i]);
6348 dirtmp->got_name_map = 0;
6350 if (opts->after_include == 0)
6351 opts->after_include = dirtmp;
6353 opts->last_after_include->next = dirtmp;
6354 opts->last_after_include = dirtmp; /* Tail follows the last one */
6356 /* Add directory to main path for includes,
6357 with the default prefix at the front of its name. */
6358 if (!strcmp (argv[i], "-iwithprefixbefore")) {
6359 struct file_name_list *dirtmp;
6362 if (opts->include_prefix != 0)
6363 prefix = opts->include_prefix;
6365 prefix = savestring (GCC_INCLUDE_DIR);
6366 /* Remove the `include' from /usr/local/lib/gcc.../include. */
6367 if (!strcmp (prefix + strlen (prefix) - 8, "/include"))
6368 prefix[strlen (prefix) - 7] = 0;
6371 dirtmp = (struct file_name_list *)
6372 xmalloc (sizeof (struct file_name_list));
6373 dirtmp->next = 0; /* New one goes on the end */
6374 dirtmp->control_macro = 0;
6375 dirtmp->c_system_include_path = 0;
6377 goto missing_dirname;
6379 dirtmp->fname = (char *) xmalloc (strlen (argv[i+1])
6380 + strlen (prefix) + 1);
6381 strcpy (dirtmp->fname, prefix);
6382 strcat (dirtmp->fname, argv[++i]);
6383 dirtmp->got_name_map = 0;
6385 append_include_chain (pfile, dirtmp, dirtmp);
6387 /* Add directory to end of path for includes. */
6388 if (!strcmp (argv[i], "-idirafter")) {
6389 struct file_name_list *dirtmp;
6391 dirtmp = (struct file_name_list *)
6392 xmalloc (sizeof (struct file_name_list));
6393 dirtmp->next = 0; /* New one goes on the end */
6394 dirtmp->control_macro = 0;
6395 dirtmp->c_system_include_path = 0;
6397 goto missing_dirname;
6399 dirtmp->fname = argv[++i];
6400 dirtmp->got_name_map = 0;
6402 if (opts->after_include == 0)
6403 opts->after_include = dirtmp;
6405 opts->last_after_include->next = dirtmp;
6406 opts->last_after_include = dirtmp; /* Tail follows the last one */
6411 if (opts->out_fname != NULL)
6413 cpp_fatal (pfile, "Output filename specified twice");
6417 goto missing_filename;
6418 opts->out_fname = argv[++i];
6419 if (!strcmp (opts->out_fname, "-"))
6420 opts->out_fname = "";
6424 if (!strcmp (argv[i], "-pedantic"))
6425 CPP_PEDANTIC (pfile) = 1;
6426 else if (!strcmp (argv[i], "-pedantic-errors")) {
6427 CPP_PEDANTIC (pfile) = 1;
6428 opts->pedantic_errors = 1;
6431 else if (!strcmp (argv[i], "-pcp")) {
6432 char *pcp_fname = argv[++i];
6434 ((pcp_fname[0] != '-' || pcp_fname[1] != '\0')
6435 ? fopen (pcp_fname, "w")
6436 : fdopen (dup (fileno (stdout)), "w"));
6437 if (pcp_outfile == 0)
6438 cpp_pfatal_with_name (pfile, pcp_fname);
6445 if (!strcmp (argv[i], "-traditional")) {
6446 opts->traditional = 1;
6447 } else if (!strcmp (argv[i], "-trigraphs")) {
6449 opts->no_trigraphs = 0;
6454 if (! strcmp (argv[i], "-lang-c"))
6455 opts->cplusplus = 0, opts->cplusplus_comments = 1, opts->c89 = 0,
6457 if (! strcmp (argv[i], "-lang-c89"))
6458 opts->cplusplus = 0, opts->cplusplus_comments = 0, opts->c89 = 1,
6460 if (! strcmp (argv[i], "-lang-c++"))
6461 opts->cplusplus = 1, opts->cplusplus_comments = 1, opts->c89 = 0,
6463 if (! strcmp (argv[i], "-lang-objc"))
6464 opts->cplusplus = 0, opts->cplusplus_comments = 1, opts->c89 = 0,
6466 if (! strcmp (argv[i], "-lang-objc++"))
6467 opts->cplusplus = 1, opts->cplusplus_comments = 1, opts->c89 = 0,
6469 if (! strcmp (argv[i], "-lang-asm"))
6471 if (! strcmp (argv[i], "-lint"))
6473 if (! strcmp (argv[i], "-lang-chill"))
6474 opts->objc = 0, opts->cplusplus = 0, opts->chill = 1,
6475 opts->traditional = 1, opts->no_trigraphs = 1;
6479 opts->cplusplus = 1, opts->cplusplus_comments = 1;
6483 opts->inhibit_warnings = 1;
6487 if (!strcmp (argv[i], "-Wtrigraphs"))
6488 opts->warn_trigraphs = 1;
6489 else if (!strcmp (argv[i], "-Wno-trigraphs"))
6490 opts->warn_trigraphs = 0;
6491 else if (!strcmp (argv[i], "-Wcomment"))
6492 opts->warn_comments = 1;
6493 else if (!strcmp (argv[i], "-Wno-comment"))
6494 opts->warn_comments = 0;
6495 else if (!strcmp (argv[i], "-Wcomments"))
6496 opts->warn_comments = 1;
6497 else if (!strcmp (argv[i], "-Wno-comments"))
6498 opts->warn_comments = 0;
6499 else if (!strcmp (argv[i], "-Wtraditional"))
6500 opts->warn_stringify = 1;
6501 else if (!strcmp (argv[i], "-Wno-traditional"))
6502 opts->warn_stringify = 0;
6503 else if (!strcmp (argv[i], "-Wundef"))
6504 opts->warn_undef = 1;
6505 else if (!strcmp (argv[i], "-Wno-undef"))
6506 opts->warn_undef = 0;
6507 else if (!strcmp (argv[i], "-Wimport"))
6508 opts->warn_import = 1;
6509 else if (!strcmp (argv[i], "-Wno-import"))
6510 opts->warn_import = 0;
6511 else if (!strcmp (argv[i], "-Werror"))
6512 opts->warnings_are_errors = 1;
6513 else if (!strcmp (argv[i], "-Wno-error"))
6514 opts->warnings_are_errors = 0;
6515 else if (!strcmp (argv[i], "-Wall"))
6517 opts->warn_trigraphs = 1;
6518 opts->warn_comments = 1;
6523 /* The style of the choices here is a bit mixed.
6524 The chosen scheme is a hybrid of keeping all options in one string
6525 and specifying each option in a separate argument:
6526 -M|-MM|-MD file|-MMD file [-MG]. An alternative is:
6527 -M|-MM|-MD file|-MMD file|-MG|-MMG; or more concisely:
6528 -M[M][G][D file]. This is awkward to handle in specs, and is not
6530 /* ??? -MG must be specified in addition to one of -M or -MM.
6531 This can be relaxed in the future without breaking anything.
6532 The converse isn't true. */
6534 /* -MG isn't valid with -MD or -MMD. This is checked for later. */
6535 if (!strcmp (argv[i], "-MG"))
6537 opts->print_deps_missing_files = 1;
6540 if (!strcmp (argv[i], "-M"))
6541 opts->print_deps = 2;
6542 else if (!strcmp (argv[i], "-MM"))
6543 opts->print_deps = 1;
6544 else if (!strcmp (argv[i], "-MD"))
6545 opts->print_deps = 2;
6546 else if (!strcmp (argv[i], "-MMD"))
6547 opts->print_deps = 1;
6548 /* For -MD and -MMD options, write deps on file named by next arg. */
6549 if (!strcmp (argv[i], "-MD") || !strcmp (argv[i], "-MMD"))
6552 goto missing_filename;
6553 opts->deps_file = argv[++i];
6557 /* For -M and -MM, write deps on standard output
6558 and suppress the usual output. */
6559 opts->no_output = 1;
6565 char *p = argv[i] + 2;
6567 while ((c = *p++) != 0) {
6568 /* Arg to -d specifies what parts of macros to dump */
6571 opts->dump_macros = dump_only;
6572 opts->no_output = 1;
6575 opts->dump_macros = dump_names;
6578 opts->dump_macros = dump_definitions;
6586 if (argv[i][2] == '3')
6587 opts->debug_output = 1;
6591 fprintf (stderr, "GNU CPP version %s", version_string);
6592 #ifdef TARGET_VERSION
6595 fprintf (stderr, "\n");
6600 opts->print_include_names = 1;
6604 if (argv[i][2] != 0)
6605 push_pending (pfile, "-D", argv[i] + 2);
6606 else if (i + 1 == argc)
6608 cpp_fatal (pfile, "Macro name missing after -D option");
6612 i++, push_pending (pfile, "-D", argv[i]);
6619 if (argv[i][2] != 0)
6621 else if (i + 1 == argc)
6623 cpp_fatal (pfile, "Assertion missing after -A option");
6629 if (!strcmp (p, "-")) {
6630 struct cpp_pending **ptr;
6631 /* -A- eliminates all predefined macros and assertions.
6632 Let's include also any that were specified earlier
6633 on the command line. That way we can get rid of any
6634 that were passed automatically in from GCC. */
6636 opts->inhibit_predefs = 1;
6637 for (ptr = &opts->pending; *ptr != NULL; )
6639 struct cpp_pending *pend = *ptr;
6640 if (pend->cmd && pend->cmd[0] == '-'
6641 && (pend->cmd[1] == 'D' || pend->cmd[1] == 'A'))
6650 push_pending (pfile, "-A", p);
6655 case 'U': /* JF #undef something */
6656 if (argv[i][2] != 0)
6657 push_pending (pfile, "-U", argv[i] + 2);
6658 else if (i + 1 == argc)
6660 cpp_fatal (pfile, "Macro name missing after -U option", NULL);
6664 push_pending (pfile, "-U", argv[i+1]), i++;
6668 opts->put_out_comments = 1;
6671 case 'E': /* -E comes from cc -E; ignore it. */
6675 opts->no_line_commands = 1;
6678 case '$': /* Don't include $ in identifiers. */
6679 opts->dollars_in_ident = 0;
6682 case 'I': /* Add directory to path for includes. */
6684 struct file_name_list *dirtmp;
6686 if (! CPP_OPTIONS(pfile)->ignore_srcdir
6687 && !strcmp (argv[i] + 2, "-")) {
6688 CPP_OPTIONS (pfile)->ignore_srcdir = 1;
6689 /* Don't use any preceding -I directories for #include <...>. */
6690 CPP_OPTIONS (pfile)->first_bracket_include = 0;
6693 dirtmp = (struct file_name_list *)
6694 xmalloc (sizeof (struct file_name_list));
6695 dirtmp->next = 0; /* New one goes on the end */
6696 dirtmp->control_macro = 0;
6697 dirtmp->c_system_include_path = 0;
6698 if (argv[i][2] != 0)
6699 dirtmp->fname = argv[i] + 2;
6700 else if (i + 1 == argc)
6701 goto missing_dirname;
6703 dirtmp->fname = argv[++i];
6704 dirtmp->got_name_map = 0;
6705 append_include_chain (pfile, dirtmp, dirtmp);
6711 if (!strcmp (argv[i], "-nostdinc"))
6712 /* -nostdinc causes no default include directories.
6713 You must specify all include-file directories with -I. */
6714 opts->no_standard_includes = 1;
6715 else if (!strcmp (argv[i], "-nostdinc++"))
6716 /* -nostdinc++ causes no default C++-specific include directories. */
6717 opts->no_standard_cplusplus_includes = 1;
6719 else if (!strcmp (argv[i], "-noprecomp"))
6725 /* Sun compiler passes undocumented switch "-undef".
6726 Let's assume it means to inhibit the predefined symbols. */
6727 opts->inhibit_predefs = 1;
6730 case '\0': /* JF handle '-' as file name meaning stdin or stdout */
6731 if (opts->in_fname == NULL) {
6732 opts->in_fname = "";
6734 } else if (opts->out_fname == NULL) {
6735 opts->out_fname = "";
6737 } /* else fall through into error */
6751 struct cpp_options *opts = CPP_OPTIONS (pfile);
6753 if (opts->print_deps)
6755 /* Stream on which to print the dependency information. */
6758 /* Don't actually write the deps file if compilation has failed. */
6759 if (pfile->errors == 0)
6761 char *deps_mode = opts->print_deps_append ? "a" : "w";
6762 if (opts->deps_file == 0)
6763 deps_stream = stdout;
6764 else if ((deps_stream = fopen (opts->deps_file, deps_mode)) == 0)
6765 cpp_pfatal_with_name (pfile, opts->deps_file);
6766 fputs (pfile->deps_buffer, deps_stream);
6767 putc ('\n', deps_stream);
6768 if (opts->deps_file)
6770 if (ferror (deps_stream) || fclose (deps_stream) != 0)
6771 cpp_fatal (pfile, "I/O error on output");
6777 /* Free resources used by PFILE.
6778 This is the cpp_reader 'finalizer' or 'destructor' (in C++ terminology). */
6785 while ( CPP_BUFFER (pfile) != CPP_NULL_BUFFER (pfile))
6786 cpp_pop_buffer (pfile);
6788 if (pfile->token_buffer)
6790 free (pfile->token_buffer);
6791 pfile->token_buffer = NULL;
6794 if (pfile->deps_buffer)
6796 free (pfile->deps_buffer);
6797 pfile->deps_buffer = NULL;
6798 pfile->deps_allocated_size = 0;
6801 while (pfile->if_stack)
6803 IF_STACK_FRAME *temp = pfile->if_stack;
6804 pfile->if_stack = temp->next;
6808 while (pfile->dont_repeat_files)
6810 struct file_name_list *temp = pfile->dont_repeat_files;
6811 pfile->dont_repeat_files = temp->next;
6816 while (pfile->all_include_files)
6818 struct file_name_list *temp = pfile->all_include_files;
6819 pfile->all_include_files = temp->next;
6824 for (i = IMPORT_HASH_SIZE; --i >= 0; )
6826 register struct import_file *imp = pfile->import_hash_table[i];
6829 struct import_file *next = imp->next;
6834 pfile->import_hash_table[i] = 0;
6837 for (i = ASSERTION_HASHSIZE; --i >= 0; )
6839 while (pfile->assertion_hashtab[i])
6840 delete_assertion (pfile->assertion_hashtab[i]);
6843 cpp_hash_cleanup (pfile);
6847 do_assert (pfile, keyword, buf, limit)
6849 struct directive *keyword;
6850 U_CHAR *buf, *limit;
6852 long symstart; /* remember where symbol name starts */
6854 int sym_length; /* and how long it is */
6855 struct arglist *tokens = NULL;
6857 if (CPP_PEDANTIC (pfile) && CPP_OPTIONS (pfile)->done_initializing
6858 && !CPP_BUFFER (pfile)->system_header_p)
6859 cpp_pedwarn (pfile, "ANSI C does not allow `#assert'");
6861 cpp_skip_hspace (pfile);
6862 symstart = CPP_WRITTEN (pfile); /* remember where it starts */
6863 parse_name (pfile, GETC());
6864 sym_length = check_macro_name (pfile, pfile->token_buffer + symstart,
6867 cpp_skip_hspace (pfile);
6868 if (PEEKC() != '(') {
6869 cpp_error (pfile, "missing token-sequence in `#assert'");
6875 tokens = read_token_list (pfile, &error_flag);
6879 cpp_error (pfile, "empty token-sequence in `#assert'");
6882 cpp_skip_hspace (pfile);
6884 if (c != EOF && c != '\n')
6885 cpp_pedwarn (pfile, "junk at end of `#assert'");
6886 skip_rest_of_line (pfile);
6889 /* If this name isn't already an assertion name, make it one.
6890 Error if it was already in use in some other way. */
6893 ASSERTION_HASHNODE *hp;
6894 U_CHAR *symname = pfile->token_buffer + symstart;
6895 int hashcode = hashf (symname, sym_length, ASSERTION_HASHSIZE);
6896 struct tokenlist_list *value
6897 = (struct tokenlist_list *) xmalloc (sizeof (struct tokenlist_list));
6899 hp = assertion_lookup (pfile, symname, sym_length, hashcode);
6901 if (sym_length == 7 && ! strncmp (symname, "defined", sym_length))
6902 cpp_error (pfile, "`defined' redefined as assertion");
6903 hp = assertion_install (pfile, symname, sym_length, hashcode);
6906 /* Add the spec'd token-sequence to the list of such. */
6907 value->tokens = tokens;
6908 value->next = hp->value;
6911 CPP_SET_WRITTEN (pfile, symstart); /* Pop */
6914 CPP_SET_WRITTEN (pfile, symstart); /* Pop */
6915 skip_rest_of_line (pfile);
6920 do_unassert (pfile, keyword, buf, limit)
6922 struct directive *keyword;
6923 U_CHAR *buf, *limit;
6925 long symstart; /* remember where symbol name starts */
6926 int sym_length; /* and how long it is */
6929 struct arglist *tokens = NULL;
6930 int tokens_specified = 0;
6932 if (CPP_PEDANTIC (pfile) && CPP_OPTIONS (pfile)->done_initializing
6933 && !CPP_BUFFER (pfile)->system_header_p)
6934 cpp_pedwarn (pfile, "ANSI C does not allow `#unassert'");
6936 cpp_skip_hspace (pfile);
6938 symstart = CPP_WRITTEN (pfile); /* remember where it starts */
6939 parse_name (pfile, GETC());
6940 sym_length = check_macro_name (pfile, pfile->token_buffer + symstart,
6943 cpp_skip_hspace (pfile);
6944 if (PEEKC() == '(') {
6947 tokens = read_token_list (pfile, &error_flag);
6951 cpp_error (pfile, "empty token list in `#unassert'");
6955 tokens_specified = 1;
6958 cpp_skip_hspace (pfile);
6960 if (c != EOF && c != '\n')
6961 cpp_error (pfile, "junk at end of `#unassert'");
6962 skip_rest_of_line (pfile);
6965 ASSERTION_HASHNODE *hp;
6966 U_CHAR *symname = pfile->token_buffer + symstart;
6967 int hashcode = hashf (symname, sym_length, ASSERTION_HASHSIZE);
6968 struct tokenlist_list *tail, *prev;
6970 hp = assertion_lookup (pfile, symname, sym_length, hashcode);
6974 /* If no token list was specified, then eliminate this assertion
6976 if (! tokens_specified)
6977 delete_assertion (hp);
6979 /* If a list of tokens was given, then delete any matching list. */
6984 struct tokenlist_list *next = tail->next;
6985 if (compare_token_lists (tail->tokens, tokens)) {
6989 hp->value = tail->next;
6990 free_token_list (tail->tokens);
7000 CPP_SET_WRITTEN (pfile, symstart); /* Pop */
7003 CPP_SET_WRITTEN (pfile, symstart); /* Pop */
7004 skip_rest_of_line (pfile);
7008 /* Test whether there is an assertion named NAME
7009 and optionally whether it has an asserted token list TOKENS.
7010 NAME is not null terminated; its length is SYM_LENGTH.
7011 If TOKENS_SPECIFIED is 0, then don't check for any token list. */
7014 check_assertion (pfile, name, sym_length, tokens_specified, tokens)
7018 int tokens_specified;
7019 struct arglist *tokens;
7021 ASSERTION_HASHNODE *hp;
7022 int hashcode = hashf (name, sym_length, ASSERTION_HASHSIZE);
7024 if (CPP_PEDANTIC (pfile) && !CPP_BUFFER (pfile)->system_header_p)
7025 cpp_pedwarn (pfile, "ANSI C does not allow testing assertions");
7027 hp = assertion_lookup (pfile, name, sym_length, hashcode);
7029 /* It is not an assertion; just return false. */
7032 /* If no token list was specified, then value is 1. */
7033 if (! tokens_specified)
7037 struct tokenlist_list *tail;
7041 /* If a list of tokens was given,
7042 then succeed if the assertion records a matching list. */
7045 if (compare_token_lists (tail->tokens, tokens))
7050 /* Fail if the assertion has no matching list. */
7055 /* Compare two lists of tokens for equality including order of tokens. */
7058 compare_token_lists (l1, l2)
7059 struct arglist *l1, *l2;
7062 if (l1->length != l2->length)
7064 if (strncmp (l1->name, l2->name, l1->length))
7070 /* Succeed if both lists end at the same time. */
7075 reverse_token_list (tokens)
7076 struct arglist *tokens;
7078 register struct arglist *prev = 0, *this, *next;
7079 for (this = tokens; this; this = next)
7088 /* Read a space-separated list of tokens ending in a close parenthesis.
7089 Return a list of strings, in the order they were written.
7090 (In case of error, return 0 and store -1 in *ERROR_FLAG.) */
7092 static struct arglist *
7093 read_token_list (pfile, error_flag)
7097 struct arglist *token_ptrs = 0;
7102 FORWARD (1); /* Skip '(' */
7104 /* Loop over the assertion value tokens. */
7107 struct arglist *temp;
7108 long name_written = CPP_WRITTEN (pfile);
7109 int eofp = 0; int c;
7111 cpp_skip_hspace (pfile);
7115 /* Find the end of the token. */
7118 CPP_PUTC (pfile, c);
7126 CPP_PUTC (pfile, c);
7128 else if (c == '"' || c == '\'')
7131 cpp_get_token (pfile);
7137 while (c != EOF && ! is_space[c] && c != '(' && c != ')'
7138 && c != '"' && c != '\'')
7140 CPP_PUTC (pfile, c);
7143 if (c != EOF) FORWARD(-1);
7146 length = CPP_WRITTEN (pfile) - name_written;
7147 temp = (struct arglist *)
7148 xmalloc (sizeof (struct arglist) + length + 1);
7149 temp->name = (U_CHAR *) (temp + 1);
7150 bcopy ((char *) (pfile->token_buffer + name_written),
7151 (char *) temp->name, length);
7152 temp->name[length] = 0;
7153 temp->next = token_ptrs;
7155 temp->length = length;
7157 CPP_ADJUST_WRITTEN (pfile, -length); /* pop */
7159 if (c == EOF || c == '\n')
7162 "unterminated token sequence following `#' operator");
7167 /* We accumulated the names in reverse order.
7168 Now reverse them to get the proper order. */
7169 return reverse_token_list (token_ptrs);
7173 free_token_list (tokens)
7174 struct arglist *tokens;
7177 struct arglist *next = tokens->next;
7178 free (tokens->name);
7184 /* Get the file-mode and data size of the file open on FD
7185 and store them in *MODE_POINTER and *SIZE_POINTER. */
7188 file_size_and_mode (fd, mode_pointer, size_pointer)
7191 long int *size_pointer;
7195 if (fstat (fd, &sbuf) < 0) return (-1);
7196 if (mode_pointer) *mode_pointer = sbuf.st_mode;
7197 if (size_pointer) *size_pointer = sbuf.st_size;
7201 /* Read LEN bytes at PTR from descriptor DESC, for file FILENAME,
7202 retrying if necessary. Return a negative value if an error occurs,
7203 otherwise return the actual number of bytes read,
7204 which must be LEN unless end-of-file was reached. */
7207 safe_read (desc, ptr, len)
7214 int nchars = read (desc, ptr, left);
7232 xcalloc (number, size)
7233 unsigned number, size;
7235 register unsigned total = number * size;
7236 register char *ptr = (char *) xmalloc (total);
7245 unsigned size = strlen (input);
7246 char *output = xmalloc (size + 1);
7247 strcpy (output, input);
7251 /* Initialize PMARK to remember the current position of PFILE. */
7254 parse_set_mark (pmark, pfile)
7255 struct parse_marker *pmark;
7258 cpp_buffer *pbuf = CPP_BUFFER (pfile);
7259 pmark->next = pbuf->marks;
7260 pbuf->marks = pmark;
7262 pmark->position = pbuf->cur - pbuf->buf;
7265 /* Cleanup PMARK - we no longer need it. */
7268 parse_clear_mark (pmark)
7269 struct parse_marker *pmark;
7271 struct parse_marker **pp = &pmark->buf->marks;
7272 for (; ; pp = &(*pp)->next) {
7273 if (*pp == NULL) abort ();
7274 if (*pp == pmark) break;
7279 /* Backup the current position of PFILE to that saved in PMARK. */
7282 parse_goto_mark (pmark, pfile)
7283 struct parse_marker *pmark;
7286 cpp_buffer *pbuf = CPP_BUFFER (pfile);
7287 if (pbuf != pmark->buf)
7288 cpp_fatal (pfile, "internal error %s", "parse_goto_mark");
7289 pbuf->cur = pbuf->buf + pmark->position;
7292 /* Reset PMARK to point to the current position of PFILE. (Same
7293 as parse_clear_mark (PMARK), parse_set_mark (PMARK, PFILE) but faster. */
7296 parse_move_mark (pmark, pfile)
7297 struct parse_marker *pmark;
7300 cpp_buffer *pbuf = CPP_BUFFER (pfile);
7301 if (pbuf != pmark->buf)
7302 cpp_fatal (pfile, "internal error %s", "parse_move_mark");
7303 pmark->position = pbuf->cur - pbuf->buf;
7307 cpp_read_check_assertion (pfile)
7310 int name_start = CPP_WRITTEN (pfile);
7311 int name_length, name_written;
7313 FORWARD (1); /* Skip '#' */
7314 cpp_skip_hspace (pfile);
7315 parse_name (pfile, GETC ());
7316 name_written = CPP_WRITTEN (pfile);
7317 name_length = name_written - name_start;
7318 cpp_skip_hspace (pfile);
7319 if (CPP_BUF_PEEK (CPP_BUFFER (pfile)) == '(')
7322 struct arglist *token_ptrs = read_token_list (pfile, &error_flag);
7323 result = check_assertion (pfile,
7324 pfile->token_buffer + name_start, name_length,
7328 result = check_assertion (pfile,
7329 pfile->token_buffer + name_start, name_length,
7331 CPP_ADJUST_WRITTEN (pfile, - name_length); /* pop */
7336 cpp_print_file_and_line (pfile)
7339 cpp_buffer *ip = cpp_file_buffer (pfile);
7344 cpp_buf_line_and_col (ip, &line, &col);
7345 cpp_file_line_for_message (pfile, ip->nominal_fname,
7346 line, pfile->show_column ? col : -1);
7351 cpp_error (pfile, msg, arg1, arg2, arg3)
7354 char *arg1, *arg2, *arg3;
7356 cpp_print_containing_files (pfile);
7357 cpp_print_file_and_line (pfile);
7358 cpp_message (pfile, 1, msg, arg1, arg2, arg3);
7361 /* Print error message but don't count it. */
7364 cpp_warning (pfile, msg, arg1, arg2, arg3)
7367 char *arg1, *arg2, *arg3;
7369 if (CPP_OPTIONS (pfile)->inhibit_warnings)
7372 if (CPP_OPTIONS (pfile)->warnings_are_errors)
7375 cpp_print_containing_files (pfile);
7376 cpp_print_file_and_line (pfile);
7377 cpp_message (pfile, 0, msg, arg1, arg2, arg3);
7380 /* Print an error message and maybe count it. */
7383 cpp_pedwarn (pfile, msg, arg1, arg2, arg3)
7386 char *arg1, *arg2, *arg3;
7388 if (CPP_OPTIONS (pfile)->pedantic_errors)
7389 cpp_error (pfile, msg, arg1, arg2, arg3);
7391 cpp_warning (pfile, msg, arg1, arg2, arg3);
7395 cpp_error_with_line (pfile, line, column, msg, arg1, arg2, arg3)
7399 char *arg1, *arg2, *arg3;
7402 cpp_buffer *ip = cpp_file_buffer (pfile);
7404 cpp_print_containing_files (pfile);
7407 cpp_file_line_for_message (pfile, ip->nominal_fname, line, column);
7409 cpp_message (pfile, 1, msg, arg1, arg2, arg3);
7413 cpp_warning_with_line (pfile, line, column, msg, arg1, arg2, arg3)
7417 char *arg1, *arg2, *arg3;
7422 if (CPP_OPTIONS (pfile)->inhibit_warnings)
7425 if (CPP_OPTIONS (pfile)->warnings_are_errors)
7428 cpp_print_containing_files (pfile);
7430 ip = cpp_file_buffer (pfile);
7433 cpp_file_line_for_message (pfile, ip->nominal_fname, line, column);
7435 cpp_message (pfile, 0, msg, arg1, arg2, arg3);
7439 cpp_pedwarn_with_line (pfile, line, column, msg, arg1, arg2, arg3)
7443 char *arg1, *arg2, *arg3;
7445 if (CPP_OPTIONS (pfile)->pedantic_errors)
7446 cpp_error_with_line (pfile, column, line, msg, arg1, arg2, arg3);
7448 cpp_warning_with_line (pfile, line, column, msg, arg1, arg2, arg3);
7451 /* Report a warning (or an error if pedantic_errors)
7452 giving specified file name and line number, not current. */
7455 cpp_pedwarn_with_file_and_line (pfile, file, line, msg, arg1, arg2, arg3)
7460 char *arg1, *arg2, *arg3;
7462 if (!CPP_OPTIONS (pfile)->pedantic_errors
7463 && CPP_OPTIONS (pfile)->inhibit_warnings)
7466 cpp_file_line_for_message (pfile, file, line, -1);
7467 cpp_message (pfile, CPP_OPTIONS (pfile)->pedantic_errors,
7468 msg, arg1, arg2, arg3);
7471 /* This defines "errno" properly for VMS, and gives us EACCES. */
7478 #ifndef HAVE_STRERROR
7479 extern int sys_nerr;
7481 extern const char *const sys_errlist[];
7483 extern char *sys_errlist[];
7485 #else /* HAVE_STRERROR */
7489 char *strerror (int,...);
7492 /* my_strerror - return the descriptive text associated with an
7496 my_strerror (errnum)
7502 #ifndef HAVE_STRERROR
7503 result = (char *) ((errnum < sys_nerr) ? sys_errlist[errnum] : 0);
7505 result = strerror (errnum);
7508 /* VAXCRTL's strerror() takes an optional second argument, which only
7509 matters when the first argument is EVMSERR. However, it's simplest
7510 just to pass it unconditionally. `vaxc$errno' is declared in
7511 <errno.h>, and maintained by the library in parallel with `errno'.
7512 We assume that caller's `errnum' either matches the last setting of
7513 `errno' by the library or else does not have the value `EVMSERR'. */
7515 result = strerror (errnum, vaxc$errno);
7519 result = "undocumented I/O error";
7524 /* Error including a message from `errno'. */
7527 cpp_error_from_errno (pfile, name)
7532 cpp_buffer *ip = cpp_file_buffer (pfile);
7534 cpp_print_containing_files (pfile);
7537 cpp_file_line_for_message (pfile, ip->nominal_fname, ip->lineno, -1);
7539 cpp_message (pfile, 1, "%s: %s", name, my_strerror (errno));
7543 cpp_perror_with_name (pfile, name)
7547 cpp_message (pfile, 1, "%s: %s: %s", progname, name, my_strerror (errno));
7551 * No pre-compiled header file support.
7553 * Possibly different enum token codes for each C/C++ token.
7555 * Should clean up remaining directives to that do_XXX functions
7556 * only take two arguments and all have command_reads_line.
7558 * Find and cleanup remaining uses of static variables,
7560 * Support for trigraphs.
7562 * Support -dM flag (dump_all_macros).
7564 * Support for_lint flag.