1 /* C Compatible Compiler Preprocessor (CCCP)
2 Copyright (C) 1986, 87, 89, 92-96, 1997 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, 59 Temple Place - Suite 330,
19 Boston, MA 02111-1307, USA.
21 In other words, you are welcome to use, share and improve this program.
22 You are forbidden to forbid anyone else to use, share and improve
23 what you give them. Help stamp out software-hoarding! */
25 typedef unsigned char U_CHAR;
29 #include "../src/config.h"
37 /* The macro EMACS is defined when cpp is distributed as part of Emacs,
38 for the sake of machines with limited C compilers. */
41 #endif /* not EMACS */
43 #ifndef STANDARD_INCLUDE_DIR
44 #define STANDARD_INCLUDE_DIR "/usr/include"
49 /* By default, colon separates directories in a path. */
50 #ifndef PATH_SEPARATOR
51 #define PATH_SEPARATOR ':'
54 #include <sys/types.h>
60 /* The following symbols should be autoconfigured:
67 In the mean time, we'll get by with approximations based
68 on existing GCC configuration symbols. */
71 # ifndef HAVE_STDLIB_H
72 # define HAVE_STDLIB_H 1
74 # ifndef HAVE_UNISTD_H
75 # define HAVE_UNISTD_H 1
78 # define STDC_HEADERS 1
80 #endif /* defined (POSIX) */
82 #if defined (POSIX) || (defined (USG) && !defined (VMS))
84 # define HAVE_FCNTL_H 1
91 # if TIME_WITH_SYS_TIME
92 # include <sys/time.h>
96 # include <sys/time.h>
101 # include <sys/resource.h>
119 # define bcmp(a, b, n) memcmp (a, b, n)
122 # define bcopy(s, d, n) memcpy (d, s, n)
125 # define bzero(d, n) memset (d, 0, n)
127 #else /* !STDC_HEADERS */
131 # if !defined (BSTRING) && (defined (USG) || defined (VMS))
134 # define bcmp my_bcmp
147 # endif /* !defined (bcmp) */
150 # define bcopy my_bcopy
160 # endif /* !defined (bcopy) */
163 # define bzero my_bzero
167 register unsigned length;
172 # endif /* !defined (bzero) */
174 # endif /* !defined (BSTRING) && (defined (USG) || defined (VMS)) */
175 #endif /* ! STDC_HEADERS */
177 #if __GNUC__ < 2 || (__GNUC__ == 2 && __GNUC_MINOR__ < 7)
178 # define __attribute__(x)
182 # if defined (USE_PROTOTYPES) ? USE_PROTOTYPES : defined (__STDC__)
183 # define PROTO(ARGS) ARGS
185 # define PROTO(ARGS) ()
189 #if defined (__STDC__) && defined (HAVE_VPRINTF)
191 # define VA_START(va_list, var) va_start (va_list, var)
192 # define PRINTF_ALIST(msg) char *msg, ...
193 # define PRINTF_DCL(msg)
194 # define PRINTF_PROTO(ARGS, m, n) PROTO (ARGS) __attribute__ ((format (__printf__, m, n)))
196 # include <varargs.h>
197 # define VA_START(va_list, var) va_start (va_list)
198 # define PRINTF_ALIST(msg) msg, va_alist
199 # define PRINTF_DCL(msg) char *msg; va_dcl
200 # define PRINTF_PROTO(ARGS, m, n) () __attribute__ ((format (__printf__, m, n)))
201 # define vfprintf(file, msg, args) \
203 char *a0 = va_arg(args, char *); \
204 char *a1 = va_arg(args, char *); \
205 char *a2 = va_arg(args, char *); \
206 char *a3 = va_arg(args, char *); \
207 fprintf (file, msg, a0, a1, a2, a3); \
211 #define PRINTF_PROTO_1(ARGS) PRINTF_PROTO(ARGS, 1, 2)
212 #define PRINTF_PROTO_2(ARGS) PRINTF_PROTO(ARGS, 2, 3)
213 #define PRINTF_PROTO_3(ARGS) PRINTF_PROTO(ARGS, 3, 4)
219 /* VMS-specific definitions */
222 #define read(fd,buf,size) VMS_read (fd,buf,size)
223 #define write(fd,buf,size) VMS_write (fd,buf,size)
224 #define open(fname,mode,prot) VMS_open (fname,mode,prot)
225 #define fopen(fname,mode) VMS_fopen (fname,mode)
226 #define freopen(fname,mode,ofile) VMS_freopen (fname,mode,ofile)
227 #define fstat(fd,stbuf) VMS_fstat (fd,stbuf)
228 static int VMS_fstat (), VMS_stat ();
229 static int VMS_read ();
230 static int VMS_write ();
231 static int VMS_open ();
232 static FILE * VMS_fopen ();
233 static FILE * VMS_freopen ();
234 static void hack_vms_include_specification ();
235 #define INO_T_EQ(a, b) (!bcmp((char *) &(a), (char *) &(b), sizeof (a)))
236 #define INO_T_HASH(a) 0
237 #define INCLUDE_LEN_FUDGE 12 /* leave room for VMS syntax conversion */
246 #define MIN(X,Y) ((X) < (Y) ? (X) : (Y))
247 #define MAX(X,Y) ((X) > (Y) ? (X) : (Y))
249 /* Find the largest host integer type and set its size and type.
250 Don't blindly use `long'; on some crazy hosts it is shorter than `int'. */
252 #ifndef HOST_BITS_PER_WIDE_INT
254 #if HOST_BITS_PER_LONG > HOST_BITS_PER_INT
255 #define HOST_BITS_PER_WIDE_INT HOST_BITS_PER_LONG
256 #define HOST_WIDE_INT long
258 #define HOST_BITS_PER_WIDE_INT HOST_BITS_PER_INT
259 #define HOST_WIDE_INT int
265 #define S_ISREG(m) (((m) & S_IFMT) == S_IFREG)
269 #define S_ISDIR(m) (((m) & S_IFMT) == S_IFDIR)
273 #define INO_T_EQ(a, b) ((a) == (b))
277 #define INO_T_HASH(a) (a)
280 /* Define a generic NULL if one hasn't already been defined. */
287 #if defined (USE_PROTOTYPES) ? USE_PROTOTYPES : defined (__STDC__)
288 #define GENERIC_PTR void *
290 #define GENERIC_PTR char *
295 #define NULL_PTR ((GENERIC_PTR) 0)
298 #ifndef INCLUDE_LEN_FUDGE
299 #define INCLUDE_LEN_FUDGE 0
302 /* External declarations. */
304 extern char *version_string;
306 #ifndef HAVE_STRERROR
309 extern const char *const sys_errlist[];
311 extern char *sys_errlist[];
313 #else /* HAVE_STRERROR */
317 char *strerror (int,...);
319 HOST_WIDE_INT parse_escape PROTO((char **, HOST_WIDE_INT));
320 HOST_WIDE_INT parse_c_expression PROTO((char *));
326 /* Name under which this program was invoked. */
328 static char *progname;
330 /* Nonzero means use extra default include directories for C++. */
332 static int cplusplus;
334 /* Nonzero means handle cplusplus style comments */
336 static int cplusplus_comments;
338 /* Nonzero means handle #import, for objective C. */
342 /* Nonzero means this is an assembly file, and allow
343 unknown directives, which could be comments. */
347 /* Current maximum length of directory names in the search path
348 for include files. (Altered as we get more of them.) */
350 static int max_include_len;
352 /* Nonzero means turn NOTREACHED into #pragma NOTREACHED etc */
354 static int for_lint = 0;
356 /* Nonzero means copy comments into the output file. */
358 static int put_out_comments = 0;
360 /* Nonzero means don't process the ANSI trigraph sequences. */
362 static int no_trigraphs = 0;
364 /* Nonzero means print the names of included files rather than
365 the preprocessed output. 1 means just the #include "...",
366 2 means #include <...> as well. */
368 static int print_deps = 0;
370 /* Nonzero if missing .h files in -M output are assumed to be generated
371 files and not errors. */
373 static int print_deps_missing_files = 0;
375 /* Nonzero means print names of header files (-H). */
377 static int print_include_names = 0;
379 /* Nonzero means don't output line number information. */
381 static int no_line_directives;
383 /* Nonzero means output the text in failing conditionals,
384 inside #failed ... #endfailed. */
386 static int output_conditionals;
388 /* dump_only means inhibit output of the preprocessed text
389 and instead output the definitions of all user-defined
390 macros in a form suitable for use as input to cccp.
391 dump_names means pass #define and the macro name through to output.
392 dump_definitions means pass the whole definition (plus #define) through
395 static enum {dump_none, dump_only, dump_names, dump_definitions}
396 dump_macros = dump_none;
398 /* Nonzero means pass all #define and #undef directives which we actually
399 process through to the output stream. This feature is used primarily
400 to allow cc1 to record the #defines and #undefs for the sake of
401 debuggers which understand about preprocessor macros, but it may
402 also be useful with -E to figure out how symbols are defined, and
403 where they are defined. */
404 static int debug_output = 0;
406 /* Nonzero indicates special processing used by the pcp program. The
407 special effects of this mode are:
409 Inhibit all macro expansion, except those inside #if directives.
411 Process #define directives normally, and output their contents
414 Output preconditions to pcp_outfile indicating all the relevant
415 preconditions for use of this file in a later cpp run.
417 static FILE *pcp_outfile;
419 /* Nonzero means we are inside an IF during a -pcp run. In this mode
420 macro expansion is done, and preconditions are output for all macro
421 uses requiring them. */
422 static int pcp_inside_if;
424 /* Nonzero means never to include precompiled files.
425 This is 1 since there's no way now to make precompiled files,
426 so it's not worth testing for them. */
427 static int no_precomp = 1;
429 /* Nonzero means give all the error messages the ANSI standard requires. */
433 /* Nonzero means try to make failure to fit ANSI C an error. */
435 static int pedantic_errors;
437 /* Nonzero means don't print warning messages. -w. */
439 static int inhibit_warnings = 0;
441 /* Nonzero means warn if slash-star appears in a slash-star comment,
442 or if newline-backslash appears in a slash-slash comment. */
444 static int warn_comments;
446 /* Nonzero means warn if a macro argument is (or would be)
447 stringified with -traditional. */
449 static int warn_stringify;
451 /* Nonzero means warn if there are any trigraphs. */
453 static int warn_trigraphs;
455 /* Nonzero means warn if #import is used. */
457 static int warn_import = 1;
459 /* Nonzero means turn warnings into errors. */
461 static int warnings_are_errors;
463 /* Nonzero means try to imitate old fashioned non-ANSI preprocessor. */
467 /* Nonzero for the 1989 C Standard, including corrigenda and amendments. */
471 /* Nonzero causes output not to be done,
472 but directives such as #define that have side effects
475 static int no_output;
477 /* Nonzero means this file was included with a -imacros or -include
478 command line and should not be recorded as an include file. */
480 static int no_record_file;
482 /* Nonzero means that we have finished processing the command line options.
483 This flag is used to decide whether or not to issue certain errors
486 static int done_initializing = 0;
488 /* Line where a newline was first seen in a string constant. */
490 static int multiline_string_line = 0;
492 /* I/O buffer structure.
493 The `fname' field is nonzero for source files and #include files
494 and for the dummy text used for -D and -U.
495 It is zero for rescanning results of macro expansion
496 and for expanding macro arguments. */
497 #define INPUT_STACK_MAX 400
498 static struct file_buf {
500 /* Filename specified with #line directive. */
502 /* Include file description. */
503 struct include_file *inc;
504 /* Record where in the search path this file was found.
505 For #include_next. */
506 struct file_name_list *dir;
511 /* Macro that this level is the expansion of.
512 Included so that we can reenable the macro
513 at the end of this level. */
514 struct hashnode *macro;
515 /* Value of if_stack at start of this file.
516 Used to prohibit unmatched #endif (etc) in an include file. */
517 struct if_stack *if_stack;
518 /* Object to be freed at end of input at this level. */
520 /* True if this is a header file included using <FILENAME>. */
521 char system_header_p;
522 } instack[INPUT_STACK_MAX];
524 static int last_error_tick; /* Incremented each time we print it. */
525 static int input_file_stack_tick; /* Incremented when the status changes. */
527 /* Current nesting level of input sources.
528 `instack[indepth]' is the level currently being read. */
529 static int indepth = -1;
530 #define CHECK_DEPTH(code) \
531 if (indepth >= (INPUT_STACK_MAX - 1)) \
533 error_with_line (line_for_error (instack[indepth].lineno), \
534 "macro or `#include' recursion too deep"); \
538 /* Current depth in #include directives that use <...>. */
539 static int system_include_depth = 0;
541 typedef struct file_buf FILE_BUF;
543 /* The output buffer. Its LENGTH field is the amount of room allocated
544 for the buffer, not the number of chars actually present. To get
545 that, subtract outbuf.buf from outbuf.bufp. */
547 #define OUTBUF_SIZE 10 /* initial size of output buffer */
548 static FILE_BUF outbuf;
550 /* Grow output buffer OBUF points at
551 so it can hold at least NEEDED more chars. */
553 #define check_expand(OBUF, NEEDED) \
554 (((OBUF)->length - ((OBUF)->bufp - (OBUF)->buf) <= (NEEDED)) \
555 ? grow_outbuf ((OBUF), (NEEDED)) : 0)
557 struct file_name_list
559 struct file_name_list *next;
560 /* If the following is 1, it is a C-language system include
562 int c_system_include_path;
563 /* Mapping of file names for this directory. */
564 struct file_name_map *name_map;
565 /* Non-zero if name_map is valid. */
567 /* The include directory status. */
569 /* The include prefix: "" denotes the working directory,
570 otherwise fname must end in '/'.
571 The actual size is dynamically allocated. */
575 /* #include "file" looks in source file dir, then stack. */
576 /* #include <file> just looks in the stack. */
577 /* -I directories are added to the end, then the defaults are added. */
579 static struct default_include {
580 char *fname; /* The name of the directory. */
581 int cplusplus; /* Only look here if we're compiling C++. */
582 int cxx_aware; /* Includes in this directory don't need to
583 be wrapped in extern "C" when compiling
585 } include_defaults_array[]
586 #ifdef INCLUDE_DEFAULTS
590 /* Pick up GNU C++ specific include files. */
591 { GPLUSPLUS_INCLUDE_DIR, 1, 1 },
592 { OLD_GPLUSPLUS_INCLUDE_DIR, 1, 1 },
594 /* This is the dir for fixincludes. Put it just before
595 the files that we fix. */
596 { GCC_INCLUDE_DIR, 0, 0 },
597 /* For cross-compilation, this dir name is generated
598 automatically in Makefile.in. */
599 { CROSS_INCLUDE_DIR, 0, 0 },
600 #ifdef TOOL_INCLUDE_DIR
601 /* This is another place that the target system's headers might be. */
602 { TOOL_INCLUDE_DIR, 0, 0 },
604 #else /* not CROSS_COMPILE */
605 #ifdef LOCAL_INCLUDE_DIR
606 /* This should be /usr/local/include and should come before
607 the fixincludes-fixed header files. */
608 { LOCAL_INCLUDE_DIR, 0, 1 },
610 #ifdef TOOL_INCLUDE_DIR
611 /* This is here ahead of GCC_INCLUDE_DIR because assert.h goes here.
612 Likewise, behind LOCAL_INCLUDE_DIR, where glibc puts its assert.h. */
613 { TOOL_INCLUDE_DIR, 0, 0 },
615 /* This is the dir for fixincludes. Put it just before
616 the files that we fix. */
617 { GCC_INCLUDE_DIR, 0, 0 },
618 /* Some systems have an extra dir of include files. */
619 #ifdef SYSTEM_INCLUDE_DIR
620 { SYSTEM_INCLUDE_DIR, 0, 0 },
622 { STANDARD_INCLUDE_DIR, 0, 0 },
623 #endif /* not CROSS_COMPILE */
626 #endif /* no INCLUDE_DEFAULTS */
628 /* The code looks at the defaults through this pointer, rather than through
629 the constant structure above. This pointer gets changed if an environment
630 variable specifies other defaults. */
631 static struct default_include *include_defaults = include_defaults_array;
633 static struct file_name_list *include = 0; /* First dir to search */
634 /* First dir to search for <file> */
635 /* This is the first element to use for #include <...>.
636 If it is 0, use the entire chain for such includes. */
637 static struct file_name_list *first_bracket_include = 0;
638 /* This is the first element in the chain that corresponds to
639 a directory of system header files. */
640 static struct file_name_list *first_system_include = 0;
641 static struct file_name_list *last_include = 0; /* Last in chain */
643 /* Chain of include directories to put at the end of the other chain. */
644 static struct file_name_list *after_include = 0;
645 static struct file_name_list *last_after_include = 0; /* Last in chain */
647 /* Chain to put at the start of the system include files. */
648 static struct file_name_list *before_system = 0;
649 static struct file_name_list *last_before_system = 0; /* Last in chain */
651 /* Directory prefix that should replace `/usr' in the standard
652 include file directories. */
653 static char *include_prefix;
655 /* Maintain and search list of included files. */
657 struct include_file {
658 struct include_file *next; /* for include_hashtab */
659 struct include_file *next_ino; /* for include_ino_hashtab */
661 /* If the following is the empty string, it means #pragma once
662 was seen in this include file, or #import was applied to the file.
663 Otherwise, if it is nonzero, it is a macro name.
664 Don't include the file again if that macro is defined. */
665 U_CHAR *control_macro;
666 /* Nonzero if the dependency on this include file has been output. */
671 /* Hash tables of files already included with #include or #import.
672 include_hashtab is by full name; include_ino_hashtab is by inode number. */
674 #define INCLUDE_HASHSIZE 61
675 static struct include_file *include_hashtab[INCLUDE_HASHSIZE];
676 static struct include_file *include_ino_hashtab[INCLUDE_HASHSIZE];
678 /* Global list of strings read in from precompiled files. This list
679 is kept in the order the strings are read in, with new strings being
680 added at the end through stringlist_tailp. We use this list to output
681 the strings at the end of the run.
683 static STRINGDEF *stringlist;
684 static STRINGDEF **stringlist_tailp = &stringlist;
687 /* Structure returned by create_definition */
688 typedef struct macrodef MACRODEF;
691 struct definition *defn;
696 enum sharp_token_type {
697 NO_SHARP_TOKEN = 0, /* token not present */
699 SHARP_TOKEN = '#', /* token spelled with # only */
700 WHITE_SHARP_TOKEN, /* token spelled with # and white space */
702 PERCENT_COLON_TOKEN = '%', /* token spelled with %: only */
703 WHITE_PERCENT_COLON_TOKEN /* token spelled with %: and white space */
706 /* Structure allocated for every #define. For a simple replacement
709 nargs = -1, the `pattern' list is null, and the expansion is just
710 the replacement text. Nargs = 0 means a functionlike macro with no args,
712 #define getchar() getc (stdin) .
713 When there are args, the expansion is the replacement text with the
714 args squashed out, and the reflist is a list describing how to
715 build the output from the input: e.g., "3 chars, then the 1st arg,
716 then 9 chars, then the 3rd arg, then 0 chars, then the 2nd arg".
717 The chars here come from the expansion. Whatever is left of the
718 expansion after the last arg-occurrence is copied after that arg.
719 Note that the reflist can be arbitrarily long---
720 its length depends on the number of times the arguments appear in
721 the replacement text, not how many args there are. Example:
722 #define f(x) x+x+x+x+x+x+x would have replacement text "++++++" and
724 { (0, 1), (1, 1), (1, 1), ..., (1, 1), NULL }
725 where (x, y) means (nchars, argno). */
727 typedef struct definition DEFINITION;
730 int length; /* length of expansion string */
731 int predefined; /* True if the macro was builtin or */
732 /* came from the command line */
734 int line; /* Line number of definition */
735 char *file; /* File of definition */
736 char rest_args; /* Nonzero if last arg. absorbs the rest */
738 struct reflist *next;
740 enum sharp_token_type stringify; /* set if a # operator before arg */
741 enum sharp_token_type raw_before; /* set if a ## operator before arg */
742 enum sharp_token_type raw_after; /* set if a ## operator after arg */
744 char rest_args; /* Nonzero if this arg. absorbs the rest */
745 int nchars; /* Number of literal chars to copy before
746 this arg occurrence. */
747 int argno; /* Number of arg to substitute (origin-0) */
750 /* Names of macro args, concatenated in reverse order
751 with comma-space between them.
752 The only use of this is that we warn on redefinition
753 if this differs between the old and new definitions. */
758 /* different kinds of things that can appear in the value field
759 of a hash node. Actually, this may be useless now. */
767 * special extension string that can be added to the last macro argument to
768 * allow it to absorb the "rest" of the arguments when expanded. Ex:
769 * #define wow(a, b...) process (b, a, b)
770 * { wow (1, 2, 3); } -> { process (2, 3, 1, 2, 3); }
771 * { wow (one, two); } -> { process (two, one, two); }
772 * if this "rest_arg" is used with the concat token '##' and if it is not
773 * supplied then the token attached to with ## will not be outputted. Ex:
774 * #define wow (a, b...) process (b ## , a, ## b)
775 * { wow (1, 2); } -> { process (2, 1, 2); }
776 * { wow (one); } -> { process (one); {
778 static char rest_extension[] = "...";
779 #define REST_EXTENSION_LENGTH (sizeof (rest_extension) - 1)
781 /* The structure of a node in the hash table. The hash table
782 has entries for all tokens defined by #define directives (type T_MACRO),
783 plus some special tokens like __LINE__ (these each have their own
784 type, and the appropriate code is run when that type of node is seen.
785 It does not contain control words like "#define", which are recognized
786 by a separate piece of code. */
788 /* different flavors of hash nodes --- also used in keyword table */
790 T_DEFINE = 1, /* the `#define' keyword */
791 T_INCLUDE, /* the `#include' keyword */
792 T_INCLUDE_NEXT, /* the `#include_next' keyword */
793 T_IMPORT, /* the `#import' keyword */
794 T_IFDEF, /* the `#ifdef' keyword */
795 T_IFNDEF, /* the `#ifndef' keyword */
796 T_IF, /* the `#if' keyword */
797 T_ELSE, /* `#else' */
798 T_PRAGMA, /* `#pragma' */
799 T_ELIF, /* `#elif' */
800 T_UNDEF, /* `#undef' */
801 T_LINE, /* `#line' */
802 T_ERROR, /* `#error' */
803 T_WARNING, /* `#warning' */
804 T_ENDIF, /* `#endif' */
805 T_SCCS, /* `#sccs', used on system V. */
806 T_IDENT, /* `#ident', used on system V. */
807 T_ASSERT, /* `#assert', taken from system V. */
808 T_UNASSERT, /* `#unassert', taken from system V. */
809 T_SPECLINE, /* special symbol `__LINE__' */
810 T_DATE, /* `__DATE__' */
811 T_FILE, /* `__FILE__' */
812 T_BASE_FILE, /* `__BASE_FILE__' */
813 T_INCLUDE_LEVEL, /* `__INCLUDE_LEVEL__' */
814 T_VERSION, /* `__VERSION__' */
815 T_SIZE_TYPE, /* `__SIZE_TYPE__' */
816 T_PTRDIFF_TYPE, /* `__PTRDIFF_TYPE__' */
817 T_WCHAR_TYPE, /* `__WCHAR_TYPE__' */
818 T_USER_LABEL_PREFIX_TYPE, /* `__USER_LABEL_PREFIX__' */
819 T_REGISTER_PREFIX_TYPE, /* `__REGISTER_PREFIX__' */
820 T_IMMEDIATE_PREFIX_TYPE, /* `__IMMEDIATE_PREFIX__' */
821 T_TIME, /* `__TIME__' */
822 T_CONST, /* Constant value, used by `__STDC__' */
823 T_MACRO, /* macro defined by `#define' */
824 T_DISABLED, /* macro temporarily turned off for rescan */
825 T_SPEC_DEFINED, /* special `defined' macro for use in #if statements */
826 T_PCSTRING, /* precompiled string (hashval is KEYDEF *) */
827 T_UNUSED /* Used for something not defined. */
831 struct hashnode *next; /* double links for easy deletion */
832 struct hashnode *prev;
833 struct hashnode **bucket_hdr; /* also, a back pointer to this node's hash
834 chain is kept, in case the node is the head
835 of the chain and gets deleted. */
836 enum node_type type; /* type of special token */
837 int length; /* length of token, for quick comparison */
838 U_CHAR *name; /* the actual name */
839 union hashval value; /* pointer to expansion, or whatever */
842 typedef struct hashnode HASHNODE;
844 /* Some definitions for the hash table. The hash function MUST be
845 computed as shown in hashf () below. That is because the rescan
846 loop computes the hash value `on the fly' for most tokens,
847 in order to avoid the overhead of a lot of procedure calls to
848 the hashf () function. Hashf () only exists for the sake of
849 politeness, for use when speed isn't so important. */
851 #define HASHSIZE 1403
852 static HASHNODE *hashtab[HASHSIZE];
853 #define HASHSTEP(old, c) ((old << 2) + c)
854 #define MAKE_POS(v) (v & 0x7fffffff) /* make number positive */
856 /* Symbols to predefine. */
858 #ifdef CPP_PREDEFINES
859 static char *predefs = CPP_PREDEFINES;
861 static char *predefs = "";
864 /* We let tm.h override the types used here, to handle trivial differences
865 such as the choice of unsigned int or long unsigned int for size_t.
866 When machines start needing nontrivial differences in the size type,
867 it would be best to do something here to figure out automatically
868 from other information what type to use. */
870 /* The string value for __SIZE_TYPE__. */
873 #define SIZE_TYPE "long unsigned int"
876 /* The string value for __PTRDIFF_TYPE__. */
879 #define PTRDIFF_TYPE "long int"
882 /* The string value for __WCHAR_TYPE__. */
885 #define WCHAR_TYPE "int"
887 char * wchar_type = WCHAR_TYPE;
890 /* The string value for __USER_LABEL_PREFIX__ */
892 #ifndef USER_LABEL_PREFIX
893 #define USER_LABEL_PREFIX ""
896 /* The string value for __REGISTER_PREFIX__ */
898 #ifndef REGISTER_PREFIX
899 #define REGISTER_PREFIX ""
902 /* The string value for __IMMEDIATE_PREFIX__ */
904 #ifndef IMMEDIATE_PREFIX
905 #define IMMEDIATE_PREFIX ""
908 /* In the definition of a #assert name, this structure forms
909 a list of the individual values asserted.
910 Each value is itself a list of "tokens".
911 These are strings that are compared by name. */
913 struct tokenlist_list {
914 struct tokenlist_list *next;
915 struct arglist *tokens;
918 struct assertion_hashnode {
919 struct assertion_hashnode *next; /* double links for easy deletion */
920 struct assertion_hashnode *prev;
921 /* also, a back pointer to this node's hash
922 chain is kept, in case the node is the head
923 of the chain and gets deleted. */
924 struct assertion_hashnode **bucket_hdr;
925 int length; /* length of token, for quick comparison */
926 U_CHAR *name; /* the actual name */
927 /* List of token-sequences. */
928 struct tokenlist_list *value;
931 typedef struct assertion_hashnode ASSERTION_HASHNODE;
933 /* Some definitions for the hash table. The hash function MUST be
934 computed as shown in hashf below. That is because the rescan
935 loop computes the hash value `on the fly' for most tokens,
936 in order to avoid the overhead of a lot of procedure calls to
937 the hashf function. hashf only exists for the sake of
938 politeness, for use when speed isn't so important. */
940 #define ASSERTION_HASHSIZE 37
941 static ASSERTION_HASHNODE *assertion_hashtab[ASSERTION_HASHSIZE];
943 /* Nonzero means inhibit macroexpansion of what seem to be
944 assertion tests, in rescan. For #if. */
945 static int assertions_flag;
947 /* `struct directive' defines one #-directive, including how to handle it. */
949 #define DO_PROTO PROTO((U_CHAR *, U_CHAR *, FILE_BUF *, struct directive *))
952 int length; /* Length of name */
953 int (*func) DO_PROTO; /* Function to handle directive */
954 char *name; /* Name of directive */
955 enum node_type type; /* Code which describes which directive. */
956 char angle_brackets; /* Nonzero => <...> is special. */
957 char traditional_comments; /* Nonzero: keep comments if -traditional. */
958 char pass_thru; /* Copy directive to output:
959 if 1, copy if dumping definitions;
960 if 2, always copy, after preprocessing. */
963 /* These functions are declared to return int instead of void since they
964 are going to be placed in the table and some old compilers have trouble with
965 pointers to functions returning void. */
967 static int do_assert DO_PROTO;
968 static int do_define DO_PROTO;
969 static int do_elif DO_PROTO;
970 static int do_else DO_PROTO;
971 static int do_endif DO_PROTO;
972 static int do_error DO_PROTO;
973 static int do_ident DO_PROTO;
974 static int do_if DO_PROTO;
975 static int do_include DO_PROTO;
976 static int do_line DO_PROTO;
977 static int do_pragma DO_PROTO;
978 #ifdef SCCS_DIRECTIVE
979 static int do_sccs DO_PROTO;
981 static int do_unassert DO_PROTO;
982 static int do_undef DO_PROTO;
983 static int do_warning DO_PROTO;
984 static int do_xifdef DO_PROTO;
986 /* Here is the actual list of #-directives, most-often-used first. */
988 static struct directive directive_table[] = {
989 { 6, do_define, "define", T_DEFINE, 0, 1, 1},
990 { 2, do_if, "if", T_IF},
991 { 5, do_xifdef, "ifdef", T_IFDEF},
992 { 6, do_xifdef, "ifndef", T_IFNDEF},
993 { 5, do_endif, "endif", T_ENDIF},
994 { 4, do_else, "else", T_ELSE},
995 { 4, do_elif, "elif", T_ELIF},
996 { 4, do_line, "line", T_LINE},
997 { 7, do_include, "include", T_INCLUDE, 1},
998 { 12, do_include, "include_next", T_INCLUDE_NEXT, 1},
999 { 6, do_include, "import", T_IMPORT, 1},
1000 { 5, do_undef, "undef", T_UNDEF},
1001 { 5, do_error, "error", T_ERROR},
1002 { 7, do_warning, "warning", T_WARNING},
1003 #ifdef SCCS_DIRECTIVE
1004 { 4, do_sccs, "sccs", T_SCCS},
1006 { 6, do_pragma, "pragma", T_PRAGMA, 0, 0, 2},
1007 { 5, do_ident, "ident", T_IDENT},
1008 { 6, do_assert, "assert", T_ASSERT},
1009 { 8, do_unassert, "unassert", T_UNASSERT},
1010 { -1, 0, "", T_UNUSED},
1013 /* When a directive handler is called,
1014 this points to the # (or the : of the %:) that started the directive. */
1015 U_CHAR *directive_start;
1017 /* table to tell if char can be part of a C identifier. */
1018 U_CHAR is_idchar[256];
1019 /* table to tell if char can be first char of a c identifier. */
1020 U_CHAR is_idstart[256];
1021 /* table to tell if c is horizontal space. */
1022 static U_CHAR is_hor_space[256];
1023 /* table to tell if c is horizontal or vertical space. */
1024 U_CHAR is_space[256];
1025 /* names of some characters */
1026 static char *char_name[256];
1028 #define SKIP_WHITE_SPACE(p) do { while (is_hor_space[*p]) p++; } while (0)
1029 #define SKIP_ALL_WHITE_SPACE(p) do { while (is_space[*p]) p++; } while (0)
1031 static int errors = 0; /* Error counter for exit code */
1033 /* Name of output file, for error messages. */
1034 static char *out_fname;
1037 /* Stack of conditionals currently in progress
1038 (including both successful and failing conditionals). */
1041 struct if_stack *next; /* for chaining to the next stack frame */
1042 char *fname; /* copied from input when frame is made */
1043 int lineno; /* similarly */
1044 int if_succeeded; /* true if a leg of this if-group
1045 has been passed through rescan */
1046 U_CHAR *control_macro; /* For #ifndef at start of file,
1047 this is the macro name tested. */
1048 enum node_type type; /* type of last directive seen in this group */
1050 typedef struct if_stack IF_STACK_FRAME;
1051 static IF_STACK_FRAME *if_stack = NULL;
1053 /* Buffer of -M output. */
1054 static char *deps_buffer;
1056 /* Number of bytes allocated in above. */
1057 static int deps_allocated_size;
1059 /* Number of bytes used. */
1060 static int deps_size;
1062 /* Number of bytes since the last newline. */
1063 static int deps_column;
1065 /* Nonzero means -I- has been seen,
1066 so don't look for #include "foo" the source-file directory. */
1067 static int ignore_srcdir;
1069 static int safe_read PROTO((int, char *, int));
1070 static void safe_write PROTO((int, char *, int));
1072 int main PROTO((int, char **));
1074 static void path_include PROTO((char *));
1076 static U_CHAR *index0 PROTO((U_CHAR *, int, size_t));
1078 static void trigraph_pcp PROTO((FILE_BUF *));
1080 static void newline_fix PROTO((U_CHAR *));
1081 static void name_newline_fix PROTO((U_CHAR *));
1083 static char *get_lintcmd PROTO((U_CHAR *, U_CHAR *, U_CHAR **, int *, int *));
1085 static void rescan PROTO((FILE_BUF *, int));
1087 static FILE_BUF expand_to_temp_buffer PROTO((U_CHAR *, U_CHAR *, int, int));
1089 static int handle_directive PROTO((FILE_BUF *, FILE_BUF *));
1091 static struct tm *timestamp PROTO((void));
1092 static void special_symbol PROTO((HASHNODE *, FILE_BUF *));
1094 static int is_system_include PROTO((char *));
1095 static char *base_name PROTO((char *));
1096 static int absolute_filename PROTO((char *));
1097 static size_t simplify_filename PROTO((char *));
1099 static char *read_filename_string PROTO((int, FILE *));
1100 static struct file_name_map *read_name_map PROTO((char *));
1101 static int open_include_file PROTO((char *, struct file_name_list *, U_CHAR *, struct include_file **));
1102 static char *remap_include_file PROTO((char *, struct file_name_list *));
1103 static int lookup_ino_include PROTO((struct include_file *));
1105 static void finclude PROTO((int, struct include_file *, FILE_BUF *, int, struct file_name_list *));
1106 static void record_control_macro PROTO((struct include_file *, U_CHAR *));
1108 static char *check_precompiled PROTO((int, struct stat *, char *, char **));
1109 static int check_preconditions PROTO((char *));
1110 static void pcfinclude PROTO((U_CHAR *, U_CHAR *, U_CHAR *, FILE_BUF *));
1111 static void pcstring_used PROTO((HASHNODE *));
1112 static void write_output PROTO((void));
1113 static void pass_thru_directive PROTO((U_CHAR *, U_CHAR *, FILE_BUF *, struct directive *));
1115 static MACRODEF create_definition PROTO((U_CHAR *, U_CHAR *, FILE_BUF *));
1117 static int check_macro_name PROTO((U_CHAR *, char *));
1118 static int compare_defs PROTO((DEFINITION *, DEFINITION *));
1119 static int comp_def_part PROTO((int, U_CHAR *, int, U_CHAR *, int, int));
1121 static DEFINITION *collect_expansion PROTO((U_CHAR *, U_CHAR *, int, struct arglist *));
1123 int check_assertion PROTO((U_CHAR *, int, int, struct arglist *));
1124 static int compare_token_lists PROTO((struct arglist *, struct arglist *));
1126 static struct arglist *read_token_list PROTO((U_CHAR **, U_CHAR *, int *));
1127 static void free_token_list PROTO((struct arglist *));
1129 static ASSERTION_HASHNODE *assertion_install PROTO((U_CHAR *, int, int));
1130 static ASSERTION_HASHNODE *assertion_lookup PROTO((U_CHAR *, int, int));
1131 static void delete_assertion PROTO((ASSERTION_HASHNODE *));
1133 static void do_once PROTO((void));
1135 static HOST_WIDE_INT eval_if_expression PROTO((U_CHAR *, int));
1136 static void conditional_skip PROTO((FILE_BUF *, int, enum node_type, U_CHAR *, FILE_BUF *));
1137 static void skip_if_group PROTO((FILE_BUF *, int, FILE_BUF *));
1138 static void validate_else PROTO((U_CHAR *, U_CHAR *));
1140 static U_CHAR *skip_to_end_of_comment PROTO((FILE_BUF *, int *, int));
1141 static U_CHAR *skip_quoted_string PROTO((U_CHAR *, U_CHAR *, int, int *, int *, int *));
1142 static char *quote_string PROTO((char *, char *));
1143 static U_CHAR *skip_paren_group PROTO((FILE_BUF *));
1145 /* Last arg to output_line_directive. */
1146 enum file_change_code {same_file, enter_file, leave_file};
1147 static void output_line_directive PROTO((FILE_BUF *, FILE_BUF *, int, enum file_change_code));
1149 static void macroexpand PROTO((HASHNODE *, FILE_BUF *));
1152 static char *macarg PROTO((struct argdata *, int));
1154 static U_CHAR *macarg1 PROTO((U_CHAR *, U_CHAR *, int *, int *, int *, int));
1156 static int discard_comments PROTO((U_CHAR *, int, int));
1158 static int change_newlines PROTO((U_CHAR *, int));
1160 char *my_strerror PROTO((int));
1161 void error PRINTF_PROTO_1((char *, ...));
1162 static void verror PROTO((char *, va_list));
1163 static void error_from_errno PROTO((char *));
1164 void warning PRINTF_PROTO_1((char *, ...));
1165 static void vwarning PROTO((char *, va_list));
1166 static void error_with_line PRINTF_PROTO_2((int, char *, ...));
1167 static void verror_with_line PROTO((int, char *, va_list));
1168 static void vwarning_with_line PROTO((int, char *, va_list));
1169 static void warning_with_line PRINTF_PROTO_2((int, char *, ...));
1170 void pedwarn PRINTF_PROTO_1((char *, ...));
1171 void pedwarn_with_line PRINTF_PROTO_2((int, char *, ...));
1172 static void pedwarn_with_file_and_line PRINTF_PROTO_3((char *, int, char *, ...));
1174 static void print_containing_files PROTO((void));
1176 static int line_for_error PROTO((int));
1177 static int grow_outbuf PROTO((FILE_BUF *, int));
1179 static HASHNODE *install PROTO((U_CHAR *, int, enum node_type, char *, int));
1180 HASHNODE *lookup PROTO((U_CHAR *, int, int));
1181 static void delete_macro PROTO((HASHNODE *));
1182 static int hashf PROTO((U_CHAR *, int, int));
1184 static void dump_single_macro PROTO((HASHNODE *, FILE *));
1185 static void dump_all_macros PROTO((void));
1186 static void dump_defn_1 PROTO((U_CHAR *, int, int, FILE *));
1187 static void dump_arg_n PROTO((DEFINITION *, int, FILE *));
1189 static void initialize_char_syntax PROTO((void));
1190 static void initialize_builtins PROTO((FILE_BUF *, FILE_BUF *));
1192 static void make_definition PROTO((char *, FILE_BUF *));
1193 static void make_undef PROTO((char *, FILE_BUF *));
1195 static void make_assertion PROTO((char *, char *));
1197 static struct file_name_list *new_include_prefix PROTO((struct file_name_list *, char *, char *));
1198 static void append_include_chain PROTO((struct file_name_list *, struct file_name_list *));
1200 static void deps_output PROTO((char *, int));
1202 static void fatal PRINTF_PROTO_1((char *, ...)) __attribute__ ((noreturn));
1203 void fancy_abort PROTO((void)) __attribute__ ((noreturn));
1204 static void perror_with_name PROTO((char *));
1205 static void pfatal_with_name PROTO((char *)) __attribute__ ((noreturn));
1206 static void pipe_closed PROTO((int)) __attribute__ ((noreturn));
1208 static void memory_full PROTO((void)) __attribute__ ((noreturn));
1209 GENERIC_PTR xmalloc PROTO((size_t));
1210 static GENERIC_PTR xrealloc PROTO((GENERIC_PTR, size_t));
1211 static GENERIC_PTR xcalloc PROTO((size_t, size_t));
1212 static char *savestring PROTO((char *));
1214 /* Read LEN bytes at PTR from descriptor DESC, for file FILENAME,
1215 retrying if necessary. Return a negative value if an error occurs,
1216 otherwise return the actual number of bytes read,
1217 which must be LEN unless end-of-file was reached. */
1220 safe_read (desc, ptr, len)
1227 int nchars = read (desc, ptr, left);
1244 /* Write LEN bytes at PTR to descriptor DESC,
1245 retrying if necessary, and treating any real error as fatal. */
1248 safe_write (desc, ptr, len)
1254 int written = write (desc, ptr, len);
1261 pfatal_with_name (out_fname);
1278 char **pend_files = (char **) xmalloc (argc * sizeof (char *));
1279 char **pend_defs = (char **) xmalloc (argc * sizeof (char *));
1280 char **pend_undefs = (char **) xmalloc (argc * sizeof (char *));
1281 char **pend_assertions = (char **) xmalloc (argc * sizeof (char *));
1282 char **pend_includes = (char **) xmalloc (argc * sizeof (char *));
1284 /* Record the option used with each element of pend_assertions.
1285 This is preparation for supporting more than one option for making
1287 char **pend_assertion_options = (char **) xmalloc (argc * sizeof (char *));
1288 int inhibit_predefs = 0;
1289 int no_standard_includes = 0;
1290 int no_standard_cplusplus_includes = 0;
1291 int missing_newline = 0;
1293 /* Non-0 means don't output the preprocessed program. */
1294 int inhibit_output = 0;
1295 /* Non-0 means -v, so print the full set of include dirs. */
1298 /* File name which deps are being written to.
1299 This is 0 if deps are being written to stdout. */
1300 char *deps_file = 0;
1301 /* Fopen file mode to open deps_file with. */
1302 char *deps_mode = "a";
1303 /* Stream on which to print the dependency information. */
1304 FILE *deps_stream = 0;
1305 /* Target-name to write with the dependency information. */
1306 char *deps_target = 0;
1309 /* Get rid of any avoidable limit on stack size. */
1313 /* Set the stack limit huge so that alloca (particularly stringtab
1314 in dbxread.c) does not fail. */
1315 getrlimit (RLIMIT_STACK, &rlim);
1316 rlim.rlim_cur = rlim.rlim_max;
1317 setrlimit (RLIMIT_STACK, &rlim);
1319 #endif /* RLIMIT_STACK defined */
1322 signal (SIGPIPE, pipe_closed);
1325 progname = base_name (argv[0]);
1329 /* Remove extension from PROGNAME. */
1331 char *s = progname = savestring (progname);
1333 if ((p = rindex (s, ';')) != 0) *p = '\0'; /* strip version number */
1334 if ((p = rindex (s, '.')) != 0 /* strip type iff ".exe" */
1335 && (p[1] == 'e' || p[1] == 'E')
1336 && (p[2] == 'x' || p[2] == 'X')
1337 && (p[3] == 'e' || p[3] == 'E')
1346 /* Initialize is_idchar. */
1347 initialize_char_syntax ();
1349 no_line_directives = 0;
1351 dump_macros = dump_none;
1354 cplusplus_comments = 1;
1356 bzero ((char *) pend_files, argc * sizeof (char *));
1357 bzero ((char *) pend_defs, argc * sizeof (char *));
1358 bzero ((char *) pend_undefs, argc * sizeof (char *));
1359 bzero ((char *) pend_assertions, argc * sizeof (char *));
1360 bzero ((char *) pend_includes, argc * sizeof (char *));
1362 /* Process switches and find input file name. */
1364 for (i = 1; i < argc; i++) {
1365 if (argv[i][0] != '-') {
1366 if (out_fname != NULL)
1367 fatal ("Usage: %s [switches] input output", argv[0]);
1368 else if (in_fname != NULL)
1369 out_fname = argv[i];
1373 switch (argv[i][1]) {
1376 if (!strcmp (argv[i], "-include")) {
1378 fatal ("Filename missing after `-include' option");
1380 simplify_filename (pend_includes[i] = argv[++i]);
1382 if (!strcmp (argv[i], "-imacros")) {
1384 fatal ("Filename missing after `-imacros' option");
1386 simplify_filename (pend_files[i] = argv[++i]);
1388 if (!strcmp (argv[i], "-iprefix")) {
1390 fatal ("Filename missing after `-iprefix' option");
1392 include_prefix = argv[++i];
1394 if (!strcmp (argv[i], "-ifoutput")) {
1395 output_conditionals = 1;
1397 if (!strcmp (argv[i], "-isystem")) {
1398 struct file_name_list *dirtmp;
1400 if (! (dirtmp = new_include_prefix (NULL_PTR, "", argv[++i])))
1402 dirtmp->c_system_include_path = 1;
1404 if (before_system == 0)
1405 before_system = dirtmp;
1407 last_before_system->next = dirtmp;
1408 last_before_system = dirtmp; /* Tail follows the last one */
1410 /* Add directory to end of path for includes,
1411 with the default prefix at the front of its name. */
1412 if (!strcmp (argv[i], "-iwithprefix")) {
1413 struct file_name_list *dirtmp;
1416 if (include_prefix != 0)
1417 prefix = include_prefix;
1419 prefix = savestring (GCC_INCLUDE_DIR);
1420 /* Remove the `include' from /usr/local/lib/gcc.../include. */
1421 if (!strcmp (prefix + strlen (prefix) - 8, "/include"))
1422 prefix[strlen (prefix) - 7] = 0;
1425 if (! (dirtmp = new_include_prefix (NULL_PTR, prefix, argv[++i])))
1428 if (after_include == 0)
1429 after_include = dirtmp;
1431 last_after_include->next = dirtmp;
1432 last_after_include = dirtmp; /* Tail follows the last one */
1434 /* Add directory to main path for includes,
1435 with the default prefix at the front of its name. */
1436 if (!strcmp (argv[i], "-iwithprefixbefore")) {
1437 struct file_name_list *dirtmp;
1440 if (include_prefix != 0)
1441 prefix = include_prefix;
1443 prefix = savestring (GCC_INCLUDE_DIR);
1444 /* Remove the `include' from /usr/local/lib/gcc.../include. */
1445 if (!strcmp (prefix + strlen (prefix) - 8, "/include"))
1446 prefix[strlen (prefix) - 7] = 0;
1449 dirtmp = new_include_prefix (NULL_PTR, prefix, argv[++i]);
1450 append_include_chain (dirtmp, dirtmp);
1452 /* Add directory to end of path for includes. */
1453 if (!strcmp (argv[i], "-idirafter")) {
1454 struct file_name_list *dirtmp;
1456 if (! (dirtmp = new_include_prefix (NULL_PTR, "", argv[++i])))
1459 if (after_include == 0)
1460 after_include = dirtmp;
1462 last_after_include->next = dirtmp;
1463 last_after_include = dirtmp; /* Tail follows the last one */
1468 if (out_fname != NULL)
1469 fatal ("Output filename specified twice");
1471 fatal ("Filename missing after -o option");
1472 out_fname = argv[++i];
1473 if (!strcmp (out_fname, "-"))
1478 if (!strcmp (argv[i], "-pedantic"))
1480 else if (!strcmp (argv[i], "-pedantic-errors")) {
1482 pedantic_errors = 1;
1483 } else if (!strcmp (argv[i], "-pcp")) {
1486 fatal ("Filename missing after -pcp option");
1487 pcp_fname = argv[++i];
1489 ((pcp_fname[0] != '-' || pcp_fname[1] != '\0')
1490 ? fopen (pcp_fname, "w")
1492 if (pcp_outfile == 0)
1493 pfatal_with_name (pcp_fname);
1499 if (!strcmp (argv[i], "-traditional")) {
1501 cplusplus_comments = 0;
1502 } else if (!strcmp (argv[i], "-trigraphs")) {
1508 if (! strcmp (argv[i], "-lang-c"))
1509 cplusplus = 0, cplusplus_comments = 1, c89 = 0, objc = 0;
1510 if (! strcmp (argv[i], "-lang-c89"))
1511 cplusplus = 0, cplusplus_comments = 0, c89 = 1, objc = 0;
1512 if (! strcmp (argv[i], "-lang-c++"))
1513 cplusplus = 1, cplusplus_comments = 1, c89 = 0, objc = 0;
1514 if (! strcmp (argv[i], "-lang-objc"))
1515 cplusplus = 0, cplusplus_comments = 1, c89 = 0, objc = 1;
1516 if (! strcmp (argv[i], "-lang-objc++"))
1517 cplusplus = 1, cplusplus_comments = 1, c89 = 0, objc = 1;
1518 if (! strcmp (argv[i], "-lang-asm"))
1520 if (! strcmp (argv[i], "-lint"))
1525 cplusplus = 1, cplusplus_comments = 1;
1529 inhibit_warnings = 1;
1533 if (!strcmp (argv[i], "-Wtrigraphs"))
1535 else if (!strcmp (argv[i], "-Wno-trigraphs"))
1537 else if (!strcmp (argv[i], "-Wcomment"))
1539 else if (!strcmp (argv[i], "-Wno-comment"))
1541 else if (!strcmp (argv[i], "-Wcomments"))
1543 else if (!strcmp (argv[i], "-Wno-comments"))
1545 else if (!strcmp (argv[i], "-Wtraditional"))
1547 else if (!strcmp (argv[i], "-Wno-traditional"))
1549 else if (!strcmp (argv[i], "-Wimport"))
1551 else if (!strcmp (argv[i], "-Wno-import"))
1553 else if (!strcmp (argv[i], "-Werror"))
1554 warnings_are_errors = 1;
1555 else if (!strcmp (argv[i], "-Wno-error"))
1556 warnings_are_errors = 0;
1557 else if (!strcmp (argv[i], "-Wall"))
1565 /* The style of the choices here is a bit mixed.
1566 The chosen scheme is a hybrid of keeping all options in one string
1567 and specifying each option in a separate argument:
1568 -M|-MM|-MD file|-MMD file [-MG]. An alternative is:
1569 -M|-MM|-MD file|-MMD file|-MG|-MMG; or more concisely:
1570 -M[M][G][D file]. This is awkward to handle in specs, and is not
1572 /* ??? -MG must be specified in addition to one of -M or -MM.
1573 This can be relaxed in the future without breaking anything.
1574 The converse isn't true. */
1576 /* -MG isn't valid with -MD or -MMD. This is checked for later. */
1577 if (!strcmp (argv[i], "-MG"))
1579 print_deps_missing_files = 1;
1582 if (!strcmp (argv[i], "-M"))
1584 else if (!strcmp (argv[i], "-MM"))
1586 else if (!strcmp (argv[i], "-MD"))
1588 else if (!strcmp (argv[i], "-MMD"))
1590 /* For -MD and -MMD options, write deps on file named by next arg. */
1591 if (!strcmp (argv[i], "-MD")
1592 || !strcmp (argv[i], "-MMD")) {
1594 fatal ("Filename missing after %s option", argv[i]);
1596 deps_file = argv[i];
1599 /* For -M and -MM, write deps on standard output
1600 and suppress the usual output. */
1601 deps_stream = stdout;
1608 char *p = argv[i] + 2;
1610 while ((c = *p++)) {
1611 /* Arg to -d specifies what parts of macros to dump */
1614 dump_macros = dump_only;
1618 dump_macros = dump_names;
1621 dump_macros = dump_definitions;
1629 if (argv[i][2] == '3')
1634 fprintf (stderr, "GNU CPP version %s", version_string);
1635 #ifdef TARGET_VERSION
1638 fprintf (stderr, "\n");
1643 print_include_names = 1;
1647 if (argv[i][2] != 0)
1648 pend_defs[i] = argv[i] + 2;
1649 else if (i + 1 == argc)
1650 fatal ("Macro name missing after -D option");
1652 i++, pend_defs[i] = argv[i];
1659 if (argv[i][2] != 0)
1661 else if (i + 1 == argc)
1662 fatal ("Assertion missing after -A option");
1666 if (!strcmp (p, "-")) {
1667 /* -A- eliminates all predefined macros and assertions.
1668 Let's include also any that were specified earlier
1669 on the command line. That way we can get rid of any
1670 that were passed automatically in from GCC. */
1672 inhibit_predefs = 1;
1673 for (j = 0; j < i; j++)
1674 pend_defs[j] = pend_assertions[j] = 0;
1676 pend_assertions[i] = p;
1677 pend_assertion_options[i] = "-A";
1682 case 'U': /* JF #undef something */
1683 if (argv[i][2] != 0)
1684 pend_undefs[i] = argv[i] + 2;
1685 else if (i + 1 == argc)
1686 fatal ("Macro name missing after -U option");
1688 pend_undefs[i] = argv[i+1], i++;
1692 put_out_comments = 1;
1695 case 'E': /* -E comes from cc -E; ignore it. */
1699 no_line_directives = 1;
1702 case '$': /* Don't include $ in identifiers. */
1703 is_idchar['$'] = is_idstart['$'] = 0;
1706 case 'I': /* Add directory to path for includes. */
1708 struct file_name_list *dirtmp;
1710 if (! ignore_srcdir && !strcmp (argv[i] + 2, "-")) {
1712 /* Don't use any preceding -I directories for #include <...>. */
1713 first_bracket_include = 0;
1716 dirtmp = new_include_prefix (last_include, "",
1717 argv[i][2] ? argv[i] + 2 : argv[++i]);
1718 append_include_chain (dirtmp, dirtmp);
1724 if (!strcmp (argv[i], "-nostdinc"))
1725 /* -nostdinc causes no default include directories.
1726 You must specify all include-file directories with -I. */
1727 no_standard_includes = 1;
1728 else if (!strcmp (argv[i], "-nostdinc++"))
1729 /* -nostdinc++ causes no default C++-specific include directories. */
1730 no_standard_cplusplus_includes = 1;
1731 else if (!strcmp (argv[i], "-noprecomp"))
1736 /* Sun compiler passes undocumented switch "-undef".
1737 Let's assume it means to inhibit the predefined symbols. */
1738 inhibit_predefs = 1;
1741 case '\0': /* JF handle '-' as file name meaning stdin or stdout */
1742 if (in_fname == NULL) {
1745 } else if (out_fname == NULL) {
1748 } /* else fall through into error */
1751 fatal ("Invalid option `%s'", argv[i]);
1756 /* Add dirs from CPATH after dirs from -I. */
1757 /* There seems to be confusion about what CPATH should do,
1758 so for the moment it is not documented. */
1759 /* Some people say that CPATH should replace the standard include dirs,
1760 but that seems pointless: it comes before them, so it overrides them
1762 cp = getenv ("CPATH");
1763 if (cp && ! no_standard_includes)
1766 /* Initialize output buffer */
1768 outbuf.buf = (U_CHAR *) xmalloc (OUTBUF_SIZE);
1769 outbuf.bufp = outbuf.buf;
1770 outbuf.length = OUTBUF_SIZE;
1772 /* Do partial setup of input buffer for the sake of generating
1773 early #line directives (when -g is in effect). */
1775 fp = &instack[++indepth];
1776 if (in_fname == NULL)
1778 fp->nominal_fname = fp->fname = in_fname;
1781 /* In C++, wchar_t is a distinct basic type, and we can expect
1782 __wchar_t to be defined by cc1plus. */
1784 wchar_type = "__wchar_t";
1786 /* Install __LINE__, etc. Must follow initialize_char_syntax
1787 and option processing. */
1788 initialize_builtins (fp, &outbuf);
1790 /* Do standard #defines and assertions
1791 that identify system and machine type. */
1793 if (!inhibit_predefs) {
1794 char *p = (char *) alloca (strlen (predefs) + 1);
1795 strcpy (p, predefs);
1798 while (*p == ' ' || *p == '\t')
1800 /* Handle -D options. */
1801 if (p[0] == '-' && p[1] == 'D') {
1803 while (*p && *p != ' ' && *p != '\t')
1808 output_line_directive (fp, &outbuf, 0, same_file);
1809 make_definition (q, &outbuf);
1810 while (*p == ' ' || *p == '\t')
1812 } else if (p[0] == '-' && p[1] == 'A') {
1813 /* Handle -A options (assertions). */
1822 past_name = assertion;
1823 /* Locate end of name. */
1824 while (*past_name && *past_name != ' '
1825 && *past_name != '\t' && *past_name != '(')
1827 /* Locate `(' at start of value. */
1829 while (*value && (*value == ' ' || *value == '\t'))
1831 if (*value++ != '(')
1833 while (*value && (*value == ' ' || *value == '\t'))
1836 /* Locate end of value. */
1837 while (*past_value && *past_value != ' '
1838 && *past_value != '\t' && *past_value != ')')
1840 termination = past_value;
1841 while (*termination && (*termination == ' ' || *termination == '\t'))
1843 if (*termination++ != ')')
1845 if (*termination && *termination != ' ' && *termination != '\t')
1847 /* Temporarily null-terminate the value. */
1848 save_char = *termination;
1849 *termination = '\0';
1850 /* Install the assertion. */
1851 make_assertion ("-A", assertion);
1852 *termination = (char) save_char;
1854 while (*p == ' ' || *p == '\t')
1862 /* Now handle the command line options. */
1864 /* Do -U's, -D's and -A's in the order they were seen. */
1865 for (i = 1; i < argc; i++) {
1866 if (pend_undefs[i]) {
1868 output_line_directive (fp, &outbuf, 0, same_file);
1869 make_undef (pend_undefs[i], &outbuf);
1873 output_line_directive (fp, &outbuf, 0, same_file);
1874 make_definition (pend_defs[i], &outbuf);
1876 if (pend_assertions[i])
1877 make_assertion (pend_assertion_options[i], pend_assertions[i]);
1880 done_initializing = 1;
1882 { /* Read the appropriate environment variable and if it exists
1883 replace include_defaults with the listed path. */
1885 switch ((objc << 1) + cplusplus)
1888 epath = getenv ("C_INCLUDE_PATH");
1891 epath = getenv ("CPLUS_INCLUDE_PATH");
1894 epath = getenv ("OBJC_INCLUDE_PATH");
1897 epath = getenv ("OBJCPLUS_INCLUDE_PATH");
1900 /* If the environment var for this language is set,
1901 add to the default list of include directories. */
1904 char *startp, *endp;
1906 for (num_dirs = 1, startp = epath; *startp; startp++)
1907 if (*startp == PATH_SEPARATOR)
1910 = (struct default_include *) xmalloc ((num_dirs
1911 * sizeof (struct default_include))
1912 + sizeof (include_defaults_array));
1913 startp = endp = epath;
1917 if (c == PATH_SEPARATOR || !c) {
1919 include_defaults[num_dirs].fname
1920 = startp == endp ? "." : savestring (startp);
1922 include_defaults[num_dirs].cplusplus = cplusplus;
1923 include_defaults[num_dirs].cxx_aware = 1;
1930 /* Put the usual defaults back in at the end. */
1931 bcopy ((char *) include_defaults_array,
1932 (char *) &include_defaults[num_dirs],
1933 sizeof (include_defaults_array));
1937 append_include_chain (before_system, last_before_system);
1938 first_system_include = before_system;
1940 /* Unless -fnostdinc,
1941 tack on the standard include file dirs to the specified list */
1942 if (!no_standard_includes) {
1943 struct default_include *p = include_defaults;
1944 char *specd_prefix = include_prefix;
1945 char *default_prefix = savestring (GCC_INCLUDE_DIR);
1946 int default_len = 0;
1947 /* Remove the `include' from /usr/local/lib/gcc.../include. */
1948 if (!strcmp (default_prefix + strlen (default_prefix) - 8, "/include")) {
1949 default_len = strlen (default_prefix) - 7;
1950 default_prefix[default_len] = 0;
1952 /* Search "translated" versions of GNU directories.
1953 These have /usr/local/lib/gcc... replaced by specd_prefix. */
1954 if (specd_prefix != 0 && default_len != 0)
1955 for (p = include_defaults; p->fname; p++) {
1956 /* Some standard dirs are only for C++. */
1957 if (!p->cplusplus || (cplusplus && !no_standard_cplusplus_includes)) {
1958 /* Does this dir start with the prefix? */
1959 if (!strncmp (p->fname, default_prefix, default_len)) {
1960 /* Yes; change prefix and add to search list. */
1961 struct file_name_list *new
1962 = new_include_prefix (NULL_PTR, specd_prefix,
1963 p->fname + default_len);
1965 new->c_system_include_path = !p->cxx_aware;
1966 append_include_chain (new, new);
1967 if (first_system_include == 0)
1968 first_system_include = new;
1973 /* Search ordinary names for GNU include directories. */
1974 for (p = include_defaults; p->fname; p++) {
1975 /* Some standard dirs are only for C++. */
1976 if (!p->cplusplus || (cplusplus && !no_standard_cplusplus_includes)) {
1977 struct file_name_list *new
1978 = new_include_prefix (NULL_PTR, "", p->fname);
1980 new->c_system_include_path = !p->cxx_aware;
1981 append_include_chain (new, new);
1982 if (first_system_include == 0)
1983 first_system_include = new;
1989 /* Tack the after_include chain at the end of the include chain. */
1990 append_include_chain (after_include, last_after_include);
1991 if (first_system_include == 0)
1992 first_system_include = after_include;
1994 /* With -v, print the list of dirs to search. */
1996 struct file_name_list *p;
1997 fprintf (stderr, "#include \"...\" search starts here:\n");
1998 for (p = include; p; p = p->next) {
1999 if (p == first_bracket_include)
2000 fprintf (stderr, "#include <...> search starts here:\n");
2002 fprintf (stderr, " .\n");
2003 else if (!strcmp (p->fname, "/") || !strcmp (p->fname, "//"))
2004 fprintf (stderr, " %s\n", p->fname);
2006 /* Omit trailing '/'. */
2007 fprintf (stderr, " %.*s\n", (int) strlen (p->fname) - 1, p->fname);
2009 fprintf (stderr, "End of search list.\n");
2012 /* -MG doesn't select the form of output and must be specified with one of
2013 -M or -MM. -MG doesn't make sense with -MD or -MMD since they don't
2014 inhibit compilation. */
2015 if (print_deps_missing_files && (print_deps == 0 || !inhibit_output))
2016 fatal ("-MG must be specified with one of -M or -MM");
2018 /* Either of two environment variables can specify output of deps.
2019 Its value is either "OUTPUT_FILE" or "OUTPUT_FILE DEPS_TARGET",
2020 where OUTPUT_FILE is the file to write deps info to
2021 and DEPS_TARGET is the target to mention in the deps. */
2024 && (getenv ("SUNPRO_DEPENDENCIES") != 0
2025 || getenv ("DEPENDENCIES_OUTPUT") != 0)) {
2026 char *spec = getenv ("DEPENDENCIES_OUTPUT");
2031 spec = getenv ("SUNPRO_DEPENDENCIES");
2038 /* Find the space before the DEPS_TARGET, if there is one. */
2039 /* This should use index. (mrs) */
2040 while (*s != 0 && *s != ' ') s++;
2042 deps_target = s + 1;
2043 output_file = xmalloc (s - spec + 1);
2044 bcopy (spec, output_file, s - spec);
2045 output_file[s - spec] = 0;
2052 deps_file = output_file;
2056 /* For -M, print the expected object file name
2057 as the target of this Make-rule. */
2059 deps_allocated_size = 200;
2060 deps_buffer = xmalloc (deps_allocated_size);
2066 deps_output (deps_target, ':');
2067 } else if (*in_fname == 0) {
2068 deps_output ("-", ':');
2073 q = base_name (in_fname);
2075 /* Copy remainder to mungable area. */
2076 p = (char *) alloca (strlen(q) + 8);
2079 /* Output P, but remove known suffixes. */
2083 && p[len - 2] == '.'
2084 && index("cCsSm", p[len - 1]))
2087 && p[len - 3] == '.'
2088 && p[len - 2] == 'c'
2089 && p[len - 1] == 'c')
2092 && p[len - 4] == '.'
2093 && p[len - 3] == 'c'
2094 && p[len - 2] == 'x'
2095 && p[len - 1] == 'x')
2098 && p[len - 4] == '.'
2099 && p[len - 3] == 'c'
2100 && p[len - 2] == 'p'
2101 && p[len - 1] == 'p')
2104 /* Supply our own suffix. */
2111 deps_output (p, ':');
2112 deps_output (in_fname, ' ');
2116 /* Scan the -imacros files before the main input.
2117 Much like #including them, but with no_output set
2118 so that only their macro definitions matter. */
2120 no_output++; no_record_file++;
2121 for (i = 1; i < argc; i++)
2122 if (pend_files[i]) {
2123 struct include_file *inc;
2124 int fd = open_include_file (pend_files[i], NULL_PTR, NULL_PTR, &inc);
2126 perror_with_name (pend_files[i]);
2127 return FATAL_EXIT_CODE;
2129 finclude (fd, inc, &outbuf, 0, NULL_PTR);
2131 no_output--; no_record_file--;
2133 /* Copy the entire contents of the main input file into
2134 the stacked input buffer previously allocated for it. */
2136 /* JF check for stdin */
2137 if (in_fname == NULL || *in_fname == 0) {
2140 } else if ((f = open (in_fname, O_RDONLY, 0666)) < 0)
2143 if (fstat (f, &st) != 0)
2144 pfatal_with_name (in_fname);
2145 fp->nominal_fname = fp->fname = in_fname;
2147 fp->system_header_p = 0;
2148 /* JF all this is mine about reading pipes and ttys */
2149 if (! S_ISREG (st.st_mode)) {
2150 /* Read input from a file that is not a normal disk file.
2151 We cannot preallocate a buffer with the correct size,
2152 so we must read in the file a piece at the time and make it bigger. */
2157 if (S_ISDIR (st.st_mode))
2158 fatal ("Input file `%s' is a directory", in_fname);
2162 fp->buf = (U_CHAR *) xmalloc (bsize + 2);
2164 cnt = safe_read (f, (char *) fp->buf + size, bsize - size);
2165 if (cnt < 0) goto perror; /* error! */
2167 if (size != bsize) break; /* End of file */
2169 fp->buf = (U_CHAR *) xrealloc (fp->buf, bsize + 2);
2173 /* Read a file whose size we can determine in advance.
2174 For the sake of VMS, st.st_size is just an upper bound. */
2175 fp->buf = (U_CHAR *) xmalloc (st.st_size + 2);
2176 fp->length = safe_read (f, (char *) fp->buf, st.st_size);
2177 if (fp->length < 0) goto perror;
2180 fp->if_stack = if_stack;
2182 /* Make sure data ends with a newline. And put a null after it. */
2184 if ((fp->length > 0 && fp->buf[fp->length - 1] != '\n')
2185 /* Backslash-newline at end is not good enough. */
2186 || (fp->length > 1 && fp->buf[fp->length - 2] == '\\')) {
2187 fp->buf[fp->length++] = '\n';
2188 missing_newline = 1;
2190 fp->buf[fp->length] = '\0';
2192 /* Unless inhibited, convert trigraphs in the input. */
2197 /* Now that we know the input file is valid, open the output. */
2199 if (!out_fname || !strcmp (out_fname, ""))
2200 out_fname = "stdout";
2201 else if (! freopen (out_fname, "w", stdout))
2202 pfatal_with_name (out_fname);
2204 output_line_directive (fp, &outbuf, 0, same_file);
2206 /* Scan the -include files before the main input. */
2209 for (i = 1; i < argc; i++)
2210 if (pend_includes[i]) {
2211 struct include_file *inc;
2212 int fd = open_include_file (pend_includes[i], NULL_PTR, NULL_PTR, &inc);
2214 perror_with_name (pend_includes[i]);
2215 return FATAL_EXIT_CODE;
2217 finclude (fd, inc, &outbuf, 0, NULL_PTR);
2221 /* Scan the input, processing macros and directives. */
2223 rescan (&outbuf, 0);
2225 if (missing_newline)
2228 if (pedantic && missing_newline)
2229 pedwarn ("file does not end in newline");
2231 /* Now we have processed the entire input
2232 Write whichever kind of output has been requested. */
2234 if (dump_macros == dump_only)
2236 else if (! inhibit_output) {
2241 /* Don't actually write the deps file if compilation has failed. */
2243 if (deps_file && ! (deps_stream = fopen (deps_file, deps_mode)))
2244 pfatal_with_name (deps_file);
2245 fputs (deps_buffer, deps_stream);
2246 putc ('\n', deps_stream);
2248 if (ferror (deps_stream) || fclose (deps_stream) != 0)
2249 fatal ("I/O error on output");
2254 if (pcp_outfile && pcp_outfile != stdout
2255 && (ferror (pcp_outfile) || fclose (pcp_outfile) != 0))
2256 fatal ("I/O error on `-pcp' output");
2258 if (ferror (stdout) || fclose (stdout) != 0)
2259 fatal ("I/O error on output");
2262 exit (FATAL_EXIT_CODE);
2263 exit (SUCCESS_EXIT_CODE);
2266 pfatal_with_name (in_fname);
2270 /* Given a colon-separated list of file names PATH,
2271 add all the names to the search path for include files. */
2285 struct file_name_list *dirtmp;
2287 /* Find the end of this name. */
2288 while ((c = *q++) != PATH_SEPARATOR && c)
2292 dirtmp = new_include_prefix (last_include, "", p == q ? "." : p);
2294 append_include_chain (dirtmp, dirtmp);
2296 /* Advance past this name. */
2303 /* Return the address of the first character in S that equals C.
2304 S is an array of length N, possibly containing '\0's, and followed by '\0'.
2305 Return 0 if there is no such character. Assume that C itself is not '\0'.
2306 If we knew we could use memchr, we could just invoke memchr (S, C, N),
2307 but unfortunately memchr isn't autoconfigured yet. */
2315 char *p = (char *) s;
2317 char *q = index (p, c);
2319 return (U_CHAR *) q;
2321 size_t l = strlen (p);
2331 /* Pre-C-Preprocessor to translate ANSI trigraph idiocy in BUF
2332 before main CCCP processing. Name `pcp' is also in honor of the
2333 drugs the trigraph designers must have been on.
2335 Using an extra pass through the buffer takes a little extra time,
2336 but is infinitely less hairy than trying to handle trigraphs inside
2337 strings, etc. everywhere, and also makes sure that trigraphs are
2338 only translated in the top level of processing. */
2344 register U_CHAR c, *fptr, *bptr, *sptr, *lptr;
2347 fptr = bptr = sptr = buf->buf;
2348 lptr = fptr + buf->length;
2349 while ((sptr = index0 (sptr, '?', (size_t) (lptr - sptr))) != NULL) {
2386 len = sptr - fptr - 2;
2388 /* BSD doc says bcopy () works right for overlapping strings. In ANSI
2389 C, this will be memmove (). */
2390 if (bptr != fptr && len > 0)
2391 bcopy ((char *) fptr, (char *) bptr, len);
2397 len = buf->length - (fptr - buf->buf);
2398 if (bptr != fptr && len > 0)
2399 bcopy ((char *) fptr, (char *) bptr, len);
2400 buf->length -= fptr - bptr;
2401 buf->buf[buf->length] = '\0';
2402 if (warn_trigraphs && fptr != bptr)
2403 warning_with_line (0, "%lu trigraph(s) encountered",
2404 (unsigned long) (fptr - bptr) / 2);
2407 /* Move all backslash-newline pairs out of embarrassing places.
2408 Exchange all such pairs following BP
2409 with any potentially-embarrassing characters that follow them.
2410 Potentially-embarrassing characters are / and *
2411 (because a backslash-newline inside a comment delimiter
2412 would cause it not to be recognized). */
2418 register U_CHAR *p = bp;
2420 /* First count the backslash-newline pairs here. */
2422 while (p[0] == '\\' && p[1] == '\n')
2425 /* What follows the backslash-newlines is not embarrassing. */
2427 if (*p != '/' && *p != '*')
2430 /* Copy all potentially embarrassing characters
2431 that follow the backslash-newline pairs
2432 down to where the pairs originally started. */
2434 while (*p == '*' || *p == '/')
2437 /* Now write the same number of pairs after the embarrassing chars. */
2444 /* Like newline_fix but for use within a directive-name.
2445 Move any backslash-newlines up past any following symbol constituents. */
2448 name_newline_fix (bp)
2451 register U_CHAR *p = bp;
2453 /* First count the backslash-newline pairs here. */
2454 while (p[0] == '\\' && p[1] == '\n')
2457 /* What follows the backslash-newlines is not embarrassing. */
2462 /* Copy all potentially embarrassing characters
2463 that follow the backslash-newline pairs
2464 down to where the pairs originally started. */
2466 while (is_idchar[*p])
2469 /* Now write the same number of pairs after the embarrassing chars. */
2476 /* Look for lint commands in comments.
2478 When we come in here, ibp points into a comment. Limit is as one expects.
2479 scan within the comment -- it should start, after lwsp, with a lint command.
2480 If so that command is returned as a (constant) string.
2482 Upon return, any arg will be pointed to with argstart and will be
2483 arglen long. Note that we don't parse that arg since it will just
2484 be printed out again. */
2487 get_lintcmd (ibp, limit, argstart, arglen, cmdlen)
2488 register U_CHAR *ibp;
2489 register U_CHAR *limit;
2490 U_CHAR **argstart; /* point to command arg */
2491 int *arglen, *cmdlen; /* how long they are */
2493 HOST_WIDE_INT linsize;
2494 register U_CHAR *numptr; /* temp for arg parsing */
2498 SKIP_WHITE_SPACE (ibp);
2500 if (ibp >= limit) return NULL;
2502 linsize = limit - ibp;
2504 /* Oh, I wish C had lexical functions... hell, I'll just open-code the set */
2505 if ((linsize >= 10) && !bcmp (ibp, "NOTREACHED", 10)) {
2507 return "NOTREACHED";
2509 if ((linsize >= 8) && !bcmp (ibp, "ARGSUSED", 8)) {
2513 if ((linsize >= 11) && !bcmp (ibp, "LINTLIBRARY", 11)) {
2515 return "LINTLIBRARY";
2517 if ((linsize >= 7) && !bcmp (ibp, "VARARGS", 7)) {
2519 ibp += 7; linsize -= 7;
2520 if ((linsize == 0) || ! isdigit (*ibp)) return "VARARGS";
2522 /* OK, read a number */
2523 for (numptr = *argstart = ibp; (numptr < limit) && isdigit (*numptr);
2525 *arglen = numptr - *argstart;
2532 * The main loop of the program.
2534 * Read characters from the input stack, transferring them to the
2537 * Macros are expanded and push levels on the input stack.
2538 * At the end of such a level it is popped off and we keep reading.
2539 * At the end of any other kind of level, we return.
2540 * #-directives are handled, except within macros.
2542 * If OUTPUT_MARKS is nonzero, keep Newline markers found in the input
2543 * and insert them when appropriate. This is set while scanning macro
2544 * arguments before substitution. It is zero when scanning for final output.
2545 * There are three types of Newline markers:
2546 * * Newline - follows a macro name that was not expanded
2547 * because it appeared inside an expansion of the same macro.
2548 * This marker prevents future expansion of that identifier.
2549 * When the input is rescanned into the final output, these are deleted.
2550 * These are also deleted by ## concatenation.
2551 * * Newline Space (or Newline and any other whitespace character)
2552 * stands for a place that tokens must be separated or whitespace
2553 * is otherwise desirable, but where the ANSI standard specifies there
2554 * is no whitespace. This marker turns into a Space (or whichever other
2555 * whitespace char appears in the marker) in the final output,
2556 * but it turns into nothing in an argument that is stringified with #.
2557 * Such stringified arguments are the only place where the ANSI standard
2558 * specifies with precision that whitespace may not appear.
2560 * During this function, IP->bufp is kept cached in IBP for speed of access.
2561 * Likewise, OP->bufp is kept in OBP. Before calling a subroutine
2562 * IBP, IP and OBP must be copied back to memory. IP and IBP are
2563 * copied back with the RECACHE macro. OBP must be copied back from OP->bufp
2564 * explicitly, and before RECACHE, since RECACHE uses OBP.
2568 rescan (op, output_marks)
2572 /* Character being scanned in main loop. */
2575 /* Length of pending accumulated identifier. */
2576 register int ident_length = 0;
2578 /* Hash code of pending accumulated identifier. */
2579 register int hash = 0;
2581 /* Current input level (&instack[indepth]). */
2584 /* Pointer for scanning input. */
2585 register U_CHAR *ibp;
2587 /* Pointer to end of input. End of scan is controlled by LIMIT. */
2588 register U_CHAR *limit;
2590 /* Pointer for storing output. */
2591 register U_CHAR *obp;
2593 /* REDO_CHAR is nonzero if we are processing an identifier
2594 after backing up over the terminating character.
2595 Sometimes we process an identifier without backing up over
2596 the terminating character, if the terminating character
2597 is not special. Backing up is done so that the terminating character
2598 will be dispatched on again once the identifier is dealt with. */
2601 /* 1 if within an identifier inside of which a concatenation
2602 marker (Newline -) has been seen. */
2603 int concatenated = 0;
2605 /* While scanning a comment or a string constant,
2606 this records the line it started on, for error messages. */
2609 /* Record position of last `real' newline. */
2610 U_CHAR *beg_of_line;
2612 /* Pop the innermost input stack level, assuming it is a macro expansion. */
2615 do { ip->macro->type = T_MACRO; \
2616 if (ip->free_ptr) free (ip->free_ptr); \
2617 --indepth; } while (0)
2619 /* Reload `rescan's local variables that describe the current
2620 level of the input stack. */
2623 do { ip = &instack[indepth]; \
2625 limit = ip->buf + ip->length; \
2627 check_expand (op, limit - ibp); \
2629 obp = op->bufp; } while (0)
2631 if (no_output && instack[indepth].fname != 0)
2632 skip_if_group (&instack[indepth], 1, NULL);
2639 /* Our caller must always put a null after the end of
2640 the input at each input stack level. */
2650 if (*ibp == '\n' && !ip->macro) {
2651 /* At the top level, always merge lines ending with backslash-newline,
2652 even in middle of identifier. But do not merge lines in a macro,
2653 since backslash might be followed by a newline-space marker. */
2656 --obp; /* remove backslash from obuf */
2659 /* If ANSI, backslash is just another character outside a string. */
2662 /* Otherwise, backslash suppresses specialness of following char,
2663 so copy it here to prevent the switch from seeing it.
2664 But first get any pending identifier processed. */
2665 if (ident_length > 0)
2672 if (ident_length || ip->macro || traditional)
2674 while (*ibp == '\\' && ibp[1] == '\n') {
2680 /* Treat this %: digraph as if it were #. */
2684 if (assertions_flag) {
2687 /* Copy #foo (bar lose) without macro expansion. */
2688 obp[-1] = '#'; /* In case it was '%'. */
2689 SKIP_WHITE_SPACE (ibp);
2690 while (is_idchar[*ibp])
2692 SKIP_WHITE_SPACE (ibp);
2695 skip_paren_group (ip);
2696 bcopy ((char *) ibp, (char *) obp, ip->bufp - ibp);
2697 obp += ip->bufp - ibp;
2703 /* If this is expanding a macro definition, don't recognize
2704 preprocessing directives. */
2707 /* If this is expand_into_temp_buffer,
2708 don't recognize them either. Warn about them
2709 only after an actual newline at this level,
2710 not at the beginning of the input level. */
2712 if (ip->buf != beg_of_line)
2713 warning ("preprocessing directive not recognized within macro arg");
2720 /* # keyword: a # must be first nonblank char on the line */
2721 if (beg_of_line == 0)
2726 /* Scan from start of line, skipping whitespace, comments
2727 and backslash-newlines, and see if we reach this #.
2728 If not, this # is not special. */
2730 /* If -traditional, require # to be at beginning of line. */
2733 if (is_hor_space[*bp])
2735 else if (*bp == '\\' && bp[1] == '\n')
2737 else if (*bp == '/' && bp[1] == '*') {
2739 while (!(*bp == '*' && bp[1] == '/'))
2743 /* There is no point in trying to deal with C++ // comments here,
2744 because if there is one, then this # must be part of the
2745 comment and we would never reach here. */
2751 while (bp[1] == '\\' && bp[2] == '\n')
2755 /* %: appears at start of line; skip past the ':' too. */
2764 /* This # can start a directive. */
2766 --obp; /* Don't copy the '#' */
2770 if (! handle_directive (ip, op)) {
2774 /* Not a known directive: treat it as ordinary text.
2775 IP, OP, IBP, etc. have not been changed. */
2776 if (no_output && instack[indepth].fname) {
2777 /* If not generating expanded output,
2778 what we do with ordinary text is skip it.
2779 Discard everything until next # directive. */
2780 skip_if_group (&instack[indepth], 1, 0);
2785 *obp++ = '#'; /* Copy # (even if it was originally %:). */
2786 /* Don't expand an identifier that could be a macro directive.
2787 (Section 3.8.3 of the ANSI C standard) */
2788 SKIP_WHITE_SPACE (ibp);
2789 if (is_idstart[*ibp])
2792 while (is_idchar[*ibp])
2800 /* A # directive has been successfully processed. */
2801 /* If not generating expanded output, ignore everything until
2802 next # directive. */
2803 if (no_output && instack[indepth].fname)
2804 skip_if_group (&instack[indepth], 1, 0);
2810 case '\"': /* skip quoted string */
2812 /* A single quoted string is treated like a double -- some
2813 programs (e.g., troff) are perverse this way */
2815 /* Handle any pending identifier;
2816 but the L in L'...' or L"..." is not an identifier. */
2818 && ! (ident_length == 1 && hash == HASHSTEP (0, 'L')))
2821 start_line = ip->lineno;
2823 /* Skip ahead to a matching quote. */
2827 if (ip->macro != 0) {
2828 /* try harder: this string crosses a macro expansion boundary.
2829 This can happen naturally if -traditional.
2830 Otherwise, only -D can make a macro with an unmatched quote. */
2836 error_with_line (line_for_error (start_line),
2837 "unterminated string or character constant");
2838 error_with_line (multiline_string_line,
2839 "possible real start of unterminated constant");
2840 multiline_string_line = 0;
2849 /* Traditionally, end of line ends a string constant with no error.
2850 So exit the loop and record the new line. */
2856 error_with_line (line_for_error (start_line),
2857 "unterminated character constant");
2860 if (multiline_string_line == 0) {
2862 pedwarn_with_line (line_for_error (start_line),
2863 "string constant runs past end of line");
2864 multiline_string_line = ip->lineno - 1;
2872 /* Backslash newline is replaced by nothing at all,
2873 but keep the line counts correct. */
2878 /* ANSI stupidly requires that in \\ the second \
2879 is *not* prevented from combining with a newline. */
2880 while (*ibp == '\\' && ibp[1] == '\n') {
2899 if (*ibp == '\\' && ibp[1] == '\n')
2903 && !(cplusplus_comments && *ibp == '/'))
2911 /* C++ style comment... */
2912 start_line = ip->lineno;
2914 /* Comments are equivalent to spaces. */
2915 if (! put_out_comments)
2919 U_CHAR *before_bp = ibp;
2921 while (++ibp < limit) {
2923 if (ibp[-1] != '\\') {
2924 if (put_out_comments) {
2925 bcopy ((char *) before_bp, (char *) obp, ibp - before_bp);
2926 obp += ibp - before_bp;
2931 warning ("multiline `//' comment");
2933 /* Copy the newline into the output buffer, in order to
2934 avoid the pain of a #line every time a multiline comment
2936 if (!put_out_comments)
2945 /* Ordinary C comment. Skip it, optionally copying it to output. */
2947 start_line = ip->lineno;
2949 ++ibp; /* Skip the star. */
2951 /* If this cpp is for lint, we peek inside the comments: */
2955 char *lintcmd = get_lintcmd (ibp, limit, &argbp, &arglen, &cmdlen);
2957 if (lintcmd != NULL) {
2959 check_expand (op, cmdlen + arglen + 14);
2961 /* I believe it is always safe to emit this newline: */
2963 bcopy ("#pragma lint ", (char *) obp, 13);
2965 bcopy (lintcmd, (char *) obp, cmdlen);
2970 bcopy (argbp, (char *) obp, arglen);
2974 /* OK, now bring us back to the state we were in before we entered
2975 this branch. We need #line because the #pragma's newline always
2976 messes up the line count. */
2978 output_line_directive (ip, op, 0, same_file);
2979 check_expand (op, limit - ibp + 2);
2985 /* Comments are equivalent to spaces.
2986 Note that we already output the slash; we might not want it.
2987 For -traditional, a comment is equivalent to nothing. */
2988 if (! put_out_comments) {
2998 U_CHAR *before_bp = ibp;
3003 if (ibp[-2] == '/' && warn_comments)
3004 warning ("`/*' within comment");
3005 if (*ibp == '\\' && ibp[1] == '\n')
3013 /* Copy the newline into the output buffer, in order to
3014 avoid the pain of a #line every time a multiline comment
3016 if (!put_out_comments)
3023 error_with_line (line_for_error (start_line),
3024 "unterminated comment");
3033 if (put_out_comments) {
3034 bcopy ((char *) before_bp, (char *) obp, ibp - before_bp);
3035 obp += ibp - before_bp;
3041 if (! is_idchar['$'])
3044 pedwarn ("`$' in identifier");
3047 case '0': case '1': case '2': case '3': case '4':
3048 case '5': case '6': case '7': case '8': case '9':
3049 /* If digit is not part of identifier, it starts a number,
3050 which means that following letters are not an identifier.
3051 "0x5" does not refer to an identifier "x5".
3052 So copy all alphanumerics that follow without accumulating
3053 as an identifier. Periods also, for sake of "3.e7". */
3055 if (ident_length == 0) {
3057 while (ibp[0] == '\\' && ibp[1] == '\n') {
3062 if (!is_idchar[c] && c != '.') {
3067 /* A sign can be part of a preprocessing number
3068 if it follows an `e' or `p'. */
3069 if (c == 'e' || c == 'E' || c == 'p' || c == 'P') {
3070 while (ibp[0] == '\\' && ibp[1] == '\n') {
3074 if (*ibp == '+' || *ibp == '-') {
3076 /* But traditional C does not let the token go past the sign,
3077 and C89 does not allow `p'. */
3078 if (traditional || (c89 && (c == 'p' || c == 'P')))
3088 case 'a': case 'b': case 'c': case 'd': case 'e': case 'f':
3089 case 'g': case 'h': case 'i': case 'j': case 'k': case 'l':
3090 case 'm': case 'n': case 'o': case 'p': case 'q': case 'r':
3091 case 's': case 't': case 'u': case 'v': case 'w': case 'x':
3093 case 'A': case 'B': case 'C': case 'D': case 'E': case 'F':
3094 case 'G': case 'H': case 'I': case 'J': case 'K': case 'L':
3095 case 'M': case 'N': case 'O': case 'P': case 'Q': case 'R':
3096 case 'S': case 'T': case 'U': case 'V': case 'W': case 'X':
3100 /* Compute step of hash function, to avoid a proc call on every token */
3101 hash = HASHSTEP (hash, c);
3105 if (ip->fname == 0 && *ibp == '-') {
3106 /* Newline - inhibits expansion of preceding token.
3107 If expanding a macro arg, we keep the newline -.
3108 In final output, it is deleted.
3109 We recognize Newline - in macro bodies and macro args. */
3110 if (! concatenated) {
3115 if (!output_marks) {
3118 /* If expanding a macro arg, keep the newline -. */
3124 /* If reprocessing a macro expansion, newline is a special marker. */
3125 else if (ip->macro != 0) {
3126 /* Newline White is a "funny space" to separate tokens that are
3127 supposed to be separate but without space between.
3128 Here White means any whitespace character.
3129 Newline - marks a recursive macro use that is not
3130 supposed to be expandable. */
3132 if (is_space[*ibp]) {
3133 /* Newline Space does not prevent expansion of preceding token
3134 so expand the preceding token and then come back. */
3135 if (ident_length > 0)
3138 /* If generating final output, newline space makes a space. */
3139 if (!output_marks) {
3141 /* And Newline Newline makes a newline, so count it. */
3142 if (obp[-1] == '\n')
3145 /* If expanding a macro arg, keep the newline space.
3146 If the arg gets stringified, newline space makes nothing. */
3149 } else abort (); /* Newline followed by something random? */
3153 /* If there is a pending identifier, handle it and come back here. */
3154 if (ident_length > 0)
3159 /* Update the line counts and output a #line if necessary. */
3162 if (ip->lineno != op->lineno) {
3164 output_line_directive (ip, op, 1, same_file);
3165 check_expand (op, limit - ibp);
3170 /* Come here either after (1) a null character that is part of the input
3171 or (2) at the end of the input, because there is a null there. */
3174 /* Our input really contains a null character. */
3178 /* At end of a macro-expansion level, pop it and read next level. */
3179 if (ip->macro != 0) {
3182 /* If traditional, and we have an identifier that ends here,
3183 process it now, so we get the right error for recursion. */
3184 if (traditional && ident_length
3185 && ! is_idchar[*instack[indepth - 1].bufp]) {
3194 /* If we don't have a pending identifier,
3195 return at end of input. */
3196 if (ident_length == 0) {
3204 /* If we do have a pending identifier, just consider this null
3205 a special character and arrange to dispatch on it again.
3206 The second time, IDENT_LENGTH will be zero so we will return. */
3212 /* Handle the case of a character such as /, ', " or null
3213 seen following an identifier. Back over it so that
3214 after the identifier is processed the special char
3215 will be dispatched on again. */
3225 if (ident_length > 0) {
3226 register HASHNODE *hp;
3228 /* We have just seen an identifier end. If it's a macro, expand it.
3230 IDENT_LENGTH is the length of the identifier
3231 and HASH is its hash code.
3233 The identifier has already been copied to the output,
3234 so if it is a macro we must remove it.
3236 If REDO_CHAR is 0, the char that terminated the identifier
3237 has been skipped in the output and the input.
3238 OBP-IDENT_LENGTH-1 points to the identifier.
3239 If the identifier is a macro, we must back over the terminator.
3241 If REDO_CHAR is 1, the terminating char has already been
3242 backed over. OBP-IDENT_LENGTH points to the identifier. */
3244 if (!pcp_outfile || pcp_inside_if) {
3245 for (hp = hashtab[MAKE_POS (hash) % HASHSIZE]; hp != NULL;
3248 if (hp->length == ident_length) {
3249 int obufp_before_macroname;
3250 int op_lineno_before_macroname;
3251 register int i = ident_length;
3252 register U_CHAR *p = hp->name;
3253 register U_CHAR *q = obp - i;
3259 do { /* All this to avoid a strncmp () */
3264 /* We found a use of a macro name.
3265 see if the context shows it is a macro call. */
3267 /* Back up over terminating character if not already done. */
3273 /* Save this as a displacement from the beginning of the output
3274 buffer. We can not save this as a position in the output
3275 buffer, because it may get realloc'ed by RECACHE. */
3276 obufp_before_macroname = (obp - op->buf) - ident_length;
3277 op_lineno_before_macroname = op->lineno;
3279 if (hp->type == T_PCSTRING) {
3280 pcstring_used (hp); /* Mark the definition of this key
3281 as needed, ensuring that it
3283 break; /* Exit loop, since the key cannot have a
3284 definition any longer. */
3287 /* Record whether the macro is disabled. */
3288 disabled = hp->type == T_DISABLED;
3290 /* This looks like a macro ref, but if the macro was disabled,
3291 just copy its name and put in a marker if requested. */
3295 /* This error check caught useful cases such as
3296 #define foo(x,y) bar (x (y,0), y)
3299 error ("recursive use of macro `%s'", hp->name);
3303 check_expand (op, limit - ibp + 2);
3310 /* If macro wants an arglist, verify that a '(' follows.
3311 first skip all whitespace, copying it to the output
3312 after the macro name. Then, if there is no '(',
3313 decide this is not a macro call and leave things that way. */
3314 if ((hp->type == T_MACRO || hp->type == T_DISABLED)
3315 && hp->value.defn->nargs >= 0)
3317 U_CHAR *old_ibp = ibp;
3318 U_CHAR *old_obp = obp;
3319 int old_iln = ip->lineno;
3320 int old_oln = op->lineno;
3323 /* Scan forward over whitespace, copying it to the output. */
3324 if (ibp == limit && ip->macro != 0) {
3329 old_iln = ip->lineno;
3330 old_oln = op->lineno;
3332 /* A comment: copy it unchanged or discard it. */
3333 else if (*ibp == '/' && ibp[1] == '*') {
3334 if (put_out_comments) {
3337 } else if (! traditional) {
3341 while (ibp + 1 != limit
3342 && !(ibp[0] == '*' && ibp[1] == '/')) {
3343 /* We need not worry about newline-marks,
3344 since they are never found in comments. */
3346 /* Newline in a file. Count it. */
3350 if (put_out_comments)
3356 if (put_out_comments) {
3361 else if (is_space[*ibp]) {
3363 if (ibp[-1] == '\n') {
3364 if (ip->macro == 0) {
3365 /* Newline in a file. Count it. */
3368 } else if (!output_marks) {
3369 /* A newline mark, and we don't want marks
3370 in the output. If it is newline-hyphen,
3371 discard it entirely. Otherwise, it is
3372 newline-whitechar, so keep the whitechar. */
3382 /* A newline mark; copy both chars to the output. */
3390 /* It isn't a macro call.
3391 Put back the space that we just skipped. */
3394 ip->lineno = old_iln;
3395 op->lineno = old_oln;
3396 /* Exit the for loop. */
3401 /* This is now known to be a macro call.
3402 Discard the macro name from the output,
3403 along with any following whitespace just copied,
3404 but preserve newlines if not outputting marks since this
3405 is more likely to do the right thing with line numbers. */
3406 obp = op->buf + obufp_before_macroname;
3408 op->lineno = op_lineno_before_macroname;
3410 int newlines = op->lineno - op_lineno_before_macroname;
3411 while (0 < newlines--)
3415 /* Prevent accidental token-pasting with a character
3416 before the macro call. */
3417 if (!traditional && obp != op->buf) {
3419 case '!': case '%': case '&': case '*':
3420 case '+': case '-': case '.': case '/':
3421 case ':': case '<': case '=': case '>':
3423 /* If we are expanding a macro arg, make a newline marker
3424 to separate the tokens. If we are making real output,
3425 a plain space will do. */
3432 /* Expand the macro, reading arguments as needed,
3433 and push the expansion on the input stack. */
3436 macroexpand (hp, op);
3438 /* Reexamine input stack, since macroexpand has pushed
3439 a new level on it. */
3446 } /* End hash-table-search loop */
3448 ident_length = hash = 0; /* Stop collecting identifier */
3451 } /* End if (ident_length > 0) */
3453 } /* End per-char loop */
3455 /* Come here to return -- but first give an error message
3456 if there was an unterminated successful conditional. */
3458 if (if_stack != ip->if_stack)
3462 switch (if_stack->type)
3483 error_with_line (line_for_error (if_stack->lineno),
3484 "unterminated `#%s' conditional", str);
3486 if_stack = ip->if_stack;
3490 * Rescan a string into a temporary buffer and return the result
3491 * as a FILE_BUF. Note this function returns a struct, not a pointer.
3493 * OUTPUT_MARKS nonzero means keep Newline markers found in the input
3494 * and insert such markers when appropriate. See `rescan' for details.
3495 * OUTPUT_MARKS is 1 for macroexpanding a macro argument separately
3496 * before substitution; it is 0 for other uses.
3499 expand_to_temp_buffer (buf, limit, output_marks, assertions)
3500 U_CHAR *buf, *limit;
3501 int output_marks, assertions;
3503 register FILE_BUF *ip;
3505 int length = limit - buf;
3507 int odepth = indepth;
3508 int save_assertions_flag = assertions_flag;
3510 assertions_flag = assertions;
3515 /* Set up the input on the input stack. */
3517 buf1 = (U_CHAR *) alloca (length + 1);
3519 register U_CHAR *p1 = buf;
3520 register U_CHAR *p2 = buf1;
3527 /* Set up to receive the output. */
3529 obuf.length = length * 2 + 100; /* Usually enough. Why be stingy? */
3530 obuf.bufp = obuf.buf = (U_CHAR *) xmalloc (obuf.length);
3535 CHECK_DEPTH ({return obuf;});
3539 ip = &instack[indepth];
3541 ip->nominal_fname = 0;
3543 ip->system_header_p = 0;
3546 ip->length = length;
3547 ip->buf = ip->bufp = buf1;
3548 ip->if_stack = if_stack;
3550 ip->lineno = obuf.lineno = 1;
3552 /* Scan the input, create the output. */
3553 rescan (&obuf, output_marks);
3555 /* Pop input stack to original state. */
3558 if (indepth != odepth)
3561 /* Record the output. */
3562 obuf.length = obuf.bufp - obuf.buf;
3564 assertions_flag = save_assertions_flag;
3569 * Process a # directive. Expects IP->bufp to point after the '#', as in
3570 * `#define foo bar'. Passes to the directive handler
3571 * (do_define, do_include, etc.): the addresses of the 1st and
3572 * last chars of the directive (starting immediately after the #
3573 * keyword), plus op and the keyword table pointer. If the directive
3574 * contains comments it is copied into a temporary buffer sans comments
3575 * and the temporary buffer is passed to the directive handler instead.
3576 * Likewise for backslash-newlines.
3578 * Returns nonzero if this was a known # directive.
3579 * Otherwise, returns zero, without advancing the input pointer.
3583 handle_directive (ip, op)
3586 register U_CHAR *bp, *cp;
3587 register struct directive *kt;
3588 register int ident_length;
3591 /* Nonzero means we must copy the entire directive
3592 to get rid of comments or backslash-newlines. */
3593 int copy_directive = 0;
3595 U_CHAR *ident, *after_ident;
3599 /* Record where the directive started. do_xifdef needs this. */
3600 directive_start = bp - 1;
3602 /* Skip whitespace and \-newline. */
3604 if (is_hor_space[*bp]) {
3605 if (*bp != ' ' && *bp != '\t' && pedantic)
3606 pedwarn ("%s in preprocessing directive", char_name[*bp]);
3608 } else if (*bp == '/' && (bp[1] == '*'
3609 || (cplusplus_comments && bp[1] == '/'))) {
3611 skip_to_end_of_comment (ip, &ip->lineno, 0);
3613 } else if (*bp == '\\' && bp[1] == '\n') {
3614 bp += 2; ip->lineno++;
3618 /* Now find end of directive name.
3619 If we encounter a backslash-newline, exchange it with any following
3620 symbol-constituents so that we end up with a contiguous name. */
3627 if (*cp == '\\' && cp[1] == '\n')
3628 name_newline_fix (cp);
3634 ident_length = cp - bp;
3638 /* A line of just `#' becomes blank. */
3640 if (ident_length == 0 && *after_ident == '\n') {
3641 ip->bufp = after_ident;
3645 if (ident_length == 0 || !is_idstart[*ident]) {
3647 while (is_idchar[*p]) {
3648 if (*p < '0' || *p > '9')
3652 /* Handle # followed by a line number. */
3653 if (p != ident && !is_idchar[*p]) {
3654 static struct directive line_directive_table[] = {
3655 { 4, do_line, "line", T_LINE},
3658 pedwarn ("`#' followed by integer");
3659 after_ident = ident;
3660 kt = line_directive_table;
3664 /* Avoid error for `###' and similar cases unless -pedantic. */
3666 while (*p == '#' || is_hor_space[*p]) p++;
3668 if (pedantic && !lang_asm)
3669 warning ("invalid preprocessing directive");
3675 error ("invalid preprocessing directive name");
3681 * Decode the keyword and call the appropriate expansion
3682 * routine, after moving the input pointer up to the next line.
3684 for (kt = directive_table; kt->length > 0; kt++) {
3685 if (kt->length == ident_length && !bcmp (kt->name, ident, ident_length)) {
3686 register U_CHAR *buf;
3687 register U_CHAR *limit;
3690 int *already_output;
3692 /* Nonzero means do not delete comments within the directive.
3693 #define needs this when -traditional. */
3698 limit = ip->buf + ip->length;
3701 keep_comments = traditional && kt->traditional_comments;
3702 /* #import is defined only in Objective C, or when on the NeXT. */
3703 if (kt->type == T_IMPORT
3704 && !(objc || lookup ((U_CHAR *) "__NeXT__", -1, -1)))
3707 /* Find the end of this directive (first newline not backslashed
3708 and not in a string or comment).
3709 Set COPY_DIRECTIVE if the directive must be copied
3710 (it contains a backslash-newline or a comment). */
3712 buf = bp = after_ident;
3713 while (bp < limit) {
3714 register U_CHAR c = *bp++;
3722 } else if (traditional)
3729 bp = skip_quoted_string (bp - 1, limit, ip->lineno, &ip->lineno, ©_directive, &unterminated);
3730 /* Don't bother calling the directive if we already got an error
3731 message due to unterminated string. Skip everything and pretend
3732 we called the directive. */
3735 /* Traditional preprocessing permits unterminated strings. */
3744 /* <...> is special for #include. */
3746 if (!kt->angle_brackets)
3748 while (bp < limit && *bp != '>' && *bp != '\n') {
3749 if (*bp == '\\' && bp[1] == '\n') {
3759 if (*bp == '\\' && bp[1] == '\n')
3762 || (cplusplus_comments && *bp == '/')) {
3763 U_CHAR *obp = bp - 1;
3765 skip_to_end_of_comment (ip, &ip->lineno, 0);
3767 /* No need to copy the directive because of a comment at the end;
3768 just don't include the comment in the directive. */
3769 if (!put_out_comments) {
3771 for (p = bp; *p == ' ' || *p == '\t'; p++)
3778 /* Don't remove the comments if -traditional. */
3779 if (! keep_comments)
3788 pedwarn ("%s in preprocessing directive", char_name[c]);
3792 --bp; /* Point to the newline */
3800 resume_p = ip->bufp;
3801 /* BP is the end of the directive.
3802 RESUME_P is the next interesting data after the directive.
3803 A comment may come between. */
3805 /* If a directive should be copied through, and -E was given,
3806 pass it through before removing comments. */
3807 if (!no_output && put_out_comments
3808 && (dump_macros != dump_definitions) < kt->pass_thru) {
3811 /* Output directive name. */
3812 check_expand (op, kt->length + 2);
3813 /* Make sure # is at the start of a line */
3814 if (op->bufp > op->buf && op->bufp[-1] != '\n') {
3819 bcopy (kt->name, op->bufp, kt->length);
3820 op->bufp += kt->length;
3822 /* Output arguments. */
3824 check_expand (op, len);
3825 bcopy (buf, (char *) op->bufp, len);
3827 /* Take account of any (escaped) newlines just output. */
3829 if (buf[len] == '\n')
3832 already_output = &junk;
3833 } /* Don't we need a newline or #line? */
3835 if (copy_directive) {
3836 register U_CHAR *xp = buf;
3837 /* Need to copy entire directive into temp buffer before dispatching */
3839 cp = (U_CHAR *) alloca (bp - buf + 5); /* room for directive plus
3843 /* Copy to the new buffer, deleting comments
3844 and backslash-newlines (and whitespace surrounding the latter). */
3847 register U_CHAR c = *xp++;
3852 abort (); /* A bare newline should never part of the line. */
3855 /* <...> is special for #include. */
3857 if (!kt->angle_brackets)
3859 while (xp < bp && c != '>') {
3861 if (c == '\\' && xp < bp && *xp == '\n')
3872 if (cp != buf && is_hor_space[cp[-1]]) {
3873 while (cp - 1 != buf && is_hor_space[cp[-2]])
3875 SKIP_WHITE_SPACE (xp);
3876 } else if (is_hor_space[*xp]) {
3878 SKIP_WHITE_SPACE (xp);
3880 } else if (traditional && xp < bp) {
3888 register U_CHAR *bp1
3889 = skip_quoted_string (xp - 1, bp, ip->lineno,
3890 NULL_PTR, NULL_PTR, NULL_PTR);
3904 || (cplusplus_comments && *xp == '/')) {
3906 /* If we already copied the directive through,
3907 already_output != 0 prevents outputting comment now. */
3908 skip_to_end_of_comment (ip, already_output, 0);
3910 while (xp != ip->bufp)
3912 /* Delete or replace the slash. */
3913 else if (traditional)
3922 /* Null-terminate the copy. */
3928 ip->bufp = resume_p;
3930 /* Some directives should be written out for cc1 to process,
3931 just as if they were not defined. And sometimes we're copying
3932 definitions through. */
3934 if (!no_output && already_output == 0
3935 && (dump_macros < dump_names) < kt->pass_thru) {
3938 /* Output directive name. */
3939 check_expand (op, kt->length + 1);
3941 bcopy (kt->name, (char *) op->bufp, kt->length);
3942 op->bufp += kt->length;
3944 if ((dump_macros != dump_definitions) < kt->pass_thru) {
3945 /* Output arguments. */
3947 check_expand (op, len);
3948 bcopy (buf, (char *) op->bufp, len);
3950 } else if (kt->type == T_DEFINE && dump_macros == dump_names) {
3953 SKIP_WHITE_SPACE (xp);
3955 while (is_idchar[*xp]) xp++;
3957 check_expand (op, len + 1);
3959 bcopy (yp, op->bufp, len);
3962 } /* Don't we need a newline or #line? */
3964 /* Call the appropriate directive handler. buf now points to
3965 either the appropriate place in the input buffer, or to
3966 the temp buffer if it was necessary to make one. cp
3967 points to the first char after the contents of the (possibly
3968 copied) directive, in either case. */
3969 (*kt->func) (buf, cp, op, kt);
3970 check_expand (op, ip->length - (ip->bufp - ip->buf));
3976 /* It is deliberate that we don't warn about undefined directives.
3977 That is the responsibility of cc1. */
3984 static struct tm *timebuf;
3986 time_t t = time ((time_t *) 0);
3987 timebuf = localtime (&t);
3992 static char *monthnames[] = {"Jan", "Feb", "Mar", "Apr", "May", "Jun",
3993 "Jul", "Aug", "Sep", "Oct", "Nov", "Dec",
3997 * expand things like __FILE__. Place the expansion into the output
3998 * buffer *without* rescanning.
4002 special_symbol (hp, op)
4009 FILE_BUF *ip = NULL;
4012 int paren = 0; /* For special `defined' keyword */
4014 if (pcp_outfile && pcp_inside_if
4015 && hp->type != T_SPEC_DEFINED && hp->type != T_CONST)
4016 error ("Predefined macro `%s' used inside `#if' during precompilation",
4019 for (i = indepth; i >= 0; i--)
4020 if (instack[i].fname != NULL) {
4025 error ("cccp error: not in any file?!");
4026 return; /* the show must go on */
4034 if (hp->type == T_FILE)
4035 string = ip->nominal_fname;
4037 string = instack[0].nominal_fname;
4041 buf = (char *) alloca (3 + 4 * strlen (string));
4042 quote_string (buf, string);
4050 case T_INCLUDE_LEVEL:
4052 for (i = indepth; i >= 0; i--)
4053 if (instack[i].fname != NULL)
4056 buf = (char *) alloca (8); /* Eight bytes ought to be more than enough */
4057 sprintf (buf, "%d", true_indepth - 1);
4061 buf = (char *) alloca (3 + strlen (version_string));
4062 sprintf (buf, "\"%s\"", version_string);
4065 #ifndef NO_BUILTIN_SIZE_TYPE
4071 #ifndef NO_BUILTIN_PTRDIFF_TYPE
4072 case T_PTRDIFF_TYPE:
4081 case T_USER_LABEL_PREFIX_TYPE:
4082 buf = USER_LABEL_PREFIX;
4085 case T_REGISTER_PREFIX_TYPE:
4086 buf = REGISTER_PREFIX;
4089 case T_IMMEDIATE_PREFIX_TYPE:
4090 buf = IMMEDIATE_PREFIX;
4094 buf = hp->value.cpval;
4095 if (pcp_inside_if && pcp_outfile)
4096 /* Output a precondition for this macro use */
4097 fprintf (pcp_outfile, "#define %s %s\n", hp->name, buf);
4101 buf = (char *) alloca (10);
4102 sprintf (buf, "%d", ip->lineno);
4107 buf = (char *) alloca (20);
4108 timebuf = timestamp ();
4109 if (hp->type == T_DATE)
4110 sprintf (buf, "\"%s %2d %4d\"", monthnames[timebuf->tm_mon],
4111 timebuf->tm_mday, timebuf->tm_year + 1900);
4113 sprintf (buf, "\"%02d:%02d:%02d\"", timebuf->tm_hour, timebuf->tm_min,
4117 case T_SPEC_DEFINED:
4118 buf = " 0 "; /* Assume symbol is not defined */
4119 ip = &instack[indepth];
4120 SKIP_WHITE_SPACE (ip->bufp);
4121 if (*ip->bufp == '(') {
4123 ip->bufp++; /* Skip over the paren */
4124 SKIP_WHITE_SPACE (ip->bufp);
4127 if (!is_idstart[*ip->bufp])
4129 if (ip->bufp[0] == 'L' && (ip->bufp[1] == '\'' || ip->bufp[1] == '"'))
4131 if ((hp = lookup (ip->bufp, -1, -1))) {
4132 if (pcp_outfile && pcp_inside_if
4133 && (hp->type == T_CONST
4134 || (hp->type == T_MACRO && hp->value.defn->predefined)))
4135 /* Output a precondition for this macro use. */
4136 fprintf (pcp_outfile, "#define %s\n", hp->name);
4140 if (pcp_outfile && pcp_inside_if) {
4141 /* Output a precondition for this macro use */
4142 U_CHAR *cp = ip->bufp;
4143 fprintf (pcp_outfile, "#undef ");
4144 while (is_idchar[*cp]) /* Ick! */
4145 fputc (*cp++, pcp_outfile);
4146 putc ('\n', pcp_outfile);
4148 while (is_idchar[*ip->bufp])
4150 SKIP_WHITE_SPACE (ip->bufp);
4152 if (*ip->bufp != ')')
4160 error ("`defined' without an identifier");
4164 error ("cccp error: invalid special hash type"); /* time for gdb */
4168 check_expand (op, len);
4169 bcopy (buf, (char *) op->bufp, len);
4176 /* Routines to handle #directives */
4178 /* Handle #include and #import.
4179 This function expects to see "fname" or <fname> on the input. */
4182 do_include (buf, limit, op, keyword)
4183 U_CHAR *buf, *limit;
4185 struct directive *keyword;
4187 U_CHAR *importing = keyword->type == T_IMPORT ? (U_CHAR *) "" : (U_CHAR *) 0;
4188 int skip_dirs = (keyword->type == T_INCLUDE_NEXT);
4189 static int import_warning = 0;
4190 char *fname; /* Dynamically allocated fname buffer */
4193 char *fbeg, *fend; /* Beginning and end of fname */
4196 struct file_name_list *search_start = include; /* Chain of dirs to search */
4197 struct file_name_list *dsp; /* First in chain, if #include "..." */
4198 struct file_name_list *searchptr = 0;
4201 int f = -3; /* file number */
4202 struct include_file *inc = 0;
4204 int retried = 0; /* Have already tried macro
4205 expanding the include line*/
4206 int angle_brackets = 0; /* 0 for "...", 1 for <...> */
4208 int vaxc_include = 0; /* 1 for token without punctuation */
4215 if (importing && warn_import && !inhibit_warnings
4216 && !instack[indepth].system_header_p && !import_warning) {
4218 warning ("using `#import' is not recommended");
4219 fprintf (stderr, "The fact that a certain header file need not be processed more than once\n");
4220 fprintf (stderr, "should be indicated in the header file, not where it is used.\n");
4221 fprintf (stderr, "The best way to do this is with a conditional of this form:\n\n");
4222 fprintf (stderr, " #ifndef _FOO_H_INCLUDED\n");
4223 fprintf (stderr, " #define _FOO_H_INCLUDED\n");
4224 fprintf (stderr, " ... <real contents of file> ...\n");
4225 fprintf (stderr, " #endif /* Not _FOO_H_INCLUDED */\n\n");
4226 fprintf (stderr, "Then users can use `#include' any number of times.\n");
4227 fprintf (stderr, "GNU C automatically avoids processing the file more than once\n");
4228 fprintf (stderr, "when it is equipped with such a conditional.\n");
4234 SKIP_WHITE_SPACE (fin);
4235 /* Discard trailing whitespace so we can easily see
4236 if we have parsed all the significant chars we were given. */
4237 while (limit != fin && is_hor_space[limit[-1]]) limit--;
4238 fbeg = fend = (char *) alloca (limit - fin);
4244 /* Copy the operand text, concatenating the strings. */
4246 while (fin != limit) {
4247 while (fin != limit && *fin != '\"')
4252 /* If not at the end, there had better be another string. */
4253 /* Skip just horiz space, and don't go past limit. */
4254 while (fin != limit && is_hor_space[*fin]) fin++;
4255 if (fin != limit && *fin == '\"')
4262 /* We have "filename". Figure out directory this source
4263 file is coming from and put it on the front of the list. */
4265 /* If -I- was specified, don't search current dir, only spec'd ones. */
4266 if (ignore_srcdir) break;
4268 for (fp = &instack[indepth]; fp >= instack; fp--)
4273 if ((nam = fp->nominal_fname) != NULL) {
4274 /* Found a named file. Figure out dir of the file,
4275 and put it in front of the search list. */
4276 dsp = ((struct file_name_list *)
4277 alloca (sizeof (struct file_name_list) + strlen (nam)));
4278 strcpy (dsp->fname, nam);
4279 simplify_filename (dsp->fname);
4280 nam = base_name (dsp->fname);
4282 /* But for efficiency's sake, do not insert the dir
4283 if it matches the search list's first dir. */
4284 dsp->next = search_start;
4285 if (!search_start || strcmp (dsp->fname, search_start->fname)) {
4287 n = nam - dsp->fname;
4288 if (n + INCLUDE_LEN_FUDGE > max_include_len)
4289 max_include_len = n + INCLUDE_LEN_FUDGE;
4291 dsp[0].got_name_map = 0;
4299 while (fin != limit && *fin != '>')
4301 if (*fin == '>' && fin + 1 == limit) {
4303 /* If -I-, start with the first -I dir after the -I-. */
4304 search_start = first_bracket_include;
4312 * Support '#include xyz' like VAX-C to allow for easy use of all the
4313 * decwindow include files. It defaults to '#include <xyz.h>' (so the
4314 * code from case '<' is repeated here) and generates a warning.
4315 * (Note: macro expansion of `xyz' takes precedence.)
4317 if (retried && isalpha(*(U_CHAR *) (--fbeg))) {
4318 while (fin != limit && (!isspace(*fin)))
4320 warning ("VAX-C-style include specification found, use '#include <filename.h>' !");
4324 /* If -I-, start with the first -I dir after the -I-. */
4325 search_start = first_bracket_include;
4333 error ("`#%s' expects \"FILENAME\" or <FILENAME>", keyword->name);
4336 /* Expand buffer and then remove any newline markers.
4337 We can't just tell expand_to_temp_buffer to omit the markers,
4338 since it would put extra spaces in include file names. */
4341 trybuf = expand_to_temp_buffer (buf, limit, 1, 0);
4343 buf = (U_CHAR *) alloca (trybuf.bufp - trybuf.buf + 1);
4345 while (src != trybuf.bufp) {
4346 switch ((*limit++ = *src++)) {
4355 U_CHAR *src1 = skip_quoted_string (src - 1, trybuf.bufp, 0,
4356 NULL_PTR, NULL_PTR, NULL_PTR);
4370 /* For #include_next, skip in the search path
4371 past the dir in which the containing file was found. */
4374 for (fp = &instack[indepth]; fp >= instack; fp--)
4375 if (fp->fname != NULL) {
4376 /* fp->dir is null if the containing file was specified
4377 with an absolute file name. In that case, don't skip anything. */
4379 search_start = fp->dir->next;
4385 flen = simplify_filename (fbeg);
4389 error ("empty file name in `#%s'", keyword->name);
4393 /* Allocate this permanently, because it gets stored in the definitions
4395 fname = xmalloc (max_include_len + flen + 1);
4396 /* + 1 above for terminating null. */
4398 system_include_depth += angle_brackets;
4400 /* If specified file name is absolute, just open it. */
4402 if (absolute_filename (fbeg)) {
4403 strcpy (fname, fbeg);
4404 f = open_include_file (fname, NULL_PTR, importing, &inc);
4408 struct bypass_dir *next;
4410 struct file_name_list *searchptr;
4411 } **bypass_slot = 0;
4413 /* Search directory path, trying to open the file.
4414 Copy each filename tried into FNAME. */
4416 for (searchptr = search_start; searchptr; searchptr = searchptr->next) {
4418 if (searchptr == first_bracket_include) {
4419 /* Go to bypass directory if we know we've seen this file before. */
4420 static struct bypass_dir *bypass_hashtab[INCLUDE_HASHSIZE];
4421 struct bypass_dir *p;
4422 bypass_slot = &bypass_hashtab[hashf ((U_CHAR *) fbeg, flen,
4424 for (p = *bypass_slot; p; p = p->next)
4425 if (!strcmp (fbeg, p->fname)) {
4426 searchptr = p->searchptr;
4432 strcpy (fname, searchptr->fname);
4433 strcat (fname, fbeg);
4435 /* Change this 1/2 Unix 1/2 VMS file specification into a
4436 full VMS file specification */
4437 if (searchptr->fname[0]) {
4438 /* Fix up the filename */
4439 hack_vms_include_specification (fname, vaxc_include);
4441 /* This is a normal VMS filespec, so use it unchanged. */
4442 strcpy (fname, fbeg);
4443 /* if it's '#include filename', add the missing .h */
4444 if (vaxc_include && index(fname,'.')==NULL) {
4445 strcat (fname, ".h");
4449 f = open_include_file (fname, searchptr, importing, &inc);
4451 if (bypass_slot && searchptr != first_bracket_include) {
4452 /* This is the first time we found this include file,
4453 and we found it after first_bracket_include.
4454 Record its location so that we can bypass to here next time. */
4455 struct bypass_dir *p
4456 = (struct bypass_dir *) xmalloc (sizeof (struct bypass_dir));
4457 p->next = *bypass_slot;
4458 p->fname = fname + strlen (searchptr->fname);
4459 p->searchptr = searchptr;
4465 /* Our VMS hacks can produce invalid filespecs, so don't worry
4466 about errors other than EACCES. */
4467 if (errno == EACCES)
4470 if (errno != ENOENT && errno != ENOTDIR)
4480 /* The file was already included. */
4482 /* If generating dependencies and -MG was specified, we assume missing
4483 files are leaf files, living in the same directory as the source file
4484 or other similar place; these missing files may be generated from
4485 other files and may not exist yet (eg: y.tab.h). */
4486 } else if (print_deps_missing_files
4487 && (system_include_depth != 0) < print_deps)
4489 /* If it was requested as a system header file,
4490 then assume it belongs in the first place to look for such. */
4494 char *p = (char *) alloca (strlen (search_start->fname)
4495 + strlen (fbeg) + 1);
4496 strcpy (p, search_start->fname);
4498 deps_output (p, ' ');
4503 /* Otherwise, omit the directory, as if the file existed
4504 in the directory with the source. */
4505 deps_output (fbeg, ' ');
4508 /* If -M was specified, and this header file won't be added to the
4509 dependency list, then don't count this as an error, because we can
4510 still produce correct output. Otherwise, we can't produce correct
4511 output, because there may be dependencies we need inside the missing
4512 file, and we don't know what directory this missing file exists in. */
4513 else if (0 < print_deps && print_deps <= (system_include_depth != 0))
4514 warning ("No include path in which to find %s", fbeg);
4516 error_from_errno (fbeg);
4518 error ("No include path in which to find %s", fbeg);
4522 /* Actually process the file. */
4524 pcftry = (char *) alloca (strlen (fname) + 30);
4531 sprintf (pcftry, "%s%d", fname, pcfnum++);
4533 pcf = open (pcftry, O_RDONLY, 0666);
4538 if (fstat (pcf, &s) != 0)
4539 pfatal_with_name (pcftry);
4540 if (! INO_T_EQ (inc->st.st_ino, s.st_ino)
4541 || inc->st.st_dev != s.st_dev)
4543 pcfbuf = check_precompiled (pcf, &s, fname, &pcfbuflimit);
4544 /* Don't need it any more. */
4549 /* Don't need it at all. */
4554 } while (pcf != -1 && !pcfbuf);
4557 /* Actually process the file */
4559 pcfname = xmalloc (strlen (pcftry) + 1);
4560 strcpy (pcfname, pcftry);
4561 pcfinclude ((U_CHAR *) pcfbuf, (U_CHAR *) pcfbuflimit,
4562 (U_CHAR *) fname, op);
4565 finclude (f, inc, op, is_system_include (fname), searchptr);
4568 system_include_depth -= angle_brackets;
4573 /* Return nonzero if the given FILENAME is an absolute pathname which
4574 designates a file within one of the known "system" include file
4575 directories. We assume here that if the given FILENAME looks like
4576 it is the name of a file which resides either directly in a "system"
4577 include file directory, or within any subdirectory thereof, then the
4578 given file must be a "system" include file. This function tells us
4579 if we should suppress pedantic errors/warnings for the given FILENAME.
4581 The value is 2 if the file is a C-language system header file
4582 for which C++ should (on most systems) assume `extern "C"'. */
4585 is_system_include (filename)
4586 register char *filename;
4588 struct file_name_list *searchptr;
4590 for (searchptr = first_system_include; searchptr;
4591 searchptr = searchptr->next)
4592 if (! strncmp (searchptr->fname, filename, strlen (searchptr->fname)))
4593 return searchptr->c_system_include_path + 1;
4597 /* Yield the non-directory suffix of a file name. */
4605 #if defined (__MSDOS__) || defined (_WIN32)
4606 if (isalpha (s[0]) && s[1] == ':') s += 2;
4609 if ((p = rindex (s, ':'))) s = p + 1; /* Skip device. */
4610 if ((p = rindex (s, ']'))) s = p + 1; /* Skip directory. */
4611 if ((p = rindex (s, '>'))) s = p + 1; /* Skip alternate (int'n'l) dir. */
4615 if ((p = rindex (s, '/'))) s = p + 1;
4616 #ifdef DIR_SEPARATOR
4617 if ((p = rindex (s, DIR_SEPARATOR))) s = p + 1;
4622 /* Yield nonzero if FILENAME is absolute (i.e. not relative). */
4625 absolute_filename (filename)
4628 #if defined (__MSDOS__) || (defined (_WIN32) && !defined (__CYGWIN32__))
4629 if (isalpha (filename[0]) && filename[1] == ':') filename += 2;
4631 #if defined (__CYGWIN32__)
4632 /* At present, any path that begins with a drive spec is absolute. */
4633 if (isalpha (filename[0]) && filename[1] == ':') return 1;
4635 if (filename[0] == '/') return 1;
4636 #ifdef DIR_SEPARATOR
4637 if (filename[0] == DIR_SEPARATOR) return 1;
4642 /* Remove unnecessary characters from FILENAME in place,
4643 to avoid unnecessary filename aliasing.
4644 Return the length of the resulting string.
4646 Do only the simplifications allowed by Posix.
4647 It is OK to miss simplifications on non-Posix hosts,
4648 since this merely leads to suboptimial results. */
4651 simplify_filename (filename)
4654 register char *from = filename;
4655 register char *to = filename;
4658 /* Remove redundant initial /s. */
4661 if (*++from == '/') {
4662 if (*++from == '/') {
4663 /* 3 or more initial /s are equivalent to 1 /. */
4664 while (*++from == '/')
4667 /* On some hosts // differs from /; Posix allows this. */
4668 static int slashslash_vs_slash;
4669 if (slashslash_vs_slash == 0) {
4671 slashslash_vs_slash = ((stat ("/", &s1) == 0 && stat ("//", &s2) == 0
4672 && INO_T_EQ (s1.st_ino, s2.st_ino)
4673 && s1.st_dev == s2.st_dev)
4676 if (slashslash_vs_slash < 0)
4684 if (from[0] == '.' && from[1] == '/')
4687 /* Copy this component and trailing /, if any. */
4688 while ((*to++ = *from++) != '/') {
4690 /* Trim . component at end of nonempty name. */
4691 to -= filename <= to - 3 && to[-3] == '/' && to[-2] == '.';
4693 /* Trim unnecessary trailing /s. */
4694 while (to0 < --to && to[-1] == '/')
4698 return to - filename;
4703 /* Skip /s after a /. */
4704 while (*from == '/')
4709 /* The file_name_map structure holds a mapping of file names for a
4710 particular directory. This mapping is read from the file named
4711 FILE_NAME_MAP_FILE in that directory. Such a file can be used to
4712 map filenames on a file system with severe filename restrictions,
4713 such as DOS. The format of the file name map file is just a series
4714 of lines with two tokens on each line. The first token is the name
4715 to map, and the second token is the actual name to use. */
4717 struct file_name_map
4719 struct file_name_map *map_next;
4724 #define FILE_NAME_MAP_FILE "header.gcc"
4726 /* Read a space delimited string of unlimited length from a stdio
4730 read_filename_string (ch, f)
4738 set = alloc = xmalloc (len + 1);
4742 while ((ch = getc (f)) != EOF && ! is_space[ch])
4744 if (set - alloc == len)
4747 alloc = xrealloc (alloc, len + 1);
4748 set = alloc + len / 2;
4758 /* Read the file name map file for DIRNAME.
4759 If DIRNAME is empty, read the map file for the working directory;
4760 otherwise DIRNAME must end in '/'. */
4762 static struct file_name_map *
4763 read_name_map (dirname)
4766 /* This structure holds a linked list of file name maps, one per
4768 struct file_name_map_list
4770 struct file_name_map_list *map_list_next;
4771 char *map_list_name;
4772 struct file_name_map *map_list_map;
4774 static struct file_name_map_list *map_list;
4775 register struct file_name_map_list *map_list_ptr;
4780 for (map_list_ptr = map_list; map_list_ptr;
4781 map_list_ptr = map_list_ptr->map_list_next)
4782 if (! strcmp (map_list_ptr->map_list_name, dirname))
4783 return map_list_ptr->map_list_map;
4785 map_list_ptr = ((struct file_name_map_list *)
4786 xmalloc (sizeof (struct file_name_map_list)));
4787 map_list_ptr->map_list_name = savestring (dirname);
4788 map_list_ptr->map_list_map = NULL;
4790 dirlen = strlen (dirname);
4791 name = (char *) alloca (dirlen + strlen (FILE_NAME_MAP_FILE) + 1);
4792 strcpy (name, dirname);
4793 strcat (name, FILE_NAME_MAP_FILE);
4794 f = fopen (name, "r");
4796 map_list_ptr->map_list_map = NULL;
4801 while ((ch = getc (f)) != EOF)
4804 struct file_name_map *ptr;
4809 from = read_filename_string (ch, f);
4810 while ((ch = getc (f)) != EOF && is_hor_space[ch])
4812 to = read_filename_string (ch, f);
4814 simplify_filename (from);
4815 tolen = simplify_filename (to);
4817 ptr = ((struct file_name_map *)
4818 xmalloc (sizeof (struct file_name_map)));
4819 ptr->map_from = from;
4821 /* Make the real filename absolute. */
4822 if (absolute_filename (to))
4826 ptr->map_to = xmalloc (dirlen + tolen + 1);
4827 strcpy (ptr->map_to, dirname);
4828 strcat (ptr->map_to, to);
4832 ptr->map_next = map_list_ptr->map_list_map;
4833 map_list_ptr->map_list_map = ptr;
4835 while ((ch = getc (f)) != '\n')
4842 map_list_ptr->map_list_next = map_list;
4843 map_list = map_list_ptr;
4845 return map_list_ptr->map_list_map;
4848 /* Try to open include file FILENAME. SEARCHPTR is the directory
4849 being tried from the include file search path.
4850 IMPORTING is "" if we are importing, null otherwise.
4851 Return -2 if found, either a matching name or a matching inode.
4852 Otherwise, open the file and return a file descriptor if successful
4853 or -1 if unsuccessful.
4854 Unless unsuccessful, put a descriptor of the included file into *PINC.
4855 This function maps filenames on file systems based on information read by
4859 open_include_file (filename, searchptr, importing, pinc)
4861 struct file_name_list *searchptr;
4863 struct include_file **pinc;
4865 char *fname = remap_include_file (filename, searchptr);
4868 /* Look up FNAME in include_hashtab. */
4869 struct include_file **phead = &include_hashtab[hashf ((U_CHAR *) fname,
4872 struct include_file *inc, *head = *phead;
4873 for (inc = head; inc; inc = inc->next)
4874 if (!strcmp (fname, inc->fname))
4878 || ! inc->control_macro
4879 || (inc->control_macro[0] && ! lookup (inc->control_macro, -1, -1))) {
4881 fd = open (fname, O_RDONLY, 0);
4887 /* FNAME was not in include_hashtab; insert a new entry. */
4888 inc = (struct include_file *) xmalloc (sizeof (struct include_file));
4891 inc->control_macro = 0;
4892 inc->deps_output = 0;
4893 if (fstat (fd, &inc->st) != 0)
4894 pfatal_with_name (fname);
4897 /* Look for another file with the same inode and device. */
4898 if (lookup_ino_include (inc)
4899 && inc->control_macro
4900 && (!inc->control_macro[0] || lookup (inc->control_macro, -1, -1))) {
4906 /* For -M, add this file to the dependencies. */
4907 if (! inc->deps_output && (system_include_depth != 0) < print_deps) {
4908 inc->deps_output = 1;
4909 deps_output (fname, ' ');
4912 /* Handle -H option. */
4913 if (print_include_names)
4914 fprintf (stderr, "%*s%s\n", indepth, "", fname);
4918 inc->control_macro = importing;
4924 /* Return the remapped name of the the include file FILENAME.
4925 SEARCHPTR is the directory being tried from the include file path. */
4928 remap_include_file (filename, searchptr)
4930 struct file_name_list *searchptr;
4932 register struct file_name_map *map;
4933 register char *from;
4937 if (! searchptr->got_name_map)
4939 searchptr->name_map = read_name_map (searchptr->fname);
4940 searchptr->got_name_map = 1;
4943 /* Check the mapping for the directory we are using. */
4944 from = filename + strlen (searchptr->fname);
4945 for (map = searchptr->name_map; map; map = map->map_next)
4946 if (! strcmp (map->map_from, from))
4950 from = base_name (filename);
4952 if (from != filename || !searchptr)
4954 /* Try to find a mapping file for the particular directory we are
4955 looking in. Thus #include <sys/types.h> will look up sys/types.h
4956 in /usr/include/header.gcc and look up types.h in
4957 /usr/include/sys/header.gcc. */
4959 char *dir = (char *) alloca (from - filename + 1);
4960 bcopy (filename, dir, from - filename);
4961 dir[from - filename] = '\0';
4963 for (map = read_name_map (dir); map; map = map->map_next)
4964 if (! strcmp (map->map_from, from))
4971 /* Insert INC into the include file table, hashed by device and inode number.
4972 If a file with different name but same dev+ino was already in the table,
4973 return 1 and set INC's control macro to the already-known macro. */
4976 lookup_ino_include (inc)
4977 struct include_file *inc;
4979 int hash = ((unsigned) (inc->st.st_dev + INO_T_HASH (inc->st.st_ino))
4980 % INCLUDE_HASHSIZE);
4981 struct include_file *i = include_ino_hashtab[hash];
4983 include_ino_hashtab[hash] = inc;
4985 for (; i; i = i->next_ino)
4986 if (INO_T_EQ (inc->st.st_ino, i->st.st_ino)
4987 && inc->st.st_dev == i->st.st_dev) {
4988 inc->control_macro = i->control_macro;
4995 /* Process file descriptor F, which corresponds to include file INC,
4997 SYSTEM_HEADER_P is 1 if this file resides in any one of the known
4998 "system" include directories (as decided by the `is_system_include'
5000 DIRPTR is the link in the dir path through which this file was found,
5001 or 0 if the file name was absolute. */
5004 finclude (f, inc, op, system_header_p, dirptr)
5006 struct include_file *inc;
5008 int system_header_p;
5009 struct file_name_list *dirptr;
5011 char *fname = inc->fname;
5013 FILE_BUF *fp; /* For input stack frame */
5014 int missing_newline = 0;
5016 CHECK_DEPTH (return;);
5018 fp = &instack[indepth + 1];
5019 bzero ((char *) fp, sizeof (FILE_BUF));
5020 fp->nominal_fname = fp->fname = fname;
5024 fp->if_stack = if_stack;
5025 fp->system_header_p = system_header_p;
5028 if (S_ISREG (inc->st.st_mode)) {
5029 fp->buf = (U_CHAR *) xmalloc (inc->st.st_size + 2);
5032 /* Read the file contents, knowing that inc->st.st_size is an upper bound
5033 on the number of bytes we can read. */
5034 fp->length = safe_read (f, (char *) fp->buf, inc->st.st_size);
5035 if (fp->length < 0) goto nope;
5037 else if (S_ISDIR (inc->st.st_mode)) {
5038 error ("directory `%s' specified in #include", fname);
5042 /* Cannot count its file size before reading.
5043 First read the entire file into heap and
5044 copy them into buffer on stack. */
5049 fp->buf = (U_CHAR *) xmalloc (bsize + 2);
5052 i = safe_read (f, (char *) fp->buf + st_size, bsize - st_size);
5054 goto nope; /* error! */
5056 if (st_size != bsize)
5057 break; /* End of file */
5059 fp->buf = (U_CHAR *) xrealloc (fp->buf, bsize + 2);
5062 fp->length = st_size;
5065 if ((fp->length > 0 && fp->buf[fp->length - 1] != '\n')
5066 /* Backslash-newline at end is not good enough. */
5067 || (fp->length > 1 && fp->buf[fp->length - 2] == '\\')) {
5068 fp->buf[fp->length++] = '\n';
5069 missing_newline = 1;
5071 fp->buf[fp->length] = '\0';
5073 /* Close descriptor now, so nesting does not use lots of descriptors. */
5076 /* Must do this before calling trigraph_pcp, so that the correct file name
5077 will be printed in warning messages. */
5080 input_file_stack_tick++;
5085 output_line_directive (fp, op, 0, enter_file);
5088 if (missing_newline)
5091 if (pedantic && missing_newline)
5092 pedwarn ("file does not end in newline");
5095 input_file_stack_tick++;
5096 output_line_directive (&instack[indepth], op, 0, leave_file);
5102 perror_with_name (fname);
5107 /* Record that inclusion of the include file INC
5108 should be controlled by the macro named MACRO_NAME.
5109 This means that trying to include the file again
5110 will do something if that macro is defined. */
5113 record_control_macro (inc, macro_name)
5114 struct include_file *inc;
5117 if (!inc->control_macro || inc->control_macro[0])
5118 inc->control_macro = macro_name;
5121 /* Load the specified precompiled header into core, and verify its
5122 preconditions. PCF indicates the file descriptor to read, which must
5123 be a regular file. *ST is its file status.
5124 FNAME indicates the file name of the original header.
5125 *LIMIT will be set to an address one past the end of the file.
5126 If the preconditions of the file are not satisfied, the buffer is
5127 freed and we return 0. If the preconditions are satisfied, return
5128 the address of the buffer following the preconditions. The buffer, in
5129 this case, should never be freed because various pieces of it will
5130 be referred to until all precompiled strings are output at the end of
5134 check_precompiled (pcf, st, fname, limit)
5147 if (S_ISREG (st->st_mode))
5149 buf = xmalloc (st->st_size + 2);
5150 length = safe_read (pcf, buf, st->st_size);
5157 if (length > 0 && buf[length-1] != '\n')
5158 buf[length++] = '\n';
5161 *limit = buf + length;
5163 /* File is in core. Check the preconditions. */
5164 if (!check_preconditions (buf))
5166 for (cp = buf; *cp; cp++)
5169 fprintf (stderr, "Using preinclude %s\n", fname);
5175 fprintf (stderr, "Cannot use preinclude %s\n", fname);
5181 /* PREC (null terminated) points to the preconditions of a
5182 precompiled header. These are a series of #define and #undef
5183 lines which must match the current contents of the hash
5187 check_preconditions (prec)
5194 lineend = index (prec, '\n');
5196 if (*prec++ != '#') {
5197 error ("Bad format encountered while reading precompiled file");
5200 if (!strncmp (prec, "define", 6)) {
5204 mdef = create_definition ((U_CHAR *) prec, (U_CHAR *) lineend, NULL_PTR);
5209 if ((hp = lookup (mdef.symnam, mdef.symlen, -1)) == NULL
5210 || (hp->type != T_MACRO && hp->type != T_CONST)
5211 || (hp->type == T_MACRO
5212 && !compare_defs (mdef.defn, hp->value.defn)
5213 && (mdef.defn->length != 2
5214 || mdef.defn->expansion[0] != '\n'
5215 || mdef.defn->expansion[1] != ' ')))
5217 } else if (!strncmp (prec, "undef", 5)) {
5222 while (is_hor_space[(U_CHAR) *prec])
5225 while (is_idchar[(U_CHAR) *prec])
5229 if (lookup ((U_CHAR *) name, len, -1))
5232 error ("Bad format encountered while reading precompiled file");
5237 /* They all passed successfully */
5241 /* Process the main body of a precompiled file. BUF points to the
5242 string section of the file, following the preconditions. LIMIT is one
5243 character past the end. NAME is the name of the file being read
5244 in. OP is the main output buffer. */
5247 pcfinclude (buf, limit, name, op)
5248 U_CHAR *buf, *limit, *name;
5255 /* First in the file comes 4 bytes indicating the number of strings, */
5256 /* in network byte order. (MSB first). */
5258 nstrings = (nstrings << 8) | *cp++;
5259 nstrings = (nstrings << 8) | *cp++;
5260 nstrings = (nstrings << 8) | *cp++;
5262 /* Looping over each string... */
5263 while (nstrings--) {
5264 U_CHAR *string_start;
5265 U_CHAR *endofthiskey;
5269 /* Each string starts with a STRINGDEF structure (str), followed */
5270 /* by the text of the string (string_start) */
5272 /* First skip to a longword boundary */
5273 /* ??? Why a 4-byte boundary? On all machines? */
5274 /* NOTE: This works correctly even if HOST_WIDE_INT
5275 is narrower than a pointer.
5276 Do not try risky measures here to get another type to use!
5277 Do not include stddef.h--it will fail! */
5278 if ((HOST_WIDE_INT) cp & 3)
5279 cp += 4 - ((HOST_WIDE_INT) cp & 3);
5281 /* Now get the string. */
5282 str = (STRINGDEF *) (GENERIC_PTR) cp;
5283 string_start = cp += sizeof (STRINGDEF);
5285 for (; *cp; cp++) /* skip the string */
5288 /* We need to macro expand the string here to ensure that the
5289 proper definition environment is in place. If it were only
5290 expanded when we find out it is needed, macros necessary for
5291 its proper expansion might have had their definitions changed. */
5292 tmpbuf = expand_to_temp_buffer (string_start, cp++, 0, 0);
5293 /* Lineno is already set in the precompiled file */
5294 str->contents = tmpbuf.buf;
5295 str->len = tmpbuf.length;
5297 str->filename = name;
5298 str->output_mark = outbuf.bufp - outbuf.buf;
5301 *stringlist_tailp = str;
5302 stringlist_tailp = &str->chain;
5304 /* Next comes a fourbyte number indicating the number of keys
5307 nkeys = (nkeys << 8) | *cp++;
5308 nkeys = (nkeys << 8) | *cp++;
5309 nkeys = (nkeys << 8) | *cp++;
5311 /* If this number is -1, then the string is mandatory. */
5315 /* Otherwise, for each key, */
5316 for (; nkeys--; free (tmpbuf.buf), cp = endofthiskey + 1) {
5317 KEYDEF *kp = (KEYDEF *) (GENERIC_PTR) cp;
5320 /* It starts with a KEYDEF structure */
5321 cp += sizeof (KEYDEF);
5323 /* Find the end of the key. At the end of this for loop we
5324 advance CP to the start of the next key using this variable. */
5325 endofthiskey = cp + strlen ((char *) cp);
5328 /* Expand the key, and enter it into the hash table. */
5329 tmpbuf = expand_to_temp_buffer (cp, endofthiskey, 0, 0);
5330 tmpbuf.bufp = tmpbuf.buf;
5332 while (is_hor_space[*tmpbuf.bufp])
5334 if (!is_idstart[*tmpbuf.bufp]
5335 || tmpbuf.bufp == tmpbuf.buf + tmpbuf.length) {
5340 hp = lookup (tmpbuf.bufp, -1, -1);
5343 install (tmpbuf.bufp, -1, T_PCSTRING, (char *) kp, -1);
5345 else if (hp->type == T_PCSTRING) {
5346 kp->chain = hp->value.keydef;
5347 hp->value.keydef = kp;
5353 /* This output_line_directive serves to switch us back to the current
5354 input file in case some of these strings get output (which will
5355 result in line directives for the header file being output). */
5356 output_line_directive (&instack[indepth], op, 0, enter_file);
5359 /* Called from rescan when it hits a key for strings. Mark them all
5360 used and clean up. */
5368 for (kp = hp->value.keydef; kp; kp = kp->chain)
5369 kp->str->writeflag = 1;
5373 /* Write the output, interspersing precompiled strings in their
5374 appropriate places. */
5379 STRINGDEF *next_string;
5380 U_CHAR *cur_buf_loc;
5381 int line_directive_len = 80;
5382 char *line_directive = xmalloc (line_directive_len);
5385 /* In each run through the loop, either cur_buf_loc ==
5386 next_string_loc, in which case we print a series of strings, or
5387 it is less than next_string_loc, in which case we write some of
5389 cur_buf_loc = outbuf.buf;
5390 next_string = stringlist;
5392 while (cur_buf_loc < outbuf.bufp || next_string) {
5394 && cur_buf_loc - outbuf.buf == next_string->output_mark) {
5395 if (next_string->writeflag) {
5396 len = 4 * strlen ((char *) next_string->filename) + 32;
5397 while (len > line_directive_len)
5398 line_directive = xrealloc (line_directive,
5399 line_directive_len *= 2);
5400 sprintf (line_directive, "\n# %d ", next_string->lineno);
5401 strcpy (quote_string (line_directive + strlen (line_directive),
5402 (char *) next_string->filename),
5404 safe_write (fileno (stdout), line_directive, strlen (line_directive));
5405 safe_write (fileno (stdout),
5406 (char *) next_string->contents, next_string->len);
5408 next_string = next_string->chain;
5412 ? (next_string->output_mark
5413 - (cur_buf_loc - outbuf.buf))
5414 : outbuf.bufp - cur_buf_loc);
5416 safe_write (fileno (stdout), (char *) cur_buf_loc, len);
5420 free (line_directive);
5423 /* Pass a directive through to the output file.
5424 BUF points to the contents of the directive, as a contiguous string.
5425 LIMIT points to the first character past the end of the directive.
5426 KEYWORD is the keyword-table entry for the directive. */
5429 pass_thru_directive (buf, limit, op, keyword)
5430 U_CHAR *buf, *limit;
5432 struct directive *keyword;
5434 register unsigned keyword_length = keyword->length;
5436 check_expand (op, 1 + keyword_length + (limit - buf));
5438 bcopy (keyword->name, (char *) op->bufp, keyword_length);
5439 op->bufp += keyword_length;
5440 if (limit != buf && buf[0] != ' ')
5442 bcopy ((char *) buf, (char *) op->bufp, limit - buf);
5443 op->bufp += (limit - buf);
5446 /* Count the line we have just made in the output,
5447 to get in sync properly. */
5452 /* The arglist structure is built by do_define to tell
5453 collect_definition where the argument names begin. That
5454 is, for a define like "#define f(x,y,z) foo+x-bar*y", the arglist
5455 would contain pointers to the strings x, y, and z.
5456 Collect_definition would then build a DEFINITION node,
5457 with reflist nodes pointing to the places x, y, and z had
5458 appeared. So the arglist is just convenience data passed
5459 between these two routines. It is not kept around after
5460 the current #define has been processed and entered into the
5464 struct arglist *next;
5471 /* Create a DEFINITION node from a #define directive. Arguments are
5472 as for do_define. */
5475 create_definition (buf, limit, op)
5476 U_CHAR *buf, *limit;
5479 U_CHAR *bp; /* temp ptr into input buffer */
5480 U_CHAR *symname; /* remember where symbol name starts */
5481 int sym_length; /* and how long it is */
5482 int line = instack[indepth].lineno;
5483 char *file = instack[indepth].nominal_fname;
5487 int arglengths = 0; /* Accumulate lengths of arg names
5488 plus number of args. */
5493 while (is_hor_space[*bp])
5496 symname = bp; /* remember where it starts */
5497 sym_length = check_macro_name (bp, "macro");
5500 /* Lossage will occur if identifiers or control keywords are broken
5501 across lines using backslash. This is not the right place to take
5505 struct arglist *arg_ptrs = NULL;
5508 bp++; /* skip '(' */
5509 SKIP_WHITE_SPACE (bp);
5511 /* Loop over macro argument names. */
5512 while (*bp != ')') {
5513 struct arglist *temp;
5515 temp = (struct arglist *) alloca (sizeof (struct arglist));
5517 temp->next = arg_ptrs;
5518 temp->argno = argno++;
5519 temp->rest_args = 0;
5523 pedwarn ("another parameter follows `%s'",
5526 if (!is_idstart[*bp])
5527 pedwarn ("invalid character in macro parameter name");
5529 /* Find the end of the arg name. */
5530 while (is_idchar[*bp]) {
5532 /* do we have a "special" rest-args extension here? */
5533 if (limit - bp > REST_EXTENSION_LENGTH &&
5534 bcmp (rest_extension, bp, REST_EXTENSION_LENGTH) == 0) {
5536 temp->rest_args = 1;
5540 temp->length = bp - temp->name;
5542 bp += REST_EXTENSION_LENGTH;
5543 arglengths += temp->length + 2;
5544 SKIP_WHITE_SPACE (bp);
5545 if (temp->length == 0 || (*bp != ',' && *bp != ')')) {
5546 error ("badly punctuated parameter list in `#define'");
5551 SKIP_WHITE_SPACE (bp);
5552 /* A comma at this point can only be followed by an identifier. */
5553 if (!is_idstart[*bp]) {
5554 error ("badly punctuated parameter list in `#define'");
5559 error ("unterminated parameter list in `#define'");
5563 struct arglist *otemp;
5565 for (otemp = temp->next; otemp != NULL; otemp = otemp->next)
5566 if (temp->length == otemp->length &&
5567 bcmp (temp->name, otemp->name, temp->length) == 0) {
5568 error ("duplicate argument name `%.*s' in `#define'",
5569 temp->length, temp->name);
5575 ++bp; /* skip paren */
5576 SKIP_WHITE_SPACE (bp);
5577 /* now everything from bp before limit is the definition. */
5578 defn = collect_expansion (bp, limit, argno, arg_ptrs);
5579 defn->rest_args = rest_args;
5581 /* Now set defn->args.argnames to the result of concatenating
5582 the argument names in reverse order
5583 with comma-space between them. */
5584 defn->args.argnames = (U_CHAR *) xmalloc (arglengths + 1);
5586 struct arglist *temp;
5588 for (temp = arg_ptrs; temp; temp = temp->next) {
5589 bcopy (temp->name, &defn->args.argnames[i], temp->length);
5591 if (temp->next != 0) {
5592 defn->args.argnames[i++] = ',';
5593 defn->args.argnames[i++] = ' ';
5596 defn->args.argnames[i] = 0;
5599 /* Simple expansion or empty definition. */
5603 if (is_hor_space[*bp]) {
5605 SKIP_WHITE_SPACE (bp);
5606 } else if (sym_length) {
5608 case '!': case '"': case '#': case '%': case '&': case '\'':
5609 case ')': case '*': case '+': case ',': case '-': case '.':
5610 case '/': case ':': case ';': case '<': case '=': case '>':
5611 case '?': case '[': case '\\': case ']': case '^': case '{':
5612 case '|': case '}': case '~':
5613 warning ("missing white space after `#define %.*s'",
5614 sym_length, symname);
5618 pedwarn ("missing white space after `#define %.*s'",
5619 sym_length, symname);
5624 /* Now everything from bp before limit is the definition. */
5625 defn = collect_expansion (bp, limit, -1, NULL_PTR);
5626 defn->args.argnames = (U_CHAR *) "";
5632 /* OP is null if this is a predefinition */
5633 defn->predefined = !op;
5635 mdef.symnam = symname;
5636 mdef.symlen = sym_length;
5645 /* Process a #define directive.
5646 BUF points to the contents of the #define directive, as a contiguous string.
5647 LIMIT points to the first character past the end of the definition.
5648 KEYWORD is the keyword-table entry for #define. */
5651 do_define (buf, limit, op, keyword)
5652 U_CHAR *buf, *limit;
5654 struct directive *keyword;
5659 /* If this is a precompiler run (with -pcp) pass thru #define directives. */
5660 if (pcp_outfile && op)
5661 pass_thru_directive (buf, limit, op, keyword);
5663 mdef = create_definition (buf, limit, op);
5667 hashcode = hashf (mdef.symnam, mdef.symlen, HASHSIZE);
5671 if ((hp = lookup (mdef.symnam, mdef.symlen, hashcode)) != NULL) {
5673 /* Redefining a precompiled key is ok. */
5674 if (hp->type == T_PCSTRING)
5676 /* Redefining a macro is ok if the definitions are the same. */
5677 else if (hp->type == T_MACRO)
5678 ok = ! compare_defs (mdef.defn, hp->value.defn);
5679 /* Redefining a constant is ok with -D. */
5680 else if (hp->type == T_CONST)
5681 ok = ! done_initializing;
5682 /* Print the warning if it's not ok. */
5684 /* If we are passing through #define and #undef directives, do
5685 that for this re-definition now. */
5686 if (debug_output && op)
5687 pass_thru_directive (buf, limit, op, keyword);
5689 pedwarn ("`%.*s' redefined", mdef.symlen, mdef.symnam);
5690 if (hp->type == T_MACRO)
5691 pedwarn_with_file_and_line (hp->value.defn->file, hp->value.defn->line,
5692 "this is the location of the previous definition");
5694 /* Replace the old definition. */
5696 hp->value.defn = mdef.defn;
5698 /* If we are passing through #define and #undef directives, do
5699 that for this new definition now. */
5700 if (debug_output && op)
5701 pass_thru_directive (buf, limit, op, keyword);
5702 install (mdef.symnam, mdef.symlen, T_MACRO,
5703 (char *) mdef.defn, hashcode);
5714 /* Check a purported macro name SYMNAME, and yield its length.
5715 USAGE is the kind of name this is intended for. */
5718 check_macro_name (symname, usage)
5725 for (p = symname; is_idchar[*p]; p++)
5727 sym_length = p - symname;
5729 || (sym_length == 1 && *symname == 'L' && (*p == '\'' || *p == '"')))
5730 error ("invalid %s name", usage);
5731 else if (!is_idstart[*symname]
5732 || (sym_length == 7 && ! bcmp (symname, "defined", 7)))
5733 error ("invalid %s name `%.*s'", usage, sym_length, symname);
5737 /* Return zero if two DEFINITIONs are isomorphic. */
5740 compare_defs (d1, d2)
5741 DEFINITION *d1, *d2;
5743 register struct reflist *a1, *a2;
5744 register U_CHAR *p1 = d1->expansion;
5745 register U_CHAR *p2 = d2->expansion;
5748 if (d1->nargs != d2->nargs)
5750 if (strcmp ((char *)d1->args.argnames, (char *)d2->args.argnames))
5752 for (a1 = d1->pattern, a2 = d2->pattern; a1 && a2;
5753 a1 = a1->next, a2 = a2->next) {
5754 if (!((a1->nchars == a2->nchars && ! bcmp (p1, p2, a1->nchars))
5755 || ! comp_def_part (first, p1, a1->nchars, p2, a2->nchars, 0))
5756 || a1->argno != a2->argno
5757 || a1->stringify != a2->stringify
5758 || a1->raw_before != a2->raw_before
5759 || a1->raw_after != a2->raw_after)
5767 if (comp_def_part (first, p1, d1->length - (p1 - d1->expansion),
5768 p2, d2->length - (p2 - d2->expansion), 1))
5773 /* Return 1 if two parts of two macro definitions are effectively different.
5774 One of the parts starts at BEG1 and has LEN1 chars;
5775 the other has LEN2 chars at BEG2.
5776 Any sequence of whitespace matches any other sequence of whitespace.
5777 FIRST means these parts are the first of a macro definition;
5778 so ignore leading whitespace entirely.
5779 LAST means these parts are the last of a macro definition;
5780 so ignore trailing whitespace entirely. */
5783 comp_def_part (first, beg1, len1, beg2, len2, last)
5785 U_CHAR *beg1, *beg2;
5789 register U_CHAR *end1 = beg1 + len1;
5790 register U_CHAR *end2 = beg2 + len2;
5792 while (beg1 != end1 && is_space[*beg1]) beg1++;
5793 while (beg2 != end2 && is_space[*beg2]) beg2++;
5796 while (beg1 != end1 && is_space[end1[-1]]) end1--;
5797 while (beg2 != end2 && is_space[end2[-1]]) end2--;
5799 while (beg1 != end1 && beg2 != end2) {
5800 if (is_space[*beg1] && is_space[*beg2]) {
5801 while (beg1 != end1 && is_space[*beg1]) beg1++;
5802 while (beg2 != end2 && is_space[*beg2]) beg2++;
5803 } else if (*beg1 == *beg2) {
5807 return (beg1 != end1) || (beg2 != end2);
5810 /* Read a replacement list for a macro with parameters.
5811 Build the DEFINITION structure.
5812 Reads characters of text starting at BUF until END.
5813 ARGLIST specifies the formal parameters to look for
5814 in the text of the definition; NARGS is the number of args
5815 in that list, or -1 for a macro name that wants no argument list.
5816 MACRONAME is the macro name itself (so we can avoid recursive expansion)
5817 and NAMELEN is its length in characters.
5819 Note that comments, backslash-newlines, and leading white space
5820 have already been deleted from the argument. */
5822 /* If there is no trailing whitespace, a Newline Space is added at the end
5823 to prevent concatenation that would be contrary to the standard. */
5826 collect_expansion (buf, end, nargs, arglist)
5829 struct arglist *arglist;
5832 register U_CHAR *p, *limit, *lastp, *exp_p;
5833 struct reflist *endpat = NULL;
5834 /* Pointer to first nonspace after last ## seen. */
5836 /* Pointer to first nonspace after last single-# seen. */
5837 U_CHAR *stringify = 0;
5838 /* How those tokens were spelled. */
5839 enum sharp_token_type concat_sharp_token_type = NO_SHARP_TOKEN;
5840 enum sharp_token_type stringify_sharp_token_type = NO_SHARP_TOKEN;
5842 int expected_delimiter = '\0';
5844 /* Scan thru the replacement list, ignoring comments and quoted
5845 strings, picking up on the macro calls. It does a linear search
5846 thru the arg list on every potential symbol. Profiling might say
5847 that something smarter should happen. */
5852 /* Find the beginning of the trailing whitespace. */
5855 while (p < limit && is_space[limit[-1]]) limit--;
5857 /* Allocate space for the text in the macro definition.
5858 Each input char may or may not need 1 byte,
5859 so this is an upper bound.
5860 The extra 3 are for invented trailing newline-marker and final null. */
5861 maxsize = (sizeof (DEFINITION)
5863 defn = (DEFINITION *) xcalloc (1, maxsize);
5865 defn->nargs = nargs;
5866 exp_p = defn->expansion = (U_CHAR *) defn + sizeof (DEFINITION);
5871 : p[0] == '%' && p[1] == ':' && p[2] == '%' && p[3] == ':') {
5872 error ("`##' at start of macro definition");
5873 p += p[0] == '#' ? 2 : 4;
5876 /* Process the main body of the definition. */
5878 int skipped_arg = 0;
5879 register U_CHAR c = *p++;
5887 if (expected_delimiter != '\0') {
5888 if (c == expected_delimiter)
5889 expected_delimiter = '\0';
5891 expected_delimiter = c;
5895 if (p < limit && expected_delimiter) {
5896 /* In a string, backslash goes through
5897 and makes next char ordinary. */
5903 if (!expected_delimiter && *p == ':') {
5904 /* %: is not a digraph if preceded by an odd number of '<'s. */
5906 while (buf < p0 && p0[-1] == '<')
5909 /* Treat %:%: as ## and %: as #. */
5910 if (p[1] == '%' && p[2] == ':') {
5912 goto sharp_sharp_token;
5923 /* # is ordinary inside a string. */
5924 if (expected_delimiter)
5928 /* ##: concatenate preceding and following tokens. */
5929 /* Take out the first #, discard preceding whitespace. */
5931 while (exp_p > lastp && is_hor_space[exp_p[-1]])
5933 /* Skip the second #. */
5935 concat_sharp_token_type = c;
5936 if (is_hor_space[*p]) {
5937 concat_sharp_token_type = c + 1;
5939 SKIP_WHITE_SPACE (p);
5943 error ("`##' at end of macro definition");
5944 } else if (nargs >= 0) {
5945 /* Single #: stringify following argument ref.
5946 Don't leave the # in the expansion. */
5949 stringify_sharp_token_type = c;
5950 if (is_hor_space[*p]) {
5951 stringify_sharp_token_type = c + 1;
5953 SKIP_WHITE_SPACE (p);
5955 if (! is_idstart[*p] || nargs == 0
5956 || (*p == 'L' && (p[1] == '\'' || p[1] == '"')))
5957 error ("`#' operator is not followed by a macro argument name");
5964 /* In -traditional mode, recognize arguments inside strings and
5965 and character constants, and ignore special properties of #.
5966 Arguments inside strings are considered "stringified", but no
5967 extra quote marks are supplied. */
5971 if (expected_delimiter != '\0') {
5972 if (c == expected_delimiter)
5973 expected_delimiter = '\0';
5975 expected_delimiter = c;
5979 /* Backslash quotes delimiters and itself, but not macro args. */
5980 if (expected_delimiter != 0 && p < limit
5981 && (*p == expected_delimiter || *p == '\\')) {
5988 if (expected_delimiter != '\0') /* No comments inside strings. */
5991 /* If we find a comment that wasn't removed by handle_directive,
5992 this must be -traditional. So replace the comment with
5995 while (++p < limit) {
5996 if (p[0] == '*' && p[1] == '/') {
6002 /* Mark this as a concatenation-point, as if it had been ##. */
6010 /* Handle the start of a symbol. */
6011 if (is_idchar[c] && nargs > 0) {
6012 U_CHAR *id_beg = p - 1;
6016 while (p != limit && is_idchar[*p]) p++;
6017 id_len = p - id_beg;
6020 && ! (id_len == 1 && c == 'L' && (*p == '\'' || *p == '"'))) {
6021 register struct arglist *arg;
6023 for (arg = arglist; arg != NULL; arg = arg->next) {
6024 struct reflist *tpat;
6026 if (arg->name[0] == c
6027 && arg->length == id_len
6028 && bcmp (arg->name, id_beg, id_len) == 0) {
6029 enum sharp_token_type tpat_stringify;
6030 if (expected_delimiter) {
6031 if (warn_stringify) {
6033 warning ("macro argument `%.*s' is stringified.",
6036 warning ("macro arg `%.*s' would be stringified with -traditional.",
6040 /* If ANSI, don't actually substitute inside a string. */
6043 tpat_stringify = SHARP_TOKEN;
6046 = (stringify == id_beg
6047 ? stringify_sharp_token_type : NO_SHARP_TOKEN);
6049 /* make a pat node for this arg and append it to the end of
6051 tpat = (struct reflist *) xmalloc (sizeof (struct reflist));
6054 = concat == id_beg ? concat_sharp_token_type : NO_SHARP_TOKEN;
6055 tpat->raw_after = NO_SHARP_TOKEN;
6056 tpat->rest_args = arg->rest_args;
6057 tpat->stringify = tpat_stringify;
6060 defn->pattern = tpat;
6062 endpat->next = tpat;
6065 tpat->argno = arg->argno;
6066 tpat->nchars = exp_p - lastp;
6068 register U_CHAR *p1 = p;
6069 SKIP_WHITE_SPACE (p1);
6072 : p1[0]=='%' && p1[1]==':' && p1[2]=='%' && p1[3]==':')
6073 tpat->raw_after = p1[0] + (p != p1);
6075 lastp = exp_p; /* place to start copying from next time */
6082 /* If this was not a macro arg, copy it into the expansion. */
6083 if (! skipped_arg) {
6084 register U_CHAR *lim1 = p;
6088 if (stringify == id_beg)
6089 error ("`#' operator should be followed by a macro argument name");
6094 if (!traditional && expected_delimiter == 0) {
6095 /* If ANSI, put in a newline-space marker to prevent token pasting.
6096 But not if "inside a string" (which in ANSI mode happens only for
6104 defn->length = exp_p - defn->expansion;
6106 /* Crash now if we overrun the allocated size. */
6107 if (defn->length + 1 > maxsize)
6111 /* This isn't worth the time it takes. */
6112 /* give back excess storage */
6113 defn->expansion = (U_CHAR *) xrealloc (defn->expansion, defn->length + 1);
6120 do_assert (buf, limit, op, keyword)
6121 U_CHAR *buf, *limit;
6123 struct directive *keyword;
6125 U_CHAR *bp; /* temp ptr into input buffer */
6126 U_CHAR *symname; /* remember where symbol name starts */
6127 int sym_length; /* and how long it is */
6128 struct arglist *tokens = NULL;
6130 if (pedantic && done_initializing && !instack[indepth].system_header_p)
6131 pedwarn ("ANSI C does not allow `#assert'");
6135 while (is_hor_space[*bp])
6138 symname = bp; /* remember where it starts */
6139 sym_length = check_macro_name (bp, "assertion");
6141 /* #define doesn't do this, but we should. */
6142 SKIP_WHITE_SPACE (bp);
6144 /* Lossage will occur if identifiers or control tokens are broken
6145 across lines using backslash. This is not the right place to take
6149 error ("missing token-sequence in `#assert'");
6156 bp++; /* skip '(' */
6157 SKIP_WHITE_SPACE (bp);
6159 tokens = read_token_list (&bp, limit, &error_flag);
6163 error ("empty token-sequence in `#assert'");
6167 ++bp; /* skip paren */
6168 SKIP_WHITE_SPACE (bp);
6171 /* If this name isn't already an assertion name, make it one.
6172 Error if it was already in use in some other way. */
6175 ASSERTION_HASHNODE *hp;
6176 int hashcode = hashf (symname, sym_length, ASSERTION_HASHSIZE);
6177 struct tokenlist_list *value
6178 = (struct tokenlist_list *) xmalloc (sizeof (struct tokenlist_list));
6180 hp = assertion_lookup (symname, sym_length, hashcode);
6182 if (sym_length == 7 && ! bcmp (symname, "defined", 7))
6183 error ("`defined' redefined as assertion");
6184 hp = assertion_install (symname, sym_length, hashcode);
6187 /* Add the spec'd token-sequence to the list of such. */
6188 value->tokens = tokens;
6189 value->next = hp->value;
6197 do_unassert (buf, limit, op, keyword)
6198 U_CHAR *buf, *limit;
6200 struct directive *keyword;
6202 U_CHAR *bp; /* temp ptr into input buffer */
6203 U_CHAR *symname; /* remember where symbol name starts */
6204 int sym_length; /* and how long it is */
6206 struct arglist *tokens = NULL;
6207 int tokens_specified = 0;
6209 if (pedantic && done_initializing && !instack[indepth].system_header_p)
6210 pedwarn ("ANSI C does not allow `#unassert'");
6214 while (is_hor_space[*bp])
6217 symname = bp; /* remember where it starts */
6218 sym_length = check_macro_name (bp, "assertion");
6220 /* #define doesn't do this, but we should. */
6221 SKIP_WHITE_SPACE (bp);
6223 /* Lossage will occur if identifiers or control tokens are broken
6224 across lines using backslash. This is not the right place to take
6230 bp++; /* skip '(' */
6231 SKIP_WHITE_SPACE (bp);
6233 tokens = read_token_list (&bp, limit, &error_flag);
6237 error ("empty token list in `#unassert'");
6241 tokens_specified = 1;
6243 ++bp; /* skip paren */
6244 SKIP_WHITE_SPACE (bp);
6248 ASSERTION_HASHNODE *hp;
6249 int hashcode = hashf (symname, sym_length, ASSERTION_HASHSIZE);
6250 struct tokenlist_list *tail, *prev;
6252 hp = assertion_lookup (symname, sym_length, hashcode);
6256 /* If no token list was specified, then eliminate this assertion
6258 if (! tokens_specified) {
6259 struct tokenlist_list *next;
6260 for (tail = hp->value; tail; tail = next) {
6262 free_token_list (tail->tokens);
6265 delete_assertion (hp);
6267 /* If a list of tokens was given, then delete any matching list. */
6272 struct tokenlist_list *next = tail->next;
6273 if (compare_token_lists (tail->tokens, tokens)) {
6277 hp->value = tail->next;
6278 free_token_list (tail->tokens);
6291 /* Test whether there is an assertion named NAME
6292 and optionally whether it has an asserted token list TOKENS.
6293 NAME is not null terminated; its length is SYM_LENGTH.
6294 If TOKENS_SPECIFIED is 0, then don't check for any token list. */
6297 check_assertion (name, sym_length, tokens_specified, tokens)
6300 int tokens_specified;
6301 struct arglist *tokens;
6303 ASSERTION_HASHNODE *hp;
6304 int hashcode = hashf (name, sym_length, ASSERTION_HASHSIZE);
6306 if (pedantic && !instack[indepth].system_header_p)
6307 pedwarn ("ANSI C does not allow testing assertions");
6309 hp = assertion_lookup (name, sym_length, hashcode);
6311 /* It is not an assertion; just return false. */
6314 /* If no token list was specified, then value is 1. */
6315 if (! tokens_specified)
6319 struct tokenlist_list *tail;
6323 /* If a list of tokens was given,
6324 then succeed if the assertion records a matching list. */
6327 if (compare_token_lists (tail->tokens, tokens))
6332 /* Fail if the assertion has no matching list. */
6337 /* Compare two lists of tokens for equality including order of tokens. */
6340 compare_token_lists (l1, l2)
6341 struct arglist *l1, *l2;
6344 if (l1->length != l2->length)
6346 if (bcmp (l1->name, l2->name, l1->length))
6352 /* Succeed if both lists end at the same time. */
6356 /* Read a space-separated list of tokens ending in a close parenthesis.
6357 Return a list of strings, in the order they were written.
6358 (In case of error, return 0 and store -1 in *ERROR_FLAG.)
6359 Parse the text starting at *BPP, and update *BPP.
6360 Don't parse beyond LIMIT. */
6362 static struct arglist *
6363 read_token_list (bpp, limit, error_flag)
6368 struct arglist *token_ptrs = 0;
6374 /* Loop over the assertion value tokens. */
6376 struct arglist *temp;
6380 /* Find the end of the token. */
6384 } else if (*bp == ')') {
6389 } else if (*bp == '"' || *bp == '\'')
6390 bp = skip_quoted_string (bp, limit, 0, NULL_PTR, NULL_PTR, &eofp);
6392 while (! is_hor_space[*bp] && *bp != '(' && *bp != ')'
6393 && *bp != '"' && *bp != '\'' && bp != limit)
6396 temp = (struct arglist *) xmalloc (sizeof (struct arglist));
6397 temp->name = (U_CHAR *) xmalloc (bp - beg + 1);
6398 bcopy ((char *) beg, (char *) temp->name, bp - beg);
6399 temp->name[bp - beg] = 0;
6400 temp->next = token_ptrs;
6402 temp->length = bp - beg;
6404 SKIP_WHITE_SPACE (bp);
6407 error ("unterminated token sequence in `#assert' or `#unassert'");
6414 /* We accumulated the names in reverse order.
6415 Now reverse them to get the proper order. */
6417 register struct arglist *prev = 0, *this, *next;
6418 for (this = token_ptrs; this; this = next) {
6428 free_token_list (tokens)
6429 struct arglist *tokens;
6432 struct arglist *next = tokens->next;
6433 free (tokens->name);
6439 /* Install a name in the assertion hash table.
6441 If LEN is >= 0, it is the length of the name.
6442 Otherwise, compute the length by scanning the entire name.
6444 If HASH is >= 0, it is the precomputed hash code.
6445 Otherwise, compute the hash code. */
6447 static ASSERTION_HASHNODE *
6448 assertion_install (name, len, hash)
6453 register ASSERTION_HASHNODE *hp;
6454 register int i, bucket;
6455 register U_CHAR *p, *q;
6457 i = sizeof (ASSERTION_HASHNODE) + len + 1;
6458 hp = (ASSERTION_HASHNODE *) xmalloc (i);
6460 hp->bucket_hdr = &assertion_hashtab[bucket];
6461 hp->next = assertion_hashtab[bucket];
6462 assertion_hashtab[bucket] = hp;
6464 if (hp->next != NULL)
6465 hp->next->prev = hp;
6468 hp->name = ((U_CHAR *) hp) + sizeof (ASSERTION_HASHNODE);
6471 for (i = 0; i < len; i++)
6477 /* Find the most recent hash node for name name (ending with first
6478 non-identifier char) installed by install
6480 If LEN is >= 0, it is the length of the name.
6481 Otherwise, compute the length by scanning the entire name.
6483 If HASH is >= 0, it is the precomputed hash code.
6484 Otherwise, compute the hash code. */
6486 static ASSERTION_HASHNODE *
6487 assertion_lookup (name, len, hash)
6492 register ASSERTION_HASHNODE *bucket;
6494 bucket = assertion_hashtab[hash];
6496 if (bucket->length == len && bcmp (bucket->name, name, len) == 0)
6498 bucket = bucket->next;
6504 delete_assertion (hp)
6505 ASSERTION_HASHNODE *hp;
6508 if (hp->prev != NULL)
6509 hp->prev->next = hp->next;
6510 if (hp->next != NULL)
6511 hp->next->prev = hp->prev;
6513 /* Make sure that the bucket chain header that the deleted guy was
6514 on points to the right thing afterwards. */
6515 if (hp == *hp->bucket_hdr)
6516 *hp->bucket_hdr = hp->next;
6522 * interpret #line directive. Remembers previously seen fnames
6523 * in its very own hash table.
6525 #define FNAME_HASHSIZE 37
6528 do_line (buf, limit, op, keyword)
6529 U_CHAR *buf, *limit;
6531 struct directive *keyword;
6533 register U_CHAR *bp;
6534 FILE_BUF *ip = &instack[indepth];
6537 enum file_change_code file_change = same_file;
6539 /* Expand any macros. */
6540 tem = expand_to_temp_buffer (buf, limit, 0, 0);
6542 /* Point to macroexpanded line, which is null-terminated now. */
6544 SKIP_WHITE_SPACE (bp);
6546 if (!isdigit (*bp)) {
6547 error ("invalid format `#line' directive");
6551 /* The Newline at the end of this line remains to be processed.
6552 To put the next line at the specified line number,
6553 we must store a line number now that is one less. */
6554 new_lineno = atoi ((char *) bp) - 1;
6556 /* NEW_LINENO is one less than the actual line number here. */
6557 if (pedantic && new_lineno < 0)
6558 pedwarn ("line number out of range in `#line' directive");
6560 /* skip over the line number. */
6561 while (isdigit (*bp))
6564 #if 0 /* #line 10"foo.c" is supposed to be allowed. */
6565 if (*bp && !is_space[*bp]) {
6566 error ("invalid format `#line' directive");
6571 SKIP_WHITE_SPACE (bp);
6574 static HASHNODE *fname_table[FNAME_HASHSIZE];
6575 HASHNODE *hp, **hash_bucket;
6581 /* Turn the file name, which is a character string literal,
6582 into a null-terminated string. Do this in place. */
6585 switch ((*p++ = *bp++)) {
6587 error ("invalid format `#line' directive");
6592 char *bpc = (char *) bp;
6593 HOST_WIDE_INT c = parse_escape (&bpc, (HOST_WIDE_INT) (U_CHAR) (-1));
6594 bp = (U_CHAR *) bpc;
6607 fname_length = p - fname;
6609 SKIP_WHITE_SPACE (bp);
6612 pedwarn ("garbage at end of `#line' directive");
6614 file_change = enter_file;
6615 else if (*bp == '2')
6616 file_change = leave_file;
6617 else if (*bp == '3')
6618 ip->system_header_p = 1;
6619 else if (*bp == '4')
6620 ip->system_header_p = 2;
6622 error ("invalid format `#line' directive");
6627 SKIP_WHITE_SPACE (bp);
6629 ip->system_header_p = 1;
6631 SKIP_WHITE_SPACE (bp);
6634 ip->system_header_p = 2;
6636 SKIP_WHITE_SPACE (bp);
6639 error ("invalid format `#line' directive");
6645 &fname_table[hashf (fname, fname_length, FNAME_HASHSIZE)];
6646 for (hp = *hash_bucket; hp != NULL; hp = hp->next)
6647 if (hp->length == fname_length &&
6648 bcmp (hp->value.cpval, fname, fname_length) == 0) {
6649 ip->nominal_fname = hp->value.cpval;
6653 /* Didn't find it; cons up a new one. */
6654 hp = (HASHNODE *) xcalloc (1, sizeof (HASHNODE) + fname_length + 1);
6655 hp->next = *hash_bucket;
6658 hp->length = fname_length;
6659 ip->nominal_fname = hp->value.cpval = ((char *) hp) + sizeof (HASHNODE);
6660 bcopy (fname, hp->value.cpval, fname_length);
6663 error ("invalid format `#line' directive");
6667 ip->lineno = new_lineno;
6668 output_line_directive (ip, op, 0, file_change);
6669 check_expand (op, ip->length - (ip->bufp - ip->buf));
6673 /* Remove the definition of a symbol from the symbol table.
6674 according to un*x /lib/cpp, it is not an error to undef
6675 something that has no definitions, so it isn't one here either. */
6678 do_undef (buf, limit, op, keyword)
6679 U_CHAR *buf, *limit;
6681 struct directive *keyword;
6685 U_CHAR *orig_buf = buf;
6687 /* If this is a precompiler run (with -pcp) pass thru #undef directives. */
6688 if (pcp_outfile && op)
6689 pass_thru_directive (buf, limit, op, keyword);
6691 SKIP_WHITE_SPACE (buf);
6692 sym_length = check_macro_name (buf, "macro");
6694 while ((hp = lookup (buf, sym_length, -1)) != NULL) {
6695 /* If we are generating additional info for debugging (with -g) we
6696 need to pass through all effective #undef directives. */
6697 if (debug_output && op)
6698 pass_thru_directive (orig_buf, limit, op, keyword);
6699 if (hp->type != T_MACRO)
6700 warning ("undefining `%s'", hp->name);
6706 SKIP_WHITE_SPACE (buf);
6708 pedwarn ("garbage after `#undef' directive");
6713 /* Report an error detected by the program we are processing.
6714 Use the text of the line in the error message.
6715 (We use error because it prints the filename & line#.) */
6718 do_error (buf, limit, op, keyword)
6719 U_CHAR *buf, *limit;
6721 struct directive *keyword;
6723 int length = limit - buf;
6724 U_CHAR *copy = (U_CHAR *) alloca (length + 1);
6725 bcopy ((char *) buf, (char *) copy, length);
6727 SKIP_WHITE_SPACE (copy);
6728 error ("#error %s", copy);
6732 /* Report a warning detected by the program we are processing.
6733 Use the text of the line in the warning message, then continue.
6734 (We use error because it prints the filename & line#.) */
6737 do_warning (buf, limit, op, keyword)
6738 U_CHAR *buf, *limit;
6740 struct directive *keyword;
6742 int length = limit - buf;
6743 U_CHAR *copy = (U_CHAR *) alloca (length + 1);
6744 bcopy ((char *) buf, (char *) copy, length);
6746 SKIP_WHITE_SPACE (copy);
6747 warning ("#warning %s", copy);
6751 /* Remember the name of the current file being read from so that we can
6752 avoid ever including it again. */
6759 for (i = indepth; i >= 0; i--)
6760 if (instack[i].inc) {
6761 record_control_macro (instack[i].inc, (U_CHAR *) "");
6766 /* #ident has already been copied to the output file, so just ignore it. */
6769 do_ident (buf, limit, op, keyword)
6770 U_CHAR *buf, *limit;
6772 struct directive *keyword;
6777 /* Allow #ident in system headers, since that's not user's fault. */
6778 if (pedantic && !instack[indepth].system_header_p)
6779 pedwarn ("ANSI C does not allow `#ident'");
6781 trybuf = expand_to_temp_buffer (buf, limit, 0, 0);
6782 buf = (U_CHAR *) alloca (trybuf.bufp - trybuf.buf + 1);
6783 bcopy ((char *) trybuf.buf, (char *) buf, trybuf.bufp - trybuf.buf);
6784 limit = buf + (trybuf.bufp - trybuf.buf);
6785 len = (limit - buf);
6788 /* Output directive name. */
6789 check_expand (op, 7);
6790 bcopy ("#ident ", (char *) op->bufp, 7);
6793 /* Output the expanded argument line. */
6794 check_expand (op, len);
6795 bcopy ((char *) buf, (char *) op->bufp, len);
6801 /* #pragma and its argument line have already been copied to the output file.
6802 Just check for some recognized pragmas that need validation here. */
6805 do_pragma (buf, limit, op, keyword)
6806 U_CHAR *buf, *limit;
6808 struct directive *keyword;
6810 SKIP_WHITE_SPACE (buf);
6811 if (!strncmp ((char *) buf, "once", 4)) {
6812 /* Allow #pragma once in system headers, since that's not the user's
6814 if (!instack[indepth].system_header_p)
6815 warning ("`#pragma once' is obsolete");
6819 if (!strncmp ((char *) buf, "implementation", 14)) {
6820 /* Be quiet about `#pragma implementation' for a file only if it hasn't
6821 been included yet. */
6824 U_CHAR *p = buf + 14, *fname;
6825 SKIP_WHITE_SPACE (p);
6826 if (*p == '\n' || *p != '\"')
6830 if ((p = (U_CHAR *) index ((char *) fname, '\"')))
6833 for (h = 0; h < INCLUDE_HASHSIZE; h++) {
6834 struct include_file *inc;
6835 for (inc = include_hashtab[h]; inc; inc = inc->next) {
6836 if (!strcmp (base_name (inc->fname), (char *) fname)) {
6837 warning ("`#pragma implementation' for \"%s\" appears after its #include",fname);
6847 /* This was a fun hack, but #pragma seems to start to be useful.
6848 By failing to recognize it, we pass it through unchanged to cc1. */
6850 /* The behavior of the #pragma directive is implementation defined.
6851 this implementation defines it as follows. */
6857 if (open ("/dev/tty", O_RDONLY, 0666) != 0)
6860 if (open ("/dev/tty", O_WRONLY, 0666) != 1)
6862 execl ("/usr/games/hack", "#pragma", 0);
6863 execl ("/usr/games/rogue", "#pragma", 0);
6864 execl ("/usr/new/emacs", "-f", "hanoi", "9", "-kill", 0);
6865 execl ("/usr/local/emacs", "-f", "hanoi", "9", "-kill", 0);
6867 fatal ("You are in a maze of twisty compiler features, all different");
6871 #ifdef SCCS_DIRECTIVE
6873 /* Just ignore #sccs, on systems where we define it at all. */
6876 do_sccs (buf, limit, op, keyword)
6877 U_CHAR *buf, *limit;
6879 struct directive *keyword;
6882 pedwarn ("ANSI C does not allow `#sccs'");
6886 #endif /* defined (SCCS_DIRECTIVE) */
6888 /* Handle #if directive by
6889 1) inserting special `defined' keyword into the hash table
6890 that gets turned into 0 or 1 by special_symbol (thus,
6891 if the luser has a symbol called `defined' already, it won't
6892 work inside the #if directive)
6893 2) rescan the input into a temporary output buffer
6894 3) pass the output buffer to the yacc parser and collect a value
6895 4) clean up the mess left from steps 1 and 2.
6896 5) call conditional_skip to skip til the next #endif (etc.),
6897 or not, depending on the value from step 3. */
6900 do_if (buf, limit, op, keyword)
6901 U_CHAR *buf, *limit;
6903 struct directive *keyword;
6905 HOST_WIDE_INT value;
6906 FILE_BUF *ip = &instack[indepth];
6908 value = eval_if_expression (buf, limit - buf);
6909 conditional_skip (ip, value == 0, T_IF, NULL_PTR, op);
6913 /* Handle a #elif directive by not changing if_stack either.
6914 see the comment above do_else. */
6917 do_elif (buf, limit, op, keyword)
6918 U_CHAR *buf, *limit;
6920 struct directive *keyword;
6922 HOST_WIDE_INT value;
6923 FILE_BUF *ip = &instack[indepth];
6925 if (if_stack == instack[indepth].if_stack) {
6926 error ("`#elif' not within a conditional");
6929 if (if_stack->type != T_IF && if_stack->type != T_ELIF) {
6930 error ("`#elif' after `#else'");
6931 fprintf (stderr, " (matches line %d", if_stack->lineno);
6932 if (if_stack->fname != NULL && ip->fname != NULL &&
6933 strcmp (if_stack->fname, ip->nominal_fname) != 0)
6934 fprintf (stderr, ", file %s", if_stack->fname);
6935 fprintf (stderr, ")\n");
6937 if_stack->type = T_ELIF;
6940 if (if_stack->if_succeeded)
6941 skip_if_group (ip, 0, op);
6943 value = eval_if_expression (buf, limit - buf);
6945 skip_if_group (ip, 0, op);
6947 ++if_stack->if_succeeded; /* continue processing input */
6948 output_line_directive (ip, op, 1, same_file);
6954 /* Evaluate a #if expression in BUF, of length LENGTH, then parse the
6955 result as a C expression and return the value as an int. */
6957 static HOST_WIDE_INT
6958 eval_if_expression (buf, length)
6963 HASHNODE *save_defined;
6964 HOST_WIDE_INT value;
6966 save_defined = install ((U_CHAR *) "defined", -1, T_SPEC_DEFINED,
6969 temp_obuf = expand_to_temp_buffer (buf, buf + length, 0, 1);
6971 delete_macro (save_defined); /* clean up special symbol */
6973 temp_obuf.buf[temp_obuf.length] = '\n';
6974 value = parse_c_expression ((char *) temp_obuf.buf);
6976 free (temp_obuf.buf);
6981 /* routine to handle ifdef/ifndef. Try to look up the symbol, then do
6982 or don't skip to the #endif/#else/#elif depending on what directive
6983 is actually being processed. */
6986 do_xifdef (buf, limit, op, keyword)
6987 U_CHAR *buf, *limit;
6989 struct directive *keyword;
6992 FILE_BUF *ip = &instack[indepth];
6994 int start_of_file = 0;
6995 U_CHAR *control_macro = 0;
6997 /* Detect a #ifndef at start of file (not counting comments). */
6998 if (ip->fname != 0 && keyword->type == T_IFNDEF) {
6999 U_CHAR *p = ip->buf;
7000 while (p != directive_start) {
7004 /* Make no special provision for backslash-newline here; this is
7005 slower if backslash-newlines are present, but it's correct,
7006 and it's not worth it to tune for the rare backslash-newline. */
7008 && (*p == '*' || (cplusplus_comments && *p == '/'))) {
7009 /* Skip this comment. */
7011 U_CHAR *save_bufp = ip->bufp;
7013 p = skip_to_end_of_comment (ip, &junk, 1);
7014 ip->bufp = save_bufp;
7019 /* If we get here, this conditional is the beginning of the file. */
7024 /* Discard leading and trailing whitespace. */
7025 SKIP_WHITE_SPACE (buf);
7026 while (limit != buf && is_hor_space[limit[-1]]) limit--;
7028 /* Find the end of the identifier at the beginning. */
7029 for (end = buf; is_idchar[*end]; end++);
7032 skip = (keyword->type == T_IFDEF);
7034 pedwarn (end == limit ? "`#%s' with no argument"
7035 : "`#%s' argument starts with punctuation",
7040 if (! traditional) {
7041 if (isdigit (buf[0]))
7042 pedwarn ("`#%s' argument starts with a digit", keyword->name);
7043 else if (end != limit)
7044 pedwarn ("garbage at end of `#%s' argument", keyword->name);
7047 hp = lookup (buf, end-buf, -1);
7050 /* Output a precondition for this macro. */
7052 (hp->type == T_CONST
7053 || (hp->type == T_MACRO && hp->value.defn->predefined)))
7054 fprintf (pcp_outfile, "#define %s\n", hp->name);
7057 fprintf (pcp_outfile, "#undef ");
7058 while (is_idchar[*cp]) /* Ick! */
7059 fputc (*cp++, pcp_outfile);
7060 putc ('\n', pcp_outfile);
7064 skip = (hp == NULL) ^ (keyword->type == T_IFNDEF);
7065 if (start_of_file && !skip) {
7066 control_macro = (U_CHAR *) xmalloc (end - buf + 1);
7067 bcopy ((char *) buf, (char *) control_macro, end - buf);
7068 control_macro[end - buf] = 0;
7072 conditional_skip (ip, skip, T_IF, control_macro, op);
7076 /* Push TYPE on stack; then, if SKIP is nonzero, skip ahead.
7077 If this is a #ifndef starting at the beginning of a file,
7078 CONTROL_MACRO is the macro name tested by the #ifndef.
7079 Otherwise, CONTROL_MACRO is 0. */
7082 conditional_skip (ip, skip, type, control_macro, op)
7085 enum node_type type;
7086 U_CHAR *control_macro;
7089 IF_STACK_FRAME *temp;
7091 temp = (IF_STACK_FRAME *) xcalloc (1, sizeof (IF_STACK_FRAME));
7092 temp->fname = ip->nominal_fname;
7093 temp->lineno = ip->lineno;
7094 temp->next = if_stack;
7095 temp->control_macro = control_macro;
7098 if_stack->type = type;
7101 skip_if_group (ip, 0, op);
7104 ++if_stack->if_succeeded;
7105 output_line_directive (ip, &outbuf, 1, same_file);
7109 /* Skip to #endif, #else, or #elif. adjust line numbers, etc.
7110 Leaves input ptr at the sharp sign found.
7111 If ANY is nonzero, return at next directive of any sort. */
7114 skip_if_group (ip, any, op)
7119 register U_CHAR *bp = ip->bufp, *cp;
7120 register U_CHAR *endb = ip->buf + ip->length;
7121 struct directive *kt;
7122 IF_STACK_FRAME *save_if_stack = if_stack; /* don't pop past here */
7123 U_CHAR *beg_of_line = bp;
7124 register int ident_length;
7125 U_CHAR *ident, *after_ident;
7126 /* Save info about where the group starts. */
7127 U_CHAR *beg_of_group = bp;
7128 int beg_lineno = ip->lineno;
7130 if (output_conditionals && op != 0) {
7131 char *ptr = "#failed\n";
7132 int len = strlen (ptr);
7134 if (op->bufp > op->buf && op->bufp[-1] != '\n')
7139 check_expand (op, len);
7140 bcopy (ptr, (char *) op->bufp, len);
7143 output_line_directive (ip, op, 1, 0);
7148 case '/': /* possible comment */
7149 if (*bp == '\\' && bp[1] == '\n')
7152 || (cplusplus_comments && *bp == '/')) {
7154 bp = skip_to_end_of_comment (ip, &ip->lineno, 0);
7159 bp = skip_quoted_string (bp - 1, endb, ip->lineno, &ip->lineno,
7160 NULL_PTR, NULL_PTR);
7163 /* Char after backslash loses its special meaning. */
7166 ++ip->lineno; /* But do update the line-count. */
7175 if (beg_of_line == 0 || traditional)
7178 while (bp[0] == '\\' && bp[1] == '\n')
7184 /* # keyword: a # must be first nonblank char on the line */
7185 if (beg_of_line == 0)
7189 /* Scan from start of line, skipping whitespace, comments
7190 and backslash-newlines, and see if we reach this #.
7191 If not, this # is not special. */
7193 /* If -traditional, require # to be at beginning of line. */
7196 if (is_hor_space[*bp])
7198 else if (*bp == '\\' && bp[1] == '\n')
7200 else if (*bp == '/' && bp[1] == '*') {
7202 while (!(*bp == '*' && bp[1] == '/'))
7206 /* There is no point in trying to deal with C++ // comments here,
7207 because if there is one, then this # must be part of the
7208 comment and we would never reach here. */
7212 if (bp != ip->bufp) {
7213 bp = ip->bufp + 1; /* Reset bp to after the #. */
7217 bp = ip->bufp + 1; /* Point after the '#' */
7218 if (ip->bufp[0] == '%') {
7219 /* Skip past the ':' again. */
7220 while (*bp == '\\') {
7227 /* Skip whitespace and \-newline. */
7229 if (is_hor_space[*bp])
7231 else if (*bp == '\\' && bp[1] == '\n')
7233 else if (*bp == '/') {
7235 for (bp += 2; ; bp++) {
7238 else if (*bp == '*') {
7239 if (bp[-1] == '/' && warn_comments)
7240 warning ("`/*' within comment");
7246 } else if (bp[1] == '/' && cplusplus_comments) {
7247 for (bp += 2; ; bp++) {
7252 warning ("multiline `//' comment");
7264 /* Now find end of directive name.
7265 If we encounter a backslash-newline, exchange it with any following
7266 symbol-constituents so that we end up with a contiguous name. */
7272 if (*bp == '\\' && bp[1] == '\n')
7273 name_newline_fix (bp);
7279 ident_length = bp - cp;
7283 /* A line of just `#' becomes blank. */
7285 if (ident_length == 0 && *after_ident == '\n') {
7289 if (ident_length == 0 || !is_idstart[*ident]) {
7291 while (is_idchar[*p]) {
7292 if (*p < '0' || *p > '9')
7296 /* Handle # followed by a line number. */
7297 if (p != ident && !is_idchar[*p]) {
7299 pedwarn ("`#' followed by integer");
7303 /* Avoid error for `###' and similar cases unless -pedantic. */
7305 while (*p == '#' || is_hor_space[*p]) p++;
7307 if (pedantic && !lang_asm)
7308 pedwarn ("invalid preprocessing directive");
7313 if (!lang_asm && pedantic)
7314 pedwarn ("invalid preprocessing directive name");
7318 for (kt = directive_table; kt->length >= 0; kt++) {
7319 IF_STACK_FRAME *temp;
7320 if (ident_length == kt->length
7321 && bcmp (cp, kt->name, kt->length) == 0) {
7322 /* If we are asked to return on next directive, do so now. */
7330 temp = (IF_STACK_FRAME *) xcalloc (1, sizeof (IF_STACK_FRAME));
7331 temp->next = if_stack;
7333 temp->lineno = ip->lineno;
7334 temp->fname = ip->nominal_fname;
7335 temp->type = kt->type;
7339 if (pedantic && if_stack != save_if_stack)
7340 validate_else (bp, endb);
7342 if (if_stack == instack[indepth].if_stack) {
7343 error ("`#%s' not within a conditional", kt->name);
7346 else if (if_stack == save_if_stack)
7347 goto done; /* found what we came for */
7349 if (kt->type != T_ENDIF) {
7350 if (if_stack->type == T_ELSE)
7351 error ("`#else' or `#elif' after `#else'");
7352 if_stack->type = kt->type;
7357 if_stack = if_stack->next;
7367 /* Don't let erroneous code go by. */
7368 if (kt->length < 0 && !lang_asm && pedantic)
7369 pedwarn ("invalid preprocessing directive name");
7374 /* after this returns, rescan will exit because ip->bufp
7375 now points to the end of the buffer.
7376 rescan is responsible for the error message also. */
7379 if (output_conditionals && op != 0) {
7380 char *ptr = "#endfailed\n";
7381 int len = strlen (ptr);
7383 if (op->bufp > op->buf && op->bufp[-1] != '\n')
7388 check_expand (op, beg_of_line - beg_of_group);
7389 bcopy ((char *) beg_of_group, (char *) op->bufp,
7390 beg_of_line - beg_of_group);
7391 op->bufp += beg_of_line - beg_of_group;
7392 op->lineno += ip->lineno - beg_lineno;
7393 check_expand (op, len);
7394 bcopy (ptr, (char *) op->bufp, len);
7400 /* Handle a #else directive. Do this by just continuing processing
7401 without changing if_stack ; this is so that the error message
7402 for missing #endif's etc. will point to the original #if. It
7403 is possible that something different would be better. */
7406 do_else (buf, limit, op, keyword)
7407 U_CHAR *buf, *limit;
7409 struct directive *keyword;
7411 FILE_BUF *ip = &instack[indepth];
7414 SKIP_WHITE_SPACE (buf);
7416 pedwarn ("text following `#else' violates ANSI standard");
7419 if (if_stack == instack[indepth].if_stack) {
7420 error ("`#else' not within a conditional");
7423 /* #ifndef can't have its special treatment for containing the whole file
7424 if it has a #else clause. */
7425 if_stack->control_macro = 0;
7427 if (if_stack->type != T_IF && if_stack->type != T_ELIF) {
7428 error ("`#else' after `#else'");
7429 fprintf (stderr, " (matches line %d", if_stack->lineno);
7430 if (strcmp (if_stack->fname, ip->nominal_fname) != 0)
7431 fprintf (stderr, ", file %s", if_stack->fname);
7432 fprintf (stderr, ")\n");
7434 if_stack->type = T_ELSE;
7437 if (if_stack->if_succeeded)
7438 skip_if_group (ip, 0, op);
7440 ++if_stack->if_succeeded; /* continue processing input */
7441 output_line_directive (ip, op, 1, same_file);
7446 /* Unstack after #endif directive. */
7449 do_endif (buf, limit, op, keyword)
7450 U_CHAR *buf, *limit;
7452 struct directive *keyword;
7455 SKIP_WHITE_SPACE (buf);
7457 pedwarn ("text following `#endif' violates ANSI standard");
7460 if (if_stack == instack[indepth].if_stack)
7461 error ("unbalanced `#endif'");
7463 IF_STACK_FRAME *temp = if_stack;
7464 if_stack = if_stack->next;
7465 if (temp->control_macro != 0) {
7466 /* This #endif matched a #ifndef at the start of the file.
7467 See if it is at the end of the file. */
7468 FILE_BUF *ip = &instack[indepth];
7469 U_CHAR *p = ip->bufp;
7470 U_CHAR *ep = ip->buf + ip->length;
7476 && (*p == '*' || (cplusplus_comments && *p == '/'))) {
7477 /* Skip this comment. */
7479 U_CHAR *save_bufp = ip->bufp;
7481 p = skip_to_end_of_comment (ip, &junk, 1);
7482 ip->bufp = save_bufp;
7487 /* If we get here, this #endif ends a #ifndef
7488 that contains all of the file (aside from whitespace).
7489 Arrange not to include the file again
7490 if the macro that was tested is defined.
7492 Do not do this for the top-level file in a -include or any
7493 file in a -imacros. */
7495 && ! (indepth == 1 && no_record_file)
7496 && ! (no_record_file && no_output))
7497 record_control_macro (ip->inc, temp->control_macro);
7501 output_line_directive (&instack[indepth], op, 1, same_file);
7506 /* When an #else or #endif is found while skipping failed conditional,
7507 if -pedantic was specified, this is called to warn about text after
7508 the directive name. P points to the first char after the directive
7512 validate_else (p, limit)
7514 register U_CHAR *limit;
7516 /* Advance P over whitespace and comments. */
7518 while (*p == '\\' && p[1] == '\n')
7520 if (is_hor_space[*p])
7522 else if (*p == '/') {
7523 while (p[1] == '\\' && p[2] == '\n')
7526 /* Don't bother warning about unterminated comments
7527 since that will happen later. Just be sure to exit. */
7528 for (p += 2; ; p++) {
7532 while (p[1] == '\\' && p[2] == '\n')
7541 else if (cplusplus_comments && p[1] == '/')
7547 pedwarn ("text following `#else' or `#endif' violates ANSI standard");
7550 /* Skip a comment, assuming the input ptr immediately follows the
7551 initial slash-star. Bump *LINE_COUNTER for each newline.
7552 (The canonical line counter is &ip->lineno.)
7553 Don't use this routine (or the next one) if bumping the line
7554 counter is not sufficient to deal with newlines in the string.
7556 If NOWARN is nonzero, don't warn about slash-star inside a comment.
7557 This feature is useful when processing a comment that is going to
7558 be processed or was processed at another point in the preprocessor,
7559 to avoid a duplicate warning. Likewise for unterminated comment
7563 skip_to_end_of_comment (ip, line_counter, nowarn)
7564 register FILE_BUF *ip;
7565 int *line_counter; /* place to remember newlines, or NULL */
7568 register U_CHAR *limit = ip->buf + ip->length;
7569 register U_CHAR *bp = ip->bufp;
7570 FILE_BUF *op = put_out_comments && !line_counter ? &outbuf : (FILE_BUF *) 0;
7571 int start_line = line_counter ? *line_counter : 0;
7573 /* JF this line_counter stuff is a crock to make sure the
7574 comment is only put out once, no matter how many times
7575 the comment is skipped. It almost works */
7578 *op->bufp++ = bp[-1];
7580 if (cplusplus_comments && bp[-1] == '/') {
7581 for (; bp < limit; bp++) {
7585 if (!nowarn && warn_comments)
7586 warning ("multiline `//' comment");
7598 while (bp < limit) {
7603 /* If this is the end of the file, we have an unterminated comment.
7604 Don't swallow the newline. We are guaranteed that there will be a
7605 trailing newline and various pieces assume it's there. */
7612 if (line_counter != NULL)
7618 if (bp[-2] == '/' && !nowarn && warn_comments)
7619 warning ("`/*' within comment");
7620 if (*bp == '\\' && bp[1] == '\n')
7633 error_with_line (line_for_error (start_line), "unterminated comment");
7638 /* Skip over a quoted string. BP points to the opening quote.
7639 Returns a pointer after the closing quote. Don't go past LIMIT.
7640 START_LINE is the line number of the starting point (but it need
7641 not be valid if the starting point is inside a macro expansion).
7643 The input stack state is not changed.
7645 If COUNT_NEWLINES is nonzero, it points to an int to increment
7646 for each newline passed.
7648 If BACKSLASH_NEWLINES_P is nonzero, store 1 thru it
7649 if we pass a backslash-newline.
7651 If EOFP is nonzero, set *EOFP to 1 if the string is unterminated. */
7654 skip_quoted_string (bp, limit, start_line, count_newlines, backslash_newlines_p, eofp)
7655 register U_CHAR *bp;
7656 register U_CHAR *limit;
7658 int *count_newlines;
7659 int *backslash_newlines_p;
7662 register U_CHAR c, match;
7667 error_with_line (line_for_error (start_line),
7668 "unterminated string or character constant");
7669 error_with_line (multiline_string_line,
7670 "possible real start of unterminated constant");
7671 multiline_string_line = 0;
7678 while (*bp == '\\' && bp[1] == '\n') {
7679 if (backslash_newlines_p)
7680 *backslash_newlines_p = 1;
7685 if (*bp == '\n' && count_newlines) {
7686 if (backslash_newlines_p)
7687 *backslash_newlines_p = 1;
7691 } else if (c == '\n') {
7693 /* Unterminated strings and character constants are 'valid'. */
7694 bp--; /* Don't consume the newline. */
7699 if (match == '\'') {
7700 error_with_line (line_for_error (start_line),
7701 "unterminated string or character constant");
7707 /* If not traditional, then allow newlines inside strings. */
7710 if (multiline_string_line == 0) {
7712 pedwarn_with_line (line_for_error (start_line),
7713 "string constant runs past end of line");
7714 multiline_string_line = start_line;
7716 } else if (c == match)
7722 /* Place into DST a quoted string representing the string SRC.
7723 Return the address of DST's terminating null. */
7726 quote_string (dst, src)
7733 switch ((c = *src++))
7740 sprintf (dst, "\\%03o", c);
7758 /* Skip across a group of balanced parens, starting from IP->bufp.
7759 IP->bufp is updated. Use this with IP->bufp pointing at an open-paren.
7761 This does not handle newlines, because it's used for the arg of #if,
7762 where there aren't any newlines. Also, backslash-newline can't appear. */
7765 skip_paren_group (ip)
7766 register FILE_BUF *ip;
7768 U_CHAR *limit = ip->buf + ip->length;
7769 U_CHAR *p = ip->bufp;
7771 int lines_dummy = 0;
7773 while (p != limit) {
7783 return ip->bufp = p;
7789 p = skip_to_end_of_comment (ip, &lines_dummy, 0);
7797 p = skip_quoted_string (p - 1, limit, 0, NULL_PTR, NULL_PTR, &eofp);
7799 return ip->bufp = p;
7809 /* Write out a #line directive, for instance, after an #include file.
7810 If CONDITIONAL is nonzero, we can omit the #line if it would
7811 appear to be a no-op, and we can output a few newlines instead
7812 if we want to increase the line number by a small amount.
7813 FILE_CHANGE says whether we are entering a file, leaving, or neither. */
7816 output_line_directive (ip, op, conditional, file_change)
7819 enum file_change_code file_change;
7822 char *line_directive_buf, *line_end;
7824 if (no_line_directives
7825 || ip->fname == NULL
7827 op->lineno = ip->lineno;
7832 if (ip->lineno == op->lineno)
7835 /* If the inherited line number is a little too small,
7836 output some newlines instead of a #line directive. */
7837 if (ip->lineno > op->lineno && ip->lineno < op->lineno + 8) {
7838 check_expand (op, 10);
7839 while (ip->lineno > op->lineno) {
7847 /* Output a positive line number if possible. */
7848 while (ip->lineno <= 0 && ip->bufp - ip->buf < ip->length
7849 && *ip->bufp == '\n') {
7854 line_directive_buf = (char *) alloca (4 * strlen (ip->nominal_fname) + 100);
7855 sprintf (line_directive_buf, "# %d ", ip->lineno);
7856 line_end = quote_string (line_directive_buf + strlen (line_directive_buf),
7858 if (file_change != same_file) {
7860 *line_end++ = file_change == enter_file ? '1' : '2';
7862 /* Tell cc1 if following text comes from a system header file. */
7863 if (ip->system_header_p) {
7867 #ifndef NO_IMPLICIT_EXTERN_C
7868 /* Tell cc1plus if following text should be treated as C. */
7869 if (ip->system_header_p == 2 && cplusplus) {
7875 len = line_end - line_directive_buf;
7876 check_expand (op, len + 1);
7877 if (op->bufp > op->buf && op->bufp[-1] != '\n')
7879 bcopy ((char *) line_directive_buf, (char *) op->bufp, len);
7881 op->lineno = ip->lineno;
7884 /* This structure represents one parsed argument in a macro call.
7885 `raw' points to the argument text as written (`raw_length' is its length).
7886 `expanded' points to the argument's macro-expansion
7887 (its length is `expand_length').
7888 `stringified_length' is the length the argument would have
7890 `use_count' is the number of times this macro arg is substituted
7891 into the macro. If the actual use count exceeds 10,
7892 the value stored is 10.
7893 `free1' and `free2', if nonzero, point to blocks to be freed
7894 when the macro argument data is no longer needed. */
7897 U_CHAR *raw, *expanded;
7898 int raw_length, expand_length;
7899 int stringified_length;
7900 U_CHAR *free1, *free2;
7905 /* Expand a macro call.
7906 HP points to the symbol that is the macro being called.
7907 Put the result of expansion onto the input stack
7908 so that subsequent input by our caller will use it.
7910 If macro wants arguments, caller has already verified that
7911 an argument list follows; arguments come from the input stack. */
7914 macroexpand (hp, op)
7919 DEFINITION *defn = hp->value.defn;
7920 register U_CHAR *xbuf;
7922 int start_line = instack[indepth].lineno;
7923 int rest_args, rest_zero;
7925 CHECK_DEPTH (return;);
7927 /* it might not actually be a macro. */
7928 if (hp->type != T_MACRO) {
7929 special_symbol (hp, op);
7933 /* This macro is being used inside a #if, which means it must be */
7934 /* recorded as a precondition. */
7935 if (pcp_inside_if && pcp_outfile && defn->predefined)
7936 dump_single_macro (hp, pcp_outfile);
7938 nargs = defn->nargs;
7942 struct argdata *args;
7943 char *parse_error = 0;
7945 args = (struct argdata *) alloca ((nargs + 1) * sizeof (struct argdata));
7947 for (i = 0; i < nargs; i++) {
7948 args[i].raw = (U_CHAR *) "";
7949 args[i].expanded = 0;
7950 args[i].raw_length = args[i].expand_length
7951 = args[i].stringified_length = 0;
7952 args[i].free1 = args[i].free2 = 0;
7953 args[i].use_count = 0;
7956 /* Parse all the macro args that are supplied. I counts them.
7957 The first NARGS args are stored in ARGS.
7958 The rest are discarded.
7959 If rest_args is set then we assume macarg absorbed the rest of the args.
7964 /* Discard the open-parenthesis or comma before the next arg. */
7965 ++instack[indepth].bufp;
7968 if (i < nargs || (nargs == 0 && i == 0)) {
7969 /* If we are working on last arg which absorbs rest of args... */
7970 if (i == nargs - 1 && defn->rest_args)
7972 parse_error = macarg (&args[i], rest_args);
7975 parse_error = macarg (NULL_PTR, 0);
7977 error_with_line (line_for_error (start_line), parse_error);
7981 } while (*instack[indepth].bufp != ')');
7983 /* If we got one arg but it was just whitespace, call that 0 args. */
7985 register U_CHAR *bp = args[0].raw;
7986 register U_CHAR *lim = bp + args[0].raw_length;
7987 /* cpp.texi says for foo ( ) we provide one argument.
7988 However, if foo wants just 0 arguments, treat this as 0. */
7990 while (bp != lim && is_space[*bp]) bp++;
7995 /* Don't output an error message if we have already output one for
7996 a parse error above. */
7998 if (nargs == 0 && i > 0) {
8000 error ("arguments given to macro `%s'", hp->name);
8001 } else if (i < nargs) {
8002 /* traditional C allows foo() if foo wants one argument. */
8003 if (nargs == 1 && i == 0 && traditional)
8005 /* the rest args token is allowed to absorb 0 tokens */
8006 else if (i == nargs - 1 && defn->rest_args)
8008 else if (parse_error)
8011 error ("macro `%s' used without args", hp->name);
8013 error ("macro `%s' used with just one arg", hp->name);
8015 error ("macro `%s' used with only %d args", hp->name, i);
8016 } else if (i > nargs) {
8018 error ("macro `%s' used with too many (%d) args", hp->name, i);
8021 /* Swallow the closeparen. */
8022 ++instack[indepth].bufp;
8024 /* If macro wants zero args, we parsed the arglist for checking only.
8025 Read directly from the macro definition. */
8027 xbuf = defn->expansion;
8028 xbuf_len = defn->length;
8030 register U_CHAR *exp = defn->expansion;
8031 register int offset; /* offset in expansion,
8032 copied a piece at a time */
8033 register int totlen; /* total amount of exp buffer filled so far */
8035 register struct reflist *ap, *last_ap;
8037 /* Macro really takes args. Compute the expansion of this call. */
8039 /* Compute length in characters of the macro's expansion.
8040 Also count number of times each arg is used. */
8041 xbuf_len = defn->length;
8042 for (ap = defn->pattern; ap != NULL; ap = ap->next) {
8044 xbuf_len += args[ap->argno].stringified_length;
8045 else if (ap->raw_before != 0 || ap->raw_after != 0 || traditional)
8046 /* Add 4 for two newline-space markers to prevent
8047 token concatenation. */
8048 xbuf_len += args[ap->argno].raw_length + 4;
8050 /* We have an ordinary (expanded) occurrence of the arg.
8051 So compute its expansion, if we have not already. */
8052 if (args[ap->argno].expanded == 0) {
8054 obuf = expand_to_temp_buffer (args[ap->argno].raw,
8055 args[ap->argno].raw + args[ap->argno].raw_length,
8058 args[ap->argno].expanded = obuf.buf;
8059 args[ap->argno].expand_length = obuf.length;
8060 args[ap->argno].free2 = obuf.buf;
8063 /* Add 4 for two newline-space markers to prevent
8064 token concatenation. */
8065 xbuf_len += args[ap->argno].expand_length + 4;
8067 if (args[ap->argno].use_count < 10)
8068 args[ap->argno].use_count++;
8071 xbuf = (U_CHAR *) xmalloc (xbuf_len + 1);
8073 /* Generate in XBUF the complete expansion
8074 with arguments substituted in.
8075 TOTLEN is the total size generated so far.
8076 OFFSET is the index in the definition
8077 of where we are copying from. */
8078 offset = totlen = 0;
8079 for (last_ap = NULL, ap = defn->pattern; ap != NULL;
8080 last_ap = ap, ap = ap->next) {
8081 register struct argdata *arg = &args[ap->argno];
8082 int count_before = totlen;
8084 /* Add chars to XBUF. */
8085 for (i = 0; i < ap->nchars; i++, offset++)
8086 xbuf[totlen++] = exp[offset];
8088 /* If followed by an empty rest arg with concatenation,
8089 delete the last run of nonwhite chars. */
8090 if (rest_zero && totlen > count_before
8091 && ((ap->rest_args && ap->raw_before != 0)
8092 || (last_ap != NULL && last_ap->rest_args
8093 && last_ap->raw_after != 0))) {
8094 /* Delete final whitespace. */
8095 while (totlen > count_before && is_space[xbuf[totlen - 1]]) {
8099 /* Delete the nonwhites before them. */
8100 while (totlen > count_before && ! is_space[xbuf[totlen - 1]]) {
8105 if (ap->stringify != 0) {
8106 int arglen = arg->raw_length;
8112 && (c = arg->raw[i], is_space[c]))
8115 && (c = arg->raw[arglen - 1], is_space[c]))
8118 xbuf[totlen++] = '\"'; /* insert beginning quote */
8119 for (; i < arglen; i++) {
8122 /* Special markers Newline Space
8123 generate nothing for a stringified argument. */
8124 if (c == '\n' && arg->raw[i+1] != '\n') {
8129 /* Internal sequences of whitespace are replaced by one space
8130 except within an string or char token. */
8132 && (c == '\n' ? arg->raw[i+1] == '\n' : is_space[c])) {
8134 /* Note that Newline Space does occur within whitespace
8135 sequences; consider it part of the sequence. */
8136 if (c == '\n' && is_space[arg->raw[i+1]])
8138 else if (c != '\n' && is_space[c])
8155 } else if (c == '\"' || c == '\'')
8159 /* Escape these chars */
8160 if (c == '\"' || (in_string && c == '\\'))
8161 xbuf[totlen++] = '\\';
8165 sprintf ((char *) &xbuf[totlen], "\\%03o", (unsigned int) c);
8170 xbuf[totlen++] = '\"'; /* insert ending quote */
8171 } else if (ap->raw_before != 0 || ap->raw_after != 0 || traditional) {
8172 U_CHAR *p1 = arg->raw;
8173 U_CHAR *l1 = p1 + arg->raw_length;
8174 if (ap->raw_before != 0) {
8175 while (p1 != l1 && is_space[*p1]) p1++;
8176 while (p1 != l1 && is_idchar[*p1])
8177 xbuf[totlen++] = *p1++;
8178 /* Delete any no-reexpansion marker that follows
8179 an identifier at the beginning of the argument
8180 if the argument is concatenated with what precedes it. */
8181 if (p1[0] == '\n' && p1[1] == '-')
8183 } else if (!traditional) {
8184 /* Ordinary expanded use of the argument.
8185 Put in newline-space markers to prevent token pasting. */
8186 xbuf[totlen++] = '\n';
8187 xbuf[totlen++] = ' ';
8189 if (ap->raw_after != 0) {
8190 /* Arg is concatenated after: delete trailing whitespace,
8191 whitespace markers, and no-reexpansion markers. */
8193 if (is_space[l1[-1]]) l1--;
8194 else if (l1[-1] == '-') {
8195 U_CHAR *p2 = l1 - 1;
8196 /* If a `-' is preceded by an odd number of newlines then it
8197 and the last newline are a no-reexpansion marker. */
8198 while (p2 != p1 && p2[-1] == '\n') p2--;
8199 if ((l1 - 1 - p2) & 1) {
8208 bcopy ((char *) p1, (char *) (xbuf + totlen), l1 - p1);
8210 if (!traditional && ap->raw_after == 0) {
8211 /* Ordinary expanded use of the argument.
8212 Put in newline-space markers to prevent token pasting. */
8213 xbuf[totlen++] = '\n';
8214 xbuf[totlen++] = ' ';
8217 /* Ordinary expanded use of the argument.
8218 Put in newline-space markers to prevent token pasting. */
8220 xbuf[totlen++] = '\n';
8221 xbuf[totlen++] = ' ';
8223 bcopy ((char *) arg->expanded, (char *) (xbuf + totlen),
8224 arg->expand_length);
8225 totlen += arg->expand_length;
8227 xbuf[totlen++] = '\n';
8228 xbuf[totlen++] = ' ';
8230 /* If a macro argument with newlines is used multiple times,
8231 then only expand the newlines once. This avoids creating output
8232 lines which don't correspond to any input line, which confuses
8234 if (arg->use_count > 1 && arg->newlines > 0) {
8235 /* Don't bother doing change_newlines for subsequent
8239 = change_newlines (arg->expanded, arg->expand_length);
8243 if (totlen > xbuf_len)
8247 /* If there is anything left of the definition after handling
8248 the arg list, copy that in too. */
8250 for (i = offset; i < defn->length; i++) {
8251 /* if we've reached the end of the macro */
8254 if (! (rest_zero && last_ap != NULL && last_ap->rest_args
8255 && last_ap->raw_after != 0))
8256 xbuf[totlen++] = exp[i];
8262 for (i = 0; i < nargs; i++) {
8263 if (args[i].free1 != 0)
8264 free (args[i].free1);
8265 if (args[i].free2 != 0)
8266 free (args[i].free2);
8270 xbuf = defn->expansion;
8271 xbuf_len = defn->length;
8274 /* Now put the expansion on the input stack
8275 so our caller will commence reading from it. */
8277 register FILE_BUF *ip2;
8279 ip2 = &instack[++indepth];
8282 ip2->nominal_fname = 0;
8284 /* This may not be exactly correct, but will give much better error
8285 messages for nested macro calls than using a line number of zero. */
8286 ip2->lineno = start_line;
8288 ip2->length = xbuf_len;
8290 ip2->free_ptr = (nargs > 0) ? xbuf : 0;
8292 ip2->if_stack = if_stack;
8293 ip2->system_header_p = 0;
8295 /* Recursive macro use sometimes works traditionally.
8296 #define foo(x,y) bar (x (y,0), y)
8300 hp->type = T_DISABLED;
8304 /* Parse a macro argument and store the info on it into *ARGPTR.
8305 REST_ARGS is passed to macarg1 to make it absorb the rest of the args.
8306 Return nonzero to indicate a syntax error. */
8309 macarg (argptr, rest_args)
8310 register struct argdata *argptr;
8313 FILE_BUF *ip = &instack[indepth];
8319 /* Try to parse as much of the argument as exists at this
8320 input stack level. */
8321 U_CHAR *bp = macarg1 (ip->bufp, ip->buf + ip->length,
8322 &paren, &newlines, &comments, rest_args);
8324 /* If we find the end of the argument at this level,
8325 set up *ARGPTR to point at it in the input stack. */
8326 if (!(ip->fname != 0 && (newlines != 0 || comments != 0))
8327 && bp != ip->buf + ip->length) {
8329 argptr->raw = ip->bufp;
8330 argptr->raw_length = bp - ip->bufp;
8331 argptr->newlines = newlines;
8335 /* This input stack level ends before the macro argument does.
8336 We must pop levels and keep parsing.
8337 Therefore, we must allocate a temporary buffer and copy
8338 the macro argument into it. */
8339 int bufsize = bp - ip->bufp;
8340 int extra = newlines;
8341 U_CHAR *buffer = (U_CHAR *) xmalloc (bufsize + extra + 1);
8342 int final_start = 0;
8344 bcopy ((char *) ip->bufp, (char *) buffer, bufsize);
8346 ip->lineno += newlines;
8348 while (bp == ip->buf + ip->length) {
8349 if (instack[indepth].macro == 0) {
8350 result = "unterminated macro call";
8353 ip->macro->type = T_MACRO;
8355 free (ip->free_ptr);
8356 ip = &instack[--indepth];
8359 bp = macarg1 (ip->bufp, ip->buf + ip->length, &paren,
8360 &newlines, &comments, rest_args);
8361 final_start = bufsize;
8362 bufsize += bp - ip->bufp;
8364 buffer = (U_CHAR *) xrealloc (buffer, bufsize + extra + 1);
8365 bcopy ((char *) ip->bufp, (char *) (buffer + bufsize - (bp - ip->bufp)),
8368 ip->lineno += newlines;
8371 /* Now, if arg is actually wanted, record its raw form,
8372 discarding comments and duplicating newlines in whatever
8373 part of it did not come from a macro expansion.
8374 EXTRA space has been preallocated for duplicating the newlines.
8375 FINAL_START is the index of the start of that part. */
8377 argptr->raw = buffer;
8378 argptr->raw_length = bufsize;
8379 argptr->free1 = buffer;
8380 argptr->newlines = newlines;
8381 if ((newlines || comments) && ip->fname != 0)
8384 discard_comments (argptr->raw + final_start,
8385 argptr->raw_length - final_start,
8387 argptr->raw[argptr->raw_length] = 0;
8388 if (argptr->raw_length > bufsize + extra)
8393 /* If we are not discarding this argument,
8394 macroexpand it and compute its length as stringified.
8395 All this info goes into *ARGPTR. */
8398 register U_CHAR *buf, *lim;
8399 register int totlen;
8402 lim = buf + argptr->raw_length;
8404 while (buf != lim && is_space[*buf])
8406 while (buf != lim && is_space[lim[-1]])
8408 totlen = traditional ? 0 : 2; /* Count opening and closing quote. */
8409 while (buf != lim) {
8410 register U_CHAR c = *buf++;
8412 /* Internal sequences of whitespace are replaced by one space
8413 in most cases, but not always. So count all the whitespace
8414 in case we need to keep it all. */
8417 SKIP_ALL_WHITE_SPACE (buf);
8420 if (c == '\"' || c == '\\') /* escape these chars */
8422 else if (!isprint (c))
8425 argptr->stringified_length = totlen;
8430 /* Scan text from START (inclusive) up to LIMIT (exclusive),
8431 counting parens in *DEPTHPTR,
8432 and return if reach LIMIT
8433 or before a `)' that would make *DEPTHPTR negative
8434 or before a comma when *DEPTHPTR is zero.
8435 Single and double quotes are matched and termination
8436 is inhibited within them. Comments also inhibit it.
8437 Value returned is pointer to stopping place.
8439 Increment *NEWLINES each time a newline is passed.
8440 REST_ARGS notifies macarg1 that it should absorb the rest of the args.
8441 Set *COMMENTS to 1 if a comment is seen. */
8444 macarg1 (start, limit, depthptr, newlines, comments, rest_args)
8446 register U_CHAR *limit;
8447 int *depthptr, *newlines, *comments;
8450 register U_CHAR *bp = start;
8452 while (bp < limit) {
8458 if (--(*depthptr) < 0)
8462 /* Traditionally, backslash makes following char not special. */
8463 if (bp + 1 < limit && traditional)
8466 /* But count source lines anyway. */
8475 if (bp[1] == '\\' && bp[2] == '\n')
8476 newline_fix (bp + 1);
8479 for (bp += 2; bp < limit; bp++) {
8482 else if (*bp == '*') {
8483 if (bp[-1] == '/' && warn_comments)
8484 warning ("`/*' within comment");
8485 if (bp[1] == '\\' && bp[2] == '\n')
8486 newline_fix (bp + 1);
8493 } else if (bp[1] == '/' && cplusplus_comments) {
8495 for (bp += 2; bp < limit; bp++) {
8501 warning ("multiline `//' comment");
8510 for (quotec = *bp++; bp + 1 < limit && *bp != quotec; bp++) {
8515 while (*bp == '\\' && bp[1] == '\n') {
8518 } else if (*bp == '\n') {
8527 /* if we've returned to lowest level and we aren't absorbing all args */
8528 if ((*depthptr) == 0 && rest_args == 0)
8538 /* Discard comments and duplicate newlines
8539 in the string of length LENGTH at START,
8540 except inside of string constants.
8541 The string is copied into itself with its beginning staying fixed.
8543 NEWLINES is the number of newlines that must be duplicated.
8544 We assume that that much extra space is available past the end
8548 discard_comments (start, length, newlines)
8553 register U_CHAR *ibp;
8554 register U_CHAR *obp;
8555 register U_CHAR *limit;
8558 /* If we have newlines to duplicate, copy everything
8559 that many characters up. Then, in the second part,
8560 we will have room to insert the newlines
8562 NEWLINES may actually be too large, because it counts
8563 newlines in string constants, and we don't duplicate those.
8564 But that does no harm. */
8566 ibp = start + length;
8567 obp = ibp + newlines;
8569 while (limit != ibp)
8573 ibp = start + newlines;
8574 limit = start + length + newlines;
8577 while (ibp < limit) {
8578 *obp++ = c = *ibp++;
8581 /* Duplicate the newline. */
8593 if (*ibp == '\\' && ibp[1] == '\n')
8595 /* Delete any comment. */
8596 if (cplusplus_comments && ibp[0] == '/') {
8597 /* Comments are equivalent to spaces. */
8600 while (ibp < limit && (*ibp != '\n' || ibp[-1] == '\\'))
8604 if (ibp[0] != '*' || ibp + 1 >= limit)
8606 /* Comments are equivalent to spaces.
8607 For -traditional, a comment is equivalent to nothing. */
8613 while (ibp + 1 < limit) {
8615 && ibp[1] == '\\' && ibp[2] == '\n')
8616 newline_fix (ibp + 1);
8617 if (ibp[0] == '*' && ibp[1] == '/')
8626 /* Notice and skip strings, so that we don't
8627 think that comments start inside them,
8628 and so we don't duplicate newlines in them. */
8631 while (ibp < limit) {
8632 *obp++ = c = *ibp++;
8635 if (c == '\n' && quotec == '\'')
8637 if (c == '\\' && ibp < limit) {
8638 while (*ibp == '\\' && ibp[1] == '\n')
8651 /* Turn newlines to spaces in the string of length LENGTH at START,
8652 except inside of string constants.
8653 The string is copied into itself with its beginning staying fixed. */
8656 change_newlines (start, length)
8660 register U_CHAR *ibp;
8661 register U_CHAR *obp;
8662 register U_CHAR *limit;
8666 limit = start + length;
8669 while (ibp < limit) {
8670 *obp++ = c = *ibp++;
8673 /* If this is a NEWLINE NEWLINE, then this is a real newline in the
8674 string. Skip past the newline and its duplicate.
8675 Put a space in the output. */
8686 /* Notice and skip strings, so that we don't delete newlines in them. */
8689 while (ibp < limit) {
8690 *obp++ = c = *ibp++;
8693 if (c == '\n' && quotec == '\'')
8704 /* my_strerror - return the descriptive text associated with an
8708 my_strerror (errnum)
8714 #ifndef HAVE_STRERROR
8715 result = (char *) ((errnum < sys_nerr) ? sys_errlist[errnum] : 0);
8717 result = strerror (errnum);
8720 /* VAXCRTL's strerror() takes an optional second argument, which only
8721 matters when the first argument is EVMSERR. However, it's simplest
8722 just to pass it unconditionally. `vaxc$errno' is declared in
8723 <errno.h>, and maintained by the library in parallel with `errno'.
8724 We assume that caller's `errnum' either matches the last setting of
8725 `errno' by the library or else does not have the value `EVMSERR'. */
8727 result = strerror (errnum, vaxc$errno);
8731 result = "undocumented I/O error";
8736 /* error - print error message and increment count of errors. */
8739 error (PRINTF_ALIST (msg))
8744 VA_START (args, msg);
8755 FILE_BUF *ip = NULL;
8757 print_containing_files ();
8759 for (i = indepth; i >= 0; i--)
8760 if (instack[i].fname != NULL) {
8766 fprintf (stderr, "%s:%d: ", ip->nominal_fname, ip->lineno);
8767 vfprintf (stderr, msg, args);
8768 fprintf (stderr, "\n");
8772 /* Error including a message from `errno'. */
8775 error_from_errno (name)
8779 FILE_BUF *ip = NULL;
8781 print_containing_files ();
8783 for (i = indepth; i >= 0; i--)
8784 if (instack[i].fname != NULL) {
8790 fprintf (stderr, "%s:%d: ", ip->nominal_fname, ip->lineno);
8792 fprintf (stderr, "%s: %s\n", name, my_strerror (errno));
8797 /* Print error message but don't count it. */
8800 warning (PRINTF_ALIST (msg))
8805 VA_START (args, msg);
8806 vwarning (msg, args);
8811 vwarning (msg, args)
8816 FILE_BUF *ip = NULL;
8818 if (inhibit_warnings)
8821 if (warnings_are_errors)
8824 print_containing_files ();
8826 for (i = indepth; i >= 0; i--)
8827 if (instack[i].fname != NULL) {
8833 fprintf (stderr, "%s:%d: ", ip->nominal_fname, ip->lineno);
8834 fprintf (stderr, "warning: ");
8835 vfprintf (stderr, msg, args);
8836 fprintf (stderr, "\n");
8840 #if defined (__STDC__) && defined (HAVE_VPRINTF)
8841 error_with_line (int line, PRINTF_ALIST (msg))
8843 error_with_line (line, PRINTF_ALIST (msg))
8850 VA_START (args, msg);
8851 verror_with_line (line, msg, args);
8856 verror_with_line (line, msg, args)
8862 FILE_BUF *ip = NULL;
8864 print_containing_files ();
8866 for (i = indepth; i >= 0; i--)
8867 if (instack[i].fname != NULL) {
8873 fprintf (stderr, "%s:%d: ", ip->nominal_fname, line);
8874 vfprintf (stderr, msg, args);
8875 fprintf (stderr, "\n");
8880 #if defined (__STDC__) && defined (HAVE_VPRINTF)
8881 warning_with_line (int line, PRINTF_ALIST (msg))
8883 warning_with_line (line, PRINTF_ALIST (msg))
8890 VA_START (args, msg);
8891 vwarning_with_line (line, msg, args);
8896 vwarning_with_line (line, msg, args)
8902 FILE_BUF *ip = NULL;
8904 if (inhibit_warnings)
8907 if (warnings_are_errors)
8910 print_containing_files ();
8912 for (i = indepth; i >= 0; i--)
8913 if (instack[i].fname != NULL) {
8919 fprintf (stderr, line ? "%s:%d: " : "%s: ", ip->nominal_fname, line);
8920 fprintf (stderr, "warning: ");
8921 vfprintf (stderr, msg, args);
8922 fprintf (stderr, "\n");
8925 /* Print an error message and maybe count it. */
8928 pedwarn (PRINTF_ALIST (msg))
8933 VA_START (args, msg);
8934 if (pedantic_errors)
8937 vwarning (msg, args);
8942 #if defined (__STDC__) && defined (HAVE_VPRINTF)
8943 pedwarn_with_line (int line, PRINTF_ALIST (msg))
8945 pedwarn_with_line (line, PRINTF_ALIST (msg))
8952 VA_START (args, msg);
8953 if (pedantic_errors)
8954 verror_with_line (line, msg, args);
8956 vwarning_with_line (line, msg, args);
8960 /* Report a warning (or an error if pedantic_errors)
8961 giving specified file name and line number, not current. */
8964 #if defined (__STDC__) && defined (HAVE_VPRINTF)
8965 pedwarn_with_file_and_line (char *file, int line, PRINTF_ALIST (msg))
8967 pedwarn_with_file_and_line (file, line, PRINTF_ALIST (msg))
8975 if (!pedantic_errors && inhibit_warnings)
8978 fprintf (stderr, "%s:%d: ", file, line);
8979 if (pedantic_errors)
8981 if (!pedantic_errors)
8982 fprintf (stderr, "warning: ");
8983 VA_START (args, msg);
8984 vfprintf (stderr, msg, args);
8986 fprintf (stderr, "\n");
8989 /* Print the file names and line numbers of the #include
8990 directives which led to the current file. */
8993 print_containing_files ()
8995 FILE_BUF *ip = NULL;
8999 /* If stack of files hasn't changed since we last printed
9000 this info, don't repeat it. */
9001 if (last_error_tick == input_file_stack_tick)
9004 for (i = indepth; i >= 0; i--)
9005 if (instack[i].fname != NULL) {
9010 /* Give up if we don't find a source file. */
9014 /* Find the other, outer source files. */
9015 for (i--; i >= 0; i--)
9016 if (instack[i].fname != NULL) {
9020 fprintf (stderr, "In file included");
9022 fprintf (stderr, ",\n ");
9025 fprintf (stderr, " from %s:%d", ip->nominal_fname, ip->lineno);
9028 fprintf (stderr, ":\n");
9030 /* Record we have printed the status as of this time. */
9031 last_error_tick = input_file_stack_tick;
9034 /* Return the line at which an error occurred.
9035 The error is not necessarily associated with the current spot
9036 in the input stack, so LINE says where. LINE will have been
9037 copied from ip->lineno for the current input level.
9038 If the current level is for a file, we return LINE.
9039 But if the current level is not for a file, LINE is meaningless.
9040 In that case, we return the lineno of the innermost file. */
9043 line_for_error (line)
9049 for (i = indepth; i >= 0; ) {
9050 if (instack[i].fname != 0)
9055 line1 = instack[i].lineno;
9063 * If OBUF doesn't have NEEDED bytes after OPTR, make it bigger.
9065 * As things stand, nothing is ever placed in the output buffer to be
9066 * removed again except when it's KNOWN to be part of an identifier,
9067 * so flushing and moving down everything left, instead of expanding,
9071 /* You might think void was cleaner for the return type,
9072 but that would get type mismatch in check_expand in strict ANSI. */
9075 grow_outbuf (obuf, needed)
9076 register FILE_BUF *obuf;
9077 register int needed;
9082 if (obuf->length - (obuf->bufp - obuf->buf) > needed)
9085 /* Make it at least twice as big as it is now. */
9087 /* Make it have at least 150% of the free space we will need. */
9088 minsize = (3 * needed) / 2 + (obuf->bufp - obuf->buf);
9089 if (minsize > obuf->length)
9090 obuf->length = minsize;
9092 if ((p = (U_CHAR *) xrealloc (obuf->buf, obuf->length)) == NULL)
9095 obuf->bufp = p + (obuf->bufp - obuf->buf);
9101 /* Symbol table for macro names and special symbols */
9104 * install a name in the main hash table, even if it is already there.
9105 * name stops with first non alphanumeric, except leading '#'.
9106 * caller must check against redefinition if that is desired.
9107 * delete_macro () removes things installed by install () in fifo order.
9108 * this is important because of the `defined' special symbol used
9109 * in #if, and also if pushdef/popdef directives are ever implemented.
9111 * If LEN is >= 0, it is the length of the name.
9112 * Otherwise, compute the length by scanning the entire name.
9114 * If HASH is >= 0, it is the precomputed hash code.
9115 * Otherwise, compute the hash code.
9119 install (name, len, type, value, hash)
9122 enum node_type type;
9126 register HASHNODE *hp;
9127 register int i, bucket;
9128 register U_CHAR *p, *q;
9132 while (is_idchar[*p])
9138 hash = hashf (name, len, HASHSIZE);
9140 i = sizeof (HASHNODE) + len + 1;
9141 hp = (HASHNODE *) xmalloc (i);
9143 hp->bucket_hdr = &hashtab[bucket];
9144 hp->next = hashtab[bucket];
9145 hashtab[bucket] = hp;
9147 if (hp->next != NULL)
9148 hp->next->prev = hp;
9151 hp->value.cpval = value;
9152 hp->name = ((U_CHAR *) hp) + sizeof (HASHNODE);
9155 for (i = 0; i < len; i++)
9162 * find the most recent hash node for name name (ending with first
9163 * non-identifier char) installed by install
9165 * If LEN is >= 0, it is the length of the name.
9166 * Otherwise, compute the length by scanning the entire name.
9168 * If HASH is >= 0, it is the precomputed hash code.
9169 * Otherwise, compute the hash code.
9173 lookup (name, len, hash)
9178 register U_CHAR *bp;
9179 register HASHNODE *bucket;
9182 for (bp = name; is_idchar[*bp]; bp++) ;
9187 hash = hashf (name, len, HASHSIZE);
9189 bucket = hashtab[hash];
9191 if (bucket->length == len && bcmp (bucket->name, name, len) == 0)
9193 bucket = bucket->next;
9199 * Delete a hash node. Some weirdness to free junk from macros.
9200 * More such weirdness will have to be added if you define more hash
9201 * types that need it.
9204 /* Note that the DEFINITION of a macro is removed from the hash table
9205 but its storage is not freed. This would be a storage leak
9206 except that it is not reasonable to keep undefining and redefining
9207 large numbers of macros many times.
9208 In any case, this is necessary, because a macro can be #undef'd
9209 in the middle of reading the arguments to a call to it.
9210 If #undef freed the DEFINITION, that would crash. */
9217 if (hp->prev != NULL)
9218 hp->prev->next = hp->next;
9219 if (hp->next != NULL)
9220 hp->next->prev = hp->prev;
9222 /* Make sure that the bucket chain header that the deleted guy was
9223 on points to the right thing afterwards. */
9224 if (hp == *hp->bucket_hdr)
9225 *hp->bucket_hdr = hp->next;
9228 if (hp->type == T_MACRO) {
9229 DEFINITION *d = hp->value.defn;
9230 struct reflist *ap, *nextap;
9232 for (ap = d->pattern; ap != NULL; ap = nextap) {
9243 * return hash function on name. must be compatible with the one
9244 * computed a step at a time, elsewhere
9248 hashf (name, len, hashsize)
9249 register U_CHAR *name;
9256 r = HASHSTEP (r, *name++);
9258 return MAKE_POS (r) % hashsize;
9262 /* Dump the definition of a single macro HP to OF. */
9265 dump_single_macro (hp, of)
9266 register HASHNODE *hp;
9269 register DEFINITION *defn = hp->value.defn;
9275 /* Print the definition of the macro HP. */
9277 fprintf (of, "#define %s", hp->name);
9279 if (defn->nargs >= 0) {
9283 for (i = 0; i < defn->nargs; i++) {
9284 dump_arg_n (defn, i, of);
9285 if (i + 1 < defn->nargs)
9295 for (ap = defn->pattern; ap != NULL; ap = ap->next) {
9296 dump_defn_1 (defn->expansion, offset, ap->nchars, of);
9297 offset += ap->nchars;
9299 if (ap->nchars != 0)
9301 if (ap->stringify) {
9302 switch (ap->stringify) {
9303 case SHARP_TOKEN: fprintf (of, "#"); break;
9304 case WHITE_SHARP_TOKEN: fprintf (of, "# "); break;
9305 case PERCENT_COLON_TOKEN: fprintf (of, "%%:"); break;
9306 case WHITE_PERCENT_COLON_TOKEN: fprintf (of, "%%: "); break;
9310 if (ap->raw_before != 0) {
9312 switch (ap->raw_before) {
9313 case WHITE_SHARP_TOKEN:
9314 case WHITE_PERCENT_COLON_TOKEN:
9321 switch (ap->raw_before) {
9322 case SHARP_TOKEN: fprintf (of, "##"); break;
9323 case WHITE_SHARP_TOKEN: fprintf (of, "## "); break;
9324 case PERCENT_COLON_TOKEN: fprintf (of, "%%:%%:"); break;
9325 case WHITE_PERCENT_COLON_TOKEN: fprintf (of, "%%:%%: "); break;
9332 dump_arg_n (defn, ap->argno, of);
9333 if (!traditional && ap->raw_after != 0) {
9334 switch (ap->raw_after) {
9335 case SHARP_TOKEN: fprintf (of, "##"); break;
9336 case WHITE_SHARP_TOKEN: fprintf (of, " ##"); break;
9337 case PERCENT_COLON_TOKEN: fprintf (of, "%%:%%:"); break;
9338 case WHITE_PERCENT_COLON_TOKEN: fprintf (of, " %%:%%:"); break;
9344 dump_defn_1 (defn->expansion, offset, defn->length - offset, of);
9348 /* Dump all macro definitions as #defines to stdout. */
9355 for (bucket = 0; bucket < HASHSIZE; bucket++) {
9356 register HASHNODE *hp;
9358 for (hp = hashtab[bucket]; hp; hp= hp->next) {
9359 if (hp->type == T_MACRO)
9360 dump_single_macro (hp, stdout);
9365 /* Output to OF a substring of a macro definition.
9366 BASE is the beginning of the definition.
9367 Output characters START thru LENGTH.
9368 Unless traditional, discard newlines outside of strings, thus
9369 converting funny-space markers to ordinary spaces. */
9372 dump_defn_1 (base, start, length, of)
9378 U_CHAR *p = base + start;
9379 U_CHAR *limit = base + start + length;
9382 fwrite (p, sizeof (*p), length, of);
9385 if (*p == '\"' || *p =='\'') {
9386 U_CHAR *p1 = skip_quoted_string (p, limit, 0, NULL_PTR,
9387 NULL_PTR, NULL_PTR);
9388 fwrite (p, sizeof (*p), p1 - p, of);
9399 /* Print the name of argument number ARGNUM of macro definition DEFN
9401 Recall that DEFN->args.argnames contains all the arg names
9402 concatenated in reverse order with comma-space in between. */
9405 dump_arg_n (defn, argnum, of)
9410 register U_CHAR *p = defn->args.argnames;
9411 while (argnum + 1 < defn->nargs) {
9412 p = (U_CHAR *) index ((char *) p, ' ') + 1;
9416 while (*p && *p != ',') {
9422 /* Initialize syntactic classifications of characters. */
9425 initialize_char_syntax ()
9430 * Set up is_idchar and is_idstart tables. These should be
9431 * faster than saying (is_alpha (c) || c == '_'), etc.
9432 * Set up these things before calling any routines tthat
9435 for (i = 'a'; i <= 'z'; i++) {
9436 is_idchar[i - 'a' + 'A'] = 1;
9438 is_idstart[i - 'a' + 'A'] = 1;
9441 for (i = '0'; i <= '9'; i++)
9444 is_idstart['_'] = 1;
9446 is_idstart['$'] = 1;
9448 /* horizontal space table */
9449 is_hor_space[' '] = 1;
9450 is_hor_space['\t'] = 1;
9451 is_hor_space['\v'] = 1;
9452 is_hor_space['\f'] = 1;
9453 is_hor_space['\r'] = 1;
9462 char_name['\v'] = "vertical tab";
9463 char_name['\f'] = "formfeed";
9464 char_name['\r'] = "carriage return";
9467 /* Initialize the built-in macros. */
9470 initialize_builtins (inp, outp)
9474 install ((U_CHAR *) "__LINE__", -1, T_SPECLINE, NULL_PTR, -1);
9475 install ((U_CHAR *) "__DATE__", -1, T_DATE, NULL_PTR, -1);
9476 install ((U_CHAR *) "__FILE__", -1, T_FILE, NULL_PTR, -1);
9477 install ((U_CHAR *) "__BASE_FILE__", -1, T_BASE_FILE, NULL_PTR, -1);
9478 install ((U_CHAR *) "__INCLUDE_LEVEL__", -1, T_INCLUDE_LEVEL, NULL_PTR, -1);
9479 install ((U_CHAR *) "__VERSION__", -1, T_VERSION, NULL_PTR, -1);
9480 #ifndef NO_BUILTIN_SIZE_TYPE
9481 install ((U_CHAR *) "__SIZE_TYPE__", -1, T_SIZE_TYPE, NULL_PTR, -1);
9483 #ifndef NO_BUILTIN_PTRDIFF_TYPE
9484 install ((U_CHAR *) "__PTRDIFF_TYPE__ ", -1, T_PTRDIFF_TYPE, NULL_PTR, -1);
9486 install ((U_CHAR *) "__WCHAR_TYPE__", -1, T_WCHAR_TYPE, NULL_PTR, -1);
9487 install ((U_CHAR *) "__USER_LABEL_PREFIX__", -1, T_USER_LABEL_PREFIX_TYPE,
9489 install ((U_CHAR *) "__REGISTER_PREFIX__", -1, T_REGISTER_PREFIX_TYPE,
9491 install ((U_CHAR *) "__IMMEDIATE_PREFIX__", -1, T_IMMEDIATE_PREFIX_TYPE,
9493 install ((U_CHAR *) "__TIME__", -1, T_TIME, NULL_PTR, -1);
9495 install ((U_CHAR *) "__STDC__", -1, T_CONST, "1", -1);
9496 install ((U_CHAR *) "__STDC_VERSION__", -1, T_CONST, "199409L", -1);
9499 install ((U_CHAR *) "__OBJC__", -1, T_CONST, "1", -1);
9500 /* This is supplied using a -D by the compiler driver
9501 so that it is present only when truly compiling with GNU C. */
9502 /* install ((U_CHAR *) "__GNUC__", -1, T_CONST, "2", -1); */
9503 install ((U_CHAR *) "__HAVE_BUILTIN_SETJMP__", -1, T_CONST, "1", -1);
9507 char directive[2048];
9508 U_CHAR *udirective = (U_CHAR *) directive;
9509 register struct directive *dp = &directive_table[0];
9510 struct tm *timebuf = timestamp ();
9512 sprintf (directive, " __BASE_FILE__ \"%s\"\n",
9513 instack[0].nominal_fname);
9514 output_line_directive (inp, outp, 0, same_file);
9515 pass_thru_directive (udirective, &udirective[strlen (directive)],
9518 sprintf (directive, " __VERSION__ \"%s\"\n", version_string);
9519 output_line_directive (inp, outp, 0, same_file);
9520 pass_thru_directive (udirective, &udirective[strlen (directive)],
9523 #ifndef NO_BUILTIN_SIZE_TYPE
9524 sprintf (directive, " __SIZE_TYPE__ %s\n", SIZE_TYPE);
9525 output_line_directive (inp, outp, 0, same_file);
9526 pass_thru_directive (udirective, &udirective[strlen (directive)],
9530 #ifndef NO_BUILTIN_PTRDIFF_TYPE
9531 sprintf (directive, " __PTRDIFF_TYPE__ %s\n", PTRDIFF_TYPE);
9532 output_line_directive (inp, outp, 0, same_file);
9533 pass_thru_directive (udirective, &udirective[strlen (directive)],
9537 sprintf (directive, " __WCHAR_TYPE__ %s\n", wchar_type);
9538 output_line_directive (inp, outp, 0, same_file);
9539 pass_thru_directive (udirective, &udirective[strlen (directive)],
9542 sprintf (directive, " __DATE__ \"%s %2d %4d\"\n",
9543 monthnames[timebuf->tm_mon],
9544 timebuf->tm_mday, timebuf->tm_year + 1900);
9545 output_line_directive (inp, outp, 0, same_file);
9546 pass_thru_directive (udirective, &udirective[strlen (directive)],
9549 sprintf (directive, " __TIME__ \"%02d:%02d:%02d\"\n",
9550 timebuf->tm_hour, timebuf->tm_min, timebuf->tm_sec);
9551 output_line_directive (inp, outp, 0, same_file);
9552 pass_thru_directive (udirective, &udirective[strlen (directive)],
9557 sprintf (directive, " __STDC__ 1");
9558 output_line_directive (inp, outp, 0, same_file);
9559 pass_thru_directive (udirective, &udirective[strlen (directive)],
9564 sprintf (directive, " __OBJC__ 1");
9565 output_line_directive (inp, outp, 0, same_file);
9566 pass_thru_directive (udirective, &udirective[strlen (directive)],
9573 * process a given definition string, for initialization
9574 * If STR is just an identifier, define it with value 1.
9575 * If STR has anything after the identifier, then it should
9576 * be identifier=definition.
9580 make_definition (str, op)
9585 struct directive *kt;
9588 p = buf = (U_CHAR *) str;
9589 if (!is_idstart[*p]) {
9590 error ("malformed option `-D %s'", str);
9593 while (is_idchar[*++p])
9596 while (is_idchar[*++p] || *p == ',' || is_hor_space[*p])
9599 p = (U_CHAR *) str; /* Error */
9602 buf = (U_CHAR *) alloca (p - buf + 4);
9603 strcpy ((char *)buf, str);
9604 strcat ((char *)buf, " 1");
9605 } else if (*p != '=') {
9606 error ("malformed option `-D %s'", str);
9610 /* Copy the entire option so we can modify it. */
9611 buf = (U_CHAR *) alloca (2 * strlen (str) + 1);
9612 strncpy ((char *) buf, str, p - (U_CHAR *) str);
9613 /* Change the = to a space. */
9614 buf[p - (U_CHAR *) str] = ' ';
9615 /* Scan for any backslash-newline and remove it. */
9617 q = &buf[p - (U_CHAR *) str];
9619 if (*p == '\"' || *p == '\'') {
9620 int unterminated = 0;
9621 U_CHAR *p1 = skip_quoted_string (p, p + strlen ((char *) p), 0,
9622 NULL_PTR, NULL_PTR, &unterminated);
9626 if (*p == '\\' && p[1] == '\n')
9630 } else if (*p == '\\' && p[1] == '\n')
9632 /* Change newline chars into newline-markers. */
9633 else if (*p == '\n')
9645 ip = &instack[++indepth];
9646 ip->nominal_fname = ip->fname = "*Initialization*";
9648 ip->buf = ip->bufp = buf;
9649 ip->length = strlen ((char *) buf);
9653 ip->if_stack = if_stack;
9654 ip->system_header_p = 0;
9656 for (kt = directive_table; kt->type != T_DEFINE; kt++)
9659 /* Pass NULL instead of OP, since this is a "predefined" macro. */
9660 do_define (buf, buf + strlen ((char *) buf), NULL_PTR, kt);
9664 /* JF, this does the work for the -U option */
9667 make_undef (str, op)
9672 struct directive *kt;
9674 ip = &instack[++indepth];
9675 ip->nominal_fname = ip->fname = "*undef*";
9677 ip->buf = ip->bufp = (U_CHAR *) str;
9678 ip->length = strlen (str);
9682 ip->if_stack = if_stack;
9683 ip->system_header_p = 0;
9685 for (kt = directive_table; kt->type != T_UNDEF; kt++)
9688 do_undef ((U_CHAR *) str, (U_CHAR *) str + strlen (str), op, kt);
9692 /* Process the string STR as if it appeared as the body of a #assert.
9693 OPTION is the option name for which STR was the argument. */
9696 make_assertion (option, str)
9701 struct directive *kt;
9702 U_CHAR *buf, *p, *q;
9704 /* Copy the entire option so we can modify it. */
9705 buf = (U_CHAR *) alloca (strlen (str) + 1);
9706 strcpy ((char *) buf, str);
9707 /* Scan for any backslash-newline and remove it. */
9710 if (*p == '\\' && p[1] == '\n')
9718 if (!is_idstart[*p]) {
9719 error ("malformed option `%s %s'", option, str);
9722 while (is_idchar[*++p])
9724 SKIP_WHITE_SPACE (p);
9725 if (! (*p == 0 || *p == '(')) {
9726 error ("malformed option `%s %s'", option, str);
9730 ip = &instack[++indepth];
9731 ip->nominal_fname = ip->fname = "*Initialization*";
9733 ip->buf = ip->bufp = buf;
9734 ip->length = strlen ((char *) buf);
9738 ip->if_stack = if_stack;
9739 ip->system_header_p = 0;
9741 for (kt = directive_table; kt->type != T_ASSERT; kt++)
9744 /* Pass NULL as output ptr to do_define since we KNOW it never does
9746 do_assert (buf, buf + strlen ((char *) buf) , NULL_PTR, kt);
9750 /* The previous include prefix, if any, is PREV_FILE_NAME.
9751 Allocate a new include prefix whose name is the
9752 simplified concatenation of PREFIX and NAME,
9753 with a trailing / added if needed.
9754 But return 0 if the include prefix should be ignored,
9755 e.g. because it is a duplicate of PREV_FILE_NAME. */
9757 static struct file_name_list *
9758 new_include_prefix (prev_file_name, prefix, name)
9759 struct file_name_list *prev_file_name;
9764 fatal ("Directory name missing after command line option");
9767 /* Ignore the empty string. */
9770 struct file_name_list *dir
9771 = ((struct file_name_list *)
9772 xmalloc (sizeof (struct file_name_list)
9773 + strlen (prefix) + strlen (name) + 1 /* for trailing / */));
9775 strcpy (dir->fname, prefix);
9776 strcat (dir->fname, name);
9777 len = simplify_filename (dir->fname);
9779 /* Convert directory name to a prefix. */
9780 if (dir->fname[len - 1] != '/') {
9781 if (len == 1 && dir->fname[len - 1] == '.')
9784 dir->fname[len++] = '/';
9785 dir->fname[len] = 0;
9788 /* Ignore a directory whose name matches the previous one. */
9789 if (prev_file_name && !strcmp (prev_file_name->fname, dir->fname)) {
9790 /* But treat `-Idir -I- -Idir' as `-I- -Idir'. */
9791 if (!first_bracket_include)
9792 first_bracket_include = prev_file_name;
9798 /* VMS can't stat dir prefixes, so skip these optimizations in VMS. */
9800 /* Ignore a nonexistent directory. */
9801 if (stat (len ? dir->fname : ".", &dir->st) != 0) {
9802 if (errno != ENOENT && errno != ENOTDIR)
9803 error_from_errno (dir->fname);
9808 /* Ignore a directory whose identity matches the previous one. */
9810 && INO_T_EQ (prev_file_name->st.st_ino, dir->st.st_ino)
9811 && prev_file_name->st.st_dev == dir->st.st_dev) {
9812 /* But treat `-Idir -I- -Idir' as `-I- -Idir'. */
9813 if (!first_bracket_include)
9814 first_bracket_include = prev_file_name;
9821 dir->c_system_include_path = 0;
9822 dir->got_name_map = 0;
9828 /* Append a chain of `struct file_name_list's
9829 to the end of the main include chain.
9830 FIRST is the beginning of the chain to append, and LAST is the end. */
9833 append_include_chain (first, last)
9834 struct file_name_list *first, *last;
9836 struct file_name_list *dir;
9838 if (!first || !last)
9844 last_include->next = first;
9846 if (first_bracket_include == 0)
9847 first_bracket_include = first;
9849 for (dir = first; ; dir = dir->next) {
9850 int len = strlen (dir->fname) + INCLUDE_LEN_FUDGE;
9851 if (len > max_include_len)
9852 max_include_len = len;
9858 last_include = last;
9861 /* Add output to `deps_buffer' for the -M switch.
9862 STRING points to the text to be output.
9863 SPACER is ':' for targets, ' ' for dependencies. */
9866 deps_output (string, spacer)
9870 int size = strlen (string);
9875 #ifndef MAX_OUTPUT_COLUMNS
9876 #define MAX_OUTPUT_COLUMNS 72
9878 if (MAX_OUTPUT_COLUMNS - 1 /*spacer*/ - 2 /*` \'*/ < deps_column + size
9879 && 1 < deps_column) {
9880 bcopy (" \\\n ", &deps_buffer[deps_size], 4);
9887 if (deps_size + size + 8 > deps_allocated_size) {
9888 deps_allocated_size = (deps_size + size + 50) * 2;
9889 deps_buffer = xrealloc (deps_buffer, deps_allocated_size);
9891 if (spacer == ' ') {
9892 deps_buffer[deps_size++] = ' ';
9895 bcopy (string, &deps_buffer[deps_size], size);
9897 deps_column += size;
9898 if (spacer == ':') {
9899 deps_buffer[deps_size++] = ':';
9902 deps_buffer[deps_size] = 0;
9906 fatal (PRINTF_ALIST (msg))
9911 fprintf (stderr, "%s: ", progname);
9912 VA_START (args, msg);
9913 vfprintf (stderr, msg, args);
9915 fprintf (stderr, "\n");
9916 exit (FATAL_EXIT_CODE);
9919 /* More 'friendly' abort that prints the line and file.
9920 config.h can #define abort fancy_abort if you like that sort of thing. */
9925 fatal ("Internal gcc abort.");
9929 perror_with_name (name)
9932 fprintf (stderr, "%s: ", progname);
9933 fprintf (stderr, "%s: %s\n", name, my_strerror (errno));
9938 pfatal_with_name (name)
9941 perror_with_name (name);
9945 exit (FATAL_EXIT_CODE);
9949 /* Handler for SIGPIPE. */
9953 /* If this is missing, some compilers complain. */
9956 fatal ("output pipe has been closed");
9962 fatal ("Memory exhausted.");
9970 register GENERIC_PTR ptr = (GENERIC_PTR) malloc (size);
9977 xrealloc (old, size)
9981 register GENERIC_PTR ptr = (GENERIC_PTR) realloc (old, size);
9988 xcalloc (number, size)
9989 size_t number, size;
9991 register size_t total = number * size;
9992 register GENERIC_PTR ptr = (GENERIC_PTR) malloc (total);
10003 size_t size = strlen (input);
10004 char *output = xmalloc (size + 1);
10005 strcpy (output, input);
10011 /* Under VMS we need to fix up the "include" specification filename so
10012 that everything following the 1st slash is changed into its correct
10013 VMS file specification. */
10016 hack_vms_include_specification (fname, vaxc_include)
10020 register char *cp, *cp1, *cp2;
10021 int f, check_filename_before_returning;
10024 check_filename_before_returning = 0;
10026 cp = base_name (fname);
10029 * Check if we have a vax-c style '#include filename'
10030 * and add the missing .h
10032 if (vaxc_include && !index (cp,'.'))
10035 cp2 = Local; /* initialize */
10037 /* We are trying to do a number of things here. First of all, we are
10038 trying to hammer the filenames into a standard format, such that later
10039 processing can handle them.
10041 If the file name contains something like [dir.], then it recognizes this
10042 as a root, and strips the ".]". Later processing will add whatever is
10043 needed to get things working properly.
10045 If no device is specified, then the first directory name is taken to be
10046 a device name (or a rooted logical). */
10048 /* See if we found that 1st slash */
10049 if (cp == 0) return; /* Nothing to do!!! */
10050 if (*cp != '/') return; /* Nothing to do!!! */
10051 /* Point to the UNIX filename part (which needs to be fixed!) */
10053 /* If the directory spec is not rooted, we can just copy
10054 the UNIX filename part and we are done */
10055 if (((cp - fname) > 1) && ((cp[-1] == ']') || (cp[-1] == '>'))) {
10056 if (cp[-2] != '.') {
10058 * The VMS part ends in a `]', and the preceding character is not a `.'.
10059 * We strip the `]', and then splice the two parts of the name in the
10060 * usual way. Given the default locations for include files in cccp.c,
10061 * we will only use this code if the user specifies alternate locations
10062 * with the /include (-I) switch on the command line. */
10063 cp -= 1; /* Strip "]" */
10064 cp1--; /* backspace */
10067 * The VMS part has a ".]" at the end, and this will not do. Later
10068 * processing will add a second directory spec, and this would be a syntax
10069 * error. Thus we strip the ".]", and thus merge the directory specs.
10070 * We also backspace cp1, so that it points to a '/'. This inhibits the
10071 * generation of the 000000 root directory spec (which does not belong here
10074 cp -= 2; /* Strip ".]" */
10075 cp1--; }; /* backspace */
10078 /* We drop in here if there is no VMS style directory specification yet.
10079 * If there is no device specification either, we make the first dir a
10080 * device and try that. If we do not do this, then we will be essentially
10081 * searching the users default directory (as if they did a #include "asdf.h").
10083 * Then all we need to do is to push a '[' into the output string. Later
10084 * processing will fill this in, and close the bracket.
10086 if (cp[-1] != ':') *cp2++ = ':'; /* dev not in spec. take first dir */
10087 *cp2++ = '['; /* Open the directory specification */
10090 /* at this point we assume that we have the device spec, and (at least
10091 the opening "[" for a directory specification. We may have directories
10092 specified already */
10094 /* If there are no other slashes then the filename will be
10095 in the "root" directory. Otherwise, we need to add
10096 directory specifications. */
10097 if (index (cp1, '/') == 0) {
10098 /* Just add "000000]" as the directory string */
10099 strcpy (cp2, "000000]");
10100 cp2 += strlen (cp2);
10101 check_filename_before_returning = 1; /* we might need to fool with this later */
10103 /* As long as there are still subdirectories to add, do them. */
10104 while (index (cp1, '/') != 0) {
10105 /* If this token is "." we can ignore it */
10106 if ((cp1[0] == '.') && (cp1[1] == '/')) {
10110 /* Add a subdirectory spec. Do not duplicate "." */
10111 if (cp2[-1] != '.' && cp2[-1] != '[' && cp2[-1] != '<')
10113 /* If this is ".." then the spec becomes "-" */
10114 if ((cp1[0] == '.') && (cp1[1] == '.') && (cp[2] == '/')) {
10115 /* Add "-" and skip the ".." */
10120 /* Copy the subdirectory */
10121 while (*cp1 != '/') *cp2++= *cp1++;
10122 cp1++; /* Skip the "/" */
10124 /* Close the directory specification */
10125 if (cp2[-1] == '.') /* no trailing periods */
10129 /* Now add the filename */
10130 while (*cp1) *cp2++ = *cp1++;
10132 /* Now append it to the original VMS spec. */
10133 strcpy (cp, Local);
10135 /* If we put a [000000] in the filename, try to open it first. If this fails,
10136 remove the [000000], and return that name. This provides flexibility
10137 to the user in that they can use both rooted and non-rooted logical names
10138 to point to the location of the file. */
10140 if (check_filename_before_returning) {
10141 f = open (fname, O_RDONLY, 0666);
10143 /* The file name is OK as it is, so return it as is. */
10147 /* The filename did not work. Try to remove the [000000] from the name,
10149 cp = index (fname, '[');
10150 cp2 = index (fname, ']') + 1;
10151 strcpy (cp, cp2); /* this gets rid of it */
10159 /* These are the read/write replacement routines for
10160 VAX-11 "C". They make read/write behave enough
10161 like their UNIX counterparts that CCCP will work */
10164 read (fd, buf, size)
10169 #undef read /* Get back the REAL read routine */
10171 register int total = 0;
10173 /* Read until the buffer is exhausted */
10175 /* Limit each read to 32KB */
10176 i = (size > (32*1024)) ? (32*1024) : size;
10177 i = read (fd, buf, i);
10179 if (i == 0) return (total);
10182 /* Account for this read */
10191 write (fd, buf, size)
10196 #undef write /* Get back the REAL write routine */
10200 /* Limit individual writes to 32Kb */
10203 j = (i > (32*1024)) ? (32*1024) : i;
10204 if (write (fd, buf, j) < 0) return (-1);
10205 /* Account for the data written */
10212 /* The following wrapper functions supply additional arguments to the VMS
10213 I/O routines to optimize performance with file handling. The arguments
10215 "mbc=16" - Set multi-block count to 16 (use a 8192 byte buffer).
10216 "deq=64" - When extending the file, extend it in chunks of 32Kbytes.
10217 "fop=tef"- Truncate unused portions of file when closing file.
10218 "shr=nil"- Disallow file sharing while file is open. */
10221 freopen (fname, type, oldfile)
10226 #undef freopen /* Get back the REAL fopen routine */
10227 if (strcmp (type, "w") == 0)
10228 return freopen (fname, type, oldfile, "mbc=16", "deq=64", "fop=tef", "shr=nil");
10229 return freopen (fname, type, oldfile, "mbc=16");
10233 fopen (fname, type)
10237 #undef fopen /* Get back the REAL fopen routine */
10238 /* The gcc-vms-1.42 distribution's header files prototype fopen with two
10239 fixed arguments, which matches ANSI's specification but not VAXCRTL's
10240 pre-ANSI implementation. This hack circumvents the mismatch problem. */
10241 FILE *(*vmslib_fopen)() = (FILE *(*)()) fopen;
10244 return (*vmslib_fopen) (fname, type, "mbc=32",
10245 "deq=64", "fop=tef", "shr=nil");
10247 return (*vmslib_fopen) (fname, type, "mbc=32");
10251 open (fname, flags, prot)
10256 #undef open /* Get back the REAL open routine */
10257 return open (fname, flags, prot, "mbc=16", "deq=64", "fop=tef");
10260 /* more VMS hackery */
10264 extern unsigned long sys$parse(), sys$search();
10266 /* Work around another library bug. If a file is located via a searchlist,
10267 and if the device it's on is not the same device as the one specified
10268 in the first element of that searchlist, then both stat() and fstat()
10269 will fail to return info about it. `errno' will be set to EVMSERR, and
10270 `vaxc$errno' will be set to SS$_NORMAL due yet another bug in stat()!
10271 We can get around this by fully parsing the filename and then passing
10272 that absolute name to stat().
10274 Without this fix, we can end up failing to find header files, which is
10275 bad enough, but then compounding the problem by reporting the reason for
10276 failure as "normal successful completion." */
10278 #undef fstat /* get back to library version */
10281 VMS_fstat (fd, statbuf)
10283 struct stat *statbuf;
10285 int result = fstat (fd, statbuf);
10290 char nambuf[NAM$C_MAXRSS+1];
10292 if ((fp = fdopen (fd, "r")) != 0 && fgetname (fp, nambuf) != 0)
10293 result = VMS_stat (nambuf, statbuf);
10294 /* No fclose(fp) here; that would close(fd) as well. */
10301 VMS_stat (name, statbuf)
10303 struct stat *statbuf;
10305 int result = stat (name, statbuf);
10311 char exp_nam[NAM$C_MAXRSS+1], /* expanded name buffer for sys$parse */
10312 res_nam[NAM$C_MAXRSS+1]; /* resultant name buffer for sys$search */
10315 fab.fab$l_fna = (char *) name;
10316 fab.fab$b_fns = (unsigned char) strlen (name);
10317 fab.fab$l_nam = (void *) &nam;
10319 nam.nam$l_esa = exp_nam, nam.nam$b_ess = sizeof exp_nam - 1;
10320 nam.nam$l_rsa = res_nam, nam.nam$b_rss = sizeof res_nam - 1;
10321 nam.nam$b_nop = NAM$M_PWD | NAM$M_NOCONCEAL;
10322 if (sys$parse (&fab) & 1)
10324 if (sys$search (&fab) & 1)
10326 res_nam[nam.nam$b_rsl] = '\0';
10327 result = stat (res_nam, statbuf);
10329 /* Clean up searchlist context cached by the system. */
10330 nam.nam$b_nop = NAM$M_SYNCHK;
10331 fab.fab$l_fna = 0, fab.fab$b_fns = 0;
10332 (void) sys$parse (&fab);