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 is_system_include PROTO((char *));
1087 static char *read_filename_string PROTO((int, FILE *));
1088 static struct file_name_map *read_name_map PROTO((char *));
1089 static int open_include_file PROTO((char *, struct file_name_list *));
1091 static void finclude PROTO((int, char *, FILE_BUF *, int, struct file_name_list *));
1092 static void record_control_macro PROTO((char *, U_CHAR *));
1094 static int import_hash PROTO((char *));
1095 static int lookup_import PROTO((char *, struct file_name_list *));
1096 static void add_import PROTO((int, char *));
1098 static char *check_precompiled PROTO((int, char *, char **));
1099 static int check_preconditions PROTO((char *));
1100 static void pcfinclude PROTO((U_CHAR *, U_CHAR *, U_CHAR *, FILE_BUF *));
1101 static void pcstring_used PROTO((HASHNODE *));
1102 static void write_output PROTO((void));
1103 static void pass_thru_directive PROTO((U_CHAR *, U_CHAR *, FILE_BUF *, struct directive *));
1105 static MACRODEF create_definition PROTO((U_CHAR *, U_CHAR *, FILE_BUF *));
1107 static int check_macro_name PROTO((U_CHAR *, char *));
1108 static int compare_defs PROTO((DEFINITION *, DEFINITION *));
1109 static int comp_def_part PROTO((int, U_CHAR *, int, U_CHAR *, int, int));
1111 static DEFINITION *collect_expansion PROTO((U_CHAR *, U_CHAR *, int, struct arglist *));
1113 int check_assertion PROTO((U_CHAR *, int, int, struct arglist *));
1114 static int compare_token_lists PROTO((struct arglist *, struct arglist *));
1116 static struct arglist *read_token_list PROTO((U_CHAR **, U_CHAR *, int *));
1117 static void free_token_list PROTO((struct arglist *));
1119 static ASSERTION_HASHNODE *assertion_install PROTO((U_CHAR *, int, int));
1120 static ASSERTION_HASHNODE *assertion_lookup PROTO((U_CHAR *, int, int));
1121 static void delete_assertion PROTO((ASSERTION_HASHNODE *));
1123 static void do_once PROTO((void));
1125 static HOST_WIDE_INT eval_if_expression PROTO((U_CHAR *, int));
1126 static void conditional_skip PROTO((FILE_BUF *, int, enum node_type, U_CHAR *, FILE_BUF *));
1127 static void skip_if_group PROTO((FILE_BUF *, int, FILE_BUF *));
1128 static void validate_else PROTO((U_CHAR *));
1130 static U_CHAR *skip_to_end_of_comment PROTO((FILE_BUF *, int *, int));
1131 static U_CHAR *skip_quoted_string PROTO((U_CHAR *, U_CHAR *, int, int *, int *, int *));
1132 static char *quote_string PROTO((char *, char *));
1133 static U_CHAR *skip_paren_group PROTO((FILE_BUF *));
1135 /* Last arg to output_line_directive. */
1136 enum file_change_code {same_file, enter_file, leave_file};
1137 static void output_line_directive PROTO((FILE_BUF *, FILE_BUF *, int, enum file_change_code));
1139 static void macroexpand PROTO((HASHNODE *, FILE_BUF *));
1142 static char *macarg PROTO((struct argdata *, int));
1144 static U_CHAR *macarg1 PROTO((U_CHAR *, U_CHAR *, int *, int *, int *, int));
1146 static int discard_comments PROTO((U_CHAR *, int, int));
1148 static int change_newlines PROTO((U_CHAR *, int));
1150 char *my_strerror PROTO((int));
1151 void error PRINTF_PROTO_1((char *, ...));
1152 static void verror PROTO((char *, va_list));
1153 static void error_from_errno PROTO((char *));
1154 void warning PRINTF_PROTO_1((char *, ...));
1155 static void vwarning PROTO((char *, va_list));
1156 static void error_with_line PRINTF_PROTO_2((int, char *, ...));
1157 static void verror_with_line PROTO((int, char *, va_list));
1158 static void vwarning_with_line PROTO((int, char *, va_list));
1159 void pedwarn PRINTF_PROTO_1((char *, ...));
1160 void pedwarn_with_line PRINTF_PROTO_2((int, char *, ...));
1161 static void pedwarn_with_file_and_line PRINTF_PROTO_3((char *, int, char *, ...));
1163 static void print_containing_files PROTO((void));
1165 static int line_for_error PROTO((int));
1166 static int grow_outbuf PROTO((FILE_BUF *, int));
1168 static HASHNODE *install PROTO((U_CHAR *, int, enum node_type, char *, int));
1169 HASHNODE *lookup PROTO((U_CHAR *, int, int));
1170 static void delete_macro PROTO((HASHNODE *));
1171 static int hashf PROTO((U_CHAR *, int, int));
1173 static void dump_single_macro PROTO((HASHNODE *, FILE *));
1174 static void dump_all_macros PROTO((void));
1175 static void dump_defn_1 PROTO((U_CHAR *, int, int, FILE *));
1176 static void dump_arg_n PROTO((DEFINITION *, int, FILE *));
1178 static void initialize_char_syntax PROTO((void));
1179 static void initialize_builtins PROTO((FILE_BUF *, FILE_BUF *));
1181 static void make_definition PROTO((char *, FILE_BUF *));
1182 static void make_undef PROTO((char *, FILE_BUF *));
1184 static void make_assertion PROTO((char *, char *));
1186 static void append_include_chain PROTO((struct file_name_list *, struct file_name_list *));
1188 static void deps_output PROTO((char *, int));
1190 static void fatal PRINTF_PROTO_1((char *, ...)) __attribute__ ((noreturn));
1191 void fancy_abort PROTO((void)) __attribute__ ((noreturn));
1192 static void perror_with_name PROTO((char *));
1193 static void pfatal_with_name PROTO((char *)) __attribute__ ((noreturn));
1194 static void pipe_closed PROTO((int)) __attribute__ ((noreturn));
1196 static void memory_full PROTO((void)) __attribute__ ((noreturn));
1197 GENERIC_PTR xmalloc PROTO((size_t));
1198 static GENERIC_PTR xrealloc PROTO((GENERIC_PTR, size_t));
1199 static GENERIC_PTR xcalloc PROTO((size_t, size_t));
1200 static char *savestring PROTO((char *));
1202 static int file_size_and_mode PROTO((int, int *, long int *));
1203 static void output_dots PROTO((FILE *, int));
1205 /* Read LEN bytes at PTR from descriptor DESC, for file FILENAME,
1206 retrying if necessary. Return a negative value if an error occurs,
1207 otherwise return the actual number of bytes read,
1208 which must be LEN unless end-of-file was reached. */
1211 safe_read (desc, ptr, len)
1218 int nchars = read (desc, ptr, left);
1235 /* Write LEN bytes at PTR to descriptor DESC,
1236 retrying if necessary, and treating any real error as fatal. */
1239 safe_write (desc, ptr, len)
1245 int written = write (desc, ptr, len);
1252 pfatal_with_name (out_fname);
1270 char **pend_files = (char **) xmalloc (argc * sizeof (char *));
1271 char **pend_defs = (char **) xmalloc (argc * sizeof (char *));
1272 char **pend_undefs = (char **) xmalloc (argc * sizeof (char *));
1273 char **pend_assertions = (char **) xmalloc (argc * sizeof (char *));
1274 char **pend_includes = (char **) xmalloc (argc * sizeof (char *));
1276 /* Record the option used with each element of pend_assertions.
1277 This is preparation for supporting more than one option for making
1279 char **pend_assertion_options = (char **) xmalloc (argc * sizeof (char *));
1280 int inhibit_predefs = 0;
1281 int no_standard_includes = 0;
1282 int no_standard_cplusplus_includes = 0;
1283 int missing_newline = 0;
1285 /* Non-0 means don't output the preprocessed program. */
1286 int inhibit_output = 0;
1287 /* Non-0 means -v, so print the full set of include dirs. */
1290 /* File name which deps are being written to.
1291 This is 0 if deps are being written to stdout. */
1292 char *deps_file = 0;
1293 /* Fopen file mode to open deps_file with. */
1294 char *deps_mode = "a";
1295 /* Stream on which to print the dependency information. */
1296 FILE *deps_stream = 0;
1297 /* Target-name to write with the dependency information. */
1298 char *deps_target = 0;
1301 /* Get rid of any avoidable limit on stack size. */
1305 /* Set the stack limit huge so that alloca (particularly stringtab
1306 * in dbxread.c) does not fail. */
1307 getrlimit (RLIMIT_STACK, &rlim);
1308 rlim.rlim_cur = rlim.rlim_max;
1309 setrlimit (RLIMIT_STACK, &rlim);
1311 #endif /* RLIMIT_STACK defined */
1314 signal (SIGPIPE, pipe_closed);
1317 cp = argv[0] + strlen (argv[0]);
1318 while (cp != argv[0] && cp[-1] != '/'
1319 #ifdef DIR_SEPARATOR
1320 && cp[-1] != DIR_SEPARATOR
1328 /* Remove directories from PROGNAME. */
1332 if ((p = rindex (s, ':')) != 0) s = p + 1; /* skip device */
1333 if ((p = rindex (s, ']')) != 0) s = p + 1; /* skip directory */
1334 if ((p = rindex (s, '>')) != 0) s = p + 1; /* alternate (int'n'l) dir */
1335 s = progname = savestring (s);
1336 if ((p = rindex (s, ';')) != 0) *p = '\0'; /* strip version number */
1337 if ((p = rindex (s, '.')) != 0 /* strip type iff ".exe" */
1338 && (p[1] == 'e' || p[1] == 'E')
1339 && (p[2] == 'x' || p[2] == 'X')
1340 && (p[3] == 'e' || p[3] == 'E')
1349 /* Initialize is_idchar to allow $. */
1350 dollars_in_ident = 1;
1351 initialize_char_syntax ();
1352 dollars_in_ident = DOLLARS_IN_IDENTIFIERS > 0;
1354 no_line_directives = 0;
1356 dump_macros = dump_none;
1359 cplusplus_comments = 0;
1361 bzero ((char *) pend_files, argc * sizeof (char *));
1362 bzero ((char *) pend_defs, argc * sizeof (char *));
1363 bzero ((char *) pend_undefs, argc * sizeof (char *));
1364 bzero ((char *) pend_assertions, argc * sizeof (char *));
1365 bzero ((char *) pend_includes, argc * sizeof (char *));
1367 /* Process switches and find input file name. */
1369 for (i = 1; i < argc; i++) {
1370 if (argv[i][0] != '-') {
1371 if (out_fname != NULL)
1372 fatal ("Usage: %s [switches] input output", argv[0]);
1373 else if (in_fname != NULL)
1374 out_fname = argv[i];
1378 switch (argv[i][1]) {
1381 if (!strcmp (argv[i], "-include")) {
1383 fatal ("Filename missing after `-include' option");
1385 pend_includes[i] = argv[i+1], i++;
1387 if (!strcmp (argv[i], "-imacros")) {
1389 fatal ("Filename missing after `-imacros' option");
1391 pend_files[i] = argv[i+1], i++;
1393 if (!strcmp (argv[i], "-iprefix")) {
1395 fatal ("Filename missing after `-iprefix' option");
1397 include_prefix = argv[++i];
1399 if (!strcmp (argv[i], "-ifoutput")) {
1400 output_conditionals = 1;
1402 if (!strcmp (argv[i], "-isystem")) {
1403 struct file_name_list *dirtmp;
1406 fatal ("Filename missing after `-isystem' option");
1408 dirtmp = (struct file_name_list *)
1409 xmalloc (sizeof (struct file_name_list));
1411 dirtmp->control_macro = 0;
1412 dirtmp->c_system_include_path = 1;
1413 dirtmp->fname = xmalloc (strlen (argv[i+1]) + 1);
1414 strcpy (dirtmp->fname, argv[++i]);
1415 dirtmp->got_name_map = 0;
1417 if (before_system == 0)
1418 before_system = dirtmp;
1420 last_before_system->next = dirtmp;
1421 last_before_system = dirtmp; /* Tail follows the last one */
1423 /* Add directory to end of path for includes,
1424 with the default prefix at the front of its name. */
1425 if (!strcmp (argv[i], "-iwithprefix")) {
1426 struct file_name_list *dirtmp;
1429 if (include_prefix != 0)
1430 prefix = include_prefix;
1432 prefix = savestring (GCC_INCLUDE_DIR);
1433 /* Remove the `include' from /usr/local/lib/gcc.../include. */
1434 if (!strcmp (prefix + strlen (prefix) - 8, "/include"))
1435 prefix[strlen (prefix) - 7] = 0;
1438 dirtmp = (struct file_name_list *)
1439 xmalloc (sizeof (struct file_name_list));
1440 dirtmp->next = 0; /* New one goes on the end */
1441 dirtmp->control_macro = 0;
1442 dirtmp->c_system_include_path = 0;
1444 fatal ("Directory name missing after `-iwithprefix' option");
1446 dirtmp->fname = xmalloc (strlen (argv[i+1]) + strlen (prefix) + 1);
1447 strcpy (dirtmp->fname, prefix);
1448 strcat (dirtmp->fname, argv[++i]);
1449 dirtmp->got_name_map = 0;
1451 if (after_include == 0)
1452 after_include = dirtmp;
1454 last_after_include->next = dirtmp;
1455 last_after_include = dirtmp; /* Tail follows the last one */
1457 /* Add directory to main path for includes,
1458 with the default prefix at the front of its name. */
1459 if (!strcmp (argv[i], "-iwithprefixbefore")) {
1460 struct file_name_list *dirtmp;
1463 if (include_prefix != 0)
1464 prefix = include_prefix;
1466 prefix = savestring (GCC_INCLUDE_DIR);
1467 /* Remove the `include' from /usr/local/lib/gcc.../include. */
1468 if (!strcmp (prefix + strlen (prefix) - 8, "/include"))
1469 prefix[strlen (prefix) - 7] = 0;
1472 dirtmp = (struct file_name_list *)
1473 xmalloc (sizeof (struct file_name_list));
1474 dirtmp->next = 0; /* New one goes on the end */
1475 dirtmp->control_macro = 0;
1476 dirtmp->c_system_include_path = 0;
1478 fatal ("Directory name missing after `-iwithprefixbefore' option");
1480 dirtmp->fname = xmalloc (strlen (argv[i+1]) + strlen (prefix) + 1);
1481 strcpy (dirtmp->fname, prefix);
1482 strcat (dirtmp->fname, argv[++i]);
1483 dirtmp->got_name_map = 0;
1485 append_include_chain (dirtmp, dirtmp);
1487 /* Add directory to end of path for includes. */
1488 if (!strcmp (argv[i], "-idirafter")) {
1489 struct file_name_list *dirtmp;
1491 dirtmp = (struct file_name_list *)
1492 xmalloc (sizeof (struct file_name_list));
1493 dirtmp->next = 0; /* New one goes on the end */
1494 dirtmp->control_macro = 0;
1495 dirtmp->c_system_include_path = 0;
1497 fatal ("Directory name missing after `-idirafter' option");
1499 dirtmp->fname = argv[++i];
1500 dirtmp->got_name_map = 0;
1502 if (after_include == 0)
1503 after_include = dirtmp;
1505 last_after_include->next = dirtmp;
1506 last_after_include = dirtmp; /* Tail follows the last one */
1511 if (out_fname != NULL)
1512 fatal ("Output filename specified twice");
1514 fatal ("Filename missing after -o option");
1515 out_fname = argv[++i];
1516 if (!strcmp (out_fname, "-"))
1521 if (!strcmp (argv[i], "-pedantic"))
1523 else if (!strcmp (argv[i], "-pedantic-errors")) {
1525 pedantic_errors = 1;
1526 } else if (!strcmp (argv[i], "-pcp")) {
1529 fatal ("Filename missing after -pcp option");
1530 pcp_fname = argv[++i];
1532 ((pcp_fname[0] != '-' || pcp_fname[1] != '\0')
1533 ? fopen (pcp_fname, "w")
1535 if (pcp_outfile == 0)
1536 pfatal_with_name (pcp_fname);
1542 if (!strcmp (argv[i], "-traditional")) {
1544 if (dollars_in_ident > 0)
1545 dollars_in_ident = 1;
1546 } else if (!strcmp (argv[i], "-trigraphs")) {
1552 if (! strcmp (argv[i], "-lang-c"))
1553 cplusplus = 0, cplusplus_comments = 0, objc = 0;
1554 if (! strcmp (argv[i], "-lang-c++"))
1555 cplusplus = 1, cplusplus_comments = 1, objc = 0;
1556 if (! strcmp (argv[i], "-lang-c-c++-comments"))
1557 cplusplus = 0, cplusplus_comments = 1, objc = 0;
1558 if (! strcmp (argv[i], "-lang-objc"))
1559 objc = 1, cplusplus = 0, cplusplus_comments = 1;
1560 if (! strcmp (argv[i], "-lang-objc++"))
1561 objc = 1, cplusplus = 1, cplusplus_comments = 1;
1562 if (! strcmp (argv[i], "-lang-asm"))
1564 if (! strcmp (argv[i], "-lint"))
1569 cplusplus = 1, cplusplus_comments = 1;
1573 inhibit_warnings = 1;
1577 if (!strcmp (argv[i], "-Wtrigraphs"))
1579 else if (!strcmp (argv[i], "-Wno-trigraphs"))
1581 else if (!strcmp (argv[i], "-Wcomment"))
1583 else if (!strcmp (argv[i], "-Wno-comment"))
1585 else if (!strcmp (argv[i], "-Wcomments"))
1587 else if (!strcmp (argv[i], "-Wno-comments"))
1589 else if (!strcmp (argv[i], "-Wtraditional"))
1591 else if (!strcmp (argv[i], "-Wno-traditional"))
1593 else if (!strcmp (argv[i], "-Wimport"))
1595 else if (!strcmp (argv[i], "-Wno-import"))
1597 else if (!strcmp (argv[i], "-Werror"))
1598 warnings_are_errors = 1;
1599 else if (!strcmp (argv[i], "-Wno-error"))
1600 warnings_are_errors = 0;
1601 else if (!strcmp (argv[i], "-Wall"))
1609 /* The style of the choices here is a bit mixed.
1610 The chosen scheme is a hybrid of keeping all options in one string
1611 and specifying each option in a separate argument:
1612 -M|-MM|-MD file|-MMD file [-MG]. An alternative is:
1613 -M|-MM|-MD file|-MMD file|-MG|-MMG; or more concisely:
1614 -M[M][G][D file]. This is awkward to handle in specs, and is not
1616 /* ??? -MG must be specified in addition to one of -M or -MM.
1617 This can be relaxed in the future without breaking anything.
1618 The converse isn't true. */
1620 /* -MG isn't valid with -MD or -MMD. This is checked for later. */
1621 if (!strcmp (argv[i], "-MG"))
1623 print_deps_missing_files = 1;
1626 if (!strcmp (argv[i], "-M"))
1628 else if (!strcmp (argv[i], "-MM"))
1630 else if (!strcmp (argv[i], "-MD"))
1632 else if (!strcmp (argv[i], "-MMD"))
1634 /* For -MD and -MMD options, write deps on file named by next arg. */
1635 if (!strcmp (argv[i], "-MD")
1636 || !strcmp (argv[i], "-MMD")) {
1638 fatal ("Filename missing after %s option", argv[i]);
1640 deps_file = argv[i];
1643 /* For -M and -MM, write deps on standard output
1644 and suppress the usual output. */
1645 deps_stream = stdout;
1652 char *p = argv[i] + 2;
1654 while ((c = *p++)) {
1655 /* Arg to -d specifies what parts of macros to dump */
1658 dump_macros = dump_only;
1662 dump_macros = dump_names;
1665 dump_macros = dump_definitions;
1673 if (argv[i][2] == '3')
1678 fprintf (stderr, "GNU CPP version %s", version_string);
1679 #ifdef TARGET_VERSION
1682 fprintf (stderr, "\n");
1687 print_include_names = 1;
1691 if (argv[i][2] != 0)
1692 pend_defs[i] = argv[i] + 2;
1693 else if (i + 1 == argc)
1694 fatal ("Macro name missing after -D option");
1696 i++, pend_defs[i] = argv[i];
1703 if (argv[i][2] != 0)
1705 else if (i + 1 == argc)
1706 fatal ("Assertion missing after -A option");
1710 if (!strcmp (p, "-")) {
1711 /* -A- eliminates all predefined macros and assertions.
1712 Let's include also any that were specified earlier
1713 on the command line. That way we can get rid of any
1714 that were passed automatically in from GCC. */
1716 inhibit_predefs = 1;
1717 for (j = 0; j < i; j++)
1718 pend_defs[j] = pend_assertions[j] = 0;
1720 pend_assertions[i] = p;
1721 pend_assertion_options[i] = "-A";
1726 case 'U': /* JF #undef something */
1727 if (argv[i][2] != 0)
1728 pend_undefs[i] = argv[i] + 2;
1729 else if (i + 1 == argc)
1730 fatal ("Macro name missing after -U option");
1732 pend_undefs[i] = argv[i+1], i++;
1736 put_out_comments = 1;
1739 case 'E': /* -E comes from cc -E; ignore it. */
1743 no_line_directives = 1;
1746 case '$': /* Don't include $ in identifiers. */
1747 dollars_in_ident = 0;
1750 case 'I': /* Add directory to path for includes. */
1752 struct file_name_list *dirtmp;
1754 if (! ignore_srcdir && !strcmp (argv[i] + 2, "-")) {
1756 /* Don't use any preceding -I directories for #include <...>. */
1757 first_bracket_include = 0;
1760 dirtmp = (struct file_name_list *)
1761 xmalloc (sizeof (struct file_name_list));
1762 dirtmp->next = 0; /* New one goes on the end */
1763 dirtmp->control_macro = 0;
1764 dirtmp->c_system_include_path = 0;
1765 if (argv[i][2] != 0)
1766 dirtmp->fname = argv[i] + 2;
1767 else if (i + 1 == argc)
1768 fatal ("Directory name missing after -I option");
1770 dirtmp->fname = argv[++i];
1771 dirtmp->got_name_map = 0;
1772 append_include_chain (dirtmp, dirtmp);
1778 if (!strcmp (argv[i], "-nostdinc"))
1779 /* -nostdinc causes no default include directories.
1780 You must specify all include-file directories with -I. */
1781 no_standard_includes = 1;
1782 else if (!strcmp (argv[i], "-nostdinc++"))
1783 /* -nostdinc++ causes no default C++-specific include directories. */
1784 no_standard_cplusplus_includes = 1;
1785 else if (!strcmp (argv[i], "-noprecomp"))
1790 /* Sun compiler passes undocumented switch "-undef".
1791 Let's assume it means to inhibit the predefined symbols. */
1792 inhibit_predefs = 1;
1795 case '\0': /* JF handle '-' as file name meaning stdin or stdout */
1796 if (in_fname == NULL) {
1799 } else if (out_fname == NULL) {
1802 } /* else fall through into error */
1805 fatal ("Invalid option `%s'", argv[i]);
1810 /* Add dirs from CPATH after dirs from -I. */
1811 /* There seems to be confusion about what CPATH should do,
1812 so for the moment it is not documented. */
1813 /* Some people say that CPATH should replace the standard include dirs,
1814 but that seems pointless: it comes before them, so it overrides them
1816 cp = getenv ("CPATH");
1817 if (cp && ! no_standard_includes)
1820 /* Now that dollars_in_ident is known, initialize is_idchar. */
1821 initialize_char_syntax ();
1823 /* Initialize output buffer */
1825 outbuf.buf = (U_CHAR *) xmalloc (OUTBUF_SIZE);
1826 outbuf.bufp = outbuf.buf;
1827 outbuf.length = OUTBUF_SIZE;
1829 /* Do partial setup of input buffer for the sake of generating
1830 early #line directives (when -g is in effect). */
1832 fp = &instack[++indepth];
1833 if (in_fname == NULL)
1835 fp->nominal_fname = fp->fname = in_fname;
1838 /* In C++, wchar_t is a distinct basic type, and we can expect
1839 __wchar_t to be defined by cc1plus. */
1841 wchar_type = "__wchar_t";
1843 /* Install __LINE__, etc. Must follow initialize_char_syntax
1844 and option processing. */
1845 initialize_builtins (fp, &outbuf);
1847 /* Do standard #defines and assertions
1848 that identify system and machine type. */
1850 if (!inhibit_predefs) {
1851 char *p = (char *) alloca (strlen (predefs) + 1);
1852 strcpy (p, predefs);
1855 while (*p == ' ' || *p == '\t')
1857 /* Handle -D options. */
1858 if (p[0] == '-' && p[1] == 'D') {
1860 while (*p && *p != ' ' && *p != '\t')
1865 output_line_directive (fp, &outbuf, 0, same_file);
1866 make_definition (q, &outbuf);
1867 while (*p == ' ' || *p == '\t')
1869 } else if (p[0] == '-' && p[1] == 'A') {
1870 /* Handle -A options (assertions). */
1879 past_name = assertion;
1880 /* Locate end of name. */
1881 while (*past_name && *past_name != ' '
1882 && *past_name != '\t' && *past_name != '(')
1884 /* Locate `(' at start of value. */
1886 while (*value && (*value == ' ' || *value == '\t'))
1888 if (*value++ != '(')
1890 while (*value && (*value == ' ' || *value == '\t'))
1893 /* Locate end of value. */
1894 while (*past_value && *past_value != ' '
1895 && *past_value != '\t' && *past_value != ')')
1897 termination = past_value;
1898 while (*termination && (*termination == ' ' || *termination == '\t'))
1900 if (*termination++ != ')')
1902 if (*termination && *termination != ' ' && *termination != '\t')
1904 /* Temporarily null-terminate the value. */
1905 save_char = *termination;
1906 *termination = '\0';
1907 /* Install the assertion. */
1908 make_assertion ("-A", assertion);
1909 *termination = (char) save_char;
1911 while (*p == ' ' || *p == '\t')
1919 /* Now handle the command line options. */
1921 /* Do -U's, -D's and -A's in the order they were seen. */
1922 for (i = 1; i < argc; i++) {
1923 if (pend_undefs[i]) {
1925 output_line_directive (fp, &outbuf, 0, same_file);
1926 make_undef (pend_undefs[i], &outbuf);
1930 output_line_directive (fp, &outbuf, 0, same_file);
1931 make_definition (pend_defs[i], &outbuf);
1933 if (pend_assertions[i])
1934 make_assertion (pend_assertion_options[i], pend_assertions[i]);
1937 done_initializing = 1;
1939 { /* read the appropriate environment variable and if it exists
1940 replace include_defaults with the listed path. */
1942 switch ((objc << 1) + cplusplus)
1945 epath = getenv ("C_INCLUDE_PATH");
1948 epath = getenv ("CPLUS_INCLUDE_PATH");
1951 epath = getenv ("OBJC_INCLUDE_PATH");
1954 epath = getenv ("OBJCPLUS_INCLUDE_PATH");
1957 /* If the environment var for this language is set,
1958 add to the default list of include directories. */
1960 char *nstore = (char *) alloca (strlen (epath) + 2);
1962 char *startp, *endp;
1964 for (num_dirs = 1, startp = epath; *startp; startp++)
1965 if (*startp == PATH_SEPARATOR)
1968 = (struct default_include *) xmalloc ((num_dirs
1969 * sizeof (struct default_include))
1970 + sizeof (include_defaults_array));
1971 startp = endp = epath;
1974 /* Handle cases like c:/usr/lib:d:/gcc/lib */
1975 if ((*endp == PATH_SEPARATOR
1976 #if 0 /* Obsolete, now that we use semicolons as the path separator. */
1978 && (endp-startp != 1 || !isalpha (*startp))
1983 strncpy (nstore, startp, endp-startp);
1985 strcpy (nstore, ".");
1987 nstore[endp-startp] = '\0';
1989 include_defaults[num_dirs].fname = savestring (nstore);
1990 include_defaults[num_dirs].cplusplus = cplusplus;
1991 include_defaults[num_dirs].cxx_aware = 1;
1995 endp = startp = endp + 1;
1999 /* Put the usual defaults back in at the end. */
2000 bcopy ((char *) include_defaults_array,
2001 (char *) &include_defaults[num_dirs],
2002 sizeof (include_defaults_array));
2006 append_include_chain (before_system, last_before_system);
2007 first_system_include = before_system;
2009 /* Unless -fnostdinc,
2010 tack on the standard include file dirs to the specified list */
2011 if (!no_standard_includes) {
2012 struct default_include *p = include_defaults;
2013 char *specd_prefix = include_prefix;
2014 char *default_prefix = savestring (GCC_INCLUDE_DIR);
2015 int default_len = 0;
2016 /* Remove the `include' from /usr/local/lib/gcc.../include. */
2017 if (!strcmp (default_prefix + strlen (default_prefix) - 8, "/include")) {
2018 default_len = strlen (default_prefix) - 7;
2019 default_prefix[default_len] = 0;
2021 /* Search "translated" versions of GNU directories.
2022 These have /usr/local/lib/gcc... replaced by specd_prefix. */
2023 if (specd_prefix != 0 && default_len != 0)
2024 for (p = include_defaults; p->fname; p++) {
2025 /* Some standard dirs are only for C++. */
2026 if (!p->cplusplus || (cplusplus && !no_standard_cplusplus_includes)) {
2027 /* Does this dir start with the prefix? */
2028 if (!strncmp (p->fname, default_prefix, default_len)) {
2029 /* Yes; change prefix and add to search list. */
2030 struct file_name_list *new
2031 = (struct file_name_list *) xmalloc (sizeof (struct file_name_list));
2032 int this_len = strlen (specd_prefix) + strlen (p->fname) - default_len;
2033 char *str = xmalloc (this_len + 1);
2034 strcpy (str, specd_prefix);
2035 strcat (str, p->fname + default_len);
2037 new->control_macro = 0;
2038 new->c_system_include_path = !p->cxx_aware;
2039 new->got_name_map = 0;
2040 append_include_chain (new, new);
2041 if (first_system_include == 0)
2042 first_system_include = new;
2046 /* Search ordinary names for GNU include directories. */
2047 for (p = include_defaults; p->fname; p++) {
2048 /* Some standard dirs are only for C++. */
2049 if (!p->cplusplus || (cplusplus && !no_standard_cplusplus_includes)) {
2050 struct file_name_list *new
2051 = (struct file_name_list *) xmalloc (sizeof (struct file_name_list));
2052 new->control_macro = 0;
2053 new->c_system_include_path = !p->cxx_aware;
2054 new->fname = p->fname;
2055 new->got_name_map = 0;
2056 append_include_chain (new, new);
2057 if (first_system_include == 0)
2058 first_system_include = new;
2063 /* Tack the after_include chain at the end of the include chain. */
2064 append_include_chain (after_include, last_after_include);
2065 if (first_system_include == 0)
2066 first_system_include = after_include;
2068 /* With -v, print the list of dirs to search. */
2070 struct file_name_list *p;
2071 fprintf (stderr, "#include \"...\" search starts here:\n");
2072 for (p = include; p; p = p->next) {
2073 if (p == first_bracket_include)
2074 fprintf (stderr, "#include <...> search starts here:\n");
2075 fprintf (stderr, " %s\n", p->fname);
2077 fprintf (stderr, "End of search list.\n");
2080 /* Scan the -imacros files before the main input.
2081 Much like #including them, but with no_output set
2082 so that only their macro definitions matter. */
2084 no_output++; no_record_file++;
2085 for (i = 1; i < argc; i++)
2086 if (pend_files[i]) {
2087 int fd = open (pend_files[i], O_RDONLY, 0666);
2089 perror_with_name (pend_files[i]);
2090 return FATAL_EXIT_CODE;
2092 finclude (fd, pend_files[i], &outbuf, 0, NULL_PTR);
2094 no_output--; no_record_file--;
2096 /* Copy the entire contents of the main input file into
2097 the stacked input buffer previously allocated for it. */
2099 /* JF check for stdin */
2100 if (in_fname == NULL || *in_fname == 0) {
2103 } else if ((f = open (in_fname, O_RDONLY, 0666)) < 0)
2106 /* -MG doesn't select the form of output and must be specified with one of
2107 -M or -MM. -MG doesn't make sense with -MD or -MMD since they don't
2108 inhibit compilation. */
2109 if (print_deps_missing_files && (print_deps == 0 || !inhibit_output))
2110 fatal ("-MG must be specified with one of -M or -MM");
2112 /* Either of two environment variables can specify output of deps.
2113 Its value is either "OUTPUT_FILE" or "OUTPUT_FILE DEPS_TARGET",
2114 where OUTPUT_FILE is the file to write deps info to
2115 and DEPS_TARGET is the target to mention in the deps. */
2118 && (getenv ("SUNPRO_DEPENDENCIES") != 0
2119 || getenv ("DEPENDENCIES_OUTPUT") != 0)) {
2120 char *spec = getenv ("DEPENDENCIES_OUTPUT");
2125 spec = getenv ("SUNPRO_DEPENDENCIES");
2132 /* Find the space before the DEPS_TARGET, if there is one. */
2133 /* This should use index. (mrs) */
2134 while (*s != 0 && *s != ' ') s++;
2136 deps_target = s + 1;
2137 output_file = xmalloc (s - spec + 1);
2138 bcopy (spec, output_file, s - spec);
2139 output_file[s - spec] = 0;
2146 deps_file = output_file;
2150 /* For -M, print the expected object file name
2151 as the target of this Make-rule. */
2153 deps_allocated_size = 200;
2154 deps_buffer = xmalloc (deps_allocated_size);
2160 deps_output (deps_target, ':');
2161 } else if (*in_fname == 0) {
2162 deps_output ("-", ':');
2167 /* Discard all directory prefixes from filename. */
2168 if ((q = rindex (in_fname, '/')) != NULL
2169 #ifdef DIR_SEPARATOR
2170 && (q = rindex (in_fname, DIR_SEPARATOR)) != NULL
2177 /* Copy remainder to mungable area. */
2178 p = (char *) alloca (strlen(q) + 8);
2181 /* Output P, but remove known suffixes. */
2185 && p[len - 2] == '.'
2186 && index("cCsSm", p[len - 1]))
2189 && p[len - 3] == '.'
2190 && p[len - 2] == 'c'
2191 && p[len - 1] == 'c')
2194 && p[len - 4] == '.'
2195 && p[len - 3] == 'c'
2196 && p[len - 2] == 'x'
2197 && p[len - 1] == 'x')
2200 && p[len - 4] == '.'
2201 && p[len - 3] == 'c'
2202 && p[len - 2] == 'p'
2203 && p[len - 1] == 'p')
2206 /* Supply our own suffix. */
2213 deps_output (p, ':');
2214 deps_output (in_fname, ' ');
2218 file_size_and_mode (f, &st_mode, &st_size);
2219 fp->nominal_fname = fp->fname = in_fname;
2221 fp->system_header_p = 0;
2222 /* JF all this is mine about reading pipes and ttys */
2223 if (! S_ISREG (st_mode)) {
2224 /* Read input from a file that is not a normal disk file.
2225 We cannot preallocate a buffer with the correct size,
2226 so we must read in the file a piece at the time and make it bigger. */
2233 fp->buf = (U_CHAR *) xmalloc (bsize + 2);
2235 cnt = safe_read (f, (char *) fp->buf + size, bsize - size);
2236 if (cnt < 0) goto perror; /* error! */
2238 if (size != bsize) break; /* End of file */
2240 fp->buf = (U_CHAR *) xrealloc (fp->buf, bsize + 2);
2244 /* Read a file whose size we can determine in advance.
2245 For the sake of VMS, st_size is just an upper bound. */
2246 fp->buf = (U_CHAR *) xmalloc (st_size + 2);
2247 fp->length = safe_read (f, (char *) fp->buf, st_size);
2248 if (fp->length < 0) goto perror;
2251 fp->if_stack = if_stack;
2253 /* Make sure data ends with a newline. And put a null after it. */
2255 if ((fp->length > 0 && fp->buf[fp->length - 1] != '\n')
2256 /* Backslash-newline at end is not good enough. */
2257 || (fp->length > 1 && fp->buf[fp->length - 2] == '\\')) {
2258 fp->buf[fp->length++] = '\n';
2259 missing_newline = 1;
2261 fp->buf[fp->length] = '\0';
2263 /* Unless inhibited, convert trigraphs in the input. */
2268 /* Now that we know the input file is valid, open the output. */
2270 if (!out_fname || !strcmp (out_fname, ""))
2271 out_fname = "stdout";
2272 else if (! freopen (out_fname, "w", stdout))
2273 pfatal_with_name (out_fname);
2275 output_line_directive (fp, &outbuf, 0, same_file);
2277 /* Scan the -include files before the main input. */
2280 for (i = 1; i < argc; i++)
2281 if (pend_includes[i]) {
2282 int fd = open (pend_includes[i], O_RDONLY, 0666);
2284 perror_with_name (pend_includes[i]);
2285 return FATAL_EXIT_CODE;
2287 finclude (fd, pend_includes[i], &outbuf, 0, NULL_PTR);
2291 /* Scan the input, processing macros and directives. */
2293 rescan (&outbuf, 0);
2295 if (missing_newline)
2298 if (pedantic && missing_newline)
2299 pedwarn ("file does not end in newline");
2301 /* Now we have processed the entire input
2302 Write whichever kind of output has been requested. */
2304 if (dump_macros == dump_only)
2306 else if (! inhibit_output) {
2311 /* Don't actually write the deps file if compilation has failed. */
2313 if (deps_file && ! (deps_stream = fopen (deps_file, deps_mode)))
2314 pfatal_with_name (deps_file);
2315 fputs (deps_buffer, deps_stream);
2316 putc ('\n', deps_stream);
2318 if (ferror (deps_stream) || fclose (deps_stream) != 0)
2319 fatal ("I/O error on output");
2324 if (pcp_outfile && pcp_outfile != stdout
2325 && (ferror (pcp_outfile) || fclose (pcp_outfile) != 0))
2326 fatal ("I/O error on `-pcp' output");
2328 if (ferror (stdout) || fclose (stdout) != 0)
2329 fatal ("I/O error on output");
2332 exit (FATAL_EXIT_CODE);
2333 exit (SUCCESS_EXIT_CODE);
2336 pfatal_with_name (in_fname);
2340 /* Given a colon-separated list of file names PATH,
2341 add all the names to the search path for include files. */
2355 struct file_name_list *dirtmp;
2357 /* Find the end of this name. */
2358 while (*q != 0 && *q != PATH_SEPARATOR) q++;
2360 /* An empty name in the path stands for the current directory. */
2365 /* Otherwise use the directory that is named. */
2366 name = xmalloc (q - p + 1);
2367 bcopy (p, name, q - p);
2371 dirtmp = (struct file_name_list *)
2372 xmalloc (sizeof (struct file_name_list));
2373 dirtmp->next = 0; /* New one goes on the end */
2374 dirtmp->control_macro = 0;
2375 dirtmp->c_system_include_path = 0;
2376 dirtmp->fname = name;
2377 dirtmp->got_name_map = 0;
2378 append_include_chain (dirtmp, dirtmp);
2380 /* Advance past this name. */
2384 /* Skip the colon. */
2389 /* Return the address of the first character in S that equals C.
2390 S is an array of length N, possibly containing '\0's, and followed by '\0'.
2391 Return 0 if there is no such character. Assume that C itself is not '\0'.
2392 If we knew we could use memchr, we could just invoke memchr (S, C, N),
2393 but unfortunately memchr isn't autoconfigured yet. */
2401 char *p = (char *) s;
2403 char *q = index (p, c);
2405 return (U_CHAR *) q;
2407 size_t l = strlen (p);
2417 /* Pre-C-Preprocessor to translate ANSI trigraph idiocy in BUF
2418 before main CCCP processing. Name `pcp' is also in honor of the
2419 drugs the trigraph designers must have been on.
2421 Using an extra pass through the buffer takes a little extra time,
2422 but is infinitely less hairy than trying to handle trigraphs inside
2423 strings, etc. everywhere, and also makes sure that trigraphs are
2424 only translated in the top level of processing. */
2430 register U_CHAR c, *fptr, *bptr, *sptr, *lptr;
2433 fptr = bptr = sptr = buf->buf;
2434 lptr = fptr + buf->length;
2435 while ((sptr = index0 (sptr, '?', (size_t) (lptr - sptr))) != NULL) {
2472 len = sptr - fptr - 2;
2474 /* BSD doc says bcopy () works right for overlapping strings. In ANSI
2475 C, this will be memmove (). */
2476 if (bptr != fptr && len > 0)
2477 bcopy ((char *) fptr, (char *) bptr, len);
2483 len = buf->length - (fptr - buf->buf);
2484 if (bptr != fptr && len > 0)
2485 bcopy ((char *) fptr, (char *) bptr, len);
2486 buf->length -= fptr - bptr;
2487 buf->buf[buf->length] = '\0';
2488 if (warn_trigraphs && fptr != bptr)
2489 warning ("%d trigraph(s) encountered", (fptr - bptr) / 2);
2492 /* Move all backslash-newline pairs out of embarrassing places.
2493 Exchange all such pairs following BP
2494 with any potentially-embarrassing characters that follow them.
2495 Potentially-embarrassing characters are / and *
2496 (because a backslash-newline inside a comment delimiter
2497 would cause it not to be recognized). */
2503 register U_CHAR *p = bp;
2505 /* First count the backslash-newline pairs here. */
2507 while (p[0] == '\\' && p[1] == '\n')
2510 /* What follows the backslash-newlines is not embarrassing. */
2512 if (*p != '/' && *p != '*')
2515 /* Copy all potentially embarrassing characters
2516 that follow the backslash-newline pairs
2517 down to where the pairs originally started. */
2519 while (*p == '*' || *p == '/')
2522 /* Now write the same number of pairs after the embarrassing chars. */
2529 /* Like newline_fix but for use within a directive-name.
2530 Move any backslash-newlines up past any following symbol constituents. */
2533 name_newline_fix (bp)
2536 register U_CHAR *p = bp;
2538 /* First count the backslash-newline pairs here. */
2539 while (p[0] == '\\' && p[1] == '\n')
2542 /* What follows the backslash-newlines is not embarrassing. */
2547 /* Copy all potentially embarrassing characters
2548 that follow the backslash-newline pairs
2549 down to where the pairs originally started. */
2551 while (is_idchar[*p])
2554 /* Now write the same number of pairs after the embarrassing chars. */
2561 /* Look for lint commands in comments.
2563 When we come in here, ibp points into a comment. Limit is as one expects.
2564 scan within the comment -- it should start, after lwsp, with a lint command.
2565 If so that command is returned as a (constant) string.
2567 Upon return, any arg will be pointed to with argstart and will be
2568 arglen long. Note that we don't parse that arg since it will just
2569 be printed out again.
2573 get_lintcmd (ibp, limit, argstart, arglen, cmdlen)
2574 register U_CHAR *ibp;
2575 register U_CHAR *limit;
2576 U_CHAR **argstart; /* point to command arg */
2577 int *arglen, *cmdlen; /* how long they are */
2580 register U_CHAR *numptr; /* temp for arg parsing */
2584 SKIP_WHITE_SPACE (ibp);
2586 if (ibp >= limit) return NULL;
2588 linsize = limit - ibp;
2590 /* Oh, I wish C had lexical functions... hell, I'll just open-code the set */
2591 if ((linsize >= 10) && !bcmp (ibp, "NOTREACHED", 10)) {
2593 return "NOTREACHED";
2595 if ((linsize >= 8) && !bcmp (ibp, "ARGSUSED", 8)) {
2599 if ((linsize >= 11) && !bcmp (ibp, "LINTLIBRARY", 11)) {
2601 return "LINTLIBRARY";
2603 if ((linsize >= 7) && !bcmp (ibp, "VARARGS", 7)) {
2605 ibp += 7; linsize -= 7;
2606 if ((linsize == 0) || ! isdigit (*ibp)) return "VARARGS";
2608 /* OK, read a number */
2609 for (numptr = *argstart = ibp; (numptr < limit) && isdigit (*numptr);
2611 *arglen = numptr - *argstart;
2618 * The main loop of the program.
2620 * Read characters from the input stack, transferring them to the
2623 * Macros are expanded and push levels on the input stack.
2624 * At the end of such a level it is popped off and we keep reading.
2625 * At the end of any other kind of level, we return.
2626 * #-directives are handled, except within macros.
2628 * If OUTPUT_MARKS is nonzero, keep Newline markers found in the input
2629 * and insert them when appropriate. This is set while scanning macro
2630 * arguments before substitution. It is zero when scanning for final output.
2631 * There are three types of Newline markers:
2632 * * Newline - follows a macro name that was not expanded
2633 * because it appeared inside an expansion of the same macro.
2634 * This marker prevents future expansion of that identifier.
2635 * When the input is rescanned into the final output, these are deleted.
2636 * These are also deleted by ## concatenation.
2637 * * Newline Space (or Newline and any other whitespace character)
2638 * stands for a place that tokens must be separated or whitespace
2639 * is otherwise desirable, but where the ANSI standard specifies there
2640 * is no whitespace. This marker turns into a Space (or whichever other
2641 * whitespace char appears in the marker) in the final output,
2642 * but it turns into nothing in an argument that is stringified with #.
2643 * Such stringified arguments are the only place where the ANSI standard
2644 * specifies with precision that whitespace may not appear.
2646 * During this function, IP->bufp is kept cached in IBP for speed of access.
2647 * Likewise, OP->bufp is kept in OBP. Before calling a subroutine
2648 * IBP, IP and OBP must be copied back to memory. IP and IBP are
2649 * copied back with the RECACHE macro. OBP must be copied back from OP->bufp
2650 * explicitly, and before RECACHE, since RECACHE uses OBP.
2654 rescan (op, output_marks)
2658 /* Character being scanned in main loop. */
2661 /* Length of pending accumulated identifier. */
2662 register int ident_length = 0;
2664 /* Hash code of pending accumulated identifier. */
2665 register int hash = 0;
2667 /* Current input level (&instack[indepth]). */
2670 /* Pointer for scanning input. */
2671 register U_CHAR *ibp;
2673 /* Pointer to end of input. End of scan is controlled by LIMIT. */
2674 register U_CHAR *limit;
2676 /* Pointer for storing output. */
2677 register U_CHAR *obp;
2679 /* REDO_CHAR is nonzero if we are processing an identifier
2680 after backing up over the terminating character.
2681 Sometimes we process an identifier without backing up over
2682 the terminating character, if the terminating character
2683 is not special. Backing up is done so that the terminating character
2684 will be dispatched on again once the identifier is dealt with. */
2687 /* 1 if within an identifier inside of which a concatenation
2688 marker (Newline -) has been seen. */
2689 int concatenated = 0;
2691 /* While scanning a comment or a string constant,
2692 this records the line it started on, for error messages. */
2695 /* Record position of last `real' newline. */
2696 U_CHAR *beg_of_line;
2698 /* Pop the innermost input stack level, assuming it is a macro expansion. */
2701 do { ip->macro->type = T_MACRO; \
2702 if (ip->free_ptr) free (ip->free_ptr); \
2703 --indepth; } while (0)
2705 /* Reload `rescan's local variables that describe the current
2706 level of the input stack. */
2709 do { ip = &instack[indepth]; \
2711 limit = ip->buf + ip->length; \
2713 check_expand (op, limit - ibp); \
2715 obp = op->bufp; } while (0)
2717 if (no_output && instack[indepth].fname != 0)
2718 skip_if_group (&instack[indepth], 1, NULL);
2725 /* Our caller must always put a null after the end of
2726 the input at each input stack level. */
2736 if (*ibp == '\n' && !ip->macro) {
2737 /* At the top level, always merge lines ending with backslash-newline,
2738 even in middle of identifier. But do not merge lines in a macro,
2739 since backslash might be followed by a newline-space marker. */
2742 --obp; /* remove backslash from obuf */
2745 /* If ANSI, backslash is just another character outside a string. */
2748 /* Otherwise, backslash suppresses specialness of following char,
2749 so copy it here to prevent the switch from seeing it.
2750 But first get any pending identifier processed. */
2751 if (ident_length > 0)
2758 if (ident_length || ip->macro || traditional)
2760 while (*ibp == '\\' && ibp[1] == '\n') {
2766 /* Treat this %: digraph as if it were #. */
2770 if (assertions_flag) {
2771 /* Copy #foo (bar lose) without macro expansion. */
2772 obp[-1] = '#'; /* In case it was '%'. */
2773 SKIP_WHITE_SPACE (ibp);
2774 while (is_idchar[*ibp])
2776 SKIP_WHITE_SPACE (ibp);
2779 skip_paren_group (ip);
2780 bcopy ((char *) ibp, (char *) obp, ip->bufp - ibp);
2781 obp += ip->bufp - ibp;
2786 /* If this is expanding a macro definition, don't recognize
2787 preprocessing directives. */
2790 /* If this is expand_into_temp_buffer,
2791 don't recognize them either. Warn about them
2792 only after an actual newline at this level,
2793 not at the beginning of the input level. */
2795 if (ip->buf != beg_of_line)
2796 warning ("preprocessing directive not recognized within macro arg");
2803 /* # keyword: a # must be first nonblank char on the line */
2804 if (beg_of_line == 0)
2809 /* Scan from start of line, skipping whitespace, comments
2810 and backslash-newlines, and see if we reach this #.
2811 If not, this # is not special. */
2813 /* If -traditional, require # to be at beginning of line. */
2816 if (is_hor_space[*bp])
2818 else if (*bp == '\\' && bp[1] == '\n')
2820 else if (*bp == '/' && bp[1] == '*') {
2822 while (!(*bp == '*' && bp[1] == '/'))
2826 /* There is no point in trying to deal with C++ // comments here,
2827 because if there is one, then this # must be part of the
2828 comment and we would never reach here. */
2834 while (bp[1] == '\\' && bp[2] == '\n')
2838 /* %: appears at start of line; skip past the ':' too. */
2847 /* This # can start a directive. */
2849 --obp; /* Don't copy the '#' */
2853 if (! handle_directive (ip, op)) {
2857 /* Not a known directive: treat it as ordinary text.
2858 IP, OP, IBP, etc. have not been changed. */
2859 if (no_output && instack[indepth].fname) {
2860 /* If not generating expanded output,
2861 what we do with ordinary text is skip it.
2862 Discard everything until next # directive. */
2863 skip_if_group (&instack[indepth], 1, 0);
2868 *obp++ = '#'; /* Copy # (even if it was originally %:). */
2869 /* Don't expand an identifier that could be a macro directive.
2870 (Section 3.8.3 of the ANSI C standard) */
2871 SKIP_WHITE_SPACE (ibp);
2872 if (is_idstart[*ibp])
2875 while (is_idchar[*ibp])
2883 /* A # directive has been successfully processed. */
2884 /* If not generating expanded output, ignore everything until
2885 next # directive. */
2886 if (no_output && instack[indepth].fname)
2887 skip_if_group (&instack[indepth], 1, 0);
2893 case '\"': /* skip quoted string */
2895 /* A single quoted string is treated like a double -- some
2896 programs (e.g., troff) are perverse this way */
2901 start_line = ip->lineno;
2903 /* Skip ahead to a matching quote. */
2907 if (ip->macro != 0) {
2908 /* try harder: this string crosses a macro expansion boundary.
2909 This can happen naturally if -traditional.
2910 Otherwise, only -D can make a macro with an unmatched quote. */
2916 error_with_line (line_for_error (start_line),
2917 "unterminated string or character constant");
2918 error_with_line (multiline_string_line,
2919 "possible real start of unterminated constant");
2920 multiline_string_line = 0;
2929 /* Traditionally, end of line ends a string constant with no error.
2930 So exit the loop and record the new line. */
2936 error_with_line (line_for_error (start_line),
2937 "unterminated character constant");
2940 if (pedantic && multiline_string_line == 0) {
2941 pedwarn_with_line (line_for_error (start_line),
2942 "string constant runs past end of line");
2944 if (multiline_string_line == 0)
2945 multiline_string_line = ip->lineno - 1;
2952 /* Backslash newline is replaced by nothing at all,
2953 but keep the line counts correct. */
2958 /* ANSI stupidly requires that in \\ the second \
2959 is *not* prevented from combining with a newline. */
2960 while (*ibp == '\\' && ibp[1] == '\n') {
2979 if (*ibp == '\\' && ibp[1] == '\n')
2983 && !(cplusplus_comments && *ibp == '/'))
2991 /* C++ style comment... */
2992 start_line = ip->lineno;
2994 --ibp; /* Back over the slash */
2997 /* Comments are equivalent to spaces. */
2998 if (! put_out_comments)
3001 /* must fake up a comment here */
3006 U_CHAR *before_bp = ibp+2;
3008 while (ibp < limit) {
3009 if (ibp[-1] != '\\' && *ibp == '\n') {
3010 if (put_out_comments) {
3011 bcopy ((char *) before_bp, (char *) obp, ibp - before_bp);
3012 obp += ibp - before_bp;
3018 /* Copy the newline into the output buffer, in order to
3019 avoid the pain of a #line every time a multiline comment
3021 if (!put_out_comments)
3032 /* Ordinary C comment. Skip it, optionally copying it to output. */
3034 start_line = ip->lineno;
3036 ++ibp; /* Skip the star. */
3038 /* If this cpp is for lint, we peek inside the comments: */
3042 char *lintcmd = get_lintcmd (ibp, limit, &argbp, &arglen, &cmdlen);
3044 if (lintcmd != NULL) {
3046 check_expand (op, cmdlen + arglen + 14);
3048 /* I believe it is always safe to emit this newline: */
3050 bcopy ("#pragma lint ", (char *) obp, 13);
3052 bcopy (lintcmd, (char *) obp, cmdlen);
3057 bcopy (argbp, (char *) obp, arglen);
3061 /* OK, now bring us back to the state we were in before we entered
3062 this branch. We need #line because the #pragma's newline always
3063 messes up the line count. */
3065 output_line_directive (ip, op, 0, same_file);
3066 check_expand (op, limit - ibp + 2);
3072 /* Comments are equivalent to spaces.
3073 Note that we already output the slash; we might not want it.
3074 For -traditional, a comment is equivalent to nothing. */
3075 if (! put_out_comments) {
3085 U_CHAR *before_bp = ibp;
3087 while (ibp < limit) {
3090 if (warn_comments && *ibp == '*')
3091 warning ("`/*' within comment");
3094 if (*ibp == '\\' && ibp[1] == '\n')
3096 if (ibp >= limit || *ibp == '/')
3101 /* Copy the newline into the output buffer, in order to
3102 avoid the pain of a #line every time a multiline comment
3104 if (!put_out_comments)
3112 error_with_line (line_for_error (start_line),
3113 "unterminated comment");
3116 if (put_out_comments) {
3117 bcopy ((char *) before_bp, (char *) obp, ibp - before_bp);
3118 obp += ibp - before_bp;
3125 if (!dollars_in_ident)
3129 case '0': case '1': case '2': case '3': case '4':
3130 case '5': case '6': case '7': case '8': case '9':
3131 /* If digit is not part of identifier, it starts a number,
3132 which means that following letters are not an identifier.
3133 "0x5" does not refer to an identifier "x5".
3134 So copy all alphanumerics that follow without accumulating
3135 as an identifier. Periods also, for sake of "3.e7". */
3137 if (ident_length == 0) {
3139 while (ibp[0] == '\\' && ibp[1] == '\n') {
3144 if (!is_idchar[c] && c != '.') {
3149 /* A sign can be part of a preprocessing number
3150 if it follows an e. */
3151 if (c == 'e' || c == 'E') {
3152 while (ibp[0] == '\\' && ibp[1] == '\n') {
3156 if (*ibp == '+' || *ibp == '-') {
3158 /* But traditional C does not let the token go past the sign. */
3169 case 'a': case 'b': case 'c': case 'd': case 'e': case 'f':
3170 case 'g': case 'h': case 'i': case 'j': case 'k': case 'l':
3171 case 'm': case 'n': case 'o': case 'p': case 'q': case 'r':
3172 case 's': case 't': case 'u': case 'v': case 'w': case 'x':
3174 case 'A': case 'B': case 'C': case 'D': case 'E': case 'F':
3175 case 'G': case 'H': case 'I': case 'J': case 'K': case 'L':
3176 case 'M': case 'N': case 'O': case 'P': case 'Q': case 'R':
3177 case 'S': case 'T': case 'U': case 'V': case 'W': case 'X':
3181 /* Compute step of hash function, to avoid a proc call on every token */
3182 hash = HASHSTEP (hash, c);
3186 if (ip->fname == 0 && *ibp == '-') {
3187 /* Newline - inhibits expansion of preceding token.
3188 If expanding a macro arg, we keep the newline -.
3189 In final output, it is deleted.
3190 We recognize Newline - in macro bodies and macro args. */
3191 if (! concatenated) {
3196 if (!output_marks) {
3199 /* If expanding a macro arg, keep the newline -. */
3205 /* If reprocessing a macro expansion, newline is a special marker. */
3206 else if (ip->macro != 0) {
3207 /* Newline White is a "funny space" to separate tokens that are
3208 supposed to be separate but without space between.
3209 Here White means any whitespace character.
3210 Newline - marks a recursive macro use that is not
3211 supposed to be expandable. */
3213 if (is_space[*ibp]) {
3214 /* Newline Space does not prevent expansion of preceding token
3215 so expand the preceding token and then come back. */
3216 if (ident_length > 0)
3219 /* If generating final output, newline space makes a space. */
3220 if (!output_marks) {
3222 /* And Newline Newline makes a newline, so count it. */
3223 if (obp[-1] == '\n')
3226 /* If expanding a macro arg, keep the newline space.
3227 If the arg gets stringified, newline space makes nothing. */
3230 } else abort (); /* Newline followed by something random? */
3234 /* If there is a pending identifier, handle it and come back here. */
3235 if (ident_length > 0)
3240 /* Update the line counts and output a #line if necessary. */
3243 if (ip->lineno != op->lineno) {
3245 output_line_directive (ip, op, 1, same_file);
3246 check_expand (op, limit - ibp);
3251 /* Come here either after (1) a null character that is part of the input
3252 or (2) at the end of the input, because there is a null there. */
3255 /* Our input really contains a null character. */
3258 /* At end of a macro-expansion level, pop it and read next level. */
3259 if (ip->macro != 0) {
3262 /* If traditional, and we have an identifier that ends here,
3263 process it now, so we get the right error for recursion. */
3264 if (traditional && ident_length
3265 && ! is_idchar[*instack[indepth - 1].bufp]) {
3274 /* If we don't have a pending identifier,
3275 return at end of input. */
3276 if (ident_length == 0) {
3284 /* If we do have a pending identifier, just consider this null
3285 a special character and arrange to dispatch on it again.
3286 The second time, IDENT_LENGTH will be zero so we will return. */
3292 /* Handle the case of a character such as /, ', " or null
3293 seen following an identifier. Back over it so that
3294 after the identifier is processed the special char
3295 will be dispatched on again. */
3305 if (ident_length > 0) {
3306 register HASHNODE *hp;
3308 /* We have just seen an identifier end. If it's a macro, expand it.
3310 IDENT_LENGTH is the length of the identifier
3311 and HASH is its hash code.
3313 The identifier has already been copied to the output,
3314 so if it is a macro we must remove it.
3316 If REDO_CHAR is 0, the char that terminated the identifier
3317 has been skipped in the output and the input.
3318 OBP-IDENT_LENGTH-1 points to the identifier.
3319 If the identifier is a macro, we must back over the terminator.
3321 If REDO_CHAR is 1, the terminating char has already been
3322 backed over. OBP-IDENT_LENGTH points to the identifier. */
3324 if (!pcp_outfile || pcp_inside_if) {
3325 for (hp = hashtab[MAKE_POS (hash) % HASHSIZE]; hp != NULL;
3328 if (hp->length == ident_length) {
3329 int obufp_before_macroname;
3330 int op_lineno_before_macroname;
3331 register int i = ident_length;
3332 register U_CHAR *p = hp->name;
3333 register U_CHAR *q = obp - i;
3339 do { /* All this to avoid a strncmp () */
3344 /* We found a use of a macro name.
3345 see if the context shows it is a macro call. */
3347 /* Back up over terminating character if not already done. */
3353 /* Save this as a displacement from the beginning of the output
3354 buffer. We can not save this as a position in the output
3355 buffer, because it may get realloc'ed by RECACHE. */
3356 obufp_before_macroname = (obp - op->buf) - ident_length;
3357 op_lineno_before_macroname = op->lineno;
3359 if (hp->type == T_PCSTRING) {
3360 pcstring_used (hp); /* Mark the definition of this key
3361 as needed, ensuring that it
3363 break; /* Exit loop, since the key cannot have a
3364 definition any longer. */
3367 /* Record whether the macro is disabled. */
3368 disabled = hp->type == T_DISABLED;
3370 /* This looks like a macro ref, but if the macro was disabled,
3371 just copy its name and put in a marker if requested. */
3375 /* This error check caught useful cases such as
3376 #define foo(x,y) bar (x (y,0), y)
3379 error ("recursive use of macro `%s'", hp->name);
3383 check_expand (op, limit - ibp + 2);
3390 /* If macro wants an arglist, verify that a '(' follows.
3391 first skip all whitespace, copying it to the output
3392 after the macro name. Then, if there is no '(',
3393 decide this is not a macro call and leave things that way. */
3394 if ((hp->type == T_MACRO || hp->type == T_DISABLED)
3395 && hp->value.defn->nargs >= 0)
3397 U_CHAR *old_ibp = ibp;
3398 U_CHAR *old_obp = obp;
3399 int old_iln = ip->lineno;
3400 int old_oln = op->lineno;
3403 /* Scan forward over whitespace, copying it to the output. */
3404 if (ibp == limit && ip->macro != 0) {
3409 old_iln = ip->lineno;
3410 old_oln = op->lineno;
3412 /* A comment: copy it unchanged or discard it. */
3413 else if (*ibp == '/' && ibp[1] == '*') {
3414 if (put_out_comments) {
3417 } else if (! traditional) {
3421 while (ibp + 1 != limit
3422 && !(ibp[0] == '*' && ibp[1] == '/')) {
3423 /* We need not worry about newline-marks,
3424 since they are never found in comments. */
3426 /* Newline in a file. Count it. */
3430 if (put_out_comments)
3436 if (put_out_comments) {
3441 else if (is_space[*ibp]) {
3443 if (ibp[-1] == '\n') {
3444 if (ip->macro == 0) {
3445 /* Newline in a file. Count it. */
3448 } else if (!output_marks) {
3449 /* A newline mark, and we don't want marks
3450 in the output. If it is newline-hyphen,
3451 discard it entirely. Otherwise, it is
3452 newline-whitechar, so keep the whitechar. */
3462 /* A newline mark; copy both chars to the output. */
3470 /* It isn't a macro call.
3471 Put back the space that we just skipped. */
3474 ip->lineno = old_iln;
3475 op->lineno = old_oln;
3476 /* Exit the for loop. */
3481 /* This is now known to be a macro call.
3482 Discard the macro name from the output,
3483 along with any following whitespace just copied,
3484 but preserve newlines if not outputting marks since this
3485 is more likely to do the right thing with line numbers. */
3486 obp = op->buf + obufp_before_macroname;
3488 op->lineno = op_lineno_before_macroname;
3490 int newlines = op->lineno - op_lineno_before_macroname;
3491 while (0 < newlines--)
3495 /* Prevent accidental token-pasting with a character
3496 before the macro call. */
3497 if (!traditional && obp != op->buf) {
3499 case '!': case '%': case '&': case '*':
3500 case '+': case '-': case '/': case ':':
3501 case '<': case '=': case '>': case '^':
3503 /* If we are expanding a macro arg, make a newline marker
3504 to separate the tokens. If we are making real output,
3505 a plain space will do. */
3512 /* Expand the macro, reading arguments as needed,
3513 and push the expansion on the input stack. */
3516 macroexpand (hp, op);
3518 /* Reexamine input stack, since macroexpand has pushed
3519 a new level on it. */
3526 } /* End hash-table-search loop */
3528 ident_length = hash = 0; /* Stop collecting identifier */
3531 } /* End if (ident_length > 0) */
3533 } /* End per-char loop */
3535 /* Come here to return -- but first give an error message
3536 if there was an unterminated successful conditional. */
3538 if (if_stack != ip->if_stack)
3542 switch (if_stack->type)
3563 error_with_line (line_for_error (if_stack->lineno),
3564 "unterminated `#%s' conditional", str);
3566 if_stack = ip->if_stack;
3570 * Rescan a string into a temporary buffer and return the result
3571 * as a FILE_BUF. Note this function returns a struct, not a pointer.
3573 * OUTPUT_MARKS nonzero means keep Newline markers found in the input
3574 * and insert such markers when appropriate. See `rescan' for details.
3575 * OUTPUT_MARKS is 1 for macroexpanding a macro argument separately
3576 * before substitution; it is 0 for other uses.
3579 expand_to_temp_buffer (buf, limit, output_marks, assertions)
3580 U_CHAR *buf, *limit;
3581 int output_marks, assertions;
3583 register FILE_BUF *ip;
3585 int length = limit - buf;
3587 int odepth = indepth;
3588 int save_assertions_flag = assertions_flag;
3590 assertions_flag = assertions;
3595 /* Set up the input on the input stack. */
3597 buf1 = (U_CHAR *) alloca (length + 1);
3599 register U_CHAR *p1 = buf;
3600 register U_CHAR *p2 = buf1;
3607 /* Set up to receive the output. */
3609 obuf.length = length * 2 + 100; /* Usually enough. Why be stingy? */
3610 obuf.bufp = obuf.buf = (U_CHAR *) xmalloc (obuf.length);
3615 CHECK_DEPTH ({return obuf;});
3619 ip = &instack[indepth];
3621 ip->nominal_fname = 0;
3622 ip->system_header_p = 0;
3625 ip->length = length;
3626 ip->buf = ip->bufp = buf1;
3627 ip->if_stack = if_stack;
3629 ip->lineno = obuf.lineno = 1;
3631 /* Scan the input, create the output. */
3632 rescan (&obuf, output_marks);
3634 /* Pop input stack to original state. */
3637 if (indepth != odepth)
3640 /* Record the output. */
3641 obuf.length = obuf.bufp - obuf.buf;
3643 assertions_flag = save_assertions_flag;
3648 * Process a # directive. Expects IP->bufp to point after the '#', as in
3649 * `#define foo bar'. Passes to the directive handler
3650 * (do_define, do_include, etc.): the addresses of the 1st and
3651 * last chars of the directive (starting immediately after the #
3652 * keyword), plus op and the keyword table pointer. If the directive
3653 * contains comments it is copied into a temporary buffer sans comments
3654 * and the temporary buffer is passed to the directive handler instead.
3655 * Likewise for backslash-newlines.
3657 * Returns nonzero if this was a known # directive.
3658 * Otherwise, returns zero, without advancing the input pointer.
3662 handle_directive (ip, op)
3665 register U_CHAR *bp, *cp;
3666 register struct directive *kt;
3667 register int ident_length;
3670 /* Nonzero means we must copy the entire directive
3671 to get rid of comments or backslash-newlines. */
3672 int copy_directive = 0;
3674 U_CHAR *ident, *after_ident;
3678 /* Record where the directive started. do_xifdef needs this. */
3679 directive_start = bp - 1;
3681 /* Skip whitespace and \-newline. */
3683 if (is_hor_space[*bp]) {
3684 if (*bp != ' ' && *bp != '\t' && pedantic)
3685 pedwarn ("%s in preprocessing directive", char_name[*bp]);
3687 } else if (*bp == '/' && (bp[1] == '*'
3688 || (cplusplus_comments && bp[1] == '/'))) {
3690 skip_to_end_of_comment (ip, &ip->lineno, 0);
3692 } else if (*bp == '\\' && bp[1] == '\n') {
3693 bp += 2; ip->lineno++;
3697 /* Now find end of directive name.
3698 If we encounter a backslash-newline, exchange it with any following
3699 symbol-constituents so that we end up with a contiguous name. */
3706 if (*cp == '\\' && cp[1] == '\n')
3707 name_newline_fix (cp);
3713 ident_length = cp - bp;
3717 /* A line of just `#' becomes blank. */
3719 if (ident_length == 0 && *after_ident == '\n') {
3720 ip->bufp = after_ident;
3724 if (ident_length == 0 || !is_idstart[*ident]) {
3726 while (is_idchar[*p]) {
3727 if (*p < '0' || *p > '9')
3731 /* Handle # followed by a line number. */
3732 if (p != ident && !is_idchar[*p]) {
3733 static struct directive line_directive_table[] = {
3734 { 4, do_line, "line", T_LINE},
3737 pedwarn ("`#' followed by integer");
3738 after_ident = ident;
3739 kt = line_directive_table;
3743 /* Avoid error for `###' and similar cases unless -pedantic. */
3745 while (*p == '#' || is_hor_space[*p]) p++;
3747 if (pedantic && !lang_asm)
3748 warning ("invalid preprocessing directive");
3754 error ("invalid preprocessing directive name");
3760 * Decode the keyword and call the appropriate expansion
3761 * routine, after moving the input pointer up to the next line.
3763 for (kt = directive_table; kt->length > 0; kt++) {
3764 if (kt->length == ident_length && !bcmp (kt->name, ident, ident_length)) {
3765 register U_CHAR *buf;
3766 register U_CHAR *limit;
3769 int *already_output;
3771 /* Nonzero means do not delete comments within the directive.
3772 #define needs this when -traditional. */
3777 limit = ip->buf + ip->length;
3780 keep_comments = traditional && kt->traditional_comments;
3781 /* #import is defined only in Objective C, or when on the NeXT. */
3782 if (kt->type == T_IMPORT
3783 && !(objc || lookup ((U_CHAR *) "__NeXT__", -1, -1)))
3786 /* Find the end of this directive (first newline not backslashed
3787 and not in a string or comment).
3788 Set COPY_DIRECTIVE if the directive must be copied
3789 (it contains a backslash-newline or a comment). */
3791 buf = bp = after_ident;
3792 while (bp < limit) {
3793 register U_CHAR c = *bp++;
3801 } else if (traditional)
3808 bp = skip_quoted_string (bp - 1, limit, ip->lineno, &ip->lineno, ©_directive, &unterminated);
3809 /* Don't bother calling the directive if we already got an error
3810 message due to unterminated string. Skip everything and pretend
3811 we called the directive. */
3814 /* Traditional preprocessing permits unterminated strings. */
3823 /* <...> is special for #include. */
3825 if (!kt->angle_brackets)
3827 while (bp < limit && *bp != '>' && *bp != '\n') {
3828 if (*bp == '\\' && bp[1] == '\n') {
3838 if (*bp == '\\' && bp[1] == '\n')
3841 || (cplusplus_comments && *bp == '/')) {
3842 U_CHAR *obp = bp - 1;
3844 skip_to_end_of_comment (ip, &ip->lineno, 0);
3846 /* No need to copy the directive because of a comment at the end;
3847 just don't include the comment in the directive. */
3848 if (bp == limit || *bp == '\n') {
3852 /* Don't remove the comments if -traditional. */
3853 if (! keep_comments)
3862 pedwarn ("%s in preprocessing directive", char_name[c]);
3866 --bp; /* Point to the newline */
3874 resume_p = ip->bufp;
3875 /* BP is the end of the directive.
3876 RESUME_P is the next interesting data after the directive.
3877 A comment may come between. */
3879 /* If a directive should be copied through, and -E was given,
3880 pass it through before removing comments. */
3881 if (!no_output && kt->pass_thru && put_out_comments) {
3884 /* Output directive name. */
3885 check_expand (op, kt->length + 2);
3886 /* Make sure # is at the start of a line */
3887 if (op->bufp > op->buf && op->bufp[-1] != '\n') {
3892 bcopy (kt->name, op->bufp, kt->length);
3893 op->bufp += kt->length;
3895 /* Output arguments. */
3897 check_expand (op, len);
3898 bcopy (buf, (char *) op->bufp, len);
3900 /* Take account of any (escaped) newlines just output. */
3902 if (buf[len] == '\n')
3905 already_output = &junk;
3906 } /* Don't we need a newline or #line? */
3908 if (copy_directive) {
3909 register U_CHAR *xp = buf;
3910 /* Need to copy entire directive into temp buffer before dispatching */
3912 cp = (U_CHAR *) alloca (bp - buf + 5); /* room for directive plus
3916 /* Copy to the new buffer, deleting comments
3917 and backslash-newlines (and whitespace surrounding the latter). */
3920 register U_CHAR c = *xp++;
3925 abort (); /* A bare newline should never part of the line. */
3928 /* <...> is special for #include. */
3930 if (!kt->angle_brackets)
3932 while (xp < bp && c != '>') {
3934 if (c == '\\' && xp < bp && *xp == '\n')
3945 if (cp != buf && is_space[cp[-1]]) {
3946 while (cp != buf && is_space[cp[-1]]) cp--;
3948 SKIP_WHITE_SPACE (xp);
3949 } else if (is_space[*xp]) {
3951 SKIP_WHITE_SPACE (xp);
3953 } else if (traditional && xp < bp) {
3961 register U_CHAR *bp1
3962 = skip_quoted_string (xp - 1, bp, ip->lineno,
3963 NULL_PTR, NULL_PTR, NULL_PTR);
3977 || (cplusplus_comments && *xp == '/')) {
3979 /* If we already copied the directive through,
3980 already_output != 0 prevents outputting comment now. */
3981 skip_to_end_of_comment (ip, already_output, 0);
3983 while (xp != ip->bufp)
3985 /* Delete or replace the slash. */
3986 else if (traditional)
3995 /* Null-terminate the copy. */
4001 ip->bufp = resume_p;
4003 /* Some directives should be written out for cc1 to process,
4004 just as if they were not defined. And sometimes we're copying
4005 definitions through. */
4007 if (!no_output && already_output == 0
4009 || (kt->type == T_DEFINE
4010 && (dump_macros == dump_names
4011 || dump_macros == dump_definitions)))) {
4014 /* Output directive name. */
4015 check_expand (op, kt->length + 1);
4017 bcopy (kt->name, (char *) op->bufp, kt->length);
4018 op->bufp += kt->length;
4020 if (kt->pass_thru || dump_macros == dump_definitions) {
4021 /* Output arguments. */
4023 check_expand (op, len);
4024 bcopy (buf, (char *) op->bufp, len);
4026 } else if (kt->type == T_DEFINE && dump_macros == dump_names) {
4029 SKIP_WHITE_SPACE (xp);
4031 while (is_idchar[*xp]) xp++;
4033 check_expand (op, len + 1);
4035 bcopy (yp, op->bufp, len);
4038 } /* Don't we need a newline or #line? */
4040 /* Call the appropriate directive handler. buf now points to
4041 either the appropriate place in the input buffer, or to
4042 the temp buffer if it was necessary to make one. cp
4043 points to the first char after the contents of the (possibly
4044 copied) directive, in either case. */
4045 (*kt->func) (buf, cp, op, kt);
4046 check_expand (op, ip->length - (ip->bufp - ip->buf));
4052 /* It is deliberate that we don't warn about undefined directives.
4053 That is the responsibility of cc1. */
4060 static struct tm *timebuf;
4062 time_t t = time ((time_t *)0);
4063 timebuf = localtime (&t);
4068 static char *monthnames[] = {"Jan", "Feb", "Mar", "Apr", "May", "Jun",
4069 "Jul", "Aug", "Sep", "Oct", "Nov", "Dec",
4073 * expand things like __FILE__. Place the expansion into the output
4074 * buffer *without* rescanning.
4078 special_symbol (hp, op)
4085 FILE_BUF *ip = NULL;
4088 int paren = 0; /* For special `defined' keyword */
4090 if (pcp_outfile && pcp_inside_if
4091 && hp->type != T_SPEC_DEFINED && hp->type != T_CONST)
4092 error ("Predefined macro `%s' used inside `#if' during precompilation",
4095 for (i = indepth; i >= 0; i--)
4096 if (instack[i].fname != NULL) {
4101 error ("cccp error: not in any file?!");
4102 return; /* the show must go on */
4110 if (hp->type == T_FILE)
4111 string = ip->nominal_fname;
4113 string = instack[0].nominal_fname;
4117 buf = (char *) alloca (3 + 4 * strlen (string));
4118 quote_string (buf, string);
4126 case T_INCLUDE_LEVEL:
4128 for (i = indepth; i >= 0; i--)
4129 if (instack[i].fname != NULL)
4132 buf = (char *) alloca (8); /* Eight bytes ought to be more than enough */
4133 sprintf (buf, "%d", true_indepth - 1);
4137 buf = (char *) alloca (3 + strlen (version_string));
4138 sprintf (buf, "\"%s\"", version_string);
4141 #ifndef NO_BUILTIN_SIZE_TYPE
4147 #ifndef NO_BUILTIN_PTRDIFF_TYPE
4148 case T_PTRDIFF_TYPE:
4157 case T_USER_LABEL_PREFIX_TYPE:
4158 buf = USER_LABEL_PREFIX;
4161 case T_REGISTER_PREFIX_TYPE:
4162 buf = REGISTER_PREFIX;
4165 case T_IMMEDIATE_PREFIX_TYPE:
4166 buf = IMMEDIATE_PREFIX;
4170 buf = hp->value.cpval;
4171 if (pcp_inside_if && pcp_outfile)
4172 /* Output a precondition for this macro use */
4173 fprintf (pcp_outfile, "#define %s %s\n", hp->name, buf);
4177 buf = (char *) alloca (10);
4178 sprintf (buf, "%d", ip->lineno);
4183 buf = (char *) alloca (20);
4184 timebuf = timestamp ();
4185 if (hp->type == T_DATE)
4186 sprintf (buf, "\"%s %2d %4d\"", monthnames[timebuf->tm_mon],
4187 timebuf->tm_mday, timebuf->tm_year + 1900);
4189 sprintf (buf, "\"%02d:%02d:%02d\"", timebuf->tm_hour, timebuf->tm_min,
4193 case T_SPEC_DEFINED:
4194 buf = " 0 "; /* Assume symbol is not defined */
4195 ip = &instack[indepth];
4196 SKIP_WHITE_SPACE (ip->bufp);
4197 if (*ip->bufp == '(') {
4199 ip->bufp++; /* Skip over the paren */
4200 SKIP_WHITE_SPACE (ip->bufp);
4203 if (!is_idstart[*ip->bufp])
4205 if ((hp = lookup (ip->bufp, -1, -1))) {
4206 if (pcp_outfile && pcp_inside_if
4207 && (hp->type == T_CONST
4208 || (hp->type == T_MACRO && hp->value.defn->predefined)))
4209 /* Output a precondition for this macro use. */
4210 fprintf (pcp_outfile, "#define %s\n", hp->name);
4214 if (pcp_outfile && pcp_inside_if) {
4215 /* Output a precondition for this macro use */
4216 U_CHAR *cp = ip->bufp;
4217 fprintf (pcp_outfile, "#undef ");
4218 while (is_idchar[*cp]) /* Ick! */
4219 fputc (*cp++, pcp_outfile);
4220 putc ('\n', pcp_outfile);
4222 while (is_idchar[*ip->bufp])
4224 SKIP_WHITE_SPACE (ip->bufp);
4226 if (*ip->bufp != ')')
4234 error ("`defined' without an identifier");
4238 error ("cccp error: invalid special hash type"); /* time for gdb */
4242 check_expand (op, len);
4243 bcopy (buf, (char *) op->bufp, len);
4250 /* Routines to handle #directives */
4252 /* Handle #include and #import.
4253 This function expects to see "fname" or <fname> on the input. */
4256 do_include (buf, limit, op, keyword)
4257 U_CHAR *buf, *limit;
4259 struct directive *keyword;
4261 int importing = (keyword->type == T_IMPORT);
4262 int skip_dirs = (keyword->type == T_INCLUDE_NEXT);
4263 static int import_warning = 0;
4264 char *fname; /* Dynamically allocated fname buffer */
4267 U_CHAR *fbeg, *fend; /* Beginning and end of fname */
4269 struct file_name_list *search_start = include; /* Chain of dirs to search */
4270 struct file_name_list dsp[1]; /* First in chain, if #include "..." */
4271 struct file_name_list *searchptr = 0;
4274 int f; /* file number */
4276 int retried = 0; /* Have already tried macro
4277 expanding the include line*/
4278 int angle_brackets = 0; /* 0 for "...", 1 for <...> */
4283 f= -1; /* JF we iz paranoid! */
4285 if (importing && warn_import && !inhibit_warnings
4286 && !instack[indepth].system_header_p && !import_warning) {
4288 warning ("using `#import' is not recommended");
4289 fprintf (stderr, "The fact that a certain header file need not be processed more than once\n");
4290 fprintf (stderr, "should be indicated in the header file, not where it is used.\n");
4291 fprintf (stderr, "The best way to do this is with a conditional of this form:\n\n");
4292 fprintf (stderr, " #ifndef _FOO_H_INCLUDED\n");
4293 fprintf (stderr, " #define _FOO_H_INCLUDED\n");
4294 fprintf (stderr, " ... <real contents of file> ...\n");
4295 fprintf (stderr, " #endif /* Not _FOO_H_INCLUDED */\n\n");
4296 fprintf (stderr, "Then users can use `#include' any number of times.\n");
4297 fprintf (stderr, "GNU C automatically avoids processing the file more than once\n");
4298 fprintf (stderr, "when it is equipped with such a conditional.\n");
4304 SKIP_WHITE_SPACE (fbeg);
4305 /* Discard trailing whitespace so we can easily see
4306 if we have parsed all the significant chars we were given. */
4307 while (limit != fbeg && is_hor_space[limit[-1]]) limit--;
4313 /* Copy the operand text, concatenating the strings. */
4316 fbeg = (U_CHAR *) alloca (limit - fbeg + 1);
4318 while (fin != limit) {
4319 while (fin != limit && *fin != '\"')
4324 /* If not at the end, there had better be another string. */
4325 /* Skip just horiz space, and don't go past limit. */
4326 while (fin != limit && is_hor_space[*fin]) fin++;
4327 if (fin != limit && *fin == '\"')
4335 /* We have "filename". Figure out directory this source
4336 file is coming from and put it on the front of the list. */
4338 /* If -I- was specified, don't search current dir, only spec'd ones. */
4339 if (ignore_srcdir) break;
4341 for (fp = &instack[indepth]; fp >= instack; fp--)
4346 if ((nam = fp->nominal_fname) != NULL) {
4347 /* Found a named file. Figure out dir of the file,
4348 and put it in front of the search list. */
4349 dsp[0].next = search_start;
4352 ep = rindex (nam, '/');
4353 #ifdef DIR_SEPARATOR
4354 if (ep == NULL) ep = rindex (nam, DIR_SEPARATOR);
4356 char *tmp = rindex (nam, DIR_SEPARATOR);
4357 if (tmp != NULL && tmp > ep) ep = tmp;
4361 ep = rindex (nam, ']');
4362 if (ep == NULL) ep = rindex (nam, '>');
4363 if (ep == NULL) ep = rindex (nam, ':');
4364 if (ep != NULL) ep++;
4368 dsp[0].fname = (char *) alloca (n + 1);
4369 strncpy (dsp[0].fname, nam, n);
4370 dsp[0].fname[n] = '\0';
4371 if (n + INCLUDE_LEN_FUDGE > max_include_len)
4372 max_include_len = n + INCLUDE_LEN_FUDGE;
4374 dsp[0].fname = 0; /* Current directory */
4376 dsp[0].got_name_map = 0;
4385 while (fend != limit && *fend != '>') fend++;
4386 if (*fend == '>' && fend + 1 == limit) {
4388 /* If -I-, start with the first -I dir after the -I-. */
4389 if (first_bracket_include)
4390 search_start = first_bracket_include;
4398 * Support '#include xyz' like VAX-C to allow for easy use of all the
4399 * decwindow include files. It defaults to '#include <xyz.h>' (so the
4400 * code from case '<' is repeated here) and generates a warning.
4401 * (Note: macro expansion of `xyz' takes precedence.)
4403 if (retried && isalpha(*(--fbeg))) {
4405 while (fend != limit && (!isspace(*fend))) fend++;
4406 warning ("VAX-C-style include specification found, use '#include <filename.h>' !");
4407 if (fend == limit) {
4409 /* If -I-, start with the first -I dir after the -I-. */
4410 if (first_bracket_include)
4411 search_start = first_bracket_include;
4419 error ("`#%s' expects \"FILENAME\" or <FILENAME>", keyword->name);
4422 /* Expand buffer and then remove any newline markers.
4423 We can't just tell expand_to_temp_buffer to omit the markers,
4424 since it would put extra spaces in include file names. */
4427 trybuf = expand_to_temp_buffer (buf, limit, 1, 0);
4429 buf = (U_CHAR *) alloca (trybuf.bufp - trybuf.buf + 1);
4431 while (src != trybuf.bufp) {
4432 switch ((*limit++ = *src++)) {
4441 U_CHAR *src1 = skip_quoted_string (src - 1, trybuf.bufp, 0,
4442 NULL_PTR, NULL_PTR, NULL_PTR);
4456 /* For #include_next, skip in the search path
4457 past the dir in which the containing file was found. */
4460 for (fp = &instack[indepth]; fp >= instack; fp--)
4461 if (fp->fname != NULL) {
4462 /* fp->dir is null if the containing file was specified
4463 with an absolute file name. In that case, don't skip anything. */
4465 search_start = fp->dir->next;
4474 error ("empty file name in `#%s'", keyword->name);
4478 /* Allocate this permanently, because it gets stored in the definitions
4480 fname = xmalloc (max_include_len + flen + 4);
4481 /* + 2 above for slash and terminating null. */
4482 /* + 2 added for '.h' on VMS (to support '#include filename') */
4484 /* If specified file name is absolute, just open it. */
4487 #ifdef DIR_SEPARATOR
4488 || *fbeg == DIR_SEPARATOR
4491 strncpy (fname, (char *) fbeg, flen);
4493 if (redundant_include_p (fname))
4496 f = lookup_import (fname, NULL_PTR);
4498 f = open_include_file (fname, NULL_PTR);
4500 return 0; /* Already included this file */
4502 /* Search directory path, trying to open the file.
4503 Copy each filename tried into FNAME. */
4505 for (searchptr = search_start; searchptr; searchptr = searchptr->next) {
4506 if (searchptr->fname) {
4507 /* The empty string in a search path is ignored.
4508 This makes it possible to turn off entirely
4509 a standard piece of the list. */
4510 if (searchptr->fname[0] == 0)
4512 strcpy (fname, searchptr->fname);
4513 strcat (fname, "/");
4514 fname[strlen (fname) + flen] = 0;
4518 strncat (fname, (char *) fbeg, flen);
4520 /* Change this 1/2 Unix 1/2 VMS file specification into a
4521 full VMS file specification */
4522 if (searchptr->fname && (searchptr->fname[0] != 0)) {
4523 /* Fix up the filename */
4524 hack_vms_include_specification (fname);
4526 /* This is a normal VMS filespec, so use it unchanged. */
4527 strncpy (fname, fbeg, flen);
4529 /* if it's '#include filename', add the missing .h */
4530 if (index(fname,'.')==NULL) {
4531 strcat (fname, ".h");
4535 /* ??? There are currently 3 separate mechanisms for avoiding processing
4536 of redundant include files: #import, #pragma once, and
4537 redundant_include_p. It would be nice if they were unified. */
4538 if (redundant_include_p (fname))
4541 f = lookup_import (fname, searchptr);
4543 f = open_include_file (fname, searchptr);
4545 return 0; /* Already included this file */
4547 else if (f == -1 && errno == EACCES)
4548 warning ("Header file %s exists, but is not readable", fname);
4556 /* A file that was not found. */
4558 strncpy (fname, (char *) fbeg, flen);
4560 /* If generating dependencies and -MG was specified, we assume missing
4561 files are leaf files, living in the same directory as the source file
4562 or other similar place; these missing files may be generated from
4563 other files and may not exist yet (eg: y.tab.h). */
4564 if (print_deps_missing_files
4565 && print_deps > (angle_brackets || (system_include_depth > 0)))
4567 /* If it was requested as a system header file,
4568 then assume it belongs in the first place to look for such. */
4571 for (searchptr = search_start; searchptr; searchptr = searchptr->next)
4573 if (searchptr->fname)
4577 if (searchptr->fname[0] == 0)
4579 p = (char *) alloca (strlen (searchptr->fname)
4580 + strlen (fname) + 2);
4581 strcpy (p, searchptr->fname);
4584 deps_output (p, ' ');
4591 /* Otherwise, omit the directory, as if the file existed
4592 in the directory with the source. */
4593 deps_output (fname, ' ');
4596 /* If -M was specified, and this header file won't be added to the
4597 dependency list, then don't count this as an error, because we can
4598 still produce correct output. Otherwise, we can't produce correct
4599 output, because there may be dependencies we need inside the missing
4600 file, and we don't know what directory this missing file exists in. */
4602 && (print_deps <= (angle_brackets || (system_include_depth > 0))))
4603 warning ("No include path in which to find %s", fname);
4604 else if (search_start)
4605 error_from_errno (fname);
4607 error ("No include path in which to find %s", fname);
4609 /* Check to see if this include file is a once-only include file.
4612 struct file_name_list* ptr;
4614 for (ptr = dont_repeat_files; ptr; ptr = ptr->next) {
4615 if (!strcmp (ptr->fname, fname)) {
4617 return 0; /* This file was once'd. */
4621 for (ptr = all_include_files; ptr; ptr = ptr->next) {
4622 if (!strcmp (ptr->fname, fname))
4623 break; /* This file was included before. */
4627 /* This is the first time for this file. */
4628 /* Add it to list of files included. */
4630 ptr = (struct file_name_list *) xmalloc (sizeof (struct file_name_list));
4631 ptr->control_macro = 0;
4632 ptr->c_system_include_path = 0;
4633 ptr->next = all_include_files;
4634 all_include_files = ptr;
4635 ptr->fname = savestring (fname);
4636 ptr->got_name_map = 0;
4638 /* For -M, add this file to the dependencies. */
4639 if (print_deps > (angle_brackets || (system_include_depth > 0)))
4640 deps_output (fname, ' ');
4643 /* Handle -H option. */
4644 if (print_include_names) {
4645 output_dots (stderr, indepth);
4646 fprintf (stderr, "%s\n", fname);
4650 system_include_depth++;
4652 /* Actually process the file. */
4653 add_import (f, fname); /* Record file on "seen" list for #import. */
4655 pcftry = (char *) alloca (strlen (fname) + 30);
4666 sprintf (pcftry, "%s%d", fname, pcfnum++);
4668 pcf = open (pcftry, O_RDONLY, 0666);
4674 if (bcmp ((char *) &stat_f.st_ino, (char *) &s.st_ino,
4676 || stat_f.st_dev != s.st_dev)
4678 pcfbuf = check_precompiled (pcf, fname, &pcfbuflimit);
4679 /* Don't need it any more. */
4684 /* Don't need it at all. */
4689 } while (pcf != -1 && !pcfbuf);
4692 /* Actually process the file */
4694 pcfname = xmalloc (strlen (pcftry) + 1);
4695 strcpy (pcfname, pcftry);
4696 pcfinclude ((U_CHAR *) pcfbuf, (U_CHAR *) pcfbuflimit,
4697 (U_CHAR *) fname, op);
4700 finclude (f, fname, op, is_system_include (fname), searchptr);
4703 system_include_depth--;
4708 /* Return nonzero if there is no need to include file NAME
4709 because it has already been included and it contains a conditional
4710 to make a repeated include do nothing. */
4713 redundant_include_p (name)
4716 struct file_name_list *l = all_include_files;
4717 for (; l; l = l->next)
4718 if (! strcmp (name, l->fname)
4720 && lookup (l->control_macro, -1, -1))
4725 /* Return nonzero if the given FILENAME is an absolute pathname which
4726 designates a file within one of the known "system" include file
4727 directories. We assume here that if the given FILENAME looks like
4728 it is the name of a file which resides either directly in a "system"
4729 include file directory, or within any subdirectory thereof, then the
4730 given file must be a "system" include file. This function tells us
4731 if we should suppress pedantic errors/warnings for the given FILENAME.
4733 The value is 2 if the file is a C-language system header file
4734 for which C++ should (on most systems) assume `extern "C"'. */
4737 is_system_include (filename)
4738 register char *filename;
4740 struct file_name_list *searchptr;
4742 for (searchptr = first_system_include; searchptr;
4743 searchptr = searchptr->next)
4744 if (searchptr->fname) {
4745 register char *sys_dir = searchptr->fname;
4746 register unsigned length = strlen (sys_dir);
4748 if (! strncmp (sys_dir, filename, length)
4749 && (filename[length] == '/'
4750 #ifdef DIR_SEPARATOR
4751 || filename[length] == DIR_SEPARATOR
4754 if (searchptr->c_system_include_path)
4763 /* The file_name_map structure holds a mapping of file names for a
4764 particular directory. This mapping is read from the file named
4765 FILE_NAME_MAP_FILE in that directory. Such a file can be used to
4766 map filenames on a file system with severe filename restrictions,
4767 such as DOS. The format of the file name map file is just a series
4768 of lines with two tokens on each line. The first token is the name
4769 to map, and the second token is the actual name to use. */
4771 struct file_name_map
4773 struct file_name_map *map_next;
4778 #define FILE_NAME_MAP_FILE "header.gcc"
4780 /* Read a space delimited string of unlimited length from a stdio
4784 read_filename_string (ch, f)
4792 set = alloc = xmalloc (len + 1);
4796 while ((ch = getc (f)) != EOF && ! is_space[ch])
4798 if (set - alloc == len)
4801 alloc = xrealloc (alloc, len + 1);
4802 set = alloc + len / 2;
4812 /* Read the file name map file for DIRNAME. */
4814 static struct file_name_map *
4815 read_name_map (dirname)
4818 /* This structure holds a linked list of file name maps, one per
4820 struct file_name_map_list
4822 struct file_name_map_list *map_list_next;
4823 char *map_list_name;
4824 struct file_name_map *map_list_map;
4826 static struct file_name_map_list *map_list;
4827 register struct file_name_map_list *map_list_ptr;
4831 for (map_list_ptr = map_list; map_list_ptr;
4832 map_list_ptr = map_list_ptr->map_list_next)
4833 if (! strcmp (map_list_ptr->map_list_name, dirname))
4834 return map_list_ptr->map_list_map;
4836 map_list_ptr = ((struct file_name_map_list *)
4837 xmalloc (sizeof (struct file_name_map_list)));
4838 map_list_ptr->map_list_name = savestring (dirname);
4839 map_list_ptr->map_list_map = NULL;
4841 name = (char *) alloca (strlen (dirname) + strlen (FILE_NAME_MAP_FILE) + 2);
4842 strcpy (name, dirname);
4845 strcat (name, FILE_NAME_MAP_FILE);
4846 f = fopen (name, "r");
4848 map_list_ptr->map_list_map = NULL;
4852 int dirlen = strlen (dirname);
4854 while ((ch = getc (f)) != EOF)
4857 struct file_name_map *ptr;
4861 from = read_filename_string (ch, f);
4862 while ((ch = getc (f)) != EOF && is_hor_space[ch])
4864 to = read_filename_string (ch, f);
4866 ptr = ((struct file_name_map *)
4867 xmalloc (sizeof (struct file_name_map)));
4868 ptr->map_from = from;
4870 /* Make the real filename absolute. */
4875 ptr->map_to = xmalloc (dirlen + strlen (to) + 2);
4876 strcpy (ptr->map_to, dirname);
4877 ptr->map_to[dirlen] = '/';
4878 strcpy (ptr->map_to + dirlen + 1, to);
4882 ptr->map_next = map_list_ptr->map_list_map;
4883 map_list_ptr->map_list_map = ptr;
4885 while ((ch = getc (f)) != '\n')
4892 map_list_ptr->map_list_next = map_list;
4893 map_list = map_list_ptr;
4895 return map_list_ptr->map_list_map;
4898 /* Try to open include file FILENAME. SEARCHPTR is the directory
4899 being tried from the include file search path. This function maps
4900 filenames on file systems based on information read by
4904 open_include_file (filename, searchptr)
4906 struct file_name_list *searchptr;
4908 register struct file_name_map *map;
4909 register char *from;
4912 if (searchptr && ! searchptr->got_name_map)
4914 searchptr->name_map = read_name_map (searchptr->fname
4915 ? searchptr->fname : ".");
4916 searchptr->got_name_map = 1;
4919 /* First check the mapping for the directory we are using. */
4920 if (searchptr && searchptr->name_map)
4923 if (searchptr->fname)
4924 from += strlen (searchptr->fname) + 1;
4925 for (map = searchptr->name_map; map; map = map->map_next)
4927 if (! strcmp (map->map_from, from))
4929 /* Found a match. */
4930 return open (map->map_to, O_RDONLY, 0666);
4935 /* Try to find a mapping file for the particular directory we are
4936 looking in. Thus #include <sys/types.h> will look up sys/types.h
4937 in /usr/include/header.gcc and look up types.h in
4938 /usr/include/sys/header.gcc. */
4939 p = rindex (filename, '/');
4940 #ifdef DIR_SEPARATOR
4941 if (! p) p = rindex (filename, DIR_SEPARATOR);
4943 char *tmp = rindex (filename, DIR_SEPARATOR);
4944 if (tmp != NULL && tmp > p) p = tmp;
4951 && strlen (searchptr->fname) == p - filename
4952 && ! strncmp (searchptr->fname, filename, p - filename))
4954 /* FILENAME is in SEARCHPTR, which we've already checked. */
4955 return open (filename, O_RDONLY, 0666);
4965 dir = (char *) alloca (p - filename + 1);
4966 bcopy (filename, dir, p - filename);
4967 dir[p - filename] = '\0';
4970 for (map = read_name_map (dir); map; map = map->map_next)
4971 if (! strcmp (map->map_from, from))
4972 return open (map->map_to, O_RDONLY, 0666);
4974 return open (filename, O_RDONLY, 0666);
4977 /* Process the contents of include file FNAME, already open on descriptor F,
4979 SYSTEM_HEADER_P is 1 if this file resides in any one of the known
4980 "system" include directories (as decided by the `is_system_include'
4982 DIRPTR is the link in the dir path through which this file was found,
4983 or 0 if the file name was absolute. */
4986 finclude (f, fname, op, system_header_p, dirptr)
4990 int system_header_p;
4991 struct file_name_list *dirptr;
4996 FILE_BUF *fp; /* For input stack frame */
4997 int missing_newline = 0;
4999 CHECK_DEPTH (return;);
5001 if (file_size_and_mode (f, &st_mode, &st_size) < 0)
5003 perror_with_name (fname);
5008 fp = &instack[indepth + 1];
5009 bzero ((char *) fp, sizeof (FILE_BUF));
5010 fp->nominal_fname = fp->fname = fname;
5013 fp->if_stack = if_stack;
5014 fp->system_header_p = system_header_p;
5017 if (S_ISREG (st_mode)) {
5018 fp->buf = (U_CHAR *) xmalloc (st_size + 2);
5021 /* Read the file contents, knowing that st_size is an upper bound
5022 on the number of bytes we can read. */
5023 fp->length = safe_read (f, (char *) fp->buf, st_size);
5024 if (fp->length < 0) goto nope;
5026 else if (S_ISDIR (st_mode)) {
5027 error ("directory `%s' specified in #include", fname);
5031 /* Cannot count its file size before reading.
5032 First read the entire file into heap and
5033 copy them into buffer on stack. */
5038 fp->buf = (U_CHAR *) xmalloc (bsize + 2);
5041 i = safe_read (f, (char *) fp->buf + st_size, bsize - st_size);
5043 goto nope; /* error! */
5045 if (st_size != bsize)
5046 break; /* End of file */
5048 fp->buf = (U_CHAR *) xrealloc (fp->buf, bsize + 2);
5051 fp->length = st_size;
5054 if ((fp->length > 0 && fp->buf[fp->length - 1] != '\n')
5055 /* Backslash-newline at end is not good enough. */
5056 || (fp->length > 1 && fp->buf[fp->length - 2] == '\\')) {
5057 fp->buf[fp->length++] = '\n';
5058 missing_newline = 1;
5060 fp->buf[fp->length] = '\0';
5062 /* Close descriptor now, so nesting does not use lots of descriptors. */
5065 /* Must do this before calling trigraph_pcp, so that the correct file name
5066 will be printed in warning messages. */
5069 input_file_stack_tick++;
5074 output_line_directive (fp, op, 0, enter_file);
5077 if (missing_newline)
5080 if (pedantic && missing_newline)
5081 pedwarn ("file does not end in newline");
5084 input_file_stack_tick++;
5085 output_line_directive (&instack[indepth], op, 0, leave_file);
5091 perror_with_name (fname);
5096 /* Record that inclusion of the file named FILE
5097 should be controlled by the macro named MACRO_NAME.
5098 This means that trying to include the file again
5099 will do something if that macro is defined. */
5102 record_control_macro (file, macro_name)
5106 struct file_name_list *new;
5108 for (new = all_include_files; new; new = new->next) {
5109 if (!strcmp (new->fname, file)) {
5110 new->control_macro = macro_name;
5115 /* If the file is not in all_include_files, something's wrong. */
5119 /* Maintain and search list of included files, for #import. */
5121 #define IMPORT_HASH_SIZE 31
5123 struct import_file {
5127 struct import_file *next;
5130 /* Hash table of files already included with #include or #import. */
5132 static struct import_file *import_hash_table[IMPORT_HASH_SIZE];
5134 /* Hash a file name for import_hash_table. */
5142 while (*f) val += *f++;
5143 return (val%IMPORT_HASH_SIZE);
5146 /* Search for file FILENAME in import_hash_table.
5147 Return -2 if found, either a matching name or a matching inode.
5148 Otherwise, open the file and return a file descriptor if successful
5149 or -1 if unsuccessful. */
5152 lookup_import (filename, searchptr)
5154 struct file_name_list *searchptr;
5156 struct import_file *i;
5162 hashval = import_hash (filename);
5164 /* Attempt to find file in list of already included files */
5165 i = import_hash_table[hashval];
5168 if (!strcmp (filename, i->name))
5169 return -2; /* return found */
5172 /* Open it and try a match on inode/dev */
5173 fd = open_include_file (filename, searchptr);
5177 for (h = 0; h < IMPORT_HASH_SIZE; h++) {
5178 i = import_hash_table[h];
5180 /* Compare the inode and the device.
5181 Supposedly on some systems the inode is not a scalar. */
5182 if (!bcmp ((char *) &i->inode, (char *) &sb.st_ino, sizeof (sb.st_ino))
5183 && i->dev == sb.st_dev) {
5185 return -2; /* return found */
5190 return fd; /* Not found, return open file */
5193 /* Add the file FNAME, open on descriptor FD, to import_hash_table. */
5196 add_import (fd, fname)
5200 struct import_file *i;
5204 hashval = import_hash (fname);
5206 i = (struct import_file *)xmalloc (sizeof (struct import_file));
5207 i->name = xmalloc (strlen (fname)+1);
5208 strcpy (i->name, fname);
5209 bcopy ((char *) &sb.st_ino, (char *) &i->inode, sizeof (sb.st_ino));
5211 i->next = import_hash_table[hashval];
5212 import_hash_table[hashval] = i;
5215 /* Load the specified precompiled header into core, and verify its
5216 preconditions. PCF indicates the file descriptor to read, which must
5217 be a regular file. FNAME indicates the file name of the original
5218 header. *LIMIT will be set to an address one past the end of the file.
5219 If the preconditions of the file are not satisfied, the buffer is
5220 freed and we return 0. If the preconditions are satisfied, return
5221 the address of the buffer following the preconditions. The buffer, in
5222 this case, should never be freed because various pieces of it will
5223 be referred to until all precompiled strings are output at the end of
5227 check_precompiled (pcf, fname, limit)
5241 if (file_size_and_mode (pcf, &st_mode, &st_size) < 0)
5244 if (S_ISREG (st_mode))
5246 buf = xmalloc (st_size + 2);
5247 length = safe_read (pcf, buf, st_size);
5254 if (length > 0 && buf[length-1] != '\n')
5255 buf[length++] = '\n';
5258 *limit = buf + length;
5260 /* File is in core. Check the preconditions. */
5261 if (!check_preconditions (buf))
5263 for (cp = buf; *cp; cp++)
5266 fprintf (stderr, "Using preinclude %s\n", fname);
5272 fprintf (stderr, "Cannot use preinclude %s\n", fname);
5278 /* PREC (null terminated) points to the preconditions of a
5279 precompiled header. These are a series of #define and #undef
5280 lines which must match the current contents of the hash
5283 check_preconditions (prec)
5290 lineend = index (prec, '\n');
5292 if (*prec++ != '#') {
5293 error ("Bad format encountered while reading precompiled file");
5296 if (!strncmp (prec, "define", 6)) {
5300 mdef = create_definition ((U_CHAR *) prec, (U_CHAR *) lineend, NULL_PTR);
5305 if ((hp = lookup (mdef.symnam, mdef.symlen, -1)) == NULL
5306 || (hp->type != T_MACRO && hp->type != T_CONST)
5307 || (hp->type == T_MACRO
5308 && !compare_defs (mdef.defn, hp->value.defn)
5309 && (mdef.defn->length != 2
5310 || mdef.defn->expansion[0] != '\n'
5311 || mdef.defn->expansion[1] != ' ')))
5313 } else if (!strncmp (prec, "undef", 5)) {
5318 while (is_hor_space[(U_CHAR) *prec])
5321 while (is_idchar[(U_CHAR) *prec])
5325 if (lookup ((U_CHAR *) name, len, -1))
5328 error ("Bad format encountered while reading precompiled file");
5333 /* They all passed successfully */
5337 /* Process the main body of a precompiled file. BUF points to the
5338 string section of the file, following the preconditions. LIMIT is one
5339 character past the end. NAME is the name of the file being read
5340 in. OP is the main output buffer */
5342 pcfinclude (buf, limit, name, op)
5343 U_CHAR *buf, *limit, *name;
5350 /* First in the file comes 4 bytes indicating the number of strings, */
5351 /* in network byte order. (MSB first). */
5353 nstrings = (nstrings << 8) | *cp++;
5354 nstrings = (nstrings << 8) | *cp++;
5355 nstrings = (nstrings << 8) | *cp++;
5357 /* Looping over each string... */
5358 while (nstrings--) {
5359 U_CHAR *string_start;
5360 U_CHAR *endofthiskey;
5364 /* Each string starts with a STRINGDEF structure (str), followed */
5365 /* by the text of the string (string_start) */
5367 /* First skip to a longword boundary */
5368 /* ??? Why a 4-byte boundary? On all machines? */
5369 /* NOTE: This works correctly even if HOST_WIDE_INT
5370 is narrower than a pointer.
5371 Do not try risky measures here to get another type to use!
5372 Do not include stddef.h--it will fail! */
5373 if ((HOST_WIDE_INT) cp & 3)
5374 cp += 4 - ((HOST_WIDE_INT) cp & 3);
5376 /* Now get the string. */
5377 str = (STRINGDEF *) (GENERIC_PTR) cp;
5378 string_start = cp += sizeof (STRINGDEF);
5380 for (; *cp; cp++) /* skip the string */
5383 /* We need to macro expand the string here to ensure that the
5384 proper definition environment is in place. If it were only
5385 expanded when we find out it is needed, macros necessary for
5386 its proper expansion might have had their definitions changed. */
5387 tmpbuf = expand_to_temp_buffer (string_start, cp++, 0, 0);
5388 /* Lineno is already set in the precompiled file */
5389 str->contents = tmpbuf.buf;
5390 str->len = tmpbuf.length;
5392 str->filename = name;
5393 str->output_mark = outbuf.bufp - outbuf.buf;
5396 *stringlist_tailp = str;
5397 stringlist_tailp = &str->chain;
5399 /* Next comes a fourbyte number indicating the number of keys */
5400 /* for this string. */
5402 nkeys = (nkeys << 8) | *cp++;
5403 nkeys = (nkeys << 8) | *cp++;
5404 nkeys = (nkeys << 8) | *cp++;
5406 /* If this number is -1, then the string is mandatory. */
5410 /* Otherwise, for each key, */
5411 for (; nkeys--; free (tmpbuf.buf), cp = endofthiskey + 1) {
5412 KEYDEF *kp = (KEYDEF *) (GENERIC_PTR) cp;
5415 /* It starts with a KEYDEF structure */
5416 cp += sizeof (KEYDEF);
5418 /* Find the end of the key. At the end of this for loop we
5419 advance CP to the start of the next key using this variable. */
5420 endofthiskey = cp + strlen ((char *) cp);
5423 /* Expand the key, and enter it into the hash table. */
5424 tmpbuf = expand_to_temp_buffer (cp, endofthiskey, 0, 0);
5425 tmpbuf.bufp = tmpbuf.buf;
5427 while (is_hor_space[*tmpbuf.bufp])
5429 if (!is_idstart[*tmpbuf.bufp]
5430 || tmpbuf.bufp == tmpbuf.buf + tmpbuf.length) {
5435 hp = lookup (tmpbuf.bufp, -1, -1);
5438 install (tmpbuf.bufp, -1, T_PCSTRING, (char *) kp, -1);
5440 else if (hp->type == T_PCSTRING) {
5441 kp->chain = hp->value.keydef;
5442 hp->value.keydef = kp;
5448 /* This output_line_directive serves to switch us back to the current
5449 input file in case some of these strings get output (which will
5450 result in line directives for the header file being output). */
5451 output_line_directive (&instack[indepth], op, 0, enter_file);
5454 /* Called from rescan when it hits a key for strings. Mark them all */
5455 /* used and clean up. */
5462 for (kp = hp->value.keydef; kp; kp = kp->chain)
5463 kp->str->writeflag = 1;
5467 /* Write the output, interspersing precompiled strings in their */
5468 /* appropriate places. */
5472 STRINGDEF *next_string;
5473 U_CHAR *cur_buf_loc;
5474 int line_directive_len = 80;
5475 char *line_directive = xmalloc (line_directive_len);
5478 /* In each run through the loop, either cur_buf_loc == */
5479 /* next_string_loc, in which case we print a series of strings, or */
5480 /* it is less than next_string_loc, in which case we write some of */
5482 cur_buf_loc = outbuf.buf;
5483 next_string = stringlist;
5485 while (cur_buf_loc < outbuf.bufp || next_string) {
5487 && cur_buf_loc - outbuf.buf == next_string->output_mark) {
5488 if (next_string->writeflag) {
5489 len = 4 * strlen ((char *) next_string->filename) + 32;
5490 while (len > line_directive_len)
5491 line_directive = xrealloc (line_directive,
5492 line_directive_len *= 2);
5493 sprintf (line_directive, "\n# %d ", next_string->lineno);
5494 strcpy (quote_string (line_directive + strlen (line_directive),
5495 (char *) next_string->filename),
5497 safe_write (fileno (stdout), line_directive, strlen (line_directive));
5498 safe_write (fileno (stdout),
5499 (char *) next_string->contents, next_string->len);
5501 next_string = next_string->chain;
5505 ? (next_string->output_mark
5506 - (cur_buf_loc - outbuf.buf))
5507 : outbuf.bufp - cur_buf_loc);
5509 safe_write (fileno (stdout), (char *) cur_buf_loc, len);
5513 free (line_directive);
5516 /* Pass a directive through to the output file.
5517 BUF points to the contents of the directive, as a contiguous string.
5518 LIMIT points to the first character past the end of the directive.
5519 KEYWORD is the keyword-table entry for the directive. */
5522 pass_thru_directive (buf, limit, op, keyword)
5523 U_CHAR *buf, *limit;
5525 struct directive *keyword;
5527 register unsigned keyword_length = keyword->length;
5529 check_expand (op, 1 + keyword_length + (limit - buf));
5531 bcopy (keyword->name, (char *) op->bufp, keyword_length);
5532 op->bufp += keyword_length;
5533 if (limit != buf && buf[0] != ' ')
5535 bcopy ((char *) buf, (char *) op->bufp, limit - buf);
5536 op->bufp += (limit - buf);
5539 /* Count the line we have just made in the output,
5540 to get in sync properly. */
5545 /* The arglist structure is built by do_define to tell
5546 collect_definition where the argument names begin. That
5547 is, for a define like "#define f(x,y,z) foo+x-bar*y", the arglist
5548 would contain pointers to the strings x, y, and z.
5549 Collect_definition would then build a DEFINITION node,
5550 with reflist nodes pointing to the places x, y, and z had
5551 appeared. So the arglist is just convenience data passed
5552 between these two routines. It is not kept around after
5553 the current #define has been processed and entered into the
5557 struct arglist *next;
5564 /* Create a DEFINITION node from a #define directive. Arguments are
5565 as for do_define. */
5567 create_definition (buf, limit, op)
5568 U_CHAR *buf, *limit;
5571 U_CHAR *bp; /* temp ptr into input buffer */
5572 U_CHAR *symname; /* remember where symbol name starts */
5573 int sym_length; /* and how long it is */
5574 int line = instack[indepth].lineno;
5575 char *file = instack[indepth].nominal_fname;
5579 int arglengths = 0; /* Accumulate lengths of arg names
5580 plus number of args. */
5585 while (is_hor_space[*bp])
5588 symname = bp; /* remember where it starts */
5589 sym_length = check_macro_name (bp, "macro");
5592 /* Lossage will occur if identifiers or control keywords are broken
5593 across lines using backslash. This is not the right place to take
5597 struct arglist *arg_ptrs = NULL;
5600 bp++; /* skip '(' */
5601 SKIP_WHITE_SPACE (bp);
5603 /* Loop over macro argument names. */
5604 while (*bp != ')') {
5605 struct arglist *temp;
5607 temp = (struct arglist *) alloca (sizeof (struct arglist));
5609 temp->next = arg_ptrs;
5610 temp->argno = argno++;
5611 temp->rest_args = 0;
5615 pedwarn ("another parameter follows `%s'",
5618 if (!is_idstart[*bp])
5619 pedwarn ("invalid character in macro parameter name");
5621 /* Find the end of the arg name. */
5622 while (is_idchar[*bp]) {
5624 /* do we have a "special" rest-args extension here? */
5625 if (limit - bp > REST_EXTENSION_LENGTH &&
5626 bcmp (rest_extension, bp, REST_EXTENSION_LENGTH) == 0) {
5628 temp->rest_args = 1;
5632 temp->length = bp - temp->name;
5634 bp += REST_EXTENSION_LENGTH;
5635 arglengths += temp->length + 2;
5636 SKIP_WHITE_SPACE (bp);
5637 if (temp->length == 0 || (*bp != ',' && *bp != ')')) {
5638 error ("badly punctuated parameter list in `#define'");
5643 SKIP_WHITE_SPACE (bp);
5644 /* A comma at this point can only be followed by an identifier. */
5645 if (!is_idstart[*bp]) {
5646 error ("badly punctuated parameter list in `#define'");
5651 error ("unterminated parameter list in `#define'");
5655 struct arglist *otemp;
5657 for (otemp = temp->next; otemp != NULL; otemp = otemp->next)
5658 if (temp->length == otemp->length &&
5659 bcmp (temp->name, otemp->name, temp->length) == 0) {
5660 error ("duplicate argument name `%.*s' in `#define'",
5661 temp->length, temp->name);
5667 ++bp; /* skip paren */
5668 SKIP_WHITE_SPACE (bp);
5669 /* now everything from bp before limit is the definition. */
5670 defn = collect_expansion (bp, limit, argno, arg_ptrs);
5671 defn->rest_args = rest_args;
5673 /* Now set defn->args.argnames to the result of concatenating
5674 the argument names in reverse order
5675 with comma-space between them. */
5676 defn->args.argnames = (U_CHAR *) xmalloc (arglengths + 1);
5678 struct arglist *temp;
5680 for (temp = arg_ptrs; temp; temp = temp->next) {
5681 bcopy (temp->name, &defn->args.argnames[i], temp->length);
5683 if (temp->next != 0) {
5684 defn->args.argnames[i++] = ',';
5685 defn->args.argnames[i++] = ' ';
5688 defn->args.argnames[i] = 0;
5691 /* Simple expansion or empty definition. */
5695 if (is_hor_space[*bp]) {
5697 SKIP_WHITE_SPACE (bp);
5700 case '!': case '"': case '#': case '%': case '&': case '\'':
5701 case ')': case '*': case '+': case ',': case '-': case '.':
5702 case '/': case ':': case ';': case '<': case '=': case '>':
5703 case '?': case '[': case '\\': case ']': case '^': case '{':
5704 case '|': case '}': case '~':
5705 warning ("missing white space after `#define %.*s'",
5706 sym_length, symname);
5710 pedwarn ("missing white space after `#define %.*s'",
5711 sym_length, symname);
5716 /* Now everything from bp before limit is the definition. */
5717 defn = collect_expansion (bp, limit, -1, NULL_PTR);
5718 defn->args.argnames = (U_CHAR *) "";
5724 /* OP is null if this is a predefinition */
5725 defn->predefined = !op;
5727 mdef.symnam = symname;
5728 mdef.symlen = sym_length;
5737 /* Process a #define directive.
5738 BUF points to the contents of the #define directive, as a contiguous string.
5739 LIMIT points to the first character past the end of the definition.
5740 KEYWORD is the keyword-table entry for #define. */
5743 do_define (buf, limit, op, keyword)
5744 U_CHAR *buf, *limit;
5746 struct directive *keyword;
5751 /* If this is a precompiler run (with -pcp) pass thru #define directives. */
5752 if (pcp_outfile && op)
5753 pass_thru_directive (buf, limit, op, keyword);
5755 mdef = create_definition (buf, limit, op);
5759 hashcode = hashf (mdef.symnam, mdef.symlen, HASHSIZE);
5763 if ((hp = lookup (mdef.symnam, mdef.symlen, hashcode)) != NULL) {
5765 /* Redefining a precompiled key is ok. */
5766 if (hp->type == T_PCSTRING)
5768 /* Redefining a macro is ok if the definitions are the same. */
5769 else if (hp->type == T_MACRO)
5770 ok = ! compare_defs (mdef.defn, hp->value.defn);
5771 /* Redefining a constant is ok with -D. */
5772 else if (hp->type == T_CONST)
5773 ok = ! done_initializing;
5774 /* Print the warning if it's not ok. */
5776 /* If we are passing through #define and #undef directives, do
5777 that for this re-definition now. */
5778 if (debug_output && op)
5779 pass_thru_directive (buf, limit, op, keyword);
5781 pedwarn ("`%.*s' redefined", mdef.symlen, mdef.symnam);
5782 if (hp->type == T_MACRO)
5783 pedwarn_with_file_and_line (hp->value.defn->file, hp->value.defn->line,
5784 "this is the location of the previous definition");
5786 /* Replace the old definition. */
5788 hp->value.defn = mdef.defn;
5790 /* If we are passing through #define and #undef directives, do
5791 that for this new definition now. */
5792 if (debug_output && op)
5793 pass_thru_directive (buf, limit, op, keyword);
5794 install (mdef.symnam, mdef.symlen, T_MACRO,
5795 (char *) mdef.defn, hashcode);
5806 /* Check a purported macro name SYMNAME, and yield its length.
5807 USAGE is the kind of name this is intended for. */
5810 check_macro_name (symname, usage)
5817 for (p = symname; is_idchar[*p]; p++)
5819 sym_length = p - symname;
5820 if (sym_length == 0)
5821 error ("invalid %s name", usage);
5822 else if (!is_idstart[*symname]
5823 || (sym_length == 7 && ! bcmp (symname, "defined", 7)))
5824 error ("invalid %s name `%.*s'", usage, sym_length, symname);
5829 * return zero if two DEFINITIONs are isomorphic
5832 compare_defs (d1, d2)
5833 DEFINITION *d1, *d2;
5835 register struct reflist *a1, *a2;
5836 register U_CHAR *p1 = d1->expansion;
5837 register U_CHAR *p2 = d2->expansion;
5840 if (d1->nargs != d2->nargs)
5842 if (strcmp ((char *)d1->args.argnames, (char *)d2->args.argnames))
5844 for (a1 = d1->pattern, a2 = d2->pattern; a1 && a2;
5845 a1 = a1->next, a2 = a2->next) {
5846 if (!((a1->nchars == a2->nchars && ! bcmp (p1, p2, a1->nchars))
5847 || ! comp_def_part (first, p1, a1->nchars, p2, a2->nchars, 0))
5848 || a1->argno != a2->argno
5849 || a1->stringify != a2->stringify
5850 || a1->raw_before != a2->raw_before
5851 || a1->raw_after != a2->raw_after)
5859 if (comp_def_part (first, p1, d1->length - (p1 - d1->expansion),
5860 p2, d2->length - (p2 - d2->expansion), 1))
5865 /* Return 1 if two parts of two macro definitions are effectively different.
5866 One of the parts starts at BEG1 and has LEN1 chars;
5867 the other has LEN2 chars at BEG2.
5868 Any sequence of whitespace matches any other sequence of whitespace.
5869 FIRST means these parts are the first of a macro definition;
5870 so ignore leading whitespace entirely.
5871 LAST means these parts are the last of a macro definition;
5872 so ignore trailing whitespace entirely. */
5875 comp_def_part (first, beg1, len1, beg2, len2, last)
5877 U_CHAR *beg1, *beg2;
5881 register U_CHAR *end1 = beg1 + len1;
5882 register U_CHAR *end2 = beg2 + len2;
5884 while (beg1 != end1 && is_space[*beg1]) beg1++;
5885 while (beg2 != end2 && is_space[*beg2]) beg2++;
5888 while (beg1 != end1 && is_space[end1[-1]]) end1--;
5889 while (beg2 != end2 && is_space[end2[-1]]) end2--;
5891 while (beg1 != end1 && beg2 != end2) {
5892 if (is_space[*beg1] && is_space[*beg2]) {
5893 while (beg1 != end1 && is_space[*beg1]) beg1++;
5894 while (beg2 != end2 && is_space[*beg2]) beg2++;
5895 } else if (*beg1 == *beg2) {
5899 return (beg1 != end1) || (beg2 != end2);
5902 /* Read a replacement list for a macro with parameters.
5903 Build the DEFINITION structure.
5904 Reads characters of text starting at BUF until END.
5905 ARGLIST specifies the formal parameters to look for
5906 in the text of the definition; NARGS is the number of args
5907 in that list, or -1 for a macro name that wants no argument list.
5908 MACRONAME is the macro name itself (so we can avoid recursive expansion)
5909 and NAMELEN is its length in characters.
5911 Note that comments, backslash-newlines, and leading white space
5912 have already been deleted from the argument. */
5914 /* If there is no trailing whitespace, a Newline Space is added at the end
5915 to prevent concatenation that would be contrary to the standard. */
5918 collect_expansion (buf, end, nargs, arglist)
5921 struct arglist *arglist;
5924 register U_CHAR *p, *limit, *lastp, *exp_p;
5925 struct reflist *endpat = NULL;
5926 /* Pointer to first nonspace after last ## seen. */
5928 /* Pointer to first nonspace after last single-# seen. */
5929 U_CHAR *stringify = 0;
5930 /* How those tokens were spelled. */
5931 enum sharp_token_type concat_sharp_token_type = NO_SHARP_TOKEN;
5932 enum sharp_token_type stringify_sharp_token_type = NO_SHARP_TOKEN;
5934 int expected_delimiter = '\0';
5936 /* Scan thru the replacement list, ignoring comments and quoted
5937 strings, picking up on the macro calls. It does a linear search
5938 thru the arg list on every potential symbol. Profiling might say
5939 that something smarter should happen. */
5944 /* Find the beginning of the trailing whitespace. */
5947 while (p < limit && is_space[limit[-1]]) limit--;
5949 /* Allocate space for the text in the macro definition.
5950 Each input char may or may not need 1 byte,
5951 so this is an upper bound.
5952 The extra 3 are for invented trailing newline-marker and final null. */
5953 maxsize = (sizeof (DEFINITION)
5955 defn = (DEFINITION *) xcalloc (1, maxsize);
5957 defn->nargs = nargs;
5958 exp_p = defn->expansion = (U_CHAR *) defn + sizeof (DEFINITION);
5963 : p[0] == '%' && p[1] == ':' && p[2] == '%' && p[3] == ':') {
5964 error ("`##' at start of macro definition");
5965 p += p[0] == '#' ? 2 : 4;
5968 /* Process the main body of the definition. */
5970 int skipped_arg = 0;
5971 register U_CHAR c = *p++;
5979 if (expected_delimiter != '\0') {
5980 if (c == expected_delimiter)
5981 expected_delimiter = '\0';
5983 expected_delimiter = c;
5987 if (p < limit && expected_delimiter) {
5988 /* In a string, backslash goes through
5989 and makes next char ordinary. */
5995 if (!expected_delimiter && *p == ':') {
5996 /* %: is not a digraph if preceded by an odd number of '<'s. */
5998 while (buf < p0 && p0[-1] == '<')
6001 /* Treat %:%: as ## and %: as #. */
6002 if (p[1] == '%' && p[2] == ':') {
6004 goto sharp_sharp_token;
6015 /* # is ordinary inside a string. */
6016 if (expected_delimiter)
6020 /* ##: concatenate preceding and following tokens. */
6021 /* Take out the first #, discard preceding whitespace. */
6023 while (exp_p > lastp && is_hor_space[exp_p[-1]])
6025 /* Skip the second #. */
6027 concat_sharp_token_type = c;
6028 if (is_hor_space[*p]) {
6029 concat_sharp_token_type = c + 1;
6031 SKIP_WHITE_SPACE (p);
6035 error ("`##' at end of macro definition");
6036 } else if (nargs >= 0) {
6037 /* Single #: stringify following argument ref.
6038 Don't leave the # in the expansion. */
6041 stringify_sharp_token_type = c;
6042 if (is_hor_space[*p]) {
6043 stringify_sharp_token_type = c + 1;
6045 SKIP_WHITE_SPACE (p);
6047 if (! is_idstart[*p] || nargs == 0)
6048 error ("`#' operator is not followed by a macro argument name");
6055 /* In -traditional mode, recognize arguments inside strings and
6056 and character constants, and ignore special properties of #.
6057 Arguments inside strings are considered "stringified", but no
6058 extra quote marks are supplied. */
6062 if (expected_delimiter != '\0') {
6063 if (c == expected_delimiter)
6064 expected_delimiter = '\0';
6066 expected_delimiter = c;
6070 /* Backslash quotes delimiters and itself, but not macro args. */
6071 if (expected_delimiter != 0 && p < limit
6072 && (*p == expected_delimiter || *p == '\\')) {
6079 if (expected_delimiter != '\0') /* No comments inside strings. */
6082 /* If we find a comment that wasn't removed by handle_directive,
6083 this must be -traditional. So replace the comment with
6087 while (p < limit && !(p[-2] == '*' && p[-1] == '/'))
6090 /* Mark this as a concatenation-point, as if it had been ##. */
6098 /* Handle the start of a symbol. */
6099 if (is_idchar[c] && nargs > 0) {
6100 U_CHAR *id_beg = p - 1;
6104 while (p != limit && is_idchar[*p]) p++;
6105 id_len = p - id_beg;
6107 if (is_idstart[c]) {
6108 register struct arglist *arg;
6110 for (arg = arglist; arg != NULL; arg = arg->next) {
6111 struct reflist *tpat;
6113 if (arg->name[0] == c
6114 && arg->length == id_len
6115 && bcmp (arg->name, id_beg, id_len) == 0) {
6116 enum sharp_token_type tpat_stringify;
6117 if (expected_delimiter) {
6118 if (warn_stringify) {
6120 warning ("macro argument `%.*s' is stringified.",
6123 warning ("macro arg `%.*s' would be stringified with -traditional.",
6127 /* If ANSI, don't actually substitute inside a string. */
6130 tpat_stringify = SHARP_TOKEN;
6133 = (stringify == id_beg
6134 ? stringify_sharp_token_type : NO_SHARP_TOKEN);
6136 /* make a pat node for this arg and append it to the end of
6138 tpat = (struct reflist *) xmalloc (sizeof (struct reflist));
6141 = concat == id_beg ? concat_sharp_token_type : NO_SHARP_TOKEN;
6142 tpat->raw_after = NO_SHARP_TOKEN;
6143 tpat->rest_args = arg->rest_args;
6144 tpat->stringify = tpat_stringify;
6147 defn->pattern = tpat;
6149 endpat->next = tpat;
6152 tpat->argno = arg->argno;
6153 tpat->nchars = exp_p - lastp;
6155 register U_CHAR *p1 = p;
6156 SKIP_WHITE_SPACE (p1);
6159 : p1[0]=='%' && p1[1]==':' && p1[2]=='%' && p1[3]==':')
6160 tpat->raw_after = p1[0] + (p != p1);
6162 lastp = exp_p; /* place to start copying from next time */
6169 /* If this was not a macro arg, copy it into the expansion. */
6170 if (! skipped_arg) {
6171 register U_CHAR *lim1 = p;
6175 if (stringify == id_beg)
6176 error ("`#' operator should be followed by a macro argument name");
6181 if (!traditional && expected_delimiter == 0) {
6182 /* If ANSI, put in a newline-space marker to prevent token pasting.
6183 But not if "inside a string" (which in ANSI mode happens only for
6191 defn->length = exp_p - defn->expansion;
6193 /* Crash now if we overrun the allocated size. */
6194 if (defn->length + 1 > maxsize)
6198 /* This isn't worth the time it takes. */
6199 /* give back excess storage */
6200 defn->expansion = (U_CHAR *) xrealloc (defn->expansion, defn->length + 1);
6207 do_assert (buf, limit, op, keyword)
6208 U_CHAR *buf, *limit;
6210 struct directive *keyword;
6212 U_CHAR *bp; /* temp ptr into input buffer */
6213 U_CHAR *symname; /* remember where symbol name starts */
6214 int sym_length; /* and how long it is */
6215 struct arglist *tokens = NULL;
6217 if (pedantic && done_initializing && !instack[indepth].system_header_p)
6218 pedwarn ("ANSI C does not allow `#assert'");
6222 while (is_hor_space[*bp])
6225 symname = bp; /* remember where it starts */
6226 sym_length = check_macro_name (bp, "assertion");
6228 /* #define doesn't do this, but we should. */
6229 SKIP_WHITE_SPACE (bp);
6231 /* Lossage will occur if identifiers or control tokens are broken
6232 across lines using backslash. This is not the right place to take
6236 error ("missing token-sequence in `#assert'");
6243 bp++; /* skip '(' */
6244 SKIP_WHITE_SPACE (bp);
6246 tokens = read_token_list (&bp, limit, &error_flag);
6250 error ("empty token-sequence in `#assert'");
6254 ++bp; /* skip paren */
6255 SKIP_WHITE_SPACE (bp);
6258 /* If this name isn't already an assertion name, make it one.
6259 Error if it was already in use in some other way. */
6262 ASSERTION_HASHNODE *hp;
6263 int hashcode = hashf (symname, sym_length, ASSERTION_HASHSIZE);
6264 struct tokenlist_list *value
6265 = (struct tokenlist_list *) xmalloc (sizeof (struct tokenlist_list));
6267 hp = assertion_lookup (symname, sym_length, hashcode);
6269 if (sym_length == 7 && ! bcmp (symname, "defined", 7))
6270 error ("`defined' redefined as assertion");
6271 hp = assertion_install (symname, sym_length, hashcode);
6274 /* Add the spec'd token-sequence to the list of such. */
6275 value->tokens = tokens;
6276 value->next = hp->value;
6284 do_unassert (buf, limit, op, keyword)
6285 U_CHAR *buf, *limit;
6287 struct directive *keyword;
6289 U_CHAR *bp; /* temp ptr into input buffer */
6290 U_CHAR *symname; /* remember where symbol name starts */
6291 int sym_length; /* and how long it is */
6293 struct arglist *tokens = NULL;
6294 int tokens_specified = 0;
6296 if (pedantic && done_initializing && !instack[indepth].system_header_p)
6297 pedwarn ("ANSI C does not allow `#unassert'");
6301 while (is_hor_space[*bp])
6304 symname = bp; /* remember where it starts */
6305 sym_length = check_macro_name (bp, "assertion");
6307 /* #define doesn't do this, but we should. */
6308 SKIP_WHITE_SPACE (bp);
6310 /* Lossage will occur if identifiers or control tokens are broken
6311 across lines using backslash. This is not the right place to take
6317 bp++; /* skip '(' */
6318 SKIP_WHITE_SPACE (bp);
6320 tokens = read_token_list (&bp, limit, &error_flag);
6324 error ("empty token list in `#unassert'");
6328 tokens_specified = 1;
6330 ++bp; /* skip paren */
6331 SKIP_WHITE_SPACE (bp);
6335 ASSERTION_HASHNODE *hp;
6336 int hashcode = hashf (symname, sym_length, ASSERTION_HASHSIZE);
6337 struct tokenlist_list *tail, *prev;
6339 hp = assertion_lookup (symname, sym_length, hashcode);
6343 /* If no token list was specified, then eliminate this assertion
6345 if (! tokens_specified) {
6346 struct tokenlist_list *next;
6347 for (tail = hp->value; tail; tail = next) {
6349 free_token_list (tail->tokens);
6352 delete_assertion (hp);
6354 /* If a list of tokens was given, then delete any matching list. */
6359 struct tokenlist_list *next = tail->next;
6360 if (compare_token_lists (tail->tokens, tokens)) {
6364 hp->value = tail->next;
6365 free_token_list (tail->tokens);
6378 /* Test whether there is an assertion named NAME
6379 and optionally whether it has an asserted token list TOKENS.
6380 NAME is not null terminated; its length is SYM_LENGTH.
6381 If TOKENS_SPECIFIED is 0, then don't check for any token list. */
6384 check_assertion (name, sym_length, tokens_specified, tokens)
6387 int tokens_specified;
6388 struct arglist *tokens;
6390 ASSERTION_HASHNODE *hp;
6391 int hashcode = hashf (name, sym_length, ASSERTION_HASHSIZE);
6393 if (pedantic && !instack[indepth].system_header_p)
6394 pedwarn ("ANSI C does not allow testing assertions");
6396 hp = assertion_lookup (name, sym_length, hashcode);
6398 /* It is not an assertion; just return false. */
6401 /* If no token list was specified, then value is 1. */
6402 if (! tokens_specified)
6406 struct tokenlist_list *tail;
6410 /* If a list of tokens was given,
6411 then succeed if the assertion records a matching list. */
6414 if (compare_token_lists (tail->tokens, tokens))
6419 /* Fail if the assertion has no matching list. */
6424 /* Compare two lists of tokens for equality including order of tokens. */
6427 compare_token_lists (l1, l2)
6428 struct arglist *l1, *l2;
6431 if (l1->length != l2->length)
6433 if (bcmp (l1->name, l2->name, l1->length))
6439 /* Succeed if both lists end at the same time. */
6443 /* Read a space-separated list of tokens ending in a close parenthesis.
6444 Return a list of strings, in the order they were written.
6445 (In case of error, return 0 and store -1 in *ERROR_FLAG.)
6446 Parse the text starting at *BPP, and update *BPP.
6447 Don't parse beyond LIMIT. */
6449 static struct arglist *
6450 read_token_list (bpp, limit, error_flag)
6455 struct arglist *token_ptrs = 0;
6461 /* Loop over the assertion value tokens. */
6463 struct arglist *temp;
6467 /* Find the end of the token. */
6471 } else if (*bp == ')') {
6476 } else if (*bp == '"' || *bp == '\'')
6477 bp = skip_quoted_string (bp, limit, 0, NULL_PTR, NULL_PTR, &eofp);
6479 while (! is_hor_space[*bp] && *bp != '(' && *bp != ')'
6480 && *bp != '"' && *bp != '\'' && bp != limit)
6483 temp = (struct arglist *) xmalloc (sizeof (struct arglist));
6484 temp->name = (U_CHAR *) xmalloc (bp - beg + 1);
6485 bcopy ((char *) beg, (char *) temp->name, bp - beg);
6486 temp->name[bp - beg] = 0;
6487 temp->next = token_ptrs;
6489 temp->length = bp - beg;
6491 SKIP_WHITE_SPACE (bp);
6494 error ("unterminated token sequence in `#assert' or `#unassert'");
6501 /* We accumulated the names in reverse order.
6502 Now reverse them to get the proper order. */
6504 register struct arglist *prev = 0, *this, *next;
6505 for (this = token_ptrs; this; this = next) {
6515 free_token_list (tokens)
6516 struct arglist *tokens;
6519 struct arglist *next = tokens->next;
6520 free (tokens->name);
6527 * Install a name in the assertion hash table.
6529 * If LEN is >= 0, it is the length of the name.
6530 * Otherwise, compute the length by scanning the entire name.
6532 * If HASH is >= 0, it is the precomputed hash code.
6533 * Otherwise, compute the hash code.
6535 static ASSERTION_HASHNODE *
6536 assertion_install (name, len, hash)
6541 register ASSERTION_HASHNODE *hp;
6542 register int i, bucket;
6543 register U_CHAR *p, *q;
6545 i = sizeof (ASSERTION_HASHNODE) + len + 1;
6546 hp = (ASSERTION_HASHNODE *) xmalloc (i);
6548 hp->bucket_hdr = &assertion_hashtab[bucket];
6549 hp->next = assertion_hashtab[bucket];
6550 assertion_hashtab[bucket] = hp;
6552 if (hp->next != NULL)
6553 hp->next->prev = hp;
6556 hp->name = ((U_CHAR *) hp) + sizeof (ASSERTION_HASHNODE);
6559 for (i = 0; i < len; i++)
6566 * find the most recent hash node for name name (ending with first
6567 * non-identifier char) installed by install
6569 * If LEN is >= 0, it is the length of the name.
6570 * Otherwise, compute the length by scanning the entire name.
6572 * If HASH is >= 0, it is the precomputed hash code.
6573 * Otherwise, compute the hash code.
6575 static ASSERTION_HASHNODE *
6576 assertion_lookup (name, len, hash)
6581 register ASSERTION_HASHNODE *bucket;
6583 bucket = assertion_hashtab[hash];
6585 if (bucket->length == len && bcmp (bucket->name, name, len) == 0)
6587 bucket = bucket->next;
6593 delete_assertion (hp)
6594 ASSERTION_HASHNODE *hp;
6597 if (hp->prev != NULL)
6598 hp->prev->next = hp->next;
6599 if (hp->next != NULL)
6600 hp->next->prev = hp->prev;
6602 /* make sure that the bucket chain header that
6603 the deleted guy was on points to the right thing afterwards. */
6604 if (hp == *hp->bucket_hdr)
6605 *hp->bucket_hdr = hp->next;
6611 * interpret #line directive. Remembers previously seen fnames
6612 * in its very own hash table.
6614 #define FNAME_HASHSIZE 37
6617 do_line (buf, limit, op, keyword)
6618 U_CHAR *buf, *limit;
6620 struct directive *keyword;
6622 register U_CHAR *bp;
6623 FILE_BUF *ip = &instack[indepth];
6626 enum file_change_code file_change = same_file;
6628 /* Expand any macros. */
6629 tem = expand_to_temp_buffer (buf, limit, 0, 0);
6631 /* Point to macroexpanded line, which is null-terminated now. */
6633 SKIP_WHITE_SPACE (bp);
6635 if (!isdigit (*bp)) {
6636 error ("invalid format `#line' directive");
6640 /* The Newline at the end of this line remains to be processed.
6641 To put the next line at the specified line number,
6642 we must store a line number now that is one less. */
6643 new_lineno = atoi ((char *) bp) - 1;
6645 /* NEW_LINENO is one less than the actual line number here. */
6646 if (pedantic && new_lineno < 0)
6647 pedwarn ("line number out of range in `#line' directive");
6649 /* skip over the line number. */
6650 while (isdigit (*bp))
6653 #if 0 /* #line 10"foo.c" is supposed to be allowed. */
6654 if (*bp && !is_space[*bp]) {
6655 error ("invalid format `#line' directive");
6660 SKIP_WHITE_SPACE (bp);
6663 static HASHNODE *fname_table[FNAME_HASHSIZE];
6664 HASHNODE *hp, **hash_bucket;
6670 /* Turn the file name, which is a character string literal,
6671 into a null-terminated string. Do this in place. */
6674 switch ((*p++ = *bp++)) {
6676 error ("invalid format `#line' directive");
6681 char *bpc = (char *) bp;
6682 int c = parse_escape (&bpc);
6683 bp = (U_CHAR *) bpc;
6696 fname_length = p - fname;
6698 SKIP_WHITE_SPACE (bp);
6701 pedwarn ("garbage at end of `#line' directive");
6703 file_change = enter_file;
6704 else if (*bp == '2')
6705 file_change = leave_file;
6706 else if (*bp == '3')
6707 ip->system_header_p = 1;
6708 else if (*bp == '4')
6709 ip->system_header_p = 2;
6711 error ("invalid format `#line' directive");
6716 SKIP_WHITE_SPACE (bp);
6718 ip->system_header_p = 1;
6720 SKIP_WHITE_SPACE (bp);
6723 ip->system_header_p = 2;
6725 SKIP_WHITE_SPACE (bp);
6728 error ("invalid format `#line' directive");
6734 &fname_table[hashf (fname, fname_length, FNAME_HASHSIZE)];
6735 for (hp = *hash_bucket; hp != NULL; hp = hp->next)
6736 if (hp->length == fname_length &&
6737 bcmp (hp->value.cpval, fname, fname_length) == 0) {
6738 ip->nominal_fname = hp->value.cpval;
6742 /* Didn't find it; cons up a new one. */
6743 hp = (HASHNODE *) xcalloc (1, sizeof (HASHNODE) + fname_length + 1);
6744 hp->next = *hash_bucket;
6747 hp->length = fname_length;
6748 ip->nominal_fname = hp->value.cpval = ((char *) hp) + sizeof (HASHNODE);
6749 bcopy (fname, hp->value.cpval, fname_length);
6752 error ("invalid format `#line' directive");
6756 ip->lineno = new_lineno;
6757 output_line_directive (ip, op, 0, file_change);
6758 check_expand (op, ip->length - (ip->bufp - ip->buf));
6763 * remove the definition of a symbol from the symbol table.
6764 * according to un*x /lib/cpp, it is not an error to undef
6765 * something that has no definitions, so it isn't one here either.
6769 do_undef (buf, limit, op, keyword)
6770 U_CHAR *buf, *limit;
6772 struct directive *keyword;
6776 U_CHAR *orig_buf = buf;
6778 /* If this is a precompiler run (with -pcp) pass thru #undef directives. */
6779 if (pcp_outfile && op)
6780 pass_thru_directive (buf, limit, op, keyword);
6782 SKIP_WHITE_SPACE (buf);
6783 sym_length = check_macro_name (buf, "macro");
6785 while ((hp = lookup (buf, sym_length, -1)) != NULL) {
6786 /* If we are generating additional info for debugging (with -g) we
6787 need to pass through all effective #undef directives. */
6788 if (debug_output && op)
6789 pass_thru_directive (orig_buf, limit, op, keyword);
6790 if (hp->type != T_MACRO)
6791 warning ("undefining `%s'", hp->name);
6797 SKIP_WHITE_SPACE (buf);
6799 pedwarn ("garbage after `#undef' directive");
6805 * Report an error detected by the program we are processing.
6806 * Use the text of the line in the error message.
6807 * (We use error because it prints the filename & line#.)
6811 do_error (buf, limit, op, keyword)
6812 U_CHAR *buf, *limit;
6814 struct directive *keyword;
6816 int length = limit - buf;
6817 U_CHAR *copy = (U_CHAR *) xmalloc (length + 1);
6818 bcopy ((char *) buf, (char *) copy, length);
6820 SKIP_WHITE_SPACE (copy);
6821 error ("#error %s", copy);
6826 * Report a warning detected by the program we are processing.
6827 * Use the text of the line in the warning message, then continue.
6828 * (We use error because it prints the filename & line#.)
6832 do_warning (buf, limit, op, keyword)
6833 U_CHAR *buf, *limit;
6835 struct directive *keyword;
6837 int length = limit - buf;
6838 U_CHAR *copy = (U_CHAR *) xmalloc (length + 1);
6839 bcopy ((char *) buf, (char *) copy, length);
6841 SKIP_WHITE_SPACE (copy);
6842 warning ("#warning %s", copy);
6846 /* Remember the name of the current file being read from so that we can
6847 avoid ever including it again. */
6853 FILE_BUF *ip = NULL;
6855 for (i = indepth; i >= 0; i--)
6856 if (instack[i].fname != NULL) {
6862 struct file_name_list *new;
6864 new = (struct file_name_list *) xmalloc (sizeof (struct file_name_list));
6865 new->next = dont_repeat_files;
6866 dont_repeat_files = new;
6867 new->fname = savestring (ip->fname);
6868 new->control_macro = 0;
6869 new->got_name_map = 0;
6870 new->c_system_include_path = 0;
6874 /* #ident has already been copied to the output file, so just ignore it. */
6877 do_ident (buf, limit, op, keyword)
6878 U_CHAR *buf, *limit;
6880 struct directive *keyword;
6885 /* Allow #ident in system headers, since that's not user's fault. */
6886 if (pedantic && !instack[indepth].system_header_p)
6887 pedwarn ("ANSI C does not allow `#ident'");
6889 trybuf = expand_to_temp_buffer (buf, limit, 0, 0);
6890 buf = (U_CHAR *) alloca (trybuf.bufp - trybuf.buf + 1);
6891 bcopy ((char *) trybuf.buf, (char *) buf, trybuf.bufp - trybuf.buf);
6892 limit = buf + (trybuf.bufp - trybuf.buf);
6893 len = (limit - buf);
6896 /* Output directive name. */
6897 check_expand (op, 7);
6898 bcopy ("#ident ", (char *) op->bufp, 7);
6901 /* Output the expanded argument line. */
6902 check_expand (op, len);
6903 bcopy ((char *) buf, (char *) op->bufp, len);
6909 /* #pragma and its argument line have already been copied to the output file.
6910 Just check for some recognized pragmas that need validation here. */
6913 do_pragma (buf, limit, op, keyword)
6914 U_CHAR *buf, *limit;
6916 struct directive *keyword;
6918 SKIP_WHITE_SPACE (buf);
6919 if (!strncmp ((char *) buf, "once", 4)) {
6920 /* Allow #pragma once in system headers, since that's not the user's
6922 if (!instack[indepth].system_header_p)
6923 warning ("`#pragma once' is obsolete");
6927 if (!strncmp ((char *) buf, "implementation", 14)) {
6928 /* Be quiet about `#pragma implementation' for a file only if it hasn't
6929 been included yet. */
6930 struct file_name_list *ptr;
6931 U_CHAR *p = buf + 14, *fname, *inc_fname;
6932 SKIP_WHITE_SPACE (p);
6933 if (*p == '\n' || *p != '\"')
6937 if ((p = (U_CHAR *) index ((char *) fname, '\"')))
6940 for (ptr = all_include_files; ptr; ptr = ptr->next) {
6941 inc_fname = (U_CHAR *) rindex (ptr->fname, '/');
6942 inc_fname = inc_fname ? inc_fname + 1 : (U_CHAR *) ptr->fname;
6943 if (inc_fname && !strcmp ((char *) inc_fname, (char *) fname))
6944 warning ("`#pragma implementation' for `%s' appears after file is included",
6953 /* This was a fun hack, but #pragma seems to start to be useful.
6954 By failing to recognize it, we pass it through unchanged to cc1. */
6957 * the behavior of the #pragma directive is implementation defined.
6958 * this implementation defines it as follows.
6965 if (open ("/dev/tty", O_RDONLY, 0666) != 0)
6968 if (open ("/dev/tty", O_WRONLY, 0666) != 1)
6970 execl ("/usr/games/hack", "#pragma", 0);
6971 execl ("/usr/games/rogue", "#pragma", 0);
6972 execl ("/usr/new/emacs", "-f", "hanoi", "9", "-kill", 0);
6973 execl ("/usr/local/emacs", "-f", "hanoi", "9", "-kill", 0);
6975 fatal ("You are in a maze of twisty compiler features, all different");
6979 #ifdef SCCS_DIRECTIVE
6981 /* Just ignore #sccs, on systems where we define it at all. */
6984 do_sccs (buf, limit, op, keyword)
6985 U_CHAR *buf, *limit;
6987 struct directive *keyword;
6990 pedwarn ("ANSI C does not allow `#sccs'");
6994 #endif /* defined (SCCS_DIRECTIVE) */
6997 * handle #if directive by
6998 * 1) inserting special `defined' keyword into the hash table
6999 * that gets turned into 0 or 1 by special_symbol (thus,
7000 * if the luser has a symbol called `defined' already, it won't
7001 * work inside the #if directive)
7002 * 2) rescan the input into a temporary output buffer
7003 * 3) pass the output buffer to the yacc parser and collect a value
7004 * 4) clean up the mess left from steps 1 and 2.
7005 * 5) call conditional_skip to skip til the next #endif (etc.),
7006 * or not, depending on the value from step 3.
7010 do_if (buf, limit, op, keyword)
7011 U_CHAR *buf, *limit;
7013 struct directive *keyword;
7015 HOST_WIDE_INT value;
7016 FILE_BUF *ip = &instack[indepth];
7018 value = eval_if_expression (buf, limit - buf);
7019 conditional_skip (ip, value == 0, T_IF, NULL_PTR, op);
7024 * handle a #elif directive by not changing if_stack either.
7025 * see the comment above do_else.
7029 do_elif (buf, limit, op, keyword)
7030 U_CHAR *buf, *limit;
7032 struct directive *keyword;
7034 HOST_WIDE_INT value;
7035 FILE_BUF *ip = &instack[indepth];
7037 if (if_stack == instack[indepth].if_stack) {
7038 error ("`#elif' not within a conditional");
7041 if (if_stack->type != T_IF && if_stack->type != T_ELIF) {
7042 error ("`#elif' after `#else'");
7043 fprintf (stderr, " (matches line %d", if_stack->lineno);
7044 if (if_stack->fname != NULL && ip->fname != NULL &&
7045 strcmp (if_stack->fname, ip->nominal_fname) != 0)
7046 fprintf (stderr, ", file %s", if_stack->fname);
7047 fprintf (stderr, ")\n");
7049 if_stack->type = T_ELIF;
7052 if (if_stack->if_succeeded)
7053 skip_if_group (ip, 0, op);
7055 value = eval_if_expression (buf, limit - buf);
7057 skip_if_group (ip, 0, op);
7059 ++if_stack->if_succeeded; /* continue processing input */
7060 output_line_directive (ip, op, 1, same_file);
7067 * evaluate a #if expression in BUF, of length LENGTH,
7068 * then parse the result as a C expression and return the value as an int.
7070 static HOST_WIDE_INT
7071 eval_if_expression (buf, length)
7076 HASHNODE *save_defined;
7077 HOST_WIDE_INT value;
7079 save_defined = install ((U_CHAR *) "defined", -1, T_SPEC_DEFINED,
7082 temp_obuf = expand_to_temp_buffer (buf, buf + length, 0, 1);
7084 delete_macro (save_defined); /* clean up special symbol */
7086 value = parse_c_expression ((char *) temp_obuf.buf);
7088 free (temp_obuf.buf);
7094 * routine to handle ifdef/ifndef. Try to look up the symbol,
7095 * then do or don't skip to the #endif/#else/#elif depending
7096 * on what directive is actually being processed.
7100 do_xifdef (buf, limit, op, keyword)
7101 U_CHAR *buf, *limit;
7103 struct directive *keyword;
7106 FILE_BUF *ip = &instack[indepth];
7108 int start_of_file = 0;
7109 U_CHAR *control_macro = 0;
7111 /* Detect a #ifndef at start of file (not counting comments). */
7112 if (ip->fname != 0 && keyword->type == T_IFNDEF) {
7113 U_CHAR *p = ip->buf;
7114 while (p != directive_start) {
7118 /* Make no special provision for backslash-newline here; this is
7119 slower if backslash-newlines are present, but it's correct,
7120 and it's not worth it to tune for the rare backslash-newline. */
7122 && (*p == '*' || (cplusplus_comments && *p == '/'))) {
7123 /* Skip this comment. */
7125 U_CHAR *save_bufp = ip->bufp;
7127 p = skip_to_end_of_comment (ip, &junk, 1);
7128 ip->bufp = save_bufp;
7133 /* If we get here, this conditional is the beginning of the file. */
7138 /* Discard leading and trailing whitespace. */
7139 SKIP_WHITE_SPACE (buf);
7140 while (limit != buf && is_hor_space[limit[-1]]) limit--;
7142 /* Find the end of the identifier at the beginning. */
7143 for (end = buf; is_idchar[*end]; end++);
7146 skip = (keyword->type == T_IFDEF);
7148 pedwarn (end == limit ? "`#%s' with no argument"
7149 : "`#%s' argument starts with punctuation",
7154 if (pedantic && buf[0] >= '0' && buf[0] <= '9')
7155 pedwarn ("`#%s' argument starts with a digit", keyword->name);
7156 else if (end != limit && !traditional)
7157 pedwarn ("garbage at end of `#%s' argument", keyword->name);
7159 hp = lookup (buf, end-buf, -1);
7162 /* Output a precondition for this macro. */
7164 (hp->type == T_CONST
7165 || (hp->type == T_MACRO && hp->value.defn->predefined)))
7166 fprintf (pcp_outfile, "#define %s\n", hp->name);
7169 fprintf (pcp_outfile, "#undef ");
7170 while (is_idchar[*cp]) /* Ick! */
7171 fputc (*cp++, pcp_outfile);
7172 putc ('\n', pcp_outfile);
7176 skip = (hp == NULL) ^ (keyword->type == T_IFNDEF);
7177 if (start_of_file && !skip) {
7178 control_macro = (U_CHAR *) xmalloc (end - buf + 1);
7179 bcopy ((char *) buf, (char *) control_macro, end - buf);
7180 control_macro[end - buf] = 0;
7184 conditional_skip (ip, skip, T_IF, control_macro, op);
7188 /* Push TYPE on stack; then, if SKIP is nonzero, skip ahead.
7189 If this is a #ifndef starting at the beginning of a file,
7190 CONTROL_MACRO is the macro name tested by the #ifndef.
7191 Otherwise, CONTROL_MACRO is 0. */
7194 conditional_skip (ip, skip, type, control_macro, op)
7197 enum node_type type;
7198 U_CHAR *control_macro;
7201 IF_STACK_FRAME *temp;
7203 temp = (IF_STACK_FRAME *) xcalloc (1, sizeof (IF_STACK_FRAME));
7204 temp->fname = ip->nominal_fname;
7205 temp->lineno = ip->lineno;
7206 temp->next = if_stack;
7207 temp->control_macro = control_macro;
7210 if_stack->type = type;
7213 skip_if_group (ip, 0, op);
7216 ++if_stack->if_succeeded;
7217 output_line_directive (ip, &outbuf, 1, same_file);
7222 * skip to #endif, #else, or #elif. adjust line numbers, etc.
7223 * leaves input ptr at the sharp sign found.
7224 * If ANY is nonzero, return at next directive of any sort.
7227 skip_if_group (ip, any, op)
7232 register U_CHAR *bp = ip->bufp, *cp;
7233 register U_CHAR *endb = ip->buf + ip->length;
7234 struct directive *kt;
7235 IF_STACK_FRAME *save_if_stack = if_stack; /* don't pop past here */
7236 U_CHAR *beg_of_line = bp;
7237 register int ident_length;
7238 U_CHAR *ident, *after_ident;
7239 /* Save info about where the group starts. */
7240 U_CHAR *beg_of_group = bp;
7241 int beg_lineno = ip->lineno;
7243 if (output_conditionals && op != 0) {
7244 char *ptr = "#failed\n";
7245 int len = strlen (ptr);
7247 if (op->bufp > op->buf && op->bufp[-1] != '\n')
7252 check_expand (op, len);
7253 bcopy (ptr, (char *) op->bufp, len);
7256 output_line_directive (ip, op, 1, 0);
7261 case '/': /* possible comment */
7262 if (*bp == '\\' && bp[1] == '\n')
7265 || (cplusplus_comments && *bp == '/')) {
7267 bp = skip_to_end_of_comment (ip, &ip->lineno, 0);
7272 bp = skip_quoted_string (bp - 1, endb, ip->lineno, &ip->lineno,
7273 NULL_PTR, NULL_PTR);
7276 /* Char after backslash loses its special meaning. */
7279 ++ip->lineno; /* But do update the line-count. */
7288 if (beg_of_line == 0 || traditional)
7291 while (bp[0] == '\\' && bp[1] == '\n')
7297 /* # keyword: a # must be first nonblank char on the line */
7298 if (beg_of_line == 0)
7302 /* Scan from start of line, skipping whitespace, comments
7303 and backslash-newlines, and see if we reach this #.
7304 If not, this # is not special. */
7306 /* If -traditional, require # to be at beginning of line. */
7309 if (is_hor_space[*bp])
7311 else if (*bp == '\\' && bp[1] == '\n')
7313 else if (*bp == '/' && bp[1] == '*') {
7315 while (!(*bp == '*' && bp[1] == '/'))
7319 /* There is no point in trying to deal with C++ // comments here,
7320 because if there is one, then this # must be part of the
7321 comment and we would never reach here. */
7325 if (bp != ip->bufp) {
7326 bp = ip->bufp + 1; /* Reset bp to after the #. */
7330 bp = ip->bufp + 1; /* Point after the '#' */
7331 if (ip->bufp[0] == '%') {
7332 /* Skip past the ':' again. */
7333 while (*bp == '\\') {
7340 /* Skip whitespace and \-newline. */
7342 if (is_hor_space[*bp])
7344 else if (*bp == '\\' && bp[1] == '\n')
7346 else if (*bp == '/' && bp[1] == '*') {
7348 while (!(*bp == '*' && bp[1] == '/')) {
7354 } else if (cplusplus_comments && *bp == '/' && bp[1] == '/') {
7356 while (bp[-1] == '\\' || *bp != '\n') {
7367 /* Now find end of directive name.
7368 If we encounter a backslash-newline, exchange it with any following
7369 symbol-constituents so that we end up with a contiguous name. */
7375 if (*bp == '\\' && bp[1] == '\n')
7376 name_newline_fix (bp);
7382 ident_length = bp - cp;
7386 /* A line of just `#' becomes blank. */
7388 if (ident_length == 0 && *after_ident == '\n') {
7392 if (ident_length == 0 || !is_idstart[*ident]) {
7394 while (is_idchar[*p]) {
7395 if (*p < '0' || *p > '9')
7399 /* Handle # followed by a line number. */
7400 if (p != ident && !is_idchar[*p]) {
7402 pedwarn ("`#' followed by integer");
7406 /* Avoid error for `###' and similar cases unless -pedantic. */
7408 while (*p == '#' || is_hor_space[*p]) p++;
7410 if (pedantic && !lang_asm)
7411 pedwarn ("invalid preprocessing directive");
7416 if (!lang_asm && pedantic)
7417 pedwarn ("invalid preprocessing directive name");
7421 for (kt = directive_table; kt->length >= 0; kt++) {
7422 IF_STACK_FRAME *temp;
7423 if (ident_length == kt->length
7424 && bcmp (cp, kt->name, kt->length) == 0) {
7425 /* If we are asked to return on next directive, do so now. */
7433 temp = (IF_STACK_FRAME *) xcalloc (1, sizeof (IF_STACK_FRAME));
7434 temp->next = if_stack;
7436 temp->lineno = ip->lineno;
7437 temp->fname = ip->nominal_fname;
7438 temp->type = kt->type;
7442 if (pedantic && if_stack != save_if_stack)
7445 if (if_stack == instack[indepth].if_stack) {
7446 error ("`#%s' not within a conditional", kt->name);
7449 else if (if_stack == save_if_stack)
7450 goto done; /* found what we came for */
7452 if (kt->type != T_ENDIF) {
7453 if (if_stack->type == T_ELSE)
7454 error ("`#else' or `#elif' after `#else'");
7455 if_stack->type = kt->type;
7460 if_stack = if_stack->next;
7470 /* Don't let erroneous code go by. */
7471 if (kt->length < 0 && !lang_asm && pedantic)
7472 pedwarn ("invalid preprocessing directive name");
7477 /* after this returns, rescan will exit because ip->bufp
7478 now points to the end of the buffer.
7479 rescan is responsible for the error message also. */
7482 if (output_conditionals && op != 0) {
7483 char *ptr = "#endfailed\n";
7484 int len = strlen (ptr);
7486 if (op->bufp > op->buf && op->bufp[-1] != '\n')
7491 check_expand (op, beg_of_line - beg_of_group);
7492 bcopy ((char *) beg_of_group, (char *) op->bufp,
7493 beg_of_line - beg_of_group);
7494 op->bufp += beg_of_line - beg_of_group;
7495 op->lineno += ip->lineno - beg_lineno;
7496 check_expand (op, len);
7497 bcopy (ptr, (char *) op->bufp, len);
7504 * handle a #else directive. Do this by just continuing processing
7505 * without changing if_stack ; this is so that the error message
7506 * for missing #endif's etc. will point to the original #if. It
7507 * is possible that something different would be better.
7511 do_else (buf, limit, op, keyword)
7512 U_CHAR *buf, *limit;
7514 struct directive *keyword;
7516 FILE_BUF *ip = &instack[indepth];
7519 SKIP_WHITE_SPACE (buf);
7521 pedwarn ("text following `#else' violates ANSI standard");
7524 if (if_stack == instack[indepth].if_stack) {
7525 error ("`#else' not within a conditional");
7528 /* #ifndef can't have its special treatment for containing the whole file
7529 if it has a #else clause. */
7530 if_stack->control_macro = 0;
7532 if (if_stack->type != T_IF && if_stack->type != T_ELIF) {
7533 error ("`#else' after `#else'");
7534 fprintf (stderr, " (matches line %d", if_stack->lineno);
7535 if (strcmp (if_stack->fname, ip->nominal_fname) != 0)
7536 fprintf (stderr, ", file %s", if_stack->fname);
7537 fprintf (stderr, ")\n");
7539 if_stack->type = T_ELSE;
7542 if (if_stack->if_succeeded)
7543 skip_if_group (ip, 0, op);
7545 ++if_stack->if_succeeded; /* continue processing input */
7546 output_line_directive (ip, op, 1, same_file);
7552 * unstack after #endif directive
7556 do_endif (buf, limit, op, keyword)
7557 U_CHAR *buf, *limit;
7559 struct directive *keyword;
7562 SKIP_WHITE_SPACE (buf);
7564 pedwarn ("text following `#endif' violates ANSI standard");
7567 if (if_stack == instack[indepth].if_stack)
7568 error ("unbalanced `#endif'");
7570 IF_STACK_FRAME *temp = if_stack;
7571 if_stack = if_stack->next;
7572 if (temp->control_macro != 0) {
7573 /* This #endif matched a #ifndef at the start of the file.
7574 See if it is at the end of the file. */
7575 FILE_BUF *ip = &instack[indepth];
7576 U_CHAR *p = ip->bufp;
7577 U_CHAR *ep = ip->buf + ip->length;
7583 && (*p == '*' || (cplusplus_comments && *p == '/'))) {
7584 /* Skip this comment. */
7586 U_CHAR *save_bufp = ip->bufp;
7588 p = skip_to_end_of_comment (ip, &junk, 1);
7589 ip->bufp = save_bufp;
7594 /* If we get here, this #endif ends a #ifndef
7595 that contains all of the file (aside from whitespace).
7596 Arrange not to include the file again
7597 if the macro that was tested is defined.
7599 Do not do this for the top-level file in a -include or any
7600 file in a -imacros. */
7602 && ! (indepth == 1 && no_record_file)
7603 && ! (no_record_file && no_output))
7604 record_control_macro (ip->fname, temp->control_macro);
7608 output_line_directive (&instack[indepth], op, 1, same_file);
7613 /* When an #else or #endif is found while skipping failed conditional,
7614 if -pedantic was specified, this is called to warn about text after
7615 the directive name. P points to the first char after the directive name. */
7621 /* Advance P over whitespace and comments. */
7623 if (*p == '\\' && p[1] == '\n')
7625 if (is_hor_space[*p])
7627 else if (*p == '/') {
7628 if (p[1] == '\\' && p[2] == '\n')
7629 newline_fix (p + 1);
7632 /* Don't bother warning about unterminated comments
7633 since that will happen later. Just be sure to exit. */
7635 if (p[1] == '\\' && p[2] == '\n')
7636 newline_fix (p + 1);
7637 if (*p == '*' && p[1] == '/') {
7644 else if (cplusplus_comments && p[1] == '/') {
7646 while (*p && (*p != '\n' || p[-1] == '\\'))
7651 if (*p && *p != '\n')
7652 pedwarn ("text following `#else' or `#endif' violates ANSI standard");
7655 /* Skip a comment, assuming the input ptr immediately follows the
7656 initial slash-star. Bump *LINE_COUNTER for each newline.
7657 (The canonical line counter is &ip->lineno.)
7658 Don't use this routine (or the next one) if bumping the line
7659 counter is not sufficient to deal with newlines in the string.
7661 If NOWARN is nonzero, don't warn about slash-star inside a comment.
7662 This feature is useful when processing a comment that is going to be
7663 processed or was processed at another point in the preprocessor,
7664 to avoid a duplicate warning. Likewise for unterminated comment errors. */
7667 skip_to_end_of_comment (ip, line_counter, nowarn)
7668 register FILE_BUF *ip;
7669 int *line_counter; /* place to remember newlines, or NULL */
7672 register U_CHAR *limit = ip->buf + ip->length;
7673 register U_CHAR *bp = ip->bufp;
7674 FILE_BUF *op = &outbuf; /* JF */
7675 int output = put_out_comments && !line_counter;
7676 int start_line = line_counter ? *line_counter : 0;
7678 /* JF this line_counter stuff is a crock to make sure the
7679 comment is only put out once, no matter how many times
7680 the comment is skipped. It almost works */
7685 if (cplusplus_comments && bp[-1] == '/') {
7687 while (bp < limit) {
7689 if (*bp == '\n' && bp[-1] != '\\')
7701 while (bp < limit) {
7702 if (bp[-1] != '\\' && *bp == '\n') {
7705 if (*bp == '\n' && line_counter)
7714 while (bp < limit) {
7719 if (warn_comments && !nowarn && bp < limit && *bp == '*')
7720 warning ("`/*' within comment");
7723 /* If this is the end of the file, we have an unterminated comment.
7724 Don't swallow the newline. We are guaranteed that there will be a
7725 trailing newline and various pieces assume it's there. */
7732 if (line_counter != NULL)
7738 if (*bp == '\\' && bp[1] == '\n')
7751 error_with_line (line_for_error (start_line), "unterminated comment");
7757 * Skip over a quoted string. BP points to the opening quote.
7758 * Returns a pointer after the closing quote. Don't go past LIMIT.
7759 * START_LINE is the line number of the starting point (but it need
7760 * not be valid if the starting point is inside a macro expansion).
7762 * The input stack state is not changed.
7764 * If COUNT_NEWLINES is nonzero, it points to an int to increment
7765 * for each newline passed.
7767 * If BACKSLASH_NEWLINES_P is nonzero, store 1 thru it
7768 * if we pass a backslash-newline.
7770 * If EOFP is nonzero, set *EOFP to 1 if the string is unterminated.
7773 skip_quoted_string (bp, limit, start_line, count_newlines, backslash_newlines_p, eofp)
7774 register U_CHAR *bp;
7775 register U_CHAR *limit;
7777 int *count_newlines;
7778 int *backslash_newlines_p;
7781 register U_CHAR c, match;
7786 error_with_line (line_for_error (start_line),
7787 "unterminated string or character constant");
7788 error_with_line (multiline_string_line,
7789 "possible real start of unterminated constant");
7790 multiline_string_line = 0;
7797 while (*bp == '\\' && bp[1] == '\n') {
7798 if (backslash_newlines_p)
7799 *backslash_newlines_p = 1;
7804 if (*bp == '\n' && count_newlines) {
7805 if (backslash_newlines_p)
7806 *backslash_newlines_p = 1;
7810 } else if (c == '\n') {
7812 /* Unterminated strings and character constants are 'valid'. */
7813 bp--; /* Don't consume the newline. */
7818 if (pedantic || match == '\'') {
7819 error_with_line (line_for_error (start_line),
7820 "unterminated string or character constant");
7826 /* If not traditional, then allow newlines inside strings. */
7829 if (multiline_string_line == 0)
7830 multiline_string_line = start_line;
7831 } else if (c == match)
7837 /* Place into DST a quoted string representing the string SRC.
7838 Return the address of DST's terminating null. */
7840 quote_string (dst, src)
7847 switch ((c = *src++))
7854 sprintf (dst, "\\%03o", c);
7872 /* Skip across a group of balanced parens, starting from IP->bufp.
7873 IP->bufp is updated. Use this with IP->bufp pointing at an open-paren.
7875 This does not handle newlines, because it's used for the arg of #if,
7876 where there aren't any newlines. Also, backslash-newline can't appear. */
7879 skip_paren_group (ip)
7880 register FILE_BUF *ip;
7882 U_CHAR *limit = ip->buf + ip->length;
7883 U_CHAR *p = ip->bufp;
7885 int lines_dummy = 0;
7887 while (p != limit) {
7897 return ip->bufp = p;
7903 p = skip_to_end_of_comment (ip, &lines_dummy, 0);
7911 p = skip_quoted_string (p - 1, limit, 0, NULL_PTR, NULL_PTR, &eofp);
7913 return ip->bufp = p;
7924 * write out a #line directive, for instance, after an #include file.
7925 * If CONDITIONAL is nonzero, we can omit the #line if it would
7926 * appear to be a no-op, and we can output a few newlines instead
7927 * if we want to increase the line number by a small amount.
7928 * FILE_CHANGE says whether we are entering a file, leaving, or neither.
7932 output_line_directive (ip, op, conditional, file_change)
7935 enum file_change_code file_change;
7938 char *line_directive_buf, *line_end;
7940 if (no_line_directives
7941 || ip->fname == NULL
7943 op->lineno = ip->lineno;
7948 if (ip->lineno == op->lineno)
7951 /* If the inherited line number is a little too small,
7952 output some newlines instead of a #line directive. */
7953 if (ip->lineno > op->lineno && ip->lineno < op->lineno + 8) {
7954 check_expand (op, 10);
7955 while (ip->lineno > op->lineno) {
7963 /* Don't output a line number of 0 if we can help it. */
7964 if (ip->lineno == 0 && ip->bufp - ip->buf < ip->length
7965 && *ip->bufp == '\n') {
7970 line_directive_buf = (char *) alloca (4 * strlen (ip->nominal_fname) + 100);
7971 sprintf (line_directive_buf, "# %d ", ip->lineno);
7972 line_end = quote_string (line_directive_buf + strlen (line_directive_buf),
7974 if (file_change != same_file) {
7976 *line_end++ = file_change == enter_file ? '1' : '2';
7978 /* Tell cc1 if following text comes from a system header file. */
7979 if (ip->system_header_p) {
7983 #ifndef NO_IMPLICIT_EXTERN_C
7984 /* Tell cc1plus if following text should be treated as C. */
7985 if (ip->system_header_p == 2 && cplusplus) {
7991 len = line_end - line_directive_buf;
7992 check_expand (op, len + 1);
7993 if (op->bufp > op->buf && op->bufp[-1] != '\n')
7995 bcopy ((char *) line_directive_buf, (char *) op->bufp, len);
7997 op->lineno = ip->lineno;
8000 /* This structure represents one parsed argument in a macro call.
8001 `raw' points to the argument text as written (`raw_length' is its length).
8002 `expanded' points to the argument's macro-expansion
8003 (its length is `expand_length').
8004 `stringified_length' is the length the argument would have
8006 `use_count' is the number of times this macro arg is substituted
8007 into the macro. If the actual use count exceeds 10,
8008 the value stored is 10.
8009 `free1' and `free2', if nonzero, point to blocks to be freed
8010 when the macro argument data is no longer needed. */
8013 U_CHAR *raw, *expanded;
8014 int raw_length, expand_length;
8015 int stringified_length;
8016 U_CHAR *free1, *free2;
8021 /* Expand a macro call.
8022 HP points to the symbol that is the macro being called.
8023 Put the result of expansion onto the input stack
8024 so that subsequent input by our caller will use it.
8026 If macro wants arguments, caller has already verified that
8027 an argument list follows; arguments come from the input stack. */
8030 macroexpand (hp, op)
8035 DEFINITION *defn = hp->value.defn;
8036 register U_CHAR *xbuf;
8038 int start_line = instack[indepth].lineno;
8039 int rest_args, rest_zero;
8041 CHECK_DEPTH (return;);
8043 /* it might not actually be a macro. */
8044 if (hp->type != T_MACRO) {
8045 special_symbol (hp, op);
8049 /* This macro is being used inside a #if, which means it must be */
8050 /* recorded as a precondition. */
8051 if (pcp_inside_if && pcp_outfile && defn->predefined)
8052 dump_single_macro (hp, pcp_outfile);
8054 nargs = defn->nargs;
8058 struct argdata *args;
8059 char *parse_error = 0;
8061 args = (struct argdata *) alloca ((nargs + 1) * sizeof (struct argdata));
8063 for (i = 0; i < nargs; i++) {
8064 args[i].raw = (U_CHAR *) "";
8065 args[i].expanded = 0;
8066 args[i].raw_length = args[i].expand_length
8067 = args[i].stringified_length = 0;
8068 args[i].free1 = args[i].free2 = 0;
8069 args[i].use_count = 0;
8072 /* Parse all the macro args that are supplied. I counts them.
8073 The first NARGS args are stored in ARGS.
8074 The rest are discarded.
8075 If rest_args is set then we assume macarg absorbed the rest of the args.
8080 /* Discard the open-parenthesis or comma before the next arg. */
8081 ++instack[indepth].bufp;
8084 if (i < nargs || (nargs == 0 && i == 0)) {
8085 /* if we are working on last arg which absorbs rest of args... */
8086 if (i == nargs - 1 && defn->rest_args)
8088 parse_error = macarg (&args[i], rest_args);
8091 parse_error = macarg (NULL_PTR, 0);
8093 error_with_line (line_for_error (start_line), parse_error);
8097 } while (*instack[indepth].bufp != ')');
8099 /* If we got one arg but it was just whitespace, call that 0 args. */
8101 register U_CHAR *bp = args[0].raw;
8102 register U_CHAR *lim = bp + args[0].raw_length;
8103 /* cpp.texi says for foo ( ) we provide one argument.
8104 However, if foo wants just 0 arguments, treat this as 0. */
8106 while (bp != lim && is_space[*bp]) bp++;
8111 /* Don't output an error message if we have already output one for
8112 a parse error above. */
8114 if (nargs == 0 && i > 0) {
8116 error ("arguments given to macro `%s'", hp->name);
8117 } else if (i < nargs) {
8118 /* traditional C allows foo() if foo wants one argument. */
8119 if (nargs == 1 && i == 0 && traditional)
8121 /* the rest args token is allowed to absorb 0 tokens */
8122 else if (i == nargs - 1 && defn->rest_args)
8124 else if (parse_error)
8127 error ("macro `%s' used without args", hp->name);
8129 error ("macro `%s' used with just one arg", hp->name);
8131 error ("macro `%s' used with only %d args", hp->name, i);
8132 } else if (i > nargs) {
8134 error ("macro `%s' used with too many (%d) args", hp->name, i);
8137 /* Swallow the closeparen. */
8138 ++instack[indepth].bufp;
8140 /* If macro wants zero args, we parsed the arglist for checking only.
8141 Read directly from the macro definition. */
8143 xbuf = defn->expansion;
8144 xbuf_len = defn->length;
8146 register U_CHAR *exp = defn->expansion;
8147 register int offset; /* offset in expansion,
8148 copied a piece at a time */
8149 register int totlen; /* total amount of exp buffer filled so far */
8151 register struct reflist *ap, *last_ap;
8153 /* Macro really takes args. Compute the expansion of this call. */
8155 /* Compute length in characters of the macro's expansion.
8156 Also count number of times each arg is used. */
8157 xbuf_len = defn->length;
8158 for (ap = defn->pattern; ap != NULL; ap = ap->next) {
8160 xbuf_len += args[ap->argno].stringified_length;
8161 else if (ap->raw_before != 0 || ap->raw_after != 0 || traditional)
8162 /* Add 4 for two newline-space markers to prevent
8163 token concatenation. */
8164 xbuf_len += args[ap->argno].raw_length + 4;
8166 /* We have an ordinary (expanded) occurrence of the arg.
8167 So compute its expansion, if we have not already. */
8168 if (args[ap->argno].expanded == 0) {
8170 obuf = expand_to_temp_buffer (args[ap->argno].raw,
8171 args[ap->argno].raw + args[ap->argno].raw_length,
8174 args[ap->argno].expanded = obuf.buf;
8175 args[ap->argno].expand_length = obuf.length;
8176 args[ap->argno].free2 = obuf.buf;
8179 /* Add 4 for two newline-space markers to prevent
8180 token concatenation. */
8181 xbuf_len += args[ap->argno].expand_length + 4;
8183 if (args[ap->argno].use_count < 10)
8184 args[ap->argno].use_count++;
8187 xbuf = (U_CHAR *) xmalloc (xbuf_len + 1);
8189 /* Generate in XBUF the complete expansion
8190 with arguments substituted in.
8191 TOTLEN is the total size generated so far.
8192 OFFSET is the index in the definition
8193 of where we are copying from. */
8194 offset = totlen = 0;
8195 for (last_ap = NULL, ap = defn->pattern; ap != NULL;
8196 last_ap = ap, ap = ap->next) {
8197 register struct argdata *arg = &args[ap->argno];
8198 int count_before = totlen;
8200 /* Add chars to XBUF. */
8201 for (i = 0; i < ap->nchars; i++, offset++)
8202 xbuf[totlen++] = exp[offset];
8204 /* If followed by an empty rest arg with concatenation,
8205 delete the last run of nonwhite chars. */
8206 if (rest_zero && totlen > count_before
8207 && ((ap->rest_args && ap->raw_before != 0)
8208 || (last_ap != NULL && last_ap->rest_args
8209 && last_ap->raw_after != 0))) {
8210 /* Delete final whitespace. */
8211 while (totlen > count_before && is_space[xbuf[totlen - 1]]) {
8215 /* Delete the nonwhites before them. */
8216 while (totlen > count_before && ! is_space[xbuf[totlen - 1]]) {
8221 if (ap->stringify != 0) {
8222 int arglen = arg->raw_length;
8228 && (c = arg->raw[i], is_space[c]))
8231 && (c = arg->raw[arglen - 1], is_space[c]))
8234 xbuf[totlen++] = '\"'; /* insert beginning quote */
8235 for (; i < arglen; i++) {
8238 /* Special markers Newline Space
8239 generate nothing for a stringified argument. */
8240 if (c == '\n' && arg->raw[i+1] != '\n') {
8245 /* Internal sequences of whitespace are replaced by one space
8246 except within an string or char token. */
8248 && (c == '\n' ? arg->raw[i+1] == '\n' : is_space[c])) {
8250 /* Note that Newline Space does occur within whitespace
8251 sequences; consider it part of the sequence. */
8252 if (c == '\n' && is_space[arg->raw[i+1]])
8254 else if (c != '\n' && is_space[c])
8271 } else if (c == '\"' || c == '\'')
8275 /* Escape these chars */
8276 if (c == '\"' || (in_string && c == '\\'))
8277 xbuf[totlen++] = '\\';
8281 sprintf ((char *) &xbuf[totlen], "\\%03o", (unsigned int) c);
8286 xbuf[totlen++] = '\"'; /* insert ending quote */
8287 } else if (ap->raw_before != 0 || ap->raw_after != 0 || traditional) {
8288 U_CHAR *p1 = arg->raw;
8289 U_CHAR *l1 = p1 + arg->raw_length;
8290 if (ap->raw_before != 0) {
8291 while (p1 != l1 && is_space[*p1]) p1++;
8292 while (p1 != l1 && is_idchar[*p1])
8293 xbuf[totlen++] = *p1++;
8294 /* Delete any no-reexpansion marker that follows
8295 an identifier at the beginning of the argument
8296 if the argument is concatenated with what precedes it. */
8297 if (p1[0] == '\n' && p1[1] == '-')
8299 } else if (!traditional) {
8300 /* Ordinary expanded use of the argument.
8301 Put in newline-space markers to prevent token pasting. */
8302 xbuf[totlen++] = '\n';
8303 xbuf[totlen++] = ' ';
8305 if (ap->raw_after != 0) {
8306 /* Arg is concatenated after: delete trailing whitespace,
8307 whitespace markers, and no-reexpansion markers. */
8309 if (is_space[l1[-1]]) l1--;
8310 else if (l1[-1] == '-') {
8311 U_CHAR *p2 = l1 - 1;
8312 /* If a `-' is preceded by an odd number of newlines then it
8313 and the last newline are a no-reexpansion marker. */
8314 while (p2 != p1 && p2[-1] == '\n') p2--;
8315 if ((l1 - 1 - p2) & 1) {
8324 bcopy ((char *) p1, (char *) (xbuf + totlen), l1 - p1);
8326 if (!traditional && ap->raw_after == 0) {
8327 /* Ordinary expanded use of the argument.
8328 Put in newline-space markers to prevent token pasting. */
8329 xbuf[totlen++] = '\n';
8330 xbuf[totlen++] = ' ';
8333 /* Ordinary expanded use of the argument.
8334 Put in newline-space markers to prevent token pasting. */
8336 xbuf[totlen++] = '\n';
8337 xbuf[totlen++] = ' ';
8339 bcopy ((char *) arg->expanded, (char *) (xbuf + totlen),
8340 arg->expand_length);
8341 totlen += arg->expand_length;
8343 xbuf[totlen++] = '\n';
8344 xbuf[totlen++] = ' ';
8346 /* If a macro argument with newlines is used multiple times,
8347 then only expand the newlines once. This avoids creating output
8348 lines which don't correspond to any input line, which confuses
8350 if (arg->use_count > 1 && arg->newlines > 0) {
8351 /* Don't bother doing change_newlines for subsequent
8355 = change_newlines (arg->expanded, arg->expand_length);
8359 if (totlen > xbuf_len)
8363 /* if there is anything left of the definition
8364 after handling the arg list, copy that in too. */
8366 for (i = offset; i < defn->length; i++) {
8367 /* if we've reached the end of the macro */
8370 if (! (rest_zero && last_ap != NULL && last_ap->rest_args
8371 && last_ap->raw_after != 0))
8372 xbuf[totlen++] = exp[i];
8378 for (i = 0; i < nargs; i++) {
8379 if (args[i].free1 != 0)
8380 free (args[i].free1);
8381 if (args[i].free2 != 0)
8382 free (args[i].free2);
8386 xbuf = defn->expansion;
8387 xbuf_len = defn->length;
8390 /* Now put the expansion on the input stack
8391 so our caller will commence reading from it. */
8393 register FILE_BUF *ip2;
8395 ip2 = &instack[++indepth];
8398 ip2->nominal_fname = 0;
8399 /* This may not be exactly correct, but will give much better error
8400 messages for nested macro calls than using a line number of zero. */
8401 ip2->lineno = start_line;
8403 ip2->length = xbuf_len;
8405 ip2->free_ptr = (nargs > 0) ? xbuf : 0;
8407 ip2->if_stack = if_stack;
8408 ip2->system_header_p = 0;
8410 /* Recursive macro use sometimes works traditionally.
8411 #define foo(x,y) bar (x (y,0), y)
8415 hp->type = T_DISABLED;
8420 * Parse a macro argument and store the info on it into *ARGPTR.
8421 * REST_ARGS is passed to macarg1 to make it absorb the rest of the args.
8422 * Return nonzero to indicate a syntax error.
8426 macarg (argptr, rest_args)
8427 register struct argdata *argptr;
8430 FILE_BUF *ip = &instack[indepth];
8436 /* Try to parse as much of the argument as exists at this
8437 input stack level. */
8438 U_CHAR *bp = macarg1 (ip->bufp, ip->buf + ip->length,
8439 &paren, &newlines, &comments, rest_args);
8441 /* If we find the end of the argument at this level,
8442 set up *ARGPTR to point at it in the input stack. */
8443 if (!(ip->fname != 0 && (newlines != 0 || comments != 0))
8444 && bp != ip->buf + ip->length) {
8446 argptr->raw = ip->bufp;
8447 argptr->raw_length = bp - ip->bufp;
8448 argptr->newlines = newlines;
8452 /* This input stack level ends before the macro argument does.
8453 We must pop levels and keep parsing.
8454 Therefore, we must allocate a temporary buffer and copy
8455 the macro argument into it. */
8456 int bufsize = bp - ip->bufp;
8457 int extra = newlines;
8458 U_CHAR *buffer = (U_CHAR *) xmalloc (bufsize + extra + 1);
8459 int final_start = 0;
8461 bcopy ((char *) ip->bufp, (char *) buffer, bufsize);
8463 ip->lineno += newlines;
8465 while (bp == ip->buf + ip->length) {
8466 if (instack[indepth].macro == 0) {
8467 result = "unterminated macro call";
8470 ip->macro->type = T_MACRO;
8472 free (ip->free_ptr);
8473 ip = &instack[--indepth];
8476 bp = macarg1 (ip->bufp, ip->buf + ip->length, &paren,
8477 &newlines, &comments, rest_args);
8478 final_start = bufsize;
8479 bufsize += bp - ip->bufp;
8481 buffer = (U_CHAR *) xrealloc (buffer, bufsize + extra + 1);
8482 bcopy ((char *) ip->bufp, (char *) (buffer + bufsize - (bp - ip->bufp)),
8485 ip->lineno += newlines;
8488 /* Now, if arg is actually wanted, record its raw form,
8489 discarding comments and duplicating newlines in whatever
8490 part of it did not come from a macro expansion.
8491 EXTRA space has been preallocated for duplicating the newlines.
8492 FINAL_START is the index of the start of that part. */
8494 argptr->raw = buffer;
8495 argptr->raw_length = bufsize;
8496 argptr->free1 = buffer;
8497 argptr->newlines = newlines;
8498 if ((newlines || comments) && ip->fname != 0)
8501 discard_comments (argptr->raw + final_start,
8502 argptr->raw_length - final_start,
8504 argptr->raw[argptr->raw_length] = 0;
8505 if (argptr->raw_length > bufsize + extra)
8510 /* If we are not discarding this argument,
8511 macroexpand it and compute its length as stringified.
8512 All this info goes into *ARGPTR. */
8515 register U_CHAR *buf, *lim;
8516 register int totlen;
8519 lim = buf + argptr->raw_length;
8521 while (buf != lim && is_space[*buf])
8523 while (buf != lim && is_space[lim[-1]])
8525 totlen = traditional ? 0 : 2; /* Count opening and closing quote. */
8526 while (buf != lim) {
8527 register U_CHAR c = *buf++;
8529 /* Internal sequences of whitespace are replaced by one space
8530 in most cases, but not always. So count all the whitespace
8531 in case we need to keep it all. */
8534 SKIP_ALL_WHITE_SPACE (buf);
8537 if (c == '\"' || c == '\\') /* escape these chars */
8539 else if (!isprint (c))
8542 argptr->stringified_length = totlen;
8547 /* Scan text from START (inclusive) up to LIMIT (exclusive),
8548 counting parens in *DEPTHPTR,
8549 and return if reach LIMIT
8550 or before a `)' that would make *DEPTHPTR negative
8551 or before a comma when *DEPTHPTR is zero.
8552 Single and double quotes are matched and termination
8553 is inhibited within them. Comments also inhibit it.
8554 Value returned is pointer to stopping place.
8556 Increment *NEWLINES each time a newline is passed.
8557 REST_ARGS notifies macarg1 that it should absorb the rest of the args.
8558 Set *COMMENTS to 1 if a comment is seen. */
8561 macarg1 (start, limit, depthptr, newlines, comments, rest_args)
8563 register U_CHAR *limit;
8564 int *depthptr, *newlines, *comments;
8567 register U_CHAR *bp = start;
8569 while (bp < limit) {
8575 if (--(*depthptr) < 0)
8579 /* Traditionally, backslash makes following char not special. */
8580 if (bp + 1 < limit && traditional)
8583 /* But count source lines anyway. */
8592 if (bp[1] == '\\' && bp[2] == '\n')
8593 newline_fix (bp + 1);
8594 if (cplusplus_comments && bp[1] == '/') {
8597 while (bp < limit && (*bp != '\n' || bp[-1] == '\\')) {
8598 if (*bp == '\n') ++*newlines;
8601 /* Now count the newline that we are about to skip. */
8605 if (bp[1] != '*' || bp + 1 >= limit)
8609 while (bp + 1 < limit) {
8611 && bp[1] == '\\' && bp[2] == '\n')
8612 newline_fix (bp + 1);
8613 if (bp[0] == '*' && bp[1] == '/')
8615 if (*bp == '\n') ++*newlines;
8623 for (quotec = *bp++; bp + 1 < limit && *bp != quotec; bp++) {
8628 while (*bp == '\\' && bp[1] == '\n') {
8631 } else if (*bp == '\n') {
8640 /* if we've returned to lowest level and we aren't absorbing all args */
8641 if ((*depthptr) == 0 && rest_args == 0)
8651 /* Discard comments and duplicate newlines
8652 in the string of length LENGTH at START,
8653 except inside of string constants.
8654 The string is copied into itself with its beginning staying fixed.
8656 NEWLINES is the number of newlines that must be duplicated.
8657 We assume that that much extra space is available past the end
8661 discard_comments (start, length, newlines)
8666 register U_CHAR *ibp;
8667 register U_CHAR *obp;
8668 register U_CHAR *limit;
8671 /* If we have newlines to duplicate, copy everything
8672 that many characters up. Then, in the second part,
8673 we will have room to insert the newlines
8675 NEWLINES may actually be too large, because it counts
8676 newlines in string constants, and we don't duplicate those.
8677 But that does no harm. */
8679 ibp = start + length;
8680 obp = ibp + newlines;
8682 while (limit != ibp)
8686 ibp = start + newlines;
8687 limit = start + length + newlines;
8690 while (ibp < limit) {
8691 *obp++ = c = *ibp++;
8694 /* Duplicate the newline. */
8706 if (*ibp == '\\' && ibp[1] == '\n')
8708 /* Delete any comment. */
8709 if (cplusplus_comments && ibp[0] == '/') {
8710 /* Comments are equivalent to spaces. */
8713 while (ibp < limit && (*ibp != '\n' || ibp[-1] == '\\'))
8717 if (ibp[0] != '*' || ibp + 1 >= limit)
8719 /* Comments are equivalent to spaces.
8720 For -traditional, a comment is equivalent to nothing. */
8726 while (ibp + 1 < limit) {
8728 && ibp[1] == '\\' && ibp[2] == '\n')
8729 newline_fix (ibp + 1);
8730 if (ibp[0] == '*' && ibp[1] == '/')
8739 /* Notice and skip strings, so that we don't
8740 think that comments start inside them,
8741 and so we don't duplicate newlines in them. */
8744 while (ibp < limit) {
8745 *obp++ = c = *ibp++;
8748 if (c == '\n' && quotec == '\'')
8750 if (c == '\\' && ibp < limit) {
8751 while (*ibp == '\\' && ibp[1] == '\n')
8764 /* Turn newlines to spaces in the string of length LENGTH at START,
8765 except inside of string constants.
8766 The string is copied into itself with its beginning staying fixed. */
8769 change_newlines (start, length)
8773 register U_CHAR *ibp;
8774 register U_CHAR *obp;
8775 register U_CHAR *limit;
8779 limit = start + length;
8782 while (ibp < limit) {
8783 *obp++ = c = *ibp++;
8786 /* If this is a NEWLINE NEWLINE, then this is a real newline in the
8787 string. Skip past the newline and its duplicate.
8788 Put a space in the output. */
8799 /* Notice and skip strings, so that we don't delete newlines in them. */
8802 while (ibp < limit) {
8803 *obp++ = c = *ibp++;
8806 if (c == '\n' && quotec == '\'')
8818 * my_strerror - return the descriptive text associated with an `errno' code.
8822 my_strerror (errnum)
8828 #ifndef HAVE_STRERROR
8829 result = (char *) ((errnum < sys_nerr) ? sys_errlist[errnum] : 0);
8831 result = strerror (errnum);
8834 /* VAXCRTL's strerror() takes an optional second argument, which only
8835 matters when the first argument is EVMSERR. However, it's simplest
8836 just to pass it unconditionally. `vaxc$errno' is declared in
8837 <errno.h>, and maintained by the library in parallel with `errno'.
8838 We assume that caller's `errnum' either matches the last setting of
8839 `errno' by the library or else does not have the value `EVMSERR'. */
8841 result = strerror (errnum, vaxc$errno);
8845 result = "undocumented I/O error";
8851 * error - print error message and increment count of errors.
8855 error (PRINTF_ALIST (msg))
8860 VA_START (args, msg);
8871 FILE_BUF *ip = NULL;
8873 print_containing_files ();
8875 for (i = indepth; i >= 0; i--)
8876 if (instack[i].fname != NULL) {
8882 fprintf (stderr, "%s:%d: ", ip->nominal_fname, ip->lineno);
8883 vfprintf (stderr, msg, args);
8884 fprintf (stderr, "\n");
8888 /* Error including a message from `errno'. */
8891 error_from_errno (name)
8895 FILE_BUF *ip = NULL;
8897 print_containing_files ();
8899 for (i = indepth; i >= 0; i--)
8900 if (instack[i].fname != NULL) {
8906 fprintf (stderr, "%s:%d: ", ip->nominal_fname, ip->lineno);
8908 fprintf (stderr, "%s: %s\n", name, my_strerror (errno));
8913 /* Print error message but don't count it. */
8916 warning (PRINTF_ALIST (msg))
8921 VA_START (args, msg);
8922 vwarning (msg, args);
8927 vwarning (msg, args)
8932 FILE_BUF *ip = NULL;
8934 if (inhibit_warnings)
8937 if (warnings_are_errors)
8940 print_containing_files ();
8942 for (i = indepth; i >= 0; i--)
8943 if (instack[i].fname != NULL) {
8949 fprintf (stderr, "%s:%d: ", ip->nominal_fname, ip->lineno);
8950 fprintf (stderr, "warning: ");
8951 vfprintf (stderr, msg, args);
8952 fprintf (stderr, "\n");
8956 #if defined (__STDC__) && defined (HAVE_VPRINTF)
8957 error_with_line (int line, PRINTF_ALIST (msg))
8959 error_with_line (line, PRINTF_ALIST (msg))
8966 VA_START (args, msg);
8967 verror_with_line (line, msg, args);
8972 verror_with_line (line, msg, args)
8978 FILE_BUF *ip = NULL;
8980 print_containing_files ();
8982 for (i = indepth; i >= 0; i--)
8983 if (instack[i].fname != NULL) {
8989 fprintf (stderr, "%s:%d: ", ip->nominal_fname, line);
8990 vfprintf (stderr, msg, args);
8991 fprintf (stderr, "\n");
8996 vwarning_with_line (line, msg, args)
9002 FILE_BUF *ip = NULL;
9004 if (inhibit_warnings)
9007 if (warnings_are_errors)
9010 print_containing_files ();
9012 for (i = indepth; i >= 0; i--)
9013 if (instack[i].fname != NULL) {
9019 fprintf (stderr, "%s:%d: ", ip->nominal_fname, line);
9020 fprintf (stderr, "warning: ");
9021 vfprintf (stderr, msg, args);
9022 fprintf (stderr, "\n");
9025 /* print an error message and maybe count it. */
9028 pedwarn (PRINTF_ALIST (msg))
9033 VA_START (args, msg);
9034 if (pedantic_errors)
9037 vwarning (msg, args);
9042 #if defined (__STDC__) && defined (HAVE_VPRINTF)
9043 pedwarn_with_line (int line, PRINTF_ALIST (msg))
9045 pedwarn_with_line (line, PRINTF_ALIST (msg))
9052 VA_START (args, msg);
9053 if (pedantic_errors)
9054 verror_with_line (line, msg, args);
9056 vwarning_with_line (line, msg, args);
9060 /* Report a warning (or an error if pedantic_errors)
9061 giving specified file name and line number, not current. */
9064 #if defined (__STDC__) && defined (HAVE_VPRINTF)
9065 pedwarn_with_file_and_line (char *file, int line, PRINTF_ALIST (msg))
9067 pedwarn_with_file_and_line (file, line, PRINTF_ALIST (msg))
9075 if (!pedantic_errors && inhibit_warnings)
9078 fprintf (stderr, "%s:%d: ", file, line);
9079 if (pedantic_errors)
9081 if (!pedantic_errors)
9082 fprintf (stderr, "warning: ");
9083 VA_START (args, msg);
9084 vfprintf (stderr, msg, args);
9086 fprintf (stderr, "\n");
9089 /* Print the file names and line numbers of the #include
9090 directives which led to the current file. */
9093 print_containing_files ()
9095 FILE_BUF *ip = NULL;
9099 /* If stack of files hasn't changed since we last printed
9100 this info, don't repeat it. */
9101 if (last_error_tick == input_file_stack_tick)
9104 for (i = indepth; i >= 0; i--)
9105 if (instack[i].fname != NULL) {
9110 /* Give up if we don't find a source file. */
9114 /* Find the other, outer source files. */
9115 for (i--; i >= 0; i--)
9116 if (instack[i].fname != NULL) {
9120 fprintf (stderr, "In file included");
9122 fprintf (stderr, ",\n ");
9125 fprintf (stderr, " from %s:%d", ip->nominal_fname, ip->lineno);
9128 fprintf (stderr, ":\n");
9130 /* Record we have printed the status as of this time. */
9131 last_error_tick = input_file_stack_tick;
9134 /* Return the line at which an error occurred.
9135 The error is not necessarily associated with the current spot
9136 in the input stack, so LINE says where. LINE will have been
9137 copied from ip->lineno for the current input level.
9138 If the current level is for a file, we return LINE.
9139 But if the current level is not for a file, LINE is meaningless.
9140 In that case, we return the lineno of the innermost file. */
9143 line_for_error (line)
9149 for (i = indepth; i >= 0; ) {
9150 if (instack[i].fname != 0)
9155 line1 = instack[i].lineno;
9163 * If OBUF doesn't have NEEDED bytes after OPTR, make it bigger.
9165 * As things stand, nothing is ever placed in the output buffer to be
9166 * removed again except when it's KNOWN to be part of an identifier,
9167 * so flushing and moving down everything left, instead of expanding,
9171 /* You might think void was cleaner for the return type,
9172 but that would get type mismatch in check_expand in strict ANSI. */
9174 grow_outbuf (obuf, needed)
9175 register FILE_BUF *obuf;
9176 register int needed;
9181 if (obuf->length - (obuf->bufp - obuf->buf) > needed)
9184 /* Make it at least twice as big as it is now. */
9186 /* Make it have at least 150% of the free space we will need. */
9187 minsize = (3 * needed) / 2 + (obuf->bufp - obuf->buf);
9188 if (minsize > obuf->length)
9189 obuf->length = minsize;
9191 if ((p = (U_CHAR *) xrealloc (obuf->buf, obuf->length)) == NULL)
9194 obuf->bufp = p + (obuf->bufp - obuf->buf);
9200 /* Symbol table for macro names and special symbols */
9203 * install a name in the main hash table, even if it is already there.
9204 * name stops with first non alphanumeric, except leading '#'.
9205 * caller must check against redefinition if that is desired.
9206 * delete_macro () removes things installed by install () in fifo order.
9207 * this is important because of the `defined' special symbol used
9208 * in #if, and also if pushdef/popdef directives are ever implemented.
9210 * If LEN is >= 0, it is the length of the name.
9211 * Otherwise, compute the length by scanning the entire name.
9213 * If HASH is >= 0, it is the precomputed hash code.
9214 * Otherwise, compute the hash code.
9217 install (name, len, type, value, hash)
9220 enum node_type type;
9224 register HASHNODE *hp;
9225 register int i, bucket;
9226 register U_CHAR *p, *q;
9230 while (is_idchar[*p])
9236 hash = hashf (name, len, HASHSIZE);
9238 i = sizeof (HASHNODE) + len + 1;
9239 hp = (HASHNODE *) xmalloc (i);
9241 hp->bucket_hdr = &hashtab[bucket];
9242 hp->next = hashtab[bucket];
9243 hashtab[bucket] = hp;
9245 if (hp->next != NULL)
9246 hp->next->prev = hp;
9249 hp->value.cpval = value;
9250 hp->name = ((U_CHAR *) hp) + sizeof (HASHNODE);
9253 for (i = 0; i < len; i++)
9260 * find the most recent hash node for name name (ending with first
9261 * non-identifier char) installed by install
9263 * If LEN is >= 0, it is the length of the name.
9264 * Otherwise, compute the length by scanning the entire name.
9266 * If HASH is >= 0, it is the precomputed hash code.
9267 * Otherwise, compute the hash code.
9270 lookup (name, len, hash)
9275 register U_CHAR *bp;
9276 register HASHNODE *bucket;
9279 for (bp = name; is_idchar[*bp]; bp++) ;
9284 hash = hashf (name, len, HASHSIZE);
9286 bucket = hashtab[hash];
9288 if (bucket->length == len && bcmp (bucket->name, name, len) == 0)
9290 bucket = bucket->next;
9296 * Delete a hash node. Some weirdness to free junk from macros.
9297 * More such weirdness will have to be added if you define more hash
9298 * types that need it.
9301 /* Note that the DEFINITION of a macro is removed from the hash table
9302 but its storage is not freed. This would be a storage leak
9303 except that it is not reasonable to keep undefining and redefining
9304 large numbers of macros many times.
9305 In any case, this is necessary, because a macro can be #undef'd
9306 in the middle of reading the arguments to a call to it.
9307 If #undef freed the DEFINITION, that would crash. */
9314 if (hp->prev != NULL)
9315 hp->prev->next = hp->next;
9316 if (hp->next != NULL)
9317 hp->next->prev = hp->prev;
9319 /* make sure that the bucket chain header that
9320 the deleted guy was on points to the right thing afterwards. */
9321 if (hp == *hp->bucket_hdr)
9322 *hp->bucket_hdr = hp->next;
9325 if (hp->type == T_MACRO) {
9326 DEFINITION *d = hp->value.defn;
9327 struct reflist *ap, *nextap;
9329 for (ap = d->pattern; ap != NULL; ap = nextap) {
9340 * return hash function on name. must be compatible with the one
9341 * computed a step at a time, elsewhere
9344 hashf (name, len, hashsize)
9345 register U_CHAR *name;
9352 r = HASHSTEP (r, *name++);
9354 return MAKE_POS (r) % hashsize;
9358 /* Dump the definition of a single macro HP to OF. */
9360 dump_single_macro (hp, of)
9361 register HASHNODE *hp;
9364 register DEFINITION *defn = hp->value.defn;
9370 /* Print the definition of the macro HP. */
9372 fprintf (of, "#define %s", hp->name);
9374 if (defn->nargs >= 0) {
9378 for (i = 0; i < defn->nargs; i++) {
9379 dump_arg_n (defn, i, of);
9380 if (i + 1 < defn->nargs)
9390 for (ap = defn->pattern; ap != NULL; ap = ap->next) {
9391 dump_defn_1 (defn->expansion, offset, ap->nchars, of);
9392 offset += ap->nchars;
9394 if (ap->nchars != 0)
9396 if (ap->stringify) {
9397 switch (ap->stringify) {
9398 case SHARP_TOKEN: fprintf (of, "#"); break;
9399 case WHITE_SHARP_TOKEN: fprintf (of, "# "); break;
9400 case PERCENT_COLON_TOKEN: fprintf (of, "%%:"); break;
9401 case WHITE_PERCENT_COLON_TOKEN: fprintf (of, "%%: "); break;
9405 if (ap->raw_before != 0) {
9407 switch (ap->raw_before) {
9408 case WHITE_SHARP_TOKEN:
9409 case WHITE_PERCENT_COLON_TOKEN:
9416 switch (ap->raw_before) {
9417 case SHARP_TOKEN: fprintf (of, "##"); break;
9418 case WHITE_SHARP_TOKEN: fprintf (of, "## "); break;
9419 case PERCENT_COLON_TOKEN: fprintf (of, "%%:%%:"); break;
9420 case WHITE_PERCENT_COLON_TOKEN: fprintf (of, "%%:%%: "); break;
9427 dump_arg_n (defn, ap->argno, of);
9428 if (!traditional && ap->raw_after != 0) {
9429 switch (ap->raw_after) {
9430 case SHARP_TOKEN: fprintf (of, "##"); break;
9431 case WHITE_SHARP_TOKEN: fprintf (of, " ##"); break;
9432 case PERCENT_COLON_TOKEN: fprintf (of, "%%:%%:"); break;
9433 case WHITE_PERCENT_COLON_TOKEN: fprintf (of, " %%:%%:"); break;
9439 dump_defn_1 (defn->expansion, offset, defn->length - offset, of);
9443 /* Dump all macro definitions as #defines to stdout. */
9450 for (bucket = 0; bucket < HASHSIZE; bucket++) {
9451 register HASHNODE *hp;
9453 for (hp = hashtab[bucket]; hp; hp= hp->next) {
9454 if (hp->type == T_MACRO)
9455 dump_single_macro (hp, stdout);
9460 /* Output to OF a substring of a macro definition.
9461 BASE is the beginning of the definition.
9462 Output characters START thru LENGTH.
9463 Unless traditional, discard newlines outside of strings, thus
9464 converting funny-space markers to ordinary spaces. */
9467 dump_defn_1 (base, start, length, of)
9473 U_CHAR *p = base + start;
9474 U_CHAR *limit = base + start + length;
9477 fwrite (p, sizeof (*p), length, of);
9480 if (*p == '\"' || *p =='\'') {
9481 U_CHAR *p1 = skip_quoted_string (p, limit, 0, NULL_PTR,
9482 NULL_PTR, NULL_PTR);
9483 fwrite (p, sizeof (*p), p1 - p, of);
9494 /* Print the name of argument number ARGNUM of macro definition DEFN
9496 Recall that DEFN->args.argnames contains all the arg names
9497 concatenated in reverse order with comma-space in between. */
9500 dump_arg_n (defn, argnum, of)
9505 register U_CHAR *p = defn->args.argnames;
9506 while (argnum + 1 < defn->nargs) {
9507 p = (U_CHAR *) index ((char *) p, ' ') + 1;
9511 while (*p && *p != ',') {
9517 /* Initialize syntactic classifications of characters. */
9520 initialize_char_syntax ()
9525 * Set up is_idchar and is_idstart tables. These should be
9526 * faster than saying (is_alpha (c) || c == '_'), etc.
9527 * Set up these things before calling any routines tthat
9530 for (i = 'a'; i <= 'z'; i++) {
9531 is_idchar[i - 'a' + 'A'] = 1;
9533 is_idstart[i - 'a' + 'A'] = 1;
9536 for (i = '0'; i <= '9'; i++)
9539 is_idstart['_'] = 1;
9540 is_idchar['$'] = dollars_in_ident;
9541 is_idstart['$'] = dollars_in_ident;
9543 /* horizontal space table */
9544 is_hor_space[' '] = 1;
9545 is_hor_space['\t'] = 1;
9546 is_hor_space['\v'] = 1;
9547 is_hor_space['\f'] = 1;
9548 is_hor_space['\r'] = 1;
9557 char_name['\v'] = "vertical tab";
9558 char_name['\f'] = "formfeed";
9559 char_name['\r'] = "carriage return";
9562 /* Initialize the built-in macros. */
9565 initialize_builtins (inp, outp)
9569 install ((U_CHAR *) "__LINE__", -1, T_SPECLINE, NULL_PTR, -1);
9570 install ((U_CHAR *) "__DATE__", -1, T_DATE, NULL_PTR, -1);
9571 install ((U_CHAR *) "__FILE__", -1, T_FILE, NULL_PTR, -1);
9572 install ((U_CHAR *) "__BASE_FILE__", -1, T_BASE_FILE, NULL_PTR, -1);
9573 install ((U_CHAR *) "__INCLUDE_LEVEL__", -1, T_INCLUDE_LEVEL, NULL_PTR, -1);
9574 install ((U_CHAR *) "__VERSION__", -1, T_VERSION, NULL_PTR, -1);
9575 #ifndef NO_BUILTIN_SIZE_TYPE
9576 install ((U_CHAR *) "__SIZE_TYPE__", -1, T_SIZE_TYPE, NULL_PTR, -1);
9578 #ifndef NO_BUILTIN_PTRDIFF_TYPE
9579 install ((U_CHAR *) "__PTRDIFF_TYPE__ ", -1, T_PTRDIFF_TYPE, NULL_PTR, -1);
9581 install ((U_CHAR *) "__WCHAR_TYPE__", -1, T_WCHAR_TYPE, NULL_PTR, -1);
9582 install ((U_CHAR *) "__USER_LABEL_PREFIX__", -1, T_USER_LABEL_PREFIX_TYPE,
9584 install ((U_CHAR *) "__REGISTER_PREFIX__", -1, T_REGISTER_PREFIX_TYPE,
9586 install ((U_CHAR *) "__IMMEDIATE_PREFIX__", -1, T_IMMEDIATE_PREFIX_TYPE,
9588 install ((U_CHAR *) "__TIME__", -1, T_TIME, NULL_PTR, -1);
9590 install ((U_CHAR *) "__STDC__", -1, T_CONST, "1", -1);
9591 install ((U_CHAR *) "__STDC_VERSION__", -1, T_CONST, "199409L", -1);
9594 install ((U_CHAR *) "__OBJC__", -1, T_CONST, "1", -1);
9595 /* This is supplied using a -D by the compiler driver
9596 so that it is present only when truly compiling with GNU C. */
9597 /* install ((U_CHAR *) "__GNUC__", -1, T_CONST, "2", -1); */
9601 char directive[2048];
9602 U_CHAR *udirective = (U_CHAR *) directive;
9603 register struct directive *dp = &directive_table[0];
9604 struct tm *timebuf = timestamp ();
9606 sprintf (directive, " __BASE_FILE__ \"%s\"\n",
9607 instack[0].nominal_fname);
9608 output_line_directive (inp, outp, 0, same_file);
9609 pass_thru_directive (udirective, &udirective[strlen (directive)],
9612 sprintf (directive, " __VERSION__ \"%s\"\n", version_string);
9613 output_line_directive (inp, outp, 0, same_file);
9614 pass_thru_directive (udirective, &udirective[strlen (directive)],
9617 #ifndef NO_BUILTIN_SIZE_TYPE
9618 sprintf (directive, " __SIZE_TYPE__ %s\n", SIZE_TYPE);
9619 output_line_directive (inp, outp, 0, same_file);
9620 pass_thru_directive (udirective, &udirective[strlen (directive)],
9624 #ifndef NO_BUILTIN_PTRDIFF_TYPE
9625 sprintf (directive, " __PTRDIFF_TYPE__ %s\n", PTRDIFF_TYPE);
9626 output_line_directive (inp, outp, 0, same_file);
9627 pass_thru_directive (udirective, &udirective[strlen (directive)],
9631 sprintf (directive, " __WCHAR_TYPE__ %s\n", wchar_type);
9632 output_line_directive (inp, outp, 0, same_file);
9633 pass_thru_directive (udirective, &udirective[strlen (directive)],
9636 sprintf (directive, " __DATE__ \"%s %2d %4d\"\n",
9637 monthnames[timebuf->tm_mon],
9638 timebuf->tm_mday, timebuf->tm_year + 1900);
9639 output_line_directive (inp, outp, 0, same_file);
9640 pass_thru_directive (udirective, &udirective[strlen (directive)],
9643 sprintf (directive, " __TIME__ \"%02d:%02d:%02d\"\n",
9644 timebuf->tm_hour, timebuf->tm_min, timebuf->tm_sec);
9645 output_line_directive (inp, outp, 0, same_file);
9646 pass_thru_directive (udirective, &udirective[strlen (directive)],
9651 sprintf (directive, " __STDC__ 1");
9652 output_line_directive (inp, outp, 0, same_file);
9653 pass_thru_directive (udirective, &udirective[strlen (directive)],
9658 sprintf (directive, " __OBJC__ 1");
9659 output_line_directive (inp, outp, 0, same_file);
9660 pass_thru_directive (udirective, &udirective[strlen (directive)],
9667 * process a given definition string, for initialization
9668 * If STR is just an identifier, define it with value 1.
9669 * If STR has anything after the identifier, then it should
9670 * be identifier=definition.
9674 make_definition (str, op)
9679 struct directive *kt;
9682 p = buf = (U_CHAR *) str;
9683 if (!is_idstart[*p]) {
9684 error ("malformed option `-D %s'", str);
9687 while (is_idchar[*++p])
9690 while (is_idchar[*++p] || *p == ',' || is_hor_space[*p])
9693 p = (U_CHAR *) str; /* Error */
9696 buf = (U_CHAR *) alloca (p - buf + 4);
9697 strcpy ((char *)buf, str);
9698 strcat ((char *)buf, " 1");
9699 } else if (*p != '=') {
9700 error ("malformed option `-D %s'", str);
9704 /* Copy the entire option so we can modify it. */
9705 buf = (U_CHAR *) alloca (2 * strlen (str) + 1);
9706 strncpy ((char *) buf, str, p - (U_CHAR *) str);
9707 /* Change the = to a space. */
9708 buf[p - (U_CHAR *) str] = ' ';
9709 /* Scan for any backslash-newline and remove it. */
9711 q = &buf[p - (U_CHAR *) str];
9713 if (*p == '\"' || *p == '\'') {
9714 int unterminated = 0;
9715 U_CHAR *p1 = skip_quoted_string (p, p + strlen ((char *) p), 0,
9716 NULL_PTR, NULL_PTR, &unterminated);
9720 if (*p == '\\' && p[1] == '\n')
9724 } else if (*p == '\\' && p[1] == '\n')
9726 /* Change newline chars into newline-markers. */
9727 else if (*p == '\n')
9739 ip = &instack[++indepth];
9740 ip->nominal_fname = ip->fname = "*Initialization*";
9742 ip->buf = ip->bufp = buf;
9743 ip->length = strlen ((char *) buf);
9747 ip->if_stack = if_stack;
9748 ip->system_header_p = 0;
9750 for (kt = directive_table; kt->type != T_DEFINE; kt++)
9753 /* Pass NULL instead of OP, since this is a "predefined" macro. */
9754 do_define (buf, buf + strlen ((char *) buf), NULL_PTR, kt);
9758 /* JF, this does the work for the -U option */
9761 make_undef (str, op)
9766 struct directive *kt;
9768 ip = &instack[++indepth];
9769 ip->nominal_fname = ip->fname = "*undef*";
9771 ip->buf = ip->bufp = (U_CHAR *) str;
9772 ip->length = strlen (str);
9776 ip->if_stack = if_stack;
9777 ip->system_header_p = 0;
9779 for (kt = directive_table; kt->type != T_UNDEF; kt++)
9782 do_undef ((U_CHAR *) str, (U_CHAR *) str + strlen (str), op, kt);
9786 /* Process the string STR as if it appeared as the body of a #assert.
9787 OPTION is the option name for which STR was the argument. */
9790 make_assertion (option, str)
9795 struct directive *kt;
9796 U_CHAR *buf, *p, *q;
9798 /* Copy the entire option so we can modify it. */
9799 buf = (U_CHAR *) alloca (strlen (str) + 1);
9800 strcpy ((char *) buf, str);
9801 /* Scan for any backslash-newline and remove it. */
9804 if (*p == '\\' && p[1] == '\n')
9812 if (!is_idstart[*p]) {
9813 error ("malformed option `%s %s'", option, str);
9816 while (is_idchar[*++p])
9818 SKIP_WHITE_SPACE (p);
9819 if (! (*p == 0 || *p == '(')) {
9820 error ("malformed option `%s %s'", option, str);
9824 ip = &instack[++indepth];
9825 ip->nominal_fname = ip->fname = "*Initialization*";
9827 ip->buf = ip->bufp = buf;
9828 ip->length = strlen ((char *) buf);
9832 ip->if_stack = if_stack;
9833 ip->system_header_p = 0;
9835 for (kt = directive_table; kt->type != T_ASSERT; kt++)
9838 /* pass NULL as output ptr to do_define since we KNOW it never
9839 does any output.... */
9840 do_assert (buf, buf + strlen ((char *) buf) , NULL_PTR, kt);
9844 /* Append a chain of `struct file_name_list's
9845 to the end of the main include chain.
9846 FIRST is the beginning of the chain to append, and LAST is the end. */
9849 append_include_chain (first, last)
9850 struct file_name_list *first, *last;
9852 struct file_name_list *dir;
9854 if (!first || !last)
9860 last_include->next = first;
9862 if (first_bracket_include == 0)
9863 first_bracket_include = first;
9865 for (dir = first; ; dir = dir->next) {
9866 int len = strlen (dir->fname) + INCLUDE_LEN_FUDGE;
9867 if (len > max_include_len)
9868 max_include_len = len;
9874 last_include = last;
9877 /* Add output to `deps_buffer' for the -M switch.
9878 STRING points to the text to be output.
9879 SPACER is ':' for targets, ' ' for dependencies. */
9882 deps_output (string, spacer)
9886 int size = strlen (string);
9891 #ifndef MAX_OUTPUT_COLUMNS
9892 #define MAX_OUTPUT_COLUMNS 72
9894 if (MAX_OUTPUT_COLUMNS - 1 /*spacer*/ - 2 /*` \'*/ < deps_column + size
9895 && 1 < deps_column) {
9896 bcopy (" \\\n ", &deps_buffer[deps_size], 4);
9903 if (deps_size + size + 8 > deps_allocated_size) {
9904 deps_allocated_size = (deps_size + size + 50) * 2;
9905 deps_buffer = xrealloc (deps_buffer, deps_allocated_size);
9907 if (spacer == ' ') {
9908 deps_buffer[deps_size++] = ' ';
9911 bcopy (string, &deps_buffer[deps_size], size);
9913 deps_column += size;
9914 if (spacer == ':') {
9915 deps_buffer[deps_size++] = ':';
9918 deps_buffer[deps_size] = 0;
9922 fatal (PRINTF_ALIST (msg))
9927 fprintf (stderr, "%s: ", progname);
9928 VA_START (args, msg);
9929 vfprintf (stderr, msg, args);
9931 fprintf (stderr, "\n");
9932 exit (FATAL_EXIT_CODE);
9935 /* More 'friendly' abort that prints the line and file.
9936 config.h can #define abort fancy_abort if you like that sort of thing. */
9941 fatal ("Internal gcc abort.");
9945 perror_with_name (name)
9948 fprintf (stderr, "%s: ", progname);
9949 fprintf (stderr, "%s: %s\n", name, my_strerror (errno));
9954 pfatal_with_name (name)
9957 perror_with_name (name);
9961 exit (FATAL_EXIT_CODE);
9965 /* Handler for SIGPIPE. */
9969 /* If this is missing, some compilers complain. */
9972 fatal ("output pipe has been closed");
9978 fatal ("Memory exhausted.");
9986 register GENERIC_PTR ptr = (GENERIC_PTR) malloc (size);
9993 xrealloc (old, size)
9997 register GENERIC_PTR ptr = (GENERIC_PTR) realloc (old, size);
10004 xcalloc (number, size)
10005 size_t number, size;
10007 register size_t total = number * size;
10008 register GENERIC_PTR ptr = (GENERIC_PTR) malloc (total);
10011 bzero (ptr, total);
10019 size_t size = strlen (input);
10020 char *output = xmalloc (size + 1);
10021 strcpy (output, input);
10025 /* Get the file-mode and data size of the file open on FD
10026 and store them in *MODE_POINTER and *SIZE_POINTER. */
10029 file_size_and_mode (fd, mode_pointer, size_pointer)
10032 long int *size_pointer;
10036 if (fstat (fd, &sbuf) < 0) return (-1);
10037 if (mode_pointer) *mode_pointer = sbuf.st_mode;
10038 if (size_pointer) *size_pointer = sbuf.st_size;
10043 output_dots (fd, depth)
10047 while (depth > 0) {
10056 /* Under VMS we need to fix up the "include" specification
10057 filename so that everything following the 1st slash is
10058 changed into its correct VMS file specification. */
10061 hack_vms_include_specification (fname)
10064 register char *cp, *cp1, *cp2;
10065 int f, check_filename_before_returning, no_prefix_seen;
10068 check_filename_before_returning = 0;
10069 no_prefix_seen = 0;
10071 /* Ignore leading "./"s */
10072 while (fname[0] == '.' && fname[1] == '/') {
10073 strcpy (fname, fname+2);
10074 no_prefix_seen = 1; /* mark this for later */
10076 /* Look for the boundary between the VMS and UNIX filespecs */
10077 cp = rindex (fname, ']'); /* Look for end of dirspec. */
10078 if (cp == 0) cp = rindex (fname, '>'); /* ... Ditto */
10079 if (cp == 0) cp = rindex (fname, ':'); /* Look for end of devspec. */
10083 cp = index (fname, '/'); /* Look for the "/" */
10087 * Check if we have a vax-c style '#include filename'
10088 * and add the missing .h
10091 if (index(fname,'.') == 0)
10092 strcat(fname, ".h");
10094 if (index(cp,'.') == 0)
10098 cp2 = Local; /* initialize */
10100 /* We are trying to do a number of things here. First of all, we are
10101 trying to hammer the filenames into a standard format, such that later
10102 processing can handle them.
10104 If the file name contains something like [dir.], then it recognizes this
10105 as a root, and strips the ".]". Later processing will add whatever is
10106 needed to get things working properly.
10108 If no device is specified, then the first directory name is taken to be
10109 a device name (or a rooted logical). */
10111 /* See if we found that 1st slash */
10112 if (cp == 0) return; /* Nothing to do!!! */
10113 if (*cp != '/') return; /* Nothing to do!!! */
10114 /* Point to the UNIX filename part (which needs to be fixed!) */
10116 /* If the directory spec is not rooted, we can just copy
10117 the UNIX filename part and we are done */
10118 if (((cp - fname) > 1) && ((cp[-1] == ']') || (cp[-1] == '>'))) {
10119 if (cp[-2] != '.') {
10121 * The VMS part ends in a `]', and the preceding character is not a `.'.
10122 * We strip the `]', and then splice the two parts of the name in the
10123 * usual way. Given the default locations for include files in cccp.c,
10124 * we will only use this code if the user specifies alternate locations
10125 * with the /include (-I) switch on the command line. */
10126 cp -= 1; /* Strip "]" */
10127 cp1--; /* backspace */
10130 * The VMS part has a ".]" at the end, and this will not do. Later
10131 * processing will add a second directory spec, and this would be a syntax
10132 * error. Thus we strip the ".]", and thus merge the directory specs.
10133 * We also backspace cp1, so that it points to a '/'. This inhibits the
10134 * generation of the 000000 root directory spec (which does not belong here
10137 cp -= 2; /* Strip ".]" */
10138 cp1--; }; /* backspace */
10141 /* We drop in here if there is no VMS style directory specification yet.
10142 * If there is no device specification either, we make the first dir a
10143 * device and try that. If we do not do this, then we will be essentially
10144 * searching the users default directory (as if they did a #include "asdf.h").
10146 * Then all we need to do is to push a '[' into the output string. Later
10147 * processing will fill this in, and close the bracket.
10149 if (cp[-1] != ':') *cp2++ = ':'; /* dev not in spec. take first dir */
10150 *cp2++ = '['; /* Open the directory specification */
10153 /* at this point we assume that we have the device spec, and (at least
10154 the opening "[" for a directory specification. We may have directories
10155 specified already */
10157 /* If there are no other slashes then the filename will be
10158 in the "root" directory. Otherwise, we need to add
10159 directory specifications. */
10160 if (index (cp1, '/') == 0) {
10161 /* Just add "000000]" as the directory string */
10162 strcpy (cp2, "000000]");
10163 cp2 += strlen (cp2);
10164 check_filename_before_returning = 1; /* we might need to fool with this later */
10166 /* As long as there are still subdirectories to add, do them. */
10167 while (index (cp1, '/') != 0) {
10168 /* If this token is "." we can ignore it */
10169 if ((cp1[0] == '.') && (cp1[1] == '/')) {
10173 /* Add a subdirectory spec. Do not duplicate "." */
10174 if (cp2[-1] != '.' && cp2[-1] != '[' && cp2[-1] != '<')
10176 /* If this is ".." then the spec becomes "-" */
10177 if ((cp1[0] == '.') && (cp1[1] == '.') && (cp[2] == '/')) {
10178 /* Add "-" and skip the ".." */
10183 /* Copy the subdirectory */
10184 while (*cp1 != '/') *cp2++= *cp1++;
10185 cp1++; /* Skip the "/" */
10187 /* Close the directory specification */
10188 if (cp2[-1] == '.') /* no trailing periods */
10192 /* Now add the filename */
10193 while (*cp1) *cp2++ = *cp1++;
10195 /* Now append it to the original VMS spec. */
10196 strcpy (cp, Local);
10198 /* If we put a [000000] in the filename, try to open it first. If this fails,
10199 remove the [000000], and return that name. This provides flexibility
10200 to the user in that they can use both rooted and non-rooted logical names
10201 to point to the location of the file. */
10203 if (check_filename_before_returning && no_prefix_seen) {
10204 f = open (fname, O_RDONLY, 0666);
10206 /* The file name is OK as it is, so return it as is. */
10210 /* The filename did not work. Try to remove the [000000] from the name,
10212 cp = index (fname, '[');
10213 cp2 = index (fname, ']') + 1;
10214 strcpy (cp, cp2); /* this gets rid of it */
10222 /* These are the read/write replacement routines for
10223 VAX-11 "C". They make read/write behave enough
10224 like their UNIX counterparts that CCCP will work */
10227 read (fd, buf, size)
10232 #undef read /* Get back the REAL read routine */
10234 register int total = 0;
10236 /* Read until the buffer is exhausted */
10238 /* Limit each read to 32KB */
10239 i = (size > (32*1024)) ? (32*1024) : size;
10240 i = read (fd, buf, i);
10242 if (i == 0) return (total);
10245 /* Account for this read */
10254 write (fd, buf, size)
10259 #undef write /* Get back the REAL write routine */
10263 /* Limit individual writes to 32Kb */
10266 j = (i > (32*1024)) ? (32*1024) : i;
10267 if (write (fd, buf, j) < 0) return (-1);
10268 /* Account for the data written */
10275 /* The following wrapper functions supply additional arguments to the VMS
10276 I/O routines to optimize performance with file handling. The arguments
10278 "mbc=16" - Set multi-block count to 16 (use a 8192 byte buffer).
10279 "deq=64" - When extending the file, extend it in chunks of 32Kbytes.
10280 "fop=tef"- Truncate unused portions of file when closing file.
10281 "shr=nil"- Disallow file sharing while file is open.
10285 freopen (fname, type, oldfile)
10290 #undef freopen /* Get back the REAL fopen routine */
10291 if (strcmp (type, "w") == 0)
10292 return freopen (fname, type, oldfile, "mbc=16", "deq=64", "fop=tef", "shr=nil");
10293 return freopen (fname, type, oldfile, "mbc=16");
10297 fopen (fname, type)
10301 #undef fopen /* Get back the REAL fopen routine */
10302 /* The gcc-vms-1.42 distribution's header files prototype fopen with two
10303 fixed arguments, which matches ANSI's specification but not VAXCRTL's
10304 pre-ANSI implementation. This hack circumvents the mismatch problem. */
10305 FILE *(*vmslib_fopen)() = (FILE *(*)()) fopen;
10308 return (*vmslib_fopen) (fname, type, "mbc=32",
10309 "deq=64", "fop=tef", "shr=nil");
10311 return (*vmslib_fopen) (fname, type, "mbc=32");
10315 open (fname, flags, prot)
10320 #undef open /* Get back the REAL open routine */
10321 return open (fname, flags, prot, "mbc=16", "deq=64", "fop=tef");
10324 /* Avoid run-time library bug, where copying M out of N+M characters with
10325 N >= 65535 results in VAXCRTL's strncat falling into an infinite loop.
10326 gcc-cpp exercises this particular bug. [Fixed in V5.5-2's VAXCRTL.] */
10329 strncat (dst, src, cnt)
10334 register char *d = dst, *s = (char *) src;
10335 register int n = cnt; /* convert to _signed_ type */
10337 while (*d) d++; /* advance to end */
10339 if (!(*d++ = *s++)) break;
10340 if (n < 0) *d = '\0';
10344 /* more VMS hackery */
10348 extern unsigned long sys$parse(), sys$search();
10350 /* Work around another library bug. If a file is located via a searchlist,
10351 and if the device it's on is not the same device as the one specified
10352 in the first element of that searchlist, then both stat() and fstat()
10353 will fail to return info about it. `errno' will be set to EVMSERR, and
10354 `vaxc$errno' will be set to SS$_NORMAL due yet another bug in stat()!
10355 We can get around this by fully parsing the filename and then passing
10356 that absolute name to stat().
10358 Without this fix, we can end up failing to find header files, which is
10359 bad enough, but then compounding the problem by reporting the reason for
10360 failure as "normal successful completion." */
10362 #undef fstat /* get back to library version */
10365 VMS_fstat (fd, statbuf)
10367 struct stat *statbuf;
10369 int result = fstat (fd, statbuf);
10374 char nambuf[NAM$C_MAXRSS+1];
10376 if ((fp = fdopen (fd, "r")) != 0 && fgetname (fp, nambuf) != 0)
10377 result = VMS_stat (nambuf, statbuf);
10378 /* No fclose(fp) here; that would close(fd) as well. */
10385 VMS_stat (name, statbuf)
10387 struct stat *statbuf;
10389 int result = stat (name, statbuf);
10395 char exp_nam[NAM$C_MAXRSS+1], /* expanded name buffer for sys$parse */
10396 res_nam[NAM$C_MAXRSS+1]; /* resultant name buffer for sys$search */
10399 fab.fab$l_fna = (char *) name;
10400 fab.fab$b_fns = (unsigned char) strlen (name);
10401 fab.fab$l_nam = (void *) &nam;
10403 nam.nam$l_esa = exp_nam, nam.nam$b_ess = sizeof exp_nam - 1;
10404 nam.nam$l_rsa = res_nam, nam.nam$b_rss = sizeof res_nam - 1;
10405 nam.nam$b_nop = NAM$M_PWD | NAM$M_NOCONCEAL;
10406 if (sys$parse (&fab) & 1)
10408 if (sys$search (&fab) & 1)
10410 res_nam[nam.nam$b_rsl] = '\0';
10411 result = stat (res_nam, statbuf);
10413 /* Clean up searchlist context cached by the system. */
10414 nam.nam$b_nop = NAM$M_SYNCHK;
10415 fab.fab$l_fna = 0, fab.fab$b_fns = 0;
10416 (void) sys$parse (&fab);