1 /* C Compatible Compiler Preprocessor (CCCP)
2 Copyright (C) 1986, 87, 89, 92, 93, 94, 1995 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"
47 #ifndef LOCAL_INCLUDE_DIR
48 #define LOCAL_INCLUDE_DIR "/usr/local/include"
51 #if 0 /* We can't get ptrdiff_t, so I arranged not to need PTR_INT_TYPE. */
53 #define PTR_INT_TYPE ptrdiff_t
55 #define PTR_INT_TYPE long
61 /* By default, colon separates directories in a path. */
62 #ifndef PATH_SEPARATOR
63 #define PATH_SEPARATOR ':'
66 #include <sys/types.h>
72 /* The following symbols should be autoconfigured:
79 In the mean time, we'll get by with approximations based
80 on existing GCC configuration symbols. */
83 # ifndef HAVE_STDLIB_H
84 # define HAVE_STDLIB_H 1
86 # ifndef HAVE_UNISTD_H
87 # define HAVE_UNISTD_H 1
90 # define STDC_HEADERS 1
92 #endif /* defined (POSIX) */
94 #if defined (POSIX) || (defined (USG) && !defined (VMS))
96 # define HAVE_FCNTL_H 1
103 # if TIME_WITH_SYS_TIME
104 # include <sys/time.h>
108 # include <sys/time.h>
113 # include <sys/resource.h>
120 /* This defines "errno" properly for VMS, and gives us EACCES. */
132 # define bcmp(a, b, n) memcmp (a, b, n)
135 # define bcopy(s, d, n) memcpy (d, s, n)
138 # define bzero(d, n) memset (d, 0, n)
140 #else /* !STDC_HEADERS */
144 # if !defined (BSTRING) && (defined (USG) || defined (VMS))
147 # define bcmp my_bcmp
160 # endif /* !defined (bcmp) */
163 # define bcopy my_bcopy
173 # endif /* !defined (bcopy) */
176 # define bzero my_bzero
180 register unsigned length;
185 # endif /* !defined (bzero) */
187 # endif /* !defined (BSTRING) && (defined (USG) || defined (VMS)) */
188 #endif /* ! STDC_HEADERS */
190 #if __GNUC__ < 2 || (__GNUC__ == 2 && __GNUC_MINOR__ < 6)
191 # define __attribute__(x)
195 # if defined (USE_PROTOTYPES) ? USE_PROTOTYPES : defined (__STDC__)
196 # define PROTO(ARGS) ARGS
198 # define PROTO(ARGS) ()
202 #if defined (__STDC__) && defined (HAVE_VPRINTF)
204 # define VA_START(va_list, var) va_start (va_list, var)
205 # define PRINTF_ALIST(msg) char *msg, ...
206 # define PRINTF_DCL(msg)
207 # define PRINTF_PROTO(ARGS, m, n) PROTO (ARGS) __attribute__ ((format (printf, m, n)))
209 # include <varargs.h>
210 # define VA_START(va_list, var) va_start (va_list)
211 # define PRINTF_ALIST(msg) msg, va_alist
212 # define PRINTF_DCL(msg) char *msg; va_dcl
213 # define PRINTF_PROTO(ARGS, m, n) () __attribute__ ((format (printf, m, n)))
214 # define vfprintf(file, msg, args) \
216 char *a0 = va_arg(args, char *); \
217 char *a1 = va_arg(args, char *); \
218 char *a2 = va_arg(args, char *); \
219 char *a3 = va_arg(args, char *); \
220 fprintf (file, msg, a0, a1, a2, a3); \
224 #define PRINTF_PROTO_1(ARGS) PRINTF_PROTO(ARGS, 1, 2)
225 #define PRINTF_PROTO_2(ARGS) PRINTF_PROTO(ARGS, 2, 3)
226 #define PRINTF_PROTO_3(ARGS) PRINTF_PROTO(ARGS, 3, 4)
232 /* VMS-specific definitions */
235 #define O_RDONLY 0 /* Open arg for Read/Only */
236 #define O_WRONLY 1 /* Open arg for Write/Only */
237 #define read(fd,buf,size) VMS_read (fd,buf,size)
238 #define write(fd,buf,size) VMS_write (fd,buf,size)
239 #define open(fname,mode,prot) VMS_open (fname,mode,prot)
240 #define fopen(fname,mode) VMS_fopen (fname,mode)
241 #define freopen(fname,mode,ofile) VMS_freopen (fname,mode,ofile)
242 #define strncat(dst,src,cnt) VMS_strncat (dst,src,cnt)
243 #define fstat(fd,stbuf) VMS_fstat (fd,stbuf)
244 static int VMS_fstat (), VMS_stat ();
245 static char * VMS_strncat ();
246 static int VMS_read ();
247 static int VMS_write ();
248 static int VMS_open ();
249 static FILE * VMS_fopen ();
250 static FILE * VMS_freopen ();
251 static void hack_vms_include_specification ();
252 typedef struct { unsigned :16, :16, :16; } vms_ino_t;
253 #define ino_t vms_ino_t
254 #define INCLUDE_LEN_FUDGE 10 /* leave room for VMS syntax conversion */
256 #define BSTRING /* VMS/GCC supplies the bstring routines */
257 #endif /* __GNUC__ */
266 #define MIN(X,Y) ((X) < (Y) ? (X) : (Y))
267 #define MAX(X,Y) ((X) > (Y) ? (X) : (Y))
269 /* Find the largest host integer type and set its size and type. */
271 #ifndef HOST_BITS_PER_WIDE_INT
273 #if HOST_BITS_PER_LONG > HOST_BITS_PER_INT
274 #define HOST_BITS_PER_WIDE_INT HOST_BITS_PER_LONG
275 #define HOST_WIDE_INT long
277 #define HOST_BITS_PER_WIDE_INT HOST_BITS_PER_INT
278 #define HOST_WIDE_INT int
284 #define S_ISREG(m) (((m) & S_IFMT) == S_IFREG)
288 #define S_ISDIR(m) (((m) & S_IFMT) == S_IFDIR)
291 /* Define a generic NULL if one hasn't already been defined. */
298 #if defined (USE_PROTOTYPES) ? USE_PROTOTYPES : defined (__STDC__)
299 #define GENERIC_PTR void *
301 #define GENERIC_PTR char *
306 #define NULL_PTR ((GENERIC_PTR)0)
309 #ifndef INCLUDE_LEN_FUDGE
310 #define INCLUDE_LEN_FUDGE 0
313 /* External declarations. */
315 extern char *version_string;
317 #ifndef HAVE_STRERROR
320 extern const char *const sys_errlist[];
322 extern char *sys_errlist[];
324 #else /* HAVE_STRERROR */
328 char *strerror (int,...);
330 int parse_escape PROTO((char **));
331 HOST_WIDE_INT parse_c_expression PROTO((char *));
337 /* Name under which this program was invoked. */
339 static char *progname;
341 /* Nonzero means use extra default include directories for C++. */
343 static int cplusplus;
345 /* Nonzero means handle cplusplus style comments */
347 static int cplusplus_comments;
349 /* Nonzero means handle #import, for objective C. */
353 /* Nonzero means this is an assembly file, and allow
354 unknown directives, which could be comments. */
358 /* Current maximum length of directory names in the search path
359 for include files. (Altered as we get more of them.) */
361 static int max_include_len;
363 /* Nonzero means turn NOTREACHED into #pragma NOTREACHED etc */
365 static int for_lint = 0;
367 /* Nonzero means copy comments into the output file. */
369 static int put_out_comments = 0;
371 /* Nonzero means don't process the ANSI trigraph sequences. */
373 static int no_trigraphs = 0;
375 /* Nonzero means print the names of included files rather than
376 the preprocessed output. 1 means just the #include "...",
377 2 means #include <...> as well. */
379 static int print_deps = 0;
381 /* Nonzero if missing .h files in -M output are assumed to be generated
382 files and not errors. */
384 static int print_deps_missing_files = 0;
386 /* Nonzero means print names of header files (-H). */
388 static int print_include_names = 0;
390 /* Nonzero means don't output line number information. */
392 static int no_line_directives;
394 /* Nonzero means output the text in failing conditionals,
395 inside #failed ... #endfailed. */
397 static int output_conditionals;
399 /* dump_only means inhibit output of the preprocessed text
400 and instead output the definitions of all user-defined
401 macros in a form suitable for use as input to cccp.
402 dump_names means pass #define and the macro name through to output.
403 dump_definitions means pass the whole definition (plus #define) through
406 static enum {dump_none, dump_only, dump_names, dump_definitions}
407 dump_macros = dump_none;
409 /* Nonzero means pass all #define and #undef directives which we actually
410 process through to the output stream. This feature is used primarily
411 to allow cc1 to record the #defines and #undefs for the sake of
412 debuggers which understand about preprocessor macros, but it may
413 also be useful with -E to figure out how symbols are defined, and
414 where they are defined. */
415 static int debug_output = 0;
417 /* Nonzero indicates special processing used by the pcp program. The
418 special effects of this mode are:
420 Inhibit all macro expansion, except those inside #if directives.
422 Process #define directives normally, and output their contents
425 Output preconditions to pcp_outfile indicating all the relevant
426 preconditions for use of this file in a later cpp run.
428 static FILE *pcp_outfile;
430 /* Nonzero means we are inside an IF during a -pcp run. In this mode
431 macro expansion is done, and preconditions are output for all macro
432 uses requiring them. */
433 static int pcp_inside_if;
435 /* Nonzero means never to include precompiled files.
436 This is 1 since there's no way now to make precompiled files,
437 so it's not worth testing for them. */
438 static int no_precomp = 1;
440 /* Nonzero means give all the error messages the ANSI standard requires. */
444 /* Nonzero means try to make failure to fit ANSI C an error. */
446 static int pedantic_errors;
448 /* Nonzero means don't print warning messages. -w. */
450 static int inhibit_warnings = 0;
452 /* Nonzero means warn if slash-star appears in a comment. */
454 static int warn_comments;
456 /* Nonzero means warn if a macro argument is (or would be)
457 stringified with -traditional. */
459 static int warn_stringify;
461 /* Nonzero means warn if there are any trigraphs. */
463 static int warn_trigraphs;
465 /* Nonzero means warn if #import is used. */
467 static int warn_import = 1;
469 /* Nonzero means turn warnings into errors. */
471 static int warnings_are_errors;
473 /* Nonzero means try to imitate old fashioned non-ANSI preprocessor. */
477 /* Nonzero causes output not to be done,
478 but directives such as #define that have side effects
481 static int no_output;
483 /* Nonzero means this file was included with a -imacros or -include
484 command line and should not be recorded as an include file. */
486 static int no_record_file;
488 /* Nonzero means that we have finished processing the command line options.
489 This flag is used to decide whether or not to issue certain errors
492 static int done_initializing = 0;
494 /* Line where a newline was first seen in a string constant. */
496 static int multiline_string_line = 0;
498 /* I/O buffer structure.
499 The `fname' field is nonzero for source files and #include files
500 and for the dummy text used for -D and -U.
501 It is zero for rescanning results of macro expansion
502 and for expanding macro arguments. */
503 #define INPUT_STACK_MAX 400
504 static struct file_buf {
506 /* Filename specified with #line directive. */
508 /* Record where in the search path this file was found.
509 For #include_next. */
510 struct file_name_list *dir;
515 /* Macro that this level is the expansion of.
516 Included so that we can reenable the macro
517 at the end of this level. */
518 struct hashnode *macro;
519 /* Value of if_stack at start of this file.
520 Used to prohibit unmatched #endif (etc) in an include file. */
521 struct if_stack *if_stack;
522 /* Object to be freed at end of input at this level. */
524 /* True if this is a header file included using <FILENAME>. */
525 char system_header_p;
526 } instack[INPUT_STACK_MAX];
528 static int last_error_tick; /* Incremented each time we print it. */
529 static int input_file_stack_tick; /* Incremented when the status changes. */
531 /* Current nesting level of input sources.
532 `instack[indepth]' is the level currently being read. */
533 static int indepth = -1;
534 #define CHECK_DEPTH(code) \
535 if (indepth >= (INPUT_STACK_MAX - 1)) \
537 error_with_line (line_for_error (instack[indepth].lineno), \
538 "macro or `#include' recursion too deep"); \
542 /* Current depth in #include directives that use <...>. */
543 static int system_include_depth = 0;
545 typedef struct file_buf FILE_BUF;
547 /* The output buffer. Its LENGTH field is the amount of room allocated
548 for the buffer, not the number of chars actually present. To get
549 that, subtract outbuf.buf from outbuf.bufp. */
551 #define OUTBUF_SIZE 10 /* initial size of output buffer */
552 static FILE_BUF outbuf;
554 /* Grow output buffer OBUF points at
555 so it can hold at least NEEDED more chars. */
557 #define check_expand(OBUF, NEEDED) \
558 (((OBUF)->length - ((OBUF)->bufp - (OBUF)->buf) <= (NEEDED)) \
559 ? grow_outbuf ((OBUF), (NEEDED)) : 0)
561 struct file_name_list
563 struct file_name_list *next;
565 /* If the following is nonzero, it is a macro name.
566 Don't include the file again if that macro is defined. */
567 U_CHAR *control_macro;
568 /* If the following is nonzero, it is a C-language system include
570 int c_system_include_path;
571 /* Mapping of file names for this directory. */
572 struct file_name_map *name_map;
573 /* Non-zero if name_map is valid. */
577 /* #include "file" looks in source file dir, then stack. */
578 /* #include <file> just looks in the stack. */
579 /* -I directories are added to the end, then the defaults are added. */
581 static struct default_include {
582 char *fname; /* The name of the directory. */
583 int cplusplus; /* Only look here if we're compiling C++. */
584 int cxx_aware; /* Includes in this directory don't need to
585 be wrapped in extern "C" when compiling
587 } include_defaults_array[]
588 #ifdef INCLUDE_DEFAULTS
592 /* Pick up GNU C++ specific include files. */
593 { GPLUSPLUS_INCLUDE_DIR, 1, 1 },
595 /* This is the dir for fixincludes. Put it just before
596 the files that we fix. */
597 { GCC_INCLUDE_DIR, 0, 0 },
598 /* For cross-compilation, this dir name is generated
599 automatically in Makefile.in. */
600 { CROSS_INCLUDE_DIR, 0, 0 },
601 /* This is another place that the target system's headers might be. */
602 { TOOL_INCLUDE_DIR, 0, 0 },
603 #else /* not CROSS_COMPILE */
604 /* This should be /usr/local/include and should come before
605 the fixincludes-fixed header files. */
606 { LOCAL_INCLUDE_DIR, 0, 1 },
607 /* This is here ahead of GCC_INCLUDE_DIR because assert.h goes here.
608 Likewise, behind LOCAL_INCLUDE_DIR, where glibc puts its assert.h. */
609 { TOOL_INCLUDE_DIR, 0, 0 },
610 /* This is the dir for fixincludes. Put it just before
611 the files that we fix. */
612 { GCC_INCLUDE_DIR, 0, 0 },
613 /* Some systems have an extra dir of include files. */
614 #ifdef SYSTEM_INCLUDE_DIR
615 { SYSTEM_INCLUDE_DIR, 0, 0 },
617 { STANDARD_INCLUDE_DIR, 0, 0 },
618 #endif /* not CROSS_COMPILE */
621 #endif /* no INCLUDE_DEFAULTS */
623 /* The code looks at the defaults through this pointer, rather than through
624 the constant structure above. This pointer gets changed if an environment
625 variable specifies other defaults. */
626 static struct default_include *include_defaults = include_defaults_array;
628 static struct file_name_list *include = 0; /* First dir to search */
629 /* First dir to search for <file> */
630 /* This is the first element to use for #include <...>.
631 If it is 0, use the entire chain for such includes. */
632 static struct file_name_list *first_bracket_include = 0;
633 /* This is the first element in the chain that corresponds to
634 a directory of system header files. */
635 static struct file_name_list *first_system_include = 0;
636 static struct file_name_list *last_include = 0; /* Last in chain */
638 /* Chain of include directories to put at the end of the other chain. */
639 static struct file_name_list *after_include = 0;
640 static struct file_name_list *last_after_include = 0; /* Last in chain */
642 /* Chain to put at the start of the system include files. */
643 static struct file_name_list *before_system = 0;
644 static struct file_name_list *last_before_system = 0; /* Last in chain */
646 /* List of included files that contained #pragma once. */
647 static struct file_name_list *dont_repeat_files = 0;
649 /* List of other included files.
650 If ->control_macro if nonzero, the file had a #ifndef
651 around the entire contents, and ->control_macro gives the macro name. */
652 static struct file_name_list *all_include_files = 0;
654 /* Directory prefix that should replace `/usr' in the standard
655 include file directories. */
656 static char *include_prefix;
658 /* Global list of strings read in from precompiled files. This list
659 is kept in the order the strings are read in, with new strings being
660 added at the end through stringlist_tailp. We use this list to output
661 the strings at the end of the run.
663 static STRINGDEF *stringlist;
664 static STRINGDEF **stringlist_tailp = &stringlist;
667 /* Structure returned by create_definition */
668 typedef struct macrodef MACRODEF;
671 struct definition *defn;
676 enum sharp_token_type {
677 NO_SHARP_TOKEN = 0, /* token not present */
679 SHARP_TOKEN = '#', /* token spelled with # only */
680 WHITE_SHARP_TOKEN, /* token spelled with # and white space */
682 PERCENT_COLON_TOKEN = '%', /* token spelled with %: only */
683 WHITE_PERCENT_COLON_TOKEN /* token spelled with %: and white space */
686 /* Structure allocated for every #define. For a simple replacement
689 nargs = -1, the `pattern' list is null, and the expansion is just
690 the replacement text. Nargs = 0 means a functionlike macro with no args,
692 #define getchar() getc (stdin) .
693 When there are args, the expansion is the replacement text with the
694 args squashed out, and the reflist is a list describing how to
695 build the output from the input: e.g., "3 chars, then the 1st arg,
696 then 9 chars, then the 3rd arg, then 0 chars, then the 2nd arg".
697 The chars here come from the expansion. Whatever is left of the
698 expansion after the last arg-occurrence is copied after that arg.
699 Note that the reflist can be arbitrarily long---
700 its length depends on the number of times the arguments appear in
701 the replacement text, not how many args there are. Example:
702 #define f(x) x+x+x+x+x+x+x would have replacement text "++++++" and
704 { (0, 1), (1, 1), (1, 1), ..., (1, 1), NULL }
705 where (x, y) means (nchars, argno). */
707 typedef struct definition DEFINITION;
710 int length; /* length of expansion string */
711 int predefined; /* True if the macro was builtin or */
712 /* came from the command line */
714 int line; /* Line number of definition */
715 char *file; /* File of definition */
716 char rest_args; /* Nonzero if last arg. absorbs the rest */
718 struct reflist *next;
720 enum sharp_token_type stringify; /* set if a # operator before arg */
721 enum sharp_token_type raw_before; /* set if a ## operator before arg */
722 enum sharp_token_type raw_after; /* set if a ## operator after arg */
724 char rest_args; /* Nonzero if this arg. absorbs the rest */
725 int nchars; /* Number of literal chars to copy before
726 this arg occurrence. */
727 int argno; /* Number of arg to substitute (origin-0) */
730 /* Names of macro args, concatenated in reverse order
731 with comma-space between them.
732 The only use of this is that we warn on redefinition
733 if this differs between the old and new definitions. */
738 /* different kinds of things that can appear in the value field
739 of a hash node. Actually, this may be useless now. */
747 * special extension string that can be added to the last macro argument to
748 * allow it to absorb the "rest" of the arguments when expanded. Ex:
749 * #define wow(a, b...) process (b, a, b)
750 * { wow (1, 2, 3); } -> { process (2, 3, 1, 2, 3); }
751 * { wow (one, two); } -> { process (two, one, two); }
752 * if this "rest_arg" is used with the concat token '##' and if it is not
753 * supplied then the token attached to with ## will not be outputted. Ex:
754 * #define wow (a, b...) process (b ## , a, ## b)
755 * { wow (1, 2); } -> { process (2, 1, 2); }
756 * { wow (one); } -> { process (one); {
758 static char rest_extension[] = "...";
759 #define REST_EXTENSION_LENGTH (sizeof (rest_extension) - 1)
761 /* The structure of a node in the hash table. The hash table
762 has entries for all tokens defined by #define directives (type T_MACRO),
763 plus some special tokens like __LINE__ (these each have their own
764 type, and the appropriate code is run when that type of node is seen.
765 It does not contain control words like "#define", which are recognized
766 by a separate piece of code. */
768 /* different flavors of hash nodes --- also used in keyword table */
770 T_DEFINE = 1, /* the `#define' keyword */
771 T_INCLUDE, /* the `#include' keyword */
772 T_INCLUDE_NEXT, /* the `#include_next' keyword */
773 T_IMPORT, /* the `#import' keyword */
774 T_IFDEF, /* the `#ifdef' keyword */
775 T_IFNDEF, /* the `#ifndef' keyword */
776 T_IF, /* the `#if' keyword */
777 T_ELSE, /* `#else' */
778 T_PRAGMA, /* `#pragma' */
779 T_ELIF, /* `#elif' */
780 T_UNDEF, /* `#undef' */
781 T_LINE, /* `#line' */
782 T_ERROR, /* `#error' */
783 T_WARNING, /* `#warning' */
784 T_ENDIF, /* `#endif' */
785 T_SCCS, /* `#sccs', used on system V. */
786 T_IDENT, /* `#ident', used on system V. */
787 T_ASSERT, /* `#assert', taken from system V. */
788 T_UNASSERT, /* `#unassert', taken from system V. */
789 T_SPECLINE, /* special symbol `__LINE__' */
790 T_DATE, /* `__DATE__' */
791 T_FILE, /* `__FILE__' */
792 T_BASE_FILE, /* `__BASE_FILE__' */
793 T_INCLUDE_LEVEL, /* `__INCLUDE_LEVEL__' */
794 T_VERSION, /* `__VERSION__' */
795 T_SIZE_TYPE, /* `__SIZE_TYPE__' */
796 T_PTRDIFF_TYPE, /* `__PTRDIFF_TYPE__' */
797 T_WCHAR_TYPE, /* `__WCHAR_TYPE__' */
798 T_USER_LABEL_PREFIX_TYPE, /* `__USER_LABEL_PREFIX__' */
799 T_REGISTER_PREFIX_TYPE, /* `__REGISTER_PREFIX__' */
800 T_IMMEDIATE_PREFIX_TYPE, /* `__IMMEDIATE_PREFIX__' */
801 T_TIME, /* `__TIME__' */
802 T_CONST, /* Constant value, used by `__STDC__' */
803 T_MACRO, /* macro defined by `#define' */
804 T_DISABLED, /* macro temporarily turned off for rescan */
805 T_SPEC_DEFINED, /* special `defined' macro for use in #if statements */
806 T_PCSTRING, /* precompiled string (hashval is KEYDEF *) */
807 T_UNUSED /* Used for something not defined. */
811 struct hashnode *next; /* double links for easy deletion */
812 struct hashnode *prev;
813 struct hashnode **bucket_hdr; /* also, a back pointer to this node's hash
814 chain is kept, in case the node is the head
815 of the chain and gets deleted. */
816 enum node_type type; /* type of special token */
817 int length; /* length of token, for quick comparison */
818 U_CHAR *name; /* the actual name */
819 union hashval value; /* pointer to expansion, or whatever */
822 typedef struct hashnode HASHNODE;
824 /* Some definitions for the hash table. The hash function MUST be
825 computed as shown in hashf () below. That is because the rescan
826 loop computes the hash value `on the fly' for most tokens,
827 in order to avoid the overhead of a lot of procedure calls to
828 the hashf () function. Hashf () only exists for the sake of
829 politeness, for use when speed isn't so important. */
831 #define HASHSIZE 1403
832 static HASHNODE *hashtab[HASHSIZE];
833 #define HASHSTEP(old, c) ((old << 2) + c)
834 #define MAKE_POS(v) (v & 0x7fffffff) /* make number positive */
836 /* Symbols to predefine. */
838 #ifdef CPP_PREDEFINES
839 static char *predefs = CPP_PREDEFINES;
841 static char *predefs = "";
844 /* We let tm.h override the types used here, to handle trivial differences
845 such as the choice of unsigned int or long unsigned int for size_t.
846 When machines start needing nontrivial differences in the size type,
847 it would be best to do something here to figure out automatically
848 from other information what type to use. */
850 /* The string value for __SIZE_TYPE__. */
853 #define SIZE_TYPE "long unsigned int"
856 /* The string value for __PTRDIFF_TYPE__. */
859 #define PTRDIFF_TYPE "long int"
862 /* The string value for __WCHAR_TYPE__. */
865 #define WCHAR_TYPE "int"
867 char * wchar_type = WCHAR_TYPE;
870 /* The string value for __USER_LABEL_PREFIX__ */
872 #ifndef USER_LABEL_PREFIX
873 #define USER_LABEL_PREFIX ""
876 /* The string value for __REGISTER_PREFIX__ */
878 #ifndef REGISTER_PREFIX
879 #define REGISTER_PREFIX ""
882 /* The string value for __IMMEDIATE_PREFIX__ */
884 #ifndef IMMEDIATE_PREFIX
885 #define IMMEDIATE_PREFIX ""
888 /* In the definition of a #assert name, this structure forms
889 a list of the individual values asserted.
890 Each value is itself a list of "tokens".
891 These are strings that are compared by name. */
893 struct tokenlist_list {
894 struct tokenlist_list *next;
895 struct arglist *tokens;
898 struct assertion_hashnode {
899 struct assertion_hashnode *next; /* double links for easy deletion */
900 struct assertion_hashnode *prev;
901 /* also, a back pointer to this node's hash
902 chain is kept, in case the node is the head
903 of the chain and gets deleted. */
904 struct assertion_hashnode **bucket_hdr;
905 int length; /* length of token, for quick comparison */
906 U_CHAR *name; /* the actual name */
907 /* List of token-sequences. */
908 struct tokenlist_list *value;
911 typedef struct assertion_hashnode ASSERTION_HASHNODE;
913 /* Some definitions for the hash table. The hash function MUST be
914 computed as shown in hashf below. That is because the rescan
915 loop computes the hash value `on the fly' for most tokens,
916 in order to avoid the overhead of a lot of procedure calls to
917 the hashf function. hashf only exists for the sake of
918 politeness, for use when speed isn't so important. */
920 #define ASSERTION_HASHSIZE 37
921 static ASSERTION_HASHNODE *assertion_hashtab[ASSERTION_HASHSIZE];
923 /* Nonzero means inhibit macroexpansion of what seem to be
924 assertion tests, in rescan. For #if. */
925 static int assertions_flag;
927 /* `struct directive' defines one #-directive, including how to handle it. */
929 #define DO_PROTO PROTO((U_CHAR *, U_CHAR *, FILE_BUF *, struct directive *))
932 int length; /* Length of name */
933 int (*func) DO_PROTO; /* Function to handle directive */
934 char *name; /* Name of directive */
935 enum node_type type; /* Code which describes which directive. */
936 char angle_brackets; /* Nonzero => <...> is special. */
937 char traditional_comments; /* Nonzero: keep comments if -traditional. */
938 char pass_thru; /* Copy preprocessed directive to output file. */
941 /* These functions are declared to return int instead of void since they
942 are going to be placed in the table and some old compilers have trouble with
943 pointers to functions returning void. */
945 static int do_assert DO_PROTO;
946 static int do_define DO_PROTO;
947 static int do_elif DO_PROTO;
948 static int do_else DO_PROTO;
949 static int do_endif DO_PROTO;
950 static int do_error DO_PROTO;
951 static int do_ident DO_PROTO;
952 static int do_if DO_PROTO;
953 static int do_include DO_PROTO;
954 static int do_line DO_PROTO;
955 static int do_pragma DO_PROTO;
956 #ifdef SCCS_DIRECTIVE
957 static int do_sccs DO_PROTO;
959 static int do_unassert DO_PROTO;
960 static int do_undef DO_PROTO;
961 static int do_warning DO_PROTO;
962 static int do_xifdef DO_PROTO;
964 /* Here is the actual list of #-directives, most-often-used first. */
966 static struct directive directive_table[] = {
967 { 6, do_define, "define", T_DEFINE, 0, 1},
968 { 2, do_if, "if", T_IF},
969 { 5, do_xifdef, "ifdef", T_IFDEF},
970 { 6, do_xifdef, "ifndef", T_IFNDEF},
971 { 5, do_endif, "endif", T_ENDIF},
972 { 4, do_else, "else", T_ELSE},
973 { 4, do_elif, "elif", T_ELIF},
974 { 4, do_line, "line", T_LINE},
975 { 7, do_include, "include", T_INCLUDE, 1},
976 { 12, do_include, "include_next", T_INCLUDE_NEXT, 1},
977 { 6, do_include, "import", T_IMPORT, 1},
978 { 5, do_undef, "undef", T_UNDEF},
979 { 5, do_error, "error", T_ERROR},
980 { 7, do_warning, "warning", T_WARNING},
981 #ifdef SCCS_DIRECTIVE
982 { 4, do_sccs, "sccs", T_SCCS},
984 { 6, do_pragma, "pragma", T_PRAGMA, 0, 0, 1},
985 { 5, do_ident, "ident", T_IDENT},
986 { 6, do_assert, "assert", T_ASSERT},
987 { 8, do_unassert, "unassert", T_UNASSERT},
988 { -1, 0, "", T_UNUSED},
991 /* When a directive handler is called,
992 this points to the # (or the : of the %:) that started the directive. */
993 U_CHAR *directive_start;
995 /* table to tell if char can be part of a C identifier. */
996 U_CHAR is_idchar[256];
997 /* table to tell if char can be first char of a c identifier. */
998 U_CHAR is_idstart[256];
999 /* table to tell if c is horizontal space. */
1000 U_CHAR is_hor_space[256];
1001 /* table to tell if c is horizontal or vertical space. */
1002 static U_CHAR is_space[256];
1003 /* names of some characters */
1004 static char *char_name[256];
1006 #define SKIP_WHITE_SPACE(p) do { while (is_hor_space[*p]) p++; } while (0)
1007 #define SKIP_ALL_WHITE_SPACE(p) do { while (is_space[*p]) p++; } while (0)
1009 static int errors = 0; /* Error counter for exit code */
1011 /* Name of output file, for error messages. */
1012 static char *out_fname;
1014 /* Zero means dollar signs are punctuation.
1015 -$ stores 0; -traditional may store 1. Default is 1 for VMS, 0 otherwise.
1016 This must be 0 for correct processing of this ANSI C program:
1018 #define lose(b) foo (b)
1021 static int dollars_in_ident;
1022 #ifndef DOLLARS_IN_IDENTIFIERS
1023 #define DOLLARS_IN_IDENTIFIERS 1
1027 /* Stack of conditionals currently in progress
1028 (including both successful and failing conditionals). */
1031 struct if_stack *next; /* for chaining to the next stack frame */
1032 char *fname; /* copied from input when frame is made */
1033 int lineno; /* similarly */
1034 int if_succeeded; /* true if a leg of this if-group
1035 has been passed through rescan */
1036 U_CHAR *control_macro; /* For #ifndef at start of file,
1037 this is the macro name tested. */
1038 enum node_type type; /* type of last directive seen in this group */
1040 typedef struct if_stack IF_STACK_FRAME;
1041 static IF_STACK_FRAME *if_stack = NULL;
1043 /* Buffer of -M output. */
1044 static char *deps_buffer;
1046 /* Number of bytes allocated in above. */
1047 static int deps_allocated_size;
1049 /* Number of bytes used. */
1050 static int deps_size;
1052 /* Number of bytes since the last newline. */
1053 static int deps_column;
1055 /* Nonzero means -I- has been seen,
1056 so don't look for #include "foo" the source-file directory. */
1057 static int ignore_srcdir;
1059 static int safe_read PROTO((int, char *, int));
1060 static void safe_write PROTO((int, char *, int));
1062 int main PROTO((int, char **));
1064 static void path_include PROTO((char *));
1066 static U_CHAR *index0 PROTO((U_CHAR *, int, size_t));
1068 static void trigraph_pcp PROTO((FILE_BUF *));
1070 static void newline_fix PROTO((U_CHAR *));
1071 static void name_newline_fix PROTO((U_CHAR *));
1073 static char *get_lintcmd PROTO((U_CHAR *, U_CHAR *, U_CHAR **, int *, int *));
1075 static void rescan PROTO((FILE_BUF *, int));
1077 static FILE_BUF expand_to_temp_buffer PROTO((U_CHAR *, U_CHAR *, int, int));
1079 static int handle_directive PROTO((FILE_BUF *, FILE_BUF *));
1081 static struct tm *timestamp PROTO((void));
1082 static void special_symbol PROTO((HASHNODE *, FILE_BUF *));
1084 static int redundant_include_p PROTO((char *));
1085 static int is_system_include PROTO((char *));
1086 static char *skip_redundant_dir_prefix PROTO((char *));
1088 static char *read_filename_string PROTO((int, FILE *));
1089 static struct file_name_map *read_name_map PROTO((char *));
1090 static int open_include_file PROTO((char *, struct file_name_list *));
1092 static void finclude PROTO((int, char *, FILE_BUF *, int, struct file_name_list *));
1093 static void record_control_macro PROTO((char *, U_CHAR *));
1095 static int import_hash PROTO((char *));
1096 static int lookup_import PROTO((char *, struct file_name_list *));
1097 static void add_import PROTO((int, char *));
1099 static char *check_precompiled PROTO((int, char *, char **));
1100 static int check_preconditions PROTO((char *));
1101 static void pcfinclude PROTO((U_CHAR *, U_CHAR *, U_CHAR *, FILE_BUF *));
1102 static void pcstring_used PROTO((HASHNODE *));
1103 static void write_output PROTO((void));
1104 static void pass_thru_directive PROTO((U_CHAR *, U_CHAR *, FILE_BUF *, struct directive *));
1106 static MACRODEF create_definition PROTO((U_CHAR *, U_CHAR *, FILE_BUF *));
1108 static int check_macro_name PROTO((U_CHAR *, char *));
1109 static int compare_defs PROTO((DEFINITION *, DEFINITION *));
1110 static int comp_def_part PROTO((int, U_CHAR *, int, U_CHAR *, int, int));
1112 static DEFINITION *collect_expansion PROTO((U_CHAR *, U_CHAR *, int, struct arglist *));
1114 int check_assertion PROTO((U_CHAR *, int, int, struct arglist *));
1115 static int compare_token_lists PROTO((struct arglist *, struct arglist *));
1117 static struct arglist *read_token_list PROTO((U_CHAR **, U_CHAR *, int *));
1118 static void free_token_list PROTO((struct arglist *));
1120 static ASSERTION_HASHNODE *assertion_install PROTO((U_CHAR *, int, int));
1121 static ASSERTION_HASHNODE *assertion_lookup PROTO((U_CHAR *, int, int));
1122 static void delete_assertion PROTO((ASSERTION_HASHNODE *));
1124 static void do_once PROTO((void));
1126 static HOST_WIDE_INT eval_if_expression PROTO((U_CHAR *, int));
1127 static void conditional_skip PROTO((FILE_BUF *, int, enum node_type, U_CHAR *, FILE_BUF *));
1128 static void skip_if_group PROTO((FILE_BUF *, int, FILE_BUF *));
1129 static void validate_else PROTO((U_CHAR *));
1131 static U_CHAR *skip_to_end_of_comment PROTO((FILE_BUF *, int *, int));
1132 static U_CHAR *skip_quoted_string PROTO((U_CHAR *, U_CHAR *, int, int *, int *, int *));
1133 static char *quote_string PROTO((char *, char *));
1134 static U_CHAR *skip_paren_group PROTO((FILE_BUF *));
1136 /* Last arg to output_line_directive. */
1137 enum file_change_code {same_file, enter_file, leave_file};
1138 static void output_line_directive PROTO((FILE_BUF *, FILE_BUF *, int, enum file_change_code));
1140 static void macroexpand PROTO((HASHNODE *, FILE_BUF *));
1143 static char *macarg PROTO((struct argdata *, int));
1145 static U_CHAR *macarg1 PROTO((U_CHAR *, U_CHAR *, int *, int *, int *, int));
1147 static int discard_comments PROTO((U_CHAR *, int, int));
1149 static int change_newlines PROTO((U_CHAR *, int));
1151 char *my_strerror PROTO((int));
1152 void error PRINTF_PROTO_1((char *, ...));
1153 static void verror PROTO((char *, va_list));
1154 static void error_from_errno PROTO((char *));
1155 void warning PRINTF_PROTO_1((char *, ...));
1156 static void vwarning PROTO((char *, va_list));
1157 static void error_with_line PRINTF_PROTO_2((int, char *, ...));
1158 static void verror_with_line PROTO((int, char *, va_list));
1159 static void vwarning_with_line PROTO((int, char *, va_list));
1160 static void warning_with_line PROTO((int, char *, ...));
1161 void pedwarn PRINTF_PROTO_1((char *, ...));
1162 void pedwarn_with_line PRINTF_PROTO_2((int, char *, ...));
1163 static void pedwarn_with_file_and_line PRINTF_PROTO_3((char *, int, char *, ...));
1165 static void print_containing_files PROTO((void));
1167 static int line_for_error PROTO((int));
1168 static int grow_outbuf PROTO((FILE_BUF *, int));
1170 static HASHNODE *install PROTO((U_CHAR *, int, enum node_type, char *, int));
1171 HASHNODE *lookup PROTO((U_CHAR *, int, int));
1172 static void delete_macro PROTO((HASHNODE *));
1173 static int hashf PROTO((U_CHAR *, int, int));
1175 static void dump_single_macro PROTO((HASHNODE *, FILE *));
1176 static void dump_all_macros PROTO((void));
1177 static void dump_defn_1 PROTO((U_CHAR *, int, int, FILE *));
1178 static void dump_arg_n PROTO((DEFINITION *, int, FILE *));
1180 static void initialize_char_syntax PROTO((void));
1181 static void initialize_builtins PROTO((FILE_BUF *, FILE_BUF *));
1183 static void make_definition PROTO((char *, FILE_BUF *));
1184 static void make_undef PROTO((char *, FILE_BUF *));
1186 static void make_assertion PROTO((char *, char *));
1188 static void append_include_chain PROTO((struct file_name_list *, struct file_name_list *));
1190 static void deps_output PROTO((char *, int));
1192 static void fatal PRINTF_PROTO_1((char *, ...)) __attribute__ ((noreturn));
1193 void fancy_abort PROTO((void)) __attribute__ ((noreturn));
1194 static void perror_with_name PROTO((char *));
1195 static void pfatal_with_name PROTO((char *)) __attribute__ ((noreturn));
1196 static void pipe_closed PROTO((int)) __attribute__ ((noreturn));
1198 static void memory_full PROTO((void)) __attribute__ ((noreturn));
1199 GENERIC_PTR xmalloc PROTO((size_t));
1200 static GENERIC_PTR xrealloc PROTO((GENERIC_PTR, size_t));
1201 static GENERIC_PTR xcalloc PROTO((size_t, size_t));
1202 static char *savestring PROTO((char *));
1204 static int file_size_and_mode PROTO((int, int *, long int *));
1206 /* Read LEN bytes at PTR from descriptor DESC, for file FILENAME,
1207 retrying if necessary. Return a negative value if an error occurs,
1208 otherwise return the actual number of bytes read,
1209 which must be LEN unless end-of-file was reached. */
1212 safe_read (desc, ptr, len)
1219 int nchars = read (desc, ptr, left);
1236 /* Write LEN bytes at PTR to descriptor DESC,
1237 retrying if necessary, and treating any real error as fatal. */
1240 safe_write (desc, ptr, len)
1246 int written = write (desc, ptr, len);
1253 pfatal_with_name (out_fname);
1271 char **pend_files = (char **) xmalloc (argc * sizeof (char *));
1272 char **pend_defs = (char **) xmalloc (argc * sizeof (char *));
1273 char **pend_undefs = (char **) xmalloc (argc * sizeof (char *));
1274 char **pend_assertions = (char **) xmalloc (argc * sizeof (char *));
1275 char **pend_includes = (char **) xmalloc (argc * sizeof (char *));
1277 /* Record the option used with each element of pend_assertions.
1278 This is preparation for supporting more than one option for making
1280 char **pend_assertion_options = (char **) xmalloc (argc * sizeof (char *));
1281 int inhibit_predefs = 0;
1282 int no_standard_includes = 0;
1283 int no_standard_cplusplus_includes = 0;
1284 int missing_newline = 0;
1286 /* Non-0 means don't output the preprocessed program. */
1287 int inhibit_output = 0;
1288 /* Non-0 means -v, so print the full set of include dirs. */
1291 /* File name which deps are being written to.
1292 This is 0 if deps are being written to stdout. */
1293 char *deps_file = 0;
1294 /* Fopen file mode to open deps_file with. */
1295 char *deps_mode = "a";
1296 /* Stream on which to print the dependency information. */
1297 FILE *deps_stream = 0;
1298 /* Target-name to write with the dependency information. */
1299 char *deps_target = 0;
1302 /* Get rid of any avoidable limit on stack size. */
1306 /* Set the stack limit huge so that alloca (particularly stringtab
1307 * in dbxread.c) does not fail. */
1308 getrlimit (RLIMIT_STACK, &rlim);
1309 rlim.rlim_cur = rlim.rlim_max;
1310 setrlimit (RLIMIT_STACK, &rlim);
1312 #endif /* RLIMIT_STACK defined */
1315 signal (SIGPIPE, pipe_closed);
1318 cp = argv[0] + strlen (argv[0]);
1319 while (cp != argv[0] && cp[-1] != '/'
1320 #ifdef DIR_SEPARATOR
1321 && cp[-1] != DIR_SEPARATOR
1329 /* Remove directories from PROGNAME. */
1333 if ((p = rindex (s, ':')) != 0) s = p + 1; /* skip device */
1334 if ((p = rindex (s, ']')) != 0) s = p + 1; /* skip directory */
1335 if ((p = rindex (s, '>')) != 0) s = p + 1; /* alternate (int'n'l) dir */
1336 s = progname = savestring (s);
1337 if ((p = rindex (s, ';')) != 0) *p = '\0'; /* strip version number */
1338 if ((p = rindex (s, '.')) != 0 /* strip type iff ".exe" */
1339 && (p[1] == 'e' || p[1] == 'E')
1340 && (p[2] == 'x' || p[2] == 'X')
1341 && (p[3] == 'e' || p[3] == 'E')
1350 /* Initialize is_idchar to allow $. */
1351 dollars_in_ident = 1;
1352 initialize_char_syntax ();
1353 dollars_in_ident = DOLLARS_IN_IDENTIFIERS > 0;
1355 no_line_directives = 0;
1357 dump_macros = dump_none;
1360 cplusplus_comments = 1;
1362 bzero ((char *) pend_files, argc * sizeof (char *));
1363 bzero ((char *) pend_defs, argc * sizeof (char *));
1364 bzero ((char *) pend_undefs, argc * sizeof (char *));
1365 bzero ((char *) pend_assertions, argc * sizeof (char *));
1366 bzero ((char *) pend_includes, argc * sizeof (char *));
1368 /* Process switches and find input file name. */
1370 for (i = 1; i < argc; i++) {
1371 if (argv[i][0] != '-') {
1372 if (out_fname != NULL)
1373 fatal ("Usage: %s [switches] input output", argv[0]);
1374 else if (in_fname != NULL)
1375 out_fname = argv[i];
1379 switch (argv[i][1]) {
1382 if (!strcmp (argv[i], "-include")) {
1384 fatal ("Filename missing after `-include' option");
1386 pend_includes[i] = argv[i+1], i++;
1388 if (!strcmp (argv[i], "-imacros")) {
1390 fatal ("Filename missing after `-imacros' option");
1392 pend_files[i] = argv[i+1], i++;
1394 if (!strcmp (argv[i], "-iprefix")) {
1396 fatal ("Filename missing after `-iprefix' option");
1398 include_prefix = argv[++i];
1400 if (!strcmp (argv[i], "-ifoutput")) {
1401 output_conditionals = 1;
1403 if (!strcmp (argv[i], "-isystem")) {
1404 struct file_name_list *dirtmp;
1407 fatal ("Filename missing after `-isystem' option");
1409 dirtmp = (struct file_name_list *)
1410 xmalloc (sizeof (struct file_name_list));
1412 dirtmp->control_macro = 0;
1413 dirtmp->c_system_include_path = 1;
1414 dirtmp->fname = xmalloc (strlen (argv[i+1]) + 1);
1415 strcpy (dirtmp->fname, argv[++i]);
1416 dirtmp->got_name_map = 0;
1418 if (before_system == 0)
1419 before_system = dirtmp;
1421 last_before_system->next = dirtmp;
1422 last_before_system = dirtmp; /* Tail follows the last one */
1424 /* Add directory to end of path for includes,
1425 with the default prefix at the front of its name. */
1426 if (!strcmp (argv[i], "-iwithprefix")) {
1427 struct file_name_list *dirtmp;
1430 if (include_prefix != 0)
1431 prefix = include_prefix;
1433 prefix = savestring (GCC_INCLUDE_DIR);
1434 /* Remove the `include' from /usr/local/lib/gcc.../include. */
1435 if (!strcmp (prefix + strlen (prefix) - 8, "/include"))
1436 prefix[strlen (prefix) - 7] = 0;
1439 dirtmp = (struct file_name_list *)
1440 xmalloc (sizeof (struct file_name_list));
1441 dirtmp->next = 0; /* New one goes on the end */
1442 dirtmp->control_macro = 0;
1443 dirtmp->c_system_include_path = 0;
1445 fatal ("Directory name missing after `-iwithprefix' option");
1447 dirtmp->fname = xmalloc (strlen (argv[i+1]) + strlen (prefix) + 1);
1448 strcpy (dirtmp->fname, prefix);
1449 strcat (dirtmp->fname, argv[++i]);
1450 dirtmp->got_name_map = 0;
1452 if (after_include == 0)
1453 after_include = dirtmp;
1455 last_after_include->next = dirtmp;
1456 last_after_include = dirtmp; /* Tail follows the last one */
1458 /* Add directory to main path for includes,
1459 with the default prefix at the front of its name. */
1460 if (!strcmp (argv[i], "-iwithprefixbefore")) {
1461 struct file_name_list *dirtmp;
1464 if (include_prefix != 0)
1465 prefix = include_prefix;
1467 prefix = savestring (GCC_INCLUDE_DIR);
1468 /* Remove the `include' from /usr/local/lib/gcc.../include. */
1469 if (!strcmp (prefix + strlen (prefix) - 8, "/include"))
1470 prefix[strlen (prefix) - 7] = 0;
1473 dirtmp = (struct file_name_list *)
1474 xmalloc (sizeof (struct file_name_list));
1475 dirtmp->next = 0; /* New one goes on the end */
1476 dirtmp->control_macro = 0;
1477 dirtmp->c_system_include_path = 0;
1479 fatal ("Directory name missing after `-iwithprefixbefore' option");
1481 dirtmp->fname = xmalloc (strlen (argv[i+1]) + strlen (prefix) + 1);
1482 strcpy (dirtmp->fname, prefix);
1483 strcat (dirtmp->fname, argv[++i]);
1484 dirtmp->got_name_map = 0;
1486 append_include_chain (dirtmp, dirtmp);
1488 /* Add directory to end of path for includes. */
1489 if (!strcmp (argv[i], "-idirafter")) {
1490 struct file_name_list *dirtmp;
1492 dirtmp = (struct file_name_list *)
1493 xmalloc (sizeof (struct file_name_list));
1494 dirtmp->next = 0; /* New one goes on the end */
1495 dirtmp->control_macro = 0;
1496 dirtmp->c_system_include_path = 0;
1498 fatal ("Directory name missing after `-idirafter' option");
1500 dirtmp->fname = argv[++i];
1501 dirtmp->got_name_map = 0;
1503 if (after_include == 0)
1504 after_include = dirtmp;
1506 last_after_include->next = dirtmp;
1507 last_after_include = dirtmp; /* Tail follows the last one */
1512 if (out_fname != NULL)
1513 fatal ("Output filename specified twice");
1515 fatal ("Filename missing after -o option");
1516 out_fname = argv[++i];
1517 if (!strcmp (out_fname, "-"))
1522 if (!strcmp (argv[i], "-pedantic"))
1524 else if (!strcmp (argv[i], "-pedantic-errors")) {
1526 pedantic_errors = 1;
1527 } else if (!strcmp (argv[i], "-pcp")) {
1530 fatal ("Filename missing after -pcp option");
1531 pcp_fname = argv[++i];
1533 ((pcp_fname[0] != '-' || pcp_fname[1] != '\0')
1534 ? fopen (pcp_fname, "w")
1536 if (pcp_outfile == 0)
1537 pfatal_with_name (pcp_fname);
1543 if (!strcmp (argv[i], "-traditional")) {
1545 cplusplus_comments = 0;
1546 if (dollars_in_ident > 0)
1547 dollars_in_ident = 1;
1548 } else if (!strcmp (argv[i], "-trigraphs")) {
1554 if (! strcmp (argv[i], "-lang-c"))
1555 cplusplus = 0, cplusplus_comments = 1, objc = 0;
1556 if (! strcmp (argv[i], "-lang-c89"))
1557 cplusplus = 0, cplusplus_comments = 0, objc = 0;
1558 if (! strcmp (argv[i], "-lang-c++"))
1559 cplusplus = 1, cplusplus_comments = 1, objc = 0;
1560 if (! strcmp (argv[i], "-lang-objc"))
1561 objc = 1, cplusplus = 0, cplusplus_comments = 1;
1562 if (! strcmp (argv[i], "-lang-objc++"))
1563 objc = 1, cplusplus = 1, cplusplus_comments = 1;
1564 if (! strcmp (argv[i], "-lang-asm"))
1566 if (! strcmp (argv[i], "-lint"))
1571 cplusplus = 1, cplusplus_comments = 1;
1575 inhibit_warnings = 1;
1579 if (!strcmp (argv[i], "-Wtrigraphs"))
1581 else if (!strcmp (argv[i], "-Wno-trigraphs"))
1583 else if (!strcmp (argv[i], "-Wcomment"))
1585 else if (!strcmp (argv[i], "-Wno-comment"))
1587 else if (!strcmp (argv[i], "-Wcomments"))
1589 else if (!strcmp (argv[i], "-Wno-comments"))
1591 else if (!strcmp (argv[i], "-Wtraditional"))
1593 else if (!strcmp (argv[i], "-Wno-traditional"))
1595 else if (!strcmp (argv[i], "-Wimport"))
1597 else if (!strcmp (argv[i], "-Wno-import"))
1599 else if (!strcmp (argv[i], "-Werror"))
1600 warnings_are_errors = 1;
1601 else if (!strcmp (argv[i], "-Wno-error"))
1602 warnings_are_errors = 0;
1603 else if (!strcmp (argv[i], "-Wall"))
1611 /* The style of the choices here is a bit mixed.
1612 The chosen scheme is a hybrid of keeping all options in one string
1613 and specifying each option in a separate argument:
1614 -M|-MM|-MD file|-MMD file [-MG]. An alternative is:
1615 -M|-MM|-MD file|-MMD file|-MG|-MMG; or more concisely:
1616 -M[M][G][D file]. This is awkward to handle in specs, and is not
1618 /* ??? -MG must be specified in addition to one of -M or -MM.
1619 This can be relaxed in the future without breaking anything.
1620 The converse isn't true. */
1622 /* -MG isn't valid with -MD or -MMD. This is checked for later. */
1623 if (!strcmp (argv[i], "-MG"))
1625 print_deps_missing_files = 1;
1628 if (!strcmp (argv[i], "-M"))
1630 else if (!strcmp (argv[i], "-MM"))
1632 else if (!strcmp (argv[i], "-MD"))
1634 else if (!strcmp (argv[i], "-MMD"))
1636 /* For -MD and -MMD options, write deps on file named by next arg. */
1637 if (!strcmp (argv[i], "-MD")
1638 || !strcmp (argv[i], "-MMD")) {
1640 fatal ("Filename missing after %s option", argv[i]);
1642 deps_file = argv[i];
1645 /* For -M and -MM, write deps on standard output
1646 and suppress the usual output. */
1647 deps_stream = stdout;
1654 char *p = argv[i] + 2;
1656 while ((c = *p++)) {
1657 /* Arg to -d specifies what parts of macros to dump */
1660 dump_macros = dump_only;
1664 dump_macros = dump_names;
1667 dump_macros = dump_definitions;
1675 if (argv[i][2] == '3')
1680 fprintf (stderr, "GNU CPP version %s", version_string);
1681 #ifdef TARGET_VERSION
1684 fprintf (stderr, "\n");
1689 print_include_names = 1;
1693 if (argv[i][2] != 0)
1694 pend_defs[i] = argv[i] + 2;
1695 else if (i + 1 == argc)
1696 fatal ("Macro name missing after -D option");
1698 i++, pend_defs[i] = argv[i];
1705 if (argv[i][2] != 0)
1707 else if (i + 1 == argc)
1708 fatal ("Assertion missing after -A option");
1712 if (!strcmp (p, "-")) {
1713 /* -A- eliminates all predefined macros and assertions.
1714 Let's include also any that were specified earlier
1715 on the command line. That way we can get rid of any
1716 that were passed automatically in from GCC. */
1718 inhibit_predefs = 1;
1719 for (j = 0; j < i; j++)
1720 pend_defs[j] = pend_assertions[j] = 0;
1722 pend_assertions[i] = p;
1723 pend_assertion_options[i] = "-A";
1728 case 'U': /* JF #undef something */
1729 if (argv[i][2] != 0)
1730 pend_undefs[i] = argv[i] + 2;
1731 else if (i + 1 == argc)
1732 fatal ("Macro name missing after -U option");
1734 pend_undefs[i] = argv[i+1], i++;
1738 put_out_comments = 1;
1741 case 'E': /* -E comes from cc -E; ignore it. */
1745 no_line_directives = 1;
1748 case '$': /* Don't include $ in identifiers. */
1749 dollars_in_ident = 0;
1752 case 'I': /* Add directory to path for includes. */
1754 struct file_name_list *dirtmp;
1756 if (! ignore_srcdir && !strcmp (argv[i] + 2, "-")) {
1758 /* Don't use any preceding -I directories for #include <...>. */
1759 first_bracket_include = 0;
1762 dirtmp = (struct file_name_list *)
1763 xmalloc (sizeof (struct file_name_list));
1764 dirtmp->next = 0; /* New one goes on the end */
1765 dirtmp->control_macro = 0;
1766 dirtmp->c_system_include_path = 0;
1767 if (argv[i][2] != 0)
1768 dirtmp->fname = argv[i] + 2;
1769 else if (i + 1 == argc)
1770 fatal ("Directory name missing after -I option");
1772 dirtmp->fname = argv[++i];
1773 dirtmp->got_name_map = 0;
1774 append_include_chain (dirtmp, dirtmp);
1780 if (!strcmp (argv[i], "-nostdinc"))
1781 /* -nostdinc causes no default include directories.
1782 You must specify all include-file directories with -I. */
1783 no_standard_includes = 1;
1784 else if (!strcmp (argv[i], "-nostdinc++"))
1785 /* -nostdinc++ causes no default C++-specific include directories. */
1786 no_standard_cplusplus_includes = 1;
1787 else if (!strcmp (argv[i], "-noprecomp"))
1792 /* Sun compiler passes undocumented switch "-undef".
1793 Let's assume it means to inhibit the predefined symbols. */
1794 inhibit_predefs = 1;
1797 case '\0': /* JF handle '-' as file name meaning stdin or stdout */
1798 if (in_fname == NULL) {
1801 } else if (out_fname == NULL) {
1804 } /* else fall through into error */
1807 fatal ("Invalid option `%s'", argv[i]);
1812 /* Add dirs from CPATH after dirs from -I. */
1813 /* There seems to be confusion about what CPATH should do,
1814 so for the moment it is not documented. */
1815 /* Some people say that CPATH should replace the standard include dirs,
1816 but that seems pointless: it comes before them, so it overrides them
1818 cp = getenv ("CPATH");
1819 if (cp && ! no_standard_includes)
1822 /* Now that dollars_in_ident is known, initialize is_idchar. */
1823 initialize_char_syntax ();
1825 /* Initialize output buffer */
1827 outbuf.buf = (U_CHAR *) xmalloc (OUTBUF_SIZE);
1828 outbuf.bufp = outbuf.buf;
1829 outbuf.length = OUTBUF_SIZE;
1831 /* Do partial setup of input buffer for the sake of generating
1832 early #line directives (when -g is in effect). */
1834 fp = &instack[++indepth];
1835 if (in_fname == NULL)
1837 fp->nominal_fname = fp->fname = in_fname;
1840 /* In C++, wchar_t is a distinct basic type, and we can expect
1841 __wchar_t to be defined by cc1plus. */
1843 wchar_type = "__wchar_t";
1845 /* Install __LINE__, etc. Must follow initialize_char_syntax
1846 and option processing. */
1847 initialize_builtins (fp, &outbuf);
1849 /* Do standard #defines and assertions
1850 that identify system and machine type. */
1852 if (!inhibit_predefs) {
1853 char *p = (char *) alloca (strlen (predefs) + 1);
1854 strcpy (p, predefs);
1857 while (*p == ' ' || *p == '\t')
1859 /* Handle -D options. */
1860 if (p[0] == '-' && p[1] == 'D') {
1862 while (*p && *p != ' ' && *p != '\t')
1867 output_line_directive (fp, &outbuf, 0, same_file);
1868 make_definition (q, &outbuf);
1869 while (*p == ' ' || *p == '\t')
1871 } else if (p[0] == '-' && p[1] == 'A') {
1872 /* Handle -A options (assertions). */
1881 past_name = assertion;
1882 /* Locate end of name. */
1883 while (*past_name && *past_name != ' '
1884 && *past_name != '\t' && *past_name != '(')
1886 /* Locate `(' at start of value. */
1888 while (*value && (*value == ' ' || *value == '\t'))
1890 if (*value++ != '(')
1892 while (*value && (*value == ' ' || *value == '\t'))
1895 /* Locate end of value. */
1896 while (*past_value && *past_value != ' '
1897 && *past_value != '\t' && *past_value != ')')
1899 termination = past_value;
1900 while (*termination && (*termination == ' ' || *termination == '\t'))
1902 if (*termination++ != ')')
1904 if (*termination && *termination != ' ' && *termination != '\t')
1906 /* Temporarily null-terminate the value. */
1907 save_char = *termination;
1908 *termination = '\0';
1909 /* Install the assertion. */
1910 make_assertion ("-A", assertion);
1911 *termination = (char) save_char;
1913 while (*p == ' ' || *p == '\t')
1921 /* Now handle the command line options. */
1923 /* Do -U's, -D's and -A's in the order they were seen. */
1924 for (i = 1; i < argc; i++) {
1925 if (pend_undefs[i]) {
1927 output_line_directive (fp, &outbuf, 0, same_file);
1928 make_undef (pend_undefs[i], &outbuf);
1932 output_line_directive (fp, &outbuf, 0, same_file);
1933 make_definition (pend_defs[i], &outbuf);
1935 if (pend_assertions[i])
1936 make_assertion (pend_assertion_options[i], pend_assertions[i]);
1939 done_initializing = 1;
1941 { /* read the appropriate environment variable and if it exists
1942 replace include_defaults with the listed path. */
1944 switch ((objc << 1) + cplusplus)
1947 epath = getenv ("C_INCLUDE_PATH");
1950 epath = getenv ("CPLUS_INCLUDE_PATH");
1953 epath = getenv ("OBJC_INCLUDE_PATH");
1956 epath = getenv ("OBJCPLUS_INCLUDE_PATH");
1959 /* If the environment var for this language is set,
1960 add to the default list of include directories. */
1962 char *nstore = (char *) alloca (strlen (epath) + 2);
1964 char *startp, *endp;
1966 for (num_dirs = 1, startp = epath; *startp; startp++)
1967 if (*startp == PATH_SEPARATOR)
1970 = (struct default_include *) xmalloc ((num_dirs
1971 * sizeof (struct default_include))
1972 + sizeof (include_defaults_array));
1973 startp = endp = epath;
1976 /* Handle cases like c:/usr/lib:d:/gcc/lib */
1977 if ((*endp == PATH_SEPARATOR
1978 #if 0 /* Obsolete, now that we use semicolons as the path separator. */
1980 && (endp-startp != 1 || !isalpha (*startp))
1985 strncpy (nstore, startp, endp-startp);
1987 strcpy (nstore, ".");
1989 nstore[endp-startp] = '\0';
1991 include_defaults[num_dirs].fname = savestring (nstore);
1992 include_defaults[num_dirs].cplusplus = cplusplus;
1993 include_defaults[num_dirs].cxx_aware = 1;
1997 endp = startp = endp + 1;
2001 /* Put the usual defaults back in at the end. */
2002 bcopy ((char *) include_defaults_array,
2003 (char *) &include_defaults[num_dirs],
2004 sizeof (include_defaults_array));
2008 append_include_chain (before_system, last_before_system);
2009 first_system_include = before_system;
2011 /* Unless -fnostdinc,
2012 tack on the standard include file dirs to the specified list */
2013 if (!no_standard_includes) {
2014 struct default_include *p = include_defaults;
2015 char *specd_prefix = include_prefix;
2016 char *default_prefix = savestring (GCC_INCLUDE_DIR);
2017 int default_len = 0;
2018 /* Remove the `include' from /usr/local/lib/gcc.../include. */
2019 if (!strcmp (default_prefix + strlen (default_prefix) - 8, "/include")) {
2020 default_len = strlen (default_prefix) - 7;
2021 default_prefix[default_len] = 0;
2023 /* Search "translated" versions of GNU directories.
2024 These have /usr/local/lib/gcc... replaced by specd_prefix. */
2025 if (specd_prefix != 0 && default_len != 0)
2026 for (p = include_defaults; p->fname; p++) {
2027 /* Some standard dirs are only for C++. */
2028 if (!p->cplusplus || (cplusplus && !no_standard_cplusplus_includes)) {
2029 /* Does this dir start with the prefix? */
2030 if (!strncmp (p->fname, default_prefix, default_len)) {
2031 /* Yes; change prefix and add to search list. */
2032 struct file_name_list *new
2033 = (struct file_name_list *) xmalloc (sizeof (struct file_name_list));
2034 int this_len = strlen (specd_prefix) + strlen (p->fname) - default_len;
2035 char *str = xmalloc (this_len + 1);
2036 strcpy (str, specd_prefix);
2037 strcat (str, p->fname + default_len);
2039 new->control_macro = 0;
2040 new->c_system_include_path = !p->cxx_aware;
2041 new->got_name_map = 0;
2042 append_include_chain (new, new);
2043 if (first_system_include == 0)
2044 first_system_include = new;
2048 /* Search ordinary names for GNU include directories. */
2049 for (p = include_defaults; p->fname; p++) {
2050 /* Some standard dirs are only for C++. */
2051 if (!p->cplusplus || (cplusplus && !no_standard_cplusplus_includes)) {
2052 struct file_name_list *new
2053 = (struct file_name_list *) xmalloc (sizeof (struct file_name_list));
2054 new->control_macro = 0;
2055 new->c_system_include_path = !p->cxx_aware;
2056 new->fname = p->fname;
2057 new->got_name_map = 0;
2058 append_include_chain (new, new);
2059 if (first_system_include == 0)
2060 first_system_include = new;
2065 /* Tack the after_include chain at the end of the include chain. */
2066 append_include_chain (after_include, last_after_include);
2067 if (first_system_include == 0)
2068 first_system_include = after_include;
2070 /* With -v, print the list of dirs to search. */
2072 struct file_name_list *p;
2073 fprintf (stderr, "#include \"...\" search starts here:\n");
2074 for (p = include; p; p = p->next) {
2075 if (p == first_bracket_include)
2076 fprintf (stderr, "#include <...> search starts here:\n");
2077 fprintf (stderr, " %s\n", p->fname);
2079 fprintf (stderr, "End of search list.\n");
2082 /* Scan the -imacros files before the main input.
2083 Much like #including them, but with no_output set
2084 so that only their macro definitions matter. */
2086 no_output++; no_record_file++;
2087 for (i = 1; i < argc; i++)
2088 if (pend_files[i]) {
2089 int fd = open (pend_files[i], O_RDONLY, 0666);
2091 perror_with_name (pend_files[i]);
2092 return FATAL_EXIT_CODE;
2094 finclude (fd, pend_files[i], &outbuf, 0, NULL_PTR);
2096 no_output--; no_record_file--;
2098 /* Copy the entire contents of the main input file into
2099 the stacked input buffer previously allocated for it. */
2101 /* JF check for stdin */
2102 if (in_fname == NULL || *in_fname == 0) {
2105 } else if ((f = open (in_fname, O_RDONLY, 0666)) < 0)
2108 /* -MG doesn't select the form of output and must be specified with one of
2109 -M or -MM. -MG doesn't make sense with -MD or -MMD since they don't
2110 inhibit compilation. */
2111 if (print_deps_missing_files && (print_deps == 0 || !inhibit_output))
2112 fatal ("-MG must be specified with one of -M or -MM");
2114 /* Either of two environment variables can specify output of deps.
2115 Its value is either "OUTPUT_FILE" or "OUTPUT_FILE DEPS_TARGET",
2116 where OUTPUT_FILE is the file to write deps info to
2117 and DEPS_TARGET is the target to mention in the deps. */
2120 && (getenv ("SUNPRO_DEPENDENCIES") != 0
2121 || getenv ("DEPENDENCIES_OUTPUT") != 0)) {
2122 char *spec = getenv ("DEPENDENCIES_OUTPUT");
2127 spec = getenv ("SUNPRO_DEPENDENCIES");
2134 /* Find the space before the DEPS_TARGET, if there is one. */
2135 /* This should use index. (mrs) */
2136 while (*s != 0 && *s != ' ') s++;
2138 deps_target = s + 1;
2139 output_file = xmalloc (s - spec + 1);
2140 bcopy (spec, output_file, s - spec);
2141 output_file[s - spec] = 0;
2148 deps_file = output_file;
2152 /* For -M, print the expected object file name
2153 as the target of this Make-rule. */
2155 deps_allocated_size = 200;
2156 deps_buffer = xmalloc (deps_allocated_size);
2162 deps_output (deps_target, ':');
2163 } else if (*in_fname == 0) {
2164 deps_output ("-", ':');
2169 /* Discard all directory prefixes from filename. */
2170 if ((q = rindex (in_fname, '/')) != NULL
2171 #ifdef DIR_SEPARATOR
2172 && (q = rindex (in_fname, DIR_SEPARATOR)) != NULL
2179 /* Copy remainder to mungable area. */
2180 p = (char *) alloca (strlen(q) + 8);
2183 /* Output P, but remove known suffixes. */
2187 && p[len - 2] == '.'
2188 && index("cCsSm", p[len - 1]))
2191 && p[len - 3] == '.'
2192 && p[len - 2] == 'c'
2193 && p[len - 1] == 'c')
2196 && p[len - 4] == '.'
2197 && p[len - 3] == 'c'
2198 && p[len - 2] == 'x'
2199 && p[len - 1] == 'x')
2202 && p[len - 4] == '.'
2203 && p[len - 3] == 'c'
2204 && p[len - 2] == 'p'
2205 && p[len - 1] == 'p')
2208 /* Supply our own suffix. */
2215 deps_output (p, ':');
2216 deps_output (in_fname, ' ');
2220 file_size_and_mode (f, &st_mode, &st_size);
2221 fp->nominal_fname = fp->fname = in_fname;
2223 fp->system_header_p = 0;
2224 /* JF all this is mine about reading pipes and ttys */
2225 if (! S_ISREG (st_mode)) {
2226 /* Read input from a file that is not a normal disk file.
2227 We cannot preallocate a buffer with the correct size,
2228 so we must read in the file a piece at the time and make it bigger. */
2235 fp->buf = (U_CHAR *) xmalloc (bsize + 2);
2237 cnt = safe_read (f, (char *) fp->buf + size, bsize - size);
2238 if (cnt < 0) goto perror; /* error! */
2240 if (size != bsize) break; /* End of file */
2242 fp->buf = (U_CHAR *) xrealloc (fp->buf, bsize + 2);
2246 /* Read a file whose size we can determine in advance.
2247 For the sake of VMS, st_size is just an upper bound. */
2248 fp->buf = (U_CHAR *) xmalloc (st_size + 2);
2249 fp->length = safe_read (f, (char *) fp->buf, st_size);
2250 if (fp->length < 0) goto perror;
2253 fp->if_stack = if_stack;
2255 /* Make sure data ends with a newline. And put a null after it. */
2257 if ((fp->length > 0 && fp->buf[fp->length - 1] != '\n')
2258 /* Backslash-newline at end is not good enough. */
2259 || (fp->length > 1 && fp->buf[fp->length - 2] == '\\')) {
2260 fp->buf[fp->length++] = '\n';
2261 missing_newline = 1;
2263 fp->buf[fp->length] = '\0';
2265 /* Unless inhibited, convert trigraphs in the input. */
2270 /* Now that we know the input file is valid, open the output. */
2272 if (!out_fname || !strcmp (out_fname, ""))
2273 out_fname = "stdout";
2274 else if (! freopen (out_fname, "w", stdout))
2275 pfatal_with_name (out_fname);
2277 output_line_directive (fp, &outbuf, 0, same_file);
2279 /* Scan the -include files before the main input. */
2282 for (i = 1; i < argc; i++)
2283 if (pend_includes[i]) {
2284 int fd = open (pend_includes[i], O_RDONLY, 0666);
2286 perror_with_name (pend_includes[i]);
2287 return FATAL_EXIT_CODE;
2289 finclude (fd, pend_includes[i], &outbuf, 0, NULL_PTR);
2293 /* Scan the input, processing macros and directives. */
2295 rescan (&outbuf, 0);
2297 if (missing_newline)
2300 if (pedantic && missing_newline)
2301 pedwarn ("file does not end in newline");
2303 /* Now we have processed the entire input
2304 Write whichever kind of output has been requested. */
2306 if (dump_macros == dump_only)
2308 else if (! inhibit_output) {
2313 /* Don't actually write the deps file if compilation has failed. */
2315 if (deps_file && ! (deps_stream = fopen (deps_file, deps_mode)))
2316 pfatal_with_name (deps_file);
2317 fputs (deps_buffer, deps_stream);
2318 putc ('\n', deps_stream);
2320 if (ferror (deps_stream) || fclose (deps_stream) != 0)
2321 fatal ("I/O error on output");
2326 if (pcp_outfile && pcp_outfile != stdout
2327 && (ferror (pcp_outfile) || fclose (pcp_outfile) != 0))
2328 fatal ("I/O error on `-pcp' output");
2330 if (ferror (stdout) || fclose (stdout) != 0)
2331 fatal ("I/O error on output");
2334 exit (FATAL_EXIT_CODE);
2335 exit (SUCCESS_EXIT_CODE);
2338 pfatal_with_name (in_fname);
2342 /* Given a colon-separated list of file names PATH,
2343 add all the names to the search path for include files. */
2357 struct file_name_list *dirtmp;
2359 /* Find the end of this name. */
2360 while (*q != 0 && *q != PATH_SEPARATOR) q++;
2362 /* An empty name in the path stands for the current directory. */
2367 /* Otherwise use the directory that is named. */
2368 name = xmalloc (q - p + 1);
2369 bcopy (p, name, q - p);
2373 dirtmp = (struct file_name_list *)
2374 xmalloc (sizeof (struct file_name_list));
2375 dirtmp->next = 0; /* New one goes on the end */
2376 dirtmp->control_macro = 0;
2377 dirtmp->c_system_include_path = 0;
2378 dirtmp->fname = name;
2379 dirtmp->got_name_map = 0;
2380 append_include_chain (dirtmp, dirtmp);
2382 /* Advance past this name. */
2386 /* Skip the colon. */
2391 /* Return the address of the first character in S that equals C.
2392 S is an array of length N, possibly containing '\0's, and followed by '\0'.
2393 Return 0 if there is no such character. Assume that C itself is not '\0'.
2394 If we knew we could use memchr, we could just invoke memchr (S, C, N),
2395 but unfortunately memchr isn't autoconfigured yet. */
2403 char *p = (char *) s;
2405 char *q = index (p, c);
2407 return (U_CHAR *) q;
2409 size_t l = strlen (p);
2419 /* Pre-C-Preprocessor to translate ANSI trigraph idiocy in BUF
2420 before main CCCP processing. Name `pcp' is also in honor of the
2421 drugs the trigraph designers must have been on.
2423 Using an extra pass through the buffer takes a little extra time,
2424 but is infinitely less hairy than trying to handle trigraphs inside
2425 strings, etc. everywhere, and also makes sure that trigraphs are
2426 only translated in the top level of processing. */
2432 register U_CHAR c, *fptr, *bptr, *sptr, *lptr;
2435 fptr = bptr = sptr = buf->buf;
2436 lptr = fptr + buf->length;
2437 while ((sptr = index0 (sptr, '?', (size_t) (lptr - sptr))) != NULL) {
2474 len = sptr - fptr - 2;
2476 /* BSD doc says bcopy () works right for overlapping strings. In ANSI
2477 C, this will be memmove (). */
2478 if (bptr != fptr && len > 0)
2479 bcopy ((char *) fptr, (char *) bptr, len);
2485 len = buf->length - (fptr - buf->buf);
2486 if (bptr != fptr && len > 0)
2487 bcopy ((char *) fptr, (char *) bptr, len);
2488 buf->length -= fptr - bptr;
2489 buf->buf[buf->length] = '\0';
2490 if (warn_trigraphs && fptr != bptr)
2491 warning_with_line (0, "%d trigraph(s) encountered", (fptr - bptr) / 2);
2494 /* Move all backslash-newline pairs out of embarrassing places.
2495 Exchange all such pairs following BP
2496 with any potentially-embarrassing characters that follow them.
2497 Potentially-embarrassing characters are / and *
2498 (because a backslash-newline inside a comment delimiter
2499 would cause it not to be recognized). */
2505 register U_CHAR *p = bp;
2507 /* First count the backslash-newline pairs here. */
2509 while (p[0] == '\\' && p[1] == '\n')
2512 /* What follows the backslash-newlines is not embarrassing. */
2514 if (*p != '/' && *p != '*')
2517 /* Copy all potentially embarrassing characters
2518 that follow the backslash-newline pairs
2519 down to where the pairs originally started. */
2521 while (*p == '*' || *p == '/')
2524 /* Now write the same number of pairs after the embarrassing chars. */
2531 /* Like newline_fix but for use within a directive-name.
2532 Move any backslash-newlines up past any following symbol constituents. */
2535 name_newline_fix (bp)
2538 register U_CHAR *p = bp;
2540 /* First count the backslash-newline pairs here. */
2541 while (p[0] == '\\' && p[1] == '\n')
2544 /* What follows the backslash-newlines is not embarrassing. */
2549 /* Copy all potentially embarrassing characters
2550 that follow the backslash-newline pairs
2551 down to where the pairs originally started. */
2553 while (is_idchar[*p])
2556 /* Now write the same number of pairs after the embarrassing chars. */
2563 /* Look for lint commands in comments.
2565 When we come in here, ibp points into a comment. Limit is as one expects.
2566 scan within the comment -- it should start, after lwsp, with a lint command.
2567 If so that command is returned as a (constant) string.
2569 Upon return, any arg will be pointed to with argstart and will be
2570 arglen long. Note that we don't parse that arg since it will just
2571 be printed out again.
2575 get_lintcmd (ibp, limit, argstart, arglen, cmdlen)
2576 register U_CHAR *ibp;
2577 register U_CHAR *limit;
2578 U_CHAR **argstart; /* point to command arg */
2579 int *arglen, *cmdlen; /* how long they are */
2582 register U_CHAR *numptr; /* temp for arg parsing */
2586 SKIP_WHITE_SPACE (ibp);
2588 if (ibp >= limit) return NULL;
2590 linsize = limit - ibp;
2592 /* Oh, I wish C had lexical functions... hell, I'll just open-code the set */
2593 if ((linsize >= 10) && !bcmp (ibp, "NOTREACHED", 10)) {
2595 return "NOTREACHED";
2597 if ((linsize >= 8) && !bcmp (ibp, "ARGSUSED", 8)) {
2601 if ((linsize >= 11) && !bcmp (ibp, "LINTLIBRARY", 11)) {
2603 return "LINTLIBRARY";
2605 if ((linsize >= 7) && !bcmp (ibp, "VARARGS", 7)) {
2607 ibp += 7; linsize -= 7;
2608 if ((linsize == 0) || ! isdigit (*ibp)) return "VARARGS";
2610 /* OK, read a number */
2611 for (numptr = *argstart = ibp; (numptr < limit) && isdigit (*numptr);
2613 *arglen = numptr - *argstart;
2620 * The main loop of the program.
2622 * Read characters from the input stack, transferring them to the
2625 * Macros are expanded and push levels on the input stack.
2626 * At the end of such a level it is popped off and we keep reading.
2627 * At the end of any other kind of level, we return.
2628 * #-directives are handled, except within macros.
2630 * If OUTPUT_MARKS is nonzero, keep Newline markers found in the input
2631 * and insert them when appropriate. This is set while scanning macro
2632 * arguments before substitution. It is zero when scanning for final output.
2633 * There are three types of Newline markers:
2634 * * Newline - follows a macro name that was not expanded
2635 * because it appeared inside an expansion of the same macro.
2636 * This marker prevents future expansion of that identifier.
2637 * When the input is rescanned into the final output, these are deleted.
2638 * These are also deleted by ## concatenation.
2639 * * Newline Space (or Newline and any other whitespace character)
2640 * stands for a place that tokens must be separated or whitespace
2641 * is otherwise desirable, but where the ANSI standard specifies there
2642 * is no whitespace. This marker turns into a Space (or whichever other
2643 * whitespace char appears in the marker) in the final output,
2644 * but it turns into nothing in an argument that is stringified with #.
2645 * Such stringified arguments are the only place where the ANSI standard
2646 * specifies with precision that whitespace may not appear.
2648 * During this function, IP->bufp is kept cached in IBP for speed of access.
2649 * Likewise, OP->bufp is kept in OBP. Before calling a subroutine
2650 * IBP, IP and OBP must be copied back to memory. IP and IBP are
2651 * copied back with the RECACHE macro. OBP must be copied back from OP->bufp
2652 * explicitly, and before RECACHE, since RECACHE uses OBP.
2656 rescan (op, output_marks)
2660 /* Character being scanned in main loop. */
2663 /* Length of pending accumulated identifier. */
2664 register int ident_length = 0;
2666 /* Hash code of pending accumulated identifier. */
2667 register int hash = 0;
2669 /* Current input level (&instack[indepth]). */
2672 /* Pointer for scanning input. */
2673 register U_CHAR *ibp;
2675 /* Pointer to end of input. End of scan is controlled by LIMIT. */
2676 register U_CHAR *limit;
2678 /* Pointer for storing output. */
2679 register U_CHAR *obp;
2681 /* REDO_CHAR is nonzero if we are processing an identifier
2682 after backing up over the terminating character.
2683 Sometimes we process an identifier without backing up over
2684 the terminating character, if the terminating character
2685 is not special. Backing up is done so that the terminating character
2686 will be dispatched on again once the identifier is dealt with. */
2689 /* 1 if within an identifier inside of which a concatenation
2690 marker (Newline -) has been seen. */
2691 int concatenated = 0;
2693 /* While scanning a comment or a string constant,
2694 this records the line it started on, for error messages. */
2697 /* Record position of last `real' newline. */
2698 U_CHAR *beg_of_line;
2700 /* Pop the innermost input stack level, assuming it is a macro expansion. */
2703 do { ip->macro->type = T_MACRO; \
2704 if (ip->free_ptr) free (ip->free_ptr); \
2705 --indepth; } while (0)
2707 /* Reload `rescan's local variables that describe the current
2708 level of the input stack. */
2711 do { ip = &instack[indepth]; \
2713 limit = ip->buf + ip->length; \
2715 check_expand (op, limit - ibp); \
2717 obp = op->bufp; } while (0)
2719 if (no_output && instack[indepth].fname != 0)
2720 skip_if_group (&instack[indepth], 1, NULL);
2727 /* Our caller must always put a null after the end of
2728 the input at each input stack level. */
2738 if (*ibp == '\n' && !ip->macro) {
2739 /* At the top level, always merge lines ending with backslash-newline,
2740 even in middle of identifier. But do not merge lines in a macro,
2741 since backslash might be followed by a newline-space marker. */
2744 --obp; /* remove backslash from obuf */
2747 /* If ANSI, backslash is just another character outside a string. */
2750 /* Otherwise, backslash suppresses specialness of following char,
2751 so copy it here to prevent the switch from seeing it.
2752 But first get any pending identifier processed. */
2753 if (ident_length > 0)
2760 if (ident_length || ip->macro || traditional)
2762 while (*ibp == '\\' && ibp[1] == '\n') {
2768 /* Treat this %: digraph as if it were #. */
2772 if (assertions_flag) {
2773 /* Copy #foo (bar lose) without macro expansion. */
2774 obp[-1] = '#'; /* In case it was '%'. */
2775 SKIP_WHITE_SPACE (ibp);
2776 while (is_idchar[*ibp])
2778 SKIP_WHITE_SPACE (ibp);
2781 skip_paren_group (ip);
2782 bcopy ((char *) ibp, (char *) obp, ip->bufp - ibp);
2783 obp += ip->bufp - ibp;
2788 /* If this is expanding a macro definition, don't recognize
2789 preprocessing directives. */
2792 /* If this is expand_into_temp_buffer,
2793 don't recognize them either. Warn about them
2794 only after an actual newline at this level,
2795 not at the beginning of the input level. */
2797 if (ip->buf != beg_of_line)
2798 warning ("preprocessing directive not recognized within macro arg");
2805 /* # keyword: a # must be first nonblank char on the line */
2806 if (beg_of_line == 0)
2811 /* Scan from start of line, skipping whitespace, comments
2812 and backslash-newlines, and see if we reach this #.
2813 If not, this # is not special. */
2815 /* If -traditional, require # to be at beginning of line. */
2818 if (is_hor_space[*bp])
2820 else if (*bp == '\\' && bp[1] == '\n')
2822 else if (*bp == '/' && bp[1] == '*') {
2824 while (!(*bp == '*' && bp[1] == '/'))
2828 /* There is no point in trying to deal with C++ // comments here,
2829 because if there is one, then this # must be part of the
2830 comment and we would never reach here. */
2836 while (bp[1] == '\\' && bp[2] == '\n')
2840 /* %: appears at start of line; skip past the ':' too. */
2849 /* This # can start a directive. */
2851 --obp; /* Don't copy the '#' */
2855 if (! handle_directive (ip, op)) {
2859 /* Not a known directive: treat it as ordinary text.
2860 IP, OP, IBP, etc. have not been changed. */
2861 if (no_output && instack[indepth].fname) {
2862 /* If not generating expanded output,
2863 what we do with ordinary text is skip it.
2864 Discard everything until next # directive. */
2865 skip_if_group (&instack[indepth], 1, 0);
2870 *obp++ = '#'; /* Copy # (even if it was originally %:). */
2871 /* Don't expand an identifier that could be a macro directive.
2872 (Section 3.8.3 of the ANSI C standard) */
2873 SKIP_WHITE_SPACE (ibp);
2874 if (is_idstart[*ibp])
2877 while (is_idchar[*ibp])
2885 /* A # directive has been successfully processed. */
2886 /* If not generating expanded output, ignore everything until
2887 next # directive. */
2888 if (no_output && instack[indepth].fname)
2889 skip_if_group (&instack[indepth], 1, 0);
2895 case '\"': /* skip quoted string */
2897 /* A single quoted string is treated like a double -- some
2898 programs (e.g., troff) are perverse this way */
2903 start_line = ip->lineno;
2905 /* Skip ahead to a matching quote. */
2909 if (ip->macro != 0) {
2910 /* try harder: this string crosses a macro expansion boundary.
2911 This can happen naturally if -traditional.
2912 Otherwise, only -D can make a macro with an unmatched quote. */
2918 error_with_line (line_for_error (start_line),
2919 "unterminated string or character constant");
2920 error_with_line (multiline_string_line,
2921 "possible real start of unterminated constant");
2922 multiline_string_line = 0;
2931 /* Traditionally, end of line ends a string constant with no error.
2932 So exit the loop and record the new line. */
2938 error_with_line (line_for_error (start_line),
2939 "unterminated character constant");
2942 if (pedantic && multiline_string_line == 0) {
2943 pedwarn_with_line (line_for_error (start_line),
2944 "string constant runs past end of line");
2946 if (multiline_string_line == 0)
2947 multiline_string_line = ip->lineno - 1;
2954 /* Backslash newline is replaced by nothing at all,
2955 but keep the line counts correct. */
2960 /* ANSI stupidly requires that in \\ the second \
2961 is *not* prevented from combining with a newline. */
2962 while (*ibp == '\\' && ibp[1] == '\n') {
2981 if (*ibp == '\\' && ibp[1] == '\n')
2985 && !(cplusplus_comments && *ibp == '/'))
2993 /* C++ style comment... */
2994 start_line = ip->lineno;
2996 /* Comments are equivalent to spaces. */
2997 if (! put_out_comments)
3001 U_CHAR *before_bp = ibp;
3003 while (++ibp < limit) {
3005 if (ibp[-1] != '\\') {
3006 if (put_out_comments) {
3007 bcopy ((char *) before_bp, (char *) obp, ibp - before_bp);
3008 obp += ibp - before_bp;
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)
3025 /* Ordinary C comment. Skip it, optionally copying it to output. */
3027 start_line = ip->lineno;
3029 ++ibp; /* Skip the star. */
3031 /* If this cpp is for lint, we peek inside the comments: */
3035 char *lintcmd = get_lintcmd (ibp, limit, &argbp, &arglen, &cmdlen);
3037 if (lintcmd != NULL) {
3039 check_expand (op, cmdlen + arglen + 14);
3041 /* I believe it is always safe to emit this newline: */
3043 bcopy ("#pragma lint ", (char *) obp, 13);
3045 bcopy (lintcmd, (char *) obp, cmdlen);
3050 bcopy (argbp, (char *) obp, arglen);
3054 /* OK, now bring us back to the state we were in before we entered
3055 this branch. We need #line because the #pragma's newline always
3056 messes up the line count. */
3058 output_line_directive (ip, op, 0, same_file);
3059 check_expand (op, limit - ibp + 2);
3065 /* Comments are equivalent to spaces.
3066 Note that we already output the slash; we might not want it.
3067 For -traditional, a comment is equivalent to nothing. */
3068 if (! put_out_comments) {
3078 U_CHAR *before_bp = ibp;
3080 while (ibp < limit) {
3083 if (warn_comments && *ibp == '*')
3084 warning ("`/*' within comment");
3087 if (*ibp == '\\' && ibp[1] == '\n')
3089 if (ibp >= limit || *ibp == '/')
3094 /* Copy the newline into the output buffer, in order to
3095 avoid the pain of a #line every time a multiline comment
3097 if (!put_out_comments)
3105 error_with_line (line_for_error (start_line),
3106 "unterminated comment");
3109 if (put_out_comments) {
3110 bcopy ((char *) before_bp, (char *) obp, ibp - before_bp);
3111 obp += ibp - before_bp;
3118 if (!dollars_in_ident)
3122 case '0': case '1': case '2': case '3': case '4':
3123 case '5': case '6': case '7': case '8': case '9':
3124 /* If digit is not part of identifier, it starts a number,
3125 which means that following letters are not an identifier.
3126 "0x5" does not refer to an identifier "x5".
3127 So copy all alphanumerics that follow without accumulating
3128 as an identifier. Periods also, for sake of "3.e7". */
3130 if (ident_length == 0) {
3132 while (ibp[0] == '\\' && ibp[1] == '\n') {
3137 if (!is_idchar[c] && c != '.') {
3142 /* A sign can be part of a preprocessing number
3143 if it follows an e. */
3144 if (c == 'e' || c == 'E') {
3145 while (ibp[0] == '\\' && ibp[1] == '\n') {
3149 if (*ibp == '+' || *ibp == '-') {
3151 /* But traditional C does not let the token go past the sign. */
3162 case 'a': case 'b': case 'c': case 'd': case 'e': case 'f':
3163 case 'g': case 'h': case 'i': case 'j': case 'k': case 'l':
3164 case 'm': case 'n': case 'o': case 'p': case 'q': case 'r':
3165 case 's': case 't': case 'u': case 'v': case 'w': case 'x':
3167 case 'A': case 'B': case 'C': case 'D': case 'E': case 'F':
3168 case 'G': case 'H': case 'I': case 'J': case 'K': case 'L':
3169 case 'M': case 'N': case 'O': case 'P': case 'Q': case 'R':
3170 case 'S': case 'T': case 'U': case 'V': case 'W': case 'X':
3174 /* Compute step of hash function, to avoid a proc call on every token */
3175 hash = HASHSTEP (hash, c);
3179 if (ip->fname == 0 && *ibp == '-') {
3180 /* Newline - inhibits expansion of preceding token.
3181 If expanding a macro arg, we keep the newline -.
3182 In final output, it is deleted.
3183 We recognize Newline - in macro bodies and macro args. */
3184 if (! concatenated) {
3189 if (!output_marks) {
3192 /* If expanding a macro arg, keep the newline -. */
3198 /* If reprocessing a macro expansion, newline is a special marker. */
3199 else if (ip->macro != 0) {
3200 /* Newline White is a "funny space" to separate tokens that are
3201 supposed to be separate but without space between.
3202 Here White means any whitespace character.
3203 Newline - marks a recursive macro use that is not
3204 supposed to be expandable. */
3206 if (is_space[*ibp]) {
3207 /* Newline Space does not prevent expansion of preceding token
3208 so expand the preceding token and then come back. */
3209 if (ident_length > 0)
3212 /* If generating final output, newline space makes a space. */
3213 if (!output_marks) {
3215 /* And Newline Newline makes a newline, so count it. */
3216 if (obp[-1] == '\n')
3219 /* If expanding a macro arg, keep the newline space.
3220 If the arg gets stringified, newline space makes nothing. */
3223 } else abort (); /* Newline followed by something random? */
3227 /* If there is a pending identifier, handle it and come back here. */
3228 if (ident_length > 0)
3233 /* Update the line counts and output a #line if necessary. */
3236 if (ip->lineno != op->lineno) {
3238 output_line_directive (ip, op, 1, same_file);
3239 check_expand (op, limit - ibp);
3244 /* Come here either after (1) a null character that is part of the input
3245 or (2) at the end of the input, because there is a null there. */
3248 /* Our input really contains a null character. */
3251 /* At end of a macro-expansion level, pop it and read next level. */
3252 if (ip->macro != 0) {
3255 /* If traditional, and we have an identifier that ends here,
3256 process it now, so we get the right error for recursion. */
3257 if (traditional && ident_length
3258 && ! is_idchar[*instack[indepth - 1].bufp]) {
3267 /* If we don't have a pending identifier,
3268 return at end of input. */
3269 if (ident_length == 0) {
3277 /* If we do have a pending identifier, just consider this null
3278 a special character and arrange to dispatch on it again.
3279 The second time, IDENT_LENGTH will be zero so we will return. */
3285 /* Handle the case of a character such as /, ', " or null
3286 seen following an identifier. Back over it so that
3287 after the identifier is processed the special char
3288 will be dispatched on again. */
3298 if (ident_length > 0) {
3299 register HASHNODE *hp;
3301 /* We have just seen an identifier end. If it's a macro, expand it.
3303 IDENT_LENGTH is the length of the identifier
3304 and HASH is its hash code.
3306 The identifier has already been copied to the output,
3307 so if it is a macro we must remove it.
3309 If REDO_CHAR is 0, the char that terminated the identifier
3310 has been skipped in the output and the input.
3311 OBP-IDENT_LENGTH-1 points to the identifier.
3312 If the identifier is a macro, we must back over the terminator.
3314 If REDO_CHAR is 1, the terminating char has already been
3315 backed over. OBP-IDENT_LENGTH points to the identifier. */
3317 if (!pcp_outfile || pcp_inside_if) {
3318 for (hp = hashtab[MAKE_POS (hash) % HASHSIZE]; hp != NULL;
3321 if (hp->length == ident_length) {
3322 int obufp_before_macroname;
3323 int op_lineno_before_macroname;
3324 register int i = ident_length;
3325 register U_CHAR *p = hp->name;
3326 register U_CHAR *q = obp - i;
3332 do { /* All this to avoid a strncmp () */
3337 /* We found a use of a macro name.
3338 see if the context shows it is a macro call. */
3340 /* Back up over terminating character if not already done. */
3346 /* Save this as a displacement from the beginning of the output
3347 buffer. We can not save this as a position in the output
3348 buffer, because it may get realloc'ed by RECACHE. */
3349 obufp_before_macroname = (obp - op->buf) - ident_length;
3350 op_lineno_before_macroname = op->lineno;
3352 if (hp->type == T_PCSTRING) {
3353 pcstring_used (hp); /* Mark the definition of this key
3354 as needed, ensuring that it
3356 break; /* Exit loop, since the key cannot have a
3357 definition any longer. */
3360 /* Record whether the macro is disabled. */
3361 disabled = hp->type == T_DISABLED;
3363 /* This looks like a macro ref, but if the macro was disabled,
3364 just copy its name and put in a marker if requested. */
3368 /* This error check caught useful cases such as
3369 #define foo(x,y) bar (x (y,0), y)
3372 error ("recursive use of macro `%s'", hp->name);
3376 check_expand (op, limit - ibp + 2);
3383 /* If macro wants an arglist, verify that a '(' follows.
3384 first skip all whitespace, copying it to the output
3385 after the macro name. Then, if there is no '(',
3386 decide this is not a macro call and leave things that way. */
3387 if ((hp->type == T_MACRO || hp->type == T_DISABLED)
3388 && hp->value.defn->nargs >= 0)
3390 U_CHAR *old_ibp = ibp;
3391 U_CHAR *old_obp = obp;
3392 int old_iln = ip->lineno;
3393 int old_oln = op->lineno;
3396 /* Scan forward over whitespace, copying it to the output. */
3397 if (ibp == limit && ip->macro != 0) {
3402 old_iln = ip->lineno;
3403 old_oln = op->lineno;
3405 /* A comment: copy it unchanged or discard it. */
3406 else if (*ibp == '/' && ibp[1] == '*') {
3407 if (put_out_comments) {
3410 } else if (! traditional) {
3414 while (ibp + 1 != limit
3415 && !(ibp[0] == '*' && ibp[1] == '/')) {
3416 /* We need not worry about newline-marks,
3417 since they are never found in comments. */
3419 /* Newline in a file. Count it. */
3423 if (put_out_comments)
3429 if (put_out_comments) {
3434 else if (is_space[*ibp]) {
3436 if (ibp[-1] == '\n') {
3437 if (ip->macro == 0) {
3438 /* Newline in a file. Count it. */
3441 } else if (!output_marks) {
3442 /* A newline mark, and we don't want marks
3443 in the output. If it is newline-hyphen,
3444 discard it entirely. Otherwise, it is
3445 newline-whitechar, so keep the whitechar. */
3455 /* A newline mark; copy both chars to the output. */
3463 /* It isn't a macro call.
3464 Put back the space that we just skipped. */
3467 ip->lineno = old_iln;
3468 op->lineno = old_oln;
3469 /* Exit the for loop. */
3474 /* This is now known to be a macro call.
3475 Discard the macro name from the output,
3476 along with any following whitespace just copied,
3477 but preserve newlines if not outputting marks since this
3478 is more likely to do the right thing with line numbers. */
3479 obp = op->buf + obufp_before_macroname;
3481 op->lineno = op_lineno_before_macroname;
3483 int newlines = op->lineno - op_lineno_before_macroname;
3484 while (0 < newlines--)
3488 /* Prevent accidental token-pasting with a character
3489 before the macro call. */
3490 if (!traditional && obp != op->buf) {
3492 case '!': case '%': case '&': case '*':
3493 case '+': case '-': case '/': case ':':
3494 case '<': case '=': case '>': case '^':
3496 /* If we are expanding a macro arg, make a newline marker
3497 to separate the tokens. If we are making real output,
3498 a plain space will do. */
3505 /* Expand the macro, reading arguments as needed,
3506 and push the expansion on the input stack. */
3509 macroexpand (hp, op);
3511 /* Reexamine input stack, since macroexpand has pushed
3512 a new level on it. */
3519 } /* End hash-table-search loop */
3521 ident_length = hash = 0; /* Stop collecting identifier */
3524 } /* End if (ident_length > 0) */
3526 } /* End per-char loop */
3528 /* Come here to return -- but first give an error message
3529 if there was an unterminated successful conditional. */
3531 if (if_stack != ip->if_stack)
3535 switch (if_stack->type)
3556 error_with_line (line_for_error (if_stack->lineno),
3557 "unterminated `#%s' conditional", str);
3559 if_stack = ip->if_stack;
3563 * Rescan a string into a temporary buffer and return the result
3564 * as a FILE_BUF. Note this function returns a struct, not a pointer.
3566 * OUTPUT_MARKS nonzero means keep Newline markers found in the input
3567 * and insert such markers when appropriate. See `rescan' for details.
3568 * OUTPUT_MARKS is 1 for macroexpanding a macro argument separately
3569 * before substitution; it is 0 for other uses.
3572 expand_to_temp_buffer (buf, limit, output_marks, assertions)
3573 U_CHAR *buf, *limit;
3574 int output_marks, assertions;
3576 register FILE_BUF *ip;
3578 int length = limit - buf;
3580 int odepth = indepth;
3581 int save_assertions_flag = assertions_flag;
3583 assertions_flag = assertions;
3588 /* Set up the input on the input stack. */
3590 buf1 = (U_CHAR *) alloca (length + 1);
3592 register U_CHAR *p1 = buf;
3593 register U_CHAR *p2 = buf1;
3600 /* Set up to receive the output. */
3602 obuf.length = length * 2 + 100; /* Usually enough. Why be stingy? */
3603 obuf.bufp = obuf.buf = (U_CHAR *) xmalloc (obuf.length);
3608 CHECK_DEPTH ({return obuf;});
3612 ip = &instack[indepth];
3614 ip->nominal_fname = 0;
3615 ip->system_header_p = 0;
3618 ip->length = length;
3619 ip->buf = ip->bufp = buf1;
3620 ip->if_stack = if_stack;
3622 ip->lineno = obuf.lineno = 1;
3624 /* Scan the input, create the output. */
3625 rescan (&obuf, output_marks);
3627 /* Pop input stack to original state. */
3630 if (indepth != odepth)
3633 /* Record the output. */
3634 obuf.length = obuf.bufp - obuf.buf;
3636 assertions_flag = save_assertions_flag;
3641 * Process a # directive. Expects IP->bufp to point after the '#', as in
3642 * `#define foo bar'. Passes to the directive handler
3643 * (do_define, do_include, etc.): the addresses of the 1st and
3644 * last chars of the directive (starting immediately after the #
3645 * keyword), plus op and the keyword table pointer. If the directive
3646 * contains comments it is copied into a temporary buffer sans comments
3647 * and the temporary buffer is passed to the directive handler instead.
3648 * Likewise for backslash-newlines.
3650 * Returns nonzero if this was a known # directive.
3651 * Otherwise, returns zero, without advancing the input pointer.
3655 handle_directive (ip, op)
3658 register U_CHAR *bp, *cp;
3659 register struct directive *kt;
3660 register int ident_length;
3663 /* Nonzero means we must copy the entire directive
3664 to get rid of comments or backslash-newlines. */
3665 int copy_directive = 0;
3667 U_CHAR *ident, *after_ident;
3671 /* Record where the directive started. do_xifdef needs this. */
3672 directive_start = bp - 1;
3674 /* Skip whitespace and \-newline. */
3676 if (is_hor_space[*bp]) {
3677 if (*bp != ' ' && *bp != '\t' && pedantic)
3678 pedwarn ("%s in preprocessing directive", char_name[*bp]);
3680 } else if (*bp == '/' && (bp[1] == '*'
3681 || (cplusplus_comments && bp[1] == '/'))) {
3683 skip_to_end_of_comment (ip, &ip->lineno, 0);
3685 } else if (*bp == '\\' && bp[1] == '\n') {
3686 bp += 2; ip->lineno++;
3690 /* Now find end of directive name.
3691 If we encounter a backslash-newline, exchange it with any following
3692 symbol-constituents so that we end up with a contiguous name. */
3699 if (*cp == '\\' && cp[1] == '\n')
3700 name_newline_fix (cp);
3706 ident_length = cp - bp;
3710 /* A line of just `#' becomes blank. */
3712 if (ident_length == 0 && *after_ident == '\n') {
3713 ip->bufp = after_ident;
3717 if (ident_length == 0 || !is_idstart[*ident]) {
3719 while (is_idchar[*p]) {
3720 if (*p < '0' || *p > '9')
3724 /* Handle # followed by a line number. */
3725 if (p != ident && !is_idchar[*p]) {
3726 static struct directive line_directive_table[] = {
3727 { 4, do_line, "line", T_LINE},
3730 pedwarn ("`#' followed by integer");
3731 after_ident = ident;
3732 kt = line_directive_table;
3736 /* Avoid error for `###' and similar cases unless -pedantic. */
3738 while (*p == '#' || is_hor_space[*p]) p++;
3740 if (pedantic && !lang_asm)
3741 warning ("invalid preprocessing directive");
3747 error ("invalid preprocessing directive name");
3753 * Decode the keyword and call the appropriate expansion
3754 * routine, after moving the input pointer up to the next line.
3756 for (kt = directive_table; kt->length > 0; kt++) {
3757 if (kt->length == ident_length && !bcmp (kt->name, ident, ident_length)) {
3758 register U_CHAR *buf;
3759 register U_CHAR *limit;
3762 int *already_output;
3764 /* Nonzero means do not delete comments within the directive.
3765 #define needs this when -traditional. */
3770 limit = ip->buf + ip->length;
3773 keep_comments = traditional && kt->traditional_comments;
3774 /* #import is defined only in Objective C, or when on the NeXT. */
3775 if (kt->type == T_IMPORT
3776 && !(objc || lookup ((U_CHAR *) "__NeXT__", -1, -1)))
3779 /* Find the end of this directive (first newline not backslashed
3780 and not in a string or comment).
3781 Set COPY_DIRECTIVE if the directive must be copied
3782 (it contains a backslash-newline or a comment). */
3784 buf = bp = after_ident;
3785 while (bp < limit) {
3786 register U_CHAR c = *bp++;
3794 } else if (traditional)
3801 bp = skip_quoted_string (bp - 1, limit, ip->lineno, &ip->lineno, ©_directive, &unterminated);
3802 /* Don't bother calling the directive if we already got an error
3803 message due to unterminated string. Skip everything and pretend
3804 we called the directive. */
3807 /* Traditional preprocessing permits unterminated strings. */
3816 /* <...> is special for #include. */
3818 if (!kt->angle_brackets)
3820 while (bp < limit && *bp != '>' && *bp != '\n') {
3821 if (*bp == '\\' && bp[1] == '\n') {
3831 if (*bp == '\\' && bp[1] == '\n')
3834 || (cplusplus_comments && *bp == '/')) {
3835 U_CHAR *obp = bp - 1;
3837 skip_to_end_of_comment (ip, &ip->lineno, 0);
3839 /* No need to copy the directive because of a comment at the end;
3840 just don't include the comment in the directive. */
3841 if (bp == limit || *bp == '\n') {
3845 /* Don't remove the comments if -traditional. */
3846 if (! keep_comments)
3855 pedwarn ("%s in preprocessing directive", char_name[c]);
3859 --bp; /* Point to the newline */
3867 resume_p = ip->bufp;
3868 /* BP is the end of the directive.
3869 RESUME_P is the next interesting data after the directive.
3870 A comment may come between. */
3872 /* If a directive should be copied through, and -E was given,
3873 pass it through before removing comments. */
3874 if (!no_output && kt->pass_thru && put_out_comments) {
3877 /* Output directive name. */
3878 check_expand (op, kt->length + 2);
3879 /* Make sure # is at the start of a line */
3880 if (op->bufp > op->buf && op->bufp[-1] != '\n') {
3885 bcopy (kt->name, op->bufp, kt->length);
3886 op->bufp += kt->length;
3888 /* Output arguments. */
3890 check_expand (op, len);
3891 bcopy (buf, (char *) op->bufp, len);
3893 /* Take account of any (escaped) newlines just output. */
3895 if (buf[len] == '\n')
3898 already_output = &junk;
3899 } /* Don't we need a newline or #line? */
3901 if (copy_directive) {
3902 register U_CHAR *xp = buf;
3903 /* Need to copy entire directive into temp buffer before dispatching */
3905 cp = (U_CHAR *) alloca (bp - buf + 5); /* room for directive plus
3909 /* Copy to the new buffer, deleting comments
3910 and backslash-newlines (and whitespace surrounding the latter). */
3913 register U_CHAR c = *xp++;
3918 abort (); /* A bare newline should never part of the line. */
3921 /* <...> is special for #include. */
3923 if (!kt->angle_brackets)
3925 while (xp < bp && c != '>') {
3927 if (c == '\\' && xp < bp && *xp == '\n')
3938 if (cp != buf && is_space[cp[-1]]) {
3939 while (cp != buf && is_space[cp[-1]]) cp--;
3941 SKIP_WHITE_SPACE (xp);
3942 } else if (is_space[*xp]) {
3944 SKIP_WHITE_SPACE (xp);
3946 } else if (traditional && xp < bp) {
3954 register U_CHAR *bp1
3955 = skip_quoted_string (xp - 1, bp, ip->lineno,
3956 NULL_PTR, NULL_PTR, NULL_PTR);
3970 || (cplusplus_comments && *xp == '/')) {
3972 /* If we already copied the directive through,
3973 already_output != 0 prevents outputting comment now. */
3974 skip_to_end_of_comment (ip, already_output, 0);
3976 while (xp != ip->bufp)
3978 /* Delete or replace the slash. */
3979 else if (traditional)
3988 /* Null-terminate the copy. */
3994 ip->bufp = resume_p;
3996 /* Some directives should be written out for cc1 to process,
3997 just as if they were not defined. And sometimes we're copying
3998 definitions through. */
4000 if (!no_output && already_output == 0
4002 || (kt->type == T_DEFINE
4003 && (dump_macros == dump_names
4004 || dump_macros == dump_definitions)))) {
4007 /* Output directive name. */
4008 check_expand (op, kt->length + 1);
4010 bcopy (kt->name, (char *) op->bufp, kt->length);
4011 op->bufp += kt->length;
4013 if (kt->pass_thru || dump_macros == dump_definitions) {
4014 /* Output arguments. */
4016 check_expand (op, len);
4017 bcopy (buf, (char *) op->bufp, len);
4019 } else if (kt->type == T_DEFINE && dump_macros == dump_names) {
4022 SKIP_WHITE_SPACE (xp);
4024 while (is_idchar[*xp]) xp++;
4026 check_expand (op, len + 1);
4028 bcopy (yp, op->bufp, len);
4031 } /* Don't we need a newline or #line? */
4033 /* Call the appropriate directive handler. buf now points to
4034 either the appropriate place in the input buffer, or to
4035 the temp buffer if it was necessary to make one. cp
4036 points to the first char after the contents of the (possibly
4037 copied) directive, in either case. */
4038 (*kt->func) (buf, cp, op, kt);
4039 check_expand (op, ip->length - (ip->bufp - ip->buf));
4045 /* It is deliberate that we don't warn about undefined directives.
4046 That is the responsibility of cc1. */
4053 static struct tm *timebuf;
4055 time_t t = time ((time_t *)0);
4056 timebuf = localtime (&t);
4061 static char *monthnames[] = {"Jan", "Feb", "Mar", "Apr", "May", "Jun",
4062 "Jul", "Aug", "Sep", "Oct", "Nov", "Dec",
4066 * expand things like __FILE__. Place the expansion into the output
4067 * buffer *without* rescanning.
4071 special_symbol (hp, op)
4078 FILE_BUF *ip = NULL;
4081 int paren = 0; /* For special `defined' keyword */
4083 if (pcp_outfile && pcp_inside_if
4084 && hp->type != T_SPEC_DEFINED && hp->type != T_CONST)
4085 error ("Predefined macro `%s' used inside `#if' during precompilation",
4088 for (i = indepth; i >= 0; i--)
4089 if (instack[i].fname != NULL) {
4094 error ("cccp error: not in any file?!");
4095 return; /* the show must go on */
4103 if (hp->type == T_FILE)
4104 string = ip->nominal_fname;
4106 string = instack[0].nominal_fname;
4110 buf = (char *) alloca (3 + 4 * strlen (string));
4111 quote_string (buf, string);
4119 case T_INCLUDE_LEVEL:
4121 for (i = indepth; i >= 0; i--)
4122 if (instack[i].fname != NULL)
4125 buf = (char *) alloca (8); /* Eight bytes ought to be more than enough */
4126 sprintf (buf, "%d", true_indepth - 1);
4130 buf = (char *) alloca (3 + strlen (version_string));
4131 sprintf (buf, "\"%s\"", version_string);
4134 #ifndef NO_BUILTIN_SIZE_TYPE
4140 #ifndef NO_BUILTIN_PTRDIFF_TYPE
4141 case T_PTRDIFF_TYPE:
4150 case T_USER_LABEL_PREFIX_TYPE:
4151 buf = USER_LABEL_PREFIX;
4154 case T_REGISTER_PREFIX_TYPE:
4155 buf = REGISTER_PREFIX;
4158 case T_IMMEDIATE_PREFIX_TYPE:
4159 buf = IMMEDIATE_PREFIX;
4163 buf = hp->value.cpval;
4164 if (pcp_inside_if && pcp_outfile)
4165 /* Output a precondition for this macro use */
4166 fprintf (pcp_outfile, "#define %s %s\n", hp->name, buf);
4170 buf = (char *) alloca (10);
4171 sprintf (buf, "%d", ip->lineno);
4176 buf = (char *) alloca (20);
4177 timebuf = timestamp ();
4178 if (hp->type == T_DATE)
4179 sprintf (buf, "\"%s %2d %4d\"", monthnames[timebuf->tm_mon],
4180 timebuf->tm_mday, timebuf->tm_year + 1900);
4182 sprintf (buf, "\"%02d:%02d:%02d\"", timebuf->tm_hour, timebuf->tm_min,
4186 case T_SPEC_DEFINED:
4187 buf = " 0 "; /* Assume symbol is not defined */
4188 ip = &instack[indepth];
4189 SKIP_WHITE_SPACE (ip->bufp);
4190 if (*ip->bufp == '(') {
4192 ip->bufp++; /* Skip over the paren */
4193 SKIP_WHITE_SPACE (ip->bufp);
4196 if (!is_idstart[*ip->bufp])
4198 if ((hp = lookup (ip->bufp, -1, -1))) {
4199 if (pcp_outfile && pcp_inside_if
4200 && (hp->type == T_CONST
4201 || (hp->type == T_MACRO && hp->value.defn->predefined)))
4202 /* Output a precondition for this macro use. */
4203 fprintf (pcp_outfile, "#define %s\n", hp->name);
4207 if (pcp_outfile && pcp_inside_if) {
4208 /* Output a precondition for this macro use */
4209 U_CHAR *cp = ip->bufp;
4210 fprintf (pcp_outfile, "#undef ");
4211 while (is_idchar[*cp]) /* Ick! */
4212 fputc (*cp++, pcp_outfile);
4213 putc ('\n', pcp_outfile);
4215 while (is_idchar[*ip->bufp])
4217 SKIP_WHITE_SPACE (ip->bufp);
4219 if (*ip->bufp != ')')
4227 error ("`defined' without an identifier");
4231 error ("cccp error: invalid special hash type"); /* time for gdb */
4235 check_expand (op, len);
4236 bcopy (buf, (char *) op->bufp, len);
4243 /* Routines to handle #directives */
4245 /* Handle #include and #import.
4246 This function expects to see "fname" or <fname> on the input. */
4249 do_include (buf, limit, op, keyword)
4250 U_CHAR *buf, *limit;
4252 struct directive *keyword;
4254 int importing = (keyword->type == T_IMPORT);
4255 int skip_dirs = (keyword->type == T_INCLUDE_NEXT);
4256 static int import_warning = 0;
4257 char *fname; /* Dynamically allocated fname buffer */
4260 U_CHAR *fbeg, *fend; /* Beginning and end of fname */
4262 struct file_name_list *search_start = include; /* Chain of dirs to search */
4263 struct file_name_list dsp[1]; /* First in chain, if #include "..." */
4264 struct file_name_list *searchptr = 0;
4267 int f; /* file number */
4269 int retried = 0; /* Have already tried macro
4270 expanding the include line*/
4271 int angle_brackets = 0; /* 0 for "...", 1 for <...> */
4276 f= -1; /* JF we iz paranoid! */
4278 if (importing && warn_import && !inhibit_warnings
4279 && !instack[indepth].system_header_p && !import_warning) {
4281 warning ("using `#import' is not recommended");
4282 fprintf (stderr, "The fact that a certain header file need not be processed more than once\n");
4283 fprintf (stderr, "should be indicated in the header file, not where it is used.\n");
4284 fprintf (stderr, "The best way to do this is with a conditional of this form:\n\n");
4285 fprintf (stderr, " #ifndef _FOO_H_INCLUDED\n");
4286 fprintf (stderr, " #define _FOO_H_INCLUDED\n");
4287 fprintf (stderr, " ... <real contents of file> ...\n");
4288 fprintf (stderr, " #endif /* Not _FOO_H_INCLUDED */\n\n");
4289 fprintf (stderr, "Then users can use `#include' any number of times.\n");
4290 fprintf (stderr, "GNU C automatically avoids processing the file more than once\n");
4291 fprintf (stderr, "when it is equipped with such a conditional.\n");
4297 SKIP_WHITE_SPACE (fbeg);
4298 /* Discard trailing whitespace so we can easily see
4299 if we have parsed all the significant chars we were given. */
4300 while (limit != fbeg && is_hor_space[limit[-1]]) limit--;
4306 /* Copy the operand text, concatenating the strings. */
4309 fbeg = (U_CHAR *) alloca (limit - fbeg + 1);
4311 while (fin != limit) {
4312 while (fin != limit && *fin != '\"')
4317 /* If not at the end, there had better be another string. */
4318 /* Skip just horiz space, and don't go past limit. */
4319 while (fin != limit && is_hor_space[*fin]) fin++;
4320 if (fin != limit && *fin == '\"')
4328 /* We have "filename". Figure out directory this source
4329 file is coming from and put it on the front of the list. */
4331 /* If -I- was specified, don't search current dir, only spec'd ones. */
4332 if (ignore_srcdir) break;
4334 for (fp = &instack[indepth]; fp >= instack; fp--)
4339 if ((nam = fp->nominal_fname) != NULL) {
4340 /* Found a named file. Figure out dir of the file,
4341 and put it in front of the search list. */
4342 dsp[0].next = search_start;
4345 ep = rindex (nam, '/');
4346 #ifdef DIR_SEPARATOR
4347 if (ep == NULL) ep = rindex (nam, DIR_SEPARATOR);
4349 char *tmp = rindex (nam, DIR_SEPARATOR);
4350 if (tmp != NULL && tmp > ep) ep = tmp;
4354 ep = rindex (nam, ']');
4355 if (ep == NULL) ep = rindex (nam, '>');
4356 if (ep == NULL) ep = rindex (nam, ':');
4357 if (ep != NULL) ep++;
4361 dsp[0].fname = (char *) alloca (n + 1);
4362 strncpy (dsp[0].fname, nam, n);
4363 dsp[0].fname[n] = '\0';
4364 if (n + INCLUDE_LEN_FUDGE > max_include_len)
4365 max_include_len = n + INCLUDE_LEN_FUDGE;
4367 dsp[0].fname = 0; /* Current directory */
4369 dsp[0].got_name_map = 0;
4378 while (fend != limit && *fend != '>') fend++;
4379 if (*fend == '>' && fend + 1 == limit) {
4381 /* If -I-, start with the first -I dir after the -I-. */
4382 if (first_bracket_include)
4383 search_start = first_bracket_include;
4391 * Support '#include xyz' like VAX-C to allow for easy use of all the
4392 * decwindow include files. It defaults to '#include <xyz.h>' (so the
4393 * code from case '<' is repeated here) and generates a warning.
4394 * (Note: macro expansion of `xyz' takes precedence.)
4396 if (retried && isalpha(*(--fbeg))) {
4398 while (fend != limit && (!isspace(*fend))) fend++;
4399 warning ("VAX-C-style include specification found, use '#include <filename.h>' !");
4400 if (fend == limit) {
4402 /* If -I-, start with the first -I dir after the -I-. */
4403 if (first_bracket_include)
4404 search_start = first_bracket_include;
4412 error ("`#%s' expects \"FILENAME\" or <FILENAME>", keyword->name);
4415 /* Expand buffer and then remove any newline markers.
4416 We can't just tell expand_to_temp_buffer to omit the markers,
4417 since it would put extra spaces in include file names. */
4420 trybuf = expand_to_temp_buffer (buf, limit, 1, 0);
4422 buf = (U_CHAR *) alloca (trybuf.bufp - trybuf.buf + 1);
4424 while (src != trybuf.bufp) {
4425 switch ((*limit++ = *src++)) {
4434 U_CHAR *src1 = skip_quoted_string (src - 1, trybuf.bufp, 0,
4435 NULL_PTR, NULL_PTR, NULL_PTR);
4449 /* For #include_next, skip in the search path
4450 past the dir in which the containing file was found. */
4453 for (fp = &instack[indepth]; fp >= instack; fp--)
4454 if (fp->fname != NULL) {
4455 /* fp->dir is null if the containing file was specified
4456 with an absolute file name. In that case, don't skip anything. */
4458 search_start = fp->dir->next;
4467 error ("empty file name in `#%s'", keyword->name);
4471 /* Allocate this permanently, because it gets stored in the definitions
4473 fname = xmalloc (max_include_len + flen + 4);
4474 /* + 2 above for slash and terminating null. */
4475 /* + 2 added for '.h' on VMS (to support '#include filename') */
4477 /* If specified file name is absolute, just open it. */
4480 #ifdef DIR_SEPARATOR
4481 || *fbeg == DIR_SEPARATOR
4484 strncpy (fname, (char *) fbeg, flen);
4486 if (redundant_include_p (fname))
4489 f = lookup_import (fname, NULL_PTR);
4491 f = open_include_file (fname, NULL_PTR);
4493 return 0; /* Already included this file */
4495 /* Search directory path, trying to open the file.
4496 Copy each filename tried into FNAME. */
4498 for (searchptr = search_start; searchptr; searchptr = searchptr->next) {
4499 if (searchptr->fname) {
4500 /* The empty string in a search path is ignored.
4501 This makes it possible to turn off entirely
4502 a standard piece of the list. */
4503 if (searchptr->fname[0] == 0)
4505 strcpy (fname, skip_redundant_dir_prefix (searchptr->fname));
4506 if (fname[0] && fname[strlen (fname) - 1] != '/')
4507 strcat (fname, "/");
4511 strncat (fname, (char *) fbeg, flen);
4513 /* Change this 1/2 Unix 1/2 VMS file specification into a
4514 full VMS file specification */
4515 if (searchptr->fname && (searchptr->fname[0] != 0)) {
4516 /* Fix up the filename */
4517 hack_vms_include_specification (fname);
4519 /* This is a normal VMS filespec, so use it unchanged. */
4520 strncpy (fname, fbeg, flen);
4522 /* if it's '#include filename', add the missing .h */
4523 if (index(fname,'.')==NULL) {
4524 strcat (fname, ".h");
4528 /* ??? There are currently 3 separate mechanisms for avoiding processing
4529 of redundant include files: #import, #pragma once, and
4530 redundant_include_p. It would be nice if they were unified. */
4531 if (redundant_include_p (fname))
4534 f = lookup_import (fname, searchptr);
4536 f = open_include_file (fname, searchptr);
4538 return 0; /* Already included this file */
4540 else if (f == -1 && errno == EACCES)
4541 warning ("Header file %s exists, but is not readable", fname);
4549 /* A file that was not found. */
4551 strncpy (fname, (char *) fbeg, flen);
4553 /* If generating dependencies and -MG was specified, we assume missing
4554 files are leaf files, living in the same directory as the source file
4555 or other similar place; these missing files may be generated from
4556 other files and may not exist yet (eg: y.tab.h). */
4557 if (print_deps_missing_files
4558 && print_deps > (angle_brackets || (system_include_depth > 0)))
4560 /* If it was requested as a system header file,
4561 then assume it belongs in the first place to look for such. */
4564 for (searchptr = search_start; searchptr; searchptr = searchptr->next)
4566 if (searchptr->fname)
4570 if (searchptr->fname[0] == 0)
4572 p = (char *) alloca (strlen (searchptr->fname)
4573 + strlen (fname) + 2);
4574 strcpy (p, skip_redundant_dir_prefix (searchptr->fname));
4575 if (p[0] && p[strlen (p) - 1] != '/')
4578 deps_output (p, ' ');
4585 /* Otherwise, omit the directory, as if the file existed
4586 in the directory with the source. */
4587 deps_output (fname, ' ');
4590 /* If -M was specified, and this header file won't be added to the
4591 dependency list, then don't count this as an error, because we can
4592 still produce correct output. Otherwise, we can't produce correct
4593 output, because there may be dependencies we need inside the missing
4594 file, and we don't know what directory this missing file exists in. */
4596 && (print_deps <= (angle_brackets || (system_include_depth > 0))))
4597 warning ("No include path in which to find %s", fname);
4598 else if (search_start)
4599 error_from_errno (fname);
4601 error ("No include path in which to find %s", fname);
4603 /* Check to see if this include file is a once-only include file.
4606 struct file_name_list* ptr;
4608 for (ptr = dont_repeat_files; ptr; ptr = ptr->next) {
4609 if (!strcmp (ptr->fname, fname)) {
4611 return 0; /* This file was once'd. */
4615 for (ptr = all_include_files; ptr; ptr = ptr->next) {
4616 if (!strcmp (ptr->fname, fname))
4617 break; /* This file was included before. */
4621 /* This is the first time for this file. */
4622 /* Add it to list of files included. */
4624 ptr = (struct file_name_list *) xmalloc (sizeof (struct file_name_list));
4625 ptr->control_macro = 0;
4626 ptr->c_system_include_path = 0;
4627 ptr->next = all_include_files;
4628 all_include_files = ptr;
4629 ptr->fname = savestring (fname);
4630 ptr->got_name_map = 0;
4632 /* For -M, add this file to the dependencies. */
4633 if (print_deps > (angle_brackets || (system_include_depth > 0)))
4634 deps_output (fname, ' ');
4637 /* Handle -H option. */
4638 if (print_include_names)
4639 fprintf (stderr, "%*s%s\n", indepth, "", fname);
4642 system_include_depth++;
4644 /* Actually process the file. */
4645 add_import (f, fname); /* Record file on "seen" list for #import. */
4647 pcftry = (char *) alloca (strlen (fname) + 30);
4658 sprintf (pcftry, "%s%d", fname, pcfnum++);
4660 pcf = open (pcftry, O_RDONLY, 0666);
4666 if (bcmp ((char *) &stat_f.st_ino, (char *) &s.st_ino,
4668 || stat_f.st_dev != s.st_dev)
4670 pcfbuf = check_precompiled (pcf, fname, &pcfbuflimit);
4671 /* Don't need it any more. */
4676 /* Don't need it at all. */
4681 } while (pcf != -1 && !pcfbuf);
4684 /* Actually process the file */
4686 pcfname = xmalloc (strlen (pcftry) + 1);
4687 strcpy (pcfname, pcftry);
4688 pcfinclude ((U_CHAR *) pcfbuf, (U_CHAR *) pcfbuflimit,
4689 (U_CHAR *) fname, op);
4692 finclude (f, fname, op, is_system_include (fname), searchptr);
4695 system_include_depth--;
4700 /* Return nonzero if there is no need to include file NAME
4701 because it has already been included and it contains a conditional
4702 to make a repeated include do nothing. */
4705 redundant_include_p (name)
4708 struct file_name_list *l = all_include_files;
4709 for (; l; l = l->next)
4710 if (! strcmp (name, l->fname)
4712 && lookup (l->control_macro, -1, -1))
4717 /* Return nonzero if the given FILENAME is an absolute pathname which
4718 designates a file within one of the known "system" include file
4719 directories. We assume here that if the given FILENAME looks like
4720 it is the name of a file which resides either directly in a "system"
4721 include file directory, or within any subdirectory thereof, then the
4722 given file must be a "system" include file. This function tells us
4723 if we should suppress pedantic errors/warnings for the given FILENAME.
4725 The value is 2 if the file is a C-language system header file
4726 for which C++ should (on most systems) assume `extern "C"'. */
4729 is_system_include (filename)
4730 register char *filename;
4732 struct file_name_list *searchptr;
4734 for (searchptr = first_system_include; searchptr;
4735 searchptr = searchptr->next)
4736 if (searchptr->fname) {
4737 register char *sys_dir = searchptr->fname;
4738 register unsigned length = strlen (sys_dir);
4740 if (! strncmp (sys_dir, filename, length)
4741 && (filename[length] == '/'
4742 #ifdef DIR_SEPARATOR
4743 || filename[length] == DIR_SEPARATOR
4746 if (searchptr->c_system_include_path)
4755 /* Skip leading "./" from a directory name.
4756 This may yield the empty string, which represents the current directory. */
4759 skip_redundant_dir_prefix (dir)
4762 while (dir[0] == '.' && dir[1] == '/')
4763 for (dir += 2; *dir == '/'; dir++)
4765 if (dir[0] == '.' && !dir[1])
4770 /* The file_name_map structure holds a mapping of file names for a
4771 particular directory. This mapping is read from the file named
4772 FILE_NAME_MAP_FILE in that directory. Such a file can be used to
4773 map filenames on a file system with severe filename restrictions,
4774 such as DOS. The format of the file name map file is just a series
4775 of lines with two tokens on each line. The first token is the name
4776 to map, and the second token is the actual name to use. */
4778 struct file_name_map
4780 struct file_name_map *map_next;
4785 #define FILE_NAME_MAP_FILE "header.gcc"
4787 /* Read a space delimited string of unlimited length from a stdio
4791 read_filename_string (ch, f)
4799 set = alloc = xmalloc (len + 1);
4803 while ((ch = getc (f)) != EOF && ! is_space[ch])
4805 if (set - alloc == len)
4808 alloc = xrealloc (alloc, len + 1);
4809 set = alloc + len / 2;
4819 /* Read the file name map file for DIRNAME. */
4821 static struct file_name_map *
4822 read_name_map (dirname)
4825 /* This structure holds a linked list of file name maps, one per
4827 struct file_name_map_list
4829 struct file_name_map_list *map_list_next;
4830 char *map_list_name;
4831 struct file_name_map *map_list_map;
4833 static struct file_name_map_list *map_list;
4834 register struct file_name_map_list *map_list_ptr;
4838 int separator_needed;
4840 dirname = skip_redundant_dir_prefix (dirname);
4842 for (map_list_ptr = map_list; map_list_ptr;
4843 map_list_ptr = map_list_ptr->map_list_next)
4844 if (! strcmp (map_list_ptr->map_list_name, dirname))
4845 return map_list_ptr->map_list_map;
4847 map_list_ptr = ((struct file_name_map_list *)
4848 xmalloc (sizeof (struct file_name_map_list)));
4849 map_list_ptr->map_list_name = savestring (dirname);
4850 map_list_ptr->map_list_map = NULL;
4852 dirlen = strlen (dirname);
4853 separator_needed = dirlen != 0 && dirname[dirlen - 1] != '/';
4854 name = (char *) alloca (dirlen + strlen (FILE_NAME_MAP_FILE) + 2);
4855 strcpy (name, dirname);
4857 strcpy (name + dirlen + separator_needed, FILE_NAME_MAP_FILE);
4858 f = fopen (name, "r");
4860 map_list_ptr->map_list_map = NULL;
4865 while ((ch = getc (f)) != EOF)
4868 struct file_name_map *ptr;
4872 from = read_filename_string (ch, f);
4873 while ((ch = getc (f)) != EOF && is_hor_space[ch])
4875 to = read_filename_string (ch, f);
4877 ptr = ((struct file_name_map *)
4878 xmalloc (sizeof (struct file_name_map)));
4879 ptr->map_from = from;
4881 /* Make the real filename absolute. */
4886 ptr->map_to = xmalloc (dirlen + strlen (to) + 2);
4887 strcpy (ptr->map_to, dirname);
4888 ptr->map_to[dirlen] = '/';
4889 strcpy (ptr->map_to + dirlen + separator_needed, to);
4893 ptr->map_next = map_list_ptr->map_list_map;
4894 map_list_ptr->map_list_map = ptr;
4896 while ((ch = getc (f)) != '\n')
4903 map_list_ptr->map_list_next = map_list;
4904 map_list = map_list_ptr;
4906 return map_list_ptr->map_list_map;
4909 /* Try to open include file FILENAME. SEARCHPTR is the directory
4910 being tried from the include file search path. This function maps
4911 filenames on file systems based on information read by
4915 open_include_file (filename, searchptr)
4917 struct file_name_list *searchptr;
4919 register struct file_name_map *map;
4920 register char *from;
4923 if (searchptr && ! searchptr->got_name_map)
4925 searchptr->name_map = read_name_map (searchptr->fname
4926 ? searchptr->fname : ".");
4927 searchptr->got_name_map = 1;
4930 /* First check the mapping for the directory we are using. */
4931 if (searchptr && searchptr->name_map)
4934 if (searchptr->fname)
4935 from += strlen (searchptr->fname) + 1;
4936 for (map = searchptr->name_map; map; map = map->map_next)
4938 if (! strcmp (map->map_from, from))
4940 /* Found a match. */
4941 return open (map->map_to, O_RDONLY, 0666);
4946 /* Try to find a mapping file for the particular directory we are
4947 looking in. Thus #include <sys/types.h> will look up sys/types.h
4948 in /usr/include/header.gcc and look up types.h in
4949 /usr/include/sys/header.gcc. */
4950 p = rindex (filename, '/');
4951 #ifdef DIR_SEPARATOR
4952 if (! p) p = rindex (filename, DIR_SEPARATOR);
4954 char *tmp = rindex (filename, DIR_SEPARATOR);
4955 if (tmp != NULL && tmp > p) p = tmp;
4962 && strlen (searchptr->fname) == p - filename
4963 && ! strncmp (searchptr->fname, filename, p - filename))
4965 /* FILENAME is in SEARCHPTR, which we've already checked. */
4966 return open (filename, O_RDONLY, 0666);
4976 dir = (char *) alloca (p - filename + 1);
4977 bcopy (filename, dir, p - filename);
4978 dir[p - filename] = '\0';
4981 for (map = read_name_map (dir); map; map = map->map_next)
4982 if (! strcmp (map->map_from, from))
4983 return open (map->map_to, O_RDONLY, 0666);
4985 return open (filename, O_RDONLY, 0666);
4988 /* Process the contents of include file FNAME, already open on descriptor F,
4990 SYSTEM_HEADER_P is 1 if this file resides in any one of the known
4991 "system" include directories (as decided by the `is_system_include'
4993 DIRPTR is the link in the dir path through which this file was found,
4994 or 0 if the file name was absolute. */
4997 finclude (f, fname, op, system_header_p, dirptr)
5001 int system_header_p;
5002 struct file_name_list *dirptr;
5007 FILE_BUF *fp; /* For input stack frame */
5008 int missing_newline = 0;
5010 CHECK_DEPTH (return;);
5012 if (file_size_and_mode (f, &st_mode, &st_size) < 0)
5014 perror_with_name (fname);
5019 fp = &instack[indepth + 1];
5020 bzero ((char *) fp, sizeof (FILE_BUF));
5021 fp->nominal_fname = fp->fname = fname;
5024 fp->if_stack = if_stack;
5025 fp->system_header_p = system_header_p;
5028 if (S_ISREG (st_mode)) {
5029 fp->buf = (U_CHAR *) xmalloc (st_size + 2);
5032 /* Read the file contents, knowing that st_size is an upper bound
5033 on the number of bytes we can read. */
5034 fp->length = safe_read (f, (char *) fp->buf, st_size);
5035 if (fp->length < 0) goto nope;
5037 else if (S_ISDIR (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 file named FILE
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 (file, macro_name)
5117 struct file_name_list *new;
5119 for (new = all_include_files; new; new = new->next) {
5120 if (!strcmp (new->fname, file)) {
5121 new->control_macro = macro_name;
5126 /* If the file is not in all_include_files, something's wrong. */
5130 /* Maintain and search list of included files, for #import. */
5132 #define IMPORT_HASH_SIZE 31
5134 struct import_file {
5138 struct import_file *next;
5141 /* Hash table of files already included with #include or #import. */
5143 static struct import_file *import_hash_table[IMPORT_HASH_SIZE];
5145 /* Hash a file name for import_hash_table. */
5153 while (*f) val += *f++;
5154 return (val%IMPORT_HASH_SIZE);
5157 /* Search for file FILENAME in import_hash_table.
5158 Return -2 if found, either a matching name or a matching inode.
5159 Otherwise, open the file and return a file descriptor if successful
5160 or -1 if unsuccessful. */
5163 lookup_import (filename, searchptr)
5165 struct file_name_list *searchptr;
5167 struct import_file *i;
5173 hashval = import_hash (filename);
5175 /* Attempt to find file in list of already included files */
5176 i = import_hash_table[hashval];
5179 if (!strcmp (filename, i->name))
5180 return -2; /* return found */
5183 /* Open it and try a match on inode/dev */
5184 fd = open_include_file (filename, searchptr);
5188 for (h = 0; h < IMPORT_HASH_SIZE; h++) {
5189 i = import_hash_table[h];
5191 /* Compare the inode and the device.
5192 Supposedly on some systems the inode is not a scalar. */
5193 if (!bcmp ((char *) &i->inode, (char *) &sb.st_ino, sizeof (sb.st_ino))
5194 && i->dev == sb.st_dev) {
5196 return -2; /* return found */
5201 return fd; /* Not found, return open file */
5204 /* Add the file FNAME, open on descriptor FD, to import_hash_table. */
5207 add_import (fd, fname)
5211 struct import_file *i;
5215 hashval = import_hash (fname);
5217 i = (struct import_file *)xmalloc (sizeof (struct import_file));
5218 i->name = xmalloc (strlen (fname)+1);
5219 strcpy (i->name, fname);
5220 bcopy ((char *) &sb.st_ino, (char *) &i->inode, sizeof (sb.st_ino));
5222 i->next = import_hash_table[hashval];
5223 import_hash_table[hashval] = i;
5226 /* Load the specified precompiled header into core, and verify its
5227 preconditions. PCF indicates the file descriptor to read, which must
5228 be a regular file. FNAME indicates the file name of the original
5229 header. *LIMIT will be set to an address one past the end of the file.
5230 If the preconditions of the file are not satisfied, the buffer is
5231 freed and we return 0. If the preconditions are satisfied, return
5232 the address of the buffer following the preconditions. The buffer, in
5233 this case, should never be freed because various pieces of it will
5234 be referred to until all precompiled strings are output at the end of
5238 check_precompiled (pcf, fname, limit)
5252 if (file_size_and_mode (pcf, &st_mode, &st_size) < 0)
5255 if (S_ISREG (st_mode))
5257 buf = xmalloc (st_size + 2);
5258 length = safe_read (pcf, buf, st_size);
5265 if (length > 0 && buf[length-1] != '\n')
5266 buf[length++] = '\n';
5269 *limit = buf + length;
5271 /* File is in core. Check the preconditions. */
5272 if (!check_preconditions (buf))
5274 for (cp = buf; *cp; cp++)
5277 fprintf (stderr, "Using preinclude %s\n", fname);
5283 fprintf (stderr, "Cannot use preinclude %s\n", fname);
5289 /* PREC (null terminated) points to the preconditions of a
5290 precompiled header. These are a series of #define and #undef
5291 lines which must match the current contents of the hash
5294 check_preconditions (prec)
5301 lineend = index (prec, '\n');
5303 if (*prec++ != '#') {
5304 error ("Bad format encountered while reading precompiled file");
5307 if (!strncmp (prec, "define", 6)) {
5311 mdef = create_definition ((U_CHAR *) prec, (U_CHAR *) lineend, NULL_PTR);
5316 if ((hp = lookup (mdef.symnam, mdef.symlen, -1)) == NULL
5317 || (hp->type != T_MACRO && hp->type != T_CONST)
5318 || (hp->type == T_MACRO
5319 && !compare_defs (mdef.defn, hp->value.defn)
5320 && (mdef.defn->length != 2
5321 || mdef.defn->expansion[0] != '\n'
5322 || mdef.defn->expansion[1] != ' ')))
5324 } else if (!strncmp (prec, "undef", 5)) {
5329 while (is_hor_space[(U_CHAR) *prec])
5332 while (is_idchar[(U_CHAR) *prec])
5336 if (lookup ((U_CHAR *) name, len, -1))
5339 error ("Bad format encountered while reading precompiled file");
5344 /* They all passed successfully */
5348 /* Process the main body of a precompiled file. BUF points to the
5349 string section of the file, following the preconditions. LIMIT is one
5350 character past the end. NAME is the name of the file being read
5351 in. OP is the main output buffer */
5353 pcfinclude (buf, limit, name, op)
5354 U_CHAR *buf, *limit, *name;
5361 /* First in the file comes 4 bytes indicating the number of strings, */
5362 /* in network byte order. (MSB first). */
5364 nstrings = (nstrings << 8) | *cp++;
5365 nstrings = (nstrings << 8) | *cp++;
5366 nstrings = (nstrings << 8) | *cp++;
5368 /* Looping over each string... */
5369 while (nstrings--) {
5370 U_CHAR *string_start;
5371 U_CHAR *endofthiskey;
5375 /* Each string starts with a STRINGDEF structure (str), followed */
5376 /* by the text of the string (string_start) */
5378 /* First skip to a longword boundary */
5379 /* ??? Why a 4-byte boundary? On all machines? */
5380 /* NOTE: This works correctly even if HOST_WIDE_INT
5381 is narrower than a pointer.
5382 Do not try risky measures here to get another type to use!
5383 Do not include stddef.h--it will fail! */
5384 if ((HOST_WIDE_INT) cp & 3)
5385 cp += 4 - ((HOST_WIDE_INT) cp & 3);
5387 /* Now get the string. */
5388 str = (STRINGDEF *) (GENERIC_PTR) cp;
5389 string_start = cp += sizeof (STRINGDEF);
5391 for (; *cp; cp++) /* skip the string */
5394 /* We need to macro expand the string here to ensure that the
5395 proper definition environment is in place. If it were only
5396 expanded when we find out it is needed, macros necessary for
5397 its proper expansion might have had their definitions changed. */
5398 tmpbuf = expand_to_temp_buffer (string_start, cp++, 0, 0);
5399 /* Lineno is already set in the precompiled file */
5400 str->contents = tmpbuf.buf;
5401 str->len = tmpbuf.length;
5403 str->filename = name;
5404 str->output_mark = outbuf.bufp - outbuf.buf;
5407 *stringlist_tailp = str;
5408 stringlist_tailp = &str->chain;
5410 /* Next comes a fourbyte number indicating the number of keys */
5411 /* for this string. */
5413 nkeys = (nkeys << 8) | *cp++;
5414 nkeys = (nkeys << 8) | *cp++;
5415 nkeys = (nkeys << 8) | *cp++;
5417 /* If this number is -1, then the string is mandatory. */
5421 /* Otherwise, for each key, */
5422 for (; nkeys--; free (tmpbuf.buf), cp = endofthiskey + 1) {
5423 KEYDEF *kp = (KEYDEF *) (GENERIC_PTR) cp;
5426 /* It starts with a KEYDEF structure */
5427 cp += sizeof (KEYDEF);
5429 /* Find the end of the key. At the end of this for loop we
5430 advance CP to the start of the next key using this variable. */
5431 endofthiskey = cp + strlen ((char *) cp);
5434 /* Expand the key, and enter it into the hash table. */
5435 tmpbuf = expand_to_temp_buffer (cp, endofthiskey, 0, 0);
5436 tmpbuf.bufp = tmpbuf.buf;
5438 while (is_hor_space[*tmpbuf.bufp])
5440 if (!is_idstart[*tmpbuf.bufp]
5441 || tmpbuf.bufp == tmpbuf.buf + tmpbuf.length) {
5446 hp = lookup (tmpbuf.bufp, -1, -1);
5449 install (tmpbuf.bufp, -1, T_PCSTRING, (char *) kp, -1);
5451 else if (hp->type == T_PCSTRING) {
5452 kp->chain = hp->value.keydef;
5453 hp->value.keydef = kp;
5459 /* This output_line_directive serves to switch us back to the current
5460 input file in case some of these strings get output (which will
5461 result in line directives for the header file being output). */
5462 output_line_directive (&instack[indepth], op, 0, enter_file);
5465 /* Called from rescan when it hits a key for strings. Mark them all */
5466 /* used and clean up. */
5473 for (kp = hp->value.keydef; kp; kp = kp->chain)
5474 kp->str->writeflag = 1;
5478 /* Write the output, interspersing precompiled strings in their */
5479 /* appropriate places. */
5483 STRINGDEF *next_string;
5484 U_CHAR *cur_buf_loc;
5485 int line_directive_len = 80;
5486 char *line_directive = xmalloc (line_directive_len);
5489 /* In each run through the loop, either cur_buf_loc == */
5490 /* next_string_loc, in which case we print a series of strings, or */
5491 /* it is less than next_string_loc, in which case we write some of */
5493 cur_buf_loc = outbuf.buf;
5494 next_string = stringlist;
5496 while (cur_buf_loc < outbuf.bufp || next_string) {
5498 && cur_buf_loc - outbuf.buf == next_string->output_mark) {
5499 if (next_string->writeflag) {
5500 len = 4 * strlen ((char *) next_string->filename) + 32;
5501 while (len > line_directive_len)
5502 line_directive = xrealloc (line_directive,
5503 line_directive_len *= 2);
5504 sprintf (line_directive, "\n# %d ", next_string->lineno);
5505 strcpy (quote_string (line_directive + strlen (line_directive),
5506 (char *) next_string->filename),
5508 safe_write (fileno (stdout), line_directive, strlen (line_directive));
5509 safe_write (fileno (stdout),
5510 (char *) next_string->contents, next_string->len);
5512 next_string = next_string->chain;
5516 ? (next_string->output_mark
5517 - (cur_buf_loc - outbuf.buf))
5518 : outbuf.bufp - cur_buf_loc);
5520 safe_write (fileno (stdout), (char *) cur_buf_loc, len);
5524 free (line_directive);
5527 /* Pass a directive through to the output file.
5528 BUF points to the contents of the directive, as a contiguous string.
5529 LIMIT points to the first character past the end of the directive.
5530 KEYWORD is the keyword-table entry for the directive. */
5533 pass_thru_directive (buf, limit, op, keyword)
5534 U_CHAR *buf, *limit;
5536 struct directive *keyword;
5538 register unsigned keyword_length = keyword->length;
5540 check_expand (op, 1 + keyword_length + (limit - buf));
5542 bcopy (keyword->name, (char *) op->bufp, keyword_length);
5543 op->bufp += keyword_length;
5544 if (limit != buf && buf[0] != ' ')
5546 bcopy ((char *) buf, (char *) op->bufp, limit - buf);
5547 op->bufp += (limit - buf);
5550 /* Count the line we have just made in the output,
5551 to get in sync properly. */
5556 /* The arglist structure is built by do_define to tell
5557 collect_definition where the argument names begin. That
5558 is, for a define like "#define f(x,y,z) foo+x-bar*y", the arglist
5559 would contain pointers to the strings x, y, and z.
5560 Collect_definition would then build a DEFINITION node,
5561 with reflist nodes pointing to the places x, y, and z had
5562 appeared. So the arglist is just convenience data passed
5563 between these two routines. It is not kept around after
5564 the current #define has been processed and entered into the
5568 struct arglist *next;
5575 /* Create a DEFINITION node from a #define directive. Arguments are
5576 as for do_define. */
5578 create_definition (buf, limit, op)
5579 U_CHAR *buf, *limit;
5582 U_CHAR *bp; /* temp ptr into input buffer */
5583 U_CHAR *symname; /* remember where symbol name starts */
5584 int sym_length; /* and how long it is */
5585 int line = instack[indepth].lineno;
5586 char *file = instack[indepth].nominal_fname;
5590 int arglengths = 0; /* Accumulate lengths of arg names
5591 plus number of args. */
5596 while (is_hor_space[*bp])
5599 symname = bp; /* remember where it starts */
5600 sym_length = check_macro_name (bp, "macro");
5603 /* Lossage will occur if identifiers or control keywords are broken
5604 across lines using backslash. This is not the right place to take
5608 struct arglist *arg_ptrs = NULL;
5611 bp++; /* skip '(' */
5612 SKIP_WHITE_SPACE (bp);
5614 /* Loop over macro argument names. */
5615 while (*bp != ')') {
5616 struct arglist *temp;
5618 temp = (struct arglist *) alloca (sizeof (struct arglist));
5620 temp->next = arg_ptrs;
5621 temp->argno = argno++;
5622 temp->rest_args = 0;
5626 pedwarn ("another parameter follows `%s'",
5629 if (!is_idstart[*bp])
5630 pedwarn ("invalid character in macro parameter name");
5632 /* Find the end of the arg name. */
5633 while (is_idchar[*bp]) {
5635 /* do we have a "special" rest-args extension here? */
5636 if (limit - bp > REST_EXTENSION_LENGTH &&
5637 bcmp (rest_extension, bp, REST_EXTENSION_LENGTH) == 0) {
5639 temp->rest_args = 1;
5643 temp->length = bp - temp->name;
5645 bp += REST_EXTENSION_LENGTH;
5646 arglengths += temp->length + 2;
5647 SKIP_WHITE_SPACE (bp);
5648 if (temp->length == 0 || (*bp != ',' && *bp != ')')) {
5649 error ("badly punctuated parameter list in `#define'");
5654 SKIP_WHITE_SPACE (bp);
5655 /* A comma at this point can only be followed by an identifier. */
5656 if (!is_idstart[*bp]) {
5657 error ("badly punctuated parameter list in `#define'");
5662 error ("unterminated parameter list in `#define'");
5666 struct arglist *otemp;
5668 for (otemp = temp->next; otemp != NULL; otemp = otemp->next)
5669 if (temp->length == otemp->length &&
5670 bcmp (temp->name, otemp->name, temp->length) == 0) {
5671 error ("duplicate argument name `%.*s' in `#define'",
5672 temp->length, temp->name);
5678 ++bp; /* skip paren */
5679 SKIP_WHITE_SPACE (bp);
5680 /* now everything from bp before limit is the definition. */
5681 defn = collect_expansion (bp, limit, argno, arg_ptrs);
5682 defn->rest_args = rest_args;
5684 /* Now set defn->args.argnames to the result of concatenating
5685 the argument names in reverse order
5686 with comma-space between them. */
5687 defn->args.argnames = (U_CHAR *) xmalloc (arglengths + 1);
5689 struct arglist *temp;
5691 for (temp = arg_ptrs; temp; temp = temp->next) {
5692 bcopy (temp->name, &defn->args.argnames[i], temp->length);
5694 if (temp->next != 0) {
5695 defn->args.argnames[i++] = ',';
5696 defn->args.argnames[i++] = ' ';
5699 defn->args.argnames[i] = 0;
5702 /* Simple expansion or empty definition. */
5706 if (is_hor_space[*bp]) {
5708 SKIP_WHITE_SPACE (bp);
5711 case '!': case '"': case '#': case '%': case '&': case '\'':
5712 case ')': case '*': case '+': case ',': case '-': case '.':
5713 case '/': case ':': case ';': case '<': case '=': case '>':
5714 case '?': case '[': case '\\': case ']': case '^': case '{':
5715 case '|': case '}': case '~':
5716 warning ("missing white space after `#define %.*s'",
5717 sym_length, symname);
5721 pedwarn ("missing white space after `#define %.*s'",
5722 sym_length, symname);
5727 /* Now everything from bp before limit is the definition. */
5728 defn = collect_expansion (bp, limit, -1, NULL_PTR);
5729 defn->args.argnames = (U_CHAR *) "";
5735 /* OP is null if this is a predefinition */
5736 defn->predefined = !op;
5738 mdef.symnam = symname;
5739 mdef.symlen = sym_length;
5748 /* Process a #define directive.
5749 BUF points to the contents of the #define directive, as a contiguous string.
5750 LIMIT points to the first character past the end of the definition.
5751 KEYWORD is the keyword-table entry for #define. */
5754 do_define (buf, limit, op, keyword)
5755 U_CHAR *buf, *limit;
5757 struct directive *keyword;
5762 /* If this is a precompiler run (with -pcp) pass thru #define directives. */
5763 if (pcp_outfile && op)
5764 pass_thru_directive (buf, limit, op, keyword);
5766 mdef = create_definition (buf, limit, op);
5770 hashcode = hashf (mdef.symnam, mdef.symlen, HASHSIZE);
5774 if ((hp = lookup (mdef.symnam, mdef.symlen, hashcode)) != NULL) {
5776 /* Redefining a precompiled key is ok. */
5777 if (hp->type == T_PCSTRING)
5779 /* Redefining a macro is ok if the definitions are the same. */
5780 else if (hp->type == T_MACRO)
5781 ok = ! compare_defs (mdef.defn, hp->value.defn);
5782 /* Redefining a constant is ok with -D. */
5783 else if (hp->type == T_CONST)
5784 ok = ! done_initializing;
5785 /* Print the warning if it's not ok. */
5787 /* If we are passing through #define and #undef directives, do
5788 that for this re-definition now. */
5789 if (debug_output && op)
5790 pass_thru_directive (buf, limit, op, keyword);
5792 pedwarn ("`%.*s' redefined", mdef.symlen, mdef.symnam);
5793 if (hp->type == T_MACRO)
5794 pedwarn_with_file_and_line (hp->value.defn->file, hp->value.defn->line,
5795 "this is the location of the previous definition");
5797 /* Replace the old definition. */
5799 hp->value.defn = mdef.defn;
5801 /* If we are passing through #define and #undef directives, do
5802 that for this new definition now. */
5803 if (debug_output && op)
5804 pass_thru_directive (buf, limit, op, keyword);
5805 install (mdef.symnam, mdef.symlen, T_MACRO,
5806 (char *) mdef.defn, hashcode);
5817 /* Check a purported macro name SYMNAME, and yield its length.
5818 USAGE is the kind of name this is intended for. */
5821 check_macro_name (symname, usage)
5828 for (p = symname; is_idchar[*p]; p++)
5830 sym_length = p - symname;
5831 if (sym_length == 0)
5832 error ("invalid %s name", usage);
5833 else if (!is_idstart[*symname]
5834 || (sym_length == 7 && ! bcmp (symname, "defined", 7)))
5835 error ("invalid %s name `%.*s'", usage, sym_length, symname);
5840 * return zero if two DEFINITIONs are isomorphic
5843 compare_defs (d1, d2)
5844 DEFINITION *d1, *d2;
5846 register struct reflist *a1, *a2;
5847 register U_CHAR *p1 = d1->expansion;
5848 register U_CHAR *p2 = d2->expansion;
5851 if (d1->nargs != d2->nargs)
5853 if (strcmp ((char *)d1->args.argnames, (char *)d2->args.argnames))
5855 for (a1 = d1->pattern, a2 = d2->pattern; a1 && a2;
5856 a1 = a1->next, a2 = a2->next) {
5857 if (!((a1->nchars == a2->nchars && ! bcmp (p1, p2, a1->nchars))
5858 || ! comp_def_part (first, p1, a1->nchars, p2, a2->nchars, 0))
5859 || a1->argno != a2->argno
5860 || a1->stringify != a2->stringify
5861 || a1->raw_before != a2->raw_before
5862 || a1->raw_after != a2->raw_after)
5870 if (comp_def_part (first, p1, d1->length - (p1 - d1->expansion),
5871 p2, d2->length - (p2 - d2->expansion), 1))
5876 /* Return 1 if two parts of two macro definitions are effectively different.
5877 One of the parts starts at BEG1 and has LEN1 chars;
5878 the other has LEN2 chars at BEG2.
5879 Any sequence of whitespace matches any other sequence of whitespace.
5880 FIRST means these parts are the first of a macro definition;
5881 so ignore leading whitespace entirely.
5882 LAST means these parts are the last of a macro definition;
5883 so ignore trailing whitespace entirely. */
5886 comp_def_part (first, beg1, len1, beg2, len2, last)
5888 U_CHAR *beg1, *beg2;
5892 register U_CHAR *end1 = beg1 + len1;
5893 register U_CHAR *end2 = beg2 + len2;
5895 while (beg1 != end1 && is_space[*beg1]) beg1++;
5896 while (beg2 != end2 && is_space[*beg2]) beg2++;
5899 while (beg1 != end1 && is_space[end1[-1]]) end1--;
5900 while (beg2 != end2 && is_space[end2[-1]]) end2--;
5902 while (beg1 != end1 && beg2 != end2) {
5903 if (is_space[*beg1] && is_space[*beg2]) {
5904 while (beg1 != end1 && is_space[*beg1]) beg1++;
5905 while (beg2 != end2 && is_space[*beg2]) beg2++;
5906 } else if (*beg1 == *beg2) {
5910 return (beg1 != end1) || (beg2 != end2);
5913 /* Read a replacement list for a macro with parameters.
5914 Build the DEFINITION structure.
5915 Reads characters of text starting at BUF until END.
5916 ARGLIST specifies the formal parameters to look for
5917 in the text of the definition; NARGS is the number of args
5918 in that list, or -1 for a macro name that wants no argument list.
5919 MACRONAME is the macro name itself (so we can avoid recursive expansion)
5920 and NAMELEN is its length in characters.
5922 Note that comments, backslash-newlines, and leading white space
5923 have already been deleted from the argument. */
5925 /* If there is no trailing whitespace, a Newline Space is added at the end
5926 to prevent concatenation that would be contrary to the standard. */
5929 collect_expansion (buf, end, nargs, arglist)
5932 struct arglist *arglist;
5935 register U_CHAR *p, *limit, *lastp, *exp_p;
5936 struct reflist *endpat = NULL;
5937 /* Pointer to first nonspace after last ## seen. */
5939 /* Pointer to first nonspace after last single-# seen. */
5940 U_CHAR *stringify = 0;
5941 /* How those tokens were spelled. */
5942 enum sharp_token_type concat_sharp_token_type = NO_SHARP_TOKEN;
5943 enum sharp_token_type stringify_sharp_token_type = NO_SHARP_TOKEN;
5945 int expected_delimiter = '\0';
5947 /* Scan thru the replacement list, ignoring comments and quoted
5948 strings, picking up on the macro calls. It does a linear search
5949 thru the arg list on every potential symbol. Profiling might say
5950 that something smarter should happen. */
5955 /* Find the beginning of the trailing whitespace. */
5958 while (p < limit && is_space[limit[-1]]) limit--;
5960 /* Allocate space for the text in the macro definition.
5961 Each input char may or may not need 1 byte,
5962 so this is an upper bound.
5963 The extra 3 are for invented trailing newline-marker and final null. */
5964 maxsize = (sizeof (DEFINITION)
5966 defn = (DEFINITION *) xcalloc (1, maxsize);
5968 defn->nargs = nargs;
5969 exp_p = defn->expansion = (U_CHAR *) defn + sizeof (DEFINITION);
5974 : p[0] == '%' && p[1] == ':' && p[2] == '%' && p[3] == ':') {
5975 error ("`##' at start of macro definition");
5976 p += p[0] == '#' ? 2 : 4;
5979 /* Process the main body of the definition. */
5981 int skipped_arg = 0;
5982 register U_CHAR c = *p++;
5990 if (expected_delimiter != '\0') {
5991 if (c == expected_delimiter)
5992 expected_delimiter = '\0';
5994 expected_delimiter = c;
5998 if (p < limit && expected_delimiter) {
5999 /* In a string, backslash goes through
6000 and makes next char ordinary. */
6006 if (!expected_delimiter && *p == ':') {
6007 /* %: is not a digraph if preceded by an odd number of '<'s. */
6009 while (buf < p0 && p0[-1] == '<')
6012 /* Treat %:%: as ## and %: as #. */
6013 if (p[1] == '%' && p[2] == ':') {
6015 goto sharp_sharp_token;
6026 /* # is ordinary inside a string. */
6027 if (expected_delimiter)
6031 /* ##: concatenate preceding and following tokens. */
6032 /* Take out the first #, discard preceding whitespace. */
6034 while (exp_p > lastp && is_hor_space[exp_p[-1]])
6036 /* Skip the second #. */
6038 concat_sharp_token_type = c;
6039 if (is_hor_space[*p]) {
6040 concat_sharp_token_type = c + 1;
6042 SKIP_WHITE_SPACE (p);
6046 error ("`##' at end of macro definition");
6047 } else if (nargs >= 0) {
6048 /* Single #: stringify following argument ref.
6049 Don't leave the # in the expansion. */
6052 stringify_sharp_token_type = c;
6053 if (is_hor_space[*p]) {
6054 stringify_sharp_token_type = c + 1;
6056 SKIP_WHITE_SPACE (p);
6058 if (! is_idstart[*p] || nargs == 0)
6059 error ("`#' operator is not followed by a macro argument name");
6066 /* In -traditional mode, recognize arguments inside strings and
6067 and character constants, and ignore special properties of #.
6068 Arguments inside strings are considered "stringified", but no
6069 extra quote marks are supplied. */
6073 if (expected_delimiter != '\0') {
6074 if (c == expected_delimiter)
6075 expected_delimiter = '\0';
6077 expected_delimiter = c;
6081 /* Backslash quotes delimiters and itself, but not macro args. */
6082 if (expected_delimiter != 0 && p < limit
6083 && (*p == expected_delimiter || *p == '\\')) {
6090 if (expected_delimiter != '\0') /* No comments inside strings. */
6093 /* If we find a comment that wasn't removed by handle_directive,
6094 this must be -traditional. So replace the comment with
6098 while (p < limit && !(p[-2] == '*' && p[-1] == '/'))
6101 /* Mark this as a concatenation-point, as if it had been ##. */
6109 /* Handle the start of a symbol. */
6110 if (is_idchar[c] && nargs > 0) {
6111 U_CHAR *id_beg = p - 1;
6115 while (p != limit && is_idchar[*p]) p++;
6116 id_len = p - id_beg;
6118 if (is_idstart[c]) {
6119 register struct arglist *arg;
6121 for (arg = arglist; arg != NULL; arg = arg->next) {
6122 struct reflist *tpat;
6124 if (arg->name[0] == c
6125 && arg->length == id_len
6126 && bcmp (arg->name, id_beg, id_len) == 0) {
6127 enum sharp_token_type tpat_stringify;
6128 if (expected_delimiter) {
6129 if (warn_stringify) {
6131 warning ("macro argument `%.*s' is stringified.",
6134 warning ("macro arg `%.*s' would be stringified with -traditional.",
6138 /* If ANSI, don't actually substitute inside a string. */
6141 tpat_stringify = SHARP_TOKEN;
6144 = (stringify == id_beg
6145 ? stringify_sharp_token_type : NO_SHARP_TOKEN);
6147 /* make a pat node for this arg and append it to the end of
6149 tpat = (struct reflist *) xmalloc (sizeof (struct reflist));
6152 = concat == id_beg ? concat_sharp_token_type : NO_SHARP_TOKEN;
6153 tpat->raw_after = NO_SHARP_TOKEN;
6154 tpat->rest_args = arg->rest_args;
6155 tpat->stringify = tpat_stringify;
6158 defn->pattern = tpat;
6160 endpat->next = tpat;
6163 tpat->argno = arg->argno;
6164 tpat->nchars = exp_p - lastp;
6166 register U_CHAR *p1 = p;
6167 SKIP_WHITE_SPACE (p1);
6170 : p1[0]=='%' && p1[1]==':' && p1[2]=='%' && p1[3]==':')
6171 tpat->raw_after = p1[0] + (p != p1);
6173 lastp = exp_p; /* place to start copying from next time */
6180 /* If this was not a macro arg, copy it into the expansion. */
6181 if (! skipped_arg) {
6182 register U_CHAR *lim1 = p;
6186 if (stringify == id_beg)
6187 error ("`#' operator should be followed by a macro argument name");
6192 if (!traditional && expected_delimiter == 0) {
6193 /* If ANSI, put in a newline-space marker to prevent token pasting.
6194 But not if "inside a string" (which in ANSI mode happens only for
6202 defn->length = exp_p - defn->expansion;
6204 /* Crash now if we overrun the allocated size. */
6205 if (defn->length + 1 > maxsize)
6209 /* This isn't worth the time it takes. */
6210 /* give back excess storage */
6211 defn->expansion = (U_CHAR *) xrealloc (defn->expansion, defn->length + 1);
6218 do_assert (buf, limit, op, keyword)
6219 U_CHAR *buf, *limit;
6221 struct directive *keyword;
6223 U_CHAR *bp; /* temp ptr into input buffer */
6224 U_CHAR *symname; /* remember where symbol name starts */
6225 int sym_length; /* and how long it is */
6226 struct arglist *tokens = NULL;
6228 if (pedantic && done_initializing && !instack[indepth].system_header_p)
6229 pedwarn ("ANSI C does not allow `#assert'");
6233 while (is_hor_space[*bp])
6236 symname = bp; /* remember where it starts */
6237 sym_length = check_macro_name (bp, "assertion");
6239 /* #define doesn't do this, but we should. */
6240 SKIP_WHITE_SPACE (bp);
6242 /* Lossage will occur if identifiers or control tokens are broken
6243 across lines using backslash. This is not the right place to take
6247 error ("missing token-sequence in `#assert'");
6254 bp++; /* skip '(' */
6255 SKIP_WHITE_SPACE (bp);
6257 tokens = read_token_list (&bp, limit, &error_flag);
6261 error ("empty token-sequence in `#assert'");
6265 ++bp; /* skip paren */
6266 SKIP_WHITE_SPACE (bp);
6269 /* If this name isn't already an assertion name, make it one.
6270 Error if it was already in use in some other way. */
6273 ASSERTION_HASHNODE *hp;
6274 int hashcode = hashf (symname, sym_length, ASSERTION_HASHSIZE);
6275 struct tokenlist_list *value
6276 = (struct tokenlist_list *) xmalloc (sizeof (struct tokenlist_list));
6278 hp = assertion_lookup (symname, sym_length, hashcode);
6280 if (sym_length == 7 && ! bcmp (symname, "defined", 7))
6281 error ("`defined' redefined as assertion");
6282 hp = assertion_install (symname, sym_length, hashcode);
6285 /* Add the spec'd token-sequence to the list of such. */
6286 value->tokens = tokens;
6287 value->next = hp->value;
6295 do_unassert (buf, limit, op, keyword)
6296 U_CHAR *buf, *limit;
6298 struct directive *keyword;
6300 U_CHAR *bp; /* temp ptr into input buffer */
6301 U_CHAR *symname; /* remember where symbol name starts */
6302 int sym_length; /* and how long it is */
6304 struct arglist *tokens = NULL;
6305 int tokens_specified = 0;
6307 if (pedantic && done_initializing && !instack[indepth].system_header_p)
6308 pedwarn ("ANSI C does not allow `#unassert'");
6312 while (is_hor_space[*bp])
6315 symname = bp; /* remember where it starts */
6316 sym_length = check_macro_name (bp, "assertion");
6318 /* #define doesn't do this, but we should. */
6319 SKIP_WHITE_SPACE (bp);
6321 /* Lossage will occur if identifiers or control tokens are broken
6322 across lines using backslash. This is not the right place to take
6328 bp++; /* skip '(' */
6329 SKIP_WHITE_SPACE (bp);
6331 tokens = read_token_list (&bp, limit, &error_flag);
6335 error ("empty token list in `#unassert'");
6339 tokens_specified = 1;
6341 ++bp; /* skip paren */
6342 SKIP_WHITE_SPACE (bp);
6346 ASSERTION_HASHNODE *hp;
6347 int hashcode = hashf (symname, sym_length, ASSERTION_HASHSIZE);
6348 struct tokenlist_list *tail, *prev;
6350 hp = assertion_lookup (symname, sym_length, hashcode);
6354 /* If no token list was specified, then eliminate this assertion
6356 if (! tokens_specified) {
6357 struct tokenlist_list *next;
6358 for (tail = hp->value; tail; tail = next) {
6360 free_token_list (tail->tokens);
6363 delete_assertion (hp);
6365 /* If a list of tokens was given, then delete any matching list. */
6370 struct tokenlist_list *next = tail->next;
6371 if (compare_token_lists (tail->tokens, tokens)) {
6375 hp->value = tail->next;
6376 free_token_list (tail->tokens);
6389 /* Test whether there is an assertion named NAME
6390 and optionally whether it has an asserted token list TOKENS.
6391 NAME is not null terminated; its length is SYM_LENGTH.
6392 If TOKENS_SPECIFIED is 0, then don't check for any token list. */
6395 check_assertion (name, sym_length, tokens_specified, tokens)
6398 int tokens_specified;
6399 struct arglist *tokens;
6401 ASSERTION_HASHNODE *hp;
6402 int hashcode = hashf (name, sym_length, ASSERTION_HASHSIZE);
6404 if (pedantic && !instack[indepth].system_header_p)
6405 pedwarn ("ANSI C does not allow testing assertions");
6407 hp = assertion_lookup (name, sym_length, hashcode);
6409 /* It is not an assertion; just return false. */
6412 /* If no token list was specified, then value is 1. */
6413 if (! tokens_specified)
6417 struct tokenlist_list *tail;
6421 /* If a list of tokens was given,
6422 then succeed if the assertion records a matching list. */
6425 if (compare_token_lists (tail->tokens, tokens))
6430 /* Fail if the assertion has no matching list. */
6435 /* Compare two lists of tokens for equality including order of tokens. */
6438 compare_token_lists (l1, l2)
6439 struct arglist *l1, *l2;
6442 if (l1->length != l2->length)
6444 if (bcmp (l1->name, l2->name, l1->length))
6450 /* Succeed if both lists end at the same time. */
6454 /* Read a space-separated list of tokens ending in a close parenthesis.
6455 Return a list of strings, in the order they were written.
6456 (In case of error, return 0 and store -1 in *ERROR_FLAG.)
6457 Parse the text starting at *BPP, and update *BPP.
6458 Don't parse beyond LIMIT. */
6460 static struct arglist *
6461 read_token_list (bpp, limit, error_flag)
6466 struct arglist *token_ptrs = 0;
6472 /* Loop over the assertion value tokens. */
6474 struct arglist *temp;
6478 /* Find the end of the token. */
6482 } else if (*bp == ')') {
6487 } else if (*bp == '"' || *bp == '\'')
6488 bp = skip_quoted_string (bp, limit, 0, NULL_PTR, NULL_PTR, &eofp);
6490 while (! is_hor_space[*bp] && *bp != '(' && *bp != ')'
6491 && *bp != '"' && *bp != '\'' && bp != limit)
6494 temp = (struct arglist *) xmalloc (sizeof (struct arglist));
6495 temp->name = (U_CHAR *) xmalloc (bp - beg + 1);
6496 bcopy ((char *) beg, (char *) temp->name, bp - beg);
6497 temp->name[bp - beg] = 0;
6498 temp->next = token_ptrs;
6500 temp->length = bp - beg;
6502 SKIP_WHITE_SPACE (bp);
6505 error ("unterminated token sequence in `#assert' or `#unassert'");
6512 /* We accumulated the names in reverse order.
6513 Now reverse them to get the proper order. */
6515 register struct arglist *prev = 0, *this, *next;
6516 for (this = token_ptrs; this; this = next) {
6526 free_token_list (tokens)
6527 struct arglist *tokens;
6530 struct arglist *next = tokens->next;
6531 free (tokens->name);
6538 * Install a name in the assertion hash table.
6540 * If LEN is >= 0, it is the length of the name.
6541 * Otherwise, compute the length by scanning the entire name.
6543 * If HASH is >= 0, it is the precomputed hash code.
6544 * Otherwise, compute the hash code.
6546 static ASSERTION_HASHNODE *
6547 assertion_install (name, len, hash)
6552 register ASSERTION_HASHNODE *hp;
6553 register int i, bucket;
6554 register U_CHAR *p, *q;
6556 i = sizeof (ASSERTION_HASHNODE) + len + 1;
6557 hp = (ASSERTION_HASHNODE *) xmalloc (i);
6559 hp->bucket_hdr = &assertion_hashtab[bucket];
6560 hp->next = assertion_hashtab[bucket];
6561 assertion_hashtab[bucket] = hp;
6563 if (hp->next != NULL)
6564 hp->next->prev = hp;
6567 hp->name = ((U_CHAR *) hp) + sizeof (ASSERTION_HASHNODE);
6570 for (i = 0; i < len; i++)
6577 * find the most recent hash node for name name (ending with first
6578 * non-identifier char) installed by install
6580 * If LEN is >= 0, it is the length of the name.
6581 * Otherwise, compute the length by scanning the entire name.
6583 * If HASH is >= 0, it is the precomputed hash code.
6584 * Otherwise, compute the hash code.
6586 static ASSERTION_HASHNODE *
6587 assertion_lookup (name, len, hash)
6592 register ASSERTION_HASHNODE *bucket;
6594 bucket = assertion_hashtab[hash];
6596 if (bucket->length == len && bcmp (bucket->name, name, len) == 0)
6598 bucket = bucket->next;
6604 delete_assertion (hp)
6605 ASSERTION_HASHNODE *hp;
6608 if (hp->prev != NULL)
6609 hp->prev->next = hp->next;
6610 if (hp->next != NULL)
6611 hp->next->prev = hp->prev;
6613 /* make sure that the bucket chain header that
6614 the deleted guy was on points to the right thing afterwards. */
6615 if (hp == *hp->bucket_hdr)
6616 *hp->bucket_hdr = hp->next;
6622 * interpret #line directive. Remembers previously seen fnames
6623 * in its very own hash table.
6625 #define FNAME_HASHSIZE 37
6628 do_line (buf, limit, op, keyword)
6629 U_CHAR *buf, *limit;
6631 struct directive *keyword;
6633 register U_CHAR *bp;
6634 FILE_BUF *ip = &instack[indepth];
6637 enum file_change_code file_change = same_file;
6639 /* Expand any macros. */
6640 tem = expand_to_temp_buffer (buf, limit, 0, 0);
6642 /* Point to macroexpanded line, which is null-terminated now. */
6644 SKIP_WHITE_SPACE (bp);
6646 if (!isdigit (*bp)) {
6647 error ("invalid format `#line' directive");
6651 /* The Newline at the end of this line remains to be processed.
6652 To put the next line at the specified line number,
6653 we must store a line number now that is one less. */
6654 new_lineno = atoi ((char *) bp) - 1;
6656 /* NEW_LINENO is one less than the actual line number here. */
6657 if (pedantic && new_lineno < 0)
6658 pedwarn ("line number out of range in `#line' directive");
6660 /* skip over the line number. */
6661 while (isdigit (*bp))
6664 #if 0 /* #line 10"foo.c" is supposed to be allowed. */
6665 if (*bp && !is_space[*bp]) {
6666 error ("invalid format `#line' directive");
6671 SKIP_WHITE_SPACE (bp);
6674 static HASHNODE *fname_table[FNAME_HASHSIZE];
6675 HASHNODE *hp, **hash_bucket;
6681 /* Turn the file name, which is a character string literal,
6682 into a null-terminated string. Do this in place. */
6685 switch ((*p++ = *bp++)) {
6687 error ("invalid format `#line' directive");
6692 char *bpc = (char *) bp;
6693 int c = parse_escape (&bpc);
6694 bp = (U_CHAR *) bpc;
6707 fname_length = p - fname;
6709 SKIP_WHITE_SPACE (bp);
6712 pedwarn ("garbage at end of `#line' directive");
6714 file_change = enter_file;
6715 else if (*bp == '2')
6716 file_change = leave_file;
6717 else if (*bp == '3')
6718 ip->system_header_p = 1;
6719 else if (*bp == '4')
6720 ip->system_header_p = 2;
6722 error ("invalid format `#line' directive");
6727 SKIP_WHITE_SPACE (bp);
6729 ip->system_header_p = 1;
6731 SKIP_WHITE_SPACE (bp);
6734 ip->system_header_p = 2;
6736 SKIP_WHITE_SPACE (bp);
6739 error ("invalid format `#line' directive");
6745 &fname_table[hashf (fname, fname_length, FNAME_HASHSIZE)];
6746 for (hp = *hash_bucket; hp != NULL; hp = hp->next)
6747 if (hp->length == fname_length &&
6748 bcmp (hp->value.cpval, fname, fname_length) == 0) {
6749 ip->nominal_fname = hp->value.cpval;
6753 /* Didn't find it; cons up a new one. */
6754 hp = (HASHNODE *) xcalloc (1, sizeof (HASHNODE) + fname_length + 1);
6755 hp->next = *hash_bucket;
6758 hp->length = fname_length;
6759 ip->nominal_fname = hp->value.cpval = ((char *) hp) + sizeof (HASHNODE);
6760 bcopy (fname, hp->value.cpval, fname_length);
6763 error ("invalid format `#line' directive");
6767 ip->lineno = new_lineno;
6768 output_line_directive (ip, op, 0, file_change);
6769 check_expand (op, ip->length - (ip->bufp - ip->buf));
6774 * remove the definition of a symbol from the symbol table.
6775 * according to un*x /lib/cpp, it is not an error to undef
6776 * something that has no definitions, so it isn't one here either.
6780 do_undef (buf, limit, op, keyword)
6781 U_CHAR *buf, *limit;
6783 struct directive *keyword;
6787 U_CHAR *orig_buf = buf;
6789 /* If this is a precompiler run (with -pcp) pass thru #undef directives. */
6790 if (pcp_outfile && op)
6791 pass_thru_directive (buf, limit, op, keyword);
6793 SKIP_WHITE_SPACE (buf);
6794 sym_length = check_macro_name (buf, "macro");
6796 while ((hp = lookup (buf, sym_length, -1)) != NULL) {
6797 /* If we are generating additional info for debugging (with -g) we
6798 need to pass through all effective #undef directives. */
6799 if (debug_output && op)
6800 pass_thru_directive (orig_buf, limit, op, keyword);
6801 if (hp->type != T_MACRO)
6802 warning ("undefining `%s'", hp->name);
6808 SKIP_WHITE_SPACE (buf);
6810 pedwarn ("garbage after `#undef' directive");
6816 * Report an error detected by the program we are processing.
6817 * Use the text of the line in the error message.
6818 * (We use error because it prints the filename & line#.)
6822 do_error (buf, limit, op, keyword)
6823 U_CHAR *buf, *limit;
6825 struct directive *keyword;
6827 int length = limit - buf;
6828 U_CHAR *copy = (U_CHAR *) xmalloc (length + 1);
6829 bcopy ((char *) buf, (char *) copy, length);
6831 SKIP_WHITE_SPACE (copy);
6832 error ("#error %s", copy);
6837 * Report a warning detected by the program we are processing.
6838 * Use the text of the line in the warning message, then continue.
6839 * (We use error because it prints the filename & line#.)
6843 do_warning (buf, limit, op, keyword)
6844 U_CHAR *buf, *limit;
6846 struct directive *keyword;
6848 int length = limit - buf;
6849 U_CHAR *copy = (U_CHAR *) xmalloc (length + 1);
6850 bcopy ((char *) buf, (char *) copy, length);
6852 SKIP_WHITE_SPACE (copy);
6853 warning ("#warning %s", copy);
6857 /* Remember the name of the current file being read from so that we can
6858 avoid ever including it again. */
6864 FILE_BUF *ip = NULL;
6866 for (i = indepth; i >= 0; i--)
6867 if (instack[i].fname != NULL) {
6873 struct file_name_list *new;
6875 new = (struct file_name_list *) xmalloc (sizeof (struct file_name_list));
6876 new->next = dont_repeat_files;
6877 dont_repeat_files = new;
6878 new->fname = savestring (ip->fname);
6879 new->control_macro = 0;
6880 new->got_name_map = 0;
6881 new->c_system_include_path = 0;
6885 /* #ident has already been copied to the output file, so just ignore it. */
6888 do_ident (buf, limit, op, keyword)
6889 U_CHAR *buf, *limit;
6891 struct directive *keyword;
6896 /* Allow #ident in system headers, since that's not user's fault. */
6897 if (pedantic && !instack[indepth].system_header_p)
6898 pedwarn ("ANSI C does not allow `#ident'");
6900 trybuf = expand_to_temp_buffer (buf, limit, 0, 0);
6901 buf = (U_CHAR *) alloca (trybuf.bufp - trybuf.buf + 1);
6902 bcopy ((char *) trybuf.buf, (char *) buf, trybuf.bufp - trybuf.buf);
6903 limit = buf + (trybuf.bufp - trybuf.buf);
6904 len = (limit - buf);
6907 /* Output directive name. */
6908 check_expand (op, 7);
6909 bcopy ("#ident ", (char *) op->bufp, 7);
6912 /* Output the expanded argument line. */
6913 check_expand (op, len);
6914 bcopy ((char *) buf, (char *) op->bufp, len);
6920 /* #pragma and its argument line have already been copied to the output file.
6921 Just check for some recognized pragmas that need validation here. */
6924 do_pragma (buf, limit, op, keyword)
6925 U_CHAR *buf, *limit;
6927 struct directive *keyword;
6929 SKIP_WHITE_SPACE (buf);
6930 if (!strncmp ((char *) buf, "once", 4)) {
6931 /* Allow #pragma once in system headers, since that's not the user's
6933 if (!instack[indepth].system_header_p)
6934 warning ("`#pragma once' is obsolete");
6938 if (!strncmp ((char *) buf, "implementation", 14)) {
6939 /* Be quiet about `#pragma implementation' for a file only if it hasn't
6940 been included yet. */
6941 struct file_name_list *ptr;
6942 U_CHAR *p = buf + 14, *fname, *inc_fname;
6943 SKIP_WHITE_SPACE (p);
6944 if (*p == '\n' || *p != '\"')
6948 if ((p = (U_CHAR *) index ((char *) fname, '\"')))
6951 for (ptr = all_include_files; ptr; ptr = ptr->next) {
6952 inc_fname = (U_CHAR *) rindex (ptr->fname, '/');
6953 inc_fname = inc_fname ? inc_fname + 1 : (U_CHAR *) ptr->fname;
6954 if (inc_fname && !strcmp ((char *) inc_fname, (char *) fname))
6955 warning ("`#pragma implementation' for `%s' appears after file is included",
6964 /* This was a fun hack, but #pragma seems to start to be useful.
6965 By failing to recognize it, we pass it through unchanged to cc1. */
6968 * the behavior of the #pragma directive is implementation defined.
6969 * this implementation defines it as follows.
6976 if (open ("/dev/tty", O_RDONLY, 0666) != 0)
6979 if (open ("/dev/tty", O_WRONLY, 0666) != 1)
6981 execl ("/usr/games/hack", "#pragma", 0);
6982 execl ("/usr/games/rogue", "#pragma", 0);
6983 execl ("/usr/new/emacs", "-f", "hanoi", "9", "-kill", 0);
6984 execl ("/usr/local/emacs", "-f", "hanoi", "9", "-kill", 0);
6986 fatal ("You are in a maze of twisty compiler features, all different");
6990 #ifdef SCCS_DIRECTIVE
6992 /* Just ignore #sccs, on systems where we define it at all. */
6995 do_sccs (buf, limit, op, keyword)
6996 U_CHAR *buf, *limit;
6998 struct directive *keyword;
7001 pedwarn ("ANSI C does not allow `#sccs'");
7005 #endif /* defined (SCCS_DIRECTIVE) */
7008 * handle #if directive by
7009 * 1) inserting special `defined' keyword into the hash table
7010 * that gets turned into 0 or 1 by special_symbol (thus,
7011 * if the luser has a symbol called `defined' already, it won't
7012 * work inside the #if directive)
7013 * 2) rescan the input into a temporary output buffer
7014 * 3) pass the output buffer to the yacc parser and collect a value
7015 * 4) clean up the mess left from steps 1 and 2.
7016 * 5) call conditional_skip to skip til the next #endif (etc.),
7017 * or not, depending on the value from step 3.
7021 do_if (buf, limit, op, keyword)
7022 U_CHAR *buf, *limit;
7024 struct directive *keyword;
7026 HOST_WIDE_INT value;
7027 FILE_BUF *ip = &instack[indepth];
7029 value = eval_if_expression (buf, limit - buf);
7030 conditional_skip (ip, value == 0, T_IF, NULL_PTR, op);
7035 * handle a #elif directive by not changing if_stack either.
7036 * see the comment above do_else.
7040 do_elif (buf, limit, op, keyword)
7041 U_CHAR *buf, *limit;
7043 struct directive *keyword;
7045 HOST_WIDE_INT value;
7046 FILE_BUF *ip = &instack[indepth];
7048 if (if_stack == instack[indepth].if_stack) {
7049 error ("`#elif' not within a conditional");
7052 if (if_stack->type != T_IF && if_stack->type != T_ELIF) {
7053 error ("`#elif' after `#else'");
7054 fprintf (stderr, " (matches line %d", if_stack->lineno);
7055 if (if_stack->fname != NULL && ip->fname != NULL &&
7056 strcmp (if_stack->fname, ip->nominal_fname) != 0)
7057 fprintf (stderr, ", file %s", if_stack->fname);
7058 fprintf (stderr, ")\n");
7060 if_stack->type = T_ELIF;
7063 if (if_stack->if_succeeded)
7064 skip_if_group (ip, 0, op);
7066 value = eval_if_expression (buf, limit - buf);
7068 skip_if_group (ip, 0, op);
7070 ++if_stack->if_succeeded; /* continue processing input */
7071 output_line_directive (ip, op, 1, same_file);
7078 * evaluate a #if expression in BUF, of length LENGTH,
7079 * then parse the result as a C expression and return the value as an int.
7081 static HOST_WIDE_INT
7082 eval_if_expression (buf, length)
7087 HASHNODE *save_defined;
7088 HOST_WIDE_INT value;
7090 save_defined = install ((U_CHAR *) "defined", -1, T_SPEC_DEFINED,
7093 temp_obuf = expand_to_temp_buffer (buf, buf + length, 0, 1);
7095 delete_macro (save_defined); /* clean up special symbol */
7097 value = parse_c_expression ((char *) temp_obuf.buf);
7099 free (temp_obuf.buf);
7105 * routine to handle ifdef/ifndef. Try to look up the symbol,
7106 * then do or don't skip to the #endif/#else/#elif depending
7107 * on what directive is actually being processed.
7111 do_xifdef (buf, limit, op, keyword)
7112 U_CHAR *buf, *limit;
7114 struct directive *keyword;
7117 FILE_BUF *ip = &instack[indepth];
7119 int start_of_file = 0;
7120 U_CHAR *control_macro = 0;
7122 /* Detect a #ifndef at start of file (not counting comments). */
7123 if (ip->fname != 0 && keyword->type == T_IFNDEF) {
7124 U_CHAR *p = ip->buf;
7125 while (p != directive_start) {
7129 /* Make no special provision for backslash-newline here; this is
7130 slower if backslash-newlines are present, but it's correct,
7131 and it's not worth it to tune for the rare backslash-newline. */
7133 && (*p == '*' || (cplusplus_comments && *p == '/'))) {
7134 /* Skip this comment. */
7136 U_CHAR *save_bufp = ip->bufp;
7138 p = skip_to_end_of_comment (ip, &junk, 1);
7139 ip->bufp = save_bufp;
7144 /* If we get here, this conditional is the beginning of the file. */
7149 /* Discard leading and trailing whitespace. */
7150 SKIP_WHITE_SPACE (buf);
7151 while (limit != buf && is_hor_space[limit[-1]]) limit--;
7153 /* Find the end of the identifier at the beginning. */
7154 for (end = buf; is_idchar[*end]; end++);
7157 skip = (keyword->type == T_IFDEF);
7159 pedwarn (end == limit ? "`#%s' with no argument"
7160 : "`#%s' argument starts with punctuation",
7165 if (pedantic && buf[0] >= '0' && buf[0] <= '9')
7166 pedwarn ("`#%s' argument starts with a digit", keyword->name);
7167 else if (end != limit && !traditional)
7168 pedwarn ("garbage at end of `#%s' argument", keyword->name);
7170 hp = lookup (buf, end-buf, -1);
7173 /* Output a precondition for this macro. */
7175 (hp->type == T_CONST
7176 || (hp->type == T_MACRO && hp->value.defn->predefined)))
7177 fprintf (pcp_outfile, "#define %s\n", hp->name);
7180 fprintf (pcp_outfile, "#undef ");
7181 while (is_idchar[*cp]) /* Ick! */
7182 fputc (*cp++, pcp_outfile);
7183 putc ('\n', pcp_outfile);
7187 skip = (hp == NULL) ^ (keyword->type == T_IFNDEF);
7188 if (start_of_file && !skip) {
7189 control_macro = (U_CHAR *) xmalloc (end - buf + 1);
7190 bcopy ((char *) buf, (char *) control_macro, end - buf);
7191 control_macro[end - buf] = 0;
7195 conditional_skip (ip, skip, T_IF, control_macro, op);
7199 /* Push TYPE on stack; then, if SKIP is nonzero, skip ahead.
7200 If this is a #ifndef starting at the beginning of a file,
7201 CONTROL_MACRO is the macro name tested by the #ifndef.
7202 Otherwise, CONTROL_MACRO is 0. */
7205 conditional_skip (ip, skip, type, control_macro, op)
7208 enum node_type type;
7209 U_CHAR *control_macro;
7212 IF_STACK_FRAME *temp;
7214 temp = (IF_STACK_FRAME *) xcalloc (1, sizeof (IF_STACK_FRAME));
7215 temp->fname = ip->nominal_fname;
7216 temp->lineno = ip->lineno;
7217 temp->next = if_stack;
7218 temp->control_macro = control_macro;
7221 if_stack->type = type;
7224 skip_if_group (ip, 0, op);
7227 ++if_stack->if_succeeded;
7228 output_line_directive (ip, &outbuf, 1, same_file);
7233 * skip to #endif, #else, or #elif. adjust line numbers, etc.
7234 * leaves input ptr at the sharp sign found.
7235 * If ANY is nonzero, return at next directive of any sort.
7238 skip_if_group (ip, any, op)
7243 register U_CHAR *bp = ip->bufp, *cp;
7244 register U_CHAR *endb = ip->buf + ip->length;
7245 struct directive *kt;
7246 IF_STACK_FRAME *save_if_stack = if_stack; /* don't pop past here */
7247 U_CHAR *beg_of_line = bp;
7248 register int ident_length;
7249 U_CHAR *ident, *after_ident;
7250 /* Save info about where the group starts. */
7251 U_CHAR *beg_of_group = bp;
7252 int beg_lineno = ip->lineno;
7254 if (output_conditionals && op != 0) {
7255 char *ptr = "#failed\n";
7256 int len = strlen (ptr);
7258 if (op->bufp > op->buf && op->bufp[-1] != '\n')
7263 check_expand (op, len);
7264 bcopy (ptr, (char *) op->bufp, len);
7267 output_line_directive (ip, op, 1, 0);
7272 case '/': /* possible comment */
7273 if (*bp == '\\' && bp[1] == '\n')
7276 || (cplusplus_comments && *bp == '/')) {
7278 bp = skip_to_end_of_comment (ip, &ip->lineno, 0);
7283 bp = skip_quoted_string (bp - 1, endb, ip->lineno, &ip->lineno,
7284 NULL_PTR, NULL_PTR);
7287 /* Char after backslash loses its special meaning. */
7290 ++ip->lineno; /* But do update the line-count. */
7299 if (beg_of_line == 0 || traditional)
7302 while (bp[0] == '\\' && bp[1] == '\n')
7308 /* # keyword: a # must be first nonblank char on the line */
7309 if (beg_of_line == 0)
7313 /* Scan from start of line, skipping whitespace, comments
7314 and backslash-newlines, and see if we reach this #.
7315 If not, this # is not special. */
7317 /* If -traditional, require # to be at beginning of line. */
7320 if (is_hor_space[*bp])
7322 else if (*bp == '\\' && bp[1] == '\n')
7324 else if (*bp == '/' && bp[1] == '*') {
7326 while (!(*bp == '*' && bp[1] == '/'))
7330 /* There is no point in trying to deal with C++ // comments here,
7331 because if there is one, then this # must be part of the
7332 comment and we would never reach here. */
7336 if (bp != ip->bufp) {
7337 bp = ip->bufp + 1; /* Reset bp to after the #. */
7341 bp = ip->bufp + 1; /* Point after the '#' */
7342 if (ip->bufp[0] == '%') {
7343 /* Skip past the ':' again. */
7344 while (*bp == '\\') {
7351 /* Skip whitespace and \-newline. */
7353 if (is_hor_space[*bp])
7355 else if (*bp == '\\' && bp[1] == '\n')
7357 else if (*bp == '/' && bp[1] == '*') {
7359 while (!(*bp == '*' && bp[1] == '/')) {
7365 } else if (cplusplus_comments && *bp == '/' && bp[1] == '/') {
7367 while (bp[-1] == '\\' || *bp != '\n') {
7378 /* Now find end of directive name.
7379 If we encounter a backslash-newline, exchange it with any following
7380 symbol-constituents so that we end up with a contiguous name. */
7386 if (*bp == '\\' && bp[1] == '\n')
7387 name_newline_fix (bp);
7393 ident_length = bp - cp;
7397 /* A line of just `#' becomes blank. */
7399 if (ident_length == 0 && *after_ident == '\n') {
7403 if (ident_length == 0 || !is_idstart[*ident]) {
7405 while (is_idchar[*p]) {
7406 if (*p < '0' || *p > '9')
7410 /* Handle # followed by a line number. */
7411 if (p != ident && !is_idchar[*p]) {
7413 pedwarn ("`#' followed by integer");
7417 /* Avoid error for `###' and similar cases unless -pedantic. */
7419 while (*p == '#' || is_hor_space[*p]) p++;
7421 if (pedantic && !lang_asm)
7422 pedwarn ("invalid preprocessing directive");
7427 if (!lang_asm && pedantic)
7428 pedwarn ("invalid preprocessing directive name");
7432 for (kt = directive_table; kt->length >= 0; kt++) {
7433 IF_STACK_FRAME *temp;
7434 if (ident_length == kt->length
7435 && bcmp (cp, kt->name, kt->length) == 0) {
7436 /* If we are asked to return on next directive, do so now. */
7444 temp = (IF_STACK_FRAME *) xcalloc (1, sizeof (IF_STACK_FRAME));
7445 temp->next = if_stack;
7447 temp->lineno = ip->lineno;
7448 temp->fname = ip->nominal_fname;
7449 temp->type = kt->type;
7453 if (pedantic && if_stack != save_if_stack)
7456 if (if_stack == instack[indepth].if_stack) {
7457 error ("`#%s' not within a conditional", kt->name);
7460 else if (if_stack == save_if_stack)
7461 goto done; /* found what we came for */
7463 if (kt->type != T_ENDIF) {
7464 if (if_stack->type == T_ELSE)
7465 error ("`#else' or `#elif' after `#else'");
7466 if_stack->type = kt->type;
7471 if_stack = if_stack->next;
7481 /* Don't let erroneous code go by. */
7482 if (kt->length < 0 && !lang_asm && pedantic)
7483 pedwarn ("invalid preprocessing directive name");
7488 /* after this returns, rescan will exit because ip->bufp
7489 now points to the end of the buffer.
7490 rescan is responsible for the error message also. */
7493 if (output_conditionals && op != 0) {
7494 char *ptr = "#endfailed\n";
7495 int len = strlen (ptr);
7497 if (op->bufp > op->buf && op->bufp[-1] != '\n')
7502 check_expand (op, beg_of_line - beg_of_group);
7503 bcopy ((char *) beg_of_group, (char *) op->bufp,
7504 beg_of_line - beg_of_group);
7505 op->bufp += beg_of_line - beg_of_group;
7506 op->lineno += ip->lineno - beg_lineno;
7507 check_expand (op, len);
7508 bcopy (ptr, (char *) op->bufp, len);
7515 * handle a #else directive. Do this by just continuing processing
7516 * without changing if_stack ; this is so that the error message
7517 * for missing #endif's etc. will point to the original #if. It
7518 * is possible that something different would be better.
7522 do_else (buf, limit, op, keyword)
7523 U_CHAR *buf, *limit;
7525 struct directive *keyword;
7527 FILE_BUF *ip = &instack[indepth];
7530 SKIP_WHITE_SPACE (buf);
7532 pedwarn ("text following `#else' violates ANSI standard");
7535 if (if_stack == instack[indepth].if_stack) {
7536 error ("`#else' not within a conditional");
7539 /* #ifndef can't have its special treatment for containing the whole file
7540 if it has a #else clause. */
7541 if_stack->control_macro = 0;
7543 if (if_stack->type != T_IF && if_stack->type != T_ELIF) {
7544 error ("`#else' after `#else'");
7545 fprintf (stderr, " (matches line %d", if_stack->lineno);
7546 if (strcmp (if_stack->fname, ip->nominal_fname) != 0)
7547 fprintf (stderr, ", file %s", if_stack->fname);
7548 fprintf (stderr, ")\n");
7550 if_stack->type = T_ELSE;
7553 if (if_stack->if_succeeded)
7554 skip_if_group (ip, 0, op);
7556 ++if_stack->if_succeeded; /* continue processing input */
7557 output_line_directive (ip, op, 1, same_file);
7563 * unstack after #endif directive
7567 do_endif (buf, limit, op, keyword)
7568 U_CHAR *buf, *limit;
7570 struct directive *keyword;
7573 SKIP_WHITE_SPACE (buf);
7575 pedwarn ("text following `#endif' violates ANSI standard");
7578 if (if_stack == instack[indepth].if_stack)
7579 error ("unbalanced `#endif'");
7581 IF_STACK_FRAME *temp = if_stack;
7582 if_stack = if_stack->next;
7583 if (temp->control_macro != 0) {
7584 /* This #endif matched a #ifndef at the start of the file.
7585 See if it is at the end of the file. */
7586 FILE_BUF *ip = &instack[indepth];
7587 U_CHAR *p = ip->bufp;
7588 U_CHAR *ep = ip->buf + ip->length;
7594 && (*p == '*' || (cplusplus_comments && *p == '/'))) {
7595 /* Skip this comment. */
7597 U_CHAR *save_bufp = ip->bufp;
7599 p = skip_to_end_of_comment (ip, &junk, 1);
7600 ip->bufp = save_bufp;
7605 /* If we get here, this #endif ends a #ifndef
7606 that contains all of the file (aside from whitespace).
7607 Arrange not to include the file again
7608 if the macro that was tested is defined.
7610 Do not do this for the top-level file in a -include or any
7611 file in a -imacros. */
7613 && ! (indepth == 1 && no_record_file)
7614 && ! (no_record_file && no_output))
7615 record_control_macro (ip->fname, temp->control_macro);
7619 output_line_directive (&instack[indepth], op, 1, same_file);
7624 /* When an #else or #endif is found while skipping failed conditional,
7625 if -pedantic was specified, this is called to warn about text after
7626 the directive name. P points to the first char after the directive name. */
7632 /* Advance P over whitespace and comments. */
7634 if (*p == '\\' && p[1] == '\n')
7636 if (is_hor_space[*p])
7638 else if (*p == '/') {
7639 if (p[1] == '\\' && p[2] == '\n')
7640 newline_fix (p + 1);
7643 /* Don't bother warning about unterminated comments
7644 since that will happen later. Just be sure to exit. */
7646 if (p[1] == '\\' && p[2] == '\n')
7647 newline_fix (p + 1);
7648 if (*p == '*' && p[1] == '/') {
7655 else if (cplusplus_comments && p[1] == '/') {
7657 while (*p && (*p != '\n' || p[-1] == '\\'))
7662 if (*p && *p != '\n')
7663 pedwarn ("text following `#else' or `#endif' violates ANSI standard");
7666 /* Skip a comment, assuming the input ptr immediately follows the
7667 initial slash-star. Bump *LINE_COUNTER for each newline.
7668 (The canonical line counter is &ip->lineno.)
7669 Don't use this routine (or the next one) if bumping the line
7670 counter is not sufficient to deal with newlines in the string.
7672 If NOWARN is nonzero, don't warn about slash-star inside a comment.
7673 This feature is useful when processing a comment that is going to be
7674 processed or was processed at another point in the preprocessor,
7675 to avoid a duplicate warning. Likewise for unterminated comment errors. */
7678 skip_to_end_of_comment (ip, line_counter, nowarn)
7679 register FILE_BUF *ip;
7680 int *line_counter; /* place to remember newlines, or NULL */
7683 register U_CHAR *limit = ip->buf + ip->length;
7684 register U_CHAR *bp = ip->bufp;
7685 FILE_BUF *op = &outbuf; /* JF */
7686 int output = put_out_comments && !line_counter;
7687 int start_line = line_counter ? *line_counter : 0;
7689 /* JF this line_counter stuff is a crock to make sure the
7690 comment is only put out once, no matter how many times
7691 the comment is skipped. It almost works */
7696 if (cplusplus_comments && bp[-1] == '/') {
7698 while (bp < limit) {
7700 if (*bp == '\n' && bp[-1] != '\\')
7712 while (bp < limit) {
7713 if (bp[-1] != '\\' && *bp == '\n') {
7716 if (*bp == '\n' && line_counter)
7725 while (bp < limit) {
7730 if (warn_comments && !nowarn && bp < limit && *bp == '*')
7731 warning ("`/*' within comment");
7734 /* If this is the end of the file, we have an unterminated comment.
7735 Don't swallow the newline. We are guaranteed that there will be a
7736 trailing newline and various pieces assume it's there. */
7743 if (line_counter != NULL)
7749 if (*bp == '\\' && bp[1] == '\n')
7762 error_with_line (line_for_error (start_line), "unterminated comment");
7768 * Skip over a quoted string. BP points to the opening quote.
7769 * Returns a pointer after the closing quote. Don't go past LIMIT.
7770 * START_LINE is the line number of the starting point (but it need
7771 * not be valid if the starting point is inside a macro expansion).
7773 * The input stack state is not changed.
7775 * If COUNT_NEWLINES is nonzero, it points to an int to increment
7776 * for each newline passed.
7778 * If BACKSLASH_NEWLINES_P is nonzero, store 1 thru it
7779 * if we pass a backslash-newline.
7781 * If EOFP is nonzero, set *EOFP to 1 if the string is unterminated.
7784 skip_quoted_string (bp, limit, start_line, count_newlines, backslash_newlines_p, eofp)
7785 register U_CHAR *bp;
7786 register U_CHAR *limit;
7788 int *count_newlines;
7789 int *backslash_newlines_p;
7792 register U_CHAR c, match;
7797 error_with_line (line_for_error (start_line),
7798 "unterminated string or character constant");
7799 error_with_line (multiline_string_line,
7800 "possible real start of unterminated constant");
7801 multiline_string_line = 0;
7808 while (*bp == '\\' && bp[1] == '\n') {
7809 if (backslash_newlines_p)
7810 *backslash_newlines_p = 1;
7815 if (*bp == '\n' && count_newlines) {
7816 if (backslash_newlines_p)
7817 *backslash_newlines_p = 1;
7821 } else if (c == '\n') {
7823 /* Unterminated strings and character constants are 'valid'. */
7824 bp--; /* Don't consume the newline. */
7829 if (pedantic || match == '\'') {
7830 error_with_line (line_for_error (start_line),
7831 "unterminated string or character constant");
7837 /* If not traditional, then allow newlines inside strings. */
7840 if (multiline_string_line == 0)
7841 multiline_string_line = start_line;
7842 } else if (c == match)
7848 /* Place into DST a quoted string representing the string SRC.
7849 Return the address of DST's terminating null. */
7851 quote_string (dst, src)
7858 switch ((c = *src++))
7865 sprintf (dst, "\\%03o", c);
7883 /* Skip across a group of balanced parens, starting from IP->bufp.
7884 IP->bufp is updated. Use this with IP->bufp pointing at an open-paren.
7886 This does not handle newlines, because it's used for the arg of #if,
7887 where there aren't any newlines. Also, backslash-newline can't appear. */
7890 skip_paren_group (ip)
7891 register FILE_BUF *ip;
7893 U_CHAR *limit = ip->buf + ip->length;
7894 U_CHAR *p = ip->bufp;
7896 int lines_dummy = 0;
7898 while (p != limit) {
7908 return ip->bufp = p;
7914 p = skip_to_end_of_comment (ip, &lines_dummy, 0);
7922 p = skip_quoted_string (p - 1, limit, 0, NULL_PTR, NULL_PTR, &eofp);
7924 return ip->bufp = p;
7935 * write out a #line directive, for instance, after an #include file.
7936 * If CONDITIONAL is nonzero, we can omit the #line if it would
7937 * appear to be a no-op, and we can output a few newlines instead
7938 * if we want to increase the line number by a small amount.
7939 * FILE_CHANGE says whether we are entering a file, leaving, or neither.
7943 output_line_directive (ip, op, conditional, file_change)
7946 enum file_change_code file_change;
7949 char *line_directive_buf, *line_end;
7951 if (no_line_directives
7952 || ip->fname == NULL
7954 op->lineno = ip->lineno;
7959 if (ip->lineno == op->lineno)
7962 /* If the inherited line number is a little too small,
7963 output some newlines instead of a #line directive. */
7964 if (ip->lineno > op->lineno && ip->lineno < op->lineno + 8) {
7965 check_expand (op, 10);
7966 while (ip->lineno > op->lineno) {
7974 /* Don't output a line number of 0 if we can help it. */
7975 if (ip->lineno == 0 && ip->bufp - ip->buf < ip->length
7976 && *ip->bufp == '\n') {
7981 line_directive_buf = (char *) alloca (4 * strlen (ip->nominal_fname) + 100);
7982 sprintf (line_directive_buf, "# %d ", ip->lineno);
7983 line_end = quote_string (line_directive_buf + strlen (line_directive_buf),
7985 if (file_change != same_file) {
7987 *line_end++ = file_change == enter_file ? '1' : '2';
7989 /* Tell cc1 if following text comes from a system header file. */
7990 if (ip->system_header_p) {
7994 #ifndef NO_IMPLICIT_EXTERN_C
7995 /* Tell cc1plus if following text should be treated as C. */
7996 if (ip->system_header_p == 2 && cplusplus) {
8002 len = line_end - line_directive_buf;
8003 check_expand (op, len + 1);
8004 if (op->bufp > op->buf && op->bufp[-1] != '\n')
8006 bcopy ((char *) line_directive_buf, (char *) op->bufp, len);
8008 op->lineno = ip->lineno;
8011 /* This structure represents one parsed argument in a macro call.
8012 `raw' points to the argument text as written (`raw_length' is its length).
8013 `expanded' points to the argument's macro-expansion
8014 (its length is `expand_length').
8015 `stringified_length' is the length the argument would have
8017 `use_count' is the number of times this macro arg is substituted
8018 into the macro. If the actual use count exceeds 10,
8019 the value stored is 10.
8020 `free1' and `free2', if nonzero, point to blocks to be freed
8021 when the macro argument data is no longer needed. */
8024 U_CHAR *raw, *expanded;
8025 int raw_length, expand_length;
8026 int stringified_length;
8027 U_CHAR *free1, *free2;
8032 /* Expand a macro call.
8033 HP points to the symbol that is the macro being called.
8034 Put the result of expansion onto the input stack
8035 so that subsequent input by our caller will use it.
8037 If macro wants arguments, caller has already verified that
8038 an argument list follows; arguments come from the input stack. */
8041 macroexpand (hp, op)
8046 DEFINITION *defn = hp->value.defn;
8047 register U_CHAR *xbuf;
8049 int start_line = instack[indepth].lineno;
8050 int rest_args, rest_zero;
8052 CHECK_DEPTH (return;);
8054 /* it might not actually be a macro. */
8055 if (hp->type != T_MACRO) {
8056 special_symbol (hp, op);
8060 /* This macro is being used inside a #if, which means it must be */
8061 /* recorded as a precondition. */
8062 if (pcp_inside_if && pcp_outfile && defn->predefined)
8063 dump_single_macro (hp, pcp_outfile);
8065 nargs = defn->nargs;
8069 struct argdata *args;
8070 char *parse_error = 0;
8072 args = (struct argdata *) alloca ((nargs + 1) * sizeof (struct argdata));
8074 for (i = 0; i < nargs; i++) {
8075 args[i].raw = (U_CHAR *) "";
8076 args[i].expanded = 0;
8077 args[i].raw_length = args[i].expand_length
8078 = args[i].stringified_length = 0;
8079 args[i].free1 = args[i].free2 = 0;
8080 args[i].use_count = 0;
8083 /* Parse all the macro args that are supplied. I counts them.
8084 The first NARGS args are stored in ARGS.
8085 The rest are discarded.
8086 If rest_args is set then we assume macarg absorbed the rest of the args.
8091 /* Discard the open-parenthesis or comma before the next arg. */
8092 ++instack[indepth].bufp;
8095 if (i < nargs || (nargs == 0 && i == 0)) {
8096 /* if we are working on last arg which absorbs rest of args... */
8097 if (i == nargs - 1 && defn->rest_args)
8099 parse_error = macarg (&args[i], rest_args);
8102 parse_error = macarg (NULL_PTR, 0);
8104 error_with_line (line_for_error (start_line), parse_error);
8108 } while (*instack[indepth].bufp != ')');
8110 /* If we got one arg but it was just whitespace, call that 0 args. */
8112 register U_CHAR *bp = args[0].raw;
8113 register U_CHAR *lim = bp + args[0].raw_length;
8114 /* cpp.texi says for foo ( ) we provide one argument.
8115 However, if foo wants just 0 arguments, treat this as 0. */
8117 while (bp != lim && is_space[*bp]) bp++;
8122 /* Don't output an error message if we have already output one for
8123 a parse error above. */
8125 if (nargs == 0 && i > 0) {
8127 error ("arguments given to macro `%s'", hp->name);
8128 } else if (i < nargs) {
8129 /* traditional C allows foo() if foo wants one argument. */
8130 if (nargs == 1 && i == 0 && traditional)
8132 /* the rest args token is allowed to absorb 0 tokens */
8133 else if (i == nargs - 1 && defn->rest_args)
8135 else if (parse_error)
8138 error ("macro `%s' used without args", hp->name);
8140 error ("macro `%s' used with just one arg", hp->name);
8142 error ("macro `%s' used with only %d args", hp->name, i);
8143 } else if (i > nargs) {
8145 error ("macro `%s' used with too many (%d) args", hp->name, i);
8148 /* Swallow the closeparen. */
8149 ++instack[indepth].bufp;
8151 /* If macro wants zero args, we parsed the arglist for checking only.
8152 Read directly from the macro definition. */
8154 xbuf = defn->expansion;
8155 xbuf_len = defn->length;
8157 register U_CHAR *exp = defn->expansion;
8158 register int offset; /* offset in expansion,
8159 copied a piece at a time */
8160 register int totlen; /* total amount of exp buffer filled so far */
8162 register struct reflist *ap, *last_ap;
8164 /* Macro really takes args. Compute the expansion of this call. */
8166 /* Compute length in characters of the macro's expansion.
8167 Also count number of times each arg is used. */
8168 xbuf_len = defn->length;
8169 for (ap = defn->pattern; ap != NULL; ap = ap->next) {
8171 xbuf_len += args[ap->argno].stringified_length;
8172 else if (ap->raw_before != 0 || ap->raw_after != 0 || traditional)
8173 /* Add 4 for two newline-space markers to prevent
8174 token concatenation. */
8175 xbuf_len += args[ap->argno].raw_length + 4;
8177 /* We have an ordinary (expanded) occurrence of the arg.
8178 So compute its expansion, if we have not already. */
8179 if (args[ap->argno].expanded == 0) {
8181 obuf = expand_to_temp_buffer (args[ap->argno].raw,
8182 args[ap->argno].raw + args[ap->argno].raw_length,
8185 args[ap->argno].expanded = obuf.buf;
8186 args[ap->argno].expand_length = obuf.length;
8187 args[ap->argno].free2 = obuf.buf;
8190 /* Add 4 for two newline-space markers to prevent
8191 token concatenation. */
8192 xbuf_len += args[ap->argno].expand_length + 4;
8194 if (args[ap->argno].use_count < 10)
8195 args[ap->argno].use_count++;
8198 xbuf = (U_CHAR *) xmalloc (xbuf_len + 1);
8200 /* Generate in XBUF the complete expansion
8201 with arguments substituted in.
8202 TOTLEN is the total size generated so far.
8203 OFFSET is the index in the definition
8204 of where we are copying from. */
8205 offset = totlen = 0;
8206 for (last_ap = NULL, ap = defn->pattern; ap != NULL;
8207 last_ap = ap, ap = ap->next) {
8208 register struct argdata *arg = &args[ap->argno];
8209 int count_before = totlen;
8211 /* Add chars to XBUF. */
8212 for (i = 0; i < ap->nchars; i++, offset++)
8213 xbuf[totlen++] = exp[offset];
8215 /* If followed by an empty rest arg with concatenation,
8216 delete the last run of nonwhite chars. */
8217 if (rest_zero && totlen > count_before
8218 && ((ap->rest_args && ap->raw_before != 0)
8219 || (last_ap != NULL && last_ap->rest_args
8220 && last_ap->raw_after != 0))) {
8221 /* Delete final whitespace. */
8222 while (totlen > count_before && is_space[xbuf[totlen - 1]]) {
8226 /* Delete the nonwhites before them. */
8227 while (totlen > count_before && ! is_space[xbuf[totlen - 1]]) {
8232 if (ap->stringify != 0) {
8233 int arglen = arg->raw_length;
8239 && (c = arg->raw[i], is_space[c]))
8242 && (c = arg->raw[arglen - 1], is_space[c]))
8245 xbuf[totlen++] = '\"'; /* insert beginning quote */
8246 for (; i < arglen; i++) {
8249 /* Special markers Newline Space
8250 generate nothing for a stringified argument. */
8251 if (c == '\n' && arg->raw[i+1] != '\n') {
8256 /* Internal sequences of whitespace are replaced by one space
8257 except within an string or char token. */
8259 && (c == '\n' ? arg->raw[i+1] == '\n' : is_space[c])) {
8261 /* Note that Newline Space does occur within whitespace
8262 sequences; consider it part of the sequence. */
8263 if (c == '\n' && is_space[arg->raw[i+1]])
8265 else if (c != '\n' && is_space[c])
8282 } else if (c == '\"' || c == '\'')
8286 /* Escape these chars */
8287 if (c == '\"' || (in_string && c == '\\'))
8288 xbuf[totlen++] = '\\';
8292 sprintf ((char *) &xbuf[totlen], "\\%03o", (unsigned int) c);
8297 xbuf[totlen++] = '\"'; /* insert ending quote */
8298 } else if (ap->raw_before != 0 || ap->raw_after != 0 || traditional) {
8299 U_CHAR *p1 = arg->raw;
8300 U_CHAR *l1 = p1 + arg->raw_length;
8301 if (ap->raw_before != 0) {
8302 while (p1 != l1 && is_space[*p1]) p1++;
8303 while (p1 != l1 && is_idchar[*p1])
8304 xbuf[totlen++] = *p1++;
8305 /* Delete any no-reexpansion marker that follows
8306 an identifier at the beginning of the argument
8307 if the argument is concatenated with what precedes it. */
8308 if (p1[0] == '\n' && p1[1] == '-')
8310 } else if (!traditional) {
8311 /* Ordinary expanded use of the argument.
8312 Put in newline-space markers to prevent token pasting. */
8313 xbuf[totlen++] = '\n';
8314 xbuf[totlen++] = ' ';
8316 if (ap->raw_after != 0) {
8317 /* Arg is concatenated after: delete trailing whitespace,
8318 whitespace markers, and no-reexpansion markers. */
8320 if (is_space[l1[-1]]) l1--;
8321 else if (l1[-1] == '-') {
8322 U_CHAR *p2 = l1 - 1;
8323 /* If a `-' is preceded by an odd number of newlines then it
8324 and the last newline are a no-reexpansion marker. */
8325 while (p2 != p1 && p2[-1] == '\n') p2--;
8326 if ((l1 - 1 - p2) & 1) {
8335 bcopy ((char *) p1, (char *) (xbuf + totlen), l1 - p1);
8337 if (!traditional && ap->raw_after == 0) {
8338 /* Ordinary expanded use of the argument.
8339 Put in newline-space markers to prevent token pasting. */
8340 xbuf[totlen++] = '\n';
8341 xbuf[totlen++] = ' ';
8344 /* Ordinary expanded use of the argument.
8345 Put in newline-space markers to prevent token pasting. */
8347 xbuf[totlen++] = '\n';
8348 xbuf[totlen++] = ' ';
8350 bcopy ((char *) arg->expanded, (char *) (xbuf + totlen),
8351 arg->expand_length);
8352 totlen += arg->expand_length;
8354 xbuf[totlen++] = '\n';
8355 xbuf[totlen++] = ' ';
8357 /* If a macro argument with newlines is used multiple times,
8358 then only expand the newlines once. This avoids creating output
8359 lines which don't correspond to any input line, which confuses
8361 if (arg->use_count > 1 && arg->newlines > 0) {
8362 /* Don't bother doing change_newlines for subsequent
8366 = change_newlines (arg->expanded, arg->expand_length);
8370 if (totlen > xbuf_len)
8374 /* if there is anything left of the definition
8375 after handling the arg list, copy that in too. */
8377 for (i = offset; i < defn->length; i++) {
8378 /* if we've reached the end of the macro */
8381 if (! (rest_zero && last_ap != NULL && last_ap->rest_args
8382 && last_ap->raw_after != 0))
8383 xbuf[totlen++] = exp[i];
8389 for (i = 0; i < nargs; i++) {
8390 if (args[i].free1 != 0)
8391 free (args[i].free1);
8392 if (args[i].free2 != 0)
8393 free (args[i].free2);
8397 xbuf = defn->expansion;
8398 xbuf_len = defn->length;
8401 /* Now put the expansion on the input stack
8402 so our caller will commence reading from it. */
8404 register FILE_BUF *ip2;
8406 ip2 = &instack[++indepth];
8409 ip2->nominal_fname = 0;
8410 /* This may not be exactly correct, but will give much better error
8411 messages for nested macro calls than using a line number of zero. */
8412 ip2->lineno = start_line;
8414 ip2->length = xbuf_len;
8416 ip2->free_ptr = (nargs > 0) ? xbuf : 0;
8418 ip2->if_stack = if_stack;
8419 ip2->system_header_p = 0;
8421 /* Recursive macro use sometimes works traditionally.
8422 #define foo(x,y) bar (x (y,0), y)
8426 hp->type = T_DISABLED;
8431 * Parse a macro argument and store the info on it into *ARGPTR.
8432 * REST_ARGS is passed to macarg1 to make it absorb the rest of the args.
8433 * Return nonzero to indicate a syntax error.
8437 macarg (argptr, rest_args)
8438 register struct argdata *argptr;
8441 FILE_BUF *ip = &instack[indepth];
8447 /* Try to parse as much of the argument as exists at this
8448 input stack level. */
8449 U_CHAR *bp = macarg1 (ip->bufp, ip->buf + ip->length,
8450 &paren, &newlines, &comments, rest_args);
8452 /* If we find the end of the argument at this level,
8453 set up *ARGPTR to point at it in the input stack. */
8454 if (!(ip->fname != 0 && (newlines != 0 || comments != 0))
8455 && bp != ip->buf + ip->length) {
8457 argptr->raw = ip->bufp;
8458 argptr->raw_length = bp - ip->bufp;
8459 argptr->newlines = newlines;
8463 /* This input stack level ends before the macro argument does.
8464 We must pop levels and keep parsing.
8465 Therefore, we must allocate a temporary buffer and copy
8466 the macro argument into it. */
8467 int bufsize = bp - ip->bufp;
8468 int extra = newlines;
8469 U_CHAR *buffer = (U_CHAR *) xmalloc (bufsize + extra + 1);
8470 int final_start = 0;
8472 bcopy ((char *) ip->bufp, (char *) buffer, bufsize);
8474 ip->lineno += newlines;
8476 while (bp == ip->buf + ip->length) {
8477 if (instack[indepth].macro == 0) {
8478 result = "unterminated macro call";
8481 ip->macro->type = T_MACRO;
8483 free (ip->free_ptr);
8484 ip = &instack[--indepth];
8487 bp = macarg1 (ip->bufp, ip->buf + ip->length, &paren,
8488 &newlines, &comments, rest_args);
8489 final_start = bufsize;
8490 bufsize += bp - ip->bufp;
8492 buffer = (U_CHAR *) xrealloc (buffer, bufsize + extra + 1);
8493 bcopy ((char *) ip->bufp, (char *) (buffer + bufsize - (bp - ip->bufp)),
8496 ip->lineno += newlines;
8499 /* Now, if arg is actually wanted, record its raw form,
8500 discarding comments and duplicating newlines in whatever
8501 part of it did not come from a macro expansion.
8502 EXTRA space has been preallocated for duplicating the newlines.
8503 FINAL_START is the index of the start of that part. */
8505 argptr->raw = buffer;
8506 argptr->raw_length = bufsize;
8507 argptr->free1 = buffer;
8508 argptr->newlines = newlines;
8509 if ((newlines || comments) && ip->fname != 0)
8512 discard_comments (argptr->raw + final_start,
8513 argptr->raw_length - final_start,
8515 argptr->raw[argptr->raw_length] = 0;
8516 if (argptr->raw_length > bufsize + extra)
8521 /* If we are not discarding this argument,
8522 macroexpand it and compute its length as stringified.
8523 All this info goes into *ARGPTR. */
8526 register U_CHAR *buf, *lim;
8527 register int totlen;
8530 lim = buf + argptr->raw_length;
8532 while (buf != lim && is_space[*buf])
8534 while (buf != lim && is_space[lim[-1]])
8536 totlen = traditional ? 0 : 2; /* Count opening and closing quote. */
8537 while (buf != lim) {
8538 register U_CHAR c = *buf++;
8540 /* Internal sequences of whitespace are replaced by one space
8541 in most cases, but not always. So count all the whitespace
8542 in case we need to keep it all. */
8545 SKIP_ALL_WHITE_SPACE (buf);
8548 if (c == '\"' || c == '\\') /* escape these chars */
8550 else if (!isprint (c))
8553 argptr->stringified_length = totlen;
8558 /* Scan text from START (inclusive) up to LIMIT (exclusive),
8559 counting parens in *DEPTHPTR,
8560 and return if reach LIMIT
8561 or before a `)' that would make *DEPTHPTR negative
8562 or before a comma when *DEPTHPTR is zero.
8563 Single and double quotes are matched and termination
8564 is inhibited within them. Comments also inhibit it.
8565 Value returned is pointer to stopping place.
8567 Increment *NEWLINES each time a newline is passed.
8568 REST_ARGS notifies macarg1 that it should absorb the rest of the args.
8569 Set *COMMENTS to 1 if a comment is seen. */
8572 macarg1 (start, limit, depthptr, newlines, comments, rest_args)
8574 register U_CHAR *limit;
8575 int *depthptr, *newlines, *comments;
8578 register U_CHAR *bp = start;
8580 while (bp < limit) {
8586 if (--(*depthptr) < 0)
8590 /* Traditionally, backslash makes following char not special. */
8591 if (bp + 1 < limit && traditional)
8594 /* But count source lines anyway. */
8603 if (bp[1] == '\\' && bp[2] == '\n')
8604 newline_fix (bp + 1);
8605 if (cplusplus_comments && bp[1] == '/') {
8608 while (bp < limit && (*bp != '\n' || bp[-1] == '\\')) {
8609 if (*bp == '\n') ++*newlines;
8612 /* Now count the newline that we are about to skip. */
8616 if (bp[1] != '*' || bp + 1 >= limit)
8620 while (bp + 1 < limit) {
8622 && bp[1] == '\\' && bp[2] == '\n')
8623 newline_fix (bp + 1);
8624 if (bp[0] == '*' && bp[1] == '/')
8626 if (*bp == '\n') ++*newlines;
8634 for (quotec = *bp++; bp + 1 < limit && *bp != quotec; bp++) {
8639 while (*bp == '\\' && bp[1] == '\n') {
8642 } else if (*bp == '\n') {
8651 /* if we've returned to lowest level and we aren't absorbing all args */
8652 if ((*depthptr) == 0 && rest_args == 0)
8662 /* Discard comments and duplicate newlines
8663 in the string of length LENGTH at START,
8664 except inside of string constants.
8665 The string is copied into itself with its beginning staying fixed.
8667 NEWLINES is the number of newlines that must be duplicated.
8668 We assume that that much extra space is available past the end
8672 discard_comments (start, length, newlines)
8677 register U_CHAR *ibp;
8678 register U_CHAR *obp;
8679 register U_CHAR *limit;
8682 /* If we have newlines to duplicate, copy everything
8683 that many characters up. Then, in the second part,
8684 we will have room to insert the newlines
8686 NEWLINES may actually be too large, because it counts
8687 newlines in string constants, and we don't duplicate those.
8688 But that does no harm. */
8690 ibp = start + length;
8691 obp = ibp + newlines;
8693 while (limit != ibp)
8697 ibp = start + newlines;
8698 limit = start + length + newlines;
8701 while (ibp < limit) {
8702 *obp++ = c = *ibp++;
8705 /* Duplicate the newline. */
8717 if (*ibp == '\\' && ibp[1] == '\n')
8719 /* Delete any comment. */
8720 if (cplusplus_comments && ibp[0] == '/') {
8721 /* Comments are equivalent to spaces. */
8724 while (ibp < limit && (*ibp != '\n' || ibp[-1] == '\\'))
8728 if (ibp[0] != '*' || ibp + 1 >= limit)
8730 /* Comments are equivalent to spaces.
8731 For -traditional, a comment is equivalent to nothing. */
8737 while (ibp + 1 < limit) {
8739 && ibp[1] == '\\' && ibp[2] == '\n')
8740 newline_fix (ibp + 1);
8741 if (ibp[0] == '*' && ibp[1] == '/')
8750 /* Notice and skip strings, so that we don't
8751 think that comments start inside them,
8752 and so we don't duplicate newlines in them. */
8755 while (ibp < limit) {
8756 *obp++ = c = *ibp++;
8759 if (c == '\n' && quotec == '\'')
8761 if (c == '\\' && ibp < limit) {
8762 while (*ibp == '\\' && ibp[1] == '\n')
8775 /* Turn newlines to spaces in the string of length LENGTH at START,
8776 except inside of string constants.
8777 The string is copied into itself with its beginning staying fixed. */
8780 change_newlines (start, length)
8784 register U_CHAR *ibp;
8785 register U_CHAR *obp;
8786 register U_CHAR *limit;
8790 limit = start + length;
8793 while (ibp < limit) {
8794 *obp++ = c = *ibp++;
8797 /* If this is a NEWLINE NEWLINE, then this is a real newline in the
8798 string. Skip past the newline and its duplicate.
8799 Put a space in the output. */
8810 /* Notice and skip strings, so that we don't delete newlines in them. */
8813 while (ibp < limit) {
8814 *obp++ = c = *ibp++;
8817 if (c == '\n' && quotec == '\'')
8829 * my_strerror - return the descriptive text associated with an `errno' code.
8833 my_strerror (errnum)
8839 #ifndef HAVE_STRERROR
8840 result = (char *) ((errnum < sys_nerr) ? sys_errlist[errnum] : 0);
8842 result = strerror (errnum);
8845 /* VAXCRTL's strerror() takes an optional second argument, which only
8846 matters when the first argument is EVMSERR. However, it's simplest
8847 just to pass it unconditionally. `vaxc$errno' is declared in
8848 <errno.h>, and maintained by the library in parallel with `errno'.
8849 We assume that caller's `errnum' either matches the last setting of
8850 `errno' by the library or else does not have the value `EVMSERR'. */
8852 result = strerror (errnum, vaxc$errno);
8856 result = "undocumented I/O error";
8862 * error - print error message and increment count of errors.
8866 error (PRINTF_ALIST (msg))
8871 VA_START (args, msg);
8882 FILE_BUF *ip = NULL;
8884 print_containing_files ();
8886 for (i = indepth; i >= 0; i--)
8887 if (instack[i].fname != NULL) {
8893 fprintf (stderr, "%s:%d: ", ip->nominal_fname, ip->lineno);
8894 vfprintf (stderr, msg, args);
8895 fprintf (stderr, "\n");
8899 /* Error including a message from `errno'. */
8902 error_from_errno (name)
8906 FILE_BUF *ip = NULL;
8908 print_containing_files ();
8910 for (i = indepth; i >= 0; i--)
8911 if (instack[i].fname != NULL) {
8917 fprintf (stderr, "%s:%d: ", ip->nominal_fname, ip->lineno);
8919 fprintf (stderr, "%s: %s\n", name, my_strerror (errno));
8924 /* Print error message but don't count it. */
8927 warning (PRINTF_ALIST (msg))
8932 VA_START (args, msg);
8933 vwarning (msg, args);
8938 vwarning (msg, args)
8943 FILE_BUF *ip = NULL;
8945 if (inhibit_warnings)
8948 if (warnings_are_errors)
8951 print_containing_files ();
8953 for (i = indepth; i >= 0; i--)
8954 if (instack[i].fname != NULL) {
8960 fprintf (stderr, "%s:%d: ", ip->nominal_fname, ip->lineno);
8961 fprintf (stderr, "warning: ");
8962 vfprintf (stderr, msg, args);
8963 fprintf (stderr, "\n");
8967 #if defined (__STDC__) && defined (HAVE_VPRINTF)
8968 error_with_line (int line, PRINTF_ALIST (msg))
8970 error_with_line (line, PRINTF_ALIST (msg))
8977 VA_START (args, msg);
8978 verror_with_line (line, msg, args);
8983 verror_with_line (line, msg, args)
8989 FILE_BUF *ip = NULL;
8991 print_containing_files ();
8993 for (i = indepth; i >= 0; i--)
8994 if (instack[i].fname != NULL) {
9000 fprintf (stderr, "%s:%d: ", ip->nominal_fname, line);
9001 vfprintf (stderr, msg, args);
9002 fprintf (stderr, "\n");
9007 #if defined (__STDC__) && defined (HAVE_VPRINTF)
9008 warning_with_line (int line, PRINTF_ALIST (msg))
9010 warning_with_line (line, PRINTF_ALIST (msg))
9017 VA_START (args, msg);
9018 vwarning_with_line (line, msg, args);
9023 vwarning_with_line (line, msg, args)
9029 FILE_BUF *ip = NULL;
9031 if (inhibit_warnings)
9034 if (warnings_are_errors)
9037 print_containing_files ();
9039 for (i = indepth; i >= 0; i--)
9040 if (instack[i].fname != NULL) {
9046 fprintf (stderr, line ? "%s:%d: " : "%s: ", ip->nominal_fname, line);
9047 fprintf (stderr, "warning: ");
9048 vfprintf (stderr, msg, args);
9049 fprintf (stderr, "\n");
9052 /* print an error message and maybe count it. */
9055 pedwarn (PRINTF_ALIST (msg))
9060 VA_START (args, msg);
9061 if (pedantic_errors)
9064 vwarning (msg, args);
9069 #if defined (__STDC__) && defined (HAVE_VPRINTF)
9070 pedwarn_with_line (int line, PRINTF_ALIST (msg))
9072 pedwarn_with_line (line, PRINTF_ALIST (msg))
9079 VA_START (args, msg);
9080 if (pedantic_errors)
9081 verror_with_line (line, msg, args);
9083 vwarning_with_line (line, msg, args);
9087 /* Report a warning (or an error if pedantic_errors)
9088 giving specified file name and line number, not current. */
9091 #if defined (__STDC__) && defined (HAVE_VPRINTF)
9092 pedwarn_with_file_and_line (char *file, int line, PRINTF_ALIST (msg))
9094 pedwarn_with_file_and_line (file, line, PRINTF_ALIST (msg))
9102 if (!pedantic_errors && inhibit_warnings)
9105 fprintf (stderr, "%s:%d: ", file, line);
9106 if (pedantic_errors)
9108 if (!pedantic_errors)
9109 fprintf (stderr, "warning: ");
9110 VA_START (args, msg);
9111 vfprintf (stderr, msg, args);
9113 fprintf (stderr, "\n");
9116 /* Print the file names and line numbers of the #include
9117 directives which led to the current file. */
9120 print_containing_files ()
9122 FILE_BUF *ip = NULL;
9126 /* If stack of files hasn't changed since we last printed
9127 this info, don't repeat it. */
9128 if (last_error_tick == input_file_stack_tick)
9131 for (i = indepth; i >= 0; i--)
9132 if (instack[i].fname != NULL) {
9137 /* Give up if we don't find a source file. */
9141 /* Find the other, outer source files. */
9142 for (i--; i >= 0; i--)
9143 if (instack[i].fname != NULL) {
9147 fprintf (stderr, "In file included");
9149 fprintf (stderr, ",\n ");
9152 fprintf (stderr, " from %s:%d", ip->nominal_fname, ip->lineno);
9155 fprintf (stderr, ":\n");
9157 /* Record we have printed the status as of this time. */
9158 last_error_tick = input_file_stack_tick;
9161 /* Return the line at which an error occurred.
9162 The error is not necessarily associated with the current spot
9163 in the input stack, so LINE says where. LINE will have been
9164 copied from ip->lineno for the current input level.
9165 If the current level is for a file, we return LINE.
9166 But if the current level is not for a file, LINE is meaningless.
9167 In that case, we return the lineno of the innermost file. */
9170 line_for_error (line)
9176 for (i = indepth; i >= 0; ) {
9177 if (instack[i].fname != 0)
9182 line1 = instack[i].lineno;
9190 * If OBUF doesn't have NEEDED bytes after OPTR, make it bigger.
9192 * As things stand, nothing is ever placed in the output buffer to be
9193 * removed again except when it's KNOWN to be part of an identifier,
9194 * so flushing and moving down everything left, instead of expanding,
9198 /* You might think void was cleaner for the return type,
9199 but that would get type mismatch in check_expand in strict ANSI. */
9201 grow_outbuf (obuf, needed)
9202 register FILE_BUF *obuf;
9203 register int needed;
9208 if (obuf->length - (obuf->bufp - obuf->buf) > needed)
9211 /* Make it at least twice as big as it is now. */
9213 /* Make it have at least 150% of the free space we will need. */
9214 minsize = (3 * needed) / 2 + (obuf->bufp - obuf->buf);
9215 if (minsize > obuf->length)
9216 obuf->length = minsize;
9218 if ((p = (U_CHAR *) xrealloc (obuf->buf, obuf->length)) == NULL)
9221 obuf->bufp = p + (obuf->bufp - obuf->buf);
9227 /* Symbol table for macro names and special symbols */
9230 * install a name in the main hash table, even if it is already there.
9231 * name stops with first non alphanumeric, except leading '#'.
9232 * caller must check against redefinition if that is desired.
9233 * delete_macro () removes things installed by install () in fifo order.
9234 * this is important because of the `defined' special symbol used
9235 * in #if, and also if pushdef/popdef directives are ever implemented.
9237 * If LEN is >= 0, it is the length of the name.
9238 * Otherwise, compute the length by scanning the entire name.
9240 * If HASH is >= 0, it is the precomputed hash code.
9241 * Otherwise, compute the hash code.
9244 install (name, len, type, value, hash)
9247 enum node_type type;
9251 register HASHNODE *hp;
9252 register int i, bucket;
9253 register U_CHAR *p, *q;
9257 while (is_idchar[*p])
9263 hash = hashf (name, len, HASHSIZE);
9265 i = sizeof (HASHNODE) + len + 1;
9266 hp = (HASHNODE *) xmalloc (i);
9268 hp->bucket_hdr = &hashtab[bucket];
9269 hp->next = hashtab[bucket];
9270 hashtab[bucket] = hp;
9272 if (hp->next != NULL)
9273 hp->next->prev = hp;
9276 hp->value.cpval = value;
9277 hp->name = ((U_CHAR *) hp) + sizeof (HASHNODE);
9280 for (i = 0; i < len; i++)
9287 * find the most recent hash node for name name (ending with first
9288 * non-identifier char) installed by install
9290 * If LEN is >= 0, it is the length of the name.
9291 * Otherwise, compute the length by scanning the entire name.
9293 * If HASH is >= 0, it is the precomputed hash code.
9294 * Otherwise, compute the hash code.
9297 lookup (name, len, hash)
9302 register U_CHAR *bp;
9303 register HASHNODE *bucket;
9306 for (bp = name; is_idchar[*bp]; bp++) ;
9311 hash = hashf (name, len, HASHSIZE);
9313 bucket = hashtab[hash];
9315 if (bucket->length == len && bcmp (bucket->name, name, len) == 0)
9317 bucket = bucket->next;
9323 * Delete a hash node. Some weirdness to free junk from macros.
9324 * More such weirdness will have to be added if you define more hash
9325 * types that need it.
9328 /* Note that the DEFINITION of a macro is removed from the hash table
9329 but its storage is not freed. This would be a storage leak
9330 except that it is not reasonable to keep undefining and redefining
9331 large numbers of macros many times.
9332 In any case, this is necessary, because a macro can be #undef'd
9333 in the middle of reading the arguments to a call to it.
9334 If #undef freed the DEFINITION, that would crash. */
9341 if (hp->prev != NULL)
9342 hp->prev->next = hp->next;
9343 if (hp->next != NULL)
9344 hp->next->prev = hp->prev;
9346 /* make sure that the bucket chain header that
9347 the deleted guy was on points to the right thing afterwards. */
9348 if (hp == *hp->bucket_hdr)
9349 *hp->bucket_hdr = hp->next;
9352 if (hp->type == T_MACRO) {
9353 DEFINITION *d = hp->value.defn;
9354 struct reflist *ap, *nextap;
9356 for (ap = d->pattern; ap != NULL; ap = nextap) {
9367 * return hash function on name. must be compatible with the one
9368 * computed a step at a time, elsewhere
9371 hashf (name, len, hashsize)
9372 register U_CHAR *name;
9379 r = HASHSTEP (r, *name++);
9381 return MAKE_POS (r) % hashsize;
9385 /* Dump the definition of a single macro HP to OF. */
9387 dump_single_macro (hp, of)
9388 register HASHNODE *hp;
9391 register DEFINITION *defn = hp->value.defn;
9397 /* Print the definition of the macro HP. */
9399 fprintf (of, "#define %s", hp->name);
9401 if (defn->nargs >= 0) {
9405 for (i = 0; i < defn->nargs; i++) {
9406 dump_arg_n (defn, i, of);
9407 if (i + 1 < defn->nargs)
9417 for (ap = defn->pattern; ap != NULL; ap = ap->next) {
9418 dump_defn_1 (defn->expansion, offset, ap->nchars, of);
9419 offset += ap->nchars;
9421 if (ap->nchars != 0)
9423 if (ap->stringify) {
9424 switch (ap->stringify) {
9425 case SHARP_TOKEN: fprintf (of, "#"); break;
9426 case WHITE_SHARP_TOKEN: fprintf (of, "# "); break;
9427 case PERCENT_COLON_TOKEN: fprintf (of, "%%:"); break;
9428 case WHITE_PERCENT_COLON_TOKEN: fprintf (of, "%%: "); break;
9432 if (ap->raw_before != 0) {
9434 switch (ap->raw_before) {
9435 case WHITE_SHARP_TOKEN:
9436 case WHITE_PERCENT_COLON_TOKEN:
9443 switch (ap->raw_before) {
9444 case SHARP_TOKEN: fprintf (of, "##"); break;
9445 case WHITE_SHARP_TOKEN: fprintf (of, "## "); break;
9446 case PERCENT_COLON_TOKEN: fprintf (of, "%%:%%:"); break;
9447 case WHITE_PERCENT_COLON_TOKEN: fprintf (of, "%%:%%: "); break;
9454 dump_arg_n (defn, ap->argno, of);
9455 if (!traditional && ap->raw_after != 0) {
9456 switch (ap->raw_after) {
9457 case SHARP_TOKEN: fprintf (of, "##"); break;
9458 case WHITE_SHARP_TOKEN: fprintf (of, " ##"); break;
9459 case PERCENT_COLON_TOKEN: fprintf (of, "%%:%%:"); break;
9460 case WHITE_PERCENT_COLON_TOKEN: fprintf (of, " %%:%%:"); break;
9466 dump_defn_1 (defn->expansion, offset, defn->length - offset, of);
9470 /* Dump all macro definitions as #defines to stdout. */
9477 for (bucket = 0; bucket < HASHSIZE; bucket++) {
9478 register HASHNODE *hp;
9480 for (hp = hashtab[bucket]; hp; hp= hp->next) {
9481 if (hp->type == T_MACRO)
9482 dump_single_macro (hp, stdout);
9487 /* Output to OF a substring of a macro definition.
9488 BASE is the beginning of the definition.
9489 Output characters START thru LENGTH.
9490 Unless traditional, discard newlines outside of strings, thus
9491 converting funny-space markers to ordinary spaces. */
9494 dump_defn_1 (base, start, length, of)
9500 U_CHAR *p = base + start;
9501 U_CHAR *limit = base + start + length;
9504 fwrite (p, sizeof (*p), length, of);
9507 if (*p == '\"' || *p =='\'') {
9508 U_CHAR *p1 = skip_quoted_string (p, limit, 0, NULL_PTR,
9509 NULL_PTR, NULL_PTR);
9510 fwrite (p, sizeof (*p), p1 - p, of);
9521 /* Print the name of argument number ARGNUM of macro definition DEFN
9523 Recall that DEFN->args.argnames contains all the arg names
9524 concatenated in reverse order with comma-space in between. */
9527 dump_arg_n (defn, argnum, of)
9532 register U_CHAR *p = defn->args.argnames;
9533 while (argnum + 1 < defn->nargs) {
9534 p = (U_CHAR *) index ((char *) p, ' ') + 1;
9538 while (*p && *p != ',') {
9544 /* Initialize syntactic classifications of characters. */
9547 initialize_char_syntax ()
9552 * Set up is_idchar and is_idstart tables. These should be
9553 * faster than saying (is_alpha (c) || c == '_'), etc.
9554 * Set up these things before calling any routines tthat
9557 for (i = 'a'; i <= 'z'; i++) {
9558 is_idchar[i - 'a' + 'A'] = 1;
9560 is_idstart[i - 'a' + 'A'] = 1;
9563 for (i = '0'; i <= '9'; i++)
9566 is_idstart['_'] = 1;
9567 is_idchar['$'] = dollars_in_ident;
9568 is_idstart['$'] = dollars_in_ident;
9570 /* horizontal space table */
9571 is_hor_space[' '] = 1;
9572 is_hor_space['\t'] = 1;
9573 is_hor_space['\v'] = 1;
9574 is_hor_space['\f'] = 1;
9575 is_hor_space['\r'] = 1;
9584 char_name['\v'] = "vertical tab";
9585 char_name['\f'] = "formfeed";
9586 char_name['\r'] = "carriage return";
9589 /* Initialize the built-in macros. */
9592 initialize_builtins (inp, outp)
9596 install ((U_CHAR *) "__LINE__", -1, T_SPECLINE, NULL_PTR, -1);
9597 install ((U_CHAR *) "__DATE__", -1, T_DATE, NULL_PTR, -1);
9598 install ((U_CHAR *) "__FILE__", -1, T_FILE, NULL_PTR, -1);
9599 install ((U_CHAR *) "__BASE_FILE__", -1, T_BASE_FILE, NULL_PTR, -1);
9600 install ((U_CHAR *) "__INCLUDE_LEVEL__", -1, T_INCLUDE_LEVEL, NULL_PTR, -1);
9601 install ((U_CHAR *) "__VERSION__", -1, T_VERSION, NULL_PTR, -1);
9602 #ifndef NO_BUILTIN_SIZE_TYPE
9603 install ((U_CHAR *) "__SIZE_TYPE__", -1, T_SIZE_TYPE, NULL_PTR, -1);
9605 #ifndef NO_BUILTIN_PTRDIFF_TYPE
9606 install ((U_CHAR *) "__PTRDIFF_TYPE__ ", -1, T_PTRDIFF_TYPE, NULL_PTR, -1);
9608 install ((U_CHAR *) "__WCHAR_TYPE__", -1, T_WCHAR_TYPE, NULL_PTR, -1);
9609 install ((U_CHAR *) "__USER_LABEL_PREFIX__", -1, T_USER_LABEL_PREFIX_TYPE,
9611 install ((U_CHAR *) "__REGISTER_PREFIX__", -1, T_REGISTER_PREFIX_TYPE,
9613 install ((U_CHAR *) "__IMMEDIATE_PREFIX__", -1, T_IMMEDIATE_PREFIX_TYPE,
9615 install ((U_CHAR *) "__TIME__", -1, T_TIME, NULL_PTR, -1);
9617 install ((U_CHAR *) "__STDC__", -1, T_CONST, "1", -1);
9618 install ((U_CHAR *) "__STDC_VERSION__", -1, T_CONST, "199409L", -1);
9621 install ((U_CHAR *) "__OBJC__", -1, T_CONST, "1", -1);
9622 /* This is supplied using a -D by the compiler driver
9623 so that it is present only when truly compiling with GNU C. */
9624 /* install ((U_CHAR *) "__GNUC__", -1, T_CONST, "2", -1); */
9628 char directive[2048];
9629 U_CHAR *udirective = (U_CHAR *) directive;
9630 register struct directive *dp = &directive_table[0];
9631 struct tm *timebuf = timestamp ();
9633 sprintf (directive, " __BASE_FILE__ \"%s\"\n",
9634 instack[0].nominal_fname);
9635 output_line_directive (inp, outp, 0, same_file);
9636 pass_thru_directive (udirective, &udirective[strlen (directive)],
9639 sprintf (directive, " __VERSION__ \"%s\"\n", version_string);
9640 output_line_directive (inp, outp, 0, same_file);
9641 pass_thru_directive (udirective, &udirective[strlen (directive)],
9644 #ifndef NO_BUILTIN_SIZE_TYPE
9645 sprintf (directive, " __SIZE_TYPE__ %s\n", SIZE_TYPE);
9646 output_line_directive (inp, outp, 0, same_file);
9647 pass_thru_directive (udirective, &udirective[strlen (directive)],
9651 #ifndef NO_BUILTIN_PTRDIFF_TYPE
9652 sprintf (directive, " __PTRDIFF_TYPE__ %s\n", PTRDIFF_TYPE);
9653 output_line_directive (inp, outp, 0, same_file);
9654 pass_thru_directive (udirective, &udirective[strlen (directive)],
9658 sprintf (directive, " __WCHAR_TYPE__ %s\n", wchar_type);
9659 output_line_directive (inp, outp, 0, same_file);
9660 pass_thru_directive (udirective, &udirective[strlen (directive)],
9663 sprintf (directive, " __DATE__ \"%s %2d %4d\"\n",
9664 monthnames[timebuf->tm_mon],
9665 timebuf->tm_mday, timebuf->tm_year + 1900);
9666 output_line_directive (inp, outp, 0, same_file);
9667 pass_thru_directive (udirective, &udirective[strlen (directive)],
9670 sprintf (directive, " __TIME__ \"%02d:%02d:%02d\"\n",
9671 timebuf->tm_hour, timebuf->tm_min, timebuf->tm_sec);
9672 output_line_directive (inp, outp, 0, same_file);
9673 pass_thru_directive (udirective, &udirective[strlen (directive)],
9678 sprintf (directive, " __STDC__ 1");
9679 output_line_directive (inp, outp, 0, same_file);
9680 pass_thru_directive (udirective, &udirective[strlen (directive)],
9685 sprintf (directive, " __OBJC__ 1");
9686 output_line_directive (inp, outp, 0, same_file);
9687 pass_thru_directive (udirective, &udirective[strlen (directive)],
9694 * process a given definition string, for initialization
9695 * If STR is just an identifier, define it with value 1.
9696 * If STR has anything after the identifier, then it should
9697 * be identifier=definition.
9701 make_definition (str, op)
9706 struct directive *kt;
9709 p = buf = (U_CHAR *) str;
9710 if (!is_idstart[*p]) {
9711 error ("malformed option `-D %s'", str);
9714 while (is_idchar[*++p])
9717 while (is_idchar[*++p] || *p == ',' || is_hor_space[*p])
9720 p = (U_CHAR *) str; /* Error */
9723 buf = (U_CHAR *) alloca (p - buf + 4);
9724 strcpy ((char *)buf, str);
9725 strcat ((char *)buf, " 1");
9726 } else if (*p != '=') {
9727 error ("malformed option `-D %s'", str);
9731 /* Copy the entire option so we can modify it. */
9732 buf = (U_CHAR *) alloca (2 * strlen (str) + 1);
9733 strncpy ((char *) buf, str, p - (U_CHAR *) str);
9734 /* Change the = to a space. */
9735 buf[p - (U_CHAR *) str] = ' ';
9736 /* Scan for any backslash-newline and remove it. */
9738 q = &buf[p - (U_CHAR *) str];
9740 if (*p == '\"' || *p == '\'') {
9741 int unterminated = 0;
9742 U_CHAR *p1 = skip_quoted_string (p, p + strlen ((char *) p), 0,
9743 NULL_PTR, NULL_PTR, &unterminated);
9747 if (*p == '\\' && p[1] == '\n')
9751 } else if (*p == '\\' && p[1] == '\n')
9753 /* Change newline chars into newline-markers. */
9754 else if (*p == '\n')
9766 ip = &instack[++indepth];
9767 ip->nominal_fname = ip->fname = "*Initialization*";
9769 ip->buf = ip->bufp = buf;
9770 ip->length = strlen ((char *) buf);
9774 ip->if_stack = if_stack;
9775 ip->system_header_p = 0;
9777 for (kt = directive_table; kt->type != T_DEFINE; kt++)
9780 /* Pass NULL instead of OP, since this is a "predefined" macro. */
9781 do_define (buf, buf + strlen ((char *) buf), NULL_PTR, kt);
9785 /* JF, this does the work for the -U option */
9788 make_undef (str, op)
9793 struct directive *kt;
9795 ip = &instack[++indepth];
9796 ip->nominal_fname = ip->fname = "*undef*";
9798 ip->buf = ip->bufp = (U_CHAR *) str;
9799 ip->length = strlen (str);
9803 ip->if_stack = if_stack;
9804 ip->system_header_p = 0;
9806 for (kt = directive_table; kt->type != T_UNDEF; kt++)
9809 do_undef ((U_CHAR *) str, (U_CHAR *) str + strlen (str), op, kt);
9813 /* Process the string STR as if it appeared as the body of a #assert.
9814 OPTION is the option name for which STR was the argument. */
9817 make_assertion (option, str)
9822 struct directive *kt;
9823 U_CHAR *buf, *p, *q;
9825 /* Copy the entire option so we can modify it. */
9826 buf = (U_CHAR *) alloca (strlen (str) + 1);
9827 strcpy ((char *) buf, str);
9828 /* Scan for any backslash-newline and remove it. */
9831 if (*p == '\\' && p[1] == '\n')
9839 if (!is_idstart[*p]) {
9840 error ("malformed option `%s %s'", option, str);
9843 while (is_idchar[*++p])
9845 SKIP_WHITE_SPACE (p);
9846 if (! (*p == 0 || *p == '(')) {
9847 error ("malformed option `%s %s'", option, str);
9851 ip = &instack[++indepth];
9852 ip->nominal_fname = ip->fname = "*Initialization*";
9854 ip->buf = ip->bufp = buf;
9855 ip->length = strlen ((char *) buf);
9859 ip->if_stack = if_stack;
9860 ip->system_header_p = 0;
9862 for (kt = directive_table; kt->type != T_ASSERT; kt++)
9865 /* pass NULL as output ptr to do_define since we KNOW it never
9866 does any output.... */
9867 do_assert (buf, buf + strlen ((char *) buf) , NULL_PTR, kt);
9871 /* Append a chain of `struct file_name_list's
9872 to the end of the main include chain.
9873 FIRST is the beginning of the chain to append, and LAST is the end. */
9876 append_include_chain (first, last)
9877 struct file_name_list *first, *last;
9879 struct file_name_list *dir;
9881 if (!first || !last)
9887 last_include->next = first;
9889 if (first_bracket_include == 0)
9890 first_bracket_include = first;
9892 for (dir = first; ; dir = dir->next) {
9893 int len = strlen (dir->fname) + INCLUDE_LEN_FUDGE;
9894 if (len > max_include_len)
9895 max_include_len = len;
9901 last_include = last;
9904 /* Add output to `deps_buffer' for the -M switch.
9905 STRING points to the text to be output.
9906 SPACER is ':' for targets, ' ' for dependencies. */
9909 deps_output (string, spacer)
9913 int size = strlen (string);
9918 #ifndef MAX_OUTPUT_COLUMNS
9919 #define MAX_OUTPUT_COLUMNS 72
9921 if (MAX_OUTPUT_COLUMNS - 1 /*spacer*/ - 2 /*` \'*/ < deps_column + size
9922 && 1 < deps_column) {
9923 bcopy (" \\\n ", &deps_buffer[deps_size], 4);
9930 if (deps_size + size + 8 > deps_allocated_size) {
9931 deps_allocated_size = (deps_size + size + 50) * 2;
9932 deps_buffer = xrealloc (deps_buffer, deps_allocated_size);
9934 if (spacer == ' ') {
9935 deps_buffer[deps_size++] = ' ';
9938 bcopy (string, &deps_buffer[deps_size], size);
9940 deps_column += size;
9941 if (spacer == ':') {
9942 deps_buffer[deps_size++] = ':';
9945 deps_buffer[deps_size] = 0;
9949 fatal (PRINTF_ALIST (msg))
9954 fprintf (stderr, "%s: ", progname);
9955 VA_START (args, msg);
9956 vfprintf (stderr, msg, args);
9958 fprintf (stderr, "\n");
9959 exit (FATAL_EXIT_CODE);
9962 /* More 'friendly' abort that prints the line and file.
9963 config.h can #define abort fancy_abort if you like that sort of thing. */
9968 fatal ("Internal gcc abort.");
9972 perror_with_name (name)
9975 fprintf (stderr, "%s: ", progname);
9976 fprintf (stderr, "%s: %s\n", name, my_strerror (errno));
9981 pfatal_with_name (name)
9984 perror_with_name (name);
9988 exit (FATAL_EXIT_CODE);
9992 /* Handler for SIGPIPE. */
9996 /* If this is missing, some compilers complain. */
9999 fatal ("output pipe has been closed");
10005 fatal ("Memory exhausted.");
10013 register GENERIC_PTR ptr = (GENERIC_PTR) malloc (size);
10020 xrealloc (old, size)
10024 register GENERIC_PTR ptr = (GENERIC_PTR) realloc (old, size);
10031 xcalloc (number, size)
10032 size_t number, size;
10034 register size_t total = number * size;
10035 register GENERIC_PTR ptr = (GENERIC_PTR) malloc (total);
10038 bzero (ptr, total);
10046 size_t size = strlen (input);
10047 char *output = xmalloc (size + 1);
10048 strcpy (output, input);
10052 /* Get the file-mode and data size of the file open on FD
10053 and store them in *MODE_POINTER and *SIZE_POINTER. */
10056 file_size_and_mode (fd, mode_pointer, size_pointer)
10059 long int *size_pointer;
10063 if (fstat (fd, &sbuf) < 0) return (-1);
10064 if (mode_pointer) *mode_pointer = sbuf.st_mode;
10065 if (size_pointer) *size_pointer = sbuf.st_size;
10071 /* Under VMS we need to fix up the "include" specification
10072 filename so that everything following the 1st slash is
10073 changed into its correct VMS file specification. */
10076 hack_vms_include_specification (fname)
10079 register char *cp, *cp1, *cp2;
10080 int f, check_filename_before_returning, no_prefix_seen;
10083 check_filename_before_returning = 0;
10084 no_prefix_seen = 0;
10086 /* Ignore leading "./"s */
10087 while (fname[0] == '.' && fname[1] == '/') {
10088 strcpy (fname, fname+2);
10089 no_prefix_seen = 1; /* mark this for later */
10091 /* Look for the boundary between the VMS and UNIX filespecs */
10092 cp = rindex (fname, ']'); /* Look for end of dirspec. */
10093 if (cp == 0) cp = rindex (fname, '>'); /* ... Ditto */
10094 if (cp == 0) cp = rindex (fname, ':'); /* Look for end of devspec. */
10098 cp = index (fname, '/'); /* Look for the "/" */
10102 * Check if we have a vax-c style '#include filename'
10103 * and add the missing .h
10106 if (index(fname,'.') == 0)
10107 strcat(fname, ".h");
10109 if (index(cp,'.') == 0)
10113 cp2 = Local; /* initialize */
10115 /* We are trying to do a number of things here. First of all, we are
10116 trying to hammer the filenames into a standard format, such that later
10117 processing can handle them.
10119 If the file name contains something like [dir.], then it recognizes this
10120 as a root, and strips the ".]". Later processing will add whatever is
10121 needed to get things working properly.
10123 If no device is specified, then the first directory name is taken to be
10124 a device name (or a rooted logical). */
10126 /* See if we found that 1st slash */
10127 if (cp == 0) return; /* Nothing to do!!! */
10128 if (*cp != '/') return; /* Nothing to do!!! */
10129 /* Point to the UNIX filename part (which needs to be fixed!) */
10131 /* If the directory spec is not rooted, we can just copy
10132 the UNIX filename part and we are done */
10133 if (((cp - fname) > 1) && ((cp[-1] == ']') || (cp[-1] == '>'))) {
10134 if (cp[-2] != '.') {
10136 * The VMS part ends in a `]', and the preceding character is not a `.'.
10137 * We strip the `]', and then splice the two parts of the name in the
10138 * usual way. Given the default locations for include files in cccp.c,
10139 * we will only use this code if the user specifies alternate locations
10140 * with the /include (-I) switch on the command line. */
10141 cp -= 1; /* Strip "]" */
10142 cp1--; /* backspace */
10145 * The VMS part has a ".]" at the end, and this will not do. Later
10146 * processing will add a second directory spec, and this would be a syntax
10147 * error. Thus we strip the ".]", and thus merge the directory specs.
10148 * We also backspace cp1, so that it points to a '/'. This inhibits the
10149 * generation of the 000000 root directory spec (which does not belong here
10152 cp -= 2; /* Strip ".]" */
10153 cp1--; }; /* backspace */
10156 /* We drop in here if there is no VMS style directory specification yet.
10157 * If there is no device specification either, we make the first dir a
10158 * device and try that. If we do not do this, then we will be essentially
10159 * searching the users default directory (as if they did a #include "asdf.h").
10161 * Then all we need to do is to push a '[' into the output string. Later
10162 * processing will fill this in, and close the bracket.
10164 if (cp[-1] != ':') *cp2++ = ':'; /* dev not in spec. take first dir */
10165 *cp2++ = '['; /* Open the directory specification */
10168 /* at this point we assume that we have the device spec, and (at least
10169 the opening "[" for a directory specification. We may have directories
10170 specified already */
10172 /* If there are no other slashes then the filename will be
10173 in the "root" directory. Otherwise, we need to add
10174 directory specifications. */
10175 if (index (cp1, '/') == 0) {
10176 /* Just add "000000]" as the directory string */
10177 strcpy (cp2, "000000]");
10178 cp2 += strlen (cp2);
10179 check_filename_before_returning = 1; /* we might need to fool with this later */
10181 /* As long as there are still subdirectories to add, do them. */
10182 while (index (cp1, '/') != 0) {
10183 /* If this token is "." we can ignore it */
10184 if ((cp1[0] == '.') && (cp1[1] == '/')) {
10188 /* Add a subdirectory spec. Do not duplicate "." */
10189 if (cp2[-1] != '.' && cp2[-1] != '[' && cp2[-1] != '<')
10191 /* If this is ".." then the spec becomes "-" */
10192 if ((cp1[0] == '.') && (cp1[1] == '.') && (cp[2] == '/')) {
10193 /* Add "-" and skip the ".." */
10198 /* Copy the subdirectory */
10199 while (*cp1 != '/') *cp2++= *cp1++;
10200 cp1++; /* Skip the "/" */
10202 /* Close the directory specification */
10203 if (cp2[-1] == '.') /* no trailing periods */
10207 /* Now add the filename */
10208 while (*cp1) *cp2++ = *cp1++;
10210 /* Now append it to the original VMS spec. */
10211 strcpy (cp, Local);
10213 /* If we put a [000000] in the filename, try to open it first. If this fails,
10214 remove the [000000], and return that name. This provides flexibility
10215 to the user in that they can use both rooted and non-rooted logical names
10216 to point to the location of the file. */
10218 if (check_filename_before_returning && no_prefix_seen) {
10219 f = open (fname, O_RDONLY, 0666);
10221 /* The file name is OK as it is, so return it as is. */
10225 /* The filename did not work. Try to remove the [000000] from the name,
10227 cp = index (fname, '[');
10228 cp2 = index (fname, ']') + 1;
10229 strcpy (cp, cp2); /* this gets rid of it */
10237 /* These are the read/write replacement routines for
10238 VAX-11 "C". They make read/write behave enough
10239 like their UNIX counterparts that CCCP will work */
10242 read (fd, buf, size)
10247 #undef read /* Get back the REAL read routine */
10249 register int total = 0;
10251 /* Read until the buffer is exhausted */
10253 /* Limit each read to 32KB */
10254 i = (size > (32*1024)) ? (32*1024) : size;
10255 i = read (fd, buf, i);
10257 if (i == 0) return (total);
10260 /* Account for this read */
10269 write (fd, buf, size)
10274 #undef write /* Get back the REAL write routine */
10278 /* Limit individual writes to 32Kb */
10281 j = (i > (32*1024)) ? (32*1024) : i;
10282 if (write (fd, buf, j) < 0) return (-1);
10283 /* Account for the data written */
10290 /* The following wrapper functions supply additional arguments to the VMS
10291 I/O routines to optimize performance with file handling. The arguments
10293 "mbc=16" - Set multi-block count to 16 (use a 8192 byte buffer).
10294 "deq=64" - When extending the file, extend it in chunks of 32Kbytes.
10295 "fop=tef"- Truncate unused portions of file when closing file.
10296 "shr=nil"- Disallow file sharing while file is open.
10300 freopen (fname, type, oldfile)
10305 #undef freopen /* Get back the REAL fopen routine */
10306 if (strcmp (type, "w") == 0)
10307 return freopen (fname, type, oldfile, "mbc=16", "deq=64", "fop=tef", "shr=nil");
10308 return freopen (fname, type, oldfile, "mbc=16");
10312 fopen (fname, type)
10316 #undef fopen /* Get back the REAL fopen routine */
10317 /* The gcc-vms-1.42 distribution's header files prototype fopen with two
10318 fixed arguments, which matches ANSI's specification but not VAXCRTL's
10319 pre-ANSI implementation. This hack circumvents the mismatch problem. */
10320 FILE *(*vmslib_fopen)() = (FILE *(*)()) fopen;
10323 return (*vmslib_fopen) (fname, type, "mbc=32",
10324 "deq=64", "fop=tef", "shr=nil");
10326 return (*vmslib_fopen) (fname, type, "mbc=32");
10330 open (fname, flags, prot)
10335 #undef open /* Get back the REAL open routine */
10336 return open (fname, flags, prot, "mbc=16", "deq=64", "fop=tef");
10339 /* Avoid run-time library bug, where copying M out of N+M characters with
10340 N >= 65535 results in VAXCRTL's strncat falling into an infinite loop.
10341 gcc-cpp exercises this particular bug. [Fixed in V5.5-2's VAXCRTL.] */
10344 strncat (dst, src, cnt)
10349 register char *d = dst, *s = (char *) src;
10350 register int n = cnt; /* convert to _signed_ type */
10352 while (*d) d++; /* advance to end */
10354 if (!(*d++ = *s++)) break;
10355 if (n < 0) *d = '\0';
10359 /* more VMS hackery */
10363 extern unsigned long sys$parse(), sys$search();
10365 /* Work around another library bug. If a file is located via a searchlist,
10366 and if the device it's on is not the same device as the one specified
10367 in the first element of that searchlist, then both stat() and fstat()
10368 will fail to return info about it. `errno' will be set to EVMSERR, and
10369 `vaxc$errno' will be set to SS$_NORMAL due yet another bug in stat()!
10370 We can get around this by fully parsing the filename and then passing
10371 that absolute name to stat().
10373 Without this fix, we can end up failing to find header files, which is
10374 bad enough, but then compounding the problem by reporting the reason for
10375 failure as "normal successful completion." */
10377 #undef fstat /* get back to library version */
10380 VMS_fstat (fd, statbuf)
10382 struct stat *statbuf;
10384 int result = fstat (fd, statbuf);
10389 char nambuf[NAM$C_MAXRSS+1];
10391 if ((fp = fdopen (fd, "r")) != 0 && fgetname (fp, nambuf) != 0)
10392 result = VMS_stat (nambuf, statbuf);
10393 /* No fclose(fp) here; that would close(fd) as well. */
10400 VMS_stat (name, statbuf)
10402 struct stat *statbuf;
10404 int result = stat (name, statbuf);
10410 char exp_nam[NAM$C_MAXRSS+1], /* expanded name buffer for sys$parse */
10411 res_nam[NAM$C_MAXRSS+1]; /* resultant name buffer for sys$search */
10414 fab.fab$l_fna = (char *) name;
10415 fab.fab$b_fns = (unsigned char) strlen (name);
10416 fab.fab$l_nam = (void *) &nam;
10418 nam.nam$l_esa = exp_nam, nam.nam$b_ess = sizeof exp_nam - 1;
10419 nam.nam$l_rsa = res_nam, nam.nam$b_rss = sizeof res_nam - 1;
10420 nam.nam$b_nop = NAM$M_PWD | NAM$M_NOCONCEAL;
10421 if (sys$parse (&fab) & 1)
10423 if (sys$search (&fab) & 1)
10425 res_nam[nam.nam$b_rsl] = '\0';
10426 result = stat (res_nam, statbuf);
10428 /* Clean up searchlist context cached by the system. */
10429 nam.nam$b_nop = NAM$M_SYNCHK;
10430 fab.fab$l_fna = 0, fab.fab$b_fns = 0;
10431 (void) sys$parse (&fab);