1 /* C Compatible Compiler Preprocessor (CCCP)
2 Copyright (C) 1986, 87, 89, 92, 93, 1994 Free Software Foundation, Inc.
3 Written by Paul Rubin, June 1986
4 Adapted to ANSI C, Richard Stallman, Jan 1987
6 This program is free software; you can redistribute it and/or modify it
7 under the terms of the GNU General Public License as published by the
8 Free Software Foundation; either version 2, or (at your option) any
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with this program; if not, write to the Free Software
18 Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
20 In other words, you are welcome to use, share and improve this program.
21 You are forbidden to forbid anyone else to use, share and improve
22 what you give them. Help stamp out software-hoarding! */
24 typedef unsigned char U_CHAR;
28 #include "../src/config.h"
36 /* The macro EMACS is defined when cpp is distributed as part of Emacs,
37 for the sake of machines with limited C compilers. */
40 #endif /* not EMACS */
42 #ifndef STANDARD_INCLUDE_DIR
43 #define STANDARD_INCLUDE_DIR "/usr/include"
46 #ifndef LOCAL_INCLUDE_DIR
47 #define LOCAL_INCLUDE_DIR "/usr/local/include"
50 #if 0 /* We can't get ptrdiff_t, so I arranged not to need PTR_INT_TYPE. */
52 #define PTR_INT_TYPE ptrdiff_t
54 #define PTR_INT_TYPE long
64 /* By default, colon separates directories in a path. */
65 #ifndef PATH_SEPARATOR
66 #define PATH_SEPARATOR ':'
69 /* In case config.h defines these. */
74 #include <sys/types.h>
82 #include <sys/time.h> /* for __DATE__ and __TIME__ */
83 #include <sys/resource.h>
90 /* This defines "errno" properly for VMS, and gives us EACCES. */
93 /* VMS-specific definitions */
97 #define O_RDONLY 0 /* Open arg for Read/Only */
98 #define O_WRONLY 1 /* Open arg for Write/Only */
99 #define read(fd,buf,size) VMS_read (fd,buf,size)
100 #define write(fd,buf,size) VMS_write (fd,buf,size)
101 #define open(fname,mode,prot) VMS_open (fname,mode,prot)
102 #define fopen(fname,mode) VMS_fopen (fname,mode)
103 #define freopen(fname,mode,ofile) VMS_freopen (fname,mode,ofile)
104 #define strncat(dst,src,cnt) VMS_strncat (dst,src,cnt)
105 static char * VMS_strncat ();
106 static int VMS_read ();
107 static int VMS_write ();
108 static int VMS_open ();
109 static FILE * VMS_fopen ();
110 static FILE * VMS_freopen ();
111 static void hack_vms_include_specification ();
112 typedef struct { unsigned :16, :16, :16; } vms_ino_t;
113 #define ino_t vms_ino_t
114 #define INCLUDE_LEN_FUDGE 10 /* leave room for VMS syntax conversion */
116 #define BSTRING /* VMS/GCC supplies the bstring routines */
117 #endif /* __GNUC__ */
120 extern char *index ();
121 extern char *rindex ();
129 #define MIN(X,Y) ((X) < (Y) ? (X) : (Y))
130 #define MAX(X,Y) ((X) > (Y) ? (X) : (Y))
132 /* Find the largest host integer type and set its size and type. */
134 #ifndef HOST_BITS_PER_WIDE_INT
136 #if HOST_BITS_PER_LONG > HOST_BITS_PER_INT
137 #define HOST_BITS_PER_WIDE_INT HOST_BITS_PER_LONG
138 #define HOST_WIDE_INT long
140 #define HOST_BITS_PER_WIDE_INT HOST_BITS_PER_INT
141 #define HOST_WIDE_INT int
147 #define S_ISREG(m) (((m) & S_IFMT) == S_IFREG)
151 #define S_ISDIR(m) (((m) & S_IFMT) == S_IFDIR)
154 /* Define a generic NULL if one hasn't already been defined. */
161 #if defined (USE_PROTOTYPES) ? USE_PROTOTYPES : defined (__STDC__)
162 #define GENERIC_PTR void *
164 #define GENERIC_PTR char *
169 #define NULL_PTR ((GENERIC_PTR)0)
172 #ifndef INCLUDE_LEN_FUDGE
173 #define INCLUDE_LEN_FUDGE 0
176 /* Forward declarations. */
182 /* External declarations. */
184 extern char *getenv ();
185 extern FILE *fdopen ();
186 extern char *version_string;
187 extern struct tm *localtime ();
189 #ifndef HAVE_STRERROR
191 #if defined(bsd4_4) || defined(__NetBSD__)
192 extern const char *const sys_errlist[];
194 extern char *sys_errlist[];
196 #else /* HAVE_STERRROR */
200 char *strerror (int,...);
202 extern int parse_escape ();
203 extern HOST_WIDE_INT parse_c_expression ();
209 /* Forward declarations. */
216 #if defined(USG) || defined(VMS)
224 /* These functions are declared to return int instead of void since they
225 are going to be placed in a table and some old compilers have trouble with
226 pointers to functions returning void. */
228 static int do_define ();
229 static int do_line ();
230 static int do_include ();
231 static int do_undef ();
232 static int do_error ();
233 static int do_pragma ();
234 static int do_ident ();
236 static int do_xifdef ();
237 static int do_else ();
238 static int do_elif ();
239 static int do_endif ();
240 static int do_sccs ();
241 static int do_once ();
242 static int do_assert ();
243 static int do_unassert ();
244 static int do_warning ();
246 static void add_import ();
247 static void append_include_chain ();
248 static void deps_output ();
249 static void make_undef ();
250 static void make_definition ();
251 static void make_assertion ();
252 static void path_include ();
253 static void initialize_builtins ();
254 static void initialize_char_syntax ();
255 static void dump_arg_n ();
256 static void dump_defn_1 ();
257 static void delete_macro ();
258 static void trigraph_pcp ();
259 static void rescan ();
260 static void finclude ();
261 static void validate_else ();
262 static int comp_def_part ();
263 static void error_from_errno ();
264 static void error_with_line ();
266 void pedwarn_with_line ();
267 static void pedwarn_with_file_and_line ();
268 static void fatal ();
270 static void pfatal_with_name ();
271 static void perror_with_name ();
272 static void pipe_closed ();
273 static void print_containing_files ();
274 static int lookup_import ();
275 static int redundant_include_p ();
276 static is_system_include ();
277 static struct file_name_map *read_name_map ();
278 static char *read_filename_string ();
279 static int open_include_file ();
280 static int check_preconditions ();
281 static void pcfinclude ();
282 static void pcstring_used ();
283 static void write_output ();
284 static int check_macro_name ();
285 static int compare_defs ();
286 static int compare_token_lists ();
287 static HOST_WIDE_INT eval_if_expression ();
288 static int discard_comments ();
289 static int change_newlines ();
290 static int line_for_error ();
292 static int file_size_and_mode ();
294 static struct arglist *read_token_list ();
295 static void free_token_list ();
297 static struct hashnode *install ();
298 struct hashnode *lookup ();
300 static struct assertion_hashnode *assertion_install ();
301 static struct assertion_hashnode *assertion_lookup ();
303 static char *xrealloc ();
304 static char *xcalloc ();
305 static char *savestring ();
307 static void delete_assertion ();
308 static void macroexpand ();
309 static void dump_all_macros ();
310 static void conditional_skip ();
311 static void skip_if_group ();
312 static void output_line_command ();
314 /* Last arg to output_line_command. */
315 enum file_change_code {same_file, enter_file, leave_file};
317 static int grow_outbuf ();
318 static int handle_directive ();
319 static void memory_full ();
321 static U_CHAR *macarg1 ();
322 static char *macarg ();
324 static U_CHAR *skip_to_end_of_comment ();
325 static U_CHAR *skip_quoted_string ();
326 static U_CHAR *skip_paren_group ();
327 static char *quote_string ();
329 static char *check_precompiled ();
330 /* static struct macrodef create_definition (); [moved below] */
331 static void dump_single_macro ();
332 static void output_dots ();
334 #ifndef FAILURE_EXIT_CODE
335 #define FAILURE_EXIT_CODE 33 /* gnu cc command understands this */
338 #ifndef SUCCESS_EXIT_CODE
339 #define SUCCESS_EXIT_CODE 0 /* 0 means success on Unix. */
342 /* Name under which this program was invoked. */
344 static char *progname;
346 /* Nonzero means use extra default include directories for C++. */
348 static int cplusplus;
350 /* Nonzero means handle cplusplus style comments */
352 static int cplusplus_comments;
354 /* Nonzero means handle #import, for objective C. */
358 /* Nonzero means this is an assembly file, and allow
359 unknown directives, which could be comments. */
363 /* Current maximum length of directory names in the search path
364 for include files. (Altered as we get more of them.) */
366 static int max_include_len;
368 /* Nonzero means turn NOTREACHED into #pragma NOTREACHED etc */
370 static int for_lint = 0;
372 /* Nonzero means copy comments into the output file. */
374 static int put_out_comments = 0;
376 /* Nonzero means don't process the ANSI trigraph sequences. */
378 static int no_trigraphs = 0;
380 /* Nonzero means print the names of included files rather than
381 the preprocessed output. 1 means just the #include "...",
382 2 means #include <...> as well. */
384 static int print_deps = 0;
386 /* Nonzero if missing .h files in -M output are assumed to be generated
387 files and not errors. */
389 static int print_deps_missing_files = 0;
391 /* Nonzero means print names of header files (-H). */
393 static int print_include_names = 0;
395 /* Nonzero means don't output line number information. */
397 static int no_line_commands;
399 /* Nonzero means output the text in failing conditionals,
400 inside #failed ... #endfailed. */
402 static int output_conditionals;
404 /* dump_only means inhibit output of the preprocessed text
405 and instead output the definitions of all user-defined
406 macros in a form suitable for use as input to cccp.
407 dump_names means pass #define and the macro name through to output.
408 dump_definitions means pass the whole definition (plus #define) through
411 static enum {dump_none, dump_only, dump_names, dump_definitions}
412 dump_macros = dump_none;
414 /* Nonzero means pass all #define and #undef directives which we actually
415 process through to the output stream. This feature is used primarily
416 to allow cc1 to record the #defines and #undefs for the sake of
417 debuggers which understand about preprocessor macros, but it may
418 also be useful with -E to figure out how symbols are defined, and
419 where they are defined. */
420 static int debug_output = 0;
422 /* Nonzero indicates special processing used by the pcp program. The
423 special effects of this mode are:
425 Inhibit all macro expansion, except those inside #if directives.
427 Process #define directives normally, and output their contents
430 Output preconditions to pcp_outfile indicating all the relevant
431 preconditions for use of this file in a later cpp run.
433 static FILE *pcp_outfile;
435 /* Nonzero means we are inside an IF during a -pcp run. In this mode
436 macro expansion is done, and preconditions are output for all macro
437 uses requiring them. */
438 static int pcp_inside_if;
440 /* Nonzero means never to include precompiled files.
441 This is 1 since there's no way now to make precompiled files,
442 so it's not worth testing for them. */
443 static int no_precomp = 1;
445 /* Nonzero means give all the error messages the ANSI standard requires. */
449 /* Nonzero means try to make failure to fit ANSI C an error. */
451 static int pedantic_errors;
453 /* Nonzero means don't print warning messages. -w. */
455 static int inhibit_warnings = 0;
457 /* Nonzero means warn if slash-star appears in a comment. */
459 static int warn_comments;
461 /* Nonzero means warn if a macro argument is (or would be)
462 stringified with -traditional. */
464 static int warn_stringify;
466 /* Nonzero means warn if there are any trigraphs. */
468 static int warn_trigraphs;
470 /* Nonzero means warn if #import is used. */
472 static int warn_import = 1;
474 /* Nonzero means turn warnings into errors. */
476 static int warnings_are_errors;
478 /* Nonzero means try to imitate old fashioned non-ANSI preprocessor. */
482 /* Nonzero causes output not to be done,
483 but directives such as #define that have side effects
486 static int no_output;
488 /* Nonzero means this file was included with a -imacros or -include
489 command line and should not be recorded as an include file. */
491 static int no_record_file;
493 /* Nonzero means that we have finished processing the command line options.
494 This flag is used to decide whether or not to issue certain errors
497 static int done_initializing = 0;
499 /* Line where a newline was first seen in a string constant. */
501 static int multiline_string_line = 0;
503 /* I/O buffer structure.
504 The `fname' field is nonzero for source files and #include files
505 and for the dummy text used for -D and -U.
506 It is zero for rescanning results of macro expansion
507 and for expanding macro arguments. */
508 #define INPUT_STACK_MAX 400
509 static struct file_buf {
511 /* Filename specified with #line command. */
513 /* Record where in the search path this file was found.
514 For #include_next. */
515 struct file_name_list *dir;
520 /* Macro that this level is the expansion of.
521 Included so that we can reenable the macro
522 at the end of this level. */
523 struct hashnode *macro;
524 /* Value of if_stack at start of this file.
525 Used to prohibit unmatched #endif (etc) in an include file. */
526 struct if_stack *if_stack;
527 /* Object to be freed at end of input at this level. */
529 /* True if this is a header file included using <FILENAME>. */
530 char system_header_p;
531 } instack[INPUT_STACK_MAX];
533 static int last_error_tick; /* Incremented each time we print it. */
534 static int input_file_stack_tick; /* Incremented when the status changes. */
536 /* Current nesting level of input sources.
537 `instack[indepth]' is the level currently being read. */
538 static int indepth = -1;
539 #define CHECK_DEPTH(code) \
540 if (indepth >= (INPUT_STACK_MAX - 1)) \
542 error_with_line (line_for_error (instack[indepth].lineno), \
543 "macro or `#include' recursion too deep"); \
547 /* Current depth in #include directives that use <...>. */
548 static int system_include_depth = 0;
550 typedef struct file_buf FILE_BUF;
552 /* The output buffer. Its LENGTH field is the amount of room allocated
553 for the buffer, not the number of chars actually present. To get
554 that, subtract outbuf.buf from outbuf.bufp. */
556 #define OUTBUF_SIZE 10 /* initial size of output buffer */
557 static FILE_BUF outbuf;
559 /* Grow output buffer OBUF points at
560 so it can hold at least NEEDED more chars. */
562 #define check_expand(OBUF, NEEDED) \
563 (((OBUF)->length - ((OBUF)->bufp - (OBUF)->buf) <= (NEEDED)) \
564 ? grow_outbuf ((OBUF), (NEEDED)) : 0)
566 struct file_name_list
568 struct file_name_list *next;
570 /* If the following is nonzero, it is a macro name.
571 Don't include the file again if that macro is defined. */
572 U_CHAR *control_macro;
573 /* If the following is nonzero, it is a C-language system include
575 int c_system_include_path;
576 /* Mapping of file names for this directory. */
577 struct file_name_map *name_map;
578 /* Non-zero if name_map is valid. */
582 /* #include "file" looks in source file dir, then stack. */
583 /* #include <file> just looks in the stack. */
584 /* -I directories are added to the end, then the defaults are added. */
586 static struct default_include {
587 char *fname; /* The name of the directory. */
588 int cplusplus; /* Only look here if we're compiling C++. */
589 int cxx_aware; /* Includes in this directory don't need to
590 be wrapped in extern "C" when compiling
592 } include_defaults_array[]
593 #ifdef INCLUDE_DEFAULTS
597 /* Pick up GNU C++ specific include files. */
598 { GPLUSPLUS_INCLUDE_DIR, 1, 1 },
600 /* This is the dir for fixincludes. Put it just before
601 the files that we fix. */
602 { GCC_INCLUDE_DIR, 0, 0 },
603 /* For cross-compilation, this dir name is generated
604 automatically in Makefile.in. */
605 { CROSS_INCLUDE_DIR, 0, 0 },
606 /* This is another place that the target system's headers might be. */
607 { TOOL_INCLUDE_DIR, 0, 1 },
608 #else /* not CROSS_COMPILE */
609 /* This should be /usr/local/include and should come before
610 the fixincludes-fixed header files. */
611 { LOCAL_INCLUDE_DIR, 0, 1 },
612 /* This is here ahead of GCC_INCLUDE_DIR because assert.h goes here.
613 Likewise, behind LOCAL_INCLUDE_DIR, where glibc puts its assert.h. */
614 { TOOL_INCLUDE_DIR, 0, 1 },
615 /* This is the dir for fixincludes. Put it just before
616 the files that we fix. */
617 { GCC_INCLUDE_DIR, 0, 0 },
618 /* Some systems have an extra dir of include files. */
619 #ifdef SYSTEM_INCLUDE_DIR
620 { SYSTEM_INCLUDE_DIR, 0, 0 },
622 { STANDARD_INCLUDE_DIR, 0, 0 },
623 #endif /* not CROSS_COMPILE */
626 #endif /* no INCLUDE_DEFAULTS */
628 /* The code looks at the defaults through this pointer, rather than through
629 the constant structure above. This pointer gets changed if an environment
630 variable specifies other defaults. */
631 static struct default_include *include_defaults = include_defaults_array;
633 static struct file_name_list *include = 0; /* First dir to search */
634 /* First dir to search for <file> */
635 /* This is the first element to use for #include <...>.
636 If it is 0, use the entire chain for such includes. */
637 static struct file_name_list *first_bracket_include = 0;
638 /* This is the first element in the chain that corresponds to
639 a directory of system header files. */
640 static struct file_name_list *first_system_include = 0;
641 static struct file_name_list *last_include = 0; /* Last in chain */
643 /* Chain of include directories to put at the end of the other chain. */
644 static struct file_name_list *after_include = 0;
645 static struct file_name_list *last_after_include = 0; /* Last in chain */
647 /* Chain to put at the start of the system include files. */
648 static struct file_name_list *before_system = 0;
649 static struct file_name_list *last_before_system = 0; /* Last in chain */
651 /* List of included files that contained #pragma once. */
652 static struct file_name_list *dont_repeat_files = 0;
654 /* List of other included files.
655 If ->control_macro if nonzero, the file had a #ifndef
656 around the entire contents, and ->control_macro gives the macro name. */
657 static struct file_name_list *all_include_files = 0;
659 /* Directory prefix that should replace `/usr' in the standard
660 include file directories. */
661 static char *include_prefix;
663 /* Global list of strings read in from precompiled files. This list
664 is kept in the order the strings are read in, with new strings being
665 added at the end through stringlist_tailp. We use this list to output
666 the strings at the end of the run.
668 static STRINGDEF *stringlist;
669 static STRINGDEF **stringlist_tailp = &stringlist;
672 /* Structure returned by create_definition */
673 typedef struct macrodef MACRODEF;
676 struct definition *defn;
681 static struct macrodef create_definition ();
684 /* Structure allocated for every #define. For a simple replacement
687 nargs = -1, the `pattern' list is null, and the expansion is just
688 the replacement text. Nargs = 0 means a functionlike macro with no args,
690 #define getchar() getc (stdin) .
691 When there are args, the expansion is the replacement text with the
692 args squashed out, and the reflist is a list describing how to
693 build the output from the input: e.g., "3 chars, then the 1st arg,
694 then 9 chars, then the 3rd arg, then 0 chars, then the 2nd arg".
695 The chars here come from the expansion. Whatever is left of the
696 expansion after the last arg-occurrence is copied after that arg.
697 Note that the reflist can be arbitrarily long---
698 its length depends on the number of times the arguments appear in
699 the replacement text, not how many args there are. Example:
700 #define f(x) x+x+x+x+x+x+x would have replacement text "++++++" and
702 { (0, 1), (1, 1), (1, 1), ..., (1, 1), NULL }
703 where (x, y) means (nchars, argno). */
705 typedef struct definition DEFINITION;
708 int length; /* length of expansion string */
709 int predefined; /* True if the macro was builtin or */
710 /* came from the command line */
712 int line; /* Line number of definition */
713 char *file; /* File of definition */
714 char rest_args; /* Nonzero if last arg. absorbs the rest */
716 struct reflist *next;
717 char stringify; /* nonzero if this arg was preceded by a
719 char raw_before; /* Nonzero if a ## operator before arg. */
720 char raw_after; /* Nonzero if a ## operator after arg. */
721 char rest_args; /* Nonzero if this arg. absorbs the rest */
722 int nchars; /* Number of literal chars to copy before
723 this arg occurrence. */
724 int argno; /* Number of arg to substitute (origin-0) */
727 /* Names of macro args, concatenated in reverse order
728 with comma-space between them.
729 The only use of this is that we warn on redefinition
730 if this differs between the old and new definitions. */
735 /* different kinds of things that can appear in the value field
736 of a hash node. Actually, this may be useless now. */
745 * special extension string that can be added to the last macro argument to
746 * allow it to absorb the "rest" of the arguments when expanded. Ex:
747 * #define wow(a, b...) process (b, a, b)
748 * { wow (1, 2, 3); } -> { process (2, 3, 1, 2, 3); }
749 * { wow (one, two); } -> { process (two, one, two); }
750 * if this "rest_arg" is used with the concat token '##' and if it is not
751 * supplied then the token attached to with ## will not be outputted. Ex:
752 * #define wow (a, b...) process (b ## , a, ## b)
753 * { wow (1, 2); } -> { process (2, 1, 2); }
754 * { wow (one); } -> { process (one); {
756 static char rest_extension[] = "...";
757 #define REST_EXTENSION_LENGTH (sizeof (rest_extension) - 1)
759 /* The structure of a node in the hash table. The hash table
760 has entries for all tokens defined by #define commands (type T_MACRO),
761 plus some special tokens like __LINE__ (these each have their own
762 type, and the appropriate code is run when that type of node is seen.
763 It does not contain control words like "#define", which are recognized
764 by a separate piece of code. */
766 /* different flavors of hash nodes --- also used in keyword table */
768 T_DEFINE = 1, /* the `#define' keyword */
769 T_INCLUDE, /* the `#include' keyword */
770 T_INCLUDE_NEXT, /* the `#include_next' keyword */
771 T_IMPORT, /* the `#import' keyword */
772 T_IFDEF, /* the `#ifdef' keyword */
773 T_IFNDEF, /* the `#ifndef' keyword */
774 T_IF, /* the `#if' keyword */
775 T_ELSE, /* `#else' */
776 T_PRAGMA, /* `#pragma' */
777 T_ELIF, /* `#elif' */
778 T_UNDEF, /* `#undef' */
779 T_LINE, /* `#line' */
780 T_ERROR, /* `#error' */
781 T_WARNING, /* `#warning' */
782 T_ENDIF, /* `#endif' */
783 T_SCCS, /* `#sccs', used on system V. */
784 T_IDENT, /* `#ident', used on system V. */
785 T_ASSERT, /* `#assert', taken from system V. */
786 T_UNASSERT, /* `#unassert', taken from system V. */
787 T_SPECLINE, /* special symbol `__LINE__' */
788 T_DATE, /* `__DATE__' */
789 T_FILE, /* `__FILE__' */
790 T_BASE_FILE, /* `__BASE_FILE__' */
791 T_INCLUDE_LEVEL, /* `__INCLUDE_LEVEL__' */
792 T_VERSION, /* `__VERSION__' */
793 T_SIZE_TYPE, /* `__SIZE_TYPE__' */
794 T_PTRDIFF_TYPE, /* `__PTRDIFF_TYPE__' */
795 T_WCHAR_TYPE, /* `__WCHAR_TYPE__' */
796 T_USER_LABEL_PREFIX_TYPE, /* `__USER_LABEL_PREFIX__' */
797 T_REGISTER_PREFIX_TYPE, /* `__REGISTER_PREFIX__' */
798 T_TIME, /* `__TIME__' */
799 T_CONST, /* Constant value, used by `__STDC__' */
800 T_MACRO, /* macro defined by `#define' */
801 T_DISABLED, /* macro temporarily turned off for rescan */
802 T_SPEC_DEFINED, /* special `defined' macro for use in #if statements */
803 T_PCSTRING, /* precompiled string (hashval is KEYDEF *) */
804 T_UNUSED /* Used for something not defined. */
808 struct hashnode *next; /* double links for easy deletion */
809 struct hashnode *prev;
810 struct hashnode **bucket_hdr; /* also, a back pointer to this node's hash
811 chain is kept, in case the node is the head
812 of the chain and gets deleted. */
813 enum node_type type; /* type of special token */
814 int length; /* length of token, for quick comparison */
815 U_CHAR *name; /* the actual name */
816 union hashval value; /* pointer to expansion, or whatever */
819 typedef struct hashnode HASHNODE;
821 /* Some definitions for the hash table. The hash function MUST be
822 computed as shown in hashf () below. That is because the rescan
823 loop computes the hash value `on the fly' for most tokens,
824 in order to avoid the overhead of a lot of procedure calls to
825 the hashf () function. Hashf () only exists for the sake of
826 politeness, for use when speed isn't so important. */
828 #define HASHSIZE 1403
829 static HASHNODE *hashtab[HASHSIZE];
830 #define HASHSTEP(old, c) ((old << 2) + c)
831 #define MAKE_POS(v) (v & 0x7fffffff) /* make number positive */
833 /* Symbols to predefine. */
835 #ifdef CPP_PREDEFINES
836 static char *predefs = CPP_PREDEFINES;
838 static char *predefs = "";
841 /* We let tm.h override the types used here, to handle trivial differences
842 such as the choice of unsigned int or long unsigned int for size_t.
843 When machines start needing nontrivial differences in the size type,
844 it would be best to do something here to figure out automatically
845 from other information what type to use. */
847 /* The string value for __SIZE_TYPE__. */
850 #define SIZE_TYPE "long unsigned int"
853 /* The string value for __PTRDIFF_TYPE__. */
856 #define PTRDIFF_TYPE "long int"
859 /* The string value for __WCHAR_TYPE__. */
862 #define WCHAR_TYPE "int"
864 char * wchar_type = WCHAR_TYPE;
867 /* The string value for __USER_LABEL_PREFIX__ */
869 #ifndef USER_LABEL_PREFIX
870 #define USER_LABEL_PREFIX ""
873 /* The string value for __REGISTER_PREFIX__ */
875 #ifndef REGISTER_PREFIX
876 #define REGISTER_PREFIX ""
879 /* In the definition of a #assert name, this structure forms
880 a list of the individual values asserted.
881 Each value is itself a list of "tokens".
882 These are strings that are compared by name. */
884 struct tokenlist_list {
885 struct tokenlist_list *next;
886 struct arglist *tokens;
889 struct assertion_hashnode {
890 struct assertion_hashnode *next; /* double links for easy deletion */
891 struct assertion_hashnode *prev;
892 /* also, a back pointer to this node's hash
893 chain is kept, in case the node is the head
894 of the chain and gets deleted. */
895 struct assertion_hashnode **bucket_hdr;
896 int length; /* length of token, for quick comparison */
897 U_CHAR *name; /* the actual name */
898 /* List of token-sequences. */
899 struct tokenlist_list *value;
902 typedef struct assertion_hashnode ASSERTION_HASHNODE;
904 /* Some definitions for the hash table. The hash function MUST be
905 computed as shown in hashf below. That is because the rescan
906 loop computes the hash value `on the fly' for most tokens,
907 in order to avoid the overhead of a lot of procedure calls to
908 the hashf function. hashf only exists for the sake of
909 politeness, for use when speed isn't so important. */
911 #define ASSERTION_HASHSIZE 37
912 static ASSERTION_HASHNODE *assertion_hashtab[ASSERTION_HASHSIZE];
914 /* Nonzero means inhibit macroexpansion of what seem to be
915 assertion tests, in rescan. For #if. */
916 static int assertions_flag;
918 /* `struct directive' defines one #-directive, including how to handle it. */
921 int length; /* Length of name */
922 int (*func)(); /* Function to handle directive */
923 char *name; /* Name of directive */
924 enum node_type type; /* Code which describes which directive. */
925 char angle_brackets; /* Nonzero => <...> is special. */
926 char traditional_comments; /* Nonzero: keep comments if -traditional. */
927 char pass_thru; /* Copy preprocessed directive to output file. */
930 /* Here is the actual list of #-directives, most-often-used first. */
932 static struct directive directive_table[] = {
933 { 6, do_define, "define", T_DEFINE, 0, 1},
934 { 2, do_if, "if", T_IF},
935 { 5, do_xifdef, "ifdef", T_IFDEF},
936 { 6, do_xifdef, "ifndef", T_IFNDEF},
937 { 5, do_endif, "endif", T_ENDIF},
938 { 4, do_else, "else", T_ELSE},
939 { 4, do_elif, "elif", T_ELIF},
940 { 4, do_line, "line", T_LINE},
941 { 7, do_include, "include", T_INCLUDE, 1},
942 { 12, do_include, "include_next", T_INCLUDE_NEXT, 1},
943 { 6, do_include, "import", T_IMPORT, 1},
944 { 5, do_undef, "undef", T_UNDEF},
945 { 5, do_error, "error", T_ERROR},
946 { 7, do_warning, "warning", T_WARNING},
947 #ifdef SCCS_DIRECTIVE
948 { 4, do_sccs, "sccs", T_SCCS},
950 { 6, do_pragma, "pragma", T_PRAGMA, 0, 0, 1},
951 { 5, do_ident, "ident", T_IDENT},
952 { 6, do_assert, "assert", T_ASSERT},
953 { 8, do_unassert, "unassert", T_UNASSERT},
954 { -1, 0, "", T_UNUSED},
957 /* When a directive handler is called,
958 this points to the # that started the directive. */
959 U_CHAR *directive_start;
961 /* table to tell if char can be part of a C identifier. */
962 U_CHAR is_idchar[256];
963 /* table to tell if char can be first char of a c identifier. */
964 U_CHAR is_idstart[256];
965 /* table to tell if c is horizontal space. */
966 U_CHAR is_hor_space[256];
967 /* table to tell if c is horizontal or vertical space. */
968 static U_CHAR is_space[256];
970 #define SKIP_WHITE_SPACE(p) do { while (is_hor_space[*p]) p++; } while (0)
971 #define SKIP_ALL_WHITE_SPACE(p) do { while (is_space[*p]) p++; } while (0)
973 static int errors = 0; /* Error counter for exit code */
975 /* Name of output file, for error messages. */
976 static char *out_fname;
978 /* Zero means dollar signs are punctuation.
979 -$ stores 0; -traditional may store 1. Default is 1 for VMS, 0 otherwise.
980 This must be 0 for correct processing of this ANSI C program:
982 #define lose(b) foo (b)
985 static int dollars_in_ident;
986 #ifndef DOLLARS_IN_IDENTIFIERS
987 #define DOLLARS_IN_IDENTIFIERS 1
990 static FILE_BUF expand_to_temp_buffer ();
992 static DEFINITION *collect_expansion ();
994 /* Stack of conditionals currently in progress
995 (including both successful and failing conditionals). */
998 struct if_stack *next; /* for chaining to the next stack frame */
999 char *fname; /* copied from input when frame is made */
1000 int lineno; /* similarly */
1001 int if_succeeded; /* true if a leg of this if-group
1002 has been passed through rescan */
1003 U_CHAR *control_macro; /* For #ifndef at start of file,
1004 this is the macro name tested. */
1005 enum node_type type; /* type of last directive seen in this group */
1007 typedef struct if_stack IF_STACK_FRAME;
1008 static IF_STACK_FRAME *if_stack = NULL;
1010 /* Buffer of -M output. */
1011 static char *deps_buffer;
1013 /* Number of bytes allocated in above. */
1014 static int deps_allocated_size;
1016 /* Number of bytes used. */
1017 static int deps_size;
1019 /* Number of bytes since the last newline. */
1020 static int deps_column;
1022 /* Nonzero means -I- has been seen,
1023 so don't look for #include "foo" the source-file directory. */
1024 static int ignore_srcdir;
1026 /* Read LEN bytes at PTR from descriptor DESC, for file FILENAME,
1027 retrying if necessary. Return a negative value if an error occurs,
1028 otherwise return the actual number of bytes read,
1029 which must be LEN unless end-of-file was reached. */
1032 safe_read (desc, ptr, len)
1039 int nchars = read (desc, ptr, left);
1056 /* Write LEN bytes at PTR to descriptor DESC,
1057 retrying if necessary, and treating any real error as fatal. */
1060 safe_write (desc, ptr, len)
1066 int written = write (desc, ptr, len);
1073 pfatal_with_name (out_fname);
1091 char **pend_files = (char **) xmalloc (argc * sizeof (char *));
1092 char **pend_defs = (char **) xmalloc (argc * sizeof (char *));
1093 char **pend_undefs = (char **) xmalloc (argc * sizeof (char *));
1094 char **pend_assertions = (char **) xmalloc (argc * sizeof (char *));
1095 char **pend_includes = (char **) xmalloc (argc * sizeof (char *));
1097 /* Record the option used with each element of pend_assertions.
1098 This is preparation for supporting more than one option for making
1100 char **pend_assertion_options = (char **) xmalloc (argc * sizeof (char *));
1101 int inhibit_predefs = 0;
1102 int no_standard_includes = 0;
1103 int no_standard_cplusplus_includes = 0;
1104 int missing_newline = 0;
1106 /* Non-0 means don't output the preprocessed program. */
1107 int inhibit_output = 0;
1108 /* Non-0 means -v, so print the full set of include dirs. */
1111 /* File name which deps are being written to.
1112 This is 0 if deps are being written to stdout. */
1113 char *deps_file = 0;
1114 /* Fopen file mode to open deps_file with. */
1115 char *deps_mode = "a";
1116 /* Stream on which to print the dependency information. */
1117 FILE *deps_stream = 0;
1118 /* Target-name to write with the dependency information. */
1119 char *deps_target = 0;
1122 /* Get rid of any avoidable limit on stack size. */
1126 /* Set the stack limit huge so that alloca (particularly stringtab
1127 * in dbxread.c) does not fail. */
1128 getrlimit (RLIMIT_STACK, &rlim);
1129 rlim.rlim_cur = rlim.rlim_max;
1130 setrlimit (RLIMIT_STACK, &rlim);
1132 #endif /* RLIMIT_STACK defined */
1135 signal (SIGPIPE, pipe_closed);
1138 p = argv[0] + strlen (argv[0]);
1139 while (p != argv[0] && p[-1] != '/'
1140 #ifdef DIR_SEPARATOR
1141 && p[-1] != DIR_SEPARATOR
1149 /* Remove directories from PROGNAME. */
1152 progname = savestring (argv[0]);
1154 if (!(s = rindex (progname, ']')))
1155 s = rindex (progname, ':');
1157 strcpy (progname, s+1);
1158 if (s = rindex (progname, '.'))
1166 /* Initialize is_idchar to allow $. */
1167 dollars_in_ident = 1;
1168 initialize_char_syntax ();
1169 dollars_in_ident = DOLLARS_IN_IDENTIFIERS > 0;
1171 no_line_commands = 0;
1173 dump_macros = dump_none;
1176 cplusplus_comments = 0;
1178 bzero ((char *) pend_files, argc * sizeof (char *));
1179 bzero ((char *) pend_defs, argc * sizeof (char *));
1180 bzero ((char *) pend_undefs, argc * sizeof (char *));
1181 bzero ((char *) pend_assertions, argc * sizeof (char *));
1182 bzero ((char *) pend_includes, argc * sizeof (char *));
1184 /* Process switches and find input file name. */
1186 for (i = 1; i < argc; i++) {
1187 if (argv[i][0] != '-') {
1188 if (out_fname != NULL)
1189 fatal ("Usage: %s [switches] input output", argv[0]);
1190 else if (in_fname != NULL)
1191 out_fname = argv[i];
1195 switch (argv[i][1]) {
1198 if (!strcmp (argv[i], "-include")) {
1200 fatal ("Filename missing after `-include' option");
1202 pend_includes[i] = argv[i+1], i++;
1204 if (!strcmp (argv[i], "-imacros")) {
1206 fatal ("Filename missing after `-imacros' option");
1208 pend_files[i] = argv[i+1], i++;
1210 if (!strcmp (argv[i], "-iprefix")) {
1212 fatal ("Filename missing after `-iprefix' option");
1214 include_prefix = argv[++i];
1216 if (!strcmp (argv[i], "-ifoutput")) {
1217 output_conditionals = 1;
1219 if (!strcmp (argv[i], "-isystem")) {
1220 struct file_name_list *dirtmp;
1223 fatal ("Filename missing after `-isystem' option");
1225 dirtmp = (struct file_name_list *)
1226 xmalloc (sizeof (struct file_name_list));
1228 dirtmp->control_macro = 0;
1229 dirtmp->c_system_include_path = 1;
1230 dirtmp->fname = (char *) xmalloc (strlen (argv[i+1]) + 1);
1231 strcpy (dirtmp->fname, argv[++i]);
1232 dirtmp->got_name_map = 0;
1234 if (before_system == 0)
1235 before_system = dirtmp;
1237 last_before_system->next = dirtmp;
1238 last_before_system = dirtmp; /* Tail follows the last one */
1240 /* Add directory to end of path for includes,
1241 with the default prefix at the front of its name. */
1242 if (!strcmp (argv[i], "-iwithprefix")) {
1243 struct file_name_list *dirtmp;
1246 if (include_prefix != 0)
1247 prefix = include_prefix;
1249 prefix = savestring (GCC_INCLUDE_DIR);
1250 /* Remove the `include' from /usr/local/lib/gcc.../include. */
1251 if (!strcmp (prefix + strlen (prefix) - 8, "/include"))
1252 prefix[strlen (prefix) - 7] = 0;
1255 dirtmp = (struct file_name_list *)
1256 xmalloc (sizeof (struct file_name_list));
1257 dirtmp->next = 0; /* New one goes on the end */
1258 dirtmp->control_macro = 0;
1259 dirtmp->c_system_include_path = 0;
1261 fatal ("Directory name missing after `-iwithprefix' option");
1263 dirtmp->fname = (char *) xmalloc (strlen (argv[i+1])
1264 + strlen (prefix) + 1);
1265 strcpy (dirtmp->fname, prefix);
1266 strcat (dirtmp->fname, argv[++i]);
1267 dirtmp->got_name_map = 0;
1269 if (after_include == 0)
1270 after_include = dirtmp;
1272 last_after_include->next = dirtmp;
1273 last_after_include = dirtmp; /* Tail follows the last one */
1275 /* Add directory to main path for includes,
1276 with the default prefix at the front of its name. */
1277 if (!strcmp (argv[i], "-iwithprefixbefore")) {
1278 struct file_name_list *dirtmp;
1281 if (include_prefix != 0)
1282 prefix = include_prefix;
1284 prefix = savestring (GCC_INCLUDE_DIR);
1285 /* Remove the `include' from /usr/local/lib/gcc.../include. */
1286 if (!strcmp (prefix + strlen (prefix) - 8, "/include"))
1287 prefix[strlen (prefix) - 7] = 0;
1290 dirtmp = (struct file_name_list *)
1291 xmalloc (sizeof (struct file_name_list));
1292 dirtmp->next = 0; /* New one goes on the end */
1293 dirtmp->control_macro = 0;
1294 dirtmp->c_system_include_path = 0;
1296 fatal ("Directory name missing after `-iwithprefixbefore' option");
1298 dirtmp->fname = (char *) xmalloc (strlen (argv[i+1])
1299 + strlen (prefix) + 1);
1300 strcpy (dirtmp->fname, prefix);
1301 strcat (dirtmp->fname, argv[++i]);
1302 dirtmp->got_name_map = 0;
1304 append_include_chain (dirtmp, dirtmp);
1306 /* Add directory to end of path for includes. */
1307 if (!strcmp (argv[i], "-idirafter")) {
1308 struct file_name_list *dirtmp;
1310 dirtmp = (struct file_name_list *)
1311 xmalloc (sizeof (struct file_name_list));
1312 dirtmp->next = 0; /* New one goes on the end */
1313 dirtmp->control_macro = 0;
1314 dirtmp->c_system_include_path = 0;
1316 fatal ("Directory name missing after `-idirafter' option");
1318 dirtmp->fname = argv[++i];
1319 dirtmp->got_name_map = 0;
1321 if (after_include == 0)
1322 after_include = dirtmp;
1324 last_after_include->next = dirtmp;
1325 last_after_include = dirtmp; /* Tail follows the last one */
1330 if (out_fname != NULL)
1331 fatal ("Output filename specified twice");
1333 fatal ("Filename missing after -o option");
1334 out_fname = argv[++i];
1335 if (!strcmp (out_fname, "-"))
1340 if (!strcmp (argv[i], "-pedantic"))
1342 else if (!strcmp (argv[i], "-pedantic-errors")) {
1344 pedantic_errors = 1;
1345 } else if (!strcmp (argv[i], "-pcp")) {
1348 fatal ("Filename missing after -pcp option");
1349 pcp_fname = argv[++i];
1351 ((pcp_fname[0] != '-' || pcp_fname[1] != '\0')
1352 ? fopen (pcp_fname, "w")
1353 : fdopen (dup (fileno (stdout)), "w"));
1354 if (pcp_outfile == 0)
1355 pfatal_with_name (pcp_fname);
1361 if (!strcmp (argv[i], "-traditional")) {
1363 if (dollars_in_ident > 0)
1364 dollars_in_ident = 1;
1365 } else if (!strcmp (argv[i], "-trigraphs")) {
1371 if (! strcmp (argv[i], "-lang-c"))
1372 cplusplus = 0, cplusplus_comments = 0, objc = 0;
1373 if (! strcmp (argv[i], "-lang-c++"))
1374 cplusplus = 1, cplusplus_comments = 1, objc = 0;
1375 if (! strcmp (argv[i], "-lang-c-c++-comments"))
1376 cplusplus = 0, cplusplus_comments = 1, objc = 0;
1377 if (! strcmp (argv[i], "-lang-objc"))
1378 objc = 1, cplusplus = 0, cplusplus_comments = 1;
1379 if (! strcmp (argv[i], "-lang-objc++"))
1380 objc = 1, cplusplus = 1, cplusplus_comments = 1;
1381 if (! strcmp (argv[i], "-lang-asm"))
1383 if (! strcmp (argv[i], "-lint"))
1388 cplusplus = 1, cplusplus_comments = 1;
1392 inhibit_warnings = 1;
1396 if (!strcmp (argv[i], "-Wtrigraphs"))
1398 else if (!strcmp (argv[i], "-Wno-trigraphs"))
1400 else if (!strcmp (argv[i], "-Wcomment"))
1402 else if (!strcmp (argv[i], "-Wno-comment"))
1404 else if (!strcmp (argv[i], "-Wcomments"))
1406 else if (!strcmp (argv[i], "-Wno-comments"))
1408 else if (!strcmp (argv[i], "-Wtraditional"))
1410 else if (!strcmp (argv[i], "-Wno-traditional"))
1412 else if (!strcmp (argv[i], "-Wimport"))
1414 else if (!strcmp (argv[i], "-Wno-import"))
1416 else if (!strcmp (argv[i], "-Werror"))
1417 warnings_are_errors = 1;
1418 else if (!strcmp (argv[i], "-Wno-error"))
1419 warnings_are_errors = 0;
1420 else if (!strcmp (argv[i], "-Wall"))
1428 /* The style of the choices here is a bit mixed.
1429 The chosen scheme is a hybrid of keeping all options in one string
1430 and specifying each option in a separate argument:
1431 -M|-MM|-MD file|-MMD file [-MG]. An alternative is:
1432 -M|-MM|-MD file|-MMD file|-MG|-MMG; or more concisely:
1433 -M[M][G][D file]. This is awkward to handle in specs, and is not
1435 /* ??? -MG must be specified in addition to one of -M or -MM.
1436 This can be relaxed in the future without breaking anything.
1437 The converse isn't true. */
1439 /* -MG isn't valid with -MD or -MMD. This is checked for later. */
1440 if (!strcmp (argv[i], "-MG"))
1442 print_deps_missing_files = 1;
1445 if (!strcmp (argv[i], "-M"))
1447 else if (!strcmp (argv[i], "-MM"))
1449 else if (!strcmp (argv[i], "-MD"))
1451 else if (!strcmp (argv[i], "-MMD"))
1453 /* For -MD and -MMD options, write deps on file named by next arg. */
1454 if (!strcmp (argv[i], "-MD")
1455 || !strcmp (argv[i], "-MMD")) {
1457 fatal ("Filename missing after %s option", argv[i]);
1459 deps_file = argv[i];
1462 /* For -M and -MM, write deps on standard output
1463 and suppress the usual output. */
1464 deps_stream = stdout;
1471 char *p = argv[i] + 2;
1474 /* Arg to -d specifies what parts of macros to dump */
1477 dump_macros = dump_only;
1481 dump_macros = dump_names;
1484 dump_macros = dump_definitions;
1492 if (argv[i][2] == '3')
1497 fprintf (stderr, "GNU CPP version %s", version_string);
1498 #ifdef TARGET_VERSION
1501 fprintf (stderr, "\n");
1506 print_include_names = 1;
1510 if (argv[i][2] != 0)
1511 pend_defs[i] = argv[i] + 2;
1512 else if (i + 1 == argc)
1513 fatal ("Macro name missing after -D option");
1515 i++, pend_defs[i] = argv[i];
1522 if (argv[i][2] != 0)
1524 else if (i + 1 == argc)
1525 fatal ("Assertion missing after -A option");
1529 if (!strcmp (p, "-")) {
1530 /* -A- eliminates all predefined macros and assertions.
1531 Let's include also any that were specified earlier
1532 on the command line. That way we can get rid of any
1533 that were passed automatically in from GCC. */
1535 inhibit_predefs = 1;
1536 for (j = 0; j < i; j++)
1537 pend_defs[j] = pend_assertions[j] = 0;
1539 pend_assertions[i] = p;
1540 pend_assertion_options[i] = "-A";
1545 case 'U': /* JF #undef something */
1546 if (argv[i][2] != 0)
1547 pend_undefs[i] = argv[i] + 2;
1548 else if (i + 1 == argc)
1549 fatal ("Macro name missing after -U option");
1551 pend_undefs[i] = argv[i+1], i++;
1555 put_out_comments = 1;
1558 case 'E': /* -E comes from cc -E; ignore it. */
1562 no_line_commands = 1;
1565 case '$': /* Don't include $ in identifiers. */
1566 dollars_in_ident = 0;
1569 case 'I': /* Add directory to path for includes. */
1571 struct file_name_list *dirtmp;
1573 if (! ignore_srcdir && !strcmp (argv[i] + 2, "-")) {
1575 /* Don't use any preceding -I directories for #include <...>. */
1576 first_bracket_include = 0;
1579 dirtmp = (struct file_name_list *)
1580 xmalloc (sizeof (struct file_name_list));
1581 dirtmp->next = 0; /* New one goes on the end */
1582 dirtmp->control_macro = 0;
1583 dirtmp->c_system_include_path = 0;
1584 if (argv[i][2] != 0)
1585 dirtmp->fname = argv[i] + 2;
1586 else if (i + 1 == argc)
1587 fatal ("Directory name missing after -I option");
1589 dirtmp->fname = argv[++i];
1590 dirtmp->got_name_map = 0;
1591 append_include_chain (dirtmp, dirtmp);
1597 if (!strcmp (argv[i], "-nostdinc"))
1598 /* -nostdinc causes no default include directories.
1599 You must specify all include-file directories with -I. */
1600 no_standard_includes = 1;
1601 else if (!strcmp (argv[i], "-nostdinc++"))
1602 /* -nostdinc++ causes no default C++-specific include directories. */
1603 no_standard_cplusplus_includes = 1;
1604 else if (!strcmp (argv[i], "-noprecomp"))
1609 /* Sun compiler passes undocumented switch "-undef".
1610 Let's assume it means to inhibit the predefined symbols. */
1611 inhibit_predefs = 1;
1614 case '\0': /* JF handle '-' as file name meaning stdin or stdout */
1615 if (in_fname == NULL) {
1618 } else if (out_fname == NULL) {
1621 } /* else fall through into error */
1624 fatal ("Invalid option `%s'", argv[i]);
1629 /* Add dirs from CPATH after dirs from -I. */
1630 /* There seems to be confusion about what CPATH should do,
1631 so for the moment it is not documented. */
1632 /* Some people say that CPATH should replace the standard include dirs,
1633 but that seems pointless: it comes before them, so it overrides them
1636 p = (char *) getenv ("Include");
1638 p = (char *) getenv ("CPATH");
1640 if (p != 0 && ! no_standard_includes)
1643 /* Now that dollars_in_ident is known, initialize is_idchar. */
1644 initialize_char_syntax ();
1646 /* Initialize output buffer */
1648 outbuf.buf = (U_CHAR *) xmalloc (OUTBUF_SIZE);
1649 outbuf.bufp = outbuf.buf;
1650 outbuf.length = OUTBUF_SIZE;
1652 /* Do partial setup of input buffer for the sake of generating
1653 early #line directives (when -g is in effect). */
1655 fp = &instack[++indepth];
1656 if (in_fname == NULL)
1658 fp->nominal_fname = fp->fname = in_fname;
1661 /* In C++, wchar_t is a distinct basic type, and we can expect
1662 __wchar_t to be defined by cc1plus. */
1664 wchar_type = "__wchar_t";
1666 /* Install __LINE__, etc. Must follow initialize_char_syntax
1667 and option processing. */
1668 initialize_builtins (fp, &outbuf);
1670 /* Do standard #defines and assertions
1671 that identify system and machine type. */
1673 if (!inhibit_predefs) {
1674 char *p = (char *) alloca (strlen (predefs) + 1);
1675 strcpy (p, predefs);
1678 while (*p == ' ' || *p == '\t')
1680 /* Handle -D options. */
1681 if (p[0] == '-' && p[1] == 'D') {
1683 while (*p && *p != ' ' && *p != '\t')
1688 output_line_command (fp, &outbuf, 0, same_file);
1689 make_definition (q, &outbuf);
1690 while (*p == ' ' || *p == '\t')
1692 } else if (p[0] == '-' && p[1] == 'A') {
1693 /* Handle -A options (assertions). */
1702 past_name = assertion;
1703 /* Locate end of name. */
1704 while (*past_name && *past_name != ' '
1705 && *past_name != '\t' && *past_name != '(')
1707 /* Locate `(' at start of value. */
1709 while (*value && (*value == ' ' || *value == '\t'))
1711 if (*value++ != '(')
1713 while (*value && (*value == ' ' || *value == '\t'))
1716 /* Locate end of value. */
1717 while (*past_value && *past_value != ' '
1718 && *past_value != '\t' && *past_value != ')')
1720 termination = past_value;
1721 while (*termination && (*termination == ' ' || *termination == '\t'))
1723 if (*termination++ != ')')
1725 if (*termination && *termination != ' ' && *termination != '\t')
1727 /* Temporarily null-terminate the value. */
1728 save_char = *termination;
1729 *termination = '\0';
1730 /* Install the assertion. */
1731 make_assertion ("-A", assertion);
1732 *termination = (char) save_char;
1734 while (*p == ' ' || *p == '\t')
1742 /* Now handle the command line options. */
1744 /* Do -U's, -D's and -A's in the order they were seen. */
1745 for (i = 1; i < argc; i++) {
1746 if (pend_undefs[i]) {
1748 output_line_command (fp, &outbuf, 0, same_file);
1749 make_undef (pend_undefs[i], &outbuf);
1753 output_line_command (fp, &outbuf, 0, same_file);
1754 make_definition (pend_defs[i], &outbuf);
1756 if (pend_assertions[i])
1757 make_assertion (pend_assertion_options[i], pend_assertions[i]);
1760 done_initializing = 1;
1762 { /* read the appropriate environment variable and if it exists
1763 replace include_defaults with the listed path. */
1765 switch ((objc << 1) + cplusplus)
1768 epath = getenv ("C_INCLUDE_PATH");
1771 epath = getenv ("CPLUS_INCLUDE_PATH");
1774 epath = getenv ("OBJC_INCLUDE_PATH");
1777 epath = getenv ("OBJCPLUS_INCLUDE_PATH");
1780 /* If the environment var for this language is set,
1781 add to the default list of include directories. */
1783 char *nstore = (char *) alloca (strlen (epath) + 2);
1785 char *startp, *endp;
1787 for (num_dirs = 1, startp = epath; *startp; startp++)
1788 if (*startp == PATH_SEPARATOR)
1791 = (struct default_include *) xmalloc ((num_dirs
1792 * sizeof (struct default_include))
1793 + sizeof (include_defaults_array));
1794 startp = endp = epath;
1797 /* Handle cases like c:/usr/lib:d:/gcc/lib */
1798 if ((*endp == PATH_SEPARATOR
1799 #if 0 /* Obsolete, now that we use semicolons as the path separator. */
1801 && (endp-startp != 1 || !isalpha (*startp))
1806 strncpy (nstore, startp, endp-startp);
1808 strcpy (nstore, ".");
1810 nstore[endp-startp] = '\0';
1812 include_defaults[num_dirs].fname = savestring (nstore);
1813 include_defaults[num_dirs].cplusplus = cplusplus;
1814 include_defaults[num_dirs].cxx_aware = 1;
1818 endp = startp = endp + 1;
1822 /* Put the usual defaults back in at the end. */
1823 bcopy ((char *) include_defaults_array,
1824 (char *) &include_defaults[num_dirs],
1825 sizeof (include_defaults_array));
1829 append_include_chain (before_system, last_before_system);
1830 first_system_include = before_system;
1832 /* Unless -fnostdinc,
1833 tack on the standard include file dirs to the specified list */
1834 if (!no_standard_includes) {
1835 struct default_include *p = include_defaults;
1836 char *specd_prefix = include_prefix;
1837 char *default_prefix = savestring (GCC_INCLUDE_DIR);
1838 int default_len = 0;
1839 /* Remove the `include' from /usr/local/lib/gcc.../include. */
1840 if (!strcmp (default_prefix + strlen (default_prefix) - 8, "/include")) {
1841 default_len = strlen (default_prefix) - 7;
1842 default_prefix[default_len] = 0;
1844 /* Search "translated" versions of GNU directories.
1845 These have /usr/local/lib/gcc... replaced by specd_prefix. */
1846 if (specd_prefix != 0 && default_len != 0)
1847 for (p = include_defaults; p->fname; p++) {
1848 /* Some standard dirs are only for C++. */
1849 if (!p->cplusplus || (cplusplus && !no_standard_cplusplus_includes)) {
1850 /* Does this dir start with the prefix? */
1851 if (!strncmp (p->fname, default_prefix, default_len)) {
1852 /* Yes; change prefix and add to search list. */
1853 struct file_name_list *new
1854 = (struct file_name_list *) xmalloc (sizeof (struct file_name_list));
1855 int this_len = strlen (specd_prefix) + strlen (p->fname) - default_len;
1856 char *str = (char *) xmalloc (this_len + 1);
1857 strcpy (str, specd_prefix);
1858 strcat (str, p->fname + default_len);
1860 new->control_macro = 0;
1861 new->c_system_include_path = !p->cxx_aware;
1862 new->got_name_map = 0;
1863 append_include_chain (new, new);
1864 if (first_system_include == 0)
1865 first_system_include = new;
1869 /* Search ordinary names for GNU include directories. */
1870 for (p = include_defaults; p->fname; p++) {
1871 /* Some standard dirs are only for C++. */
1872 if (!p->cplusplus || (cplusplus && !no_standard_cplusplus_includes)) {
1873 struct file_name_list *new
1874 = (struct file_name_list *) xmalloc (sizeof (struct file_name_list));
1875 new->control_macro = 0;
1876 new->c_system_include_path = !p->cxx_aware;
1877 new->fname = p->fname;
1878 new->got_name_map = 0;
1879 append_include_chain (new, new);
1880 if (first_system_include == 0)
1881 first_system_include = new;
1886 /* Tack the after_include chain at the end of the include chain. */
1887 append_include_chain (after_include, last_after_include);
1888 if (first_system_include == 0)
1889 first_system_include = after_include;
1891 /* With -v, print the list of dirs to search. */
1893 struct file_name_list *p;
1894 fprintf (stderr, "#include \"...\" search starts here:\n");
1895 for (p = include; p; p = p->next) {
1896 if (p == first_bracket_include)
1897 fprintf (stderr, "#include <...> search starts here:\n");
1898 fprintf (stderr, " %s\n", p->fname);
1900 fprintf (stderr, "End of search list.\n");
1903 /* Scan the -imacros files before the main input.
1904 Much like #including them, but with no_output set
1905 so that only their macro definitions matter. */
1907 no_output++; no_record_file++;
1908 for (i = 1; i < argc; i++)
1909 if (pend_files[i]) {
1910 int fd = open (pend_files[i], O_RDONLY, 0666);
1912 perror_with_name (pend_files[i]);
1913 return FAILURE_EXIT_CODE;
1915 finclude (fd, pend_files[i], &outbuf, 0, NULL_PTR);
1917 no_output--; no_record_file--;
1919 /* Copy the entire contents of the main input file into
1920 the stacked input buffer previously allocated for it. */
1922 /* JF check for stdin */
1923 if (in_fname == NULL || *in_fname == 0) {
1926 } else if ((f = open (in_fname, O_RDONLY, 0666)) < 0)
1929 /* -MG doesn't select the form of output and must be specified with one of
1930 -M or -MM. -MG doesn't make sense with -MD or -MMD since they don't
1931 inhibit compilation. */
1932 if (print_deps_missing_files && (print_deps == 0 || !inhibit_output))
1933 fatal ("-MG must be specified with one of -M or -MM");
1935 /* Either of two environment variables can specify output of deps.
1936 Its value is either "OUTPUT_FILE" or "OUTPUT_FILE DEPS_TARGET",
1937 where OUTPUT_FILE is the file to write deps info to
1938 and DEPS_TARGET is the target to mention in the deps. */
1941 && (getenv ("SUNPRO_DEPENDENCIES") != 0
1942 || getenv ("DEPENDENCIES_OUTPUT") != 0)) {
1943 char *spec = getenv ("DEPENDENCIES_OUTPUT");
1948 spec = getenv ("SUNPRO_DEPENDENCIES");
1955 /* Find the space before the DEPS_TARGET, if there is one. */
1956 /* This should use index. (mrs) */
1957 while (*s != 0 && *s != ' ') s++;
1959 deps_target = s + 1;
1960 output_file = (char *) xmalloc (s - spec + 1);
1961 bcopy (spec, output_file, s - spec);
1962 output_file[s - spec] = 0;
1969 deps_file = output_file;
1973 /* For -M, print the expected object file name
1974 as the target of this Make-rule. */
1976 deps_allocated_size = 200;
1977 deps_buffer = (char *) xmalloc (deps_allocated_size);
1983 deps_output (deps_target, ':');
1984 } else if (*in_fname == 0) {
1985 deps_output ("-", ':');
1990 /* Discard all directory prefixes from filename. */
1991 if ((q = rindex (in_fname, '/')) != NULL
1992 #ifdef DIR_SEPARATOR
1993 && (q = rindex (in_fname, DIR_SEPARATOR)) != NULL
2000 /* Copy remainder to mungable area. */
2001 p = (char *) alloca (strlen(q) + 8);
2004 /* Output P, but remove known suffixes. */
2008 && p[len - 2] == '.'
2009 && index("cCsSm", p[len - 1]))
2012 && p[len - 3] == '.'
2013 && p[len - 2] == 'c'
2014 && p[len - 1] == 'c')
2017 && p[len - 4] == '.'
2018 && p[len - 3] == 'c'
2019 && p[len - 2] == 'x'
2020 && p[len - 1] == 'x')
2023 && p[len - 4] == '.'
2024 && p[len - 3] == 'c'
2025 && p[len - 2] == 'p'
2026 && p[len - 1] == 'p')
2029 /* Supply our own suffix. */
2036 deps_output (p, ':');
2037 deps_output (in_fname, ' ');
2041 file_size_and_mode (f, &st_mode, &st_size);
2042 fp->nominal_fname = fp->fname = in_fname;
2044 fp->system_header_p = 0;
2045 /* JF all this is mine about reading pipes and ttys */
2046 if (! S_ISREG (st_mode)) {
2047 /* Read input from a file that is not a normal disk file.
2048 We cannot preallocate a buffer with the correct size,
2049 so we must read in the file a piece at the time and make it bigger. */
2056 fp->buf = (U_CHAR *) xmalloc (bsize + 2);
2058 cnt = safe_read (f, fp->buf + size, bsize - size);
2059 if (cnt < 0) goto perror; /* error! */
2061 if (size != bsize) break; /* End of file */
2063 fp->buf = (U_CHAR *) xrealloc (fp->buf, bsize + 2);
2067 /* Read a file whose size we can determine in advance.
2068 For the sake of VMS, st_size is just an upper bound. */
2069 fp->buf = (U_CHAR *) xmalloc (st_size + 2);
2070 fp->length = safe_read (f, fp->buf, st_size);
2071 if (fp->length < 0) goto perror;
2074 fp->if_stack = if_stack;
2076 /* Make sure data ends with a newline. And put a null after it. */
2078 if ((fp->length > 0 && fp->buf[fp->length - 1] != '\n')
2079 /* Backslash-newline at end is not good enough. */
2080 || (fp->length > 1 && fp->buf[fp->length - 2] == '\\')) {
2081 fp->buf[fp->length++] = '\n';
2082 missing_newline = 1;
2084 fp->buf[fp->length] = '\0';
2086 /* Unless inhibited, convert trigraphs in the input. */
2091 /* Now that we know the input file is valid, open the output. */
2093 if (!out_fname || !strcmp (out_fname, ""))
2094 out_fname = "stdout";
2095 else if (! freopen (out_fname, "w", stdout))
2096 pfatal_with_name (out_fname);
2098 output_line_command (fp, &outbuf, 0, same_file);
2100 /* Scan the -include files before the main input. */
2103 for (i = 1; i < argc; i++)
2104 if (pend_includes[i]) {
2105 int fd = open (pend_includes[i], O_RDONLY, 0666);
2107 perror_with_name (pend_includes[i]);
2108 return FAILURE_EXIT_CODE;
2110 finclude (fd, pend_includes[i], &outbuf, 0, NULL_PTR);
2114 /* Scan the input, processing macros and directives. */
2116 rescan (&outbuf, 0);
2118 if (missing_newline)
2121 if (pedantic && missing_newline)
2122 pedwarn ("file does not end in newline");
2124 /* Now we have processed the entire input
2125 Write whichever kind of output has been requested. */
2127 if (dump_macros == dump_only)
2129 else if (! inhibit_output) {
2134 /* Don't actually write the deps file if compilation has failed. */
2136 if (deps_file && ! (deps_stream = fopen (deps_file, deps_mode)))
2137 pfatal_with_name (deps_file);
2138 fputs (deps_buffer, deps_stream);
2139 putc ('\n', deps_stream);
2141 if (ferror (deps_stream) || fclose (deps_stream) != 0)
2142 fatal ("I/O error on output");
2147 if (pcp_outfile && pcp_outfile != stdout
2148 && (ferror (pcp_outfile) || fclose (pcp_outfile) != 0))
2149 fatal ("I/O error on `-pcp' output");
2151 if (ferror (stdout) || fclose (stdout) != 0)
2152 fatal ("I/O error on output");
2155 exit (FAILURE_EXIT_CODE);
2156 exit (SUCCESS_EXIT_CODE);
2159 pfatal_with_name (in_fname);
2163 /* Given a colon-separated list of file names PATH,
2164 add all the names to the search path for include files. */
2178 struct file_name_list *dirtmp;
2180 /* Find the end of this name. */
2181 while (*q != 0 && *q != PATH_SEPARATOR) q++;
2183 /* An empty name in the path stands for the current directory. */
2184 name = (char *) xmalloc (2);
2188 /* Otherwise use the directory that is named. */
2189 name = (char *) xmalloc (q - p + 1);
2190 bcopy (p, name, q - p);
2194 dirtmp = (struct file_name_list *)
2195 xmalloc (sizeof (struct file_name_list));
2196 dirtmp->next = 0; /* New one goes on the end */
2197 dirtmp->control_macro = 0;
2198 dirtmp->c_system_include_path = 0;
2199 dirtmp->fname = name;
2200 dirtmp->got_name_map = 0;
2201 append_include_chain (dirtmp, dirtmp);
2203 /* Advance past this name. */
2207 /* Skip the colon. */
2212 /* Return the address of the first character in S that equals C.
2213 S is an array of length N, possibly containing '\0's, and followed by '\0'.
2214 Return 0 if there is no such character. Assume that C itself is not '\0'.
2215 If we knew we could use memchr, we could just invoke memchr (S, C, N),
2216 but unfortunately memchr isn't autoconfigured yet. */
2225 char *q = index (s, c);
2227 return (U_CHAR *) q;
2239 /* Pre-C-Preprocessor to translate ANSI trigraph idiocy in BUF
2240 before main CCCP processing. Name `pcp' is also in honor of the
2241 drugs the trigraph designers must have been on.
2243 Using an extra pass through the buffer takes a little extra time,
2244 but is infinitely less hairy than trying to handle trigraphs inside
2245 strings, etc. everywhere, and also makes sure that trigraphs are
2246 only translated in the top level of processing. */
2252 register U_CHAR c, *fptr, *bptr, *sptr, *lptr;
2255 fptr = bptr = sptr = buf->buf;
2256 lptr = fptr + buf->length;
2257 while ((sptr = (U_CHAR *) index0 (sptr, '?', lptr - sptr)) != NULL) {
2294 len = sptr - fptr - 2;
2296 /* BSD doc says bcopy () works right for overlapping strings. In ANSI
2297 C, this will be memmove (). */
2298 if (bptr != fptr && len > 0)
2299 bcopy ((char *) fptr, (char *) bptr, len);
2305 len = buf->length - (fptr - buf->buf);
2306 if (bptr != fptr && len > 0)
2307 bcopy ((char *) fptr, (char *) bptr, len);
2308 buf->length -= fptr - bptr;
2309 buf->buf[buf->length] = '\0';
2310 if (warn_trigraphs && fptr != bptr)
2311 warning ("%d trigraph(s) encountered", (fptr - bptr) / 2);
2314 /* Move all backslash-newline pairs out of embarrassing places.
2315 Exchange all such pairs following BP
2316 with any potentially-embarrassing characters that follow them.
2317 Potentially-embarrassing characters are / and *
2318 (because a backslash-newline inside a comment delimiter
2319 would cause it not to be recognized). */
2325 register U_CHAR *p = bp;
2327 /* First count the backslash-newline pairs here. */
2329 while (p[0] == '\\' && p[1] == '\n')
2332 /* What follows the backslash-newlines is not embarrassing. */
2334 if (*p != '/' && *p != '*')
2337 /* Copy all potentially embarrassing characters
2338 that follow the backslash-newline pairs
2339 down to where the pairs originally started. */
2341 while (*p == '*' || *p == '/')
2344 /* Now write the same number of pairs after the embarrassing chars. */
2351 /* Like newline_fix but for use within a directive-name.
2352 Move any backslash-newlines up past any following symbol constituents. */
2355 name_newline_fix (bp)
2358 register U_CHAR *p = bp;
2360 /* First count the backslash-newline pairs here. */
2361 while (p[0] == '\\' && p[1] == '\n')
2364 /* What follows the backslash-newlines is not embarrassing. */
2369 /* Copy all potentially embarrassing characters
2370 that follow the backslash-newline pairs
2371 down to where the pairs originally started. */
2373 while (is_idchar[*p])
2376 /* Now write the same number of pairs after the embarrassing chars. */
2383 /* Look for lint commands in comments.
2385 When we come in here, ibp points into a comment. Limit is as one expects.
2386 scan within the comment -- it should start, after lwsp, with a lint command.
2387 If so that command is returned as a (constant) string.
2389 Upon return, any arg will be pointed to with argstart and will be
2390 arglen long. Note that we don't parse that arg since it will just
2391 be printed out again.
2395 get_lintcmd (ibp, limit, argstart, arglen, cmdlen)
2396 register U_CHAR *ibp;
2397 register U_CHAR *limit;
2398 U_CHAR **argstart; /* point to command arg */
2399 int *arglen, *cmdlen; /* how long they are */
2402 register U_CHAR *numptr; /* temp for arg parsing */
2406 SKIP_WHITE_SPACE (ibp);
2408 if (ibp >= limit) return NULL;
2410 linsize = limit - ibp;
2412 /* Oh, I wish C had lexical functions... hell, I'll just open-code the set */
2413 if ((linsize >= 10) && !strncmp (ibp, "NOTREACHED", 10)) {
2415 return "NOTREACHED";
2417 if ((linsize >= 8) && !strncmp (ibp, "ARGSUSED", 8)) {
2421 if ((linsize >= 11) && !strncmp (ibp, "LINTLIBRARY", 11)) {
2423 return "LINTLIBRARY";
2425 if ((linsize >= 7) && !strncmp (ibp, "VARARGS", 7)) {
2427 ibp += 7; linsize -= 7;
2428 if ((linsize == 0) || ! isdigit (*ibp)) return "VARARGS";
2430 /* OK, read a number */
2431 for (numptr = *argstart = ibp; (numptr < limit) && isdigit (*numptr);
2433 *arglen = numptr - *argstart;
2440 * The main loop of the program.
2442 * Read characters from the input stack, transferring them to the
2445 * Macros are expanded and push levels on the input stack.
2446 * At the end of such a level it is popped off and we keep reading.
2447 * At the end of any other kind of level, we return.
2448 * #-directives are handled, except within macros.
2450 * If OUTPUT_MARKS is nonzero, keep Newline markers found in the input
2451 * and insert them when appropriate. This is set while scanning macro
2452 * arguments before substitution. It is zero when scanning for final output.
2453 * There are three types of Newline markers:
2454 * * Newline - follows a macro name that was not expanded
2455 * because it appeared inside an expansion of the same macro.
2456 * This marker prevents future expansion of that identifier.
2457 * When the input is rescanned into the final output, these are deleted.
2458 * These are also deleted by ## concatenation.
2459 * * Newline Space (or Newline and any other whitespace character)
2460 * stands for a place that tokens must be separated or whitespace
2461 * is otherwise desirable, but where the ANSI standard specifies there
2462 * is no whitespace. This marker turns into a Space (or whichever other
2463 * whitespace char appears in the marker) in the final output,
2464 * but it turns into nothing in an argument that is stringified with #.
2465 * Such stringified arguments are the only place where the ANSI standard
2466 * specifies with precision that whitespace may not appear.
2468 * During this function, IP->bufp is kept cached in IBP for speed of access.
2469 * Likewise, OP->bufp is kept in OBP. Before calling a subroutine
2470 * IBP, IP and OBP must be copied back to memory. IP and IBP are
2471 * copied back with the RECACHE macro. OBP must be copied back from OP->bufp
2472 * explicitly, and before RECACHE, since RECACHE uses OBP.
2476 rescan (op, output_marks)
2480 /* Character being scanned in main loop. */
2483 /* Length of pending accumulated identifier. */
2484 register int ident_length = 0;
2486 /* Hash code of pending accumulated identifier. */
2487 register int hash = 0;
2489 /* Current input level (&instack[indepth]). */
2492 /* Pointer for scanning input. */
2493 register U_CHAR *ibp;
2495 /* Pointer to end of input. End of scan is controlled by LIMIT. */
2496 register U_CHAR *limit;
2498 /* Pointer for storing output. */
2499 register U_CHAR *obp;
2501 /* REDO_CHAR is nonzero if we are processing an identifier
2502 after backing up over the terminating character.
2503 Sometimes we process an identifier without backing up over
2504 the terminating character, if the terminating character
2505 is not special. Backing up is done so that the terminating character
2506 will be dispatched on again once the identifier is dealt with. */
2509 /* 1 if within an identifier inside of which a concatenation
2510 marker (Newline -) has been seen. */
2511 int concatenated = 0;
2513 /* While scanning a comment or a string constant,
2514 this records the line it started on, for error messages. */
2517 /* Record position of last `real' newline. */
2518 U_CHAR *beg_of_line;
2520 /* Pop the innermost input stack level, assuming it is a macro expansion. */
2523 do { ip->macro->type = T_MACRO; \
2524 if (ip->free_ptr) free (ip->free_ptr); \
2525 --indepth; } while (0)
2527 /* Reload `rescan's local variables that describe the current
2528 level of the input stack. */
2531 do { ip = &instack[indepth]; \
2533 limit = ip->buf + ip->length; \
2535 check_expand (op, limit - ibp); \
2537 obp = op->bufp; } while (0)
2539 if (no_output && instack[indepth].fname != 0)
2540 skip_if_group (&instack[indepth], 1, NULL);
2547 /* Our caller must always put a null after the end of
2548 the input at each input stack level. */
2558 if (*ibp == '\n' && !ip->macro) {
2559 /* At the top level, always merge lines ending with backslash-newline,
2560 even in middle of identifier. But do not merge lines in a macro,
2561 since backslash might be followed by a newline-space marker. */
2564 --obp; /* remove backslash from obuf */
2567 /* If ANSI, backslash is just another character outside a string. */
2570 /* Otherwise, backslash suppresses specialness of following char,
2571 so copy it here to prevent the switch from seeing it.
2572 But first get any pending identifier processed. */
2573 if (ident_length > 0)
2580 if (assertions_flag) {
2581 /* Copy #foo (bar lose) without macro expansion. */
2582 SKIP_WHITE_SPACE (ibp);
2583 while (is_idchar[*ibp])
2585 SKIP_WHITE_SPACE (ibp);
2588 skip_paren_group (ip);
2589 bcopy ((char *) ibp, (char *) obp, ip->bufp - ibp);
2590 obp += ip->bufp - ibp;
2595 /* If this is expanding a macro definition, don't recognize
2596 preprocessor directives. */
2599 /* If this is expand_into_temp_buffer, recognize them
2600 only after an actual newline at this level,
2601 not at the beginning of the input level. */
2602 if (ip->fname == 0 && beg_of_line == ip->buf)
2608 /* # keyword: a # must be first nonblank char on the line */
2609 if (beg_of_line == 0)
2614 /* Scan from start of line, skipping whitespace, comments
2615 and backslash-newlines, and see if we reach this #.
2616 If not, this # is not special. */
2618 /* If -traditional, require # to be at beginning of line. */
2621 if (is_hor_space[*bp])
2623 else if (*bp == '\\' && bp[1] == '\n')
2625 else if (*bp == '/' && bp[1] == '*') {
2627 while (!(*bp == '*' && bp[1] == '/'))
2631 /* There is no point in trying to deal with C++ // comments here,
2632 because if there is one, then this # must be part of the
2633 comment and we would never reach here. */
2640 /* This # can start a directive. */
2642 --obp; /* Don't copy the '#' */
2646 if (! handle_directive (ip, op)) {
2650 /* Not a known directive: treat it as ordinary text.
2651 IP, OP, IBP, etc. have not been changed. */
2652 if (no_output && instack[indepth].fname) {
2653 /* If not generating expanded output,
2654 what we do with ordinary text is skip it.
2655 Discard everything until next # directive. */
2656 skip_if_group (&instack[indepth], 1, 0);
2661 ++obp; /* Copy the '#' after all */
2662 /* Don't expand an identifier that could be a macro directive.
2663 (Section 3.8.3 of the ANSI C standard) */
2664 SKIP_WHITE_SPACE (ibp);
2665 if (is_idstart[*ibp])
2668 while (is_idchar[*ibp])
2676 /* A # directive has been successfully processed. */
2677 /* If not generating expanded output, ignore everything until
2678 next # directive. */
2679 if (no_output && instack[indepth].fname)
2680 skip_if_group (&instack[indepth], 1, 0);
2686 case '\"': /* skip quoted string */
2688 /* A single quoted string is treated like a double -- some
2689 programs (e.g., troff) are perverse this way */
2694 start_line = ip->lineno;
2696 /* Skip ahead to a matching quote. */
2700 if (ip->macro != 0) {
2701 /* try harder: this string crosses a macro expansion boundary.
2702 This can happen naturally if -traditional.
2703 Otherwise, only -D can make a macro with an unmatched quote. */
2709 error_with_line (line_for_error (start_line),
2710 "unterminated string or character constant");
2711 error_with_line (multiline_string_line,
2712 "possible real start of unterminated constant");
2713 multiline_string_line = 0;
2722 /* Traditionally, end of line ends a string constant with no error.
2723 So exit the loop and record the new line. */
2729 error_with_line (line_for_error (start_line),
2730 "unterminated character constant");
2733 if (pedantic && multiline_string_line == 0) {
2734 pedwarn_with_line (line_for_error (start_line),
2735 "string constant runs past end of line");
2737 if (multiline_string_line == 0)
2738 multiline_string_line = ip->lineno - 1;
2745 /* Backslash newline is replaced by nothing at all,
2746 but keep the line counts correct. */
2751 /* ANSI stupidly requires that in \\ the second \
2752 is *not* prevented from combining with a newline. */
2753 while (*ibp == '\\' && ibp[1] == '\n') {
2772 if (*ibp == '\\' && ibp[1] == '\n')
2776 && !(cplusplus_comments && *ibp == '/'))
2784 /* C++ style comment... */
2785 start_line = ip->lineno;
2787 --ibp; /* Back over the slash */
2790 /* Comments are equivalent to spaces. */
2791 if (! put_out_comments)
2794 /* must fake up a comment here */
2799 U_CHAR *before_bp = ibp+2;
2801 while (ibp < limit) {
2802 if (ibp[-1] != '\\' && *ibp == '\n') {
2803 if (put_out_comments) {
2804 bcopy ((char *) before_bp, (char *) obp, ibp - before_bp);
2805 obp += ibp - before_bp;
2811 /* Copy the newline into the output buffer, in order to
2812 avoid the pain of a #line every time a multiline comment
2814 if (!put_out_comments)
2825 /* Ordinary C comment. Skip it, optionally copying it to output. */
2827 start_line = ip->lineno;
2829 ++ibp; /* Skip the star. */
2831 /* If this cpp is for lint, we peek inside the comments: */
2835 char *lintcmd = get_lintcmd (ibp, limit, &argbp, &arglen, &cmdlen);
2837 if (lintcmd != NULL) {
2839 check_expand (op, cmdlen + arglen + 14);
2841 /* I believe it is always safe to emit this newline: */
2843 bcopy ("#pragma lint ", (char *) obp, 13);
2845 bcopy (lintcmd, (char *) obp, cmdlen);
2850 bcopy (argbp, (char *) obp, arglen);
2854 /* OK, now bring us back to the state we were in before we entered
2855 this branch. We need #line because the #pragma's newline always
2856 messes up the line count. */
2858 output_line_command (ip, op, 0, same_file);
2859 check_expand (op, limit - ibp + 2);
2865 /* Comments are equivalent to spaces.
2866 Note that we already output the slash; we might not want it.
2867 For -traditional, a comment is equivalent to nothing. */
2868 if (! put_out_comments) {
2878 U_CHAR *before_bp = ibp;
2880 while (ibp < limit) {
2883 if (warn_comments && ibp < limit && *ibp == '*')
2884 warning ("`/*' within comment");
2887 if (*ibp == '\\' && ibp[1] == '\n')
2889 if (ibp >= limit || *ibp == '/')
2894 /* Copy the newline into the output buffer, in order to
2895 avoid the pain of a #line every time a multiline comment
2897 if (!put_out_comments)
2905 error_with_line (line_for_error (start_line),
2906 "unterminated comment");
2909 if (put_out_comments) {
2910 bcopy ((char *) before_bp, (char *) obp, ibp - before_bp);
2911 obp += ibp - before_bp;
2918 if (!dollars_in_ident)
2922 case '0': case '1': case '2': case '3': case '4':
2923 case '5': case '6': case '7': case '8': case '9':
2924 /* If digit is not part of identifier, it starts a number,
2925 which means that following letters are not an identifier.
2926 "0x5" does not refer to an identifier "x5".
2927 So copy all alphanumerics that follow without accumulating
2928 as an identifier. Periods also, for sake of "3.e7". */
2930 if (ident_length == 0) {
2931 while (ibp < limit) {
2932 while (ibp < limit && ibp[0] == '\\' && ibp[1] == '\n') {
2937 /* ".." terminates a preprocessing number. This is useless for C
2938 code but useful for preprocessing other things. */
2939 if (!isalnum (c) && (c != '.' || *ibp == '.') && c != '_') {
2944 /* A sign can be part of a preprocessing number
2945 if it follows an e. */
2946 if (c == 'e' || c == 'E') {
2947 while (ibp < limit && ibp[0] == '\\' && ibp[1] == '\n') {
2951 if (ibp < limit && (*ibp == '+' || *ibp == '-')) {
2953 /* But traditional C does not let the token go past the sign. */
2964 case 'a': case 'b': case 'c': case 'd': case 'e': case 'f':
2965 case 'g': case 'h': case 'i': case 'j': case 'k': case 'l':
2966 case 'm': case 'n': case 'o': case 'p': case 'q': case 'r':
2967 case 's': case 't': case 'u': case 'v': case 'w': case 'x':
2969 case 'A': case 'B': case 'C': case 'D': case 'E': case 'F':
2970 case 'G': case 'H': case 'I': case 'J': case 'K': case 'L':
2971 case 'M': case 'N': case 'O': case 'P': case 'Q': case 'R':
2972 case 'S': case 'T': case 'U': case 'V': case 'W': case 'X':
2976 /* Compute step of hash function, to avoid a proc call on every token */
2977 hash = HASHSTEP (hash, c);
2981 if (ip->fname == 0 && *ibp == '-') {
2982 /* Newline - inhibits expansion of preceding token.
2983 If expanding a macro arg, we keep the newline -.
2984 In final output, it is deleted.
2985 We recognize Newline - in macro bodies and macro args. */
2986 if (! concatenated) {
2991 if (!output_marks) {
2994 /* If expanding a macro arg, keep the newline -. */
3000 /* If reprocessing a macro expansion, newline is a special marker. */
3001 else if (ip->macro != 0) {
3002 /* Newline White is a "funny space" to separate tokens that are
3003 supposed to be separate but without space between.
3004 Here White means any whitespace character.
3005 Newline - marks a recursive macro use that is not
3006 supposed to be expandable. */
3008 if (is_space[*ibp]) {
3009 /* Newline Space does not prevent expansion of preceding token
3010 so expand the preceding token and then come back. */
3011 if (ident_length > 0)
3014 /* If generating final output, newline space makes a space. */
3015 if (!output_marks) {
3017 /* And Newline Newline makes a newline, so count it. */
3018 if (obp[-1] == '\n')
3021 /* If expanding a macro arg, keep the newline space.
3022 If the arg gets stringified, newline space makes nothing. */
3025 } else abort (); /* Newline followed by something random? */
3029 /* If there is a pending identifier, handle it and come back here. */
3030 if (ident_length > 0)
3035 /* Update the line counts and output a #line if necessary. */
3038 if (ip->lineno != op->lineno) {
3040 output_line_command (ip, op, 1, same_file);
3041 check_expand (op, limit - ibp);
3046 /* Come here either after (1) a null character that is part of the input
3047 or (2) at the end of the input, because there is a null there. */
3050 /* Our input really contains a null character. */
3053 /* At end of a macro-expansion level, pop it and read next level. */
3054 if (ip->macro != 0) {
3057 /* If traditional, and we have an identifier that ends here,
3058 process it now, so we get the right error for recursion. */
3059 if (traditional && ident_length
3060 && ! is_idchar[*instack[indepth - 1].bufp]) {
3069 /* If we don't have a pending identifier,
3070 return at end of input. */
3071 if (ident_length == 0) {
3079 /* If we do have a pending identifier, just consider this null
3080 a special character and arrange to dispatch on it again.
3081 The second time, IDENT_LENGTH will be zero so we will return. */
3087 /* Handle the case of a character such as /, ', " or null
3088 seen following an identifier. Back over it so that
3089 after the identifier is processed the special char
3090 will be dispatched on again. */
3100 if (ident_length > 0) {
3101 register HASHNODE *hp;
3103 /* We have just seen an identifier end. If it's a macro, expand it.
3105 IDENT_LENGTH is the length of the identifier
3106 and HASH is its hash code.
3108 The identifier has already been copied to the output,
3109 so if it is a macro we must remove it.
3111 If REDO_CHAR is 0, the char that terminated the identifier
3112 has been skipped in the output and the input.
3113 OBP-IDENT_LENGTH-1 points to the identifier.
3114 If the identifier is a macro, we must back over the terminator.
3116 If REDO_CHAR is 1, the terminating char has already been
3117 backed over. OBP-IDENT_LENGTH points to the identifier. */
3119 if (!pcp_outfile || pcp_inside_if) {
3121 for (hp = hashtab[MAKE_POS (hash) % HASHSIZE]; hp != NULL;
3124 if (hp->length == ident_length) {
3125 int obufp_before_macroname;
3126 int op_lineno_before_macroname;
3127 register int i = ident_length;
3128 register U_CHAR *p = hp->name;
3129 register U_CHAR *q = obp - i;
3135 do { /* All this to avoid a strncmp () */
3140 /* We found a use of a macro name.
3141 see if the context shows it is a macro call. */
3143 /* Back up over terminating character if not already done. */
3149 /* Save this as a displacement from the beginning of the output
3150 buffer. We can not save this as a position in the output
3151 buffer, because it may get realloc'ed by RECACHE. */
3152 obufp_before_macroname = (obp - op->buf) - ident_length;
3153 op_lineno_before_macroname = op->lineno;
3155 if (hp->type == T_PCSTRING) {
3156 pcstring_used (hp); /* Mark the definition of this key
3157 as needed, ensuring that it
3159 break; /* Exit loop, since the key cannot have a
3160 definition any longer. */
3163 /* Record whether the macro is disabled. */
3164 disabled = hp->type == T_DISABLED;
3166 /* This looks like a macro ref, but if the macro was disabled,
3167 just copy its name and put in a marker if requested. */
3171 /* This error check caught useful cases such as
3172 #define foo(x,y) bar (x (y,0), y)
3175 error ("recursive use of macro `%s'", hp->name);
3179 check_expand (op, limit - ibp + 2);
3186 /* If macro wants an arglist, verify that a '(' follows.
3187 first skip all whitespace, copying it to the output
3188 after the macro name. Then, if there is no '(',
3189 decide this is not a macro call and leave things that way. */
3190 if ((hp->type == T_MACRO || hp->type == T_DISABLED)
3191 && hp->value.defn->nargs >= 0)
3193 U_CHAR *old_ibp = ibp;
3194 U_CHAR *old_obp = obp;
3195 int old_iln = ip->lineno;
3196 int old_oln = op->lineno;
3199 /* Scan forward over whitespace, copying it to the output. */
3200 if (ibp == limit && ip->macro != 0) {
3205 old_iln = ip->lineno;
3206 old_oln = op->lineno;
3208 /* A comment: copy it unchanged or discard it. */
3209 else if (*ibp == '/' && ibp+1 != limit && ibp[1] == '*') {
3210 if (put_out_comments) {
3213 } else if (! traditional) {
3217 while (ibp + 1 != limit
3218 && !(ibp[0] == '*' && ibp[1] == '/')) {
3219 /* We need not worry about newline-marks,
3220 since they are never found in comments. */
3222 /* Newline in a file. Count it. */
3226 if (put_out_comments)
3232 if (put_out_comments) {
3237 else if (is_space[*ibp]) {
3239 if (ibp[-1] == '\n') {
3240 if (ip->macro == 0) {
3241 /* Newline in a file. Count it. */
3244 } else if (!output_marks) {
3245 /* A newline mark, and we don't want marks
3246 in the output. If it is newline-hyphen,
3247 discard it entirely. Otherwise, it is
3248 newline-whitechar, so keep the whitechar. */
3258 /* A newline mark; copy both chars to the output. */
3266 /* It isn't a macro call.
3267 Put back the space that we just skipped. */
3270 ip->lineno = old_iln;
3271 op->lineno = old_oln;
3272 /* Exit the for loop. */
3277 /* This is now known to be a macro call.
3278 Discard the macro name from the output,
3279 along with any following whitespace just copied,
3280 but preserve newlines at the top level since this
3281 is more likely to do the right thing with line numbers. */
3282 obp = op->buf + obufp_before_macroname;
3284 op->lineno = op_lineno_before_macroname;
3286 int newlines = op->lineno - op_lineno_before_macroname;
3287 while (0 < newlines--)
3291 /* Prevent accidental token-pasting with a character
3292 before the macro call. */
3293 if (!traditional && obp != op->buf
3294 && (obp[-1] == '-' || obp[1] == '+' || obp[1] == '&'
3295 || obp[-1] == '|' || obp[1] == '<' || obp[1] == '>')) {
3296 /* If we are expanding a macro arg, make a newline marker
3297 to separate the tokens. If we are making real output,
3298 a plain space will do. */
3304 /* Expand the macro, reading arguments as needed,
3305 and push the expansion on the input stack. */
3308 macroexpand (hp, op);
3310 /* Reexamine input stack, since macroexpand has pushed
3311 a new level on it. */
3318 } /* End hash-table-search loop */
3320 ident_length = hash = 0; /* Stop collecting identifier */
3323 } /* End if (ident_length > 0) */
3325 } /* End per-char loop */
3327 /* Come here to return -- but first give an error message
3328 if there was an unterminated successful conditional. */
3330 if (if_stack != ip->if_stack)
3332 char *str = "unknown";
3334 switch (if_stack->type)
3353 error_with_line (line_for_error (if_stack->lineno),
3354 "unterminated `#%s' conditional", str);
3356 if_stack = ip->if_stack;
3360 * Rescan a string into a temporary buffer and return the result
3361 * as a FILE_BUF. Note this function returns a struct, not a pointer.
3363 * OUTPUT_MARKS nonzero means keep Newline markers found in the input
3364 * and insert such markers when appropriate. See `rescan' for details.
3365 * OUTPUT_MARKS is 1 for macroexpanding a macro argument separately
3366 * before substitution; it is 0 for other uses.
3369 expand_to_temp_buffer (buf, limit, output_marks, assertions)
3370 U_CHAR *buf, *limit;
3371 int output_marks, assertions;
3373 register FILE_BUF *ip;
3375 int length = limit - buf;
3377 int odepth = indepth;
3378 int save_assertions_flag = assertions_flag;
3380 assertions_flag = assertions;
3385 /* Set up the input on the input stack. */
3387 buf1 = (U_CHAR *) alloca (length + 1);
3389 register U_CHAR *p1 = buf;
3390 register U_CHAR *p2 = buf1;
3397 /* Set up to receive the output. */
3399 obuf.length = length * 2 + 100; /* Usually enough. Why be stingy? */
3400 obuf.bufp = obuf.buf = (U_CHAR *) xmalloc (obuf.length);
3405 CHECK_DEPTH ({return obuf;});
3409 ip = &instack[indepth];
3411 ip->nominal_fname = 0;
3412 ip->system_header_p = 0;
3415 ip->length = length;
3416 ip->buf = ip->bufp = buf1;
3417 ip->if_stack = if_stack;
3419 ip->lineno = obuf.lineno = 1;
3421 /* Scan the input, create the output. */
3422 rescan (&obuf, output_marks);
3424 /* Pop input stack to original state. */
3427 if (indepth != odepth)
3430 /* Record the output. */
3431 obuf.length = obuf.bufp - obuf.buf;
3433 assertions_flag = save_assertions_flag;
3438 * Process a # directive. Expects IP->bufp to point after the '#', as in
3439 * `#define foo bar'. Passes to the command handler
3440 * (do_define, do_include, etc.): the addresses of the 1st and
3441 * last chars of the command (starting immediately after the #
3442 * keyword), plus op and the keyword table pointer. If the command
3443 * contains comments it is copied into a temporary buffer sans comments
3444 * and the temporary buffer is passed to the command handler instead.
3445 * Likewise for backslash-newlines.
3447 * Returns nonzero if this was a known # directive.
3448 * Otherwise, returns zero, without advancing the input pointer.
3452 handle_directive (ip, op)
3455 register U_CHAR *bp, *cp;
3456 register struct directive *kt;
3457 register int ident_length;
3460 /* Nonzero means we must copy the entire command
3461 to get rid of comments or backslash-newlines. */
3462 int copy_command = 0;
3464 U_CHAR *ident, *after_ident;
3468 /* Record where the directive started. do_xifdef needs this. */
3469 directive_start = bp - 1;
3471 /* Skip whitespace and \-newline. */
3473 if (is_hor_space[*bp]) {
3474 if ((*bp == '\f' || *bp == '\v') && pedantic)
3475 pedwarn ("%s in preprocessing directive",
3476 *bp == '\f' ? "formfeed" : "vertical tab");
3478 } else if (*bp == '/' && (bp[1] == '*'
3479 || (cplusplus_comments && bp[1] == '/'))) {
3481 skip_to_end_of_comment (ip, &ip->lineno, 0);
3483 } else if (*bp == '\\' && bp[1] == '\n') {
3484 bp += 2; ip->lineno++;
3488 /* Now find end of directive name.
3489 If we encounter a backslash-newline, exchange it with any following
3490 symbol-constituents so that we end up with a contiguous name. */
3497 if (*cp == '\\' && cp[1] == '\n')
3498 name_newline_fix (cp);
3504 ident_length = cp - bp;
3508 /* A line of just `#' becomes blank. */
3510 if (ident_length == 0 && *after_ident == '\n') {
3511 ip->bufp = after_ident;
3515 if (ident_length == 0 || !is_idstart[*ident]) {
3517 while (is_idchar[*p]) {
3518 if (*p < '0' || *p > '9')
3522 /* Handle # followed by a line number. */
3523 if (p != ident && !is_idchar[*p]) {
3524 static struct directive line_directive_table[] = {
3525 { 4, do_line, "line", T_LINE},
3528 pedwarn ("`#' followed by integer");
3529 after_ident = ident;
3530 kt = line_directive_table;
3534 /* Avoid error for `###' and similar cases unless -pedantic. */
3536 while (*p == '#' || is_hor_space[*p]) p++;
3538 if (pedantic && !lang_asm)
3539 warning ("invalid preprocessor directive");
3545 error ("invalid preprocessor directive name");
3551 * Decode the keyword and call the appropriate expansion
3552 * routine, after moving the input pointer up to the next line.
3554 for (kt = directive_table; kt->length > 0; kt++) {
3555 if (kt->length == ident_length && !strncmp (kt->name, ident, ident_length)) {
3556 register U_CHAR *buf;
3557 register U_CHAR *limit;
3560 int *already_output;
3562 /* Nonzero means do not delete comments within the directive.
3563 #define needs this when -traditional. */
3568 limit = ip->buf + ip->length;
3571 keep_comments = traditional && kt->traditional_comments;
3572 /* #import is defined only in Objective C, or when on the NeXT. */
3573 if (kt->type == T_IMPORT && !(objc || lookup ("__NeXT__", -1, -1)))
3576 /* Find the end of this command (first newline not backslashed
3577 and not in a string or comment).
3578 Set COPY_COMMAND if the command must be copied
3579 (it contains a backslash-newline or a comment). */
3581 buf = bp = after_ident;
3582 while (bp < limit) {
3583 register U_CHAR c = *bp++;
3591 } else if (traditional)
3598 bp = skip_quoted_string (bp - 1, limit, ip->lineno, &ip->lineno, ©_command, &unterminated);
3599 /* Don't bother calling the directive if we already got an error
3600 message due to unterminated string. Skip everything and pretend
3601 we called the directive. */
3604 /* Traditional preprocessing permits unterminated strings. */
3613 /* <...> is special for #include. */
3615 if (!kt->angle_brackets)
3617 while (bp < limit && *bp != '>' && *bp != '\n') {
3618 if (*bp == '\\' && bp[1] == '\n') {
3628 if (*bp == '\\' && bp[1] == '\n')
3631 || (cplusplus_comments && *bp == '/')) {
3632 U_CHAR *obp = bp - 1;
3634 skip_to_end_of_comment (ip, &ip->lineno, 0);
3636 /* No need to copy the command because of a comment at the end;
3637 just don't include the comment in the directive. */
3638 if (bp == limit || *bp == '\n') {
3642 /* Don't remove the comments if -traditional. */
3643 if (! keep_comments)
3651 pedwarn ("%s in preprocessing directive",
3652 c == '\f' ? "formfeed" : "vertical tab");
3656 --bp; /* Point to the newline */
3664 resume_p = ip->bufp;
3665 /* BP is the end of the directive.
3666 RESUME_P is the next interesting data after the directive.
3667 A comment may come between. */
3669 /* If a directive should be copied through, and -E was given,
3670 pass it through before removing comments. */
3671 if (!no_output && kt->pass_thru && put_out_comments) {
3674 /* Output directive name. */
3675 check_expand (op, kt->length + 2);
3676 /* Make sure # is at the start of a line */
3677 if (op->bufp > op->buf && op->bufp[-1] != '\n') {
3682 bcopy (kt->name, op->bufp, kt->length);
3683 op->bufp += kt->length;
3685 /* Output arguments. */
3687 check_expand (op, len);
3688 bcopy (buf, (char *) op->bufp, len);
3690 /* Take account of any (escaped) newlines just output. */
3692 if (buf[len] == '\n')
3695 already_output = &junk;
3696 } /* Don't we need a newline or #line? */
3699 register U_CHAR *xp = buf;
3700 /* Need to copy entire command into temp buffer before dispatching */
3702 cp = (U_CHAR *) alloca (bp - buf + 5); /* room for cmd plus
3706 /* Copy to the new buffer, deleting comments
3707 and backslash-newlines (and whitespace surrounding the latter). */
3710 register U_CHAR c = *xp++;
3715 abort (); /* A bare newline should never part of the line. */
3718 /* <...> is special for #include. */
3720 if (!kt->angle_brackets)
3722 while (xp < bp && c != '>') {
3724 if (c == '\\' && xp < bp && *xp == '\n')
3735 if (cp != buf && is_space[cp[-1]]) {
3736 while (cp != buf && is_space[cp[-1]]) cp--;
3738 SKIP_WHITE_SPACE (xp);
3739 } else if (is_space[*xp]) {
3741 SKIP_WHITE_SPACE (xp);
3751 register U_CHAR *bp1
3752 = skip_quoted_string (xp - 1, bp, ip->lineno,
3753 NULL_PTR, NULL_PTR, NULL_PTR);
3767 || (cplusplus_comments && *xp == '/')) {
3769 /* If we already copied the command through,
3770 already_output != 0 prevents outputting comment now. */
3771 skip_to_end_of_comment (ip, already_output, 0);
3773 while (xp != ip->bufp)
3775 /* Delete or replace the slash. */
3776 else if (traditional)
3785 /* Null-terminate the copy. */
3791 ip->bufp = resume_p;
3793 /* Some directives should be written out for cc1 to process,
3794 just as if they were not defined. And sometimes we're copying
3795 definitions through. */
3797 if (!no_output && already_output == 0
3799 || (kt->type == T_DEFINE
3800 && (dump_macros == dump_names
3801 || dump_macros == dump_definitions)))) {
3804 /* Output directive name. */
3805 check_expand (op, kt->length + 1);
3807 bcopy (kt->name, (char *) op->bufp, kt->length);
3808 op->bufp += kt->length;
3810 if (kt->pass_thru || dump_macros == dump_definitions) {
3811 /* Output arguments. */
3813 check_expand (op, len);
3814 bcopy (buf, (char *) op->bufp, len);
3816 } else if (kt->type == T_DEFINE && dump_macros == dump_names) {
3819 SKIP_WHITE_SPACE (xp);
3821 while (is_idchar[*xp]) xp++;
3823 check_expand (op, len + 1);
3825 bcopy (yp, op->bufp, len);
3828 } /* Don't we need a newline or #line? */
3830 /* Call the appropriate command handler. buf now points to
3831 either the appropriate place in the input buffer, or to
3832 the temp buffer if it was necessary to make one. cp
3833 points to the first char after the contents of the (possibly
3834 copied) command, in either case. */
3835 (*kt->func) (buf, cp, op, kt);
3836 check_expand (op, ip->length - (ip->bufp - ip->buf));
3842 /* It is deliberate that we don't warn about undefined directives.
3843 That is the responsibility of cc1. */
3850 static struct tm *timebuf;
3852 time_t t = time ((time_t *)0);
3853 timebuf = localtime (&t);
3858 static char *monthnames[] = {"Jan", "Feb", "Mar", "Apr", "May", "Jun",
3859 "Jul", "Aug", "Sep", "Oct", "Nov", "Dec",
3863 * expand things like __FILE__. Place the expansion into the output
3864 * buffer *without* rescanning.
3868 special_symbol (hp, op)
3875 FILE_BUF *ip = NULL;
3878 int paren = 0; /* For special `defined' keyword */
3880 if (pcp_outfile && pcp_inside_if
3881 && hp->type != T_SPEC_DEFINED && hp->type != T_CONST)
3882 error ("Predefined macro `%s' used inside `#if' during precompilation",
3885 for (i = indepth; i >= 0; i--)
3886 if (instack[i].fname != NULL) {
3891 error ("cccp error: not in any file?!");
3892 return; /* the show must go on */
3900 if (hp->type == T_FILE)
3901 string = ip->nominal_fname;
3903 string = instack[0].nominal_fname;
3907 buf = (char *) alloca (3 + 4 * strlen (string));
3908 quote_string (buf, string);
3916 case T_INCLUDE_LEVEL:
3918 for (i = indepth; i >= 0; i--)
3919 if (instack[i].fname != NULL)
3922 buf = (char *) alloca (8); /* Eight bytes ought to be more than enough */
3923 sprintf (buf, "%d", true_indepth - 1);
3927 buf = (char *) alloca (3 + strlen (version_string));
3928 sprintf (buf, "\"%s\"", version_string);
3931 #ifndef NO_BUILTIN_SIZE_TYPE
3937 #ifndef NO_BUILTIN_PTRDIFF_TYPE
3938 case T_PTRDIFF_TYPE:
3947 case T_USER_LABEL_PREFIX_TYPE:
3948 buf = USER_LABEL_PREFIX;
3951 case T_REGISTER_PREFIX_TYPE:
3952 buf = REGISTER_PREFIX;
3956 buf = (char *) alloca (4 * sizeof (int));
3957 sprintf (buf, "%d", hp->value.ival);
3958 if (pcp_inside_if && pcp_outfile)
3959 /* Output a precondition for this macro use */
3960 fprintf (pcp_outfile, "#define %s %d\n", hp->name, hp->value.ival);
3964 buf = (char *) alloca (10);
3965 sprintf (buf, "%d", ip->lineno);
3970 buf = (char *) alloca (20);
3971 timebuf = timestamp ();
3972 if (hp->type == T_DATE)
3973 sprintf (buf, "\"%s %2d %4d\"", monthnames[timebuf->tm_mon],
3974 timebuf->tm_mday, timebuf->tm_year + 1900);
3976 sprintf (buf, "\"%02d:%02d:%02d\"", timebuf->tm_hour, timebuf->tm_min,
3980 case T_SPEC_DEFINED:
3981 buf = " 0 "; /* Assume symbol is not defined */
3982 ip = &instack[indepth];
3983 SKIP_WHITE_SPACE (ip->bufp);
3984 if (*ip->bufp == '(') {
3986 ip->bufp++; /* Skip over the paren */
3987 SKIP_WHITE_SPACE (ip->bufp);
3990 if (!is_idstart[*ip->bufp])
3992 if (hp = lookup (ip->bufp, -1, -1)) {
3993 if (pcp_outfile && pcp_inside_if
3994 && (hp->type == T_CONST
3995 || (hp->type == T_MACRO && hp->value.defn->predefined)))
3996 /* Output a precondition for this macro use. */
3997 fprintf (pcp_outfile, "#define %s\n", hp->name);
4001 if (pcp_outfile && pcp_inside_if) {
4002 /* Output a precondition for this macro use */
4003 U_CHAR *cp = ip->bufp;
4004 fprintf (pcp_outfile, "#undef ");
4005 while (is_idchar[*cp]) /* Ick! */
4006 fputc (*cp++, pcp_outfile);
4007 putc ('\n', pcp_outfile);
4009 while (is_idchar[*ip->bufp])
4011 SKIP_WHITE_SPACE (ip->bufp);
4013 if (*ip->bufp != ')')
4021 error ("`defined' without an identifier");
4025 error ("cccp error: invalid special hash type"); /* time for gdb */
4029 check_expand (op, len);
4030 bcopy (buf, (char *) op->bufp, len);
4037 /* Routines to handle #directives */
4039 /* Handle #include and #import.
4040 This function expects to see "fname" or <fname> on the input. */
4043 do_include (buf, limit, op, keyword)
4044 U_CHAR *buf, *limit;
4046 struct directive *keyword;
4048 int importing = (keyword->type == T_IMPORT);
4049 int skip_dirs = (keyword->type == T_INCLUDE_NEXT);
4050 static int import_warning = 0;
4051 char *fname; /* Dynamically allocated fname buffer */
4054 U_CHAR *fbeg, *fend; /* Beginning and end of fname */
4056 struct file_name_list *search_start = include; /* Chain of dirs to search */
4057 struct file_name_list dsp[1]; /* First in chain, if #include "..." */
4058 struct file_name_list *searchptr = 0;
4061 int f; /* file number */
4063 int retried = 0; /* Have already tried macro
4064 expanding the include line*/
4065 FILE_BUF trybuf; /* It got expanded into here */
4066 int angle_brackets = 0; /* 0 for "...", 1 for <...> */
4071 f= -1; /* JF we iz paranoid! */
4073 if (importing && warn_import && !inhibit_warnings
4074 && !instack[indepth].system_header_p && !import_warning) {
4076 warning ("using `#import' is not recommended");
4077 fprintf (stderr, "The fact that a certain header file need not be processed more than once\n");
4078 fprintf (stderr, "should be indicated in the header file, not where it is used.\n");
4079 fprintf (stderr, "The best way to do this is with a conditional of this form:\n\n");
4080 fprintf (stderr, " #ifndef _FOO_H_INCLUDED\n");
4081 fprintf (stderr, " #define _FOO_H_INCLUDED\n");
4082 fprintf (stderr, " ... <real contents of file> ...\n");
4083 fprintf (stderr, " #endif /* Not _FOO_H_INCLUDED */\n\n");
4084 fprintf (stderr, "Then users can use `#include' any number of times.\n");
4085 fprintf (stderr, "GNU C automatically avoids processing the file more than once\n");
4086 fprintf (stderr, "when it is equipped with such a conditional.\n");
4092 SKIP_WHITE_SPACE (fbeg);
4093 /* Discard trailing whitespace so we can easily see
4094 if we have parsed all the significant chars we were given. */
4095 while (limit != fbeg && is_hor_space[limit[-1]]) limit--;
4101 /* Copy the operand text, concatenating the strings. */
4104 fbeg = (U_CHAR *) alloca (limit - fbeg + 1);
4106 while (fin != limit) {
4107 while (fin != limit && *fin != '\"')
4112 /* If not at the end, there had better be another string. */
4113 /* Skip just horiz space, and don't go past limit. */
4114 while (fin != limit && is_hor_space[*fin]) fin++;
4115 if (fin != limit && *fin == '\"')
4123 /* We have "filename". Figure out directory this source
4124 file is coming from and put it on the front of the list. */
4126 /* If -I- was specified, don't search current dir, only spec'd ones. */
4127 if (ignore_srcdir) break;
4129 for (fp = &instack[indepth]; fp >= instack; fp--)
4134 if ((nam = fp->nominal_fname) != NULL) {
4135 /* Found a named file. Figure out dir of the file,
4136 and put it in front of the search list. */
4137 dsp[0].next = search_start;
4140 ep = rindex (nam, '/');
4142 ep = rindex (nam, ']');
4143 if (ep == NULL) ep = rindex (nam, '>');
4144 if (ep == NULL) ep = rindex (nam, ':');
4145 if (ep != NULL) ep++;
4149 dsp[0].fname = (char *) alloca (n + 1);
4150 strncpy (dsp[0].fname, nam, n);
4151 dsp[0].fname[n] = '\0';
4152 if (n + INCLUDE_LEN_FUDGE > max_include_len)
4153 max_include_len = n + INCLUDE_LEN_FUDGE;
4155 dsp[0].fname = 0; /* Current directory */
4157 dsp[0].got_name_map = 0;
4166 while (fend != limit && *fend != '>') fend++;
4167 if (*fend == '>' && fend + 1 == limit) {
4169 /* If -I-, start with the first -I dir after the -I-. */
4170 if (first_bracket_include)
4171 search_start = first_bracket_include;
4179 * Support '#include xyz' like VAX-C to allow for easy use of all the
4180 * decwindow include files. It defaults to '#include <xyz.h>' (so the
4181 * code from case '<' is repeated here) and generates a warning.
4183 if (isalpha(*(--fbeg))) {
4185 while (fend != limit && (!isspace(*fend))) fend++;
4186 warning ("VAX-C-style include specification found, use '#include <filename.h>' !");
4187 if (fend == limit) {
4189 /* If -I-, start with the first -I dir after the -I-. */
4190 if (first_bracket_include)
4191 search_start = first_bracket_include;
4199 error ("`#%s' expects \"FILENAME\" or <FILENAME>", keyword->name);
4202 trybuf = expand_to_temp_buffer (buf, limit, 0, 0);
4203 buf = (U_CHAR *) alloca (trybuf.bufp - trybuf.buf + 1);
4204 bcopy ((char *) trybuf.buf, (char *) buf, trybuf.bufp - trybuf.buf);
4205 limit = buf + (trybuf.bufp - trybuf.buf);
4212 /* For #include_next, skip in the search path
4213 past the dir in which the containing file was found. */
4216 for (fp = &instack[indepth]; fp >= instack; fp--)
4217 if (fp->fname != NULL) {
4218 /* fp->dir is null if the containing file was specified
4219 with an absolute file name. In that case, don't skip anything. */
4221 search_start = fp->dir->next;
4230 error ("empty file name in `#%s'", keyword->name);
4234 /* Allocate this permanently, because it gets stored in the definitions
4236 fname = (char *) xmalloc (max_include_len + flen + 4);
4237 /* + 2 above for slash and terminating null. */
4238 /* + 2 added for '.h' on VMS (to support '#include filename') */
4240 /* If specified file name is absolute, just open it. */
4243 strncpy (fname, fbeg, flen);
4245 if (redundant_include_p (fname))
4248 f = lookup_import (fname, NULL_PTR);
4250 f = open_include_file (fname, NULL_PTR);
4252 return 0; /* Already included this file */
4254 /* Search directory path, trying to open the file.
4255 Copy each filename tried into FNAME. */
4257 for (searchptr = search_start; searchptr; searchptr = searchptr->next) {
4258 if (searchptr->fname) {
4259 /* The empty string in a search path is ignored.
4260 This makes it possible to turn off entirely
4261 a standard piece of the list. */
4262 if (searchptr->fname[0] == 0)
4264 strcpy (fname, searchptr->fname);
4265 strcat (fname, "/");
4266 fname[strlen (fname) + flen] = 0;
4270 strncat (fname, fbeg, flen);
4272 /* Change this 1/2 Unix 1/2 VMS file specification into a
4273 full VMS file specification */
4274 if (searchptr->fname && (searchptr->fname[0] != 0)) {
4275 /* Fix up the filename */
4276 hack_vms_include_specification (fname);
4278 /* This is a normal VMS filespec, so use it unchanged. */
4279 strncpy (fname, fbeg, flen);
4281 /* if it's '#include filename', add the missing .h */
4282 if (index(fname,'.')==NULL) {
4283 strcat (fname, ".h");
4288 f = lookup_import (fname, searchptr);
4290 f = open_include_file (fname, searchptr);
4292 return 0; /* Already included this file */
4294 else if (f == -1 && errno == EACCES)
4295 warning ("Header file %s exists, but is not readable", fname);
4297 if (redundant_include_p (fname)) {
4307 /* A file that was not found. */
4309 strncpy (fname, fbeg, flen);
4311 /* If generating dependencies and -MG was specified, we assume missing
4312 files are leaf files, living in the same directory as the source file
4313 or other similar place; these missing files may be generated from
4314 other files and may not exist yet (eg: y.tab.h). */
4315 if (print_deps_missing_files
4316 && print_deps > (angle_brackets || (system_include_depth > 0)))
4318 /* If it was requested as a system header file,
4319 then assume it belongs in the first place to look for such. */
4322 for (searchptr = search_start; searchptr; searchptr = searchptr->next)
4324 if (searchptr->fname)
4328 if (searchptr->fname[0] == 0)
4330 p = xmalloc (strlen (searchptr->fname)
4331 + strlen (fname) + 2);
4332 strcpy (p, searchptr->fname);
4335 deps_output (p, ' ');
4342 /* Otherwise, omit the directory, as if the file existed
4343 in the directory with the source. */
4344 deps_output (fname, ' ');
4347 /* If -M was specified, and this header file won't be added to the
4348 dependency list, then don't count this as an error, because we can
4349 still produce correct output. Otherwise, we can't produce correct
4350 output, because there may be dependencies we need inside the missing
4351 file, and we don't know what directory this missing file exists in. */
4353 && (print_deps <= (angle_brackets || (system_include_depth > 0))))
4354 warning ("No include path in which to find %s", fname);
4355 else if (search_start)
4356 error_from_errno (fname);
4358 error ("No include path in which to find %s", fname);
4362 /* Check to see if this include file is a once-only include file.
4365 struct file_name_list* ptr;
4367 for (ptr = dont_repeat_files; ptr; ptr = ptr->next) {
4368 if (!strcmp (ptr->fname, fname)) {
4370 return 0; /* This file was once'd. */
4374 for (ptr = all_include_files; ptr; ptr = ptr->next) {
4375 if (!strcmp (ptr->fname, fname))
4376 break; /* This file was included before. */
4380 /* This is the first time for this file. */
4381 /* Add it to list of files included. */
4383 ptr = (struct file_name_list *) xmalloc (sizeof (struct file_name_list));
4384 ptr->control_macro = 0;
4385 ptr->c_system_include_path = 0;
4386 ptr->next = all_include_files;
4387 all_include_files = ptr;
4388 ptr->fname = savestring (fname);
4389 ptr->got_name_map = 0;
4391 /* For -M, add this file to the dependencies. */
4392 if (print_deps > (angle_brackets || (system_include_depth > 0)))
4393 deps_output (fname, ' ');
4396 /* Handle -H option. */
4397 if (print_include_names) {
4398 output_dots (stderr, indepth);
4399 fprintf (stderr, "%s\n", fname);
4403 system_include_depth++;
4405 /* Actually process the file. */
4406 add_import (f, fname); /* Record file on "seen" list for #import. */
4408 pcftry = (char *) alloca (strlen (fname) + 30);
4416 sprintf (pcftry, "%s%d", fname, pcfnum++);
4418 pcf = open (pcftry, O_RDONLY, 0666);
4424 if (bcmp ((char *) &stat_f.st_ino, (char *) &s.st_ino,
4426 || stat_f.st_dev != s.st_dev)
4428 pcfbuf = check_precompiled (pcf, fname, &pcfbuflimit);
4429 /* Don't need it any more. */
4434 /* Don't need it at all. */
4439 } while (pcf != -1 && !pcfbuf);
4441 /* Actually process the file */
4443 pcfname = xmalloc (strlen (pcftry) + 1);
4444 strcpy (pcfname, pcftry);
4445 pcfinclude (pcfbuf, pcfbuflimit, fname, op);
4448 finclude (f, fname, op, is_system_include (fname), searchptr);
4451 system_include_depth--;
4456 /* Return nonzero if there is no need to include file NAME
4457 because it has already been included and it contains a conditional
4458 to make a repeated include do nothing. */
4461 redundant_include_p (name)
4464 struct file_name_list *l = all_include_files;
4465 for (; l; l = l->next)
4466 if (! strcmp (name, l->fname)
4468 && lookup (l->control_macro, -1, -1))
4473 /* Return nonzero if the given FILENAME is an absolute pathname which
4474 designates a file within one of the known "system" include file
4475 directories. We assume here that if the given FILENAME looks like
4476 it is the name of a file which resides either directly in a "system"
4477 include file directory, or within any subdirectory thereof, then the
4478 given file must be a "system" include file. This function tells us
4479 if we should suppress pedantic errors/warnings for the given FILENAME.
4481 The value is 2 if the file is a C-language system header file
4482 for which C++ should (on most systems) assume `extern "C"'. */
4485 is_system_include (filename)
4486 register char *filename;
4488 struct file_name_list *searchptr;
4490 for (searchptr = first_system_include; searchptr;
4491 searchptr = searchptr->next)
4492 if (searchptr->fname) {
4493 register char *sys_dir = searchptr->fname;
4494 register unsigned length = strlen (sys_dir);
4496 if (! strncmp (sys_dir, filename, length) && filename[length] == '/')
4498 if (searchptr->c_system_include_path)
4507 /* The file_name_map structure holds a mapping of file names for a
4508 particular directory. This mapping is read from the file named
4509 FILE_NAME_MAP_FILE in that directory. Such a file can be used to
4510 map filenames on a file system with severe filename restrictions,
4511 such as DOS. The format of the file name map file is just a series
4512 of lines with two tokens on each line. The first token is the name
4513 to map, and the second token is the actual name to use. */
4515 struct file_name_map
4517 struct file_name_map *map_next;
4522 #define FILE_NAME_MAP_FILE "header.gcc"
4524 /* Read a space delimited string of unlimited length from a stdio
4528 read_filename_string (ch, f)
4536 set = alloc = xmalloc (len + 1);
4540 while ((ch = getc (f)) != EOF && ! is_space[ch])
4542 if (set - alloc == len)
4545 alloc = xrealloc (alloc, len + 1);
4546 set = alloc + len / 2;
4556 /* Read the file name map file for DIRNAME. */
4558 static struct file_name_map *
4559 read_name_map (dirname)
4562 /* This structure holds a linked list of file name maps, one per
4564 struct file_name_map_list
4566 struct file_name_map_list *map_list_next;
4567 char *map_list_name;
4568 struct file_name_map *map_list_map;
4570 static struct file_name_map_list *map_list;
4571 register struct file_name_map_list *map_list_ptr;
4575 for (map_list_ptr = map_list; map_list_ptr;
4576 map_list_ptr = map_list_ptr->map_list_next)
4577 if (! strcmp (map_list_ptr->map_list_name, dirname))
4578 return map_list_ptr->map_list_map;
4580 map_list_ptr = ((struct file_name_map_list *)
4581 xmalloc (sizeof (struct file_name_map_list)));
4582 map_list_ptr->map_list_name = savestring (dirname);
4583 map_list_ptr->map_list_map = NULL;
4585 name = (char *) alloca (strlen (dirname) + strlen (FILE_NAME_MAP_FILE) + 2);
4586 strcpy (name, dirname);
4589 strcat (name, FILE_NAME_MAP_FILE);
4590 f = fopen (name, "r");
4592 map_list_ptr->map_list_map = NULL;
4596 int dirlen = strlen (dirname);
4598 while ((ch = getc (f)) != EOF)
4601 struct file_name_map *ptr;
4605 from = read_filename_string (ch, f);
4606 while ((ch = getc (f)) != EOF && is_hor_space[ch])
4608 to = read_filename_string (ch, f);
4610 ptr = ((struct file_name_map *)
4611 xmalloc (sizeof (struct file_name_map)));
4612 ptr->map_from = from;
4614 /* Make the real filename absolute. */
4619 ptr->map_to = xmalloc (dirlen + strlen (to) + 2);
4620 strcpy (ptr->map_to, dirname);
4621 ptr->map_to[dirlen] = '/';
4622 strcpy (ptr->map_to + dirlen + 1, to);
4626 ptr->map_next = map_list_ptr->map_list_map;
4627 map_list_ptr->map_list_map = ptr;
4629 while ((ch = getc (f)) != '\n')
4636 map_list_ptr->map_list_next = map_list;
4637 map_list = map_list_ptr;
4639 return map_list_ptr->map_list_map;
4642 /* Try to open include file FILENAME. SEARCHPTR is the directory
4643 being tried from the include file search path. This function maps
4644 filenames on file systems based on information read by
4648 open_include_file (filename, searchptr)
4650 struct file_name_list *searchptr;
4652 register struct file_name_map *map;
4653 register char *from;
4656 if (searchptr && ! searchptr->got_name_map)
4658 searchptr->name_map = read_name_map (searchptr->fname
4659 ? searchptr->fname : ".");
4660 searchptr->got_name_map = 1;
4663 /* First check the mapping for the directory we are using. */
4664 if (searchptr && searchptr->name_map)
4667 if (searchptr->fname)
4668 from += strlen (searchptr->fname) + 1;
4669 for (map = searchptr->name_map; map; map = map->map_next)
4671 if (! strcmp (map->map_from, from))
4673 /* Found a match. */
4674 return open (map->map_to, O_RDONLY, 0666);
4679 /* Try to find a mapping file for the particular directory we are
4680 looking in. Thus #include <sys/types.h> will look up sys/types.h
4681 in /usr/include/header.gcc and look up types.h in
4682 /usr/include/sys/header.gcc. */
4683 p = rindex (filename, '/');
4688 && strlen (searchptr->fname) == p - filename
4689 && ! strncmp (searchptr->fname, filename, p - filename))
4691 /* FILENAME is in SEARCHPTR, which we've already checked. */
4692 return open (filename, O_RDONLY, 0666);
4702 dir = (char *) alloca (p - filename + 1);
4703 bcopy (filename, dir, p - filename);
4704 dir[p - filename] = '\0';
4707 for (map = read_name_map (dir); map; map = map->map_next)
4708 if (! strcmp (map->map_from, from))
4709 return open (map->map_to, O_RDONLY, 0666);
4711 return open (filename, O_RDONLY, 0666);
4714 /* Process the contents of include file FNAME, already open on descriptor F,
4716 SYSTEM_HEADER_P is 1 if this file resides in any one of the known
4717 "system" include directories (as decided by the `is_system_include'
4719 DIRPTR is the link in the dir path through which this file was found,
4720 or 0 if the file name was absolute. */
4723 finclude (f, fname, op, system_header_p, dirptr)
4727 int system_header_p;
4728 struct file_name_list *dirptr;
4733 FILE_BUF *fp; /* For input stack frame */
4734 int missing_newline = 0;
4736 CHECK_DEPTH (return;);
4738 if (file_size_and_mode (f, &st_mode, &st_size) < 0)
4740 perror_with_name (fname);
4745 fp = &instack[indepth + 1];
4746 bzero ((char *) fp, sizeof (FILE_BUF));
4747 fp->nominal_fname = fp->fname = fname;
4750 fp->if_stack = if_stack;
4751 fp->system_header_p = system_header_p;
4754 if (S_ISREG (st_mode)) {
4755 fp->buf = (U_CHAR *) xmalloc (st_size + 2);
4758 /* Read the file contents, knowing that st_size is an upper bound
4759 on the number of bytes we can read. */
4760 fp->length = safe_read (f, fp->buf, st_size);
4761 if (fp->length < 0) goto nope;
4763 else if (S_ISDIR (st_mode)) {
4764 error ("directory `%s' specified in #include", fname);
4768 /* Cannot count its file size before reading.
4769 First read the entire file into heap and
4770 copy them into buffer on stack. */
4775 fp->buf = (U_CHAR *) xmalloc (bsize + 2);
4778 i = safe_read (f, fp->buf + st_size, bsize - st_size);
4780 goto nope; /* error! */
4782 if (st_size != bsize)
4783 break; /* End of file */
4785 fp->buf = (U_CHAR *) xrealloc (fp->buf, bsize + 2);
4788 fp->length = st_size;
4791 if ((fp->length > 0 && fp->buf[fp->length - 1] != '\n')
4792 /* Backslash-newline at end is not good enough. */
4793 || (fp->length > 1 && fp->buf[fp->length - 2] == '\\')) {
4794 fp->buf[fp->length++] = '\n';
4795 missing_newline = 1;
4797 fp->buf[fp->length] = '\0';
4799 /* Close descriptor now, so nesting does not use lots of descriptors. */
4802 /* Must do this before calling trigraph_pcp, so that the correct file name
4803 will be printed in warning messages. */
4806 input_file_stack_tick++;
4811 output_line_command (fp, op, 0, enter_file);
4814 if (missing_newline)
4817 if (pedantic && missing_newline)
4818 pedwarn ("file does not end in newline");
4821 input_file_stack_tick++;
4822 output_line_command (&instack[indepth], op, 0, leave_file);
4828 perror_with_name (fname);
4833 /* Record that inclusion of the file named FILE
4834 should be controlled by the macro named MACRO_NAME.
4835 This means that trying to include the file again
4836 will do something if that macro is defined. */
4839 record_control_macro (file, macro_name)
4843 struct file_name_list *new;
4845 for (new = all_include_files; new; new = new->next) {
4846 if (!strcmp (new->fname, file)) {
4847 new->control_macro = macro_name;
4852 /* If the file is not in all_include_files, something's wrong. */
4856 /* Maintain and search list of included files, for #import. */
4858 #define IMPORT_HASH_SIZE 31
4860 struct import_file {
4864 struct import_file *next;
4867 /* Hash table of files already included with #include or #import. */
4869 static struct import_file *import_hash_table[IMPORT_HASH_SIZE];
4871 /* Hash a file name for import_hash_table. */
4879 while (*f) val += *f++;
4880 return (val%IMPORT_HASH_SIZE);
4883 /* Search for file FILENAME in import_hash_table.
4884 Return -2 if found, either a matching name or a matching inode.
4885 Otherwise, open the file and return a file descriptor if successful
4886 or -1 if unsuccessful. */
4889 lookup_import (filename, searchptr)
4891 struct file_name_list *searchptr;
4893 struct import_file *i;
4899 hashval = import_hash (filename);
4901 /* Attempt to find file in list of already included files */
4902 i = import_hash_table[hashval];
4905 if (!strcmp (filename, i->name))
4906 return -2; /* return found */
4909 /* Open it and try a match on inode/dev */
4910 fd = open_include_file (filename, searchptr);
4914 for (h = 0; h < IMPORT_HASH_SIZE; h++) {
4915 i = import_hash_table[h];
4917 /* Compare the inode and the device.
4918 Supposedly on some systems the inode is not a scalar. */
4919 if (!bcmp ((char *) &i->inode, (char *) &sb.st_ino, sizeof (sb.st_ino))
4920 && i->dev == sb.st_dev) {
4922 return -2; /* return found */
4927 return fd; /* Not found, return open file */
4930 /* Add the file FNAME, open on descriptor FD, to import_hash_table. */
4933 add_import (fd, fname)
4937 struct import_file *i;
4941 hashval = import_hash (fname);
4943 i = (struct import_file *)xmalloc (sizeof (struct import_file));
4944 i->name = (char *)xmalloc (strlen (fname)+1);
4945 strcpy (i->name, fname);
4946 bcopy ((char *) &sb.st_ino, (char *) &i->inode, sizeof (sb.st_ino));
4948 i->next = import_hash_table[hashval];
4949 import_hash_table[hashval] = i;
4952 /* Load the specified precompiled header into core, and verify its
4953 preconditions. PCF indicates the file descriptor to read, which must
4954 be a regular file. FNAME indicates the file name of the original
4955 header. *LIMIT will be set to an address one past the end of the file.
4956 If the preconditions of the file are not satisfied, the buffer is
4957 freed and we return 0. If the preconditions are satisfied, return
4958 the address of the buffer following the preconditions. The buffer, in
4959 this case, should never be freed because various pieces of it will
4960 be referred to until all precompiled strings are output at the end of
4964 check_precompiled (pcf, fname, limit)
4978 if (file_size_and_mode (pcf, &st_mode, &st_size) < 0)
4981 if (S_ISREG (st_mode))
4983 buf = xmalloc (st_size + 2);
4984 length = safe_read (pcf, buf, st_size);
4991 if (length > 0 && buf[length-1] != '\n')
4992 buf[length++] = '\n';
4995 *limit = buf + length;
4997 /* File is in core. Check the preconditions. */
4998 if (!check_preconditions (buf))
5000 for (cp = buf; *cp; cp++)
5003 fprintf (stderr, "Using preinclude %s\n", fname);
5009 fprintf (stderr, "Cannot use preinclude %s\n", fname);
5015 /* PREC (null terminated) points to the preconditions of a
5016 precompiled header. These are a series of #define and #undef
5017 lines which must match the current contents of the hash
5020 check_preconditions (prec)
5027 lineend = (char *) index (prec, '\n');
5029 if (*prec++ != '#') {
5030 error ("Bad format encountered while reading precompiled file");
5033 if (!strncmp (prec, "define", 6)) {
5037 mdef = create_definition (prec, lineend, NULL_PTR);
5042 if ((hp = lookup (mdef.symnam, mdef.symlen, -1)) == NULL
5043 || (hp->type != T_MACRO && hp->type != T_CONST)
5044 || (hp->type == T_MACRO
5045 && !compare_defs (mdef.defn, hp->value.defn)
5046 && (mdef.defn->length != 2
5047 || mdef.defn->expansion[0] != '\n'
5048 || mdef.defn->expansion[1] != ' ')))
5050 } else if (!strncmp (prec, "undef", 5)) {
5055 while (is_hor_space[(U_CHAR) *prec])
5058 while (is_idchar[(U_CHAR) *prec])
5062 if (lookup (name, len, -1))
5065 error ("Bad format encountered while reading precompiled file");
5070 /* They all passed successfully */
5074 /* Process the main body of a precompiled file. BUF points to the
5075 string section of the file, following the preconditions. LIMIT is one
5076 character past the end. NAME is the name of the file being read
5077 in. OP is the main output buffer */
5079 pcfinclude (buf, limit, name, op)
5080 U_CHAR *buf, *limit, *name;
5087 /* First in the file comes 4 bytes indicating the number of strings, */
5088 /* in network byte order. (MSB first). */
5090 nstrings = (nstrings << 8) | *cp++;
5091 nstrings = (nstrings << 8) | *cp++;
5092 nstrings = (nstrings << 8) | *cp++;
5094 /* Looping over each string... */
5095 while (nstrings--) {
5096 U_CHAR *string_start;
5097 U_CHAR *endofthiskey;
5101 /* Each string starts with a STRINGDEF structure (str), followed */
5102 /* by the text of the string (string_start) */
5104 /* First skip to a longword boundary */
5105 /* ??? Why a 4-byte boundary? On all machines? */
5106 /* NOTE: This works correctly even if HOST_WIDE_INT
5107 is narrower than a pointer.
5108 Do not try risky measures here to get another type to use!
5109 Do not include stddef.h--it will fail! */
5110 if ((HOST_WIDE_INT) cp & 3)
5111 cp += 4 - ((HOST_WIDE_INT) cp & 3);
5113 /* Now get the string. */
5114 str = (STRINGDEF *) cp;
5115 string_start = cp += sizeof (STRINGDEF);
5117 for (; *cp; cp++) /* skip the string */
5120 /* We need to macro expand the string here to ensure that the
5121 proper definition environment is in place. If it were only
5122 expanded when we find out it is needed, macros necessary for
5123 its proper expansion might have had their definitions changed. */
5124 tmpbuf = expand_to_temp_buffer (string_start, cp++, 0, 0);
5125 /* Lineno is already set in the precompiled file */
5126 str->contents = tmpbuf.buf;
5127 str->len = tmpbuf.length;
5129 str->filename = name;
5130 str->output_mark = outbuf.bufp - outbuf.buf;
5133 *stringlist_tailp = str;
5134 stringlist_tailp = &str->chain;
5136 /* Next comes a fourbyte number indicating the number of keys */
5137 /* for this string. */
5139 nkeys = (nkeys << 8) | *cp++;
5140 nkeys = (nkeys << 8) | *cp++;
5141 nkeys = (nkeys << 8) | *cp++;
5143 /* If this number is -1, then the string is mandatory. */
5147 /* Otherwise, for each key, */
5148 for (; nkeys--; free (tmpbuf.buf), cp = endofthiskey + 1) {
5149 KEYDEF *kp = (KEYDEF *) cp;
5152 /* It starts with a KEYDEF structure */
5153 cp += sizeof (KEYDEF);
5155 /* Find the end of the key. At the end of this for loop we
5156 advance CP to the start of the next key using this variable. */
5157 endofthiskey = cp + strlen (cp);
5160 /* Expand the key, and enter it into the hash table. */
5161 tmpbuf = expand_to_temp_buffer (cp, endofthiskey, 0, 0);
5162 tmpbuf.bufp = tmpbuf.buf;
5164 while (is_hor_space[*tmpbuf.bufp])
5166 if (!is_idstart[*tmpbuf.bufp]
5167 || tmpbuf.bufp == tmpbuf.buf + tmpbuf.length) {
5172 hp = lookup (tmpbuf.bufp, -1, -1);
5175 install (tmpbuf.bufp, -1, T_PCSTRING, 0, (char *) kp, -1);
5177 else if (hp->type == T_PCSTRING) {
5178 kp->chain = hp->value.keydef;
5179 hp->value.keydef = kp;
5185 /* This output_line_command serves to switch us back to the current
5186 input file in case some of these strings get output (which will
5187 result in line commands for the header file being output). */
5188 output_line_command (&instack[indepth], op, 0, enter_file);
5191 /* Called from rescan when it hits a key for strings. Mark them all */
5192 /* used and clean up. */
5199 for (kp = hp->value.keydef; kp; kp = kp->chain)
5200 kp->str->writeflag = 1;
5204 /* Write the output, interspersing precompiled strings in their */
5205 /* appropriate places. */
5209 STRINGDEF *next_string;
5210 U_CHAR *cur_buf_loc;
5211 int line_command_len = 80;
5212 char *line_command = xmalloc (line_command_len);
5215 /* In each run through the loop, either cur_buf_loc == */
5216 /* next_string_loc, in which case we print a series of strings, or */
5217 /* it is less than next_string_loc, in which case we write some of */
5219 cur_buf_loc = outbuf.buf;
5220 next_string = stringlist;
5222 while (cur_buf_loc < outbuf.bufp || next_string) {
5224 && cur_buf_loc - outbuf.buf == next_string->output_mark) {
5225 if (next_string->writeflag) {
5226 len = 4 * strlen (next_string->filename) + 32;
5227 while (len > line_command_len)
5228 line_command = xrealloc (line_command,
5229 line_command_len *= 2);
5230 sprintf (line_command, "\n# %d ", next_string->lineno);
5231 strcpy (quote_string (line_command + strlen (line_command),
5232 next_string->filename),
5234 safe_write (fileno (stdout), line_command, strlen (line_command));
5235 safe_write (fileno (stdout), next_string->contents, next_string->len);
5237 next_string = next_string->chain;
5241 ? (next_string->output_mark
5242 - (cur_buf_loc - outbuf.buf))
5243 : outbuf.bufp - cur_buf_loc);
5245 safe_write (fileno (stdout), cur_buf_loc, len);
5249 free (line_command);
5252 /* Pass a directive through to the output file.
5253 BUF points to the contents of the directive, as a contiguous string.
5254 LIMIT points to the first character past the end of the directive.
5255 KEYWORD is the keyword-table entry for the directive. */
5258 pass_thru_directive (buf, limit, op, keyword)
5259 U_CHAR *buf, *limit;
5261 struct directive *keyword;
5263 register unsigned keyword_length = keyword->length;
5265 check_expand (op, 1 + keyword_length + (limit - buf));
5267 bcopy (keyword->name, (char *) op->bufp, keyword_length);
5268 op->bufp += keyword_length;
5269 if (limit != buf && buf[0] != ' ')
5271 bcopy ((char *) buf, (char *) op->bufp, limit - buf);
5272 op->bufp += (limit - buf);
5275 /* Count the line we have just made in the output,
5276 to get in sync properly. */
5281 /* The arglist structure is built by do_define to tell
5282 collect_definition where the argument names begin. That
5283 is, for a define like "#define f(x,y,z) foo+x-bar*y", the arglist
5284 would contain pointers to the strings x, y, and z.
5285 Collect_definition would then build a DEFINITION node,
5286 with reflist nodes pointing to the places x, y, and z had
5287 appeared. So the arglist is just convenience data passed
5288 between these two routines. It is not kept around after
5289 the current #define has been processed and entered into the
5293 struct arglist *next;
5300 /* Create a DEFINITION node from a #define directive. Arguments are
5301 as for do_define. */
5303 create_definition (buf, limit, op)
5304 U_CHAR *buf, *limit;
5307 U_CHAR *bp; /* temp ptr into input buffer */
5308 U_CHAR *symname; /* remember where symbol name starts */
5309 int sym_length; /* and how long it is */
5310 int line = instack[indepth].lineno;
5311 char *file = instack[indepth].nominal_fname;
5315 int arglengths = 0; /* Accumulate lengths of arg names
5316 plus number of args. */
5321 while (is_hor_space[*bp])
5324 symname = bp; /* remember where it starts */
5325 sym_length = check_macro_name (bp, "macro");
5328 /* Lossage will occur if identifiers or control keywords are broken
5329 across lines using backslash. This is not the right place to take
5333 struct arglist *arg_ptrs = NULL;
5336 bp++; /* skip '(' */
5337 SKIP_WHITE_SPACE (bp);
5339 /* Loop over macro argument names. */
5340 while (*bp != ')') {
5341 struct arglist *temp;
5343 temp = (struct arglist *) alloca (sizeof (struct arglist));
5345 temp->next = arg_ptrs;
5346 temp->argno = argno++;
5347 temp->rest_args = 0;
5351 pedwarn ("another parameter follows `%s'",
5354 if (!is_idstart[*bp])
5355 pedwarn ("invalid character in macro parameter name");
5357 /* Find the end of the arg name. */
5358 while (is_idchar[*bp]) {
5360 /* do we have a "special" rest-args extension here? */
5361 if (limit - bp > REST_EXTENSION_LENGTH &&
5362 strncmp (rest_extension, bp, REST_EXTENSION_LENGTH) == 0) {
5364 temp->rest_args = 1;
5368 temp->length = bp - temp->name;
5370 bp += REST_EXTENSION_LENGTH;
5371 arglengths += temp->length + 2;
5372 SKIP_WHITE_SPACE (bp);
5373 if (temp->length == 0 || (*bp != ',' && *bp != ')')) {
5374 error ("badly punctuated parameter list in `#define'");
5379 SKIP_WHITE_SPACE (bp);
5382 error ("unterminated parameter list in `#define'");
5386 struct arglist *otemp;
5388 for (otemp = temp->next; otemp != NULL; otemp = otemp->next)
5389 if (temp->length == otemp->length &&
5390 strncmp (temp->name, otemp->name, temp->length) == 0) {
5393 name = (U_CHAR *) alloca (temp->length + 1);
5394 (void) strncpy (name, temp->name, temp->length);
5395 name[temp->length] = '\0';
5396 error ("duplicate argument name `%s' in `#define'", name);
5402 ++bp; /* skip paren */
5403 /* Skip spaces and tabs if any. */
5404 while (bp < limit && (*bp == ' ' || *bp == '\t'))
5406 /* now everything from bp before limit is the definition. */
5407 defn = collect_expansion (bp, limit, argno, arg_ptrs);
5408 defn->rest_args = rest_args;
5410 /* Now set defn->args.argnames to the result of concatenating
5411 the argument names in reverse order
5412 with comma-space between them. */
5413 defn->args.argnames = (U_CHAR *) xmalloc (arglengths + 1);
5415 struct arglist *temp;
5417 for (temp = arg_ptrs; temp; temp = temp->next) {
5418 bcopy (temp->name, &defn->args.argnames[i], temp->length);
5420 if (temp->next != 0) {
5421 defn->args.argnames[i++] = ',';
5422 defn->args.argnames[i++] = ' ';
5425 defn->args.argnames[i] = 0;
5428 /* Simple expansion or empty definition. */
5434 case '\t': case ' ':
5435 /* Skip spaces and tabs. */
5436 while (++bp < limit && (*bp == ' ' || *bp == '\t'))
5440 case '!': case '"': case '#': case '%': case '&': case '\'':
5441 case ')': case '*': case '+': case ',': case '-': case '.':
5442 case '/': case ':': case ';': case '<': case '=': case '>':
5443 case '?': case '[': case '\\': case ']': case '^': case '{':
5444 case '|': case '}': case '~':
5445 warning ("missing white space after `#define %.*s'",
5446 sym_length, symname);
5450 pedwarn ("missing white space after `#define %.*s'",
5451 sym_length, symname);
5455 /* Now everything from bp before limit is the definition. */
5456 defn = collect_expansion (bp, limit, -1, NULL_PTR);
5457 defn->args.argnames = (U_CHAR *) "";
5463 /* OP is null if this is a predefinition */
5464 defn->predefined = !op;
5466 mdef.symnam = symname;
5467 mdef.symlen = sym_length;
5476 /* Process a #define command.
5477 BUF points to the contents of the #define command, as a contiguous string.
5478 LIMIT points to the first character past the end of the definition.
5479 KEYWORD is the keyword-table entry for #define. */
5482 do_define (buf, limit, op, keyword)
5483 U_CHAR *buf, *limit;
5485 struct directive *keyword;
5490 /* If this is a precompiler run (with -pcp) pass thru #define commands. */
5491 if (pcp_outfile && op)
5492 pass_thru_directive (buf, limit, op, keyword);
5494 mdef = create_definition (buf, limit, op);
5498 hashcode = hashf (mdef.symnam, mdef.symlen, HASHSIZE);
5502 if ((hp = lookup (mdef.symnam, mdef.symlen, hashcode)) != NULL) {
5504 /* Redefining a precompiled key is ok. */
5505 if (hp->type == T_PCSTRING)
5507 /* Redefining a macro is ok if the definitions are the same. */
5508 else if (hp->type == T_MACRO)
5509 ok = ! compare_defs (mdef.defn, hp->value.defn);
5510 /* Redefining a constant is ok with -D. */
5511 else if (hp->type == T_CONST)
5512 ok = ! done_initializing;
5513 /* Print the warning if it's not ok. */
5515 U_CHAR *msg; /* what pain... */
5517 /* If we are passing through #define and #undef directives, do
5518 that for this re-definition now. */
5519 if (debug_output && op)
5520 pass_thru_directive (buf, limit, op, keyword);
5522 msg = (U_CHAR *) alloca (mdef.symlen + 22);
5524 bcopy ((char *) mdef.symnam, (char *) (msg + 1), mdef.symlen);
5525 strcpy ((char *) (msg + mdef.symlen + 1), "' redefined");
5527 if (hp->type == T_MACRO)
5528 pedwarn_with_file_and_line (hp->value.defn->file, hp->value.defn->line,
5529 "this is the location of the previous definition");
5531 /* Replace the old definition. */
5533 hp->value.defn = mdef.defn;
5535 /* If we are passing through #define and #undef directives, do
5536 that for this new definition now. */
5537 if (debug_output && op)
5538 pass_thru_directive (buf, limit, op, keyword);
5539 install (mdef.symnam, mdef.symlen, T_MACRO, 0,
5540 (char *) mdef.defn, hashcode);
5551 /* Check a purported macro name SYMNAME, and yield its length.
5552 USAGE is the kind of name this is intended for. */
5555 check_macro_name (symname, usage)
5562 for (p = symname; is_idchar[*p]; p++)
5564 sym_length = p - symname;
5565 if (sym_length == 0)
5566 error ("invalid %s name", usage);
5567 else if (!is_idstart[*symname]) {
5568 U_CHAR *msg; /* what pain... */
5569 msg = (U_CHAR *) alloca (sym_length + 1);
5570 bcopy ((char *) symname, (char *) msg, sym_length);
5571 msg[sym_length] = 0;
5572 error ("invalid %s name `%s'", usage, msg);
5574 if (! strncmp (symname, "defined", 7) && sym_length == 7)
5575 error ("invalid %s name `defined'", usage);
5581 * return zero if two DEFINITIONs are isomorphic
5584 compare_defs (d1, d2)
5585 DEFINITION *d1, *d2;
5587 register struct reflist *a1, *a2;
5588 register U_CHAR *p1 = d1->expansion;
5589 register U_CHAR *p2 = d2->expansion;
5592 if (d1->nargs != d2->nargs)
5594 if (strcmp ((char *)d1->args.argnames, (char *)d2->args.argnames))
5596 for (a1 = d1->pattern, a2 = d2->pattern; a1 && a2;
5597 a1 = a1->next, a2 = a2->next) {
5598 if (!((a1->nchars == a2->nchars && ! strncmp (p1, p2, a1->nchars))
5599 || ! comp_def_part (first, p1, a1->nchars, p2, a2->nchars, 0))
5600 || a1->argno != a2->argno
5601 || a1->stringify != a2->stringify
5602 || a1->raw_before != a2->raw_before
5603 || a1->raw_after != a2->raw_after)
5611 if (comp_def_part (first, p1, d1->length - (p1 - d1->expansion),
5612 p2, d2->length - (p2 - d2->expansion), 1))
5617 /* Return 1 if two parts of two macro definitions are effectively different.
5618 One of the parts starts at BEG1 and has LEN1 chars;
5619 the other has LEN2 chars at BEG2.
5620 Any sequence of whitespace matches any other sequence of whitespace.
5621 FIRST means these parts are the first of a macro definition;
5622 so ignore leading whitespace entirely.
5623 LAST means these parts are the last of a macro definition;
5624 so ignore trailing whitespace entirely. */
5627 comp_def_part (first, beg1, len1, beg2, len2, last)
5629 U_CHAR *beg1, *beg2;
5633 register U_CHAR *end1 = beg1 + len1;
5634 register U_CHAR *end2 = beg2 + len2;
5636 while (beg1 != end1 && is_space[*beg1]) beg1++;
5637 while (beg2 != end2 && is_space[*beg2]) beg2++;
5640 while (beg1 != end1 && is_space[end1[-1]]) end1--;
5641 while (beg2 != end2 && is_space[end2[-1]]) end2--;
5643 while (beg1 != end1 && beg2 != end2) {
5644 if (is_space[*beg1] && is_space[*beg2]) {
5645 while (beg1 != end1 && is_space[*beg1]) beg1++;
5646 while (beg2 != end2 && is_space[*beg2]) beg2++;
5647 } else if (*beg1 == *beg2) {
5651 return (beg1 != end1) || (beg2 != end2);
5654 /* Read a replacement list for a macro with parameters.
5655 Build the DEFINITION structure.
5656 Reads characters of text starting at BUF until END.
5657 ARGLIST specifies the formal parameters to look for
5658 in the text of the definition; NARGS is the number of args
5659 in that list, or -1 for a macro name that wants no argument list.
5660 MACRONAME is the macro name itself (so we can avoid recursive expansion)
5661 and NAMELEN is its length in characters.
5663 Note that comments and backslash-newlines have already been deleted
5664 from the argument. */
5666 /* Leading and trailing Space, Tab, etc. are converted to markers
5667 Newline Space, Newline Tab, etc.
5668 Newline Space makes a space in the final output
5669 but is discarded if stringified. (Newline Tab is similar but
5670 makes a Tab instead.)
5672 If there is no trailing whitespace, a Newline Space is added at the end
5673 to prevent concatenation that would be contrary to the standard. */
5676 collect_expansion (buf, end, nargs, arglist)
5679 struct arglist *arglist;
5682 register U_CHAR *p, *limit, *lastp, *exp_p;
5683 struct reflist *endpat = NULL;
5684 /* Pointer to first nonspace after last ## seen. */
5686 /* Pointer to first nonspace after last single-# seen. */
5687 U_CHAR *stringify = 0;
5689 int expected_delimiter = '\0';
5691 /* Scan thru the replacement list, ignoring comments and quoted
5692 strings, picking up on the macro calls. It does a linear search
5693 thru the arg list on every potential symbol. Profiling might say
5694 that something smarter should happen. */
5699 /* Find the beginning of the trailing whitespace. */
5700 /* Find end of leading whitespace. */
5703 while (p < limit && is_space[limit[-1]]) limit--;
5704 while (p < limit && is_space[*p]) p++;
5706 /* Allocate space for the text in the macro definition.
5707 Leading and trailing whitespace chars need 2 bytes each.
5708 Each other input char may or may not need 1 byte,
5709 so this is an upper bound.
5710 The extra 2 are for invented trailing newline-marker and final null. */
5711 maxsize = (sizeof (DEFINITION)
5712 + 2 * (end - limit) + 2 * (p - buf)
5714 defn = (DEFINITION *) xcalloc (1, maxsize);
5716 defn->nargs = nargs;
5717 exp_p = defn->expansion = (U_CHAR *) defn + sizeof (DEFINITION);
5722 /* Convert leading whitespace to Newline-markers. */
5723 while (p < limit && is_space[*p]) {
5728 if (limit - p >= 2 && p[0] == '#' && p[1] == '#') {
5729 error ("`##' at start of macro definition");
5733 /* Process the main body of the definition. */
5735 int skipped_arg = 0;
5736 register U_CHAR c = *p++;
5744 if (expected_delimiter != '\0') {
5745 if (c == expected_delimiter)
5746 expected_delimiter = '\0';
5748 expected_delimiter = c;
5752 if (p < limit && expected_delimiter) {
5753 /* In a string, backslash goes through
5754 and makes next char ordinary. */
5760 /* # is ordinary inside a string. */
5761 if (expected_delimiter)
5763 if (p < limit && *p == '#') {
5764 /* ##: concatenate preceding and following tokens. */
5765 /* Take out the first #, discard preceding whitespace. */
5767 while (exp_p > lastp && is_hor_space[exp_p[-1]])
5769 /* Skip the second #. */
5771 /* Discard following whitespace. */
5772 SKIP_WHITE_SPACE (p);
5775 error ("`##' at end of macro definition");
5776 } else if (nargs >= 0) {
5777 /* Single #: stringify following argument ref.
5778 Don't leave the # in the expansion. */
5780 SKIP_WHITE_SPACE (p);
5781 if (p == limit || ! is_idstart[*p])
5782 error ("`#' operator is not followed by a macro argument name");
5789 /* In -traditional mode, recognize arguments inside strings and
5790 and character constants, and ignore special properties of #.
5791 Arguments inside strings are considered "stringified", but no
5792 extra quote marks are supplied. */
5796 if (expected_delimiter != '\0') {
5797 if (c == expected_delimiter)
5798 expected_delimiter = '\0';
5800 expected_delimiter = c;
5804 /* Backslash quotes delimiters and itself, but not macro args. */
5805 if (expected_delimiter != 0 && p < limit
5806 && (*p == expected_delimiter || *p == '\\')) {
5813 if (expected_delimiter != '\0') /* No comments inside strings. */
5816 /* If we find a comment that wasn't removed by handle_directive,
5817 this must be -traditional. So replace the comment with
5821 while (p < limit && !(p[-2] == '*' && p[-1] == '/'))
5824 /* Mark this as a concatenation-point, as if it had been ##. */
5832 /* Handle the start of a symbol. */
5833 if (is_idchar[c] && nargs > 0) {
5834 U_CHAR *id_beg = p - 1;
5838 while (p != limit && is_idchar[*p]) p++;
5839 id_len = p - id_beg;
5841 if (is_idstart[c]) {
5842 register struct arglist *arg;
5844 for (arg = arglist; arg != NULL; arg = arg->next) {
5845 struct reflist *tpat;
5847 if (arg->name[0] == c
5848 && arg->length == id_len
5849 && strncmp (arg->name, id_beg, id_len) == 0) {
5850 if (expected_delimiter && warn_stringify) {
5852 warning ("macro argument `%.*s' is stringified.",
5855 warning ("macro arg `%.*s' would be stringified with -traditional.",
5859 /* If ANSI, don't actually substitute inside a string. */
5860 if (!traditional && expected_delimiter)
5862 /* make a pat node for this arg and append it to the end of
5864 tpat = (struct reflist *) xmalloc (sizeof (struct reflist));
5866 tpat->raw_before = concat == id_beg;
5867 tpat->raw_after = 0;
5868 tpat->rest_args = arg->rest_args;
5869 tpat->stringify = (traditional ? expected_delimiter != '\0'
5870 : stringify == id_beg);
5873 defn->pattern = tpat;
5875 endpat->next = tpat;
5878 tpat->argno = arg->argno;
5879 tpat->nchars = exp_p - lastp;
5881 register U_CHAR *p1 = p;
5882 SKIP_WHITE_SPACE (p1);
5883 if (p1 + 2 <= limit && p1[0] == '#' && p1[1] == '#')
5884 tpat->raw_after = 1;
5886 lastp = exp_p; /* place to start copying from next time */
5893 /* If this was not a macro arg, copy it into the expansion. */
5894 if (! skipped_arg) {
5895 register U_CHAR *lim1 = p;
5899 if (stringify == id_beg)
5900 error ("`#' operator should be followed by a macro argument name");
5905 if (!traditional && expected_delimiter == 0) {
5906 /* There is no trailing whitespace, so invent some in ANSI mode.
5907 But not if "inside a string" (which in ANSI mode
5908 happens only for -D option). */
5915 defn->length = exp_p - defn->expansion;
5917 /* Crash now if we overrun the allocated size. */
5918 if (defn->length + 1 > maxsize)
5922 /* This isn't worth the time it takes. */
5923 /* give back excess storage */
5924 defn->expansion = (U_CHAR *) xrealloc (defn->expansion, defn->length + 1);
5931 do_assert (buf, limit, op, keyword)
5932 U_CHAR *buf, *limit;
5934 struct directive *keyword;
5936 U_CHAR *bp; /* temp ptr into input buffer */
5937 U_CHAR *symname; /* remember where symbol name starts */
5938 int sym_length; /* and how long it is */
5939 struct arglist *tokens = NULL;
5941 if (pedantic && done_initializing && !instack[indepth].system_header_p)
5942 pedwarn ("ANSI C does not allow `#assert'");
5946 while (is_hor_space[*bp])
5949 symname = bp; /* remember where it starts */
5950 sym_length = check_macro_name (bp, "assertion");
5952 /* #define doesn't do this, but we should. */
5953 SKIP_WHITE_SPACE (bp);
5955 /* Lossage will occur if identifiers or control tokens are broken
5956 across lines using backslash. This is not the right place to take
5960 error ("missing token-sequence in `#assert'");
5967 bp++; /* skip '(' */
5968 SKIP_WHITE_SPACE (bp);
5970 tokens = read_token_list (&bp, limit, &error_flag);
5974 error ("empty token-sequence in `#assert'");
5978 ++bp; /* skip paren */
5979 SKIP_WHITE_SPACE (bp);
5982 /* If this name isn't already an assertion name, make it one.
5983 Error if it was already in use in some other way. */
5986 ASSERTION_HASHNODE *hp;
5987 int hashcode = hashf (symname, sym_length, ASSERTION_HASHSIZE);
5988 struct tokenlist_list *value
5989 = (struct tokenlist_list *) xmalloc (sizeof (struct tokenlist_list));
5991 hp = assertion_lookup (symname, sym_length, hashcode);
5993 if (sym_length == 7 && ! strncmp (symname, "defined", sym_length))
5994 error ("`defined' redefined as assertion");
5995 hp = assertion_install (symname, sym_length, hashcode);
5998 /* Add the spec'd token-sequence to the list of such. */
5999 value->tokens = tokens;
6000 value->next = hp->value;
6008 do_unassert (buf, limit, op, keyword)
6009 U_CHAR *buf, *limit;
6011 struct directive *keyword;
6013 U_CHAR *bp; /* temp ptr into input buffer */
6014 U_CHAR *symname; /* remember where symbol name starts */
6015 int sym_length; /* and how long it is */
6017 struct arglist *tokens = NULL;
6018 int tokens_specified = 0;
6020 if (pedantic && done_initializing && !instack[indepth].system_header_p)
6021 pedwarn ("ANSI C does not allow `#unassert'");
6025 while (is_hor_space[*bp])
6028 symname = bp; /* remember where it starts */
6029 sym_length = check_macro_name (bp, "assertion");
6031 /* #define doesn't do this, but we should. */
6032 SKIP_WHITE_SPACE (bp);
6034 /* Lossage will occur if identifiers or control tokens are broken
6035 across lines using backslash. This is not the right place to take
6041 bp++; /* skip '(' */
6042 SKIP_WHITE_SPACE (bp);
6044 tokens = read_token_list (&bp, limit, &error_flag);
6048 error ("empty token list in `#unassert'");
6052 tokens_specified = 1;
6054 ++bp; /* skip paren */
6055 SKIP_WHITE_SPACE (bp);
6059 ASSERTION_HASHNODE *hp;
6060 int hashcode = hashf (symname, sym_length, ASSERTION_HASHSIZE);
6061 struct tokenlist_list *tail, *prev;
6063 hp = assertion_lookup (symname, sym_length, hashcode);
6067 /* If no token list was specified, then eliminate this assertion
6069 if (! tokens_specified) {
6070 struct tokenlist_list *next;
6071 for (tail = hp->value; tail; tail = next) {
6073 free_token_list (tail->tokens);
6076 delete_assertion (hp);
6078 /* If a list of tokens was given, then delete any matching list. */
6083 struct tokenlist_list *next = tail->next;
6084 if (compare_token_lists (tail->tokens, tokens)) {
6088 hp->value = tail->next;
6089 free_token_list (tail->tokens);
6102 /* Test whether there is an assertion named NAME
6103 and optionally whether it has an asserted token list TOKENS.
6104 NAME is not null terminated; its length is SYM_LENGTH.
6105 If TOKENS_SPECIFIED is 0, then don't check for any token list. */
6108 check_assertion (name, sym_length, tokens_specified, tokens)
6111 int tokens_specified;
6112 struct arglist *tokens;
6114 ASSERTION_HASHNODE *hp;
6115 int hashcode = hashf (name, sym_length, ASSERTION_HASHSIZE);
6117 if (pedantic && !instack[indepth].system_header_p)
6118 pedwarn ("ANSI C does not allow testing assertions");
6120 hp = assertion_lookup (name, sym_length, hashcode);
6122 /* It is not an assertion; just return false. */
6125 /* If no token list was specified, then value is 1. */
6126 if (! tokens_specified)
6130 struct tokenlist_list *tail;
6134 /* If a list of tokens was given,
6135 then succeed if the assertion records a matching list. */
6138 if (compare_token_lists (tail->tokens, tokens))
6143 /* Fail if the assertion has no matching list. */
6148 /* Compare two lists of tokens for equality including order of tokens. */
6151 compare_token_lists (l1, l2)
6152 struct arglist *l1, *l2;
6155 if (l1->length != l2->length)
6157 if (strncmp (l1->name, l2->name, l1->length))
6163 /* Succeed if both lists end at the same time. */
6167 /* Read a space-separated list of tokens ending in a close parenthesis.
6168 Return a list of strings, in the order they were written.
6169 (In case of error, return 0 and store -1 in *ERROR_FLAG.)
6170 Parse the text starting at *BPP, and update *BPP.
6171 Don't parse beyond LIMIT. */
6173 static struct arglist *
6174 read_token_list (bpp, limit, error_flag)
6179 struct arglist *token_ptrs = 0;
6185 /* Loop over the assertion value tokens. */
6187 struct arglist *temp;
6191 /* Find the end of the token. */
6195 } else if (*bp == ')') {
6200 } else if (*bp == '"' || *bp == '\'')
6201 bp = skip_quoted_string (bp, limit, 0, NULL_PTR, NULL_PTR, &eofp);
6203 while (! is_hor_space[*bp] && *bp != '(' && *bp != ')'
6204 && *bp != '"' && *bp != '\'' && bp != limit)
6207 temp = (struct arglist *) xmalloc (sizeof (struct arglist));
6208 temp->name = (U_CHAR *) xmalloc (bp - beg + 1);
6209 bcopy ((char *) beg, (char *) temp->name, bp - beg);
6210 temp->name[bp - beg] = 0;
6211 temp->next = token_ptrs;
6213 temp->length = bp - beg;
6215 SKIP_WHITE_SPACE (bp);
6218 error ("unterminated token sequence in `#assert' or `#unassert'");
6225 /* We accumulated the names in reverse order.
6226 Now reverse them to get the proper order. */
6228 register struct arglist *prev = 0, *this, *next;
6229 for (this = token_ptrs; this; this = next) {
6239 free_token_list (tokens)
6240 struct arglist *tokens;
6243 struct arglist *next = tokens->next;
6244 free (tokens->name);
6251 * Install a name in the assertion hash table.
6253 * If LEN is >= 0, it is the length of the name.
6254 * Otherwise, compute the length by scanning the entire name.
6256 * If HASH is >= 0, it is the precomputed hash code.
6257 * Otherwise, compute the hash code.
6259 static ASSERTION_HASHNODE *
6260 assertion_install (name, len, hash)
6265 register ASSERTION_HASHNODE *hp;
6266 register int i, bucket;
6267 register U_CHAR *p, *q;
6269 i = sizeof (ASSERTION_HASHNODE) + len + 1;
6270 hp = (ASSERTION_HASHNODE *) xmalloc (i);
6272 hp->bucket_hdr = &assertion_hashtab[bucket];
6273 hp->next = assertion_hashtab[bucket];
6274 assertion_hashtab[bucket] = hp;
6276 if (hp->next != NULL)
6277 hp->next->prev = hp;
6280 hp->name = ((U_CHAR *) hp) + sizeof (ASSERTION_HASHNODE);
6283 for (i = 0; i < len; i++)
6290 * find the most recent hash node for name name (ending with first
6291 * non-identifier char) installed by install
6293 * If LEN is >= 0, it is the length of the name.
6294 * Otherwise, compute the length by scanning the entire name.
6296 * If HASH is >= 0, it is the precomputed hash code.
6297 * Otherwise, compute the hash code.
6299 static ASSERTION_HASHNODE *
6300 assertion_lookup (name, len, hash)
6305 register ASSERTION_HASHNODE *bucket;
6307 bucket = assertion_hashtab[hash];
6309 if (bucket->length == len && strncmp (bucket->name, name, len) == 0)
6311 bucket = bucket->next;
6317 delete_assertion (hp)
6318 ASSERTION_HASHNODE *hp;
6321 if (hp->prev != NULL)
6322 hp->prev->next = hp->next;
6323 if (hp->next != NULL)
6324 hp->next->prev = hp->prev;
6326 /* make sure that the bucket chain header that
6327 the deleted guy was on points to the right thing afterwards. */
6328 if (hp == *hp->bucket_hdr)
6329 *hp->bucket_hdr = hp->next;
6335 * interpret #line command. Remembers previously seen fnames
6336 * in its very own hash table.
6338 #define FNAME_HASHSIZE 37
6341 do_line (buf, limit, op, keyword)
6342 U_CHAR *buf, *limit;
6344 struct directive *keyword;
6346 register U_CHAR *bp;
6347 FILE_BUF *ip = &instack[indepth];
6350 enum file_change_code file_change = same_file;
6352 /* Expand any macros. */
6353 tem = expand_to_temp_buffer (buf, limit, 0, 0);
6355 /* Point to macroexpanded line, which is null-terminated now. */
6357 SKIP_WHITE_SPACE (bp);
6359 if (!isdigit (*bp)) {
6360 error ("invalid format `#line' command");
6364 /* The Newline at the end of this line remains to be processed.
6365 To put the next line at the specified line number,
6366 we must store a line number now that is one less. */
6367 new_lineno = atoi (bp) - 1;
6369 /* NEW_LINENO is one less than the actual line number here. */
6370 if (pedantic && new_lineno < 0)
6371 pedwarn ("line number out of range in `#line' command");
6373 /* skip over the line number. */
6374 while (isdigit (*bp))
6377 #if 0 /* #line 10"foo.c" is supposed to be allowed. */
6378 if (*bp && !is_space[*bp]) {
6379 error ("invalid format `#line' command");
6384 SKIP_WHITE_SPACE (bp);
6387 static HASHNODE *fname_table[FNAME_HASHSIZE];
6388 HASHNODE *hp, **hash_bucket;
6394 /* Turn the file name, which is a character string literal,
6395 into a null-terminated string. Do this in place. */
6398 switch ((*p++ = *bp++)) {
6400 error ("invalid format `#line' command");
6405 char *bpc = (char *) bp;
6406 int c = parse_escape (&bpc);
6407 bp = (U_CHAR *) bpc;
6420 fname_length = p - fname;
6422 SKIP_WHITE_SPACE (bp);
6425 pedwarn ("garbage at end of `#line' command");
6427 file_change = enter_file;
6428 else if (*bp == '2')
6429 file_change = leave_file;
6430 else if (*bp == '3')
6431 ip->system_header_p = 1;
6432 else if (*bp == '4')
6433 ip->system_header_p = 2;
6435 error ("invalid format `#line' command");
6440 SKIP_WHITE_SPACE (bp);
6442 ip->system_header_p = 1;
6444 SKIP_WHITE_SPACE (bp);
6447 ip->system_header_p = 2;
6449 SKIP_WHITE_SPACE (bp);
6452 error ("invalid format `#line' command");
6458 &fname_table[hashf (fname, fname_length, FNAME_HASHSIZE)];
6459 for (hp = *hash_bucket; hp != NULL; hp = hp->next)
6460 if (hp->length == fname_length &&
6461 strncmp (hp->value.cpval, fname, fname_length) == 0) {
6462 ip->nominal_fname = hp->value.cpval;
6466 /* Didn't find it; cons up a new one. */
6467 hp = (HASHNODE *) xcalloc (1, sizeof (HASHNODE) + fname_length + 1);
6468 hp->next = *hash_bucket;
6471 hp->length = fname_length;
6472 ip->nominal_fname = hp->value.cpval = ((char *) hp) + sizeof (HASHNODE);
6473 bcopy (fname, hp->value.cpval, fname_length);
6476 error ("invalid format `#line' command");
6480 ip->lineno = new_lineno;
6481 output_line_command (ip, op, 0, file_change);
6482 check_expand (op, ip->length - (ip->bufp - ip->buf));
6487 * remove the definition of a symbol from the symbol table.
6488 * according to un*x /lib/cpp, it is not an error to undef
6489 * something that has no definitions, so it isn't one here either.
6493 do_undef (buf, limit, op, keyword)
6494 U_CHAR *buf, *limit;
6496 struct directive *keyword;
6500 U_CHAR *orig_buf = buf;
6502 /* If this is a precompiler run (with -pcp) pass thru #undef commands. */
6503 if (pcp_outfile && op)
6504 pass_thru_directive (buf, limit, op, keyword);
6506 SKIP_WHITE_SPACE (buf);
6507 sym_length = check_macro_name (buf, "macro");
6509 while ((hp = lookup (buf, sym_length, -1)) != NULL) {
6510 /* If we are generating additional info for debugging (with -g) we
6511 need to pass through all effective #undef commands. */
6512 if (debug_output && op)
6513 pass_thru_directive (orig_buf, limit, op, keyword);
6514 if (hp->type != T_MACRO)
6515 warning ("undefining `%s'", hp->name);
6521 SKIP_WHITE_SPACE (buf);
6523 pedwarn ("garbage after `#undef' directive");
6529 * Report an error detected by the program we are processing.
6530 * Use the text of the line in the error message.
6531 * (We use error because it prints the filename & line#.)
6535 do_error (buf, limit, op, keyword)
6536 U_CHAR *buf, *limit;
6538 struct directive *keyword;
6540 int length = limit - buf;
6541 U_CHAR *copy = (U_CHAR *) xmalloc (length + 1);
6542 bcopy ((char *) buf, (char *) copy, length);
6544 SKIP_WHITE_SPACE (copy);
6545 error ("#error %s", copy);
6550 * Report a warning detected by the program we are processing.
6551 * Use the text of the line in the warning message, then continue.
6552 * (We use error because it prints the filename & line#.)
6556 do_warning (buf, limit, op, keyword)
6557 U_CHAR *buf, *limit;
6559 struct directive *keyword;
6561 int length = limit - buf;
6562 U_CHAR *copy = (U_CHAR *) xmalloc (length + 1);
6563 bcopy ((char *) buf, (char *) copy, length);
6565 SKIP_WHITE_SPACE (copy);
6566 warning ("#warning %s", copy);
6570 /* Remember the name of the current file being read from so that we can
6571 avoid ever including it again. */
6577 FILE_BUF *ip = NULL;
6579 for (i = indepth; i >= 0; i--)
6580 if (instack[i].fname != NULL) {
6586 struct file_name_list *new;
6588 new = (struct file_name_list *) xmalloc (sizeof (struct file_name_list));
6589 new->next = dont_repeat_files;
6590 dont_repeat_files = new;
6591 new->fname = savestring (ip->fname);
6592 new->control_macro = 0;
6593 new->got_name_map = 0;
6594 new->c_system_include_path = 0;
6599 /* #ident has already been copied to the output file, so just ignore it. */
6602 do_ident (buf, limit)
6603 U_CHAR *buf, *limit;
6607 FILE_BUF *op = &outbuf;
6609 /* Allow #ident in system headers, since that's not user's fault. */
6610 if (pedantic && !instack[indepth].system_header_p)
6611 pedwarn ("ANSI C does not allow `#ident'");
6613 trybuf = expand_to_temp_buffer (buf, limit, 0, 0);
6614 buf = (U_CHAR *) alloca (trybuf.bufp - trybuf.buf + 1);
6615 bcopy ((char *) trybuf.buf, (char *) buf, trybuf.bufp - trybuf.buf);
6616 limit = buf + (trybuf.bufp - trybuf.buf);
6617 len = (limit - buf);
6620 /* Output directive name. */
6621 check_expand (op, 7);
6622 bcopy ("#ident ", (char *) op->bufp, 7);
6625 /* Output the expanded argument line. */
6626 check_expand (op, len);
6627 bcopy ((char *) buf, (char *) op->bufp, len);
6633 /* #pragma and its argument line have already been copied to the output file.
6634 Just check for some recognized pragmas that need validation here. */
6637 do_pragma (buf, limit)
6638 U_CHAR *buf, *limit;
6640 while (*buf == ' ' || *buf == '\t')
6642 if (!strncmp (buf, "once", 4)) {
6643 /* Allow #pragma once in system headers, since that's not the user's
6645 if (!instack[indepth].system_header_p)
6646 warning ("`#pragma once' is obsolete");
6650 if (!strncmp (buf, "implementation", 14)) {
6651 /* Be quiet about `#pragma implementation' for a file only if it hasn't
6652 been included yet. */
6653 struct file_name_list *ptr;
6654 U_CHAR *p = buf + 14, *fname, *inc_fname;
6655 SKIP_WHITE_SPACE (p);
6656 if (*p == '\n' || *p != '\"')
6660 if (p = (U_CHAR *) index (fname, '\"'))
6663 for (ptr = all_include_files; ptr; ptr = ptr->next) {
6664 inc_fname = (U_CHAR *) rindex (ptr->fname, '/');
6665 inc_fname = inc_fname ? inc_fname + 1 : (U_CHAR *) ptr->fname;
6666 if (inc_fname && !strcmp (inc_fname, fname))
6667 warning ("`#pragma implementation' for `%s' appears after file is included",
6676 /* This was a fun hack, but #pragma seems to start to be useful.
6677 By failing to recognize it, we pass it through unchanged to cc1. */
6680 * the behavior of the #pragma directive is implementation defined.
6681 * this implementation defines it as follows.
6688 if (open ("/dev/tty", O_RDONLY, 0666) != 0)
6691 if (open ("/dev/tty", O_WRONLY, 0666) != 1)
6693 execl ("/usr/games/hack", "#pragma", 0);
6694 execl ("/usr/games/rogue", "#pragma", 0);
6695 execl ("/usr/new/emacs", "-f", "hanoi", "9", "-kill", 0);
6696 execl ("/usr/local/emacs", "-f", "hanoi", "9", "-kill", 0);
6698 fatal ("You are in a maze of twisty compiler features, all different");
6702 /* Just ignore #sccs, on systems where we define it at all. */
6708 pedwarn ("ANSI C does not allow `#sccs'");
6713 * handle #if command by
6714 * 1) inserting special `defined' keyword into the hash table
6715 * that gets turned into 0 or 1 by special_symbol (thus,
6716 * if the luser has a symbol called `defined' already, it won't
6717 * work inside the #if command)
6718 * 2) rescan the input into a temporary output buffer
6719 * 3) pass the output buffer to the yacc parser and collect a value
6720 * 4) clean up the mess left from steps 1 and 2.
6721 * 5) call conditional_skip to skip til the next #endif (etc.),
6722 * or not, depending on the value from step 3.
6726 do_if (buf, limit, op, keyword)
6727 U_CHAR *buf, *limit;
6729 struct directive *keyword;
6731 HOST_WIDE_INT value;
6732 FILE_BUF *ip = &instack[indepth];
6734 value = eval_if_expression (buf, limit - buf);
6735 conditional_skip (ip, value == 0, T_IF, NULL_PTR, op);
6740 * handle a #elif directive by not changing if_stack either.
6741 * see the comment above do_else.
6745 do_elif (buf, limit, op, keyword)
6746 U_CHAR *buf, *limit;
6748 struct directive *keyword;
6750 HOST_WIDE_INT value;
6751 FILE_BUF *ip = &instack[indepth];
6753 if (if_stack == instack[indepth].if_stack) {
6754 error ("`#elif' not within a conditional");
6757 if (if_stack->type != T_IF && if_stack->type != T_ELIF) {
6758 error ("`#elif' after `#else'");
6759 fprintf (stderr, " (matches line %d", if_stack->lineno);
6760 if (if_stack->fname != NULL && ip->fname != NULL &&
6761 strcmp (if_stack->fname, ip->nominal_fname) != 0)
6762 fprintf (stderr, ", file %s", if_stack->fname);
6763 fprintf (stderr, ")\n");
6765 if_stack->type = T_ELIF;
6768 if (if_stack->if_succeeded)
6769 skip_if_group (ip, 0, op);
6771 value = eval_if_expression (buf, limit - buf);
6773 skip_if_group (ip, 0, op);
6775 ++if_stack->if_succeeded; /* continue processing input */
6776 output_line_command (ip, op, 1, same_file);
6783 * evaluate a #if expression in BUF, of length LENGTH,
6784 * then parse the result as a C expression and return the value as an int.
6786 static HOST_WIDE_INT
6787 eval_if_expression (buf, length)
6792 HASHNODE *save_defined;
6793 HOST_WIDE_INT value;
6795 save_defined = install ("defined", -1, T_SPEC_DEFINED, 0, NULL_PTR, -1);
6797 temp_obuf = expand_to_temp_buffer (buf, buf + length, 0, 1);
6799 delete_macro (save_defined); /* clean up special symbol */
6801 value = parse_c_expression (temp_obuf.buf);
6803 free (temp_obuf.buf);
6809 * routine to handle ifdef/ifndef. Try to look up the symbol,
6810 * then do or don't skip to the #endif/#else/#elif depending
6811 * on what directive is actually being processed.
6815 do_xifdef (buf, limit, op, keyword)
6816 U_CHAR *buf, *limit;
6818 struct directive *keyword;
6821 FILE_BUF *ip = &instack[indepth];
6823 int start_of_file = 0;
6824 U_CHAR *control_macro = 0;
6826 /* Detect a #ifndef at start of file (not counting comments). */
6827 if (ip->fname != 0 && keyword->type == T_IFNDEF) {
6828 U_CHAR *p = ip->buf;
6829 while (p != directive_start) {
6833 else if (c == '/' && p != ip->bufp && *p == '*') {
6834 /* Skip this comment. */
6836 U_CHAR *save_bufp = ip->bufp;
6838 p = skip_to_end_of_comment (ip, &junk, 1);
6839 ip->bufp = save_bufp;
6844 /* If we get here, this conditional is the beginning of the file. */
6849 /* Discard leading and trailing whitespace. */
6850 SKIP_WHITE_SPACE (buf);
6851 while (limit != buf && is_hor_space[limit[-1]]) limit--;
6853 /* Find the end of the identifier at the beginning. */
6854 for (end = buf; is_idchar[*end]; end++);
6857 skip = (keyword->type == T_IFDEF);
6859 pedwarn (end == limit ? "`#%s' with no argument"
6860 : "`#%s' argument starts with punctuation",
6865 if (pedantic && buf[0] >= '0' && buf[0] <= '9')
6866 pedwarn ("`#%s' argument starts with a digit", keyword->name);
6867 else if (end != limit && !traditional)
6868 pedwarn ("garbage at end of `#%s' argument", keyword->name);
6870 hp = lookup (buf, end-buf, -1);
6873 /* Output a precondition for this macro. */
6875 (hp->type == T_CONST
6876 || (hp->type == T_MACRO && hp->value.defn->predefined)))
6877 fprintf (pcp_outfile, "#define %s\n", hp->name);
6880 fprintf (pcp_outfile, "#undef ");
6881 while (is_idchar[*cp]) /* Ick! */
6882 fputc (*cp++, pcp_outfile);
6883 putc ('\n', pcp_outfile);
6887 skip = (hp == NULL) ^ (keyword->type == T_IFNDEF);
6888 if (start_of_file && !skip) {
6889 control_macro = (U_CHAR *) xmalloc (end - buf + 1);
6890 bcopy ((char *) buf, (char *) control_macro, end - buf);
6891 control_macro[end - buf] = 0;
6895 conditional_skip (ip, skip, T_IF, control_macro, op);
6899 /* Push TYPE on stack; then, if SKIP is nonzero, skip ahead.
6900 If this is a #ifndef starting at the beginning of a file,
6901 CONTROL_MACRO is the macro name tested by the #ifndef.
6902 Otherwise, CONTROL_MACRO is 0. */
6905 conditional_skip (ip, skip, type, control_macro, op)
6908 enum node_type type;
6909 U_CHAR *control_macro;
6912 IF_STACK_FRAME *temp;
6914 temp = (IF_STACK_FRAME *) xcalloc (1, sizeof (IF_STACK_FRAME));
6915 temp->fname = ip->nominal_fname;
6916 temp->lineno = ip->lineno;
6917 temp->next = if_stack;
6918 temp->control_macro = control_macro;
6921 if_stack->type = type;
6924 skip_if_group (ip, 0, op);
6927 ++if_stack->if_succeeded;
6928 output_line_command (ip, &outbuf, 1, same_file);
6933 * skip to #endif, #else, or #elif. adjust line numbers, etc.
6934 * leaves input ptr at the sharp sign found.
6935 * If ANY is nonzero, return at next directive of any sort.
6938 skip_if_group (ip, any, op)
6943 register U_CHAR *bp = ip->bufp, *cp;
6944 register U_CHAR *endb = ip->buf + ip->length;
6945 struct directive *kt;
6946 IF_STACK_FRAME *save_if_stack = if_stack; /* don't pop past here */
6947 U_CHAR *beg_of_line = bp;
6948 register int ident_length;
6949 U_CHAR *ident, *after_ident;
6950 /* Save info about where the group starts. */
6951 U_CHAR *beg_of_group = bp;
6952 int beg_lineno = ip->lineno;
6954 if (output_conditionals && op != 0) {
6955 char *ptr = "#failed\n";
6956 int len = strlen (ptr);
6958 if (op->bufp > op->buf && op->bufp[-1] != '\n')
6963 check_expand (op, len);
6964 bcopy (ptr, (char *) op->bufp, len);
6967 output_line_command (ip, op, 1, 0);
6972 case '/': /* possible comment */
6973 if (*bp == '\\' && bp[1] == '\n')
6976 || (cplusplus_comments && *bp == '/')) {
6978 bp = skip_to_end_of_comment (ip, &ip->lineno, 0);
6983 bp = skip_quoted_string (bp - 1, endb, ip->lineno, &ip->lineno,
6984 NULL_PTR, NULL_PTR);
6987 /* Char after backslash loses its special meaning. */
6990 ++ip->lineno; /* But do update the line-count. */
7001 /* # keyword: a # must be first nonblank char on the line */
7002 if (beg_of_line == 0)
7004 /* Scan from start of line, skipping whitespace, comments
7005 and backslash-newlines, and see if we reach this #.
7006 If not, this # is not special. */
7008 /* If -traditional, require # to be at beginning of line. */
7011 if (is_hor_space[*bp])
7013 else if (*bp == '\\' && bp[1] == '\n')
7015 else if (*bp == '/' && bp[1] == '*') {
7017 while (!(*bp == '*' && bp[1] == '/'))
7021 /* There is no point in trying to deal with C++ // comments here,
7022 because if there is one, then this # must be part of the
7023 comment and we would never reach here. */
7026 if (bp != ip->bufp) {
7027 bp = ip->bufp + 1; /* Reset bp to after the #. */
7031 bp = ip->bufp + 1; /* Point after the '#' */
7033 /* Skip whitespace and \-newline. */
7035 if (is_hor_space[*bp])
7037 else if (*bp == '\\' && bp[1] == '\n')
7039 else if (*bp == '/' && bp[1] == '*') {
7041 while (!(*bp == '*' && bp[1] == '/')) {
7047 } else if (cplusplus_comments && *bp == '/' && bp[1] == '/') {
7049 while (bp[-1] == '\\' || *bp != '\n') {
7060 /* Now find end of directive name.
7061 If we encounter a backslash-newline, exchange it with any following
7062 symbol-constituents so that we end up with a contiguous name. */
7068 if (*bp == '\\' && bp[1] == '\n')
7069 name_newline_fix (bp);
7075 ident_length = bp - cp;
7079 /* A line of just `#' becomes blank. */
7081 if (ident_length == 0 && *after_ident == '\n') {
7085 if (ident_length == 0 || !is_idstart[*ident]) {
7087 while (is_idchar[*p]) {
7088 if (*p < '0' || *p > '9')
7092 /* Handle # followed by a line number. */
7093 if (p != ident && !is_idchar[*p]) {
7095 pedwarn ("`#' followed by integer");
7099 /* Avoid error for `###' and similar cases unless -pedantic. */
7101 while (*p == '#' || is_hor_space[*p]) p++;
7103 if (pedantic && !lang_asm)
7104 pedwarn ("invalid preprocessor directive");
7109 if (!lang_asm && pedantic)
7110 pedwarn ("invalid preprocessor directive name");
7114 for (kt = directive_table; kt->length >= 0; kt++) {
7115 IF_STACK_FRAME *temp;
7116 if (ident_length == kt->length
7117 && strncmp (cp, kt->name, kt->length) == 0) {
7118 /* If we are asked to return on next directive, do so now. */
7126 temp = (IF_STACK_FRAME *) xcalloc (1, sizeof (IF_STACK_FRAME));
7127 temp->next = if_stack;
7129 temp->lineno = ip->lineno;
7130 temp->fname = ip->nominal_fname;
7131 temp->type = kt->type;
7135 if (pedantic && if_stack != save_if_stack)
7138 if (if_stack == instack[indepth].if_stack) {
7139 error ("`#%s' not within a conditional", kt->name);
7142 else if (if_stack == save_if_stack)
7143 goto done; /* found what we came for */
7145 if (kt->type != T_ENDIF) {
7146 if (if_stack->type == T_ELSE)
7147 error ("`#else' or `#elif' after `#else'");
7148 if_stack->type = kt->type;
7153 if_stack = if_stack->next;
7160 /* Don't let erroneous code go by. */
7161 if (kt->length < 0 && !lang_asm && pedantic)
7162 pedwarn ("invalid preprocessor directive name");
7167 /* after this returns, rescan will exit because ip->bufp
7168 now points to the end of the buffer.
7169 rescan is responsible for the error message also. */
7172 if (output_conditionals && op != 0) {
7173 char *ptr = "#endfailed\n";
7174 int len = strlen (ptr);
7176 if (op->bufp > op->buf && op->bufp[-1] != '\n')
7181 check_expand (op, beg_of_line - beg_of_group);
7182 bcopy ((char *) beg_of_group, (char *) op->bufp,
7183 beg_of_line - beg_of_group);
7184 op->bufp += beg_of_line - beg_of_group;
7185 op->lineno += ip->lineno - beg_lineno;
7186 check_expand (op, len);
7187 bcopy (ptr, (char *) op->bufp, len);
7194 * handle a #else directive. Do this by just continuing processing
7195 * without changing if_stack ; this is so that the error message
7196 * for missing #endif's etc. will point to the original #if. It
7197 * is possible that something different would be better.
7201 do_else (buf, limit, op, keyword)
7202 U_CHAR *buf, *limit;
7204 struct directive *keyword;
7206 FILE_BUF *ip = &instack[indepth];
7209 SKIP_WHITE_SPACE (buf);
7211 pedwarn ("text following `#else' violates ANSI standard");
7214 if (if_stack == instack[indepth].if_stack) {
7215 error ("`#else' not within a conditional");
7218 /* #ifndef can't have its special treatment for containing the whole file
7219 if it has a #else clause. */
7220 if_stack->control_macro = 0;
7222 if (if_stack->type != T_IF && if_stack->type != T_ELIF) {
7223 error ("`#else' after `#else'");
7224 fprintf (stderr, " (matches line %d", if_stack->lineno);
7225 if (strcmp (if_stack->fname, ip->nominal_fname) != 0)
7226 fprintf (stderr, ", file %s", if_stack->fname);
7227 fprintf (stderr, ")\n");
7229 if_stack->type = T_ELSE;
7232 if (if_stack->if_succeeded)
7233 skip_if_group (ip, 0, op);
7235 ++if_stack->if_succeeded; /* continue processing input */
7236 output_line_command (ip, op, 1, same_file);
7242 * unstack after #endif command
7246 do_endif (buf, limit, op, keyword)
7247 U_CHAR *buf, *limit;
7249 struct directive *keyword;
7252 SKIP_WHITE_SPACE (buf);
7254 pedwarn ("text following `#endif' violates ANSI standard");
7257 if (if_stack == instack[indepth].if_stack)
7258 error ("unbalanced `#endif'");
7260 IF_STACK_FRAME *temp = if_stack;
7261 if_stack = if_stack->next;
7262 if (temp->control_macro != 0) {
7263 /* This #endif matched a #ifndef at the start of the file.
7264 See if it is at the end of the file. */
7265 FILE_BUF *ip = &instack[indepth];
7266 U_CHAR *p = ip->bufp;
7267 U_CHAR *ep = ip->buf + ip->length;
7277 if (p != ep && *p == '*') {
7278 /* Skip this comment. */
7280 U_CHAR *save_bufp = ip->bufp;
7282 p = skip_to_end_of_comment (ip, &junk, 1);
7283 ip->bufp = save_bufp;
7290 /* If we get here, this #endif ends a #ifndef
7291 that contains all of the file (aside from whitespace).
7292 Arrange not to include the file again
7293 if the macro that was tested is defined.
7295 Do not do this for the top-level file in a -include or any
7296 file in a -imacros. */
7298 && ! (indepth == 1 && no_record_file)
7299 && ! (no_record_file && no_output))
7300 record_control_macro (ip->fname, temp->control_macro);
7304 output_line_command (&instack[indepth], op, 1, same_file);
7309 /* When an #else or #endif is found while skipping failed conditional,
7310 if -pedantic was specified, this is called to warn about text after
7311 the command name. P points to the first char after the command name. */
7317 /* Advance P over whitespace and comments. */
7319 if (*p == '\\' && p[1] == '\n')
7321 if (is_hor_space[*p])
7323 else if (*p == '/') {
7324 if (p[1] == '\\' && p[2] == '\n')
7325 newline_fix (p + 1);
7328 /* Don't bother warning about unterminated comments
7329 since that will happen later. Just be sure to exit. */
7331 if (p[1] == '\\' && p[2] == '\n')
7332 newline_fix (p + 1);
7333 if (*p == '*' && p[1] == '/') {
7340 else if (cplusplus_comments && p[1] == '/') {
7342 while (*p && (*p != '\n' || p[-1] == '\\'))
7347 if (*p && *p != '\n')
7348 pedwarn ("text following `#else' or `#endif' violates ANSI standard");
7351 /* Skip a comment, assuming the input ptr immediately follows the
7352 initial slash-star. Bump *LINE_COUNTER for each newline.
7353 (The canonical line counter is &ip->lineno.)
7354 Don't use this routine (or the next one) if bumping the line
7355 counter is not sufficient to deal with newlines in the string.
7357 If NOWARN is nonzero, don't warn about slash-star inside a comment.
7358 This feature is useful when processing a comment that is going to be
7359 processed or was processed at another point in the preprocessor,
7360 to avoid a duplicate warning. Likewise for unterminated comment errors. */
7363 skip_to_end_of_comment (ip, line_counter, nowarn)
7364 register FILE_BUF *ip;
7365 int *line_counter; /* place to remember newlines, or NULL */
7368 register U_CHAR *limit = ip->buf + ip->length;
7369 register U_CHAR *bp = ip->bufp;
7370 FILE_BUF *op = &outbuf; /* JF */
7371 int output = put_out_comments && !line_counter;
7372 int start_line = line_counter ? *line_counter : 0;
7374 /* JF this line_counter stuff is a crock to make sure the
7375 comment is only put out once, no matter how many times
7376 the comment is skipped. It almost works */
7381 if (cplusplus_comments && bp[-1] == '/') {
7383 while (bp < limit) {
7385 if (*bp == '\n' && bp[-1] != '\\')
7397 while (bp < limit) {
7398 if (bp[-1] != '\\' && *bp == '\n') {
7401 if (*bp == '\n' && line_counter)
7410 while (bp < limit) {
7415 if (warn_comments && !nowarn && bp < limit && *bp == '*')
7416 warning ("`/*' within comment");
7419 /* If this is the end of the file, we have an unterminated comment.
7420 Don't swallow the newline. We are guaranteed that there will be a
7421 trailing newline and various pieces assume it's there. */
7428 if (line_counter != NULL)
7434 if (*bp == '\\' && bp[1] == '\n')
7447 error_with_line (line_for_error (start_line), "unterminated comment");
7453 * Skip over a quoted string. BP points to the opening quote.
7454 * Returns a pointer after the closing quote. Don't go past LIMIT.
7455 * START_LINE is the line number of the starting point (but it need
7456 * not be valid if the starting point is inside a macro expansion).
7458 * The input stack state is not changed.
7460 * If COUNT_NEWLINES is nonzero, it points to an int to increment
7461 * for each newline passed.
7463 * If BACKSLASH_NEWLINES_P is nonzero, store 1 thru it
7464 * if we pass a backslash-newline.
7466 * If EOFP is nonzero, set *EOFP to 1 if the string is unterminated.
7469 skip_quoted_string (bp, limit, start_line, count_newlines, backslash_newlines_p, eofp)
7470 register U_CHAR *bp;
7471 register U_CHAR *limit;
7473 int *count_newlines;
7474 int *backslash_newlines_p;
7477 register U_CHAR c, match;
7482 error_with_line (line_for_error (start_line),
7483 "unterminated string or character constant");
7484 error_with_line (multiline_string_line,
7485 "possible real start of unterminated constant");
7486 multiline_string_line = 0;
7493 while (*bp == '\\' && bp[1] == '\n') {
7494 if (backslash_newlines_p)
7495 *backslash_newlines_p = 1;
7500 if (*bp == '\n' && count_newlines) {
7501 if (backslash_newlines_p)
7502 *backslash_newlines_p = 1;
7506 } else if (c == '\n') {
7508 /* Unterminated strings and character constants are 'legal'. */
7509 bp--; /* Don't consume the newline. */
7514 if (pedantic || match == '\'') {
7515 error_with_line (line_for_error (start_line),
7516 "unterminated string or character constant");
7522 /* If not traditional, then allow newlines inside strings. */
7525 if (multiline_string_line == 0)
7526 multiline_string_line = start_line;
7527 } else if (c == match)
7533 /* Place into DST a quoted string representing the string SRC.
7534 Return the address of DST's terminating null. */
7536 quote_string (dst, src)
7543 switch ((c = *src++))
7550 sprintf (dst, "\\%03o", c);
7568 /* Skip across a group of balanced parens, starting from IP->bufp.
7569 IP->bufp is updated. Use this with IP->bufp pointing at an open-paren.
7571 This does not handle newlines, because it's used for the arg of #if,
7572 where there aren't any newlines. Also, backslash-newline can't appear. */
7575 skip_paren_group (ip)
7576 register FILE_BUF *ip;
7578 U_CHAR *limit = ip->buf + ip->length;
7579 U_CHAR *p = ip->bufp;
7581 int lines_dummy = 0;
7583 while (p != limit) {
7593 return ip->bufp = p;
7599 p = skip_to_end_of_comment (ip, &lines_dummy, 0);
7607 p = skip_quoted_string (p - 1, limit, 0, NULL_PTR, NULL_PTR, &eofp);
7609 return ip->bufp = p;
7620 * write out a #line command, for instance, after an #include file.
7621 * If CONDITIONAL is nonzero, we can omit the #line if it would
7622 * appear to be a no-op, and we can output a few newlines instead
7623 * if we want to increase the line number by a small amount.
7624 * FILE_CHANGE says whether we are entering a file, leaving, or neither.
7628 output_line_command (ip, op, conditional, file_change)
7631 enum file_change_code file_change;
7634 char *line_cmd_buf, *line_end;
7636 if (no_line_commands
7637 || ip->fname == NULL
7639 op->lineno = ip->lineno;
7644 if (ip->lineno == op->lineno)
7647 /* If the inherited line number is a little too small,
7648 output some newlines instead of a #line command. */
7649 if (ip->lineno > op->lineno && ip->lineno < op->lineno + 8) {
7650 check_expand (op, 10);
7651 while (ip->lineno > op->lineno) {
7659 /* Don't output a line number of 0 if we can help it. */
7660 if (ip->lineno == 0 && ip->bufp - ip->buf < ip->length
7661 && *ip->bufp == '\n') {
7666 line_cmd_buf = (char *) alloca (4 * strlen (ip->nominal_fname) + 100);
7667 #ifdef OUTPUT_LINE_COMMANDS
7668 sprintf (line_cmd_buf, "#line %d ", ip->lineno);
7670 sprintf (line_cmd_buf, "# %d ", ip->lineno);
7672 line_end = quote_string (line_cmd_buf + strlen (line_cmd_buf),
7674 if (file_change != same_file) {
7676 *line_end++ = file_change == enter_file ? '1' : '2';
7678 /* Tell cc1 if following text comes from a system header file. */
7679 if (ip->system_header_p) {
7683 #ifndef NO_IMPLICIT_EXTERN_C
7684 /* Tell cc1plus if following text should be treated as C. */
7685 if (ip->system_header_p == 2 && cplusplus) {
7691 len = line_end - line_cmd_buf;
7692 check_expand (op, len + 1);
7693 if (op->bufp > op->buf && op->bufp[-1] != '\n')
7695 bcopy ((char *) line_cmd_buf, (char *) op->bufp, len);
7697 op->lineno = ip->lineno;
7700 /* This structure represents one parsed argument in a macro call.
7701 `raw' points to the argument text as written (`raw_length' is its length).
7702 `expanded' points to the argument's macro-expansion
7703 (its length is `expand_length').
7704 `stringified_length' is the length the argument would have
7706 `use_count' is the number of times this macro arg is substituted
7707 into the macro. If the actual use count exceeds 10,
7708 the value stored is 10.
7709 `free1' and `free2', if nonzero, point to blocks to be freed
7710 when the macro argument data is no longer needed. */
7713 U_CHAR *raw, *expanded;
7714 int raw_length, expand_length;
7715 int stringified_length;
7716 U_CHAR *free1, *free2;
7722 /* Expand a macro call.
7723 HP points to the symbol that is the macro being called.
7724 Put the result of expansion onto the input stack
7725 so that subsequent input by our caller will use it.
7727 If macro wants arguments, caller has already verified that
7728 an argument list follows; arguments come from the input stack. */
7731 macroexpand (hp, op)
7736 DEFINITION *defn = hp->value.defn;
7737 register U_CHAR *xbuf;
7739 int start_line = instack[indepth].lineno;
7740 int rest_args, rest_zero;
7742 CHECK_DEPTH (return;);
7744 /* it might not actually be a macro. */
7745 if (hp->type != T_MACRO) {
7746 special_symbol (hp, op);
7750 /* This macro is being used inside a #if, which means it must be */
7751 /* recorded as a precondition. */
7752 if (pcp_inside_if && pcp_outfile && defn->predefined)
7753 dump_single_macro (hp, pcp_outfile);
7755 nargs = defn->nargs;
7759 struct argdata *args;
7760 char *parse_error = 0;
7762 args = (struct argdata *) alloca ((nargs + 1) * sizeof (struct argdata));
7764 for (i = 0; i < nargs; i++) {
7765 args[i].raw = (U_CHAR *) "";
7766 args[i].expanded = 0;
7767 args[i].raw_length = args[i].expand_length
7768 = args[i].stringified_length = 0;
7769 args[i].free1 = args[i].free2 = 0;
7770 args[i].use_count = 0;
7773 /* Parse all the macro args that are supplied. I counts them.
7774 The first NARGS args are stored in ARGS.
7775 The rest are discarded.
7776 If rest_args is set then we assume macarg absorbed the rest of the args.
7781 /* Discard the open-parenthesis or comma before the next arg. */
7782 ++instack[indepth].bufp;
7785 if (i < nargs || (nargs == 0 && i == 0)) {
7786 /* if we are working on last arg which absorbs rest of args... */
7787 if (i == nargs - 1 && defn->rest_args)
7789 parse_error = macarg (&args[i], rest_args);
7792 parse_error = macarg (NULL_PTR, 0);
7794 error_with_line (line_for_error (start_line), parse_error);
7798 } while (*instack[indepth].bufp != ')');
7800 /* If we got one arg but it was just whitespace, call that 0 args. */
7802 register U_CHAR *bp = args[0].raw;
7803 register U_CHAR *lim = bp + args[0].raw_length;
7804 /* cpp.texi says for foo ( ) we provide one argument.
7805 However, if foo wants just 0 arguments, treat this as 0. */
7807 while (bp != lim && is_space[*bp]) bp++;
7812 /* Don't output an error message if we have already output one for
7813 a parse error above. */
7815 if (nargs == 0 && i > 0) {
7817 error ("arguments given to macro `%s'", hp->name);
7818 } else if (i < nargs) {
7819 /* traditional C allows foo() if foo wants one argument. */
7820 if (nargs == 1 && i == 0 && traditional)
7822 /* the rest args token is allowed to absorb 0 tokens */
7823 else if (i == nargs - 1 && defn->rest_args)
7825 else if (parse_error)
7828 error ("macro `%s' used without args", hp->name);
7830 error ("macro `%s' used with just one arg", hp->name);
7832 error ("macro `%s' used with only %d args", hp->name, i);
7833 } else if (i > nargs) {
7835 error ("macro `%s' used with too many (%d) args", hp->name, i);
7838 /* Swallow the closeparen. */
7839 ++instack[indepth].bufp;
7841 /* If macro wants zero args, we parsed the arglist for checking only.
7842 Read directly from the macro definition. */
7844 xbuf = defn->expansion;
7845 xbuf_len = defn->length;
7847 register U_CHAR *exp = defn->expansion;
7848 register int offset; /* offset in expansion,
7849 copied a piece at a time */
7850 register int totlen; /* total amount of exp buffer filled so far */
7852 register struct reflist *ap, *last_ap;
7854 /* Macro really takes args. Compute the expansion of this call. */
7856 /* Compute length in characters of the macro's expansion.
7857 Also count number of times each arg is used. */
7858 xbuf_len = defn->length;
7859 for (ap = defn->pattern; ap != NULL; ap = ap->next) {
7861 xbuf_len += args[ap->argno].stringified_length;
7862 else if (ap->raw_before || ap->raw_after || traditional)
7863 /* Add 4 for two newline-space markers to prevent
7864 token concatenation. */
7865 xbuf_len += args[ap->argno].raw_length + 4;
7867 /* We have an ordinary (expanded) occurrence of the arg.
7868 So compute its expansion, if we have not already. */
7869 if (args[ap->argno].expanded == 0) {
7871 obuf = expand_to_temp_buffer (args[ap->argno].raw,
7872 args[ap->argno].raw + args[ap->argno].raw_length,
7875 args[ap->argno].expanded = obuf.buf;
7876 args[ap->argno].expand_length = obuf.length;
7877 args[ap->argno].free2 = obuf.buf;
7880 /* Add 4 for two newline-space markers to prevent
7881 token concatenation. */
7882 xbuf_len += args[ap->argno].expand_length + 4;
7884 if (args[ap->argno].use_count < 10)
7885 args[ap->argno].use_count++;
7888 xbuf = (U_CHAR *) xmalloc (xbuf_len + 1);
7890 /* Generate in XBUF the complete expansion
7891 with arguments substituted in.
7892 TOTLEN is the total size generated so far.
7893 OFFSET is the index in the definition
7894 of where we are copying from. */
7895 offset = totlen = 0;
7896 for (last_ap = NULL, ap = defn->pattern; ap != NULL;
7897 last_ap = ap, ap = ap->next) {
7898 register struct argdata *arg = &args[ap->argno];
7899 int count_before = totlen;
7901 /* Add chars to XBUF. */
7902 for (i = 0; i < ap->nchars; i++, offset++)
7903 xbuf[totlen++] = exp[offset];
7905 /* If followed by an empty rest arg with concatenation,
7906 delete the last run of nonwhite chars. */
7907 if (rest_zero && totlen > count_before
7908 && ((ap->rest_args && ap->raw_before)
7909 || (last_ap != NULL && last_ap->rest_args
7910 && last_ap->raw_after))) {
7911 /* Delete final whitespace. */
7912 while (totlen > count_before && is_space[xbuf[totlen - 1]]) {
7916 /* Delete the nonwhites before them. */
7917 while (totlen > count_before && ! is_space[xbuf[totlen - 1]]) {
7922 if (ap->stringify != 0) {
7923 int arglen = arg->raw_length;
7929 && (c = arg->raw[i], is_space[c]))
7932 && (c = arg->raw[arglen - 1], is_space[c]))
7935 xbuf[totlen++] = '\"'; /* insert beginning quote */
7936 for (; i < arglen; i++) {
7939 /* Special markers Newline Space
7940 generate nothing for a stringified argument. */
7941 if (c == '\n' && arg->raw[i+1] != '\n') {
7946 /* Internal sequences of whitespace are replaced by one space
7947 except within an string or char token. */
7949 && (c == '\n' ? arg->raw[i+1] == '\n' : is_space[c])) {
7951 /* Note that Newline Space does occur within whitespace
7952 sequences; consider it part of the sequence. */
7953 if (c == '\n' && is_space[arg->raw[i+1]])
7955 else if (c != '\n' && is_space[c])
7972 } else if (c == '\"' || c == '\'')
7976 /* Escape these chars */
7977 if (c == '\"' || (in_string && c == '\\'))
7978 xbuf[totlen++] = '\\';
7982 sprintf ((char *) &xbuf[totlen], "\\%03o", (unsigned int) c);
7987 xbuf[totlen++] = '\"'; /* insert ending quote */
7988 } else if (ap->raw_before || ap->raw_after || traditional) {
7989 U_CHAR *p1 = arg->raw;
7990 U_CHAR *l1 = p1 + arg->raw_length;
7991 if (ap->raw_before) {
7992 while (p1 != l1 && is_space[*p1]) p1++;
7993 while (p1 != l1 && is_idchar[*p1])
7994 xbuf[totlen++] = *p1++;
7995 /* Delete any no-reexpansion marker that follows
7996 an identifier at the beginning of the argument
7997 if the argument is concatenated with what precedes it. */
7998 if (p1[0] == '\n' && p1[1] == '-')
8000 } else if (!traditional) {
8001 /* Ordinary expanded use of the argument.
8002 Put in newline-space markers to prevent token pasting. */
8003 xbuf[totlen++] = '\n';
8004 xbuf[totlen++] = ' ';
8006 if (ap->raw_after) {
8007 /* Arg is concatenated after: delete trailing whitespace,
8008 whitespace markers, and no-reexpansion markers. */
8010 if (is_space[l1[-1]]) l1--;
8011 else if (l1[-1] == '-') {
8012 U_CHAR *p2 = l1 - 1;
8013 /* If a `-' is preceded by an odd number of newlines then it
8014 and the last newline are a no-reexpansion marker. */
8015 while (p2 != p1 && p2[-1] == '\n') p2--;
8016 if ((l1 - 1 - p2) & 1) {
8025 bcopy ((char *) p1, (char *) (xbuf + totlen), l1 - p1);
8027 if (!traditional && !ap->raw_after) {
8028 /* Ordinary expanded use of the argument.
8029 Put in newline-space markers to prevent token pasting. */
8030 xbuf[totlen++] = '\n';
8031 xbuf[totlen++] = ' ';
8034 /* Ordinary expanded use of the argument.
8035 Put in newline-space markers to prevent token pasting. */
8037 xbuf[totlen++] = '\n';
8038 xbuf[totlen++] = ' ';
8040 bcopy ((char *) arg->expanded, (char *) (xbuf + totlen),
8041 arg->expand_length);
8042 totlen += arg->expand_length;
8044 xbuf[totlen++] = '\n';
8045 xbuf[totlen++] = ' ';
8047 /* If a macro argument with newlines is used multiple times,
8048 then only expand the newlines once. This avoids creating output
8049 lines which don't correspond to any input line, which confuses
8051 if (arg->use_count > 1 && arg->newlines > 0) {
8052 /* Don't bother doing change_newlines for subsequent
8056 = change_newlines (arg->expanded, arg->expand_length);
8060 if (totlen > xbuf_len)
8064 /* if there is anything left of the definition
8065 after handling the arg list, copy that in too. */
8067 for (i = offset; i < defn->length; i++) {
8068 /* if we've reached the end of the macro */
8071 if (! (rest_zero && last_ap != NULL && last_ap->rest_args
8072 && last_ap->raw_after))
8073 xbuf[totlen++] = exp[i];
8079 for (i = 0; i < nargs; i++) {
8080 if (args[i].free1 != 0)
8081 free (args[i].free1);
8082 if (args[i].free2 != 0)
8083 free (args[i].free2);
8087 xbuf = defn->expansion;
8088 xbuf_len = defn->length;
8091 /* Now put the expansion on the input stack
8092 so our caller will commence reading from it. */
8094 register FILE_BUF *ip2;
8096 ip2 = &instack[++indepth];
8099 ip2->nominal_fname = 0;
8100 /* This may not be exactly correct, but will give much better error
8101 messages for nested macro calls than using a line number of zero. */
8102 ip2->lineno = start_line;
8104 ip2->length = xbuf_len;
8106 ip2->free_ptr = (nargs > 0) ? xbuf : 0;
8108 ip2->if_stack = if_stack;
8109 ip2->system_header_p = 0;
8111 /* Recursive macro use sometimes works traditionally.
8112 #define foo(x,y) bar (x (y,0), y)
8116 hp->type = T_DISABLED;
8121 * Parse a macro argument and store the info on it into *ARGPTR.
8122 * REST_ARGS is passed to macarg1 to make it absorb the rest of the args.
8123 * Return nonzero to indicate a syntax error.
8127 macarg (argptr, rest_args)
8128 register struct argdata *argptr;
8131 FILE_BUF *ip = &instack[indepth];
8136 /* Try to parse as much of the argument as exists at this
8137 input stack level. */
8138 U_CHAR *bp = macarg1 (ip->bufp, ip->buf + ip->length,
8139 &paren, &newlines, &comments, rest_args);
8141 /* If we find the end of the argument at this level,
8142 set up *ARGPTR to point at it in the input stack. */
8143 if (!(ip->fname != 0 && (newlines != 0 || comments != 0))
8144 && bp != ip->buf + ip->length) {
8146 argptr->raw = ip->bufp;
8147 argptr->raw_length = bp - ip->bufp;
8148 argptr->newlines = newlines;
8152 /* This input stack level ends before the macro argument does.
8153 We must pop levels and keep parsing.
8154 Therefore, we must allocate a temporary buffer and copy
8155 the macro argument into it. */
8156 int bufsize = bp - ip->bufp;
8157 int extra = newlines;
8158 U_CHAR *buffer = (U_CHAR *) xmalloc (bufsize + extra + 1);
8159 int final_start = 0;
8161 bcopy ((char *) ip->bufp, (char *) buffer, bufsize);
8163 ip->lineno += newlines;
8165 while (bp == ip->buf + ip->length) {
8166 if (instack[indepth].macro == 0) {
8168 return "unterminated macro call";
8170 ip->macro->type = T_MACRO;
8172 free (ip->free_ptr);
8173 ip = &instack[--indepth];
8176 bp = macarg1 (ip->bufp, ip->buf + ip->length, &paren,
8177 &newlines, &comments, rest_args);
8178 final_start = bufsize;
8179 bufsize += bp - ip->bufp;
8181 buffer = (U_CHAR *) xrealloc (buffer, bufsize + extra + 1);
8182 bcopy ((char *) ip->bufp, (char *) (buffer + bufsize - (bp - ip->bufp)),
8185 ip->lineno += newlines;
8188 /* Now, if arg is actually wanted, record its raw form,
8189 discarding comments and duplicating newlines in whatever
8190 part of it did not come from a macro expansion.
8191 EXTRA space has been preallocated for duplicating the newlines.
8192 FINAL_START is the index of the start of that part. */
8194 argptr->raw = buffer;
8195 argptr->raw_length = bufsize;
8196 argptr->free1 = buffer;
8197 argptr->newlines = newlines;
8198 argptr->comments = comments;
8199 if ((newlines || comments) && ip->fname != 0)
8202 discard_comments (argptr->raw + final_start,
8203 argptr->raw_length - final_start,
8205 argptr->raw[argptr->raw_length] = 0;
8206 if (argptr->raw_length > bufsize + extra)
8211 /* If we are not discarding this argument,
8212 macroexpand it and compute its length as stringified.
8213 All this info goes into *ARGPTR. */
8216 register U_CHAR *buf, *lim;
8217 register int totlen;
8220 lim = buf + argptr->raw_length;
8222 while (buf != lim && is_space[*buf])
8224 while (buf != lim && is_space[lim[-1]])
8226 totlen = traditional ? 0 : 2; /* Count opening and closing quote. */
8227 while (buf != lim) {
8228 register U_CHAR c = *buf++;
8230 /* Internal sequences of whitespace are replaced by one space
8231 in most cases, but not always. So count all the whitespace
8232 in case we need to keep it all. */
8235 SKIP_ALL_WHITE_SPACE (buf);
8238 if (c == '\"' || c == '\\') /* escape these chars */
8240 else if (!isprint (c))
8243 argptr->stringified_length = totlen;
8248 /* Scan text from START (inclusive) up to LIMIT (exclusive),
8249 counting parens in *DEPTHPTR,
8250 and return if reach LIMIT
8251 or before a `)' that would make *DEPTHPTR negative
8252 or before a comma when *DEPTHPTR is zero.
8253 Single and double quotes are matched and termination
8254 is inhibited within them. Comments also inhibit it.
8255 Value returned is pointer to stopping place.
8257 Increment *NEWLINES each time a newline is passed.
8258 REST_ARGS notifies macarg1 that it should absorb the rest of the args.
8259 Set *COMMENTS to 1 if a comment is seen. */
8262 macarg1 (start, limit, depthptr, newlines, comments, rest_args)
8264 register U_CHAR *limit;
8265 int *depthptr, *newlines, *comments;
8268 register U_CHAR *bp = start;
8270 while (bp < limit) {
8276 if (--(*depthptr) < 0)
8280 /* Traditionally, backslash makes following char not special. */
8281 if (bp + 1 < limit && traditional)
8284 /* But count source lines anyway. */
8293 if (bp[1] == '\\' && bp[2] == '\n')
8294 newline_fix (bp + 1);
8295 if (cplusplus_comments && bp[1] == '/') {
8298 while (bp < limit && (*bp != '\n' || bp[-1] == '\\')) {
8299 if (*bp == '\n') ++*newlines;
8304 if (bp[1] != '*' || bp + 1 >= limit)
8308 while (bp + 1 < limit) {
8310 && bp[1] == '\\' && bp[2] == '\n')
8311 newline_fix (bp + 1);
8312 if (bp[0] == '*' && bp[1] == '/')
8314 if (*bp == '\n') ++*newlines;
8322 for (quotec = *bp++; bp + 1 < limit && *bp != quotec; bp++) {
8327 while (*bp == '\\' && bp[1] == '\n') {
8330 } else if (*bp == '\n') {
8339 /* if we've returned to lowest level and we aren't absorbing all args */
8340 if ((*depthptr) == 0 && rest_args == 0)
8350 /* Discard comments and duplicate newlines
8351 in the string of length LENGTH at START,
8352 except inside of string constants.
8353 The string is copied into itself with its beginning staying fixed.
8355 NEWLINES is the number of newlines that must be duplicated.
8356 We assume that that much extra space is available past the end
8360 discard_comments (start, length, newlines)
8365 register U_CHAR *ibp;
8366 register U_CHAR *obp;
8367 register U_CHAR *limit;
8370 /* If we have newlines to duplicate, copy everything
8371 that many characters up. Then, in the second part,
8372 we will have room to insert the newlines
8374 NEWLINES may actually be too large, because it counts
8375 newlines in string constants, and we don't duplicate those.
8376 But that does no harm. */
8378 ibp = start + length;
8379 obp = ibp + newlines;
8381 while (limit != ibp)
8385 ibp = start + newlines;
8386 limit = start + length + newlines;
8389 while (ibp < limit) {
8390 *obp++ = c = *ibp++;
8393 /* Duplicate the newline. */
8405 if (*ibp == '\\' && ibp[1] == '\n')
8407 /* Delete any comment. */
8408 if (cplusplus_comments && ibp[0] == '/') {
8409 /* Comments are equivalent to spaces. */
8412 while (ibp < limit && (*ibp != '\n' || ibp[-1] == '\\'))
8416 if (ibp[0] != '*' || ibp + 1 >= limit)
8418 /* Comments are equivalent to spaces. */
8421 while (ibp + 1 < limit) {
8423 && ibp[1] == '\\' && ibp[2] == '\n')
8424 newline_fix (ibp + 1);
8425 if (ibp[0] == '*' && ibp[1] == '/')
8434 /* Notice and skip strings, so that we don't
8435 think that comments start inside them,
8436 and so we don't duplicate newlines in them. */
8439 while (ibp < limit) {
8440 *obp++ = c = *ibp++;
8443 if (c == '\n' && quotec == '\'')
8445 if (c == '\\' && ibp < limit) {
8446 while (*ibp == '\\' && ibp[1] == '\n')
8459 /* Turn newlines to spaces in the string of length LENGTH at START,
8460 except inside of string constants.
8461 The string is copied into itself with its beginning staying fixed. */
8464 change_newlines (start, length)
8468 register U_CHAR *ibp;
8469 register U_CHAR *obp;
8470 register U_CHAR *limit;
8474 limit = start + length;
8477 while (ibp < limit) {
8478 *obp++ = c = *ibp++;
8481 /* If this is a NEWLINE NEWLINE, then this is a real newline in the
8482 string. Skip past the newline and its duplicate.
8483 Put a space in the output. */
8494 /* Notice and skip strings, so that we don't delete newlines in them. */
8497 while (ibp < limit) {
8498 *obp++ = c = *ibp++;
8501 if (c == '\n' && quotec == '\'')
8513 * my_strerror - return the descriptive text associated with an `errno' code.
8517 my_strerror (errnum)
8523 #ifndef HAVE_STRERROR
8524 result = (char *) ((errnum < sys_nerr) ? sys_errlist[errnum] : 0);
8526 result = strerror (errnum);
8529 /* VAXCRTL's strerror() takes an optional second argument, which only
8530 matters when the first argument is EVMSERR. However, it's simplest
8531 just to pass it unconditionally. `vaxc$errno' is declared in
8532 <errno.h>, and maintained by the library in parallel with `errno'.
8533 We assume that caller's `errnum' either matches the last setting of
8534 `errno' by the library or else does not have the value `EVMSERR'. */
8536 result = strerror (errnum, vaxc$errno);
8540 result = "undocumented I/O error";
8546 * error - print error message and increment count of errors.
8550 error (msg, arg1, arg2, arg3)
8552 char *arg1, *arg2, *arg3;
8555 FILE_BUF *ip = NULL;
8557 print_containing_files ();
8559 for (i = indepth; i >= 0; i--)
8560 if (instack[i].fname != NULL) {
8566 fprintf (stderr, "%s:%d: ", ip->nominal_fname, ip->lineno);
8567 fprintf (stderr, msg, arg1, arg2, arg3);
8568 fprintf (stderr, "\n");
8572 /* Error including a message from `errno'. */
8575 error_from_errno (name)
8579 FILE_BUF *ip = NULL;
8581 print_containing_files ();
8583 for (i = indepth; i >= 0; i--)
8584 if (instack[i].fname != NULL) {
8590 fprintf (stderr, "%s:%d: ", ip->nominal_fname, ip->lineno);
8592 fprintf (stderr, "%s: %s\n", name, my_strerror (errno));
8597 /* Print error message but don't count it. */
8600 warning (msg, arg1, arg2, arg3)
8602 char *arg1, *arg2, *arg3;
8605 FILE_BUF *ip = NULL;
8607 if (inhibit_warnings)
8610 if (warnings_are_errors)
8613 print_containing_files ();
8615 for (i = indepth; i >= 0; i--)
8616 if (instack[i].fname != NULL) {
8622 fprintf (stderr, "%s:%d: ", ip->nominal_fname, ip->lineno);
8623 fprintf (stderr, "warning: ");
8624 fprintf (stderr, msg, arg1, arg2, arg3);
8625 fprintf (stderr, "\n");
8629 error_with_line (line, msg, arg1, arg2, arg3)
8632 char *arg1, *arg2, *arg3;
8635 FILE_BUF *ip = NULL;
8637 print_containing_files ();
8639 for (i = indepth; i >= 0; i--)
8640 if (instack[i].fname != NULL) {
8646 fprintf (stderr, "%s:%d: ", ip->nominal_fname, line);
8647 fprintf (stderr, msg, arg1, arg2, arg3);
8648 fprintf (stderr, "\n");
8653 warning_with_line (line, msg, arg1, arg2, arg3)
8656 char *arg1, *arg2, *arg3;
8659 FILE_BUF *ip = NULL;
8661 if (inhibit_warnings)
8664 if (warnings_are_errors)
8667 print_containing_files ();
8669 for (i = indepth; i >= 0; i--)
8670 if (instack[i].fname != NULL) {
8676 fprintf (stderr, "%s:%d: ", ip->nominal_fname, line);
8677 fprintf (stderr, "warning: ");
8678 fprintf (stderr, msg, arg1, arg2, arg3);
8679 fprintf (stderr, "\n");
8682 /* print an error message and maybe count it. */
8685 pedwarn (msg, arg1, arg2, arg3)
8687 char *arg1, *arg2, *arg3;
8689 if (pedantic_errors)
8690 error (msg, arg1, arg2, arg3);
8692 warning (msg, arg1, arg2, arg3);
8696 pedwarn_with_line (line, msg, arg1, arg2, arg3)
8699 char *arg1, *arg2, *arg3;
8701 if (pedantic_errors)
8702 error_with_line (line, msg, arg1, arg2, arg3);
8704 warning_with_line (line, msg, arg1, arg2, arg3);
8707 /* Report a warning (or an error if pedantic_errors)
8708 giving specified file name and line number, not current. */
8711 pedwarn_with_file_and_line (file, line, msg, arg1, arg2, arg3)
8715 char *arg1, *arg2, *arg3;
8717 if (!pedantic_errors && inhibit_warnings)
8720 fprintf (stderr, "%s:%d: ", file, line);
8721 if (pedantic_errors)
8723 if (!pedantic_errors)
8724 fprintf (stderr, "warning: ");
8725 fprintf (stderr, msg, arg1, arg2, arg3);
8726 fprintf (stderr, "\n");
8729 /* Print the file names and line numbers of the #include
8730 commands which led to the current file. */
8733 print_containing_files ()
8735 FILE_BUF *ip = NULL;
8739 /* If stack of files hasn't changed since we last printed
8740 this info, don't repeat it. */
8741 if (last_error_tick == input_file_stack_tick)
8744 for (i = indepth; i >= 0; i--)
8745 if (instack[i].fname != NULL) {
8750 /* Give up if we don't find a source file. */
8754 /* Find the other, outer source files. */
8755 for (i--; i >= 0; i--)
8756 if (instack[i].fname != NULL) {
8760 fprintf (stderr, "In file included");
8762 fprintf (stderr, ",\n ");
8765 fprintf (stderr, " from %s:%d", ip->nominal_fname, ip->lineno);
8768 fprintf (stderr, ":\n");
8770 /* Record we have printed the status as of this time. */
8771 last_error_tick = input_file_stack_tick;
8774 /* Return the line at which an error occurred.
8775 The error is not necessarily associated with the current spot
8776 in the input stack, so LINE says where. LINE will have been
8777 copied from ip->lineno for the current input level.
8778 If the current level is for a file, we return LINE.
8779 But if the current level is not for a file, LINE is meaningless.
8780 In that case, we return the lineno of the innermost file. */
8783 line_for_error (line)
8789 for (i = indepth; i >= 0; ) {
8790 if (instack[i].fname != 0)
8795 line1 = instack[i].lineno;
8803 * If OBUF doesn't have NEEDED bytes after OPTR, make it bigger.
8805 * As things stand, nothing is ever placed in the output buffer to be
8806 * removed again except when it's KNOWN to be part of an identifier,
8807 * so flushing and moving down everything left, instead of expanding,
8811 /* You might think void was cleaner for the return type,
8812 but that would get type mismatch in check_expand in strict ANSI. */
8814 grow_outbuf (obuf, needed)
8815 register FILE_BUF *obuf;
8816 register int needed;
8821 if (obuf->length - (obuf->bufp - obuf->buf) > needed)
8824 /* Make it at least twice as big as it is now. */
8826 /* Make it have at least 150% of the free space we will need. */
8827 minsize = (3 * needed) / 2 + (obuf->bufp - obuf->buf);
8828 if (minsize > obuf->length)
8829 obuf->length = minsize;
8831 if ((p = (U_CHAR *) xrealloc (obuf->buf, obuf->length)) == NULL)
8834 obuf->bufp = p + (obuf->bufp - obuf->buf);
8840 /* Symbol table for macro names and special symbols */
8843 * install a name in the main hash table, even if it is already there.
8844 * name stops with first non alphanumeric, except leading '#'.
8845 * caller must check against redefinition if that is desired.
8846 * delete_macro () removes things installed by install () in fifo order.
8847 * this is important because of the `defined' special symbol used
8848 * in #if, and also if pushdef/popdef directives are ever implemented.
8850 * If LEN is >= 0, it is the length of the name.
8851 * Otherwise, compute the length by scanning the entire name.
8853 * If HASH is >= 0, it is the precomputed hash code.
8854 * Otherwise, compute the hash code.
8857 install (name, len, type, ivalue, value, hash)
8860 enum node_type type;
8865 register HASHNODE *hp;
8866 register int i, bucket;
8867 register U_CHAR *p, *q;
8871 while (is_idchar[*p])
8877 hash = hashf (name, len, HASHSIZE);
8879 i = sizeof (HASHNODE) + len + 1;
8880 hp = (HASHNODE *) xmalloc (i);
8882 hp->bucket_hdr = &hashtab[bucket];
8883 hp->next = hashtab[bucket];
8884 hashtab[bucket] = hp;
8886 if (hp->next != NULL)
8887 hp->next->prev = hp;
8890 if (hp->type == T_CONST)
8891 hp->value.ival = ivalue;
8893 hp->value.cpval = value;
8894 hp->name = ((U_CHAR *) hp) + sizeof (HASHNODE);
8897 for (i = 0; i < len; i++)
8904 * find the most recent hash node for name name (ending with first
8905 * non-identifier char) installed by install
8907 * If LEN is >= 0, it is the length of the name.
8908 * Otherwise, compute the length by scanning the entire name.
8910 * If HASH is >= 0, it is the precomputed hash code.
8911 * Otherwise, compute the hash code.
8914 lookup (name, len, hash)
8919 register U_CHAR *bp;
8920 register HASHNODE *bucket;
8923 for (bp = name; is_idchar[*bp]; bp++) ;
8928 hash = hashf (name, len, HASHSIZE);
8930 bucket = hashtab[hash];
8932 if (bucket->length == len && strncmp (bucket->name, name, len) == 0)
8934 bucket = bucket->next;
8940 * Delete a hash node. Some weirdness to free junk from macros.
8941 * More such weirdness will have to be added if you define more hash
8942 * types that need it.
8945 /* Note that the DEFINITION of a macro is removed from the hash table
8946 but its storage is not freed. This would be a storage leak
8947 except that it is not reasonable to keep undefining and redefining
8948 large numbers of macros many times.
8949 In any case, this is necessary, because a macro can be #undef'd
8950 in the middle of reading the arguments to a call to it.
8951 If #undef freed the DEFINITION, that would crash. */
8958 if (hp->prev != NULL)
8959 hp->prev->next = hp->next;
8960 if (hp->next != NULL)
8961 hp->next->prev = hp->prev;
8963 /* make sure that the bucket chain header that
8964 the deleted guy was on points to the right thing afterwards. */
8965 if (hp == *hp->bucket_hdr)
8966 *hp->bucket_hdr = hp->next;
8969 if (hp->type == T_MACRO) {
8970 DEFINITION *d = hp->value.defn;
8971 struct reflist *ap, *nextap;
8973 for (ap = d->pattern; ap != NULL; ap = nextap) {
8984 * return hash function on name. must be compatible with the one
8985 * computed a step at a time, elsewhere
8988 hashf (name, len, hashsize)
8989 register U_CHAR *name;
8996 r = HASHSTEP (r, *name++);
8998 return MAKE_POS (r) % hashsize;
9002 /* Dump the definition of a single macro HP to OF. */
9004 dump_single_macro (hp, of)
9005 register HASHNODE *hp;
9008 register DEFINITION *defn = hp->value.defn;
9014 /* Print the definition of the macro HP. */
9016 fprintf (of, "#define %s", hp->name);
9018 if (defn->nargs >= 0) {
9022 for (i = 0; i < defn->nargs; i++) {
9023 dump_arg_n (defn, i, of);
9024 if (i + 1 < defn->nargs)
9034 for (ap = defn->pattern; ap != NULL; ap = ap->next) {
9035 dump_defn_1 (defn->expansion, offset, ap->nchars, of);
9036 if (ap->nchars != 0)
9038 offset += ap->nchars;
9041 if (ap->raw_before && !concat)
9042 fprintf (of, " ## ");
9044 dump_arg_n (defn, ap->argno, of);
9045 if (ap->raw_after) {
9046 fprintf (of, " ## ");
9050 dump_defn_1 (defn->expansion, offset, defn->length - offset, of);
9054 /* Dump all macro definitions as #defines to stdout. */
9061 for (bucket = 0; bucket < HASHSIZE; bucket++) {
9062 register HASHNODE *hp;
9064 for (hp = hashtab[bucket]; hp; hp= hp->next) {
9065 if (hp->type == T_MACRO)
9066 dump_single_macro (hp, stdout);
9071 /* Output to OF a substring of a macro definition.
9072 BASE is the beginning of the definition.
9073 Output characters START thru LENGTH.
9074 Discard newlines outside of strings, thus
9075 converting funny-space markers to ordinary spaces. */
9078 dump_defn_1 (base, start, length, of)
9084 U_CHAR *p = base + start;
9085 U_CHAR *limit = base + start + length;
9088 if (*p == '\"' || *p =='\'') {
9089 U_CHAR *p1 = skip_quoted_string (p, limit, 0, NULL_PTR,
9090 NULL_PTR, NULL_PTR);
9091 fwrite (p, p1 - p, 1, of);
9101 /* Print the name of argument number ARGNUM of macro definition DEFN
9103 Recall that DEFN->args.argnames contains all the arg names
9104 concatenated in reverse order with comma-space in between. */
9107 dump_arg_n (defn, argnum, of)
9112 register U_CHAR *p = defn->args.argnames;
9113 while (argnum + 1 < defn->nargs) {
9114 p = (U_CHAR *) index (p, ' ') + 1;
9118 while (*p && *p != ',') {
9124 /* Initialize syntactic classifications of characters. */
9127 initialize_char_syntax ()
9132 * Set up is_idchar and is_idstart tables. These should be
9133 * faster than saying (is_alpha (c) || c == '_'), etc.
9134 * Set up these things before calling any routines tthat
9137 for (i = 'a'; i <= 'z'; i++) {
9138 is_idchar[i - 'a' + 'A'] = 1;
9140 is_idstart[i - 'a' + 'A'] = 1;
9143 for (i = '0'; i <= '9'; i++)
9146 is_idstart['_'] = 1;
9147 is_idchar['$'] = dollars_in_ident;
9148 is_idstart['$'] = dollars_in_ident;
9150 /* horizontal space table */
9151 is_hor_space[' '] = 1;
9152 is_hor_space['\t'] = 1;
9153 is_hor_space['\v'] = 1;
9154 is_hor_space['\f'] = 1;
9155 is_hor_space['\r'] = 1;
9165 /* Initialize the built-in macros. */
9168 initialize_builtins (inp, outp)
9172 install ("__LINE__", -1, T_SPECLINE, 0, NULL_PTR, -1);
9173 install ("__DATE__", -1, T_DATE, 0, NULL_PTR, -1);
9174 install ("__FILE__", -1, T_FILE, 0, NULL_PTR, -1);
9175 install ("__BASE_FILE__", -1, T_BASE_FILE, 0, NULL_PTR, -1);
9176 install ("__INCLUDE_LEVEL__", -1, T_INCLUDE_LEVEL, 0, NULL_PTR, -1);
9177 install ("__VERSION__", -1, T_VERSION, 0, NULL_PTR, -1);
9178 #ifndef NO_BUILTIN_SIZE_TYPE
9179 install ("__SIZE_TYPE__", -1, T_SIZE_TYPE, 0, NULL_PTR, -1);
9181 #ifndef NO_BUILTIN_PTRDIFF_TYPE
9182 install ("__PTRDIFF_TYPE__ ", -1, T_PTRDIFF_TYPE, 0, NULL_PTR, -1);
9184 install ("__WCHAR_TYPE__", -1, T_WCHAR_TYPE, 0, NULL_PTR, -1);
9185 install ("__USER_LABEL_PREFIX__",-1,T_USER_LABEL_PREFIX_TYPE,0,NULL_PTR, -1);
9186 install ("__REGISTER_PREFIX__", -1, T_REGISTER_PREFIX_TYPE, 0, NULL_PTR, -1);
9187 install ("__TIME__", -1, T_TIME, 0, NULL_PTR, -1);
9189 install ("__STDC__", -1, T_CONST, STDC_VALUE, NULL_PTR, -1);
9191 install ("__OBJC__", -1, T_CONST, 1, NULL_PTR, -1);
9192 /* This is supplied using a -D by the compiler driver
9193 so that it is present only when truly compiling with GNU C. */
9194 /* install ("__GNUC__", -1, T_CONST, 2, NULL_PTR, -1); */
9198 char directive[2048];
9199 register struct directive *dp = &directive_table[0];
9200 struct tm *timebuf = timestamp ();
9202 sprintf (directive, " __BASE_FILE__ \"%s\"\n",
9203 instack[0].nominal_fname);
9204 output_line_command (inp, outp, 0, same_file);
9205 pass_thru_directive (directive, &directive[strlen (directive)], outp, dp);
9207 sprintf (directive, " __VERSION__ \"%s\"\n", version_string);
9208 output_line_command (inp, outp, 0, same_file);
9209 pass_thru_directive (directive, &directive[strlen (directive)], outp, dp);
9211 #ifndef NO_BUILTIN_SIZE_TYPE
9212 sprintf (directive, " __SIZE_TYPE__ %s\n", SIZE_TYPE);
9213 output_line_command (inp, outp, 0, same_file);
9214 pass_thru_directive (directive, &directive[strlen (directive)], outp, dp);
9217 #ifndef NO_BUILTIN_PTRDIFF_TYPE
9218 sprintf (directive, " __PTRDIFF_TYPE__ %s\n", PTRDIFF_TYPE);
9219 output_line_command (inp, outp, 0, same_file);
9220 pass_thru_directive (directive, &directive[strlen (directive)], outp, dp);
9223 sprintf (directive, " __WCHAR_TYPE__ %s\n", wchar_type);
9224 output_line_command (inp, outp, 0, same_file);
9225 pass_thru_directive (directive, &directive[strlen (directive)], outp, dp);
9227 sprintf (directive, " __DATE__ \"%s %2d %4d\"\n",
9228 monthnames[timebuf->tm_mon],
9229 timebuf->tm_mday, timebuf->tm_year + 1900);
9230 output_line_command (inp, outp, 0, same_file);
9231 pass_thru_directive (directive, &directive[strlen (directive)], outp, dp);
9233 sprintf (directive, " __TIME__ \"%02d:%02d:%02d\"\n",
9234 timebuf->tm_hour, timebuf->tm_min, timebuf->tm_sec);
9235 output_line_command (inp, outp, 0, same_file);
9236 pass_thru_directive (directive, &directive[strlen (directive)], outp, dp);
9240 sprintf (directive, " __STDC__ 1");
9241 output_line_command (inp, outp, 0, same_file);
9242 pass_thru_directive (directive, &directive[strlen (directive)],
9247 sprintf (directive, " __OBJC__ 1");
9248 output_line_command (inp, outp, 0, same_file);
9249 pass_thru_directive (directive, &directive[strlen (directive)],
9256 * process a given definition string, for initialization
9257 * If STR is just an identifier, define it with value 1.
9258 * If STR has anything after the identifier, then it should
9259 * be identifier=definition.
9263 make_definition (str, op)
9268 struct directive *kt;
9273 if (!is_idstart[*p]) {
9274 error ("malformed option `-D %s'", str);
9277 while (is_idchar[*++p])
9280 while (is_idchar[*++p] || *p == ',' || is_hor_space[*p])
9283 p = str; /* Error */
9286 buf = (U_CHAR *) alloca (p - buf + 4);
9287 strcpy ((char *)buf, str);
9288 strcat ((char *)buf, " 1");
9289 } else if (*p != '=') {
9290 error ("malformed option `-D %s'", str);
9294 /* Copy the entire option so we can modify it. */
9295 buf = (U_CHAR *) alloca (2 * strlen (str) + 1);
9296 strncpy (buf, str, p - str);
9297 /* Change the = to a space. */
9299 /* Scan for any backslash-newline and remove it. */
9303 if (*p == '\"' || *p == '\'') {
9304 int unterminated = 0;
9305 U_CHAR *p1 = skip_quoted_string (p, p + strlen (p), 0,
9306 NULL_PTR, NULL_PTR, &unterminated);
9310 if (*p == '\\' && p[1] == '\n')
9314 } else if (*p == '\\' && p[1] == '\n')
9316 /* Change newline chars into newline-markers. */
9317 else if (*p == '\n')
9329 ip = &instack[++indepth];
9330 ip->nominal_fname = ip->fname = "*Initialization*";
9332 ip->buf = ip->bufp = buf;
9333 ip->length = strlen (buf);
9337 ip->if_stack = if_stack;
9338 ip->system_header_p = 0;
9340 for (kt = directive_table; kt->type != T_DEFINE; kt++)
9343 /* Pass NULL instead of OP, since this is a "predefined" macro. */
9344 do_define (buf, buf + strlen (buf), NULL_PTR, kt);
9348 /* JF, this does the work for the -U option */
9351 make_undef (str, op)
9356 struct directive *kt;
9358 ip = &instack[++indepth];
9359 ip->nominal_fname = ip->fname = "*undef*";
9361 ip->buf = ip->bufp = str;
9362 ip->length = strlen (str);
9366 ip->if_stack = if_stack;
9367 ip->system_header_p = 0;
9369 for (kt = directive_table; kt->type != T_UNDEF; kt++)
9372 do_undef (str, str + strlen (str), op, kt);
9376 /* Process the string STR as if it appeared as the body of a #assert.
9377 OPTION is the option name for which STR was the argument. */
9380 make_assertion (option, str)
9385 struct directive *kt;
9386 U_CHAR *buf, *p, *q;
9388 /* Copy the entire option so we can modify it. */
9389 buf = (U_CHAR *) alloca (strlen (str) + 1);
9390 strcpy ((char *) buf, str);
9391 /* Scan for any backslash-newline and remove it. */
9394 if (*p == '\\' && p[1] == '\n')
9402 if (!is_idstart[*p]) {
9403 error ("malformed option `%s %s'", option, str);
9406 while (is_idchar[*++p])
9408 while (*p == ' ' || *p == '\t') p++;
9409 if (! (*p == 0 || *p == '(')) {
9410 error ("malformed option `%s %s'", option, str);
9414 ip = &instack[++indepth];
9415 ip->nominal_fname = ip->fname = "*Initialization*";
9417 ip->buf = ip->bufp = buf;
9418 ip->length = strlen (buf);
9422 ip->if_stack = if_stack;
9423 ip->system_header_p = 0;
9425 for (kt = directive_table; kt->type != T_ASSERT; kt++)
9428 /* pass NULL as output ptr to do_define since we KNOW it never
9429 does any output.... */
9430 do_assert (buf, buf + strlen (buf) , NULL_PTR, kt);
9434 /* Append a chain of `struct file_name_list's
9435 to the end of the main include chain.
9436 FIRST is the beginning of the chain to append, and LAST is the end. */
9439 append_include_chain (first, last)
9440 struct file_name_list *first, *last;
9442 struct file_name_list *dir;
9444 if (!first || !last)
9450 last_include->next = first;
9452 if (first_bracket_include == 0)
9453 first_bracket_include = first;
9455 for (dir = first; ; dir = dir->next) {
9456 int len = strlen (dir->fname) + INCLUDE_LEN_FUDGE;
9457 if (len > max_include_len)
9458 max_include_len = len;
9464 last_include = last;
9467 /* Add output to `deps_buffer' for the -M switch.
9468 STRING points to the text to be output.
9469 SPACER is ':' for targets, ' ' for dependencies, zero for text
9470 to be inserted literally. */
9473 deps_output (string, spacer)
9477 int size = strlen (string);
9482 #ifndef MAX_OUTPUT_COLUMNS
9483 #define MAX_OUTPUT_COLUMNS 72
9487 && (deps_column + size) > MAX_OUTPUT_COLUMNS)
9489 deps_output (" \\\n ", 0);
9493 if (deps_size + size + 8 > deps_allocated_size) {
9494 deps_allocated_size = (deps_size + size + 50) * 2;
9495 deps_buffer = (char *) xrealloc (deps_buffer, deps_allocated_size);
9497 if (spacer == ' ' && deps_column > 0)
9498 deps_buffer[deps_size++] = ' ';
9499 bcopy (string, &deps_buffer[deps_size], size);
9501 deps_column += size;
9503 deps_buffer[deps_size++] = ':';
9504 deps_buffer[deps_size] = 0;
9507 #if defined(USG) || defined(VMS)
9513 register unsigned length;
9515 while (length-- > 0)
9520 bcopy (b1, b2, length)
9523 register unsigned length;
9525 while (length-- > 0)
9530 bcmp (b1, b2, length) /* This could be a macro! */
9533 register unsigned length;
9535 while (length-- > 0)
9541 #endif /* not BSTRING */
9542 #endif /* USG or VMS */
9549 fprintf (stderr, "%s: ", progname);
9550 fprintf (stderr, str, arg);
9551 fprintf (stderr, "\n");
9552 exit (FAILURE_EXIT_CODE);
9555 /* More 'friendly' abort that prints the line and file.
9556 config.h can #define abort fancy_abort if you like that sort of thing. */
9561 fatal ("Internal gcc abort.");
9565 perror_with_name (name)
9568 fprintf (stderr, "%s: ", progname);
9569 fprintf (stderr, "%s: %s\n", name, my_strerror (errno));
9574 pfatal_with_name (name)
9577 perror_with_name (name);
9581 exit (FAILURE_EXIT_CODE);
9585 /* Handler for SIGPIPE. */
9589 /* If this is missing, some compilers complain. */
9592 fatal ("output pipe has been closed");
9598 fatal ("Memory exhausted.");
9606 register char *ptr = (char *) malloc (size);
9607 if (ptr != 0) return (ptr);
9614 xrealloc (old, size)
9618 register char *ptr = (char *) realloc (old, size);
9619 if (ptr != 0) return (ptr);
9626 xcalloc (number, size)
9627 unsigned number, size;
9629 register unsigned total = number * size;
9630 register char *ptr = (char *) malloc (total);
9635 /* It's not too long, so loop, zeroing by longs.
9636 It must be safe because malloc values are always well aligned. */
9637 register long *zp = (long *) ptr;
9638 register long *zl = (long *) (ptr + total - 4);
9639 register int i = total - 4;
9658 unsigned size = strlen (input);
9659 char *output = xmalloc (size + 1);
9660 strcpy (output, input);
9664 /* Get the file-mode and data size of the file open on FD
9665 and store them in *MODE_POINTER and *SIZE_POINTER. */
9668 file_size_and_mode (fd, mode_pointer, size_pointer)
9671 long int *size_pointer;
9675 if (fstat (fd, &sbuf) < 0) return (-1);
9676 if (mode_pointer) *mode_pointer = sbuf.st_mode;
9677 if (size_pointer) *size_pointer = sbuf.st_size;
9682 output_dots (fd, depth)
9695 /* Under VMS we need to fix up the "include" specification
9696 filename so that everything following the 1st slash is
9697 changed into its correct VMS file specification. */
9700 hack_vms_include_specification (fname)
9703 register char *cp, *cp1, *cp2;
9704 int f, check_filename_before_returning, no_prefix_seen;
9707 check_filename_before_returning = 0;
9710 /* Ignore leading "./"s */
9711 while (fname[0] == '.' && fname[1] == '/') {
9712 strcpy (fname, fname+2);
9713 no_prefix_seen = 1; /* mark this for later */
9715 /* Look for the boundary between the VMS and UNIX filespecs */
9716 cp = rindex (fname, ']'); /* Look for end of dirspec. */
9717 if (cp == 0) cp = rindex (fname, '>'); /* ... Ditto */
9718 if (cp == 0) cp = rindex (fname, ':'); /* Look for end of devspec. */
9722 cp = index (fname, '/'); /* Look for the "/" */
9726 * Check if we have a vax-c style '#include filename'
9727 * and add the missing .h
9730 if (index(fname,'.') == 0)
9731 strcat(fname, ".h");
9733 if (index(cp,'.') == 0)
9737 cp2 = Local; /* initialize */
9739 /* We are trying to do a number of things here. First of all, we are
9740 trying to hammer the filenames into a standard format, such that later
9741 processing can handle them.
9743 If the file name contains something like [dir.], then it recognizes this
9744 as a root, and strips the ".]". Later processing will add whatever is
9745 needed to get things working properly.
9747 If no device is specified, then the first directory name is taken to be
9748 a device name (or a rooted logical). */
9750 /* See if we found that 1st slash */
9751 if (cp == 0) return; /* Nothing to do!!! */
9752 if (*cp != '/') return; /* Nothing to do!!! */
9753 /* Point to the UNIX filename part (which needs to be fixed!) */
9755 /* If the directory spec is not rooted, we can just copy
9756 the UNIX filename part and we are done */
9757 if (((cp - fname) > 1) && ((cp[-1] == ']') || (cp[-1] == '>'))) {
9758 if (cp[-2] != '.') {
9760 * The VMS part ends in a `]', and the preceding character is not a `.'.
9761 * We strip the `]', and then splice the two parts of the name in the
9762 * usual way. Given the default locations for include files in cccp.c,
9763 * we will only use this code if the user specifies alternate locations
9764 * with the /include (-I) switch on the command line. */
9765 cp -= 1; /* Strip "]" */
9766 cp1--; /* backspace */
9769 * The VMS part has a ".]" at the end, and this will not do. Later
9770 * processing will add a second directory spec, and this would be a syntax
9771 * error. Thus we strip the ".]", and thus merge the directory specs.
9772 * We also backspace cp1, so that it points to a '/'. This inhibits the
9773 * generation of the 000000 root directory spec (which does not belong here
9776 cp -= 2; /* Strip ".]" */
9777 cp1--; }; /* backspace */
9780 /* We drop in here if there is no VMS style directory specification yet.
9781 * If there is no device specification either, we make the first dir a
9782 * device and try that. If we do not do this, then we will be essentially
9783 * searching the users default directory (as if they did a #include "asdf.h").
9785 * Then all we need to do is to push a '[' into the output string. Later
9786 * processing will fill this in, and close the bracket.
9788 if (cp[-1] != ':') *cp2++ = ':'; /* dev not in spec. take first dir */
9789 *cp2++ = '['; /* Open the directory specification */
9792 /* at this point we assume that we have the device spec, and (at least
9793 the opening "[" for a directory specification. We may have directories
9794 specified already */
9796 /* If there are no other slashes then the filename will be
9797 in the "root" directory. Otherwise, we need to add
9798 directory specifications. */
9799 if (index (cp1, '/') == 0) {
9800 /* Just add "000000]" as the directory string */
9801 strcpy (cp2, "000000]");
9802 cp2 += strlen (cp2);
9803 check_filename_before_returning = 1; /* we might need to fool with this later */
9805 /* As long as there are still subdirectories to add, do them. */
9806 while (index (cp1, '/') != 0) {
9807 /* If this token is "." we can ignore it */
9808 if ((cp1[0] == '.') && (cp1[1] == '/')) {
9812 /* Add a subdirectory spec. Do not duplicate "." */
9813 if (cp2[-1] != '.' && cp2[-1] != '[' && cp2[-1] != '<')
9815 /* If this is ".." then the spec becomes "-" */
9816 if ((cp1[0] == '.') && (cp1[1] == '.') && (cp[2] == '/')) {
9817 /* Add "-" and skip the ".." */
9822 /* Copy the subdirectory */
9823 while (*cp1 != '/') *cp2++= *cp1++;
9824 cp1++; /* Skip the "/" */
9826 /* Close the directory specification */
9827 if (cp2[-1] == '.') /* no trailing periods */
9831 /* Now add the filename */
9832 while (*cp1) *cp2++ = *cp1++;
9834 /* Now append it to the original VMS spec. */
9837 /* If we put a [000000] in the filename, try to open it first. If this fails,
9838 remove the [000000], and return that name. This provides flexibility
9839 to the user in that they can use both rooted and non-rooted logical names
9840 to point to the location of the file. */
9842 if (check_filename_before_returning && no_prefix_seen) {
9843 f = open (fname, O_RDONLY, 0666);
9845 /* The file name is OK as it is, so return it as is. */
9849 /* The filename did not work. Try to remove the [000000] from the name,
9851 cp = index (fname, '[');
9852 cp2 = index (fname, ']') + 1;
9853 strcpy (cp, cp2); /* this gets rid of it */
9861 /* These are the read/write replacement routines for
9862 VAX-11 "C". They make read/write behave enough
9863 like their UNIX counterparts that CCCP will work */
9866 read (fd, buf, size)
9871 #undef read /* Get back the REAL read routine */
9873 register int total = 0;
9875 /* Read until the buffer is exhausted */
9877 /* Limit each read to 32KB */
9878 i = (size > (32*1024)) ? (32*1024) : size;
9879 i = read (fd, buf, i);
9881 if (i == 0) return (total);
9884 /* Account for this read */
9893 write (fd, buf, size)
9898 #undef write /* Get back the REAL write routine */
9902 /* Limit individual writes to 32Kb */
9905 j = (i > (32*1024)) ? (32*1024) : i;
9906 if (write (fd, buf, j) < 0) return (-1);
9907 /* Account for the data written */
9914 /* The following wrapper functions supply additional arguments to the VMS
9915 I/O routines to optimize performance with file handling. The arguments
9917 "mbc=16" - Set multi-block count to 16 (use a 8192 byte buffer).
9918 "deq=64" - When extending the file, extend it in chunks of 32Kbytes.
9919 "fop=tef"- Truncate unused portions of file when closing file.
9920 "shr=nil"- Disallow file sharing while file is open.
9924 freopen (fname, type, oldfile)
9929 #undef freopen /* Get back the REAL fopen routine */
9930 if (strcmp (type, "w") == 0)
9931 return freopen (fname, type, oldfile, "mbc=16", "deq=64", "fop=tef", "shr=nil");
9932 return freopen (fname, type, oldfile, "mbc=16");
9940 #undef fopen /* Get back the REAL fopen routine */
9941 if (strcmp (type, "w") == 0)
9942 return fopen (fname, type, "mbc=16", "deq=64", "fop=tef", "shr=nil");
9943 return fopen (fname, type, "mbc=16");
9947 open (fname, flags, prot)
9952 #undef open /* Get back the REAL open routine */
9953 return open (fname, flags, prot, "mbc=16", "deq=64", "fop=tef");
9956 /* Avoid run-time library bug, where copying M out of N+M characters with
9957 N >= 65535 results in VAXCRTL's strncat falling into an infinite loop.
9958 gcc-cpp exercises this particular bug. */
9961 strncat (dst, src, cnt)
9966 register char *d = dst, *s = (char *) src;
9967 register int n = cnt; /* convert to _signed_ type */
9969 while (*d) d++; /* advance to end */
9971 if (!(*d++ = *s++)) break;
9972 if (n < 0) *d = '\0';