1 /* C Compatible Compiler Preprocessor (CCCP)
2 Copyright (C) 1986, 1987, 1989, 1992 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 */
96 #include <perror.h> /* This defines sys_errlist/sys_nerr properly */
98 #define O_RDONLY 0 /* Open arg for Read/Only */
99 #define O_WRONLY 1 /* Open arg for Write/Only */
100 #define read(fd,buf,size) VMS_read (fd,buf,size)
101 #define write(fd,buf,size) VMS_write (fd,buf,size)
102 #define open(fname,mode,prot) VMS_open (fname,mode,prot)
103 #define fopen(fname,mode) VMS_fopen (fname,mode)
104 #define freopen(fname,mode,ofile) VMS_freopen (fname,mode,ofile)
105 #define strncat(dst,src,cnt) VMS_strncat (dst,src,cnt)
106 static char * VMS_strncat ();
107 static int VMS_read ();
108 static int VMS_write ();
109 static int VMS_open ();
110 static FILE * VMS_fopen ();
111 static FILE * VMS_freopen ();
112 static void hack_vms_include_specification ();
113 typedef struct { unsigned :16, :16, :16; } vms_ino_t;
114 #define ino_t vms_ino_t
115 #define INCLUDE_LEN_FUDGE 10 /* leave room for VMS syntax conversion */
117 #define BSTRING /* VMS/GCC supplies the bstring routines */
118 #endif /* __GNUC__ */
121 extern char *index ();
122 extern char *rindex ();
130 #define MIN(X,Y) ((X) < (Y) ? (X) : (Y))
131 #define MAX(X,Y) ((X) > (Y) ? (X) : (Y))
133 /* Find the largest host integer type and set its size and type. */
135 #ifndef HOST_BITS_PER_WIDE_INT
137 #if HOST_BITS_PER_LONG > HOST_BITS_PER_INT
138 #define HOST_BITS_PER_WIDE_INT HOST_BITS_PER_LONG
139 #define HOST_WIDE_INT long
141 #define HOST_BITS_PER_WIDE_INT HOST_BITS_PER_INT
142 #define HOST_WIDE_INT int
148 #define S_ISREG(m) (((m) & S_IFMT) == S_IFREG)
152 #define S_ISDIR(m) (((m) & S_IFMT) == S_IFDIR)
155 /* Define a generic NULL if one hasn't already been defined. */
162 #if defined (USE_PROTOTYPES) ? USE_PROTOTYPES : defined (__STDC__)
163 #define GENERIC_PTR void *
165 #define GENERIC_PTR char *
170 #define NULL_PTR ((GENERIC_PTR)0)
173 #ifndef INCLUDE_LEN_FUDGE
174 #define INCLUDE_LEN_FUDGE 0
177 /* Forward declarations. */
183 /* External declarations. */
185 extern char *getenv ();
186 extern FILE *fdopen ();
187 extern char *version_string;
188 extern struct tm *localtime ();
190 extern char *sys_errlist[];
196 /* Forward declarations. */
203 #if defined(USG) || defined(VMS)
211 /* These functions are declared to return int instead of void since they
212 are going to be placed in a table and some old compilers have trouble with
213 pointers to functions returning void. */
215 static int do_define ();
216 static int do_line ();
217 static int do_include ();
218 static int do_undef ();
219 static int do_error ();
220 static int do_pragma ();
221 static int do_ident ();
223 static int do_xifdef ();
224 static int do_else ();
225 static int do_elif ();
226 static int do_endif ();
227 static int do_sccs ();
228 static int do_once ();
229 static int do_assert ();
230 static int do_unassert ();
231 static int do_warning ();
233 static void add_import ();
234 static void append_include_chain ();
235 static void deps_output ();
236 static void make_undef ();
237 static void make_definition ();
238 static void make_assertion ();
239 static void path_include ();
240 static void initialize_builtins ();
241 static void initialize_char_syntax ();
242 static void dump_arg_n ();
243 static void dump_defn_1 ();
244 static void delete_macro ();
245 static void trigraph_pcp ();
246 static void rescan ();
247 static void finclude ();
248 static void validate_else ();
249 static int comp_def_part ();
250 static void error_from_errno ();
251 static void error_with_line ();
253 void pedwarn_with_line ();
254 static void pedwarn_with_file_and_line ();
255 static void fatal ();
257 static void pfatal_with_name ();
258 static void perror_with_name ();
259 static void pipe_closed ();
260 static void print_containing_files ();
261 static int lookup_import ();
262 static int redundant_include_p ();
263 static is_system_include ();
264 static int check_preconditions ();
265 static void pcfinclude ();
266 static void pcstring_used ();
267 static void write_output ();
268 static int check_macro_name ();
269 static int compare_defs ();
270 static int compare_token_lists ();
271 static int eval_if_expression ();
272 static int discard_comments ();
273 static int change_newlines ();
274 static int line_for_error ();
276 static int file_size_and_mode ();
278 static struct arglist *read_token_list ();
279 static void free_token_list ();
281 static struct hashnode *install ();
282 struct hashnode *lookup ();
284 static struct assertion_hashnode *assertion_install ();
285 static struct assertion_hashnode *assertion_lookup ();
287 static char *xrealloc ();
288 static char *xcalloc ();
289 static char *savestring ();
291 static void delete_assertion ();
292 static void macroexpand ();
293 static void dump_all_macros ();
294 static void conditional_skip ();
295 static void skip_if_group ();
296 static void output_line_command ();
298 /* Last arg to output_line_command. */
299 enum file_change_code {same_file, enter_file, leave_file};
301 static int grow_outbuf ();
302 static int handle_directive ();
303 static void memory_full ();
305 static U_CHAR *macarg1 ();
306 static char *macarg ();
308 static U_CHAR *skip_to_end_of_comment ();
309 static U_CHAR *skip_quoted_string ();
310 static U_CHAR *skip_paren_group ();
312 static char *check_precompiled ();
313 /* static struct macrodef create_definition (); [moved below] */
314 static void dump_single_macro ();
316 #ifndef FAILURE_EXIT_CODE
317 #define FAILURE_EXIT_CODE 33 /* gnu cc command understands this */
320 #ifndef SUCCESS_EXIT_CODE
321 #define SUCCESS_EXIT_CODE 0 /* 0 means success on Unix. */
324 /* Name under which this program was invoked. */
326 static char *progname;
328 /* Nonzero means use extra default include directories for C++. */
330 static int cplusplus;
332 /* Nonzero means handle cplusplus style comments */
334 static int cplusplus_comments;
336 /* Nonzero means handle #import, for objective C. */
340 /* Nonzero means this is an assembly file, and allow
341 unknown directives, which could be comments. */
345 /* Current maximum length of directory names in the search path
346 for include files. (Altered as we get more of them.) */
348 static int max_include_len;
350 /* Nonzero means turn NOTREACHED into #pragma NOTREACHED etc */
354 /* Nonzero means copy comments into the output file. */
356 static int put_out_comments = 0;
358 /* Nonzero means don't process the ANSI trigraph sequences. */
360 static int no_trigraphs = 0;
362 /* Nonzero means print the names of included files rather than
363 the preprocessed output. 1 means just the #include "...",
364 2 means #include <...> as well. */
366 static int print_deps = 0;
368 /* Nonzero means print names of header files (-H). */
370 static int print_include_names = 0;
372 /* Nonzero means don't output line number information. */
374 static int no_line_commands;
376 /* dump_only means inhibit output of the preprocessed text
377 and instead output the definitions of all user-defined
378 macros in a form suitable for use as input to cccp.
379 dump_names means pass #define and the macro name through to output.
380 dump_definitions means pass the whole definition (plus #define) through
383 static enum {dump_none, dump_only, dump_names, dump_definitions}
384 dump_macros = dump_none;
386 /* Nonzero means pass all #define and #undef directives which we actually
387 process through to the output stream. This feature is used primarily
388 to allow cc1 to record the #defines and #undefs for the sake of
389 debuggers which understand about preprocessor macros, but it may
390 also be useful with -E to figure out how symbols are defined, and
391 where they are defined. */
392 static int debug_output = 0;
394 /* Nonzero indicates special processing used by the pcp program. The
395 special effects of this mode are:
397 Inhibit all macro expansion, except those inside #if directives.
399 Process #define directives normally, and output their contents
402 Output preconditions to pcp_outfile indicating all the relevant
403 preconditions for use of this file in a later cpp run.
405 static FILE *pcp_outfile;
407 /* Nonzero means we are inside an IF during a -pcp run. In this mode
408 macro expansion is done, and preconditions are output for all macro
409 uses requiring them. */
410 static int pcp_inside_if;
412 /* Nonzero means never to include precompiled files.
413 This is 1 since there's no way now to make precompiled files,
414 so it's not worth testing for them. */
415 static int no_precomp = 1;
417 /* Nonzero means give all the error messages the ANSI standard requires. */
421 /* Nonzero means try to make failure to fit ANSI C an error. */
423 static int pedantic_errors;
425 /* Nonzero means don't print warning messages. -w. */
427 static int inhibit_warnings = 0;
429 /* Nonzero means warn if slash-star appears in a comment. */
431 static int warn_comments;
433 /* Nonzero means warn if a macro argument is (or would be)
434 stringified with -traditional. */
436 static int warn_stringify;
438 /* Nonzero means warn if there are any trigraphs. */
440 static int warn_trigraphs;
442 /* Nonzero means warn if #import is used. */
444 static int warn_import = 1;
446 /* Nonzero means turn warnings into errors. */
448 static int warnings_are_errors;
450 /* Nonzero means try to imitate old fashioned non-ANSI preprocessor. */
454 /* Nonzero causes output not to be done,
455 but directives such as #define that have side effects
458 static int no_output;
460 /* Nonzero means that we have finished processing the command line options.
461 This flag is used to decide whether or not to issue certain errors
464 static int done_initializing = 0;
466 /* Line where a newline was first seen in a string constant. */
468 static int multiline_string_line = 0;
470 /* I/O buffer structure.
471 The `fname' field is nonzero for source files and #include files
472 and for the dummy text used for -D and -U.
473 It is zero for rescanning results of macro expansion
474 and for expanding macro arguments. */
475 #define INPUT_STACK_MAX 200
476 static struct file_buf {
478 /* Filename specified with #line command. */
480 /* Record where in the search path this file was found.
481 For #include_next. */
482 struct file_name_list *dir;
487 /* Macro that this level is the expansion of.
488 Included so that we can reenable the macro
489 at the end of this level. */
490 struct hashnode *macro;
491 /* Value of if_stack at start of this file.
492 Used to prohibit unmatched #endif (etc) in an include file. */
493 struct if_stack *if_stack;
494 /* Object to be freed at end of input at this level. */
496 /* True if this is a header file included using <FILENAME>. */
497 char system_header_p;
498 } instack[INPUT_STACK_MAX];
500 static int last_error_tick; /* Incremented each time we print it. */
501 static int input_file_stack_tick; /* Incremented when the status changes. */
503 /* Current nesting level of input sources.
504 `instack[indepth]' is the level currently being read. */
505 static int indepth = -1;
506 #define CHECK_DEPTH(code) \
507 if (indepth >= (INPUT_STACK_MAX - 1)) \
509 error_with_line (line_for_error (instack[indepth].lineno), \
510 "macro or `#include' recursion too deep"); \
514 /* Current depth in #include directives that use <...>. */
515 static int system_include_depth = 0;
517 typedef struct file_buf FILE_BUF;
519 /* The output buffer. Its LENGTH field is the amount of room allocated
520 for the buffer, not the number of chars actually present. To get
521 that, subtract outbuf.buf from outbuf.bufp. */
523 #define OUTBUF_SIZE 10 /* initial size of output buffer */
524 static FILE_BUF outbuf;
526 /* Grow output buffer OBUF points at
527 so it can hold at least NEEDED more chars. */
529 #define check_expand(OBUF, NEEDED) \
530 (((OBUF)->length - ((OBUF)->bufp - (OBUF)->buf) <= (NEEDED)) \
531 ? grow_outbuf ((OBUF), (NEEDED)) : 0)
533 struct file_name_list
535 struct file_name_list *next;
537 /* If the following is nonzero, it is a macro name.
538 Don't include the file again if that macro is defined. */
539 U_CHAR *control_macro;
542 /* #include "file" looks in source file dir, then stack. */
543 /* #include <file> just looks in the stack. */
544 /* -I directories are added to the end, then the defaults are added. */
545 static struct default_include { char *fname; int cplusplus; } include_defaults_array[]
546 #ifdef INCLUDE_DEFAULTS
550 /* Pick up GNU C++ specific include files. */
551 { GPLUSPLUS_INCLUDE_DIR, 1},
553 /* This is the dir for fixincludes. Put it just before
554 the files that we fix. */
555 { GCC_INCLUDE_DIR, 0},
556 /* For cross-compilation, this dir name is generated
557 automatically in Makefile.in. */
558 { CROSS_INCLUDE_DIR, 0 },
559 /* This is another place that the target system's headers might be. */
560 { TOOL_INCLUDE_DIR, 0},
561 #else /* not CROSS_COMPILE */
562 /* Until we are really clear on what people will use this dir for
563 in a native compiler, it's not clear where in the order it belongs. */
564 { TOOL_INCLUDE_DIR, 0},
565 /* This should be /use/local/include and should come before
566 the fixincludes-fixed header files. */
567 { LOCAL_INCLUDE_DIR, 0},
568 /* This is the dir for fixincludes. Put it just before
569 the files that we fix. */
570 { GCC_INCLUDE_DIR, 0},
571 /* Some systems have an extra dir of include files. */
572 #ifdef SYSTEM_INCLUDE_DIR
573 { SYSTEM_INCLUDE_DIR, 0},
575 { STANDARD_INCLUDE_DIR, 0},
576 #endif /* not CROSS_COMPILE */
579 #endif /* no INCLUDE_DEFAULTS */
581 /* The code looks at the defaults through this pointer, rather than through
582 the constant structure above. This pointer gets changed if an environment
583 variable specifies other defaults. */
584 static struct default_include *include_defaults = include_defaults_array;
586 static struct file_name_list *include = 0; /* First dir to search */
587 /* First dir to search for <file> */
588 /* This is the first element to use for #include <...>.
589 If it is 0, use the entire chain for such includes. */
590 static struct file_name_list *first_bracket_include = 0;
591 /* This is the first element in the chain that corresponds to
592 a directory of system header files. */
593 static struct file_name_list *first_system_include = 0;
594 static struct file_name_list *last_include = 0; /* Last in chain */
596 /* Chain of include directories to put at the end of the other chain. */
597 static struct file_name_list *after_include = 0;
598 static struct file_name_list *last_after_include = 0; /* Last in chain */
600 /* List of included files that contained #pragma once. */
601 static struct file_name_list *dont_repeat_files = 0;
603 /* List of other included files.
604 If ->control_macro if nonzero, the file had a #ifndef
605 around the entire contents, and ->control_macro gives the macro name. */
606 static struct file_name_list *all_include_files = 0;
608 /* Directory prefix that should replace `/usr' in the standard
609 include file directories. */
610 static char *include_prefix;
612 /* Global list of strings read in from precompiled files. This list
613 is kept in the order the strings are read in, with new strings being
614 added at the end through stringlist_tailp. We use this list to output
615 the strings at the end of the run.
617 static STRINGDEF *stringlist;
618 static STRINGDEF **stringlist_tailp = &stringlist;
621 /* Structure returned by create_definition */
622 typedef struct macrodef MACRODEF;
625 struct definition *defn;
630 static struct macrodef create_definition ();
633 /* Structure allocated for every #define. For a simple replacement
636 nargs = -1, the `pattern' list is null, and the expansion is just
637 the replacement text. Nargs = 0 means a functionlike macro with no args,
639 #define getchar() getc (stdin) .
640 When there are args, the expansion is the replacement text with the
641 args squashed out, and the reflist is a list describing how to
642 build the output from the input: e.g., "3 chars, then the 1st arg,
643 then 9 chars, then the 3rd arg, then 0 chars, then the 2nd arg".
644 The chars here come from the expansion. Whatever is left of the
645 expansion after the last arg-occurrence is copied after that arg.
646 Note that the reflist can be arbitrarily long---
647 its length depends on the number of times the arguments appear in
648 the replacement text, not how many args there are. Example:
649 #define f(x) x+x+x+x+x+x+x would have replacement text "++++++" and
651 { (0, 1), (1, 1), (1, 1), ..., (1, 1), NULL }
652 where (x, y) means (nchars, argno). */
654 typedef struct definition DEFINITION;
657 int length; /* length of expansion string */
658 int predefined; /* True if the macro was builtin or */
659 /* came from the command line */
661 int line; /* Line number of definition */
662 char *file; /* File of definition */
663 char rest_args; /* Nonzero if last arg. absorbs the rest */
665 struct reflist *next;
666 char stringify; /* nonzero if this arg was preceded by a
668 char raw_before; /* Nonzero if a ## operator before arg. */
669 char raw_after; /* Nonzero if a ## operator after arg. */
670 char rest_args; /* Nonzero if this arg. absorbs the rest */
671 int nchars; /* Number of literal chars to copy before
672 this arg occurrence. */
673 int argno; /* Number of arg to substitute (origin-0) */
676 /* Names of macro args, concatenated in reverse order
677 with comma-space between them.
678 The only use of this is that we warn on redefinition
679 if this differs between the old and new definitions. */
684 /* different kinds of things that can appear in the value field
685 of a hash node. Actually, this may be useless now. */
694 * special extension string that can be added to the last macro argument to
695 * allow it to absorb the "rest" of the arguments when expanded. Ex:
696 * #define wow(a, b...) process (b, a, b)
697 * { wow (1, 2, 3); } -> { process (2, 3, 1, 2, 3); }
698 * { wow (one, two); } -> { process (two, one, two); }
699 * if this "rest_arg" is used with the concat token '##' and if it is not
700 * supplied then the token attached to with ## will not be outputted. Ex:
701 * #define wow (a, b...) process (b ## , a, ## b)
702 * { wow (1, 2); } -> { process (2, 1, 2); }
703 * { wow (one); } -> { process (one); {
705 static char rest_extension[] = "...";
706 #define REST_EXTENSION_LENGTH (sizeof (rest_extension) - 1)
708 /* The structure of a node in the hash table. The hash table
709 has entries for all tokens defined by #define commands (type T_MACRO),
710 plus some special tokens like __LINE__ (these each have their own
711 type, and the appropriate code is run when that type of node is seen.
712 It does not contain control words like "#define", which are recognized
713 by a separate piece of code. */
715 /* different flavors of hash nodes --- also used in keyword table */
717 T_DEFINE = 1, /* the `#define' keyword */
718 T_INCLUDE, /* the `#include' keyword */
719 T_INCLUDE_NEXT, /* the `#include_next' keyword */
720 T_IMPORT, /* the `#import' keyword */
721 T_IFDEF, /* the `#ifdef' keyword */
722 T_IFNDEF, /* the `#ifndef' keyword */
723 T_IF, /* the `#if' keyword */
724 T_ELSE, /* `#else' */
725 T_PRAGMA, /* `#pragma' */
726 T_ELIF, /* `#elif' */
727 T_UNDEF, /* `#undef' */
728 T_LINE, /* `#line' */
729 T_ERROR, /* `#error' */
730 T_WARNING, /* `#warning' */
731 T_ENDIF, /* `#endif' */
732 T_SCCS, /* `#sccs', used on system V. */
733 T_IDENT, /* `#ident', used on system V. */
734 T_ASSERT, /* `#assert', taken from system V. */
735 T_UNASSERT, /* `#unassert', taken from system V. */
736 T_SPECLINE, /* special symbol `__LINE__' */
737 T_DATE, /* `__DATE__' */
738 T_FILE, /* `__FILE__' */
739 T_BASE_FILE, /* `__BASE_FILE__' */
740 T_INCLUDE_LEVEL, /* `__INCLUDE_LEVEL__' */
741 T_VERSION, /* `__VERSION__' */
742 T_SIZE_TYPE, /* `__SIZE_TYPE__' */
743 T_PTRDIFF_TYPE, /* `__PTRDIFF_TYPE__' */
744 T_WCHAR_TYPE, /* `__WCHAR_TYPE__' */
745 T_USER_LABEL_PREFIX_TYPE, /* `__USER_LABEL_PREFIX__' */
746 T_REGISTER_PREFIX_TYPE, /* `__REGISTER_PREFIX__' */
747 T_TIME, /* `__TIME__' */
748 T_CONST, /* Constant value, used by `__STDC__' */
749 T_MACRO, /* macro defined by `#define' */
750 T_DISABLED, /* macro temporarily turned off for rescan */
751 T_SPEC_DEFINED, /* special `defined' macro for use in #if statements */
752 T_PCSTRING, /* precompiled string (hashval is KEYDEF *) */
753 T_UNUSED /* Used for something not defined. */
757 struct hashnode *next; /* double links for easy deletion */
758 struct hashnode *prev;
759 struct hashnode **bucket_hdr; /* also, a back pointer to this node's hash
760 chain is kept, in case the node is the head
761 of the chain and gets deleted. */
762 enum node_type type; /* type of special token */
763 int length; /* length of token, for quick comparison */
764 U_CHAR *name; /* the actual name */
765 union hashval value; /* pointer to expansion, or whatever */
768 typedef struct hashnode HASHNODE;
770 /* Some definitions for the hash table. The hash function MUST be
771 computed as shown in hashf () below. That is because the rescan
772 loop computes the hash value `on the fly' for most tokens,
773 in order to avoid the overhead of a lot of procedure calls to
774 the hashf () function. Hashf () only exists for the sake of
775 politeness, for use when speed isn't so important. */
777 #define HASHSIZE 1403
778 static HASHNODE *hashtab[HASHSIZE];
779 #define HASHSTEP(old, c) ((old << 2) + c)
780 #define MAKE_POS(v) (v & 0x7fffffff) /* make number positive */
782 /* Symbols to predefine. */
784 #ifdef CPP_PREDEFINES
785 static char *predefs = CPP_PREDEFINES;
787 static char *predefs = "";
790 /* We let tm.h override the types used here, to handle trivial differences
791 such as the choice of unsigned int or long unsigned int for size_t.
792 When machines start needing nontrivial differences in the size type,
793 it would be best to do something here to figure out automatically
794 from other information what type to use. */
796 /* The string value for __size_type__. */
799 #define SIZE_TYPE "long unsigned int"
802 /* The string value for __ptrdiff_type__. */
805 #define PTRDIFF_TYPE "long int"
808 /* The string value for __wchar_type__. */
811 #define WCHAR_TYPE "int"
814 /* The string value for __USER_LABEL_PREFIX__ */
816 #ifndef USER_LABEL_PREFIX
817 #define USER_LABEL_PREFIX ""
820 /* The string value for __REGISTER_PREFIX__ */
822 #ifndef REGISTER_PREFIX
823 #define REGISTER_PREFIX ""
826 /* In the definition of a #assert name, this structure forms
827 a list of the individual values asserted.
828 Each value is itself a list of "tokens".
829 These are strings that are compared by name. */
831 struct tokenlist_list {
832 struct tokenlist_list *next;
833 struct arglist *tokens;
836 struct assertion_hashnode {
837 struct assertion_hashnode *next; /* double links for easy deletion */
838 struct assertion_hashnode *prev;
839 /* also, a back pointer to this node's hash
840 chain is kept, in case the node is the head
841 of the chain and gets deleted. */
842 struct assertion_hashnode **bucket_hdr;
843 int length; /* length of token, for quick comparison */
844 U_CHAR *name; /* the actual name */
845 /* List of token-sequences. */
846 struct tokenlist_list *value;
849 typedef struct assertion_hashnode ASSERTION_HASHNODE;
851 /* Some definitions for the hash table. The hash function MUST be
852 computed as shown in hashf below. That is because the rescan
853 loop computes the hash value `on the fly' for most tokens,
854 in order to avoid the overhead of a lot of procedure calls to
855 the hashf function. hashf only exists for the sake of
856 politeness, for use when speed isn't so important. */
858 #define ASSERTION_HASHSIZE 37
859 static ASSERTION_HASHNODE *assertion_hashtab[ASSERTION_HASHSIZE];
861 /* Nonzero means inhibit macroexpansion of what seem to be
862 assertion tests, in rescan. For #if. */
863 static int assertions_flag;
865 /* `struct directive' defines one #-directive, including how to handle it. */
868 int length; /* Length of name */
869 int (*func)(); /* Function to handle directive */
870 char *name; /* Name of directive */
871 enum node_type type; /* Code which describes which directive. */
872 char angle_brackets; /* Nonzero => <...> is special. */
873 char traditional_comments; /* Nonzero: keep comments if -traditional. */
874 char pass_thru; /* Copy preprocessed directive to output file. */
877 /* Here is the actual list of #-directives, most-often-used first. */
879 static struct directive directive_table[] = {
880 { 6, do_define, "define", T_DEFINE, 0, 1},
881 { 2, do_if, "if", T_IF},
882 { 5, do_xifdef, "ifdef", T_IFDEF},
883 { 6, do_xifdef, "ifndef", T_IFNDEF},
884 { 5, do_endif, "endif", T_ENDIF},
885 { 4, do_else, "else", T_ELSE},
886 { 4, do_elif, "elif", T_ELIF},
887 { 4, do_line, "line", T_LINE},
888 { 7, do_include, "include", T_INCLUDE, 1},
889 { 12, do_include, "include_next", T_INCLUDE_NEXT, 1},
890 { 6, do_include, "import", T_IMPORT, 1},
891 { 5, do_undef, "undef", T_UNDEF},
892 { 5, do_error, "error", T_ERROR},
893 { 7, do_warning, "warning", T_WARNING},
894 #ifdef SCCS_DIRECTIVE
895 { 4, do_sccs, "sccs", T_SCCS},
897 { 6, do_pragma, "pragma", T_PRAGMA, 0, 0, 1},
898 { 5, do_ident, "ident", T_IDENT, 0, 0, 1},
899 { 6, do_assert, "assert", T_ASSERT},
900 { 8, do_unassert, "unassert", T_UNASSERT},
901 { -1, 0, "", T_UNUSED},
904 /* When a directive handler is called,
905 this points to the # that started the directive. */
906 U_CHAR *directive_start;
908 /* table to tell if char can be part of a C identifier. */
909 U_CHAR is_idchar[256];
910 /* table to tell if char can be first char of a c identifier. */
911 U_CHAR is_idstart[256];
912 /* table to tell if c is horizontal space. */
913 U_CHAR is_hor_space[256];
914 /* table to tell if c is horizontal or vertical space. */
915 static U_CHAR is_space[256];
917 #define SKIP_WHITE_SPACE(p) do { while (is_hor_space[*p]) p++; } while (0)
918 #define SKIP_ALL_WHITE_SPACE(p) do { while (is_space[*p]) p++; } while (0)
920 static int errors = 0; /* Error counter for exit code */
922 /* Name of output file, for error messages. */
923 static char *out_fname;
925 /* Zero means dollar signs are punctuation.
926 -$ stores 0; -traditional may store 1. Default is 1 for VMS, 0 otherwise.
927 This must be 0 for correct processing of this ANSI C program:
929 #define lose(b) foo (b)
932 static int dollars_in_ident;
933 #ifndef DOLLARS_IN_IDENTIFIERS
934 #define DOLLARS_IN_IDENTIFIERS 1
937 static FILE_BUF expand_to_temp_buffer ();
939 static DEFINITION *collect_expansion ();
941 /* Stack of conditionals currently in progress
942 (including both successful and failing conditionals). */
945 struct if_stack *next; /* for chaining to the next stack frame */
946 char *fname; /* copied from input when frame is made */
947 int lineno; /* similarly */
948 int if_succeeded; /* true if a leg of this if-group
949 has been passed through rescan */
950 U_CHAR *control_macro; /* For #ifndef at start of file,
951 this is the macro name tested. */
952 enum node_type type; /* type of last directive seen in this group */
954 typedef struct if_stack IF_STACK_FRAME;
955 static IF_STACK_FRAME *if_stack = NULL;
957 /* Buffer of -M output. */
958 static char *deps_buffer;
960 /* Number of bytes allocated in above. */
961 static int deps_allocated_size;
963 /* Number of bytes used. */
964 static int deps_size;
966 /* Number of bytes since the last newline. */
967 static int deps_column;
969 /* Nonzero means -I- has been seen,
970 so don't look for #include "foo" the source-file directory. */
971 static int ignore_srcdir;
984 char **pend_files = (char **) xmalloc (argc * sizeof (char *));
985 char **pend_defs = (char **) xmalloc (argc * sizeof (char *));
986 char **pend_undefs = (char **) xmalloc (argc * sizeof (char *));
987 char **pend_assertions = (char **) xmalloc (argc * sizeof (char *));
988 char **pend_includes = (char **) xmalloc (argc * sizeof (char *));
990 /* Record the option used with each element of pend_assertions.
991 This is preparation for supporting more than one option for making
993 char **pend_assertion_options = (char **) xmalloc (argc * sizeof (char *));
994 int inhibit_predefs = 0;
995 int no_standard_includes = 0;
996 int no_standard_cplusplus_includes = 0;
997 int missing_newline = 0;
999 /* Non-0 means don't output the preprocessed program. */
1000 int inhibit_output = 0;
1002 /* File name which deps are being written to.
1003 This is 0 if deps are being written to stdout. */
1004 char *deps_file = 0;
1005 /* Fopen file mode to open deps_file with. */
1006 char *deps_mode = "a";
1007 /* Stream on which to print the dependency information. */
1008 FILE *deps_stream = 0;
1009 /* Target-name to write with the dependency information. */
1010 char *deps_target = 0;
1013 /* Get rid of any avoidable limit on stack size. */
1017 /* Set the stack limit huge so that alloca (particularly stringtab
1018 * in dbxread.c) does not fail. */
1019 getrlimit (RLIMIT_STACK, &rlim);
1020 rlim.rlim_cur = rlim.rlim_max;
1021 setrlimit (RLIMIT_STACK, &rlim);
1023 #endif /* RLIMIT_STACK defined */
1025 signal (SIGPIPE, pipe_closed);
1027 p = argv[0] + strlen (argv[0]);
1028 while (p != argv[0] && p[-1] != '/') --p;
1033 /* Remove directories from PROGNAME. */
1036 progname = savestring (argv[0]);
1038 if (!(s = rindex (progname, ']')))
1039 s = rindex (progname, ':');
1041 strcpy (progname, s+1);
1042 if (s = rindex (progname, '.'))
1050 /* Initialize is_idchar to allow $. */
1051 dollars_in_ident = 1;
1052 initialize_char_syntax ();
1053 dollars_in_ident = DOLLARS_IN_IDENTIFIERS > 0;
1055 no_line_commands = 0;
1057 dump_macros = dump_none;
1060 cplusplus_comments = 0;
1062 bzero (pend_files, argc * sizeof (char *));
1063 bzero (pend_defs, argc * sizeof (char *));
1064 bzero (pend_undefs, argc * sizeof (char *));
1065 bzero (pend_assertions, argc * sizeof (char *));
1066 bzero (pend_includes, argc * sizeof (char *));
1068 /* Process switches and find input file name. */
1070 for (i = 1; i < argc; i++) {
1071 if (argv[i][0] != '-') {
1072 if (out_fname != NULL)
1073 fatal ("Usage: %s [switches] input output", argv[0]);
1074 else if (in_fname != NULL)
1075 out_fname = argv[i];
1079 switch (argv[i][1]) {
1082 if (!strcmp (argv[i], "-include")) {
1084 fatal ("Filename missing after `-include' option");
1086 pend_includes[i] = argv[i+1], i++;
1088 if (!strcmp (argv[i], "-imacros")) {
1090 fatal ("Filename missing after `-imacros' option");
1092 pend_files[i] = argv[i+1], i++;
1094 if (!strcmp (argv[i], "-iprefix")) {
1096 fatal ("Filename missing after `-iprefix' option");
1098 include_prefix = argv[++i];
1100 /* Add directory to end of path for includes,
1101 with the default prefix at the front of its name. */
1102 if (!strcmp (argv[i], "-iwithprefix")) {
1103 struct file_name_list *dirtmp;
1105 dirtmp = (struct file_name_list *)
1106 xmalloc (sizeof (struct file_name_list));
1107 dirtmp->next = 0; /* New one goes on the end */
1108 dirtmp->control_macro = 0;
1110 fatal ("Directory name missing after `-iwithprefix' option");
1112 dirtmp->fname = (char *) xmalloc (strlen (argv[i+1])
1113 + strlen (include_prefix) + 1);
1114 strcpy (dirtmp->fname, include_prefix);
1115 strcat (dirtmp->fname, argv[++i]);
1117 if (after_include == 0)
1118 after_include = dirtmp;
1120 last_after_include->next = dirtmp;
1121 last_after_include = dirtmp; /* Tail follows the last one */
1123 /* Add directory to end of path for includes. */
1124 if (!strcmp (argv[i], "-idirafter")) {
1125 struct file_name_list *dirtmp;
1127 dirtmp = (struct file_name_list *)
1128 xmalloc (sizeof (struct file_name_list));
1129 dirtmp->next = 0; /* New one goes on the end */
1130 dirtmp->control_macro = 0;
1132 fatal ("Directory name missing after `-idirafter' option");
1134 dirtmp->fname = argv[++i];
1136 if (after_include == 0)
1137 after_include = dirtmp;
1139 last_after_include->next = dirtmp;
1140 last_after_include = dirtmp; /* Tail follows the last one */
1145 if (out_fname != NULL)
1146 fatal ("Output filename specified twice");
1148 fatal ("Filename missing after -o option");
1149 out_fname = argv[++i];
1150 if (!strcmp (out_fname, "-"))
1155 if (!strcmp (argv[i], "-pedantic"))
1157 else if (!strcmp (argv[i], "-pedantic-errors")) {
1159 pedantic_errors = 1;
1160 } else if (!strcmp (argv[i], "-pcp")) {
1161 char *pcp_fname = argv[++i];
1163 ((pcp_fname[0] != '-' || pcp_fname[1] != '\0')
1164 ? fopen (pcp_fname, "w")
1165 : fdopen (dup (fileno (stdout)), "w"));
1166 if (pcp_outfile == 0)
1167 pfatal_with_name (pcp_fname);
1173 if (!strcmp (argv[i], "-traditional")) {
1175 if (dollars_in_ident > 0)
1176 dollars_in_ident = 1;
1177 } else if (!strcmp (argv[i], "-trigraphs")) {
1183 if (! strcmp (argv[i], "-lang-c"))
1184 cplusplus = 0, cplusplus_comments = 0, objc = 0;
1185 if (! strcmp (argv[i], "-lang-c++"))
1186 cplusplus = 1, cplusplus_comments = 1, objc = 0;
1187 if (! strcmp (argv[i], "-lang-objc"))
1188 objc = 1, cplusplus = 0, cplusplus_comments = 1;
1189 if (! strcmp (argv[i], "-lang-objc++"))
1190 objc = 1, cplusplus = 1, cplusplus_comments = 1;
1191 if (! strcmp (argv[i], "-lang-asm"))
1193 if (! strcmp (argv[i], "-lint"))
1198 cplusplus = 1, cplusplus_comments = 1;
1202 inhibit_warnings = 1;
1206 if (!strcmp (argv[i], "-Wtrigraphs"))
1208 else if (!strcmp (argv[i], "-Wno-trigraphs"))
1210 else if (!strcmp (argv[i], "-Wcomment"))
1212 else if (!strcmp (argv[i], "-Wno-comment"))
1214 else if (!strcmp (argv[i], "-Wcomments"))
1216 else if (!strcmp (argv[i], "-Wno-comments"))
1218 else if (!strcmp (argv[i], "-Wtraditional"))
1220 else if (!strcmp (argv[i], "-Wno-traditional"))
1222 else if (!strcmp (argv[i], "-Wimport"))
1224 else if (!strcmp (argv[i], "-Wno-import"))
1226 else if (!strcmp (argv[i], "-Werror"))
1227 warnings_are_errors = 1;
1228 else if (!strcmp (argv[i], "-Wno-error"))
1229 warnings_are_errors = 0;
1230 else if (!strcmp (argv[i], "-Wall"))
1238 if (!strcmp (argv[i], "-M"))
1240 else if (!strcmp (argv[i], "-MM"))
1242 else if (!strcmp (argv[i], "-MD"))
1244 else if (!strcmp (argv[i], "-MMD"))
1246 /* For -MD and -MMD options, write deps on file named by next arg. */
1247 if (!strcmp (argv[i], "-MD")
1248 || !strcmp (argv[i], "-MMD")) {
1250 deps_file = argv[i];
1253 /* For -M and -MM, write deps on standard output
1254 and suppress the usual output. */
1255 deps_stream = stdout;
1262 char *p = argv[i] + 2;
1265 /* Arg to -d specifies what parts of macros to dump */
1268 dump_macros = dump_only;
1272 dump_macros = dump_names;
1275 dump_macros = dump_definitions;
1283 if (argv[i][2] == '3')
1288 fprintf (stderr, "GNU CPP version %s", version_string);
1289 #ifdef TARGET_VERSION
1292 fprintf (stderr, "\n");
1296 print_include_names = 1;
1303 if (argv[i][2] != 0)
1305 else if (i + 1 == argc)
1306 fatal ("Macro name missing after -D option");
1318 if (argv[i][2] != 0)
1320 else if (i + 1 == argc)
1321 fatal ("Assertion missing after -A option");
1325 if (!strcmp (p, "-")) {
1326 /* -A- eliminates all predefined macros and assertions.
1327 Let's include also any that were specified earlier
1328 on the command line. That way we can get rid of any
1329 that were passed automatically in from GCC. */
1331 inhibit_predefs = 1;
1332 for (j = 0; j < i; j++)
1333 pend_defs[j] = pend_assertions[j] = 0;
1335 pend_assertions[i] = p;
1336 pend_assertion_options[i] = "-A";
1341 case 'U': /* JF #undef something */
1342 if (argv[i][2] != 0)
1343 pend_undefs[i] = argv[i] + 2;
1344 else if (i + 1 == argc)
1345 fatal ("Macro name missing after -U option");
1347 pend_undefs[i] = argv[i+1], i++;
1351 put_out_comments = 1;
1354 case 'E': /* -E comes from cc -E; ignore it. */
1358 no_line_commands = 1;
1361 case '$': /* Don't include $ in identifiers. */
1362 dollars_in_ident = 0;
1365 case 'I': /* Add directory to path for includes. */
1367 struct file_name_list *dirtmp;
1369 if (! ignore_srcdir && !strcmp (argv[i] + 2, "-")) {
1371 /* Don't use any preceding -I directories for #include <...>. */
1372 first_bracket_include = 0;
1375 dirtmp = (struct file_name_list *)
1376 xmalloc (sizeof (struct file_name_list));
1377 dirtmp->next = 0; /* New one goes on the end */
1378 dirtmp->control_macro = 0;
1379 if (argv[i][2] != 0)
1380 dirtmp->fname = argv[i] + 2;
1381 else if (i + 1 == argc)
1382 fatal ("Directory name missing after -I option");
1384 dirtmp->fname = argv[++i];
1385 append_include_chain (dirtmp, dirtmp);
1391 if (!strcmp (argv[i], "-nostdinc"))
1392 /* -nostdinc causes no default include directories.
1393 You must specify all include-file directories with -I. */
1394 no_standard_includes = 1;
1395 else if (!strcmp (argv[i], "-nostdinc++"))
1396 /* -nostdinc++ causes no default C++-specific include directories. */
1397 no_standard_cplusplus_includes = 1;
1398 else if (!strcmp (argv[i], "-noprecomp"))
1403 /* Sun compiler passes undocumented switch "-undef".
1404 Let's assume it means to inhibit the predefined symbols. */
1405 inhibit_predefs = 1;
1408 case '\0': /* JF handle '-' as file name meaning stdin or stdout */
1409 if (in_fname == NULL) {
1412 } else if (out_fname == NULL) {
1415 } /* else fall through into error */
1418 fatal ("Invalid option `%s'", argv[i]);
1423 /* Add dirs from CPATH after dirs from -I. */
1424 /* There seems to be confusion about what CPATH should do,
1425 so for the moment it is not documented. */
1426 /* Some people say that CPATH should replace the standard include dirs,
1427 but that seems pointless: it comes before them, so it overrides them
1429 p = (char *) getenv ("CPATH");
1430 if (p != 0 && ! no_standard_includes)
1433 /* Now that dollars_in_ident is known, initialize is_idchar. */
1434 initialize_char_syntax ();
1436 /* Initialize output buffer */
1438 outbuf.buf = (U_CHAR *) xmalloc (OUTBUF_SIZE);
1439 outbuf.bufp = outbuf.buf;
1440 outbuf.length = OUTBUF_SIZE;
1442 /* Do partial setup of input buffer for the sake of generating
1443 early #line directives (when -g is in effect). */
1445 fp = &instack[++indepth];
1446 if (in_fname == NULL)
1448 fp->nominal_fname = fp->fname = in_fname;
1451 /* Install __LINE__, etc. Must follow initialize_char_syntax
1452 and option processing. */
1453 initialize_builtins (fp, &outbuf);
1455 /* Do standard #defines and assertions
1456 that identify system and machine type. */
1458 if (!inhibit_predefs) {
1459 char *p = (char *) alloca (strlen (predefs) + 1);
1460 strcpy (p, predefs);
1463 while (*p == ' ' || *p == '\t')
1465 /* Handle -D options. */
1466 if (p[0] == '-' && p[1] == 'D') {
1468 while (*p && *p != ' ' && *p != '\t')
1473 output_line_command (fp, &outbuf, 0, same_file);
1474 make_definition (q, &outbuf);
1475 while (*p == ' ' || *p == '\t')
1477 } else if (p[0] == '-' && p[1] == 'A') {
1478 /* Handle -A options (assertions). */
1487 past_name = assertion;
1488 /* Locate end of name. */
1489 while (*past_name && *past_name != ' '
1490 && *past_name != '\t' && *past_name != '(')
1492 /* Locate `(' at start of value. */
1494 while (*value && (*value == ' ' || *value == '\t'))
1496 if (*value++ != '(')
1498 while (*value && (*value == ' ' || *value == '\t'))
1501 /* Locate end of value. */
1502 while (*past_value && *past_value != ' '
1503 && *past_value != '\t' && *past_value != ')')
1505 termination = past_value;
1506 while (*termination && (*termination == ' ' || *termination == '\t'))
1508 if (*termination++ != ')')
1510 if (*termination && *termination != ' ' && *termination != '\t')
1512 /* Temporarily null-terminate the value. */
1513 save_char = *termination;
1514 *termination = '\0';
1515 /* Install the assertion. */
1516 make_assertion ("-A", assertion);
1517 *termination = (char) save_char;
1519 while (*p == ' ' || *p == '\t')
1527 /* Now handle the command line options. */
1529 /* Do -U's, -D's and -A's in the order they were seen. */
1530 for (i = 1; i < argc; i++) {
1531 if (pend_undefs[i]) {
1533 output_line_command (fp, &outbuf, 0, same_file);
1534 make_undef (pend_undefs[i], &outbuf);
1538 output_line_command (fp, &outbuf, 0, same_file);
1539 make_definition (pend_defs[i], &outbuf);
1541 if (pend_assertions[i])
1542 make_assertion (pend_assertion_options[i], pend_assertions[i]);
1545 done_initializing = 1;
1547 { /* read the appropriate environment variable and if it exists
1548 replace include_defaults with the listed path. */
1550 switch ((objc << 1) + cplusplus)
1553 epath = getenv ("C_INCLUDE_PATH");
1556 epath = getenv ("CPLUS_INCLUDE_PATH");
1559 epath = getenv ("OBJC_INCLUDE_PATH");
1562 epath = getenv ("OBJCPLUS_INCLUDE_PATH");
1565 /* If the environment var for this language is set,
1566 add to the default list of include directories. */
1568 char *nstore = (char *) alloca (strlen (epath) + 2);
1570 char *startp, *endp;
1572 for (num_dirs = 1, startp = epath; *startp; startp++)
1573 if (*startp == PATH_SEPARATOR)
1576 = (struct default_include *) xmalloc ((num_dirs
1577 * sizeof (struct default_include))
1578 + sizeof (include_defaults_array));
1579 startp = endp = epath;
1582 /* Handle cases like c:/usr/lib:d:/gcc/lib */
1583 if ((*endp == PATH_SEPARATOR
1584 #if 0 /* Obsolete, now that we use semicolons as the path separator. */
1586 && (endp-startp != 1 || !isalpha (*startp))
1591 strncpy (nstore, startp, endp-startp);
1593 strcpy (nstore, ".");
1595 nstore[endp-startp] = '\0';
1597 include_defaults[num_dirs].fname = savestring (nstore);
1598 include_defaults[num_dirs].cplusplus = cplusplus;
1602 endp = startp = endp + 1;
1606 /* Put the usual defaults back in at the end. */
1607 bcopy (include_defaults_array, &include_defaults[num_dirs],
1608 sizeof (include_defaults_array));
1612 first_system_include = 0;
1613 /* Unless -fnostdinc,
1614 tack on the standard include file dirs to the specified list */
1615 if (!no_standard_includes) {
1616 struct default_include *p = include_defaults;
1617 char *specd_prefix = include_prefix;
1618 char *default_prefix = savestring (GCC_INCLUDE_DIR);
1619 int default_len = 0;
1620 /* Remove the `include' from /usr/local/lib/gcc.../include. */
1621 if (!strcmp (default_prefix + strlen (default_prefix) - 8, "/include")) {
1622 default_len = strlen (default_prefix) - 7;
1623 default_prefix[default_len] = 0;
1625 /* Search "translated" versions of GNU directories.
1626 These have /usr/local/lib/gcc... replaced by specd_prefix. */
1627 if (specd_prefix != 0 && default_len != 0)
1628 for (p = include_defaults; p->fname; p++) {
1629 /* Some standard dirs are only for C++. */
1630 if (!p->cplusplus || (cplusplus && !no_standard_cplusplus_includes)) {
1631 /* Does this dir start with the prefix? */
1632 if (!strncmp (p->fname, default_prefix, default_len)) {
1633 /* Yes; change prefix and add to search list. */
1634 struct file_name_list *new
1635 = (struct file_name_list *) xmalloc (sizeof (struct file_name_list));
1636 int this_len = strlen (specd_prefix) + strlen (p->fname) - default_len;
1637 char *str = (char *) xmalloc (this_len + 1);
1638 strcpy (str, specd_prefix);
1639 strcat (str, p->fname + default_len);
1641 new->control_macro = 0;
1642 append_include_chain (new, new);
1643 if (first_system_include == 0)
1644 first_system_include = new;
1648 /* Search ordinary names for GNU include directories. */
1649 for (p = include_defaults; p->fname; p++) {
1650 /* Some standard dirs are only for C++. */
1651 if (!p->cplusplus || (cplusplus && !no_standard_cplusplus_includes)) {
1652 struct file_name_list *new
1653 = (struct file_name_list *) xmalloc (sizeof (struct file_name_list));
1654 new->control_macro = 0;
1655 new->fname = p->fname;
1656 append_include_chain (new, new);
1657 if (first_system_include == 0)
1658 first_system_include = new;
1663 /* Tack the after_include chain at the end of the include chain. */
1664 append_include_chain (after_include, last_after_include);
1665 if (first_system_include == 0)
1666 first_system_include = after_include;
1668 /* Scan the -imacros files before the main input.
1669 Much like #including them, but with no_output set
1670 so that only their macro definitions matter. */
1673 for (i = 1; i < argc; i++)
1674 if (pend_files[i]) {
1675 int fd = open (pend_files[i], O_RDONLY, 0666);
1677 perror_with_name (pend_files[i]);
1678 return FAILURE_EXIT_CODE;
1680 finclude (fd, pend_files[i], &outbuf, 0, NULL_PTR);
1684 /* Copy the entire contents of the main input file into
1685 the stacked input buffer previously allocated for it. */
1687 /* JF check for stdin */
1688 if (in_fname == NULL || *in_fname == 0) {
1691 } else if ((f = open (in_fname, O_RDONLY, 0666)) < 0)
1694 /* Either of two environment variables can specify output of deps.
1695 Its value is either "OUTPUT_FILE" or "OUTPUT_FILE DEPS_TARGET",
1696 where OUTPUT_FILE is the file to write deps info to
1697 and DEPS_TARGET is the target to mention in the deps. */
1700 && (getenv ("SUNPRO_DEPENDENCIES") != 0
1701 || getenv ("DEPENDENCIES_OUTPUT") != 0)) {
1702 char *spec = getenv ("DEPENDENCIES_OUTPUT");
1707 spec = getenv ("SUNPRO_DEPENDENCIES");
1714 /* Find the space before the DEPS_TARGET, if there is one. */
1715 /* This should use index. (mrs) */
1716 while (*s != 0 && *s != ' ') s++;
1718 deps_target = s + 1;
1719 output_file = (char *) xmalloc (s - spec + 1);
1720 bcopy (spec, output_file, s - spec);
1721 output_file[s - spec] = 0;
1728 deps_file = output_file;
1732 /* For -M, print the expected object file name
1733 as the target of this Make-rule. */
1735 deps_allocated_size = 200;
1736 deps_buffer = (char *) xmalloc (deps_allocated_size);
1742 deps_output (deps_target, 0);
1743 deps_output (":", 0);
1744 } else if (*in_fname == 0)
1745 deps_output ("-: ", 0);
1750 /* Discard all directory prefixes from P. */
1756 /* Output P, but remove known suffixes. */
1758 if (p[len - 2] == '.' && p[len - 1] == 'c')
1759 deps_output (p, len - 2);
1760 else if (p[len - 2] == '.' && p[len - 1] == 'C')
1761 deps_output (p, len - 2);
1762 else if (p[len - 3] == '.'
1763 && p[len - 2] == 'c'
1764 && p[len - 1] == 'c')
1765 deps_output (p, len - 3);
1766 else if (p[len - 4] == '.'
1767 && p[len - 3] == 'c'
1768 && p[len - 2] == 'x'
1769 && p[len - 1] == 'x')
1770 deps_output (p, len - 4);
1771 else if (p[len - 2] == '.' && p[len - 1] == 's')
1772 deps_output (p, len - 2);
1773 else if (p[len - 2] == '.' && p[len - 1] == 'S')
1774 deps_output (p, len - 2);
1775 else if (p[len - 2] == '.' && p[len - 1] == 'm')
1776 deps_output (p, len - 2);
1779 /* Supply our own suffix. */
1781 deps_output (".o : ", 0);
1783 deps_output (".obj : ", 0);
1785 deps_output (in_fname, 0);
1786 deps_output (" ", 0);
1790 file_size_and_mode (f, &st_mode, &st_size);
1791 fp->nominal_fname = fp->fname = in_fname;
1793 fp->system_header_p = 0;
1794 /* JF all this is mine about reading pipes and ttys */
1795 if (! S_ISREG (st_mode)) {
1796 /* Read input from a file that is not a normal disk file.
1797 We cannot preallocate a buffer with the correct size,
1798 so we must read in the file a piece at the time and make it bigger. */
1806 fp->buf = (U_CHAR *) xmalloc (bsize + 2);
1809 cnt = read (f, bufp, bsize - size);
1810 if (cnt < 0) goto perror; /* error! */
1811 if (cnt == 0) break; /* End of file */
1814 if (bsize == size) { /* Buffer is full! */
1816 fp->buf = (U_CHAR *) xrealloc (fp->buf, bsize + 2);
1817 bufp = fp->buf + size; /* May have moved */
1822 /* Read a file whose size we can determine in advance.
1823 For the sake of VMS, st_size is just an upper bound. */
1826 fp->buf = (U_CHAR *) xmalloc (st_size + 2);
1828 while (st_size > 0) {
1829 i = read (f, fp->buf + fp->length, st_size);
1839 fp->if_stack = if_stack;
1841 /* Make sure data ends with a newline. And put a null after it. */
1843 if ((fp->length > 0 && fp->buf[fp->length - 1] != '\n')
1844 /* Backslash-newline at end is not good enough. */
1845 || (fp->length > 1 && fp->buf[fp->length - 2] == '\\')) {
1846 fp->buf[fp->length++] = '\n';
1847 missing_newline = 1;
1849 fp->buf[fp->length] = '\0';
1851 /* Unless inhibited, convert trigraphs in the input. */
1856 /* Now that we know the input file is valid, open the output. */
1858 if (!out_fname || !strcmp (out_fname, ""))
1859 out_fname = "stdout";
1860 else if (! freopen (out_fname, "w", stdout))
1861 pfatal_with_name (out_fname);
1863 output_line_command (fp, &outbuf, 0, same_file);
1865 /* Scan the -include files before the main input. */
1867 for (i = 1; i < argc; i++)
1868 if (pend_includes[i]) {
1869 int fd = open (pend_includes[i], O_RDONLY, 0666);
1871 perror_with_name (pend_includes[i]);
1872 return FAILURE_EXIT_CODE;
1874 finclude (fd, pend_includes[i], &outbuf, 0, NULL_PTR);
1877 /* Scan the input, processing macros and directives. */
1879 rescan (&outbuf, 0);
1881 if (missing_newline)
1884 if (pedantic && missing_newline)
1885 pedwarn ("file does not end in newline");
1887 /* Now we have processed the entire input
1888 Write whichever kind of output has been requested. */
1890 if (dump_macros == dump_only)
1892 else if (! inhibit_output) {
1897 /* Don't actually write the deps file if compilation has failed. */
1899 if (deps_file && ! (deps_stream = fopen (deps_file, deps_mode)))
1900 pfatal_with_name (deps_file);
1901 fputs (deps_buffer, deps_stream);
1902 putc ('\n', deps_stream);
1904 if (ferror (deps_stream) || fclose (deps_stream) != 0)
1905 fatal ("I/O error on output");
1910 if (pcp_outfile && pcp_outfile != stdout
1911 && (ferror (pcp_outfile) || fclose (pcp_outfile) != 0))
1912 fatal ("I/O error on `-pcp' output");
1914 if (ferror (stdout) || fclose (stdout) != 0)
1915 fatal ("I/O error on output");
1918 exit (FAILURE_EXIT_CODE);
1919 exit (SUCCESS_EXIT_CODE);
1922 pfatal_with_name (in_fname);
1926 /* Given a colon-separated list of file names PATH,
1927 add all the names to the search path for include files. */
1941 struct file_name_list *dirtmp;
1943 /* Find the end of this name. */
1944 while (*q != 0 && *q != PATH_SEPARATOR) q++;
1946 /* An empty name in the path stands for the current directory. */
1947 name = (char *) xmalloc (2);
1951 /* Otherwise use the directory that is named. */
1952 name = (char *) xmalloc (q - p + 1);
1953 bcopy (p, name, q - p);
1957 dirtmp = (struct file_name_list *)
1958 xmalloc (sizeof (struct file_name_list));
1959 dirtmp->next = 0; /* New one goes on the end */
1960 dirtmp->control_macro = 0;
1961 dirtmp->fname = name;
1962 append_include_chain (dirtmp, dirtmp);
1964 /* Advance past this name. */
1968 /* Skip the colon. */
1973 /* Pre-C-Preprocessor to translate ANSI trigraph idiocy in BUF
1974 before main CCCP processing. Name `pcp' is also in honor of the
1975 drugs the trigraph designers must have been on.
1977 Using an extra pass through the buffer takes a little extra time,
1978 but is infinitely less hairy than trying to handle trigraphs inside
1979 strings, etc. everywhere, and also makes sure that trigraphs are
1980 only translated in the top level of processing. */
1986 register U_CHAR c, *fptr, *bptr, *sptr;
1989 fptr = bptr = sptr = buf->buf;
1990 while ((sptr = (U_CHAR *) index (sptr, '?')) != NULL) {
2027 len = sptr - fptr - 2;
2028 if (bptr != fptr && len > 0)
2029 bcopy (fptr, bptr, len); /* BSD doc says bcopy () works right
2030 for overlapping strings. In ANSI
2031 C, this will be memmove (). */
2036 len = buf->length - (fptr - buf->buf);
2037 if (bptr != fptr && len > 0)
2038 bcopy (fptr, bptr, len);
2039 buf->length -= fptr - bptr;
2040 buf->buf[buf->length] = '\0';
2041 if (warn_trigraphs && fptr != bptr)
2042 warning ("%d trigraph(s) encountered", (fptr - bptr) / 2);
2045 /* Move all backslash-newline pairs out of embarrassing places.
2046 Exchange all such pairs following BP
2047 with any potentially-embarrassing characters that follow them.
2048 Potentially-embarrassing characters are / and *
2049 (because a backslash-newline inside a comment delimiter
2050 would cause it not to be recognized). */
2056 register U_CHAR *p = bp;
2057 register int count = 0;
2059 /* First count the backslash-newline pairs here. */
2065 else if (p[1] == '\r' && p[2] == '\n')
2073 /* What follows the backslash-newlines is not embarrassing. */
2075 if (count == 0 || (*p != '/' && *p != '*'))
2078 /* Copy all potentially embarrassing characters
2079 that follow the backslash-newline pairs
2080 down to where the pairs originally started. */
2082 while (*p == '*' || *p == '/')
2085 /* Now write the same number of pairs after the embarrassing chars. */
2086 while (count-- > 0) {
2092 /* Like newline_fix but for use within a directive-name.
2093 Move any backslash-newlines up past any following symbol constituents. */
2096 name_newline_fix (bp)
2099 register U_CHAR *p = bp;
2100 register int count = 0;
2102 /* First count the backslash-newline pairs here. */
2107 else if (p[1] == '\r' && p[2] == '\n')
2115 /* What follows the backslash-newlines is not embarrassing. */
2117 if (count == 0 || !is_idchar[*p])
2120 /* Copy all potentially embarrassing characters
2121 that follow the backslash-newline pairs
2122 down to where the pairs originally started. */
2124 while (is_idchar[*p])
2127 /* Now write the same number of pairs after the embarrassing chars. */
2128 while (count-- > 0) {
2134 /* Look for lint commands in comments.
2136 When we come in here, ibp points into a comment. Limit is as one expects.
2137 scan within the comment -- it should start, after lwsp, with a lint command.
2138 If so that command is returned as a (constant) string.
2140 Upon return, any arg will be pointed to with argstart and will be
2141 arglen long. Note that we don't parse that arg since it will just
2142 be printed out again.
2146 get_lintcmd (ibp, limit, argstart, arglen, cmdlen)
2147 register U_CHAR *ibp;
2148 register U_CHAR *limit;
2149 U_CHAR **argstart; /* point to command arg */
2150 int *arglen, *cmdlen; /* how long they are */
2153 register U_CHAR *numptr; /* temp for arg parsing */
2157 SKIP_WHITE_SPACE (ibp);
2159 if (ibp >= limit) return NULL;
2161 linsize = limit - ibp;
2163 /* Oh, I wish C had lexical functions... hell, I'll just open-code the set */
2164 if ((linsize >= 10) && !strncmp (ibp, "NOTREACHED", 10)) {
2166 return "NOTREACHED";
2168 if ((linsize >= 8) && !strncmp (ibp, "ARGSUSED", 8)) {
2172 if ((linsize >= 11) && !strncmp (ibp, "LINTLIBRARY", 11)) {
2174 return "LINTLIBRARY";
2176 if ((linsize >= 7) && !strncmp (ibp, "VARARGS", 7)) {
2178 ibp += 7; linsize -= 7;
2179 if ((linsize == 0) || ! isdigit (*ibp)) return "VARARGS";
2181 /* OK, read a number */
2182 for (numptr = *argstart = ibp; (numptr < limit) && isdigit (*numptr);
2184 *arglen = numptr - *argstart;
2191 * The main loop of the program.
2193 * Read characters from the input stack, transferring them to the
2196 * Macros are expanded and push levels on the input stack.
2197 * At the end of such a level it is popped off and we keep reading.
2198 * At the end of any other kind of level, we return.
2199 * #-directives are handled, except within macros.
2201 * If OUTPUT_MARKS is nonzero, keep Newline markers found in the input
2202 * and insert them when appropriate. This is set while scanning macro
2203 * arguments before substitution. It is zero when scanning for final output.
2204 * There are three types of Newline markers:
2205 * * Newline - follows a macro name that was not expanded
2206 * because it appeared inside an expansion of the same macro.
2207 * This marker prevents future expansion of that identifier.
2208 * When the input is rescanned into the final output, these are deleted.
2209 * These are also deleted by ## concatenation.
2210 * * Newline Space (or Newline and any other whitespace character)
2211 * stands for a place that tokens must be separated or whitespace
2212 * is otherwise desirable, but where the ANSI standard specifies there
2213 * is no whitespace. This marker turns into a Space (or whichever other
2214 * whitespace char appears in the marker) in the final output,
2215 * but it turns into nothing in an argument that is stringified with #.
2216 * Such stringified arguments are the only place where the ANSI standard
2217 * specifies with precision that whitespace may not appear.
2219 * During this function, IP->bufp is kept cached in IBP for speed of access.
2220 * Likewise, OP->bufp is kept in OBP. Before calling a subroutine
2221 * IBP, IP and OBP must be copied back to memory. IP and IBP are
2222 * copied back with the RECACHE macro. OBP must be copied back from OP->bufp
2223 * explicitly, and before RECACHE, since RECACHE uses OBP.
2227 rescan (op, output_marks)
2231 /* Character being scanned in main loop. */
2234 /* Length of pending accumulated identifier. */
2235 register int ident_length = 0;
2237 /* Hash code of pending accumulated identifier. */
2238 register int hash = 0;
2240 /* Current input level (&instack[indepth]). */
2243 /* Pointer for scanning input. */
2244 register U_CHAR *ibp;
2246 /* Pointer to end of input. End of scan is controlled by LIMIT. */
2247 register U_CHAR *limit;
2249 /* Pointer for storing output. */
2250 register U_CHAR *obp;
2252 /* REDO_CHAR is nonzero if we are processing an identifier
2253 after backing up over the terminating character.
2254 Sometimes we process an identifier without backing up over
2255 the terminating character, if the terminating character
2256 is not special. Backing up is done so that the terminating character
2257 will be dispatched on again once the identifier is dealt with. */
2260 /* 1 if within an identifier inside of which a concatenation
2261 marker (Newline -) has been seen. */
2262 int concatenated = 0;
2264 /* While scanning a comment or a string constant,
2265 this records the line it started on, for error messages. */
2268 /* Record position of last `real' newline. */
2269 U_CHAR *beg_of_line;
2271 /* Pop the innermost input stack level, assuming it is a macro expansion. */
2274 do { ip->macro->type = T_MACRO; \
2275 if (ip->free_ptr) free (ip->free_ptr); \
2276 --indepth; } while (0)
2278 /* Reload `rescan's local variables that describe the current
2279 level of the input stack. */
2282 do { ip = &instack[indepth]; \
2284 limit = ip->buf + ip->length; \
2286 check_expand (op, limit - ibp); \
2288 obp = op->bufp; } while (0)
2290 if (no_output && instack[indepth].fname != 0)
2291 skip_if_group (&instack[indepth], 1);
2298 /* Our caller must always put a null after the end of
2299 the input at each input stack level. */
2312 /* Always merge lines ending with backslash-newline,
2313 even in middle of identifier. */
2316 --obp; /* remove backslash from obuf */
2319 /* Otherwise, backslash suppresses specialness of following char,
2320 so copy it here to prevent the switch from seeing it.
2321 But first get any pending identifier processed. */
2322 if (ident_length > 0)
2328 if (assertions_flag) {
2329 /* Copy #foo (bar lose) without macro expansion. */
2330 SKIP_WHITE_SPACE (ibp);
2331 while (is_idchar[*ibp])
2333 SKIP_WHITE_SPACE (ibp);
2336 skip_paren_group (ip);
2337 bcopy (ibp, obp, ip->bufp - ibp);
2338 obp += ip->bufp - ibp;
2343 /* If this is expanding a macro definition, don't recognize
2344 preprocessor directives. */
2347 /* If this is expand_into_temp_buffer, recognize them
2348 only after an actual newline at this level,
2349 not at the beginning of the input level. */
2350 if (ip->fname == 0 && beg_of_line == ip->buf)
2356 /* # keyword: a # must be first nonblank char on the line */
2357 if (beg_of_line == 0)
2362 /* Scan from start of line, skipping whitespace, comments
2363 and backslash-newlines, and see if we reach this #.
2364 If not, this # is not special. */
2366 /* If -traditional, require # to be at beginning of line. */
2369 if (is_hor_space[*bp])
2371 else if (*bp == '\\' && bp[1] == '\n')
2373 else if (*bp == '/' && bp[1] == '*') {
2375 while (!(*bp == '*' && bp[1] == '/'))
2379 else if (cplusplus_comments && *bp == '/' && bp[1] == '/') {
2381 while (*bp++ != '\n') ;
2389 /* This # can start a directive. */
2391 --obp; /* Don't copy the '#' */
2395 if (! handle_directive (ip, op)) {
2399 /* Not a known directive: treat it as ordinary text.
2400 IP, OP, IBP, etc. have not been changed. */
2401 if (no_output && instack[indepth].fname) {
2402 /* If not generating expanded output,
2403 what we do with ordinary text is skip it.
2404 Discard everything until next # directive. */
2405 skip_if_group (&instack[indepth], 1);
2410 ++obp; /* Copy the '#' after all */
2416 /* A # directive has been successfully processed. */
2417 /* If not generating expanded output, ignore everything until
2418 next # directive. */
2419 if (no_output && instack[indepth].fname)
2420 skip_if_group (&instack[indepth], 1);
2426 case '\"': /* skip quoted string */
2428 /* A single quoted string is treated like a double -- some
2429 programs (e.g., troff) are perverse this way */
2434 start_line = ip->lineno;
2436 /* Skip ahead to a matching quote. */
2440 if (ip->macro != 0) {
2441 /* try harder: this string crosses a macro expansion boundary.
2442 This can happen naturally if -traditional.
2443 Otherwise, only -D can make a macro with an unmatched quote. */
2449 error_with_line (line_for_error (start_line),
2450 "unterminated string or character constant");
2451 error_with_line (multiline_string_line,
2452 "possible real start of unterminated constant");
2453 multiline_string_line = 0;
2462 /* Traditionally, end of line ends a string constant with no error.
2463 So exit the loop and record the new line. */
2469 error_with_line (line_for_error (start_line),
2470 "unterminated character constant");
2473 if (pedantic && multiline_string_line == 0) {
2474 pedwarn_with_line (line_for_error (start_line),
2475 "string constant runs past end of line");
2477 if (multiline_string_line == 0)
2478 multiline_string_line = ip->lineno - 1;
2485 /* Backslash newline is replaced by nothing at all,
2486 but keep the line counts correct. */
2491 /* ANSI stupidly requires that in \\ the second \
2492 is *not* prevented from combining with a newline. */
2493 while (*ibp == '\\' && ibp[1] == '\n') {
2512 if (*ibp == '\\' && ibp[1] == '\n')
2516 && !(cplusplus_comments && *ibp == '/'))
2524 /* C++ style comment... */
2525 start_line = ip->lineno;
2527 --ibp; /* Back over the slash */
2530 /* Comments are equivalent to spaces. */
2531 if (! put_out_comments)
2534 /* must fake up a comment here */
2539 U_CHAR *before_bp = ibp+2;
2541 while (ibp < limit) {
2542 if (*ibp++ == '\n') {
2544 if (put_out_comments) {
2545 bcopy (before_bp, obp, ibp - before_bp);
2546 obp += ibp - before_bp;
2555 /* Ordinary C comment. Skip it, optionally copying it to output. */
2557 start_line = ip->lineno;
2559 ++ibp; /* Skip the star. */
2561 /* If this cpp is for lint, we peek inside the comments: */
2565 char *lintcmd = get_lintcmd (ibp, limit, &argbp, &arglen, &cmdlen);
2567 if (lintcmd != NULL) {
2568 /* I believe it is always safe to emit this newline: */
2570 bcopy ("#pragma lint ", obp, 13);
2572 bcopy (lintcmd, obp, cmdlen);
2577 bcopy (argbp, obp, arglen);
2581 /* OK, now bring us back to the state we were in before we entered
2582 this branch. We need #line b/c the newline for the pragma
2583 could fuck things up. */
2584 output_line_command (ip, op, 0, same_file);
2585 *(obp++) = ' '; /* just in case, if comments are copied thru */
2590 /* Comments are equivalent to spaces.
2591 Note that we already output the slash; we might not want it.
2592 For -traditional, a comment is equivalent to nothing. */
2593 if (! put_out_comments) {
2603 U_CHAR *before_bp = ibp;
2605 while (ibp < limit) {
2608 if (warn_comments && ibp < limit && *ibp == '*')
2609 warning ("`/*' within comment");
2612 if (*ibp == '\\' && ibp[1] == '\n')
2614 if (ibp >= limit || *ibp == '/')
2619 /* Copy the newline into the output buffer, in order to
2620 avoid the pain of a #line every time a multiline comment
2622 if (!put_out_comments)
2630 error_with_line (line_for_error (start_line),
2631 "unterminated comment");
2634 if (put_out_comments) {
2635 bcopy (before_bp, obp, ibp - before_bp);
2636 obp += ibp - before_bp;
2643 if (!dollars_in_ident)
2647 case '0': case '1': case '2': case '3': case '4':
2648 case '5': case '6': case '7': case '8': case '9':
2649 /* If digit is not part of identifier, it starts a number,
2650 which means that following letters are not an identifier.
2651 "0x5" does not refer to an identifier "x5".
2652 So copy all alphanumerics that follow without accumulating
2653 as an identifier. Periods also, for sake of "3.e7". */
2655 if (ident_length == 0) {
2656 while (ibp < limit) {
2657 while (ibp < limit && ibp[0] == '\\' && ibp[1] == '\n') {
2662 /* ".." terminates a preprocessing number. This is useless for C
2663 code but useful for preprocessing other things. */
2664 if (!isalnum (c) && (c != '.' || *ibp == '.') && c != '_') {
2669 /* A sign can be part of a preprocessing number
2670 if it follows an e. */
2671 if (c == 'e' || c == 'E') {
2672 while (ibp < limit && ibp[0] == '\\' && ibp[1] == '\n') {
2676 if (ibp < limit && (*ibp == '+' || *ibp == '-')) {
2678 /* But traditional C does not let the token go past the sign. */
2689 case 'a': case 'b': case 'c': case 'd': case 'e': case 'f':
2690 case 'g': case 'h': case 'i': case 'j': case 'k': case 'l':
2691 case 'm': case 'n': case 'o': case 'p': case 'q': case 'r':
2692 case 's': case 't': case 'u': case 'v': case 'w': case 'x':
2694 case 'A': case 'B': case 'C': case 'D': case 'E': case 'F':
2695 case 'G': case 'H': case 'I': case 'J': case 'K': case 'L':
2696 case 'M': case 'N': case 'O': case 'P': case 'Q': case 'R':
2697 case 'S': case 'T': case 'U': case 'V': case 'W': case 'X':
2701 /* Compute step of hash function, to avoid a proc call on every token */
2702 hash = HASHSTEP (hash, c);
2706 if (ip->fname == 0 && *ibp == '-') {
2707 /* Newline - inhibits expansion of preceding token.
2708 If expanding a macro arg, we keep the newline -.
2709 In final output, it is deleted.
2710 We recognize Newline - in macro bodies and macro args. */
2711 if (! concatenated) {
2716 if (!output_marks) {
2719 /* If expanding a macro arg, keep the newline -. */
2725 /* If reprocessing a macro expansion, newline is a special marker. */
2726 else if (ip->macro != 0) {
2727 /* Newline White is a "funny space" to separate tokens that are
2728 supposed to be separate but without space between.
2729 Here White means any whitespace character.
2730 Newline - marks a recursive macro use that is not
2731 supposed to be expandable. */
2733 if (is_space[*ibp]) {
2734 /* Newline Space does not prevent expansion of preceding token
2735 so expand the preceding token and then come back. */
2736 if (ident_length > 0)
2739 /* If generating final output, newline space makes a space. */
2740 if (!output_marks) {
2742 /* And Newline Newline makes a newline, so count it. */
2743 if (obp[-1] == '\n')
2746 /* If expanding a macro arg, keep the newline space.
2747 If the arg gets stringified, newline space makes nothing. */
2750 } else abort (); /* Newline followed by something random? */
2754 /* If there is a pending identifier, handle it and come back here. */
2755 if (ident_length > 0)
2760 /* Update the line counts and output a #line if necessary. */
2763 if (ip->lineno != op->lineno) {
2765 output_line_command (ip, op, 1, same_file);
2766 check_expand (op, ip->length - (ip->bufp - ip->buf));
2771 /* Come here either after (1) a null character that is part of the input
2772 or (2) at the end of the input, because there is a null there. */
2775 /* Our input really contains a null character. */
2778 /* At end of a macro-expansion level, pop it and read next level. */
2779 if (ip->macro != 0) {
2782 /* If traditional, and we have an identifier that ends here,
2783 process it now, so we get the right error for recursion. */
2784 if (traditional && ident_length
2785 && ! is_idchar[*instack[indepth - 1].bufp]) {
2794 /* If we don't have a pending identifier,
2795 return at end of input. */
2796 if (ident_length == 0) {
2804 /* If we do have a pending identifier, just consider this null
2805 a special character and arrange to dispatch on it again.
2806 The second time, IDENT_LENGTH will be zero so we will return. */
2812 /* Handle the case of a character such as /, ', " or null
2813 seen following an identifier. Back over it so that
2814 after the identifier is processed the special char
2815 will be dispatched on again. */
2825 if (ident_length > 0) {
2826 register HASHNODE *hp;
2828 /* We have just seen an identifier end. If it's a macro, expand it.
2830 IDENT_LENGTH is the length of the identifier
2831 and HASH is its hash code.
2833 The identifier has already been copied to the output,
2834 so if it is a macro we must remove it.
2836 If REDO_CHAR is 0, the char that terminated the identifier
2837 has been skipped in the output and the input.
2838 OBP-IDENT_LENGTH-1 points to the identifier.
2839 If the identifier is a macro, we must back over the terminator.
2841 If REDO_CHAR is 1, the terminating char has already been
2842 backed over. OBP-IDENT_LENGTH points to the identifier. */
2844 if (!pcp_outfile || pcp_inside_if) {
2846 for (hp = hashtab[MAKE_POS (hash) % HASHSIZE]; hp != NULL;
2849 if (hp->length == ident_length) {
2850 int obufp_before_macroname;
2851 int op_lineno_before_macroname;
2852 register int i = ident_length;
2853 register U_CHAR *p = hp->name;
2854 register U_CHAR *q = obp - i;
2860 do { /* All this to avoid a strncmp () */
2865 /* We found a use of a macro name.
2866 see if the context shows it is a macro call. */
2868 /* Back up over terminating character if not already done. */
2874 /* Save this as a displacement from the beginning of the output
2875 buffer. We can not save this as a position in the output
2876 buffer, because it may get realloc'ed by RECACHE. */
2877 obufp_before_macroname = (obp - op->buf) - ident_length;
2878 op_lineno_before_macroname = op->lineno;
2880 if (hp->type == T_PCSTRING) {
2881 pcstring_used (hp); /* Mark the definition of this key
2882 as needed, ensuring that it
2884 break; /* Exit loop, since the key cannot have a
2885 definition any longer. */
2888 /* Record whether the macro is disabled. */
2889 disabled = hp->type == T_DISABLED;
2891 /* This looks like a macro ref, but if the macro was disabled,
2892 just copy its name and put in a marker if requested. */
2896 /* This error check caught useful cases such as
2897 #define foo(x,y) bar (x (y,0), y)
2900 error ("recursive use of macro `%s'", hp->name);
2904 check_expand (op, limit - ibp + 2);
2911 /* If macro wants an arglist, verify that a '(' follows.
2912 first skip all whitespace, copying it to the output
2913 after the macro name. Then, if there is no '(',
2914 decide this is not a macro call and leave things that way. */
2915 if ((hp->type == T_MACRO || hp->type == T_DISABLED)
2916 && hp->value.defn->nargs >= 0)
2918 U_CHAR *old_ibp = ibp;
2919 U_CHAR *old_obp = obp;
2920 int old_iln = ip->lineno;
2921 int old_oln = op->lineno;
2924 /* Scan forward over whitespace, copying it to the output. */
2925 if (ibp == limit && ip->macro != 0) {
2930 old_iln = ip->lineno;
2931 old_oln = op->lineno;
2933 /* A comment: copy it unchanged or discard it. */
2934 else if (*ibp == '/' && ibp+1 != limit && ibp[1] == '*') {
2935 if (put_out_comments) {
2938 } else if (! traditional) {
2942 while (ibp + 1 != limit
2943 && !(ibp[0] == '*' && ibp[1] == '/')) {
2944 /* We need not worry about newline-marks,
2945 since they are never found in comments. */
2947 /* Newline in a file. Count it. */
2951 if (put_out_comments)
2957 if (put_out_comments) {
2962 else if (is_space[*ibp]) {
2964 if (ibp[-1] == '\n') {
2965 if (ip->macro == 0) {
2966 /* Newline in a file. Count it. */
2969 } else if (!output_marks) {
2970 /* A newline mark, and we don't want marks
2971 in the output. If it is newline-hyphen,
2972 discard it entirely. Otherwise, it is
2973 newline-whitechar, so keep the whitechar. */
2983 /* A newline mark; copy both chars to the output. */
2991 /* It isn't a macro call.
2992 Put back the space that we just skipped. */
2995 ip->lineno = old_iln;
2996 op->lineno = old_oln;
2997 /* Exit the for loop. */
3002 /* This is now known to be a macro call.
3003 Discard the macro name from the output,
3004 along with any following whitespace just copied. */
3005 obp = op->buf + obufp_before_macroname;
3006 op->lineno = op_lineno_before_macroname;
3008 /* Prevent accidental token-pasting with a character
3009 before the macro call. */
3010 if (!traditional && obp != op->buf
3011 && (obp[-1] == '-' || obp[1] == '+' || obp[1] == '&'
3012 || obp[-1] == '|' || obp[1] == '<' || obp[1] == '>')) {
3013 /* If we are expanding a macro arg, make a newline marker
3014 to separate the tokens. If we are making real output,
3015 a plain space will do. */
3021 /* Expand the macro, reading arguments as needed,
3022 and push the expansion on the input stack. */
3025 macroexpand (hp, op);
3027 /* Reexamine input stack, since macroexpand has pushed
3028 a new level on it. */
3035 } /* End hash-table-search loop */
3037 ident_length = hash = 0; /* Stop collecting identifier */
3040 } /* End if (ident_length > 0) */
3042 } /* End per-char loop */
3044 /* Come here to return -- but first give an error message
3045 if there was an unterminated successful conditional. */
3047 if (if_stack != ip->if_stack) {
3049 switch (if_stack->type) {
3066 error_with_line (line_for_error (if_stack->lineno),
3067 "unterminated `#%s' conditional", str);
3069 if_stack = ip->if_stack;
3073 * Rescan a string into a temporary buffer and return the result
3074 * as a FILE_BUF. Note this function returns a struct, not a pointer.
3076 * OUTPUT_MARKS nonzero means keep Newline markers found in the input
3077 * and insert such markers when appropriate. See `rescan' for details.
3078 * OUTPUT_MARKS is 1 for macroexpanding a macro argument separately
3079 * before substitution; it is 0 for other uses.
3082 expand_to_temp_buffer (buf, limit, output_marks, assertions)
3083 U_CHAR *buf, *limit;
3084 int output_marks, assertions;
3086 register FILE_BUF *ip;
3088 int length = limit - buf;
3090 int odepth = indepth;
3091 int save_assertions_flag = assertions_flag;
3093 assertions_flag = assertions;
3098 /* Set up the input on the input stack. */
3100 buf1 = (U_CHAR *) alloca (length + 1);
3102 register U_CHAR *p1 = buf;
3103 register U_CHAR *p2 = buf1;
3110 /* Set up to receive the output. */
3112 obuf.length = length * 2 + 100; /* Usually enough. Why be stingy? */
3113 obuf.bufp = obuf.buf = (U_CHAR *) xmalloc (obuf.length);
3118 CHECK_DEPTH ({return obuf;});
3122 ip = &instack[indepth];
3124 ip->nominal_fname = 0;
3125 ip->system_header_p = 0;
3128 ip->length = length;
3129 ip->buf = ip->bufp = buf1;
3130 ip->if_stack = if_stack;
3132 ip->lineno = obuf.lineno = 1;
3134 /* Scan the input, create the output. */
3135 rescan (&obuf, output_marks);
3137 /* Pop input stack to original state. */
3140 if (indepth != odepth)
3143 /* Record the output. */
3144 obuf.length = obuf.bufp - obuf.buf;
3146 assertions_flag = save_assertions_flag;
3151 * Process a # directive. Expects IP->bufp to point after the '#', as in
3152 * `#define foo bar'. Passes to the command handler
3153 * (do_define, do_include, etc.): the addresses of the 1st and
3154 * last chars of the command (starting immediately after the #
3155 * keyword), plus op and the keyword table pointer. If the command
3156 * contains comments it is copied into a temporary buffer sans comments
3157 * and the temporary buffer is passed to the command handler instead.
3158 * Likewise for backslash-newlines.
3160 * Returns nonzero if this was a known # directive.
3161 * Otherwise, returns zero, without advancing the input pointer.
3165 handle_directive (ip, op)
3168 register U_CHAR *bp, *cp;
3169 register struct directive *kt;
3170 register int ident_length;
3173 /* Nonzero means we must copy the entire command
3174 to get rid of comments or backslash-newlines. */
3175 int copy_command = 0;
3177 U_CHAR *ident, *after_ident;
3181 /* Record where the directive started. do_xifdef needs this. */
3182 directive_start = bp - 1;
3184 /* Skip whitespace and \-newline. */
3186 if (is_hor_space[*bp]) {
3187 if ((*bp == '\f' || *bp == '\v') && pedantic)
3188 pedwarn ("%s in preprocessing directive",
3189 *bp == '\f' ? "formfeed" : "vertical tab");
3191 } else if (*bp == '/' && bp[1] == '*') {
3193 skip_to_end_of_comment (ip, &ip->lineno, 0);
3195 } else if (*bp == '\\' && bp[1] == '\n') {
3196 bp += 2; ip->lineno++;
3200 /* Now find end of directive name.
3201 If we encounter a backslash-newline, exchange it with any following
3202 symbol-constituents so that we end up with a contiguous name. */
3209 if (*cp == '\\' && cp[1] == '\n')
3210 name_newline_fix (cp);
3216 ident_length = cp - bp;
3220 /* A line of just `#' becomes blank. */
3222 if (ident_length == 0 && *after_ident == '\n') {
3223 ip->bufp = after_ident;
3227 if (ident_length == 0 || !is_idstart[*ident]) {
3229 while (is_idchar[*p]) {
3230 if (*p < '0' || *p > '9')
3234 /* Handle # followed by a line number. */
3235 if (p != ident && !is_idchar[*p]) {
3236 static struct directive line_directive_table[] = {
3237 { 4, do_line, "line", T_LINE},
3240 pedwarn ("`#' followed by integer");
3241 after_ident = ident;
3242 kt = line_directive_table;
3246 /* Avoid error for `###' and similar cases unless -pedantic. */
3248 while (*p == '#' || is_hor_space[*p]) p++;
3250 if (pedantic && !lang_asm)
3251 warning ("invalid preprocessor directive");
3257 error ("invalid preprocessor directive name");
3263 * Decode the keyword and call the appropriate expansion
3264 * routine, after moving the input pointer up to the next line.
3266 for (kt = directive_table; kt->length > 0; kt++) {
3267 if (kt->length == ident_length && !strncmp (kt->name, ident, ident_length)) {
3268 register U_CHAR *buf;
3269 register U_CHAR *limit;
3272 int *already_output;
3274 /* Nonzero means do not delete comments within the directive.
3275 #define needs this when -traditional. */
3280 limit = ip->buf + ip->length;
3283 keep_comments = traditional && kt->traditional_comments;
3284 /* #import is defined only in Objective C, or when on the NeXT. */
3285 if (kt->type == T_IMPORT && !(objc || lookup ("__NeXT__", -1, -1)))
3288 /* Find the end of this command (first newline not backslashed
3289 and not in a string or comment).
3290 Set COPY_COMMAND if the command must be copied
3291 (it contains a backslash-newline or a comment). */
3293 buf = bp = after_ident;
3294 while (bp < limit) {
3295 register U_CHAR c = *bp++;
3309 bp = skip_quoted_string (bp - 1, limit, ip->lineno, &ip->lineno, ©_command, &unterminated);
3310 /* Don't bother calling the directive if we already got an error
3311 message due to unterminated string. Skip everything and pretend
3312 we called the directive. */
3315 /* Traditional preprocessing permits unterminated strings. */
3324 /* <...> is special for #include. */
3326 if (!kt->angle_brackets)
3328 while (*bp && *bp != '>') bp++;
3332 if (*bp == '\\' && bp[1] == '\n')
3335 || (cplusplus_comments && *bp == '/')) {
3336 U_CHAR *obp = bp - 1;
3338 skip_to_end_of_comment (ip, &ip->lineno, 0);
3340 /* No need to copy the command because of a comment at the end;
3341 just don't include the comment in the directive. */
3342 if (bp == limit || *bp == '\n') {
3346 /* Don't remove the comments if -traditional. */
3347 if (! keep_comments)
3355 pedwarn ("%s in preprocessing directive",
3356 c == '\f' ? "formfeed" : "vertical tab");
3360 --bp; /* Point to the newline */
3368 resume_p = ip->bufp;
3369 /* BP is the end of the directive.
3370 RESUME_P is the next interesting data after the directive.
3371 A comment may come between. */
3373 /* If a directive should be copied through, and -E was given,
3374 pass it through before removing comments. */
3375 if (!no_output && kt->pass_thru && put_out_comments) {
3378 /* Output directive name. */
3379 check_expand (op, kt->length + 2);
3380 /* Make sure # is at the start of a line */
3381 if (op->bufp > op->buf && op->bufp[-1] != '\n') {
3386 bcopy (kt->name, op->bufp, kt->length);
3387 op->bufp += kt->length;
3389 /* Output arguments. */
3391 check_expand (op, len);
3392 bcopy (buf, op->bufp, len);
3394 /* Take account of any (escaped) newlines just output. */
3396 if (buf[len] == '\n')
3399 already_output = &junk;
3400 } /* Don't we need a newline or #line? */
3403 register U_CHAR *xp = buf;
3404 /* Need to copy entire command into temp buffer before dispatching */
3406 cp = (U_CHAR *) alloca (bp - buf + 5); /* room for cmd plus
3410 /* Copy to the new buffer, deleting comments
3411 and backslash-newlines (and whitespace surrounding the latter). */
3414 register U_CHAR c = *xp++;
3419 abort (); /* A bare newline should never part of the line. */
3422 /* <...> is special for #include. */
3424 if (!kt->angle_brackets)
3426 while (xp < bp && c != '>') {
3428 if (c == '\\' && xp < bp && *xp == '\n')
3439 if (cp != buf && is_space[cp[-1]]) {
3440 while (cp != buf && is_space[cp[-1]]) cp--;
3442 SKIP_WHITE_SPACE (xp);
3443 } else if (is_space[*xp]) {
3445 SKIP_WHITE_SPACE (xp);
3455 register U_CHAR *bp1
3456 = skip_quoted_string (xp - 1, bp, ip->lineno,
3457 NULL_PTR, NULL_PTR, NULL_PTR);
3471 || (cplusplus_comments && *xp == '/')) {
3473 /* If we already copied the command through,
3474 already_output != 0 prevents outputting comment now. */
3475 skip_to_end_of_comment (ip, already_output, 0);
3477 while (xp != ip->bufp)
3479 /* Delete or replace the slash. */
3480 else if (traditional)
3489 /* Null-terminate the copy. */
3495 ip->bufp = resume_p;
3497 /* Some directives should be written out for cc1 to process,
3498 just as if they were not defined. And sometimes we're copying
3499 definitions through. */
3501 if (!no_output && already_output == 0
3503 || (kt->type == T_DEFINE
3504 && (dump_macros == dump_names
3505 || dump_macros == dump_definitions)))) {
3508 /* Output directive name. */
3509 check_expand (op, kt->length + 1);
3511 bcopy (kt->name, op->bufp, kt->length);
3512 op->bufp += kt->length;
3514 if (kt->pass_thru || dump_macros == dump_definitions) {
3515 /* Output arguments. */
3517 check_expand (op, len);
3518 bcopy (buf, op->bufp, len);
3520 } else if (kt->type == T_DEFINE && dump_macros == dump_names) {
3523 SKIP_WHITE_SPACE (xp);
3525 while (is_idchar[*xp]) xp++;
3527 check_expand (op, len + 1);
3529 bcopy (yp, op->bufp, len);
3532 } /* Don't we need a newline or #line? */
3534 /* Call the appropriate command handler. buf now points to
3535 either the appropriate place in the input buffer, or to
3536 the temp buffer if it was necessary to make one. cp
3537 points to the first char after the contents of the (possibly
3538 copied) command, in either case. */
3539 (*kt->func) (buf, cp, op, kt);
3540 check_expand (op, ip->length - (ip->bufp - ip->buf));
3546 /* It is deliberate that we don't warn about undefined directives.
3547 That is the responsibility of cc1. */
3554 static struct tm *timebuf;
3556 time_t t = time (0);
3557 timebuf = localtime (&t);
3562 static char *monthnames[] = {"Jan", "Feb", "Mar", "Apr", "May", "Jun",
3563 "Jul", "Aug", "Sep", "Oct", "Nov", "Dec",
3567 * expand things like __FILE__. Place the expansion into the output
3568 * buffer *without* rescanning.
3572 special_symbol (hp, op)
3579 FILE_BUF *ip = NULL;
3582 int paren = 0; /* For special `defined' keyword */
3584 if (pcp_outfile && pcp_inside_if
3585 && hp->type != T_SPEC_DEFINED && hp->type != T_CONST)
3586 error ("Predefined macro `%s' used inside `#if' during precompilation",
3589 for (i = indepth; i >= 0; i--)
3590 if (instack[i].fname != NULL) {
3595 error ("cccp error: not in any file?!");
3596 return; /* the show must go on */
3604 if (hp->type == T_FILE)
3605 string = ip->nominal_fname;
3607 string = instack[0].nominal_fname;
3611 buf = (char *) alloca (3 + strlen (string));
3612 sprintf (buf, "\"%s\"", string);
3620 case T_INCLUDE_LEVEL:
3622 for (i = indepth; i >= 0; i--)
3623 if (instack[i].fname != NULL)
3626 buf = (char *) alloca (8); /* Eight bytes ought to be more than enough */
3627 sprintf (buf, "%d", true_indepth - 1);
3631 buf = (char *) alloca (3 + strlen (version_string));
3632 sprintf (buf, "\"%s\"", version_string);
3636 buf = (char *) alloca (3 + strlen (SIZE_TYPE));
3637 sprintf (buf, "%s", SIZE_TYPE);
3640 case T_PTRDIFF_TYPE:
3641 buf = (char *) alloca (3 + strlen (PTRDIFF_TYPE));
3642 sprintf (buf, "%s", PTRDIFF_TYPE);
3646 buf = (char *) alloca (3 + strlen (WCHAR_TYPE));
3647 sprintf (buf, "%s", WCHAR_TYPE);
3650 case T_USER_LABEL_PREFIX_TYPE:
3651 buf = (char *) alloca (3 + strlen (USER_LABEL_PREFIX));
3652 sprintf (buf, "%s", USER_LABEL_PREFIX);
3655 case T_REGISTER_PREFIX_TYPE:
3656 buf = (char *) alloca (3 + strlen (REGISTER_PREFIX));
3657 sprintf (buf, "%s", REGISTER_PREFIX);
3661 buf = (char *) alloca (4 * sizeof (int));
3662 sprintf (buf, "%d", hp->value.ival);
3663 if (pcp_inside_if && pcp_outfile)
3664 /* Output a precondition for this macro use */
3665 fprintf (pcp_outfile, "#define %s %d\n", hp->name, hp->value.ival);
3669 buf = (char *) alloca (10);
3670 sprintf (buf, "%d", ip->lineno);
3675 buf = (char *) alloca (20);
3676 timebuf = timestamp ();
3677 if (hp->type == T_DATE)
3678 sprintf (buf, "\"%s %2d %4d\"", monthnames[timebuf->tm_mon],
3679 timebuf->tm_mday, timebuf->tm_year + 1900);
3681 sprintf (buf, "\"%02d:%02d:%02d\"", timebuf->tm_hour, timebuf->tm_min,
3685 case T_SPEC_DEFINED:
3686 buf = " 0 "; /* Assume symbol is not defined */
3687 ip = &instack[indepth];
3688 SKIP_WHITE_SPACE (ip->bufp);
3689 if (*ip->bufp == '(') {
3691 ip->bufp++; /* Skip over the paren */
3692 SKIP_WHITE_SPACE (ip->bufp);
3695 if (!is_idstart[*ip->bufp])
3697 if (hp = lookup (ip->bufp, -1, -1)) {
3698 if (pcp_outfile && pcp_inside_if
3699 && hp->value.defn->predefined)
3700 /* Output a precondition for this macro use. */
3701 fprintf (pcp_outfile, "#define %s\n", hp->name);
3705 if (pcp_outfile && pcp_inside_if) {
3706 /* Output a precondition for this macro use */
3707 U_CHAR *cp = ip->bufp;
3708 fprintf (pcp_outfile, "#undef ");
3709 while (is_idchar[*cp]) /* Ick! */
3710 fputc (*cp++, pcp_outfile);
3711 putc ('\n', pcp_outfile);
3713 while (is_idchar[*ip->bufp])
3715 SKIP_WHITE_SPACE (ip->bufp);
3717 if (*ip->bufp != ')')
3725 error ("`defined' without an identifier");
3729 error ("cccp error: invalid special hash type"); /* time for gdb */
3733 check_expand (op, len);
3734 bcopy (buf, op->bufp, len);
3741 /* Routines to handle #directives */
3743 /* Handle #include and #import.
3744 This function expects to see "fname" or <fname> on the input. */
3747 do_include (buf, limit, op, keyword)
3748 U_CHAR *buf, *limit;
3750 struct directive *keyword;
3752 int importing = (keyword->type == T_IMPORT);
3753 int skip_dirs = (keyword->type == T_INCLUDE_NEXT);
3754 static int import_warning = 0;
3755 char *fname; /* Dynamically allocated fname buffer */
3758 U_CHAR *fbeg, *fend; /* Beginning and end of fname */
3760 struct file_name_list *search_start = include; /* Chain of dirs to search */
3761 struct file_name_list dsp[1]; /* First in chain, if #include "..." */
3762 struct file_name_list *searchptr = 0;
3765 int f; /* file number */
3767 int retried = 0; /* Have already tried macro
3768 expanding the include line*/
3769 FILE_BUF trybuf; /* It got expanded into here */
3770 int angle_brackets = 0; /* 0 for "...", 1 for <...> */
3775 f= -1; /* JF we iz paranoid! */
3777 if (importing && warn_import && !inhibit_warnings
3778 && !instack[indepth].system_header_p && !import_warning) {
3780 warning ("using `#import' is not recommended");
3781 fprintf (stderr, "The fact that a certain header file need not be processed more than once\n");
3782 fprintf (stderr, "should be indicated in the header file, not where it is used.\n");
3783 fprintf (stderr, "The best way to do this is with a conditional of this form:\n\n");
3784 fprintf (stderr, " #ifndef _FOO_H_INCLUDED\n");
3785 fprintf (stderr, " #define _FOO_H_INCLUDED\n");
3786 fprintf (stderr, " ... <real contents of file> ...\n");
3787 fprintf (stderr, " #endif /* Not _FOO_H_INCLUDED */\n\n");
3788 fprintf (stderr, "Then users can use `#include' any number of times.\n");
3789 fprintf (stderr, "GNU C automatically avoids processing the file more than once\n");
3790 fprintf (stderr, "when it is equipped with such a conditional.\n");
3796 SKIP_WHITE_SPACE (fbeg);
3797 /* Discard trailing whitespace so we can easily see
3798 if we have parsed all the significant chars we were given. */
3799 while (limit != fbeg && is_hor_space[limit[-1]]) limit--;
3805 /* Copy the operand text, concatenating the strings. */
3808 fbeg = (U_CHAR *) alloca (limit - fbeg + 1);
3810 while (fin != limit) {
3811 while (fin != limit && *fin != '\"')
3816 /* If not at the end, there had better be another string. */
3817 /* Skip just horiz space, and don't go past limit. */
3818 while (fin != limit && is_hor_space[*fin]) fin++;
3819 if (fin != limit && *fin == '\"')
3827 /* We have "filename". Figure out directory this source
3828 file is coming from and put it on the front of the list. */
3830 /* If -I- was specified, don't search current dir, only spec'd ones. */
3831 if (ignore_srcdir) break;
3833 for (fp = &instack[indepth]; fp >= instack; fp--)
3838 if ((nam = fp->nominal_fname) != NULL) {
3839 /* Found a named file. Figure out dir of the file,
3840 and put it in front of the search list. */
3841 dsp[0].next = search_start;
3844 ep = rindex (nam, '/');
3846 ep = rindex (nam, ']');
3847 if (ep == NULL) ep = rindex (nam, '>');
3848 if (ep == NULL) ep = rindex (nam, ':');
3849 if (ep != NULL) ep++;
3853 dsp[0].fname = (char *) alloca (n + 1);
3854 strncpy (dsp[0].fname, nam, n);
3855 dsp[0].fname[n] = '\0';
3856 if (n + INCLUDE_LEN_FUDGE > max_include_len)
3857 max_include_len = n + INCLUDE_LEN_FUDGE;
3859 dsp[0].fname = 0; /* Current directory */
3869 while (fend != limit && *fend != '>') fend++;
3870 if (*fend == '>' && fend + 1 == limit) {
3872 /* If -I-, start with the first -I dir after the -I-. */
3873 if (first_bracket_include)
3874 search_start = first_bracket_include;
3882 error ("`#%s' expects \"FILENAME\" or <FILENAME>", keyword->name);
3885 trybuf = expand_to_temp_buffer (buf, limit, 0, 0);
3886 buf = (U_CHAR *) alloca (trybuf.bufp - trybuf.buf + 1);
3887 bcopy (trybuf.buf, buf, trybuf.bufp - trybuf.buf);
3888 limit = buf + (trybuf.bufp - trybuf.buf);
3895 /* For #include_next, skip in the search path
3896 past the dir in which the containing file was found. */
3899 for (fp = &instack[indepth]; fp >= instack; fp--)
3900 if (fp->fname != NULL) {
3901 /* fp->dir is null if the containing file was specified
3902 with an absolute file name. In that case, don't skip anything. */
3904 search_start = fp->dir->next;
3913 error ("empty file name in `#%s'", keyword->name);
3917 /* Allocate this permanently, because it gets stored in the definitions
3919 fname = (char *) xmalloc (max_include_len + flen + 2);
3920 /* + 2 above for slash and terminating null. */
3922 /* If specified file name is absolute, just open it. */
3925 strncpy (fname, fbeg, flen);
3927 if (redundant_include_p (fname))
3930 f = lookup_import (fname);
3932 f = open (fname, O_RDONLY, 0666);
3934 return 0; /* Already included this file */
3936 /* Search directory path, trying to open the file.
3937 Copy each filename tried into FNAME. */
3939 for (searchptr = search_start; searchptr; searchptr = searchptr->next) {
3940 if (searchptr->fname) {
3941 /* The empty string in a search path is ignored.
3942 This makes it possible to turn off entirely
3943 a standard piece of the list. */
3944 if (searchptr->fname[0] == 0)
3946 strcpy (fname, searchptr->fname);
3947 strcat (fname, "/");
3948 fname[strlen (fname) + flen] = 0;
3952 strncat (fname, fbeg, flen);
3954 /* Change this 1/2 Unix 1/2 VMS file specification into a
3955 full VMS file specification */
3956 if (searchptr->fname && (searchptr->fname[0] != 0)) {
3957 /* Fix up the filename */
3958 hack_vms_include_specification (fname);
3960 /* This is a normal VMS filespec, so use it unchanged. */
3961 strncpy (fname, fbeg, flen);
3966 f = lookup_import (fname);
3968 f = open (fname, O_RDONLY, 0666);
3970 return 0; /* Already included this file */
3972 else if (f == -1 && errno == EACCES)
3973 warning ("Header file %s exists, but is not readable", fname);
3975 if (redundant_include_p (fname)) {
3985 /* A file that was not found. */
3987 strncpy (fname, fbeg, flen);
3989 /* If -M was specified, and this header file won't be added to the
3990 dependency list, then don't count this as an error, because we can
3991 still produce correct output. Otherwise, we can't produce correct
3992 output, because there may be dependencies we need inside the missing
3993 file, and we don't know what directory this missing file exists in. */
3995 && (print_deps <= (angle_brackets || (system_include_depth > 0))))
3996 warning ("No include path in which to find %s", fname);
3997 else if (search_start)
3998 error_from_errno (fname);
4000 error ("No include path in which to find %s", fname);
4004 /* Check to see if this include file is a once-only include file.
4007 struct file_name_list* ptr;
4009 for (ptr = dont_repeat_files; ptr; ptr = ptr->next) {
4010 if (!strcmp (ptr->fname, fname)) {
4012 return 0; /* This file was once'd. */
4016 for (ptr = all_include_files; ptr; ptr = ptr->next) {
4017 if (!strcmp (ptr->fname, fname))
4018 break; /* This file was included before. */
4022 /* This is the first time for this file. */
4023 /* Add it to list of files included. */
4025 ptr = (struct file_name_list *) xmalloc (sizeof (struct file_name_list));
4026 ptr->control_macro = 0;
4027 ptr->next = all_include_files;
4028 all_include_files = ptr;
4029 ptr->fname = savestring (fname);
4031 /* For -M, add this file to the dependencies. */
4032 if (print_deps > (angle_brackets || (system_include_depth > 0))) {
4033 deps_output ("", 0);
4034 deps_output (fname, 0);
4035 deps_output (" ", 0);
4039 /* Handle -H option. */
4040 if (print_include_names)
4041 fprintf (stderr, "%s\n", fname);
4044 system_include_depth++;
4046 /* Actually process the file. */
4047 add_import (f, fname); /* Record file on "seen" list for #import. */
4049 pcftry = (char *) alloca (strlen (fname) + 30);
4057 sprintf (pcftry, "%s%d", fname, pcfnum++);
4059 pcf = open (pcftry, O_RDONLY, 0666);
4065 if (bcmp (&stat_f.st_ino, &s.st_ino, sizeof (s.st_ino))
4066 || stat_f.st_dev != s.st_dev)
4068 pcfbuf = check_precompiled (pcf, fname, &pcfbuflimit);
4069 /* Don't need it any more. */
4074 /* Don't need it at all. */
4079 } while (pcf != -1 && !pcfbuf);
4081 /* Actually process the file */
4083 pcfname = xmalloc (strlen (pcftry) + 1);
4084 strcpy (pcfname, pcftry);
4085 pcfinclude (pcfbuf, pcfbuflimit, fname, op);
4088 finclude (f, fname, op, is_system_include (fname), searchptr);
4091 system_include_depth--;
4096 /* Return nonzero if there is no need to include file NAME
4097 because it has already been included and it contains a conditional
4098 to make a repeated include do nothing. */
4101 redundant_include_p (name)
4104 struct file_name_list *l = all_include_files;
4105 for (; l; l = l->next)
4106 if (! strcmp (name, l->fname)
4108 && lookup (l->control_macro, -1, -1))
4113 /* Return nonzero if the given FILENAME is an absolute pathname which
4114 designates a file within one of the known "system" include file
4115 directories. We assume here that if the given FILENAME looks like
4116 it is the name of a file which resides either directly in a "system"
4117 include file directory, or within any subdirectory thereof, then the
4118 given file must be a "system" include file. This function tells us
4119 if we should suppress pedantic errors/warnings for the given FILENAME. */
4122 is_system_include (filename)
4123 register char *filename;
4125 struct file_name_list *searchptr;
4127 for (searchptr = first_system_include; searchptr;
4128 searchptr = searchptr->next)
4129 if (searchptr->fname) {
4130 register char *sys_dir = searchptr->fname;
4131 register unsigned length = strlen (sys_dir);
4133 if (! strncmp (sys_dir, filename, length) && filename[length] == '/')
4139 /* Process the contents of include file FNAME, already open on descriptor F,
4141 SYSTEM_HEADER_P is 1 if this file was specified using <...>.
4142 DIRPTR is the link in the dir path through which this file was found,
4143 or 0 if the file name was absolute. */
4146 finclude (f, fname, op, system_header_p, dirptr)
4150 int system_header_p;
4151 struct file_name_list *dirptr;
4156 FILE_BUF *fp; /* For input stack frame */
4157 int missing_newline = 0;
4159 CHECK_DEPTH (return;);
4161 if (file_size_and_mode (f, &st_mode, &st_size) < 0)
4163 perror_with_name (fname);
4168 fp = &instack[indepth + 1];
4169 bzero (fp, sizeof (FILE_BUF));
4170 fp->nominal_fname = fp->fname = fname;
4173 fp->if_stack = if_stack;
4174 fp->system_header_p = system_header_p;
4177 if (S_ISREG (st_mode)) {
4178 fp->buf = (U_CHAR *) xmalloc (st_size + 2);
4181 /* Read the file contents, knowing that st_size is an upper bound
4182 on the number of bytes we can read. */
4183 while (st_size > 0) {
4184 i = read (f, fp->buf + fp->length, st_size);
4193 else if (S_ISDIR (st_mode)) {
4194 error ("directory `%s' specified in #include", fname);
4198 /* Cannot count its file size before reading.
4199 First read the entire file into heap and
4200 copy them into buffer on stack. */
4207 basep = (U_CHAR *) xmalloc (bsize + 2);
4208 fp->buf = basep; /* So it will get freed, on error. */
4212 i = read (f, bufp, bsize - st_size);
4214 goto nope; /* error! */
4216 break; /* End of file */
4219 if (bsize == st_size) { /* Buffer is full! */
4221 basep = (U_CHAR *) xrealloc (basep, bsize + 2);
4223 bufp = basep + st_size; /* May have moved */
4227 fp->length = st_size;
4230 if ((fp->length > 0 && fp->buf[fp->length - 1] != '\n')
4231 /* Backslash-newline at end is not good enough. */
4232 || (fp->length > 1 && fp->buf[fp->length - 2] == '\\')) {
4233 fp->buf[fp->length++] = '\n';
4234 missing_newline = 1;
4236 fp->buf[fp->length] = '\0';
4238 /* Close descriptor now, so nesting does not use lots of descriptors. */
4241 /* Must do this before calling trigraph_pcp, so that the correct file name
4242 will be printed in warning messages. */
4245 input_file_stack_tick++;
4250 output_line_command (fp, op, 0, enter_file);
4253 if (missing_newline)
4256 if (pedantic && missing_newline)
4257 pedwarn ("file does not end in newline");
4260 input_file_stack_tick++;
4261 output_line_command (&instack[indepth], op, 0, leave_file);
4267 perror_with_name (fname);
4272 /* Record that inclusion of the file named FILE
4273 should be controlled by the macro named MACRO_NAME.
4274 This means that trying to include the file again
4275 will do something if that macro is defined. */
4278 record_control_macro (file, macro_name)
4282 struct file_name_list *new;
4284 for (new = all_include_files; new; new = new->next) {
4285 if (!strcmp (new->fname, file)) {
4286 new->control_macro = macro_name;
4291 /* If the file is not in all_include_files, something's wrong. */
4295 /* Maintain and search list of included files, for #import. */
4297 #define IMPORT_HASH_SIZE 31
4299 struct import_file {
4303 struct import_file *next;
4306 /* Hash table of files already included with #include or #import. */
4308 static struct import_file *import_hash_table[IMPORT_HASH_SIZE];
4310 /* Hash a file name for import_hash_table. */
4318 while (*f) val += *f++;
4319 return (val%IMPORT_HASH_SIZE);
4322 /* Search for file FILENAME in import_hash_table.
4323 Return -2 if found, either a matching name or a matching inode.
4324 Otherwise, open the file and return a file descriptor if successful
4325 or -1 if unsuccessful. */
4328 lookup_import (filename)
4331 struct import_file *i;
4337 hashval = import_hash (filename);
4339 /* Attempt to find file in list of already included files */
4340 i = import_hash_table[hashval];
4343 if (!strcmp (filename, i->name))
4344 return -2; /* return found */
4347 /* Open it and try a match on inode/dev */
4348 fd = open (filename, O_RDONLY, 0666);
4352 for (h = 0; h < IMPORT_HASH_SIZE; h++) {
4353 i = import_hash_table[h];
4355 /* Compare the inode and the device.
4356 Supposedly on some systems the inode is not a scalar. */
4357 if (!bcmp (&i->inode, &sb.st_ino, sizeof (sb.st_ino))
4358 && i->dev == sb.st_dev) {
4360 return -2; /* return found */
4365 return fd; /* Not found, return open file */
4368 /* Add the file FNAME, open on descriptor FD, to import_hash_table. */
4371 add_import (fd, fname)
4375 struct import_file *i;
4379 hashval = import_hash (fname);
4381 i = (struct import_file *)xmalloc (sizeof (struct import_file));
4382 i->name = (char *)xmalloc (strlen (fname)+1);
4383 strcpy (i->name, fname);
4384 bcopy (&sb.st_ino, &i->inode, sizeof (sb.st_ino));
4386 i->next = import_hash_table[hashval];
4387 import_hash_table[hashval] = i;
4390 /* Load the specified precompiled header into core, and verify its
4391 preconditions. PCF indicates the file descriptor to read, which must
4392 be a regular file. FNAME indicates the file name of the original
4393 header. *LIMIT will be set to an address one past the end of the file.
4394 If the preconditions of the file are not satisfied, the buffer is
4395 freed and we return 0. If the preconditions are satisfied, return
4396 the address of the buffer following the preconditions. The buffer, in
4397 this case, should never be freed because various pieces of it will
4398 be referred to until all precompiled strings are output at the end of
4402 check_precompiled (pcf, fname, limit)
4418 if (file_size_and_mode (pcf, &st_mode, &st_size) < 0)
4421 if (S_ISREG (st_mode))
4423 buf = xmalloc (st_size + 2);
4426 i = read (pcf, buf + length, st_size);
4438 if (length > 0 && buf[length-1] != '\n')
4439 buf[length++] = '\n';
4442 *limit = buf + length;
4444 /* File is in core. Check the preconditions. */
4445 if (!check_preconditions (buf))
4447 for (cp = buf; *cp; cp++)
4450 fprintf (stderr, "Using preinclude %s\n", fname);
4456 fprintf (stderr, "Cannot use preinclude %s\n", fname);
4462 /* PREC (null terminated) points to the preconditions of a
4463 precompiled header. These are a series of #define and #undef
4464 lines which must match the current contents of the hash
4467 check_preconditions (prec)
4474 lineend = (char *) index (prec, '\n');
4476 if (*prec++ != '#') {
4477 error ("Bad format encountered while reading precompiled file");
4480 if (!strncmp (prec, "define", 6)) {
4484 mdef = create_definition (prec, lineend, NULL_PTR);
4489 if ((hp = lookup (mdef.symnam, mdef.symlen, -1)) == NULL
4490 || (hp->type != T_MACRO && hp->type != T_CONST)
4491 || (hp->type == T_MACRO
4492 && !compare_defs (mdef.defn, hp->value.defn)
4493 && (mdef.defn->length != 2
4494 || mdef.defn->expansion[0] != '\n'
4495 || mdef.defn->expansion[1] != ' ')))
4497 } else if (!strncmp (prec, "undef", 5)) {
4502 while (is_hor_space[(U_CHAR) *prec])
4505 while (is_idchar[(U_CHAR) *prec])
4509 if (lookup (name, len, -1))
4512 error ("Bad format encountered while reading precompiled file");
4517 /* They all passed successfully */
4521 /* Process the main body of a precompiled file. BUF points to the
4522 string section of the file, following the preconditions. LIMIT is one
4523 character past the end. NAME is the name of the file being read
4524 in. OP is the main output buffer */
4526 pcfinclude (buf, limit, name, op)
4527 U_CHAR *buf, *limit, *name;
4534 /* First in the file comes 4 bytes indicating the number of strings, */
4535 /* in network byte order. (MSB first). */
4537 nstrings = (nstrings << 8) | *cp++;
4538 nstrings = (nstrings << 8) | *cp++;
4539 nstrings = (nstrings << 8) | *cp++;
4541 /* Looping over each string... */
4542 while (nstrings--) {
4543 U_CHAR *string_start;
4544 U_CHAR *endofthiskey;
4548 /* Each string starts with a STRINGDEF structure (str), followed */
4549 /* by the text of the string (string_start) */
4551 /* First skip to a longword boundary */
4552 /* ??? Why a 4-byte boundary? On all machines? */
4553 /* NOTE: This works correctly even if HOST_WIDE_INT
4554 is narrower than a pointer.
4555 Do not try risky measures here to get another type to use!
4556 Do not include gstddef.h or stddef.h--either one will fail! */
4557 if ((HOST_WIDE_INT) cp & 3)
4558 cp += 4 - ((HOST_WIDE_INT) cp & 3);
4560 /* Now get the string. */
4561 str = (STRINGDEF *) cp;
4562 string_start = cp += sizeof (STRINGDEF);
4564 for (; *cp; cp++) /* skip the string */
4567 /* We need to macro expand the string here to ensure that the
4568 proper definition environment is in place. If it were only
4569 expanded when we find out it is needed, macros necessary for
4570 its proper expansion might have had their definitions changed. */
4571 tmpbuf = expand_to_temp_buffer (string_start, cp++, 0, 0);
4572 /* Lineno is already set in the precompiled file */
4573 str->contents = tmpbuf.buf;
4574 str->len = tmpbuf.length;
4576 str->filename = name;
4577 str->output_mark = outbuf.bufp - outbuf.buf;
4580 *stringlist_tailp = str;
4581 stringlist_tailp = &str->chain;
4583 /* Next comes a fourbyte number indicating the number of keys */
4584 /* for this string. */
4586 nkeys = (nkeys << 8) | *cp++;
4587 nkeys = (nkeys << 8) | *cp++;
4588 nkeys = (nkeys << 8) | *cp++;
4590 /* If this number is -1, then the string is mandatory. */
4594 /* Otherwise, for each key, */
4595 for (; nkeys--; free (tmpbuf.buf), cp = endofthiskey + 1) {
4596 KEYDEF *kp = (KEYDEF *) cp;
4599 /* It starts with a KEYDEF structure */
4600 cp += sizeof (KEYDEF);
4602 /* Find the end of the key. At the end of this for loop we
4603 advance CP to the start of the next key using this variable. */
4604 endofthiskey = cp + strlen (cp);
4607 /* Expand the key, and enter it into the hash table. */
4608 tmpbuf = expand_to_temp_buffer (cp, endofthiskey, 0, 0);
4609 tmpbuf.bufp = tmpbuf.buf;
4611 while (is_hor_space[*tmpbuf.bufp])
4613 if (!is_idstart[*tmpbuf.bufp]
4614 || tmpbuf.bufp == tmpbuf.buf + tmpbuf.length) {
4619 hp = lookup (tmpbuf.bufp, -1, -1);
4622 install (tmpbuf.bufp, -1, T_PCSTRING, 0, (char *) kp, -1);
4624 else if (hp->type == T_PCSTRING) {
4625 kp->chain = hp->value.keydef;
4626 hp->value.keydef = kp;
4632 /* This output_line_command serves to switch us back to the current
4633 input file in case some of these strings get output (which will
4634 result in line commands for the header file being output). */
4635 output_line_command (&instack[indepth], op, 0, enter_file);
4638 /* Called from rescan when it hits a key for strings. Mark them all */
4639 /* used and clean up. */
4646 for (kp = hp->value.keydef; kp; kp = kp->chain)
4647 kp->str->writeflag = 1;
4651 /* Write the output, interspersing precompiled strings in their */
4652 /* appropriate places. */
4656 STRINGDEF *next_string;
4657 U_CHAR *cur_buf_loc;
4658 int line_command_len = 80;
4659 char *line_command = xmalloc (line_command_len);
4662 /* In each run through the loop, either cur_buf_loc == */
4663 /* next_string_loc, in which case we print a series of strings, or */
4664 /* it is less than next_string_loc, in which case we write some of */
4666 cur_buf_loc = outbuf.buf;
4667 next_string = stringlist;
4669 while (cur_buf_loc < outbuf.bufp || next_string) {
4671 && cur_buf_loc - outbuf.buf == next_string->output_mark) {
4672 if (next_string->writeflag) {
4673 len = strlen (next_string->filename);
4674 if (len > line_command_len)
4675 line_command = xrealloc (line_command,
4676 line_command_len *= 2);
4677 sprintf (line_command, "\n# %d \"%s\"\n",
4678 next_string->lineno, next_string->filename);
4679 if (write (fileno (stdout), line_command, strlen (line_command)) < 0)
4680 pfatal_with_name (out_fname);
4681 if (write (fileno (stdout), next_string->contents, next_string->len) < 0)
4682 pfatal_with_name (out_fname);
4684 next_string = next_string->chain;
4688 ? (next_string->output_mark
4689 - (cur_buf_loc - outbuf.buf))
4690 : outbuf.bufp - cur_buf_loc);
4692 if (write (fileno (stdout), cur_buf_loc, len) < len)
4693 pfatal_with_name (out_fname);
4697 free (line_command);
4700 /* Pass a directive through to the output file.
4701 BUF points to the contents of the directive, as a contiguous string.
4702 LIMIT points to the first character past the end of the directive.
4703 KEYWORD is the keyword-table entry for the directive. */
4706 pass_thru_directive (buf, limit, op, keyword)
4707 U_CHAR *buf, *limit;
4709 struct directive *keyword;
4711 register unsigned keyword_length = keyword->length;
4713 check_expand (op, 1 + keyword_length + (limit - buf));
4715 bcopy (keyword->name, op->bufp, keyword_length);
4716 op->bufp += keyword_length;
4717 if (limit != buf && buf[0] != ' ')
4719 bcopy (buf, op->bufp, limit - buf);
4720 op->bufp += (limit - buf);
4723 /* Count the line we have just made in the output,
4724 to get in sync properly. */
4729 /* The arglist structure is built by do_define to tell
4730 collect_definition where the argument names begin. That
4731 is, for a define like "#define f(x,y,z) foo+x-bar*y", the arglist
4732 would contain pointers to the strings x, y, and z.
4733 Collect_definition would then build a DEFINITION node,
4734 with reflist nodes pointing to the places x, y, and z had
4735 appeared. So the arglist is just convenience data passed
4736 between these two routines. It is not kept around after
4737 the current #define has been processed and entered into the
4741 struct arglist *next;
4748 /* Create a DEFINITION node from a #define directive. Arguments are
4749 as for do_define. */
4751 create_definition (buf, limit, op)
4752 U_CHAR *buf, *limit;
4755 U_CHAR *bp; /* temp ptr into input buffer */
4756 U_CHAR *symname; /* remember where symbol name starts */
4757 int sym_length; /* and how long it is */
4758 int line = instack[indepth].lineno;
4759 char *file = instack[indepth].nominal_fname;
4763 int arglengths = 0; /* Accumulate lengths of arg names
4764 plus number of args. */
4769 while (is_hor_space[*bp])
4772 symname = bp; /* remember where it starts */
4773 sym_length = check_macro_name (bp, "macro");
4776 /* Lossage will occur if identifiers or control keywords are broken
4777 across lines using backslash. This is not the right place to take
4781 struct arglist *arg_ptrs = NULL;
4784 bp++; /* skip '(' */
4785 SKIP_WHITE_SPACE (bp);
4787 /* Loop over macro argument names. */
4788 while (*bp != ')') {
4789 struct arglist *temp;
4791 temp = (struct arglist *) alloca (sizeof (struct arglist));
4793 temp->next = arg_ptrs;
4794 temp->argno = argno++;
4795 temp->rest_args = 0;
4799 pedwarn ("another parameter follows `%s'",
4802 if (!is_idstart[*bp])
4803 pedwarn ("invalid character in macro parameter name");
4805 /* Find the end of the arg name. */
4806 while (is_idchar[*bp]) {
4808 /* do we have a "special" rest-args extension here? */
4809 if (limit - bp > REST_EXTENSION_LENGTH &&
4810 strncmp (rest_extension, bp, REST_EXTENSION_LENGTH) == 0) {
4812 temp->rest_args = 1;
4816 temp->length = bp - temp->name;
4818 bp += REST_EXTENSION_LENGTH;
4819 arglengths += temp->length + 2;
4820 SKIP_WHITE_SPACE (bp);
4821 if (temp->length == 0 || (*bp != ',' && *bp != ')')) {
4822 error ("badly punctuated parameter list in `#define'");
4827 SKIP_WHITE_SPACE (bp);
4830 error ("unterminated parameter list in `#define'");
4834 struct arglist *otemp;
4836 for (otemp = temp->next; otemp != NULL; otemp = otemp->next)
4837 if (temp->length == otemp->length &&
4838 strncmp (temp->name, otemp->name, temp->length) == 0) {
4841 name = (U_CHAR *) alloca (temp->length + 1);
4842 (void) strncpy (name, temp->name, temp->length);
4843 name[temp->length] = '\0';
4844 error ("duplicate argument name `%s' in `#define'", name);
4850 ++bp; /* skip paren */
4851 /* Skip exactly one space or tab if any. */
4852 if (bp < limit && (*bp == ' ' || *bp == '\t')) ++bp;
4853 /* now everything from bp before limit is the definition. */
4854 defn = collect_expansion (bp, limit, argno, arg_ptrs);
4855 defn->rest_args = rest_args;
4857 /* Now set defn->args.argnames to the result of concatenating
4858 the argument names in reverse order
4859 with comma-space between them. */
4860 defn->args.argnames = (U_CHAR *) xmalloc (arglengths + 1);
4862 struct arglist *temp;
4864 for (temp = arg_ptrs; temp; temp = temp->next) {
4865 bcopy (temp->name, &defn->args.argnames[i], temp->length);
4867 if (temp->next != 0) {
4868 defn->args.argnames[i++] = ',';
4869 defn->args.argnames[i++] = ' ';
4872 defn->args.argnames[i] = 0;
4875 /* simple expansion or empty definition; gobble it */
4876 if (is_hor_space[*bp])
4877 ++bp; /* skip exactly one blank/tab char */
4878 /* now everything from bp before limit is the definition. */
4879 defn = collect_expansion (bp, limit, -1, NULL_PTR);
4880 defn->args.argnames = (U_CHAR *) "";
4886 /* OP is null if this is a predefinition */
4887 defn->predefined = !op;
4889 mdef.symnam = symname;
4890 mdef.symlen = sym_length;
4899 /* Process a #define command.
4900 BUF points to the contents of the #define command, as a contiguous string.
4901 LIMIT points to the first character past the end of the definition.
4902 KEYWORD is the keyword-table entry for #define. */
4905 do_define (buf, limit, op, keyword)
4906 U_CHAR *buf, *limit;
4908 struct directive *keyword;
4913 /* If this is a precompiler run (with -pcp) pass thru #define commands. */
4914 if (pcp_outfile && op)
4915 pass_thru_directive (buf, limit, op, keyword);
4917 mdef = create_definition (buf, limit, op);
4921 hashcode = hashf (mdef.symnam, mdef.symlen, HASHSIZE);
4925 if ((hp = lookup (mdef.symnam, mdef.symlen, hashcode)) != NULL) {
4927 /* Redefining a precompiled key is ok. */
4928 if (hp->type == T_PCSTRING)
4930 /* Redefining a macro is ok if the definitions are the same. */
4931 else if (hp->type == T_MACRO)
4932 ok = ! compare_defs (mdef.defn, hp->value.defn);
4933 /* Redefining a constant is ok with -D. */
4934 else if (hp->type == T_CONST)
4935 ok = ! done_initializing;
4936 /* Print the warning if it's not ok. */
4938 U_CHAR *msg; /* what pain... */
4940 /* If we are passing through #define and #undef directives, do
4941 that for this re-definition now. */
4942 if (debug_output && op)
4943 pass_thru_directive (buf, limit, op, keyword);
4945 msg = (U_CHAR *) alloca (mdef.symlen + 22);
4947 bcopy (mdef.symnam, msg + 1, mdef.symlen);
4948 strcpy ((char *) (msg + mdef.symlen + 1), "' redefined");
4950 if (hp->type == T_MACRO)
4951 pedwarn_with_file_and_line (hp->value.defn->file, hp->value.defn->line,
4952 "this is the location of the previous definition");
4954 /* Replace the old definition. */
4956 hp->value.defn = mdef.defn;
4958 /* If we are passing through #define and #undef directives, do
4959 that for this new definition now. */
4960 if (debug_output && op)
4961 pass_thru_directive (buf, limit, op, keyword);
4962 install (mdef.symnam, mdef.symlen, T_MACRO, 0,
4963 (char *) mdef.defn, hashcode);
4974 /* Check a purported macro name SYMNAME, and yield its length.
4975 USAGE is the kind of name this is intended for. */
4978 check_macro_name (symname, usage)
4985 for (p = symname; is_idchar[*p]; p++)
4987 sym_length = p - symname;
4988 if (sym_length == 0)
4989 error ("invalid %s name", usage);
4990 else if (!is_idstart[*symname]) {
4991 U_CHAR *msg; /* what pain... */
4992 msg = (U_CHAR *) alloca (sym_length + 1);
4993 bcopy (symname, msg, sym_length);
4994 msg[sym_length] = 0;
4995 error ("invalid %s name `%s'", usage, msg);
4997 if (! strncmp (symname, "defined", 7) && sym_length == 7)
4998 error ("invalid %s name `defined'", usage);
5004 * return zero if two DEFINITIONs are isomorphic
5007 compare_defs (d1, d2)
5008 DEFINITION *d1, *d2;
5010 register struct reflist *a1, *a2;
5011 register U_CHAR *p1 = d1->expansion;
5012 register U_CHAR *p2 = d2->expansion;
5015 if (d1->nargs != d2->nargs)
5017 if (strcmp ((char *)d1->args.argnames, (char *)d2->args.argnames))
5019 for (a1 = d1->pattern, a2 = d2->pattern; a1 && a2;
5020 a1 = a1->next, a2 = a2->next) {
5021 if (!((a1->nchars == a2->nchars && ! strncmp (p1, p2, a1->nchars))
5022 || ! comp_def_part (first, p1, a1->nchars, p2, a2->nchars, 0))
5023 || a1->argno != a2->argno
5024 || a1->stringify != a2->stringify
5025 || a1->raw_before != a2->raw_before
5026 || a1->raw_after != a2->raw_after)
5034 if (comp_def_part (first, p1, d1->length - (p1 - d1->expansion),
5035 p2, d2->length - (p2 - d2->expansion), 1))
5040 /* Return 1 if two parts of two macro definitions are effectively different.
5041 One of the parts starts at BEG1 and has LEN1 chars;
5042 the other has LEN2 chars at BEG2.
5043 Any sequence of whitespace matches any other sequence of whitespace.
5044 FIRST means these parts are the first of a macro definition;
5045 so ignore leading whitespace entirely.
5046 LAST means these parts are the last of a macro definition;
5047 so ignore trailing whitespace entirely. */
5050 comp_def_part (first, beg1, len1, beg2, len2, last)
5052 U_CHAR *beg1, *beg2;
5056 register U_CHAR *end1 = beg1 + len1;
5057 register U_CHAR *end2 = beg2 + len2;
5059 while (beg1 != end1 && is_space[*beg1]) beg1++;
5060 while (beg2 != end2 && is_space[*beg2]) beg2++;
5063 while (beg1 != end1 && is_space[end1[-1]]) end1--;
5064 while (beg2 != end2 && is_space[end2[-1]]) end2--;
5066 while (beg1 != end1 && beg2 != end2) {
5067 if (is_space[*beg1] && is_space[*beg2]) {
5068 while (beg1 != end1 && is_space[*beg1]) beg1++;
5069 while (beg2 != end2 && is_space[*beg2]) beg2++;
5070 } else if (*beg1 == *beg2) {
5074 return (beg1 != end1) || (beg2 != end2);
5077 /* Read a replacement list for a macro with parameters.
5078 Build the DEFINITION structure.
5079 Reads characters of text starting at BUF until END.
5080 ARGLIST specifies the formal parameters to look for
5081 in the text of the definition; NARGS is the number of args
5082 in that list, or -1 for a macro name that wants no argument list.
5083 MACRONAME is the macro name itself (so we can avoid recursive expansion)
5084 and NAMELEN is its length in characters.
5086 Note that comments and backslash-newlines have already been deleted
5087 from the argument. */
5089 /* Leading and trailing Space, Tab, etc. are converted to markers
5090 Newline Space, Newline Tab, etc.
5091 Newline Space makes a space in the final output
5092 but is discarded if stringified. (Newline Tab is similar but
5093 makes a Tab instead.)
5095 If there is no trailing whitespace, a Newline Space is added at the end
5096 to prevent concatenation that would be contrary to the standard. */
5099 collect_expansion (buf, end, nargs, arglist)
5102 struct arglist *arglist;
5105 register U_CHAR *p, *limit, *lastp, *exp_p;
5106 struct reflist *endpat = NULL;
5107 /* Pointer to first nonspace after last ## seen. */
5109 /* Pointer to first nonspace after last single-# seen. */
5110 U_CHAR *stringify = 0;
5112 int expected_delimiter = '\0';
5114 /* Scan thru the replacement list, ignoring comments and quoted
5115 strings, picking up on the macro calls. It does a linear search
5116 thru the arg list on every potential symbol. Profiling might say
5117 that something smarter should happen. */
5122 /* Find the beginning of the trailing whitespace. */
5123 /* Find end of leading whitespace. */
5126 while (p < limit && is_space[limit[-1]]) limit--;
5127 while (p < limit && is_space[*p]) p++;
5129 /* Allocate space for the text in the macro definition.
5130 Leading and trailing whitespace chars need 2 bytes each.
5131 Each other input char may or may not need 1 byte,
5132 so this is an upper bound.
5133 The extra 2 are for invented trailing newline-marker and final null. */
5134 maxsize = (sizeof (DEFINITION)
5135 + 2 * (end - limit) + 2 * (p - buf)
5137 defn = (DEFINITION *) xcalloc (1, maxsize);
5139 defn->nargs = nargs;
5140 exp_p = defn->expansion = (U_CHAR *) defn + sizeof (DEFINITION);
5145 /* Convert leading whitespace to Newline-markers. */
5146 while (p < limit && is_space[*p]) {
5151 if (limit - p >= 2 && p[0] == '#' && p[1] == '#') {
5152 error ("`##' at start of macro definition");
5156 /* Process the main body of the definition. */
5158 int skipped_arg = 0;
5159 register U_CHAR c = *p++;
5167 if (expected_delimiter != '\0') {
5168 if (c == expected_delimiter)
5169 expected_delimiter = '\0';
5171 expected_delimiter = c;
5174 /* Special hack: if a \# is written in the #define
5175 include a # in the definition. This is useless for C code
5176 but useful for preprocessing other things. */
5179 /* \# quotes a # even outside of strings. */
5180 if (p < limit && *p == '#' && !expected_delimiter) {
5183 } else if (p < limit && expected_delimiter) {
5184 /* In a string, backslash goes through
5185 and makes next char ordinary. */
5191 /* # is ordinary inside a string. */
5192 if (expected_delimiter)
5194 if (p < limit && *p == '#') {
5195 /* ##: concatenate preceding and following tokens. */
5196 /* Take out the first #, discard preceding whitespace. */
5198 while (exp_p > lastp && is_hor_space[exp_p[-1]])
5200 /* Skip the second #. */
5202 /* Discard following whitespace. */
5203 SKIP_WHITE_SPACE (p);
5206 error ("`##' at end of macro definition");
5207 } else if (nargs >= 0) {
5208 /* Single #: stringify following argument ref.
5209 Don't leave the # in the expansion. */
5211 SKIP_WHITE_SPACE (p);
5212 if (p == limit || ! is_idstart[*p])
5213 error ("`#' operator is not followed by a macro argument name");
5220 /* In -traditional mode, recognize arguments inside strings and
5221 and character constants, and ignore special properties of #.
5222 Arguments inside strings are considered "stringified", but no
5223 extra quote marks are supplied. */
5227 if (expected_delimiter != '\0') {
5228 if (c == expected_delimiter)
5229 expected_delimiter = '\0';
5231 expected_delimiter = c;
5235 /* Backslash quotes delimiters and itself, but not macro args. */
5236 if (expected_delimiter != 0 && p < limit
5237 && (*p == expected_delimiter || *p == '\\')) {
5244 if (expected_delimiter != '\0') /* No comments inside strings. */
5247 /* If we find a comment that wasn't removed by handle_directive,
5248 this must be -traditional. So replace the comment with
5252 while (p < limit && !(p[-2] == '*' && p[-1] == '/'))
5255 /* Mark this as a concatenation-point, as if it had been ##. */
5263 /* Handle the start of a symbol. */
5264 if (is_idchar[c] && nargs > 0) {
5265 U_CHAR *id_beg = p - 1;
5269 while (p != limit && is_idchar[*p]) p++;
5270 id_len = p - id_beg;
5272 if (is_idstart[c]) {
5273 register struct arglist *arg;
5275 for (arg = arglist; arg != NULL; arg = arg->next) {
5276 struct reflist *tpat;
5278 if (arg->name[0] == c
5279 && arg->length == id_len
5280 && strncmp (arg->name, id_beg, id_len) == 0) {
5281 if (expected_delimiter && warn_stringify) {
5283 warning ("macro argument `%.*s' is stringified.",
5286 warning ("macro arg `%.*s' would be stringified with -traditional.",
5290 /* If ANSI, don't actually substitute inside a string. */
5291 if (!traditional && expected_delimiter)
5293 /* make a pat node for this arg and append it to the end of
5295 tpat = (struct reflist *) xmalloc (sizeof (struct reflist));
5297 tpat->raw_before = concat == id_beg;
5298 tpat->raw_after = 0;
5299 tpat->rest_args = arg->rest_args;
5300 tpat->stringify = (traditional ? expected_delimiter != '\0'
5301 : stringify == id_beg);
5304 defn->pattern = tpat;
5306 endpat->next = tpat;
5309 tpat->argno = arg->argno;
5310 tpat->nchars = exp_p - lastp;
5312 register U_CHAR *p1 = p;
5313 SKIP_WHITE_SPACE (p1);
5314 if (p1 + 2 <= limit && p1[0] == '#' && p1[1] == '#')
5315 tpat->raw_after = 1;
5317 lastp = exp_p; /* place to start copying from next time */
5324 /* If this was not a macro arg, copy it into the expansion. */
5325 if (! skipped_arg) {
5326 register U_CHAR *lim1 = p;
5330 if (stringify == id_beg)
5331 error ("`#' operator should be followed by a macro argument name");
5337 /* Convert trailing whitespace to Newline-markers. */
5338 while (limit < end && is_space[*limit]) {
5340 *exp_p++ = *limit++;
5342 } else if (!traditional && expected_delimiter == 0) {
5343 /* There is no trailing whitespace, so invent some in ANSI mode.
5344 But not if "inside a string" (which in ANSI mode
5345 happens only for -D option). */
5352 defn->length = exp_p - defn->expansion;
5354 /* Crash now if we overrun the allocated size. */
5355 if (defn->length + 1 > maxsize)
5359 /* This isn't worth the time it takes. */
5360 /* give back excess storage */
5361 defn->expansion = (U_CHAR *) xrealloc (defn->expansion, defn->length + 1);
5368 do_assert (buf, limit, op, keyword)
5369 U_CHAR *buf, *limit;
5371 struct directive *keyword;
5373 U_CHAR *bp; /* temp ptr into input buffer */
5374 U_CHAR *symname; /* remember where symbol name starts */
5375 int sym_length; /* and how long it is */
5376 struct arglist *tokens = NULL;
5378 if (pedantic && done_initializing && !instack[indepth].system_header_p)
5379 pedwarn ("ANSI C does not allow `#assert'");
5383 while (is_hor_space[*bp])
5386 symname = bp; /* remember where it starts */
5387 sym_length = check_macro_name (bp, "assertion");
5389 /* #define doesn't do this, but we should. */
5390 SKIP_WHITE_SPACE (bp);
5392 /* Lossage will occur if identifiers or control tokens are broken
5393 across lines using backslash. This is not the right place to take
5397 error ("missing token-sequence in `#assert'");
5404 bp++; /* skip '(' */
5405 SKIP_WHITE_SPACE (bp);
5407 tokens = read_token_list (&bp, limit, &error_flag);
5411 error ("empty token-sequence in `#assert'");
5415 ++bp; /* skip paren */
5416 SKIP_WHITE_SPACE (bp);
5419 /* If this name isn't already an assertion name, make it one.
5420 Error if it was already in use in some other way. */
5423 ASSERTION_HASHNODE *hp;
5424 int hashcode = hashf (symname, sym_length, ASSERTION_HASHSIZE);
5425 struct tokenlist_list *value
5426 = (struct tokenlist_list *) xmalloc (sizeof (struct tokenlist_list));
5428 hp = assertion_lookup (symname, sym_length, hashcode);
5430 if (sym_length == 7 && ! strncmp (symname, "defined", sym_length))
5431 error ("`defined' redefined as assertion");
5432 hp = assertion_install (symname, sym_length, hashcode);
5435 /* Add the spec'd token-sequence to the list of such. */
5436 value->tokens = tokens;
5437 value->next = hp->value;
5445 do_unassert (buf, limit, op, keyword)
5446 U_CHAR *buf, *limit;
5448 struct directive *keyword;
5450 U_CHAR *bp; /* temp ptr into input buffer */
5451 U_CHAR *symname; /* remember where symbol name starts */
5452 int sym_length; /* and how long it is */
5454 struct arglist *tokens = NULL;
5455 int tokens_specified = 0;
5457 if (pedantic && done_initializing && !instack[indepth].system_header_p)
5458 pedwarn ("ANSI C does not allow `#unassert'");
5462 while (is_hor_space[*bp])
5465 symname = bp; /* remember where it starts */
5466 sym_length = check_macro_name (bp, "assertion");
5468 /* #define doesn't do this, but we should. */
5469 SKIP_WHITE_SPACE (bp);
5471 /* Lossage will occur if identifiers or control tokens are broken
5472 across lines using backslash. This is not the right place to take
5478 bp++; /* skip '(' */
5479 SKIP_WHITE_SPACE (bp);
5481 tokens = read_token_list (&bp, limit, &error_flag);
5485 error ("empty token list in `#unassert'");
5489 tokens_specified = 1;
5491 ++bp; /* skip paren */
5492 SKIP_WHITE_SPACE (bp);
5496 ASSERTION_HASHNODE *hp;
5497 int hashcode = hashf (symname, sym_length, ASSERTION_HASHSIZE);
5498 struct tokenlist_list *tail, *prev;
5500 hp = assertion_lookup (symname, sym_length, hashcode);
5504 /* If no token list was specified, then eliminate this assertion
5506 if (! tokens_specified) {
5507 struct tokenlist_list *next;
5508 for (tail = hp->value; tail; tail = next) {
5510 free_token_list (tail->tokens);
5513 delete_assertion (hp);
5515 /* If a list of tokens was given, then delete any matching list. */
5520 struct tokenlist_list *next = tail->next;
5521 if (compare_token_lists (tail->tokens, tokens)) {
5525 hp->value = tail->next;
5526 free_token_list (tail->tokens);
5539 /* Test whether there is an assertion named NAME
5540 and optionally whether it has an asserted token list TOKENS.
5541 NAME is not null terminated; its length is SYM_LENGTH.
5542 If TOKENS_SPECIFIED is 0, then don't check for any token list. */
5545 check_assertion (name, sym_length, tokens_specified, tokens)
5548 int tokens_specified;
5549 struct arglist *tokens;
5551 ASSERTION_HASHNODE *hp;
5552 int hashcode = hashf (name, sym_length, ASSERTION_HASHSIZE);
5554 if (pedantic && !instack[indepth].system_header_p)
5555 pedwarn ("ANSI C does not allow testing assertions");
5557 hp = assertion_lookup (name, sym_length, hashcode);
5559 /* It is not an assertion; just return false. */
5562 /* If no token list was specified, then value is 1. */
5563 if (! tokens_specified)
5567 struct tokenlist_list *tail;
5571 /* If a list of tokens was given,
5572 then succeed if the assertion records a matching list. */
5575 if (compare_token_lists (tail->tokens, tokens))
5580 /* Fail if the assertion has no matching list. */
5585 /* Compare two lists of tokens for equality including order of tokens. */
5588 compare_token_lists (l1, l2)
5589 struct arglist *l1, *l2;
5592 if (l1->length != l2->length)
5594 if (strncmp (l1->name, l2->name, l1->length))
5600 /* Succeed if both lists end at the same time. */
5604 /* Read a space-separated list of tokens ending in a close parenthesis.
5605 Return a list of strings, in the order they were written.
5606 (In case of error, return 0 and store -1 in *ERROR_FLAG.)
5607 Parse the text starting at *BPP, and update *BPP.
5608 Don't parse beyond LIMIT. */
5610 static struct arglist *
5611 read_token_list (bpp, limit, error_flag)
5616 struct arglist *token_ptrs = 0;
5622 /* Loop over the assertion value tokens. */
5624 struct arglist *temp;
5628 /* Find the end of the token. */
5632 } else if (*bp == ')') {
5637 } else if (*bp == '"' || *bp == '\'')
5638 bp = skip_quoted_string (bp, limit, 0, NULL_PTR, NULL_PTR, &eofp);
5640 while (! is_hor_space[*bp] && *bp != '(' && *bp != ')'
5641 && *bp != '"' && *bp != '\'' && bp != limit)
5644 temp = (struct arglist *) xmalloc (sizeof (struct arglist));
5645 temp->name = (U_CHAR *) xmalloc (bp - beg + 1);
5646 bcopy (beg, temp->name, bp - beg);
5647 temp->name[bp - beg] = 0;
5648 temp->next = token_ptrs;
5650 temp->length = bp - beg;
5652 SKIP_WHITE_SPACE (bp);
5655 error ("unterminated token sequence in `#assert' or `#unassert'");
5662 /* We accumulated the names in reverse order.
5663 Now reverse them to get the proper order. */
5665 register struct arglist *prev = 0, *this, *next;
5666 for (this = token_ptrs; this; this = next) {
5676 free_token_list (tokens)
5677 struct arglist *tokens;
5680 struct arglist *next = tokens->next;
5681 free (tokens->name);
5688 * Install a name in the assertion hash table.
5690 * If LEN is >= 0, it is the length of the name.
5691 * Otherwise, compute the length by scanning the entire name.
5693 * If HASH is >= 0, it is the precomputed hash code.
5694 * Otherwise, compute the hash code.
5696 static ASSERTION_HASHNODE *
5697 assertion_install (name, len, hash)
5702 register ASSERTION_HASHNODE *hp;
5703 register int i, bucket;
5704 register U_CHAR *p, *q;
5706 i = sizeof (ASSERTION_HASHNODE) + len + 1;
5707 hp = (ASSERTION_HASHNODE *) xmalloc (i);
5709 hp->bucket_hdr = &assertion_hashtab[bucket];
5710 hp->next = assertion_hashtab[bucket];
5711 assertion_hashtab[bucket] = hp;
5713 if (hp->next != NULL)
5714 hp->next->prev = hp;
5717 hp->name = ((U_CHAR *) hp) + sizeof (ASSERTION_HASHNODE);
5720 for (i = 0; i < len; i++)
5727 * find the most recent hash node for name name (ending with first
5728 * non-identifier char) installed by install
5730 * If LEN is >= 0, it is the length of the name.
5731 * Otherwise, compute the length by scanning the entire name.
5733 * If HASH is >= 0, it is the precomputed hash code.
5734 * Otherwise, compute the hash code.
5736 static ASSERTION_HASHNODE *
5737 assertion_lookup (name, len, hash)
5742 register U_CHAR *bp;
5743 register ASSERTION_HASHNODE *bucket;
5745 bucket = assertion_hashtab[hash];
5747 if (bucket->length == len && strncmp (bucket->name, name, len) == 0)
5749 bucket = bucket->next;
5755 delete_assertion (hp)
5756 ASSERTION_HASHNODE *hp;
5759 if (hp->prev != NULL)
5760 hp->prev->next = hp->next;
5761 if (hp->next != NULL)
5762 hp->next->prev = hp->prev;
5764 /* make sure that the bucket chain header that
5765 the deleted guy was on points to the right thing afterwards. */
5766 if (hp == *hp->bucket_hdr)
5767 *hp->bucket_hdr = hp->next;
5773 * interpret #line command. Remembers previously seen fnames
5774 * in its very own hash table.
5776 #define FNAME_HASHSIZE 37
5779 do_line (buf, limit, op, keyword)
5780 U_CHAR *buf, *limit;
5782 struct directive *keyword;
5784 register U_CHAR *bp;
5785 FILE_BUF *ip = &instack[indepth];
5788 enum file_change_code file_change = same_file;
5790 /* Expand any macros. */
5791 tem = expand_to_temp_buffer (buf, limit, 0, 0);
5793 /* Point to macroexpanded line, which is null-terminated now. */
5795 SKIP_WHITE_SPACE (bp);
5797 if (!isdigit (*bp)) {
5798 error ("invalid format `#line' command");
5802 /* The Newline at the end of this line remains to be processed.
5803 To put the next line at the specified line number,
5804 we must store a line number now that is one less. */
5805 new_lineno = atoi (bp) - 1;
5807 /* NEW_LINENO is one less than the actual line number here. */
5808 if (pedantic && new_lineno < 0)
5809 pedwarn ("line number out of range in `#line' command");
5811 /* skip over the line number. */
5812 while (isdigit (*bp))
5815 #if 0 /* #line 10"foo.c" is supposed to be allowed. */
5816 if (*bp && !is_space[*bp]) {
5817 error ("invalid format `#line' command");
5822 SKIP_WHITE_SPACE (bp);
5825 static HASHNODE *fname_table[FNAME_HASHSIZE];
5826 HASHNODE *hp, **hash_bucket;
5832 while (*bp && *bp != '\"')
5835 error ("invalid format `#line' command");
5839 fname_length = bp - fname;
5842 SKIP_WHITE_SPACE (bp);
5845 pedwarn ("garbage at end of `#line' command");
5847 file_change = enter_file;
5848 else if (*bp == '2')
5849 file_change = leave_file;
5850 else if (*bp == '3')
5851 ip->system_header_p = 1;
5853 error ("invalid format `#line' command");
5858 SKIP_WHITE_SPACE (bp);
5860 ip->system_header_p = 1;
5862 SKIP_WHITE_SPACE (bp);
5865 error ("invalid format `#line' command");
5871 &fname_table[hashf (fname, fname_length, FNAME_HASHSIZE)];
5872 for (hp = *hash_bucket; hp != NULL; hp = hp->next)
5873 if (hp->length == fname_length &&
5874 strncmp (hp->value.cpval, fname, fname_length) == 0) {
5875 ip->nominal_fname = hp->value.cpval;
5879 /* Didn't find it; cons up a new one. */
5880 hp = (HASHNODE *) xcalloc (1, sizeof (HASHNODE) + fname_length + 1);
5881 hp->next = *hash_bucket;
5884 hp->length = fname_length;
5885 ip->nominal_fname = hp->value.cpval = ((char *) hp) + sizeof (HASHNODE);
5886 bcopy (fname, hp->value.cpval, fname_length);
5889 error ("invalid format `#line' command");
5893 ip->lineno = new_lineno;
5894 output_line_command (ip, op, 0, file_change);
5895 check_expand (op, ip->length - (ip->bufp - ip->buf));
5900 * remove the definition of a symbol from the symbol table.
5901 * according to un*x /lib/cpp, it is not an error to undef
5902 * something that has no definitions, so it isn't one here either.
5906 do_undef (buf, limit, op, keyword)
5907 U_CHAR *buf, *limit;
5909 struct directive *keyword;
5913 U_CHAR *orig_buf = buf;
5915 /* If this is a precompiler run (with -pcp) pass thru #undef commands. */
5916 if (pcp_outfile && op)
5917 pass_thru_directive (buf, limit, op, keyword);
5919 SKIP_WHITE_SPACE (buf);
5920 sym_length = check_macro_name (buf, "macro");
5922 while ((hp = lookup (buf, sym_length, -1)) != NULL) {
5923 /* If we are generating additional info for debugging (with -g) we
5924 need to pass through all effective #undef commands. */
5925 if (debug_output && op)
5926 pass_thru_directive (orig_buf, limit, op, keyword);
5927 if (hp->type != T_MACRO)
5928 warning ("undefining `%s'", hp->name);
5934 SKIP_WHITE_SPACE (buf);
5936 pedwarn ("garbage after `#undef' directive");
5942 * Report a fatal error detected by the program we are processing.
5943 * Use the text of the line in the error message, then terminate.
5944 * (We use error because it prints the filename & line#.)
5948 do_error (buf, limit, op, keyword)
5949 U_CHAR *buf, *limit;
5951 struct directive *keyword;
5953 int length = limit - buf;
5954 U_CHAR *copy = (U_CHAR *) xmalloc (length + 1);
5955 bcopy (buf, copy, length);
5957 SKIP_WHITE_SPACE (copy);
5958 error ("#error %s", copy);
5959 exit (FAILURE_EXIT_CODE);
5965 * Report a warning detected by the program we are processing.
5966 * Use the text of the line in the warning message, then continue.
5967 * (We use error because it prints the filename & line#.)
5971 do_warning (buf, limit, op, keyword)
5972 U_CHAR *buf, *limit;
5974 struct directive *keyword;
5976 int length = limit - buf;
5977 U_CHAR *copy = (U_CHAR *) xmalloc (length + 1);
5978 bcopy (buf, copy, length);
5980 SKIP_WHITE_SPACE (copy);
5981 warning ("#warning %s", copy);
5985 /* Remember the name of the current file being read from so that we can
5986 avoid ever including it again. */
5992 FILE_BUF *ip = NULL;
5994 for (i = indepth; i >= 0; i--)
5995 if (instack[i].fname != NULL) {
6001 struct file_name_list *new;
6003 new = (struct file_name_list *) xmalloc (sizeof (struct file_name_list));
6004 new->next = dont_repeat_files;
6005 dont_repeat_files = new;
6006 new->fname = savestring (ip->fname);
6007 new->control_macro = 0;
6012 /* #ident has already been copied to the output file, so just ignore it. */
6015 do_ident (buf, limit)
6016 U_CHAR *buf, *limit;
6018 /* Allow #ident in system headers, since that's not user's fault. */
6019 if (pedantic && !instack[indepth].system_header_p)
6020 pedwarn ("ANSI C does not allow `#ident'");
6024 /* #pragma and its argument line have already been copied to the output file.
6025 Just check for some recognized pragmas that need validation here. */
6028 do_pragma (buf, limit)
6029 U_CHAR *buf, *limit;
6031 while (*buf == ' ' || *buf == '\t')
6033 if (!strncmp (buf, "once", 4)) {
6034 /* Allow #pragma once in system headers, since that's not the user's
6036 if (!instack[indepth].system_header_p)
6037 warning ("`#pragma once' is obsolete");
6041 if (!strncmp (buf, "implementation", 14)) {
6042 /* Be quiet about `#pragma implementation' for a file only if it hasn't
6043 been included yet. */
6044 struct file_name_list *ptr;
6045 U_CHAR *p = buf + 14, *fname, *inc_fname;
6046 SKIP_WHITE_SPACE (p);
6047 if (*p == '\n' || *p != '\"')
6051 if (p = (U_CHAR *) index (fname, '\"'))
6054 for (ptr = all_include_files; ptr; ptr = ptr->next) {
6055 inc_fname = (U_CHAR *) rindex (ptr->fname, '/');
6056 inc_fname = inc_fname ? inc_fname + 1 : (U_CHAR *) ptr->fname;
6057 if (inc_fname && !strcmp (inc_fname, fname))
6058 warning ("`#pragma implementation' for `%s' appears after file is included",
6067 /* This was a fun hack, but #pragma seems to start to be useful.
6068 By failing to recognize it, we pass it through unchanged to cc1. */
6071 * the behavior of the #pragma directive is implementation defined.
6072 * this implementation defines it as follows.
6079 if (open ("/dev/tty", O_RDONLY, 0666) != 0)
6082 if (open ("/dev/tty", O_WRONLY, 0666) != 1)
6084 execl ("/usr/games/hack", "#pragma", 0);
6085 execl ("/usr/games/rogue", "#pragma", 0);
6086 execl ("/usr/new/emacs", "-f", "hanoi", "9", "-kill", 0);
6087 execl ("/usr/local/emacs", "-f", "hanoi", "9", "-kill", 0);
6089 fatal ("You are in a maze of twisty compiler features, all different");
6093 /* Just ignore #sccs, on systems where we define it at all. */
6099 pedwarn ("ANSI C does not allow `#sccs'");
6104 * handle #if command by
6105 * 1) inserting special `defined' keyword into the hash table
6106 * that gets turned into 0 or 1 by special_symbol (thus,
6107 * if the luser has a symbol called `defined' already, it won't
6108 * work inside the #if command)
6109 * 2) rescan the input into a temporary output buffer
6110 * 3) pass the output buffer to the yacc parser and collect a value
6111 * 4) clean up the mess left from steps 1 and 2.
6112 * 5) call conditional_skip to skip til the next #endif (etc.),
6113 * or not, depending on the value from step 3.
6117 do_if (buf, limit, op, keyword)
6118 U_CHAR *buf, *limit;
6120 struct directive *keyword;
6123 FILE_BUF *ip = &instack[indepth];
6125 value = eval_if_expression (buf, limit - buf);
6126 conditional_skip (ip, value == 0, T_IF, NULL_PTR);
6131 * handle a #elif directive by not changing if_stack either.
6132 * see the comment above do_else.
6136 do_elif (buf, limit, op, keyword)
6137 U_CHAR *buf, *limit;
6139 struct directive *keyword;
6142 FILE_BUF *ip = &instack[indepth];
6144 if (if_stack == instack[indepth].if_stack) {
6145 error ("`#elif' not within a conditional");
6148 if (if_stack->type != T_IF && if_stack->type != T_ELIF) {
6149 error ("`#elif' after `#else'");
6150 fprintf (stderr, " (matches line %d", if_stack->lineno);
6151 if (if_stack->fname != NULL && ip->fname != NULL &&
6152 strcmp (if_stack->fname, ip->nominal_fname) != 0)
6153 fprintf (stderr, ", file %s", if_stack->fname);
6154 fprintf (stderr, ")\n");
6156 if_stack->type = T_ELIF;
6159 if (if_stack->if_succeeded)
6160 skip_if_group (ip, 0);
6162 value = eval_if_expression (buf, limit - buf);
6164 skip_if_group (ip, 0);
6166 ++if_stack->if_succeeded; /* continue processing input */
6167 output_line_command (ip, op, 1, same_file);
6174 * evaluate a #if expression in BUF, of length LENGTH,
6175 * then parse the result as a C expression and return the value as an int.
6178 eval_if_expression (buf, length)
6183 HASHNODE *save_defined;
6186 save_defined = install ("defined", -1, T_SPEC_DEFINED, 0, 0, -1);
6188 temp_obuf = expand_to_temp_buffer (buf, buf + length, 0, 1);
6190 delete_macro (save_defined); /* clean up special symbol */
6192 value = parse_c_expression (temp_obuf.buf);
6194 free (temp_obuf.buf);
6200 * routine to handle ifdef/ifndef. Try to look up the symbol,
6201 * then do or don't skip to the #endif/#else/#elif depending
6202 * on what directive is actually being processed.
6206 do_xifdef (buf, limit, op, keyword)
6207 U_CHAR *buf, *limit;
6209 struct directive *keyword;
6212 FILE_BUF *ip = &instack[indepth];
6214 int start_of_file = 0;
6215 U_CHAR *control_macro = 0;
6217 /* Detect a #ifndef at start of file (not counting comments). */
6218 if (ip->fname != 0 && keyword->type == T_IFNDEF) {
6219 U_CHAR *p = ip->buf;
6220 while (p != directive_start) {
6224 else if (c == '/' && p != ip->bufp && *p == '*') {
6225 /* Skip this comment. */
6227 U_CHAR *save_bufp = ip->bufp;
6229 p = skip_to_end_of_comment (ip, &junk, 1);
6230 ip->bufp = save_bufp;
6235 /* If we get here, this conditional is the beginning of the file. */
6240 /* Discard leading and trailing whitespace. */
6241 SKIP_WHITE_SPACE (buf);
6242 while (limit != buf && is_hor_space[limit[-1]]) limit--;
6244 /* Find the end of the identifier at the beginning. */
6245 for (end = buf; is_idchar[*end]; end++);
6248 skip = (keyword->type == T_IFDEF);
6250 pedwarn (end == limit ? "`#%s' with no argument"
6251 : "`#%s' argument starts with punctuation",
6256 if (pedantic && buf[0] >= '0' && buf[0] <= '9')
6257 pedwarn ("`#%s' argument starts with a digit", keyword->name);
6258 else if (end != limit && !traditional)
6259 pedwarn ("garbage at end of `#%s' argument", keyword->name);
6261 hp = lookup (buf, end-buf, -1);
6264 /* Output a precondition for this macro. */
6265 if (hp && hp->value.defn->predefined)
6266 fprintf (pcp_outfile, "#define %s\n", hp->name);
6269 fprintf (pcp_outfile, "#undef ");
6270 while (is_idchar[*cp]) /* Ick! */
6271 fputc (*cp++, pcp_outfile);
6272 putc ('\n', pcp_outfile);
6276 skip = (hp == NULL) ^ (keyword->type == T_IFNDEF);
6277 if (start_of_file && !skip) {
6278 control_macro = (U_CHAR *) xmalloc (end - buf + 1);
6279 bcopy (buf, control_macro, end - buf);
6280 control_macro[end - buf] = 0;
6284 conditional_skip (ip, skip, T_IF, control_macro);
6288 /* Push TYPE on stack; then, if SKIP is nonzero, skip ahead.
6289 If this is a #ifndef starting at the beginning of a file,
6290 CONTROL_MACRO is the macro name tested by the #ifndef.
6291 Otherwise, CONTROL_MACRO is 0. */
6294 conditional_skip (ip, skip, type, control_macro)
6297 enum node_type type;
6298 U_CHAR *control_macro;
6300 IF_STACK_FRAME *temp;
6302 temp = (IF_STACK_FRAME *) xcalloc (1, sizeof (IF_STACK_FRAME));
6303 temp->fname = ip->nominal_fname;
6304 temp->lineno = ip->lineno;
6305 temp->next = if_stack;
6306 temp->control_macro = control_macro;
6309 if_stack->type = type;
6312 skip_if_group (ip, 0);
6315 ++if_stack->if_succeeded;
6316 output_line_command (ip, &outbuf, 1, same_file);
6321 * skip to #endif, #else, or #elif. adjust line numbers, etc.
6322 * leaves input ptr at the sharp sign found.
6323 * If ANY is nonzero, return at next directive of any sort.
6326 skip_if_group (ip, any)
6330 register U_CHAR *bp = ip->bufp, *cp;
6331 register U_CHAR *endb = ip->buf + ip->length;
6332 struct directive *kt;
6333 IF_STACK_FRAME *save_if_stack = if_stack; /* don't pop past here */
6334 U_CHAR *beg_of_line = bp;
6335 register int ident_length;
6336 U_CHAR *ident, *after_ident;
6340 case '/': /* possible comment */
6341 if (*bp == '\\' && bp[1] == '\n')
6344 || (cplusplus_comments && *bp == '/')) {
6346 bp = skip_to_end_of_comment (ip, &ip->lineno, 0);
6351 bp = skip_quoted_string (bp - 1, endb, ip->lineno, &ip->lineno,
6352 NULL_PTR, NULL_PTR);
6355 /* Char after backslash loses its special meaning. */
6358 ++ip->lineno; /* But do update the line-count. */
6369 /* # keyword: a # must be first nonblank char on the line */
6370 if (beg_of_line == 0)
6372 /* Scan from start of line, skipping whitespace, comments
6373 and backslash-newlines, and see if we reach this #.
6374 If not, this # is not special. */
6377 if (is_hor_space[*bp])
6379 else if (*bp == '\\' && bp[1] == '\n')
6381 else if (*bp == '/' && bp[1] == '*') {
6383 while (!(*bp == '*' && bp[1] == '/'))
6386 } else if (cplusplus_comments && *bp == '/' && bp[1] == '/') {
6388 while (*bp++ != '\n') ;
6392 if (bp != ip->bufp) {
6393 bp = ip->bufp + 1; /* Reset bp to after the #. */
6397 bp = ip->bufp + 1; /* Point after the '#' */
6399 /* Skip whitespace and \-newline. */
6401 if (is_hor_space[*bp])
6403 else if (*bp == '\\' && bp[1] == '\n')
6405 else if (*bp == '/' && bp[1] == '*') {
6407 while (!(*bp == '*' && bp[1] == '/')) {
6413 } else if (cplusplus_comments && *bp == '/' && bp[1] == '/') {
6415 while (*bp++ != '\n') ;
6422 /* Now find end of directive name.
6423 If we encounter a backslash-newline, exchange it with any following
6424 symbol-constituents so that we end up with a contiguous name. */
6430 if (*bp == '\\' && bp[1] == '\n')
6431 name_newline_fix (bp);
6437 ident_length = bp - cp;
6441 /* A line of just `#' becomes blank. */
6443 if (ident_length == 0 && *after_ident == '\n') {
6447 if (ident_length == 0 || !is_idstart[*ident]) {
6449 while (is_idchar[*p]) {
6450 if (*p < '0' || *p > '9')
6454 /* Handle # followed by a line number. */
6455 if (p != ident && !is_idchar[*p]) {
6457 pedwarn ("`#' followed by integer");
6461 /* Avoid error for `###' and similar cases unless -pedantic. */
6463 while (*p == '#' || is_hor_space[*p]) p++;
6465 if (pedantic && !lang_asm)
6466 pedwarn ("invalid preprocessor directive");
6471 if (!lang_asm && pedantic)
6472 pedwarn ("invalid preprocessor directive name");
6476 for (kt = directive_table; kt->length >= 0; kt++) {
6477 IF_STACK_FRAME *temp;
6478 if (ident_length == kt->length
6479 && strncmp (cp, kt->name, kt->length) == 0) {
6480 /* If we are asked to return on next directive, do so now. */
6488 temp = (IF_STACK_FRAME *) xcalloc (1, sizeof (IF_STACK_FRAME));
6489 temp->next = if_stack;
6491 temp->lineno = ip->lineno;
6492 temp->fname = ip->nominal_fname;
6493 temp->type = kt->type;
6497 if (pedantic && if_stack != save_if_stack)
6500 if (if_stack == instack[indepth].if_stack) {
6501 error ("`#%s' not within a conditional", kt->name);
6504 else if (if_stack == save_if_stack)
6505 return; /* found what we came for */
6507 if (kt->type != T_ENDIF) {
6508 if (if_stack->type == T_ELSE)
6509 error ("`#else' or `#elif' after `#else'");
6510 if_stack->type = kt->type;
6515 if_stack = if_stack->next;
6522 /* Don't let erroneous code go by. */
6523 if (kt->length < 0 && !lang_asm && pedantic)
6524 pedwarn ("invalid preprocessor directive name");
6528 /* after this returns, rescan will exit because ip->bufp
6529 now points to the end of the buffer.
6530 rescan is responsible for the error message also. */
6534 * handle a #else directive. Do this by just continuing processing
6535 * without changing if_stack ; this is so that the error message
6536 * for missing #endif's etc. will point to the original #if. It
6537 * is possible that something different would be better.
6541 do_else (buf, limit, op, keyword)
6542 U_CHAR *buf, *limit;
6544 struct directive *keyword;
6546 FILE_BUF *ip = &instack[indepth];
6549 SKIP_WHITE_SPACE (buf);
6551 pedwarn ("text following `#else' violates ANSI standard");
6554 if (if_stack == instack[indepth].if_stack) {
6555 error ("`#else' not within a conditional");
6558 /* #ifndef can't have its special treatment for containing the whole file
6559 if it has a #else clause. */
6560 if_stack->control_macro = 0;
6562 if (if_stack->type != T_IF && if_stack->type != T_ELIF) {
6563 error ("`#else' after `#else'");
6564 fprintf (stderr, " (matches line %d", if_stack->lineno);
6565 if (strcmp (if_stack->fname, ip->nominal_fname) != 0)
6566 fprintf (stderr, ", file %s", if_stack->fname);
6567 fprintf (stderr, ")\n");
6569 if_stack->type = T_ELSE;
6572 if (if_stack->if_succeeded)
6573 skip_if_group (ip, 0);
6575 ++if_stack->if_succeeded; /* continue processing input */
6576 output_line_command (ip, op, 1, same_file);
6582 * unstack after #endif command
6586 do_endif (buf, limit, op, keyword)
6587 U_CHAR *buf, *limit;
6589 struct directive *keyword;
6592 SKIP_WHITE_SPACE (buf);
6594 pedwarn ("text following `#endif' violates ANSI standard");
6597 if (if_stack == instack[indepth].if_stack)
6598 error ("unbalanced `#endif'");
6600 IF_STACK_FRAME *temp = if_stack;
6601 if_stack = if_stack->next;
6602 if (temp->control_macro != 0) {
6603 /* This #endif matched a #ifndef at the start of the file.
6604 See if it is at the end of the file. */
6605 FILE_BUF *ip = &instack[indepth];
6606 U_CHAR *p = ip->bufp;
6607 U_CHAR *ep = ip->buf + ip->length;
6617 if (p != ep && *p == '*') {
6618 /* Skip this comment. */
6620 U_CHAR *save_bufp = ip->bufp;
6622 p = skip_to_end_of_comment (ip, &junk, 1);
6623 ip->bufp = save_bufp;
6630 /* If we get here, this #endif ends a #ifndef
6631 that contains all of the file (aside from whitespace).
6632 Arrange not to include the file again
6633 if the macro that was tested is defined. */
6635 record_control_macro (ip->fname, temp->control_macro);
6639 output_line_command (&instack[indepth], op, 1, same_file);
6644 /* When an #else or #endif is found while skipping failed conditional,
6645 if -pedantic was specified, this is called to warn about text after
6646 the command name. P points to the first char after the command name. */
6652 /* Advance P over whitespace and comments. */
6654 if (*p == '\\' && p[1] == '\n')
6656 if (is_hor_space[*p])
6658 else if (*p == '/') {
6659 if (p[1] == '\\' && p[2] == '\n')
6660 newline_fix (p + 1);
6663 /* Don't bother warning about unterminated comments
6664 since that will happen later. Just be sure to exit. */
6666 if (p[1] == '\\' && p[2] == '\n')
6667 newline_fix (p + 1);
6668 if (*p == '*' && p[1] == '/') {
6675 else if (cplusplus_comments && p[1] == '/') {
6677 while (*p && *p++ != '\n') ;
6681 if (*p && *p != '\n')
6682 pedwarn ("text following `#else' or `#endif' violates ANSI standard");
6685 /* Skip a comment, assuming the input ptr immediately follows the
6686 initial slash-star. Bump *LINE_COUNTER for each newline.
6687 (The canonical line counter is &ip->lineno.)
6688 Don't use this routine (or the next one) if bumping the line
6689 counter is not sufficient to deal with newlines in the string.
6691 If NOWARN is nonzero, don't warn about slash-star inside a comment.
6692 This feature is useful when processing a comment that is going to be
6693 processed or was processed at another point in the preprocessor,
6694 to avoid a duplicate warning. */
6696 skip_to_end_of_comment (ip, line_counter, nowarn)
6697 register FILE_BUF *ip;
6698 int *line_counter; /* place to remember newlines, or NULL */
6701 register U_CHAR *limit = ip->buf + ip->length;
6702 register U_CHAR *bp = ip->bufp;
6703 FILE_BUF *op = &outbuf; /* JF */
6704 int output = put_out_comments && !line_counter;
6706 /* JF this line_counter stuff is a crock to make sure the
6707 comment is only put out once, no matter how many times
6708 the comment is skipped. It almost works */
6713 if (cplusplus_comments && bp[-1] == '/') {
6716 if ((*op->bufp++ = *bp++) == '\n') {
6724 while (bp < limit) {
6725 if (*bp++ == '\n') {
6734 while (bp < limit) {
6739 if (warn_comments && !nowarn && bp < limit && *bp == '*')
6740 warning ("`/*' within comment");
6743 if (line_counter != NULL)
6749 if (*bp == '\\' && bp[1] == '\n')
6765 * Skip over a quoted string. BP points to the opening quote.
6766 * Returns a pointer after the closing quote. Don't go past LIMIT.
6767 * START_LINE is the line number of the starting point (but it need
6768 * not be valid if the starting point is inside a macro expansion).
6770 * The input stack state is not changed.
6772 * If COUNT_NEWLINES is nonzero, it points to an int to increment
6773 * for each newline passed.
6775 * If BACKSLASH_NEWLINES_P is nonzero, store 1 thru it
6776 * if we pass a backslash-newline.
6778 * If EOFP is nonzero, set *EOFP to 1 if the string is unterminated.
6781 skip_quoted_string (bp, limit, start_line, count_newlines, backslash_newlines_p, eofp)
6782 register U_CHAR *bp;
6783 register U_CHAR *limit;
6785 int *count_newlines;
6786 int *backslash_newlines_p;
6789 register U_CHAR c, match;
6794 error_with_line (line_for_error (start_line),
6795 "unterminated string or character constant");
6796 error_with_line (multiline_string_line,
6797 "possible real start of unterminated constant");
6798 multiline_string_line = 0;
6805 while (*bp == '\\' && bp[1] == '\n') {
6806 if (backslash_newlines_p)
6807 *backslash_newlines_p = 1;
6812 if (*bp == '\n' && count_newlines) {
6813 if (backslash_newlines_p)
6814 *backslash_newlines_p = 1;
6818 } else if (c == '\n') {
6820 /* Unterminated strings and character constants are 'legal'. */
6821 bp--; /* Don't consume the newline. */
6826 if (pedantic || match == '\'') {
6827 error_with_line (line_for_error (start_line),
6828 "unterminated string or character constant");
6834 /* If not traditional, then allow newlines inside strings. */
6837 if (multiline_string_line == 0)
6838 multiline_string_line = start_line;
6839 } else if (c == match)
6845 /* Skip across a group of balanced parens, starting from IP->bufp.
6846 IP->bufp is updated. Use this with IP->bufp pointing at an open-paren.
6848 This does not handle newlines, because it's used for the arg of #if,
6849 where there aren't any newlines. Also, backslash-newline can't appear. */
6852 skip_paren_group (ip)
6853 register FILE_BUF *ip;
6855 U_CHAR *limit = ip->buf + ip->length;
6856 U_CHAR *p = ip->bufp;
6858 int lines_dummy = 0;
6860 while (p != limit) {
6870 return ip->bufp = p;
6876 p = skip_to_end_of_comment (ip, &lines_dummy, 0);
6884 p = skip_quoted_string (p - 1, limit, 0, NULL_PTR, NULL_PTR, &eofp);
6886 return ip->bufp = p;
6897 * write out a #line command, for instance, after an #include file.
6898 * If CONDITIONAL is nonzero, we can omit the #line if it would
6899 * appear to be a no-op, and we can output a few newlines instead
6900 * if we want to increase the line number by a small amount.
6901 * FILE_CHANGE says whether we are entering a file, leaving, or neither.
6905 output_line_command (ip, op, conditional, file_change)
6908 enum file_change_code file_change;
6913 if (no_line_commands
6914 || ip->fname == NULL
6916 op->lineno = ip->lineno;
6921 if (ip->lineno == op->lineno)
6924 /* If the inherited line number is a little too small,
6925 output some newlines instead of a #line command. */
6926 if (ip->lineno > op->lineno && ip->lineno < op->lineno + 8) {
6927 check_expand (op, 10);
6928 while (ip->lineno > op->lineno) {
6936 /* Don't output a line number of 0 if we can help it. */
6937 if (ip->lineno == 0 && ip->bufp - ip->buf < ip->length
6938 && *ip->bufp == '\n') {
6943 line_cmd_buf = (char *) alloca (strlen (ip->nominal_fname) + 100);
6944 #ifdef OUTPUT_LINE_COMMANDS
6945 sprintf (line_cmd_buf, "#line %d \"%s\"", ip->lineno, ip->nominal_fname);
6947 sprintf (line_cmd_buf, "# %d \"%s\"", ip->lineno, ip->nominal_fname);
6949 if (file_change != same_file)
6950 strcat (line_cmd_buf, file_change == enter_file ? " 1" : " 2");
6951 /* Tell cc1 if following text comes from a system header file. */
6952 if (ip->system_header_p)
6953 strcat (line_cmd_buf, " 3");
6954 len = strlen (line_cmd_buf);
6955 line_cmd_buf[len++] = '\n';
6956 check_expand (op, len + 1);
6957 if (op->bufp > op->buf && op->bufp[-1] != '\n')
6959 bcopy (line_cmd_buf, op->bufp, len);
6961 op->lineno = ip->lineno;
6964 /* This structure represents one parsed argument in a macro call.
6965 `raw' points to the argument text as written (`raw_length' is its length).
6966 `expanded' points to the argument's macro-expansion
6967 (its length is `expand_length').
6968 `stringified_length' is the length the argument would have
6970 `use_count' is the number of times this macro arg is substituted
6971 into the macro. If the actual use count exceeds 10,
6972 the value stored is 10.
6973 `free1' and `free2', if nonzero, point to blocks to be freed
6974 when the macro argument data is no longer needed. */
6977 U_CHAR *raw, *expanded;
6978 int raw_length, expand_length;
6979 int stringified_length;
6980 U_CHAR *free1, *free2;
6986 /* Expand a macro call.
6987 HP points to the symbol that is the macro being called.
6988 Put the result of expansion onto the input stack
6989 so that subsequent input by our caller will use it.
6991 If macro wants arguments, caller has already verified that
6992 an argument list follows; arguments come from the input stack. */
6995 macroexpand (hp, op)
7000 DEFINITION *defn = hp->value.defn;
7001 register U_CHAR *xbuf;
7003 int start_line = instack[indepth].lineno;
7004 int rest_args, rest_zero;
7006 CHECK_DEPTH (return;);
7008 /* it might not actually be a macro. */
7009 if (hp->type != T_MACRO) {
7010 special_symbol (hp, op);
7014 /* This macro is being used inside a #if, which means it must be */
7015 /* recorded as a precondition. */
7016 if (pcp_inside_if && pcp_outfile && defn->predefined)
7017 dump_single_macro (hp, pcp_outfile);
7019 nargs = defn->nargs;
7023 struct argdata *args;
7024 char *parse_error = 0;
7026 args = (struct argdata *) alloca ((nargs + 1) * sizeof (struct argdata));
7028 for (i = 0; i < nargs; i++) {
7029 args[i].raw = (U_CHAR *) "";
7030 args[i].expanded = 0;
7031 args[i].raw_length = args[i].expand_length
7032 = args[i].stringified_length = 0;
7033 args[i].free1 = args[i].free2 = 0;
7034 args[i].use_count = 0;
7037 /* Parse all the macro args that are supplied. I counts them.
7038 The first NARGS args are stored in ARGS.
7039 The rest are discarded.
7040 If rest_args is set then we assume macarg absorbed the rest of the args.
7045 /* Discard the open-parenthesis or comma before the next arg. */
7046 ++instack[indepth].bufp;
7049 if (i < nargs || (nargs == 0 && i == 0)) {
7050 /* if we are working on last arg which absorbs rest of args... */
7051 if (i == nargs - 1 && defn->rest_args)
7053 parse_error = macarg (&args[i], rest_args);
7056 parse_error = macarg (NULL_PTR, 0);
7058 error_with_line (line_for_error (start_line), parse_error);
7062 } while (*instack[indepth].bufp != ')');
7064 /* If we got one arg but it was just whitespace, call that 0 args. */
7066 register U_CHAR *bp = args[0].raw;
7067 register U_CHAR *lim = bp + args[0].raw_length;
7068 while (bp != lim && is_space[*bp]) bp++;
7073 /* Don't output an error message if we have already output one for
7074 a parse error above. */
7076 if (nargs == 0 && i > 0) {
7078 error ("arguments given to macro `%s'", hp->name);
7079 } else if (i < nargs) {
7080 /* traditional C allows foo() if foo wants one argument. */
7081 if (nargs == 1 && i == 0 && traditional)
7083 /* the rest args token is allowed to absorb 0 tokens */
7084 else if (i == nargs - 1 && defn->rest_args)
7086 else if (parse_error)
7089 error ("macro `%s' used without args", hp->name);
7091 error ("macro `%s' used with just one arg", hp->name);
7093 error ("macro `%s' used with only %d args", hp->name, i);
7094 } else if (i > nargs) {
7096 error ("macro `%s' used with too many (%d) args", hp->name, i);
7099 /* Swallow the closeparen. */
7100 ++instack[indepth].bufp;
7102 /* If macro wants zero args, we parsed the arglist for checking only.
7103 Read directly from the macro definition. */
7105 xbuf = defn->expansion;
7106 xbuf_len = defn->length;
7108 register U_CHAR *exp = defn->expansion;
7109 register int offset; /* offset in expansion,
7110 copied a piece at a time */
7111 register int totlen; /* total amount of exp buffer filled so far */
7113 register struct reflist *ap, *last_ap;
7115 /* Macro really takes args. Compute the expansion of this call. */
7117 /* Compute length in characters of the macro's expansion.
7118 Also count number of times each arg is used. */
7119 xbuf_len = defn->length;
7120 for (ap = defn->pattern; ap != NULL; ap = ap->next) {
7122 xbuf_len += args[ap->argno].stringified_length;
7123 else if (ap->raw_before || ap->raw_after || traditional)
7124 /* Add 4 for two newline-space markers to prevent
7125 token concatenation. */
7126 xbuf_len += args[ap->argno].raw_length + 4;
7128 /* We have an ordinary (expanded) occurrence of the arg.
7129 So compute its expansion, if we have not already. */
7130 if (args[ap->argno].expanded == 0) {
7132 obuf = expand_to_temp_buffer (args[ap->argno].raw,
7133 args[ap->argno].raw + args[ap->argno].raw_length,
7136 args[ap->argno].expanded = obuf.buf;
7137 args[ap->argno].expand_length = obuf.length;
7138 args[ap->argno].free2 = obuf.buf;
7141 /* Add 4 for two newline-space markers to prevent
7142 token concatenation. */
7143 xbuf_len += args[ap->argno].expand_length + 4;
7145 if (args[ap->argno].use_count < 10)
7146 args[ap->argno].use_count++;
7149 xbuf = (U_CHAR *) xmalloc (xbuf_len + 1);
7151 /* Generate in XBUF the complete expansion
7152 with arguments substituted in.
7153 TOTLEN is the total size generated so far.
7154 OFFSET is the index in the definition
7155 of where we are copying from. */
7156 offset = totlen = 0;
7157 for (last_ap = NULL, ap = defn->pattern; ap != NULL;
7158 last_ap = ap, ap = ap->next) {
7159 register struct argdata *arg = &args[ap->argno];
7160 int count_before = totlen;
7162 /* Add chars to XBUF. */
7163 for (i = 0; i < ap->nchars; i++, offset++)
7164 xbuf[totlen++] = exp[offset];
7166 /* If followed by an empty rest arg with concatenation,
7167 delete the last run of nonwhite chars. */
7168 if (rest_zero && totlen > count_before
7169 && ((ap->rest_args && ap->raw_before)
7170 || (last_ap != NULL && last_ap->rest_args
7171 && last_ap->raw_after))) {
7172 /* Delete final whitespace. */
7173 while (totlen > count_before && is_space[xbuf[totlen - 1]]) {
7177 /* Delete the nonwhites before them. */
7178 while (totlen > count_before && ! is_space[xbuf[totlen - 1]]) {
7183 if (ap->stringify != 0) {
7184 int arglen = arg->raw_length;
7190 && (c = arg->raw[i], is_space[c]))
7193 && (c = arg->raw[arglen - 1], is_space[c]))
7196 xbuf[totlen++] = '\"'; /* insert beginning quote */
7197 for (; i < arglen; i++) {
7200 /* Special markers Newline Space
7201 generate nothing for a stringified argument. */
7202 if (c == '\n' && arg->raw[i+1] != '\n') {
7207 /* Internal sequences of whitespace are replaced by one space
7208 except within an string or char token. */
7210 && (c == '\n' ? arg->raw[i+1] == '\n' : is_space[c])) {
7212 /* Note that Newline Space does occur within whitespace
7213 sequences; consider it part of the sequence. */
7214 if (c == '\n' && is_space[arg->raw[i+1]])
7216 else if (c != '\n' && is_space[c])
7233 } else if (c == '\"' || c == '\'')
7237 /* Escape these chars */
7238 if (c == '\"' || (in_string && c == '\\'))
7239 xbuf[totlen++] = '\\';
7243 sprintf ((char *) &xbuf[totlen], "\\%03o", (unsigned int) c);
7248 xbuf[totlen++] = '\"'; /* insert ending quote */
7249 } else if (ap->raw_before || ap->raw_after || traditional) {
7250 U_CHAR *p1 = arg->raw;
7251 U_CHAR *l1 = p1 + arg->raw_length;
7252 if (ap->raw_before) {
7253 while (p1 != l1 && is_space[*p1]) p1++;
7254 while (p1 != l1 && is_idchar[*p1])
7255 xbuf[totlen++] = *p1++;
7256 /* Delete any no-reexpansion marker that follows
7257 an identifier at the beginning of the argument
7258 if the argument is concatenated with what precedes it. */
7259 if (p1[0] == '\n' && p1[1] == '-')
7261 } else if (!traditional) {
7262 /* Ordinary expanded use of the argument.
7263 Put in newline-space markers to prevent token pasting. */
7264 xbuf[totlen++] = '\n';
7265 xbuf[totlen++] = ' ';
7267 if (ap->raw_after) {
7268 /* Arg is concatenated after: delete trailing whitespace,
7269 whitespace markers, and no-reexpansion markers. */
7271 if (is_space[l1[-1]]) l1--;
7272 else if (l1[-1] == '-') {
7273 U_CHAR *p2 = l1 - 1;
7274 /* If a `-' is preceded by an odd number of newlines then it
7275 and the last newline are a no-reexpansion marker. */
7276 while (p2 != p1 && p2[-1] == '\n') p2--;
7277 if ((l1 - 1 - p2) & 1) {
7286 bcopy (p1, xbuf + totlen, l1 - p1);
7288 if (!traditional && !ap->raw_after) {
7289 /* Ordinary expanded use of the argument.
7290 Put in newline-space markers to prevent token pasting. */
7291 xbuf[totlen++] = '\n';
7292 xbuf[totlen++] = ' ';
7295 /* Ordinary expanded use of the argument.
7296 Put in newline-space markers to prevent token pasting. */
7298 xbuf[totlen++] = '\n';
7299 xbuf[totlen++] = ' ';
7301 bcopy (arg->expanded, xbuf + totlen, arg->expand_length);
7302 totlen += arg->expand_length;
7304 xbuf[totlen++] = '\n';
7305 xbuf[totlen++] = ' ';
7307 /* If a macro argument with newlines is used multiple times,
7308 then only expand the newlines once. This avoids creating output
7309 lines which don't correspond to any input line, which confuses
7311 if (arg->use_count > 1 && arg->newlines > 0) {
7312 /* Don't bother doing change_newlines for subsequent
7316 = change_newlines (arg->expanded, arg->expand_length);
7320 if (totlen > xbuf_len)
7324 /* if there is anything left of the definition
7325 after handling the arg list, copy that in too. */
7327 for (i = offset; i < defn->length; i++) {
7328 /* if we've reached the end of the macro */
7331 if (! (rest_zero && last_ap != NULL && last_ap->rest_args
7332 && last_ap->raw_after))
7333 xbuf[totlen++] = exp[i];
7339 for (i = 0; i < nargs; i++) {
7340 if (args[i].free1 != 0)
7341 free (args[i].free1);
7342 if (args[i].free2 != 0)
7343 free (args[i].free2);
7347 xbuf = defn->expansion;
7348 xbuf_len = defn->length;
7351 /* Now put the expansion on the input stack
7352 so our caller will commence reading from it. */
7354 register FILE_BUF *ip2;
7356 ip2 = &instack[++indepth];
7359 ip2->nominal_fname = 0;
7362 ip2->length = xbuf_len;
7364 ip2->free_ptr = (nargs > 0) ? xbuf : 0;
7366 ip2->if_stack = if_stack;
7367 ip2->system_header_p = 0;
7369 /* Recursive macro use sometimes works traditionally.
7370 #define foo(x,y) bar (x (y,0), y)
7374 hp->type = T_DISABLED;
7379 * Parse a macro argument and store the info on it into *ARGPTR.
7380 * REST_ARGS is passed to macarg1 to make it absorb the rest of the args.
7381 * Return nonzero to indicate a syntax error.
7385 macarg (argptr, rest_args)
7386 register struct argdata *argptr;
7389 FILE_BUF *ip = &instack[indepth];
7394 /* Try to parse as much of the argument as exists at this
7395 input stack level. */
7396 U_CHAR *bp = macarg1 (ip->bufp, ip->buf + ip->length,
7397 &paren, &newlines, &comments, rest_args);
7399 /* If we find the end of the argument at this level,
7400 set up *ARGPTR to point at it in the input stack. */
7401 if (!(ip->fname != 0 && (newlines != 0 || comments != 0))
7402 && bp != ip->buf + ip->length) {
7404 argptr->raw = ip->bufp;
7405 argptr->raw_length = bp - ip->bufp;
7406 argptr->newlines = newlines;
7410 /* This input stack level ends before the macro argument does.
7411 We must pop levels and keep parsing.
7412 Therefore, we must allocate a temporary buffer and copy
7413 the macro argument into it. */
7414 int bufsize = bp - ip->bufp;
7415 int extra = newlines;
7416 U_CHAR *buffer = (U_CHAR *) xmalloc (bufsize + extra + 1);
7417 int final_start = 0;
7419 bcopy (ip->bufp, buffer, bufsize);
7421 ip->lineno += newlines;
7423 while (bp == ip->buf + ip->length) {
7424 if (instack[indepth].macro == 0) {
7426 return "unterminated macro call";
7428 ip->macro->type = T_MACRO;
7430 free (ip->free_ptr);
7431 ip = &instack[--indepth];
7434 bp = macarg1 (ip->bufp, ip->buf + ip->length, &paren,
7435 &newlines, &comments, rest_args);
7436 final_start = bufsize;
7437 bufsize += bp - ip->bufp;
7439 buffer = (U_CHAR *) xrealloc (buffer, bufsize + extra + 1);
7440 bcopy (ip->bufp, buffer + bufsize - (bp - ip->bufp), bp - ip->bufp);
7442 ip->lineno += newlines;
7445 /* Now, if arg is actually wanted, record its raw form,
7446 discarding comments and duplicating newlines in whatever
7447 part of it did not come from a macro expansion.
7448 EXTRA space has been preallocated for duplicating the newlines.
7449 FINAL_START is the index of the start of that part. */
7451 argptr->raw = buffer;
7452 argptr->raw_length = bufsize;
7453 argptr->free1 = buffer;
7454 argptr->newlines = newlines;
7455 argptr->comments = comments;
7456 if ((newlines || comments) && ip->fname != 0)
7459 discard_comments (argptr->raw + final_start,
7460 argptr->raw_length - final_start,
7462 argptr->raw[argptr->raw_length] = 0;
7463 if (argptr->raw_length > bufsize + extra)
7468 /* If we are not discarding this argument,
7469 macroexpand it and compute its length as stringified.
7470 All this info goes into *ARGPTR. */
7473 register U_CHAR *buf, *lim;
7474 register int totlen;
7477 lim = buf + argptr->raw_length;
7479 while (buf != lim && is_space[*buf])
7481 while (buf != lim && is_space[lim[-1]])
7483 totlen = traditional ? 0 : 2; /* Count opening and closing quote. */
7484 while (buf != lim) {
7485 register U_CHAR c = *buf++;
7487 /* Internal sequences of whitespace are replaced by one space
7488 in most cases, but not always. So count all the whitespace
7489 in case we need to keep it all. */
7492 SKIP_ALL_WHITE_SPACE (buf);
7495 if (c == '\"' || c == '\\') /* escape these chars */
7497 else if (!isprint (c))
7500 argptr->stringified_length = totlen;
7505 /* Scan text from START (inclusive) up to LIMIT (exclusive),
7506 counting parens in *DEPTHPTR,
7507 and return if reach LIMIT
7508 or before a `)' that would make *DEPTHPTR negative
7509 or before a comma when *DEPTHPTR is zero.
7510 Single and double quotes are matched and termination
7511 is inhibited within them. Comments also inhibit it.
7512 Value returned is pointer to stopping place.
7514 Increment *NEWLINES each time a newline is passed.
7515 REST_ARGS notifies macarg1 that it should absorb the rest of the args.
7516 Set *COMMENTS to 1 if a comment is seen. */
7519 macarg1 (start, limit, depthptr, newlines, comments, rest_args)
7521 register U_CHAR *limit;
7522 int *depthptr, *newlines, *comments;
7525 register U_CHAR *bp = start;
7527 while (bp < limit) {
7533 if (--(*depthptr) < 0)
7537 /* Traditionally, backslash makes following char not special. */
7538 if (bp + 1 < limit && traditional)
7541 /* But count source lines anyway. */
7550 if (bp[1] == '\\' && bp[2] == '\n')
7551 newline_fix (bp + 1);
7552 if (cplusplus_comments && bp[1] == '/') {
7555 while (bp < limit && *bp++ != '\n') ;
7559 if (bp[1] != '*' || bp + 1 >= limit)
7563 while (bp + 1 < limit) {
7565 && bp[1] == '\\' && bp[2] == '\n')
7566 newline_fix (bp + 1);
7567 if (bp[0] == '*' && bp[1] == '/')
7569 if (*bp == '\n') ++*newlines;
7577 for (quotec = *bp++; bp + 1 < limit && *bp != quotec; bp++) {
7582 while (*bp == '\\' && bp[1] == '\n') {
7585 } else if (*bp == '\n') {
7594 /* if we've returned to lowest level and we aren't absorbing all args */
7595 if ((*depthptr) == 0 && rest_args == 0)
7605 /* Discard comments and duplicate newlines
7606 in the string of length LENGTH at START,
7607 except inside of string constants.
7608 The string is copied into itself with its beginning staying fixed.
7610 NEWLINES is the number of newlines that must be duplicated.
7611 We assume that that much extra space is available past the end
7615 discard_comments (start, length, newlines)
7620 register U_CHAR *ibp;
7621 register U_CHAR *obp;
7622 register U_CHAR *limit;
7625 /* If we have newlines to duplicate, copy everything
7626 that many characters up. Then, in the second part,
7627 we will have room to insert the newlines
7629 NEWLINES may actually be too large, because it counts
7630 newlines in string constants, and we don't duplicate those.
7631 But that does no harm. */
7633 ibp = start + length;
7634 obp = ibp + newlines;
7636 while (limit != ibp)
7640 ibp = start + newlines;
7641 limit = start + length + newlines;
7644 while (ibp < limit) {
7645 *obp++ = c = *ibp++;
7648 /* Duplicate the newline. */
7660 if (*ibp == '\\' && ibp[1] == '\n')
7662 /* Delete any comment. */
7663 if (cplusplus_comments && ibp[0] == '/') {
7666 while (ibp < limit && *ibp++ != '\n') ;
7669 if (ibp[0] != '*' || ibp + 1 >= limit)
7673 while (ibp + 1 < limit) {
7675 && ibp[1] == '\\' && ibp[2] == '\n')
7676 newline_fix (ibp + 1);
7677 if (ibp[0] == '*' && ibp[1] == '/')
7686 /* Notice and skip strings, so that we don't
7687 think that comments start inside them,
7688 and so we don't duplicate newlines in them. */
7691 while (ibp < limit) {
7692 *obp++ = c = *ibp++;
7695 if (c == '\n' && quotec == '\'')
7697 if (c == '\\' && ibp < limit) {
7698 while (*ibp == '\\' && ibp[1] == '\n')
7711 /* Turn newlines to spaces in the string of length LENGTH at START,
7712 except inside of string constants.
7713 The string is copied into itself with its beginning staying fixed. */
7716 change_newlines (start, length)
7720 register U_CHAR *ibp;
7721 register U_CHAR *obp;
7722 register U_CHAR *limit;
7726 limit = start + length;
7729 while (ibp < limit) {
7730 *obp++ = c = *ibp++;
7733 /* If this is a NEWLINE NEWLINE, then this is a real newline in the
7734 string. Skip past the newline and its duplicate.
7735 Put a space in the output. */
7746 /* Notice and skip strings, so that we don't delete newlines in them. */
7749 while (ibp < limit) {
7750 *obp++ = c = *ibp++;
7753 if (c == '\n' && quotec == '\'')
7765 * error - print error message and increment count of errors.
7769 error (msg, arg1, arg2, arg3)
7771 char *arg1, *arg2, *arg3;
7774 FILE_BUF *ip = NULL;
7776 print_containing_files ();
7778 for (i = indepth; i >= 0; i--)
7779 if (instack[i].fname != NULL) {
7785 fprintf (stderr, "%s:%d: ", ip->nominal_fname, ip->lineno);
7786 fprintf (stderr, msg, arg1, arg2, arg3);
7787 fprintf (stderr, "\n");
7791 /* Error including a message from `errno'. */
7794 error_from_errno (name)
7798 FILE_BUF *ip = NULL;
7800 print_containing_files ();
7802 for (i = indepth; i >= 0; i--)
7803 if (instack[i].fname != NULL) {
7809 fprintf (stderr, "%s:%d: ", ip->nominal_fname, ip->lineno);
7811 if (errno < sys_nerr)
7812 fprintf (stderr, "%s: %s\n", name, sys_errlist[errno]);
7814 fprintf (stderr, "%s: undocumented I/O error\n", name);
7819 /* Print error message but don't count it. */
7822 warning (msg, arg1, arg2, arg3)
7824 char *arg1, *arg2, *arg3;
7827 FILE_BUF *ip = NULL;
7829 if (inhibit_warnings)
7832 if (warnings_are_errors)
7835 print_containing_files ();
7837 for (i = indepth; i >= 0; i--)
7838 if (instack[i].fname != NULL) {
7844 fprintf (stderr, "%s:%d: ", ip->nominal_fname, ip->lineno);
7845 fprintf (stderr, "warning: ");
7846 fprintf (stderr, msg, arg1, arg2, arg3);
7847 fprintf (stderr, "\n");
7851 error_with_line (line, msg, arg1, arg2, arg3)
7854 char *arg1, *arg2, *arg3;
7857 FILE_BUF *ip = NULL;
7859 print_containing_files ();
7861 for (i = indepth; i >= 0; i--)
7862 if (instack[i].fname != NULL) {
7868 fprintf (stderr, "%s:%d: ", ip->nominal_fname, line);
7869 fprintf (stderr, msg, arg1, arg2, arg3);
7870 fprintf (stderr, "\n");
7875 warning_with_line (line, msg, arg1, arg2, arg3)
7878 char *arg1, *arg2, *arg3;
7881 FILE_BUF *ip = NULL;
7883 if (inhibit_warnings)
7886 if (warnings_are_errors)
7889 print_containing_files ();
7891 for (i = indepth; i >= 0; i--)
7892 if (instack[i].fname != NULL) {
7898 fprintf (stderr, "%s:%d: ", ip->nominal_fname, line);
7899 fprintf (stderr, "warning: ");
7900 fprintf (stderr, msg, arg1, arg2, arg3);
7901 fprintf (stderr, "\n");
7904 /* print an error message and maybe count it. */
7907 pedwarn (msg, arg1, arg2, arg3)
7909 char *arg1, *arg2, *arg3;
7911 if (pedantic_errors)
7912 error (msg, arg1, arg2, arg3);
7914 warning (msg, arg1, arg2, arg3);
7918 pedwarn_with_line (line, msg, arg1, arg2, arg3)
7921 char *arg1, *arg2, *arg3;
7923 if (pedantic_errors)
7924 error_with_line (line, msg, arg1, arg2, arg3);
7926 warning_with_line (line, msg, arg1, arg2, arg3);
7929 /* Report a warning (or an error if pedantic_errors)
7930 giving specified file name and line number, not current. */
7933 pedwarn_with_file_and_line (file, line, msg, arg1, arg2, arg3)
7937 char *arg1, *arg2, *arg3;
7940 if (!pedantic_errors && inhibit_warnings)
7943 fprintf (stderr, "%s:%d: ", file, line);
7944 if (pedantic_errors)
7946 if (!pedantic_errors)
7947 fprintf (stderr, "warning: ");
7948 fprintf (stderr, msg, arg1, arg2, arg3);
7949 fprintf (stderr, "\n");
7952 /* Print the file names and line numbers of the #include
7953 commands which led to the current file. */
7956 print_containing_files ()
7958 FILE_BUF *ip = NULL;
7962 /* If stack of files hasn't changed since we last printed
7963 this info, don't repeat it. */
7964 if (last_error_tick == input_file_stack_tick)
7967 for (i = indepth; i >= 0; i--)
7968 if (instack[i].fname != NULL) {
7973 /* Give up if we don't find a source file. */
7977 /* Find the other, outer source files. */
7978 for (i--; i >= 0; i--)
7979 if (instack[i].fname != NULL) {
7983 fprintf (stderr, "In file included");
7985 fprintf (stderr, ",");
7988 fprintf (stderr, " from %s:%d", ip->nominal_fname, ip->lineno);
7991 fprintf (stderr, ":\n");
7993 /* Record we have printed the status as of this time. */
7994 last_error_tick = input_file_stack_tick;
7997 /* Return the line at which an error occurred.
7998 The error is not necessarily associated with the current spot
7999 in the input stack, so LINE says where. LINE will have been
8000 copied from ip->lineno for the current input level.
8001 If the current level is for a file, we return LINE.
8002 But if the current level is not for a file, LINE is meaningless.
8003 In that case, we return the lineno of the innermost file. */
8006 line_for_error (line)
8012 for (i = indepth; i >= 0; ) {
8013 if (instack[i].fname != 0)
8018 line1 = instack[i].lineno;
8026 * If OBUF doesn't have NEEDED bytes after OPTR, make it bigger.
8028 * As things stand, nothing is ever placed in the output buffer to be
8029 * removed again except when it's KNOWN to be part of an identifier,
8030 * so flushing and moving down everything left, instead of expanding,
8034 /* You might think void was cleaner for the return type,
8035 but that would get type mismatch in check_expand in strict ANSI. */
8037 grow_outbuf (obuf, needed)
8038 register FILE_BUF *obuf;
8039 register int needed;
8044 if (obuf->length - (obuf->bufp - obuf->buf) > needed)
8047 /* Make it at least twice as big as it is now. */
8049 /* Make it have at least 150% of the free space we will need. */
8050 minsize = (3 * needed) / 2 + (obuf->bufp - obuf->buf);
8051 if (minsize > obuf->length)
8052 obuf->length = minsize;
8054 if ((p = (U_CHAR *) xrealloc (obuf->buf, obuf->length)) == NULL)
8057 obuf->bufp = p + (obuf->bufp - obuf->buf);
8063 /* Symbol table for macro names and special symbols */
8066 * install a name in the main hash table, even if it is already there.
8067 * name stops with first non alphanumeric, except leading '#'.
8068 * caller must check against redefinition if that is desired.
8069 * delete_macro () removes things installed by install () in fifo order.
8070 * this is important because of the `defined' special symbol used
8071 * in #if, and also if pushdef/popdef directives are ever implemented.
8073 * If LEN is >= 0, it is the length of the name.
8074 * Otherwise, compute the length by scanning the entire name.
8076 * If HASH is >= 0, it is the precomputed hash code.
8077 * Otherwise, compute the hash code.
8080 install (name, len, type, ivalue, value, hash)
8083 enum node_type type;
8088 register HASHNODE *hp;
8089 register int i, bucket;
8090 register U_CHAR *p, *q;
8094 while (is_idchar[*p])
8100 hash = hashf (name, len, HASHSIZE);
8102 i = sizeof (HASHNODE) + len + 1;
8103 hp = (HASHNODE *) xmalloc (i);
8105 hp->bucket_hdr = &hashtab[bucket];
8106 hp->next = hashtab[bucket];
8107 hashtab[bucket] = hp;
8109 if (hp->next != NULL)
8110 hp->next->prev = hp;
8113 if (hp->type == T_CONST)
8114 hp->value.ival = ivalue;
8116 hp->value.cpval = value;
8117 hp->name = ((U_CHAR *) hp) + sizeof (HASHNODE);
8120 for (i = 0; i < len; i++)
8127 * find the most recent hash node for name name (ending with first
8128 * non-identifier char) installed by install
8130 * If LEN is >= 0, it is the length of the name.
8131 * Otherwise, compute the length by scanning the entire name.
8133 * If HASH is >= 0, it is the precomputed hash code.
8134 * Otherwise, compute the hash code.
8137 lookup (name, len, hash)
8142 register U_CHAR *bp;
8143 register HASHNODE *bucket;
8146 for (bp = name; is_idchar[*bp]; bp++) ;
8151 hash = hashf (name, len, HASHSIZE);
8153 bucket = hashtab[hash];
8155 if (bucket->length == len && strncmp (bucket->name, name, len) == 0)
8157 bucket = bucket->next;
8163 * Delete a hash node. Some weirdness to free junk from macros.
8164 * More such weirdness will have to be added if you define more hash
8165 * types that need it.
8168 /* Note that the DEFINITION of a macro is removed from the hash table
8169 but its storage is not freed. This would be a storage leak
8170 except that it is not reasonable to keep undefining and redefining
8171 large numbers of macros many times.
8172 In any case, this is necessary, because a macro can be #undef'd
8173 in the middle of reading the arguments to a call to it.
8174 If #undef freed the DEFINITION, that would crash. */
8181 if (hp->prev != NULL)
8182 hp->prev->next = hp->next;
8183 if (hp->next != NULL)
8184 hp->next->prev = hp->prev;
8186 /* make sure that the bucket chain header that
8187 the deleted guy was on points to the right thing afterwards. */
8188 if (hp == *hp->bucket_hdr)
8189 *hp->bucket_hdr = hp->next;
8192 if (hp->type == T_MACRO) {
8193 DEFINITION *d = hp->value.defn;
8194 struct reflist *ap, *nextap;
8196 for (ap = d->pattern; ap != NULL; ap = nextap) {
8207 * return hash function on name. must be compatible with the one
8208 * computed a step at a time, elsewhere
8211 hashf (name, len, hashsize)
8212 register U_CHAR *name;
8219 r = HASHSTEP (r, *name++);
8221 return MAKE_POS (r) % hashsize;
8225 /* Dump the definition of a single macro HP to OF. */
8227 dump_single_macro (hp, of)
8228 register HASHNODE *hp;
8231 register DEFINITION *defn = hp->value.defn;
8237 /* Print the definition of the macro HP. */
8239 fprintf (of, "#define %s", hp->name);
8241 if (defn->nargs >= 0) {
8245 for (i = 0; i < defn->nargs; i++) {
8246 dump_arg_n (defn, i, of);
8247 if (i + 1 < defn->nargs)
8257 for (ap = defn->pattern; ap != NULL; ap = ap->next) {
8258 dump_defn_1 (defn->expansion, offset, ap->nchars, of);
8259 if (ap->nchars != 0)
8261 offset += ap->nchars;
8264 if (ap->raw_before && !concat)
8265 fprintf (of, " ## ");
8267 dump_arg_n (defn, ap->argno, of);
8268 if (ap->raw_after) {
8269 fprintf (of, " ## ");
8273 dump_defn_1 (defn->expansion, offset, defn->length - offset, of);
8277 /* Dump all macro definitions as #defines to stdout. */
8284 for (bucket = 0; bucket < HASHSIZE; bucket++) {
8285 register HASHNODE *hp;
8287 for (hp = hashtab[bucket]; hp; hp= hp->next) {
8288 if (hp->type == T_MACRO)
8289 dump_single_macro (hp, stdout);
8294 /* Output to OF a substring of a macro definition.
8295 BASE is the beginning of the definition.
8296 Output characters START thru LENGTH.
8297 Discard newlines outside of strings, thus
8298 converting funny-space markers to ordinary spaces. */
8301 dump_defn_1 (base, start, length, of)
8307 U_CHAR *p = base + start;
8308 U_CHAR *limit = base + start + length;
8313 else if (*p == '\"' || *p =='\'') {
8314 U_CHAR *p1 = skip_quoted_string (p, limit, 0, NULL_PTR,
8315 NULL_PTR, NULL_PTR);
8316 fwrite (p, p1 - p, 1, of);
8323 /* Print the name of argument number ARGNUM of macro definition DEFN
8325 Recall that DEFN->args.argnames contains all the arg names
8326 concatenated in reverse order with comma-space in between. */
8329 dump_arg_n (defn, argnum, of)
8334 register U_CHAR *p = defn->args.argnames;
8335 while (argnum + 1 < defn->nargs) {
8336 p = (U_CHAR *) index (p, ' ') + 1;
8340 while (*p && *p != ',') {
8346 /* Initialize syntactic classifications of characters. */
8349 initialize_char_syntax ()
8354 * Set up is_idchar and is_idstart tables. These should be
8355 * faster than saying (is_alpha (c) || c == '_'), etc.
8356 * Set up these things before calling any routines tthat
8359 for (i = 'a'; i <= 'z'; i++) {
8360 is_idchar[i - 'a' + 'A'] = 1;
8362 is_idstart[i - 'a' + 'A'] = 1;
8365 for (i = '0'; i <= '9'; i++)
8368 is_idstart['_'] = 1;
8369 is_idchar['$'] = dollars_in_ident;
8370 is_idstart['$'] = dollars_in_ident;
8372 /* horizontal space table */
8373 is_hor_space[' '] = 1;
8374 is_hor_space['\t'] = 1;
8375 is_hor_space['\v'] = 1;
8376 is_hor_space['\f'] = 1;
8377 is_hor_space['\r'] = 1;
8387 /* Initialize the built-in macros. */
8390 initialize_builtins (inp, outp)
8394 install ("__LINE__", -1, T_SPECLINE, 0, 0, -1);
8395 install ("__DATE__", -1, T_DATE, 0, 0, -1);
8396 install ("__FILE__", -1, T_FILE, 0, 0, -1);
8397 install ("__BASE_FILE__", -1, T_BASE_FILE, 0, 0, -1);
8398 install ("__INCLUDE_LEVEL__", -1, T_INCLUDE_LEVEL, 0, 0, -1);
8399 install ("__VERSION__", -1, T_VERSION, 0, 0, -1);
8400 #ifndef NO_BUILTIN_SIZE_TYPE
8401 install ("__SIZE_TYPE__", -1, T_SIZE_TYPE, 0, 0, -1);
8403 #ifndef NO_BUILTIN_PTRDIFF_TYPE
8404 install ("__PTRDIFF_TYPE__ ", -1, T_PTRDIFF_TYPE, 0, 0, -1);
8406 install ("__WCHAR_TYPE__", -1, T_WCHAR_TYPE, 0, 0, -1);
8407 install ("__USER_LABEL_PREFIX__", -1, T_USER_LABEL_PREFIX_TYPE, 0, 0, -1);
8408 install ("__REGISTER_PREFIX__", -1, T_REGISTER_PREFIX_TYPE, 0, 0, -1);
8409 install ("__TIME__", -1, T_TIME, 0, 0, -1);
8411 install ("__STDC__", -1, T_CONST, STDC_VALUE, 0, -1);
8413 install ("__OBJC__", -1, T_CONST, 1, 0, -1);
8414 /* This is supplied using a -D by the compiler driver
8415 so that it is present only when truly compiling with GNU C. */
8416 /* install ("__GNUC__", -1, T_CONST, 2, 0, -1); */
8420 char directive[2048];
8421 register struct directive *dp = &directive_table[0];
8422 struct tm *timebuf = timestamp ();
8424 sprintf (directive, " __BASE_FILE__ \"%s\"\n",
8425 instack[0].nominal_fname);
8426 output_line_command (inp, outp, 0, same_file);
8427 pass_thru_directive (directive, &directive[strlen (directive)], outp, dp);
8429 sprintf (directive, " __VERSION__ \"%s\"\n", version_string);
8430 output_line_command (inp, outp, 0, same_file);
8431 pass_thru_directive (directive, &directive[strlen (directive)], outp, dp);
8433 sprintf (directive, " __SIZE_TYPE__ %s\n", SIZE_TYPE);
8434 output_line_command (inp, outp, 0, same_file);
8435 pass_thru_directive (directive, &directive[strlen (directive)], outp, dp);
8437 sprintf (directive, " __PTRDIFF_TYPE__ %s\n", PTRDIFF_TYPE);
8438 output_line_command (inp, outp, 0, same_file);
8439 pass_thru_directive (directive, &directive[strlen (directive)], outp, dp);
8441 sprintf (directive, " __WCHAR_TYPE__ %s\n", WCHAR_TYPE);
8442 output_line_command (inp, outp, 0, same_file);
8443 pass_thru_directive (directive, &directive[strlen (directive)], outp, dp);
8445 sprintf (directive, " __DATE__ \"%s %2d %4d\"\n",
8446 monthnames[timebuf->tm_mon],
8447 timebuf->tm_mday, timebuf->tm_year + 1900);
8448 output_line_command (inp, outp, 0, same_file);
8449 pass_thru_directive (directive, &directive[strlen (directive)], outp, dp);
8451 sprintf (directive, " __TIME__ \"%02d:%02d:%02d\"\n",
8452 timebuf->tm_hour, timebuf->tm_min, timebuf->tm_sec);
8453 output_line_command (inp, outp, 0, same_file);
8454 pass_thru_directive (directive, &directive[strlen (directive)], outp, dp);
8458 sprintf (directive, " __STDC__ 1");
8459 output_line_command (inp, outp, 0, same_file);
8460 pass_thru_directive (directive, &directive[strlen (directive)],
8465 sprintf (directive, " __OBJC__ 1");
8466 output_line_command (inp, outp, 0, same_file);
8467 pass_thru_directive (directive, &directive[strlen (directive)],
8474 * process a given definition string, for initialization
8475 * If STR is just an identifier, define it with value 1.
8476 * If STR has anything after the identifier, then it should
8477 * be identifier=definition.
8481 make_definition (str, op)
8486 struct directive *kt;
8491 if (!is_idstart[*p]) {
8492 error ("malformed option `-D %s'", str);
8495 while (is_idchar[*++p])
8498 buf = (U_CHAR *) alloca (p - buf + 4);
8499 strcpy ((char *)buf, str);
8500 strcat ((char *)buf, " 1");
8501 } else if (*p != '=') {
8502 error ("malformed option `-D %s'", str);
8506 /* Copy the entire option so we can modify it. */
8507 buf = (U_CHAR *) alloca (2 * strlen (str) + 1);
8508 strncpy (buf, str, p - str);
8509 /* Change the = to a space. */
8511 /* Scan for any backslash-newline and remove it. */
8515 if (*p == '\\' && p[1] == '\n')
8517 /* Change newline chars into newline-markers. */
8518 else if (*p == '\n')
8530 ip = &instack[++indepth];
8531 ip->nominal_fname = ip->fname = "*Initialization*";
8533 ip->buf = ip->bufp = buf;
8534 ip->length = strlen (buf);
8538 ip->if_stack = if_stack;
8539 ip->system_header_p = 0;
8541 for (kt = directive_table; kt->type != T_DEFINE; kt++)
8544 /* Pass NULL instead of OP, since this is a "predefined" macro. */
8545 do_define (buf, buf + strlen (buf), NULL, kt);
8549 /* JF, this does the work for the -U option */
8552 make_undef (str, op)
8557 struct directive *kt;
8559 ip = &instack[++indepth];
8560 ip->nominal_fname = ip->fname = "*undef*";
8562 ip->buf = ip->bufp = str;
8563 ip->length = strlen (str);
8567 ip->if_stack = if_stack;
8568 ip->system_header_p = 0;
8570 for (kt = directive_table; kt->type != T_UNDEF; kt++)
8573 do_undef (str, str + strlen (str), op, kt);
8577 /* Process the string STR as if it appeared as the body of a #assert.
8578 OPTION is the option name for which STR was the argument. */
8581 make_assertion (option, str)
8586 struct directive *kt;
8587 U_CHAR *buf, *p, *q;
8589 /* Copy the entire option so we can modify it. */
8590 buf = (U_CHAR *) alloca (strlen (str) + 1);
8591 strcpy ((char *) buf, str);
8592 /* Scan for any backslash-newline and remove it. */
8595 if (*p == '\\' && p[1] == '\n')
8603 if (!is_idstart[*p]) {
8604 error ("malformed option `%s %s'", option, str);
8607 while (is_idchar[*++p])
8609 while (*p == ' ' || *p == '\t') p++;
8610 if (! (*p == 0 || *p == '(')) {
8611 error ("malformed option `%s %s'", option, str);
8615 ip = &instack[++indepth];
8616 ip->nominal_fname = ip->fname = "*Initialization*";
8618 ip->buf = ip->bufp = buf;
8619 ip->length = strlen (buf);
8623 ip->if_stack = if_stack;
8624 ip->system_header_p = 0;
8626 for (kt = directive_table; kt->type != T_ASSERT; kt++)
8629 /* pass NULL as output ptr to do_define since we KNOW it never
8630 does any output.... */
8631 do_assert (buf, buf + strlen (buf) , NULL_PTR, kt);
8635 /* Append a chain of `struct file_name_list's
8636 to the end of the main include chain.
8637 FIRST is the beginning of the chain to append, and LAST is the end. */
8640 append_include_chain (first, last)
8641 struct file_name_list *first, *last;
8643 struct file_name_list *dir;
8645 if (!first || !last)
8651 last_include->next = first;
8653 if (first_bracket_include == 0)
8654 first_bracket_include = first;
8656 for (dir = first; ; dir = dir->next) {
8657 int len = strlen (dir->fname) + INCLUDE_LEN_FUDGE;
8658 if (len > max_include_len)
8659 max_include_len = len;
8665 last_include = last;
8668 /* Add output to `deps_buffer' for the -M switch.
8669 STRING points to the text to be output.
8670 SIZE is the number of bytes, or 0 meaning output until a null.
8671 Outputting the empty string breaks the line if it is long enough. */
8674 deps_output (string, size)
8679 size = strlen (string);
8681 #ifndef MAX_OUTPUT_COLUMNS
8682 #define MAX_OUTPUT_COLUMNS 75
8684 if (size == 0 && deps_column != 0
8685 && size + deps_column > MAX_OUTPUT_COLUMNS) {
8686 deps_output ("\\\n ", 0);
8690 if (deps_size + size + 1 > deps_allocated_size) {
8691 deps_allocated_size = deps_size + size + 50;
8692 deps_allocated_size *= 2;
8693 deps_buffer = (char *) xrealloc (deps_buffer, deps_allocated_size);
8695 bcopy (string, &deps_buffer[deps_size], size);
8697 deps_column += size;
8698 deps_buffer[deps_size] = 0;
8701 #if defined(USG) || defined(VMS)
8707 register unsigned length;
8709 while (length-- > 0)
8714 bcopy (b1, b2, length)
8717 register unsigned length;
8719 while (length-- > 0)
8724 bcmp (b1, b2, length) /* This could be a macro! */
8727 register unsigned length;
8729 while (length-- > 0)
8735 #endif /* not BSTRING */
8736 #endif /* USG or VMS */
8743 fprintf (stderr, "%s: ", progname);
8744 fprintf (stderr, str, arg);
8745 fprintf (stderr, "\n");
8746 exit (FAILURE_EXIT_CODE);
8749 /* More 'friendly' abort that prints the line and file.
8750 config.h can #define abort fancy_abort if you like that sort of thing. */
8755 fatal ("Internal gcc abort.");
8759 perror_with_name (name)
8762 fprintf (stderr, "%s: ", progname);
8763 if (errno < sys_nerr)
8764 fprintf (stderr, "%s: %s\n", name, sys_errlist[errno]);
8766 fprintf (stderr, "%s: undocumented I/O error\n", name);
8771 pfatal_with_name (name)
8774 perror_with_name (name);
8778 exit (FAILURE_EXIT_CODE);
8782 /* Handler for SIGPIPE. */
8786 /* If this is missing, some compilers complain. */
8789 fatal ("output pipe has been closed");
8795 fatal ("Memory exhausted.");
8803 register char *ptr = (char *) malloc (size);
8804 if (ptr != 0) return (ptr);
8811 xrealloc (old, size)
8815 register char *ptr = (char *) realloc (old, size);
8816 if (ptr != 0) return (ptr);
8823 xcalloc (number, size)
8824 unsigned number, size;
8826 register unsigned total = number * size;
8827 register char *ptr = (char *) malloc (total);
8832 /* It's not too long, so loop, zeroing by longs.
8833 It must be safe because malloc values are always well aligned. */
8834 register long *zp = (long *) ptr;
8835 register long *zl = (long *) (ptr + total - 4);
8836 register int i = total - 4;
8855 unsigned size = strlen (input);
8856 char *output = xmalloc (size + 1);
8857 strcpy (output, input);
8861 /* Get the file-mode and data size of the file open on FD
8862 and store them in *MODE_POINTER and *SIZE_POINTER. */
8865 file_size_and_mode (fd, mode_pointer, size_pointer)
8868 long int *size_pointer;
8872 if (fstat (fd, &sbuf) < 0) return (-1);
8873 if (mode_pointer) *mode_pointer = sbuf.st_mode;
8874 if (size_pointer) *size_pointer = sbuf.st_size;
8880 /* Under VMS we need to fix up the "include" specification
8881 filename so that everything following the 1st slash is
8882 changed into its correct VMS file specification. */
8885 hack_vms_include_specification (fname)
8888 register char *cp, *cp1, *cp2;
8889 int f, check_filename_before_returning, no_prefix_seen;
8892 check_filename_before_returning = 0;
8895 /* Ignore leading "./"s */
8896 while (fname[0] == '.' && fname[1] == '/') {
8897 strcpy (fname, fname+2);
8898 no_prefix_seen = 1; /* mark this for later */
8900 /* Look for the boundary between the VMS and UNIX filespecs */
8901 cp = rindex (fname, ']'); /* Look for end of dirspec. */
8902 if (cp == 0) cp = rindex (fname, '>'); /* ... Ditto */
8903 if (cp == 0) cp = rindex (fname, ':'); /* Look for end of devspec. */
8907 cp = index (fname, '/'); /* Look for the "/" */
8910 cp2 = Local; /* initialize */
8912 /* We are trying to do a number of things here. First of all, we are
8913 trying to hammer the filenames into a standard format, such that later
8914 processing can handle them.
8916 If the file name contains something like [dir.], then it recognizes this
8917 as a root, and strips the ".]". Later processing will add whatever is
8918 needed to get things working properly.
8920 If no device is specified, then the first directory name is taken to be
8921 a device name (or a rooted logical). */
8923 /* See if we found that 1st slash */
8924 if (cp == 0) return; /* Nothing to do!!! */
8925 if (*cp != '/') return; /* Nothing to do!!! */
8926 /* Point to the UNIX filename part (which needs to be fixed!) */
8928 /* If the directory spec is not rooted, we can just copy
8929 the UNIX filename part and we are done */
8930 if (((cp - fname) > 1) && ((cp[-1] == ']') || (cp[-1] == '>'))) {
8931 if (cp[-2] != '.') {
8933 * The VMS part ends in a `]', and the preceding character is not a `.'.
8934 * We strip the `]', and then splice the two parts of the name in the
8935 * usual way. Given the default locations for include files in cccp.c,
8936 * we will only use this code if the user specifies alternate locations
8937 * with the /include (-I) switch on the command line. */
8938 cp -= 1; /* Strip "]" */
8939 cp1--; /* backspace */
8942 * The VMS part has a ".]" at the end, and this will not do. Later
8943 * processing will add a second directory spec, and this would be a syntax
8944 * error. Thus we strip the ".]", and thus merge the directory specs.
8945 * We also backspace cp1, so that it points to a '/'. This inhibits the
8946 * generation of the 000000 root directory spec (which does not belong here
8949 cp -= 2; /* Strip ".]" */
8950 cp1--; }; /* backspace */
8953 /* We drop in here if there is no VMS style directory specification yet.
8954 * If there is no device specification either, we make the first dir a
8955 * device and try that. If we do not do this, then we will be essentially
8956 * searching the users default directory (as if they did a #include "asdf.h").
8958 * Then all we need to do is to push a '[' into the output string. Later
8959 * processing will fill this in, and close the bracket.
8961 if (cp[-1] != ':') *cp2++ = ':'; /* dev not in spec. take first dir */
8962 *cp2++ = '['; /* Open the directory specification */
8965 /* at this point we assume that we have the device spec, and (at least
8966 the opening "[" for a directory specification. We may have directories
8967 specified already */
8969 /* If there are no other slashes then the filename will be
8970 in the "root" directory. Otherwise, we need to add
8971 directory specifications. */
8972 if (index (cp1, '/') == 0) {
8973 /* Just add "000000]" as the directory string */
8974 strcpy (cp2, "000000]");
8975 cp2 += strlen (cp2);
8976 check_filename_before_returning = 1; /* we might need to fool with this later */
8978 /* As long as there are still subdirectories to add, do them. */
8979 while (index (cp1, '/') != 0) {
8980 /* If this token is "." we can ignore it */
8981 if ((cp1[0] == '.') && (cp1[1] == '/')) {
8985 /* Add a subdirectory spec. Do not duplicate "." */
8986 if (cp2[-1] != '.' && cp2[-1] != '[' && cp2[-1] != '<')
8988 /* If this is ".." then the spec becomes "-" */
8989 if ((cp1[0] == '.') && (cp1[1] == '.') && (cp[2] == '/')) {
8990 /* Add "-" and skip the ".." */
8995 /* Copy the subdirectory */
8996 while (*cp1 != '/') *cp2++= *cp1++;
8997 cp1++; /* Skip the "/" */
8999 /* Close the directory specification */
9000 if (cp2[-1] == '.') /* no trailing periods */
9004 /* Now add the filename */
9005 while (*cp1) *cp2++ = *cp1++;
9007 /* Now append it to the original VMS spec. */
9010 /* If we put a [000000] in the filename, try to open it first. If this fails,
9011 remove the [000000], and return that name. This provides flexibility
9012 to the user in that they can use both rooted and non-rooted logical names
9013 to point to the location of the file. */
9015 if (check_filename_before_returning && no_prefix_seen) {
9016 f = open (fname, O_RDONLY, 0666);
9018 /* The file name is OK as it is, so return it as is. */
9022 /* The filename did not work. Try to remove the [000000] from the name,
9024 cp = index (fname, '[');
9025 cp2 = index (fname, ']') + 1;
9026 strcpy (cp, cp2); /* this gets rid of it */
9034 /* These are the read/write replacement routines for
9035 VAX-11 "C". They make read/write behave enough
9036 like their UNIX counterparts that CCCP will work */
9039 read (fd, buf, size)
9044 #undef read /* Get back the REAL read routine */
9046 register int total = 0;
9048 /* Read until the buffer is exhausted */
9050 /* Limit each read to 32KB */
9051 i = (size > (32*1024)) ? (32*1024) : size;
9052 i = read (fd, buf, i);
9054 if (i == 0) return (total);
9057 /* Account for this read */
9066 write (fd, buf, size)
9071 #undef write /* Get back the REAL write routine */
9075 /* Limit individual writes to 32Kb */
9078 j = (i > (32*1024)) ? (32*1024) : i;
9079 if (write (fd, buf, j) < 0) return (-1);
9080 /* Account for the data written */
9087 /* The following wrapper functions supply additional arguments to the VMS
9088 I/O routines to optimize performance with file handling. The arguments
9090 "mbc=16" - Set multi-block count to 16 (use a 8192 byte buffer).
9091 "deq=64" - When extending the file, extend it in chunks of 32Kbytes.
9092 "fop=tef"- Truncate unused portions of file when closing file.
9093 "shr=nil"- Disallow file sharing while file is open.
9097 freopen (fname, type, oldfile)
9102 #undef freopen /* Get back the REAL fopen routine */
9103 if (strcmp (type, "w") == 0)
9104 return freopen (fname, type, oldfile, "mbc=16", "deq=64", "fop=tef", "shr=nil");
9105 return freopen (fname, type, oldfile, "mbc=16");
9113 #undef fopen /* Get back the REAL fopen routine */
9114 if (strcmp (type, "w") == 0)
9115 return fopen (fname, type, "mbc=16", "deq=64", "fop=tef", "shr=nil");
9116 return fopen (fname, type, "mbc=16");
9120 open (fname, flags, prot)
9125 #undef open /* Get back the REAL open routine */
9126 return open (fname, flags, prot, "mbc=16", "deq=64", "fop=tef");
9129 /* Avoid run-time library bug, where copying M out of N+M characters with
9130 N >= 65535 results in VAXCRTL's strncat falling into an infinite loop.
9131 gcc-cpp exercises this particular bug. */
9134 strncat (dst, src, cnt)
9139 register char *d = dst, *s = (char *) src;
9140 register int n = cnt; /* convert to _signed_ type */
9142 while (*d) d++; /* advance to end */
9144 if (!(*d++ = *s++)) break;
9145 if (n < 0) *d = '\0';
OSDN Git Service
