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, 675 Mass Ave, Cambridge, MA 02139, USA.
20 In other words, you are welcome to use, share and improve this program.
21 You are forbidden to forbid anyone else to use, share and improve
22 what you give them. Help stamp out software-hoarding! */
24 typedef unsigned char U_CHAR;
28 #include "../src/config.h"
36 /* The macro EMACS is defined when cpp is distributed as part of Emacs,
37 for the sake of machines with limited C compilers. */
40 #endif /* not EMACS */
42 #ifndef STANDARD_INCLUDE_DIR
43 #define STANDARD_INCLUDE_DIR "/usr/include"
46 #ifndef LOCAL_INCLUDE_DIR
47 #define LOCAL_INCLUDE_DIR "/usr/local/include"
50 #if 0 /* We can't get ptrdiff_t, so I arranged not to need PTR_INT_TYPE. */
52 #define PTR_INT_TYPE ptrdiff_t
54 #define PTR_INT_TYPE long
60 /* By default, colon separates directories in a path. */
61 #ifndef PATH_SEPARATOR
62 #define PATH_SEPARATOR ':'
65 #include <sys/types.h>
71 /* The following symbols should be autoconfigured:
78 In the mean time, we'll get by with approximations based
79 on existing GCC configuration symbols. */
82 # ifndef HAVE_STDLIB_H
83 # define HAVE_STDLIB_H 1
85 # ifndef HAVE_UNISTD_H
86 # define HAVE_UNISTD_H 1
89 # define STDC_HEADERS 1
91 #endif /* defined (POSIX) */
93 #if defined (POSIX) || (defined (USG) && !defined (VMS))
95 # define HAVE_FCNTL_H 1
102 # if TIME_WITH_SYS_TIME
103 # include <sys/time.h>
107 # include <sys/time.h>
112 # include <sys/resource.h>
119 /* This defines "errno" properly for VMS, and gives us EACCES. */
131 # define bcmp(a, b, n) memcmp (a, b, n)
134 # define bcopy(s, d, n) memcpy (d, s, n)
137 # define bzero(d, n) memset (d, 0, n)
139 #else /* !STDC_HEADERS */
143 # if !defined (BSTRING) && (defined (USG) || defined (VMS))
146 # define bcmp my_bcmp
159 # endif /* !defined (bcmp) */
162 # define bcopy my_bcopy
172 # endif /* !defined (bcopy) */
175 # define bzero my_bzero
179 register unsigned length;
184 # endif /* !defined (bzero) */
186 # endif /* !defined (BSTRING) && (defined (USG) || defined (VMS)) */
187 #endif /* ! STDC_HEADERS */
189 #if __GNUC__ < 2 || (__GNUC__ == 2 && __GNUC_MINOR__ < 6)
190 # define __attribute__(x)
194 # if defined (USE_PROTOTYPES) ? USE_PROTOTYPES : defined (__STDC__)
195 # define PROTO(ARGS) ARGS
197 # define PROTO(ARGS) ()
201 #if defined (__STDC__) && defined (HAVE_VPRINTF)
203 # define VA_START(va_list, var) va_start (va_list, var)
204 # define PRINTF_ALIST(msg) char *msg, ...
205 # define PRINTF_DCL(msg)
206 # define PRINTF_PROTO(ARGS, m, n) PROTO (ARGS) __attribute__ ((format (printf, m, n)))
208 # include <varargs.h>
209 # define VA_START(va_list, var) va_start (va_list)
210 # define PRINTF_ALIST(msg) msg, va_alist
211 # define PRINTF_DCL(msg) char *msg; va_dcl
212 # define PRINTF_PROTO(ARGS, m, n) () __attribute__ ((format (printf, m, n)))
213 # define vfprintf(file, msg, args) \
215 char *a0 = va_arg(args, char *); \
216 char *a1 = va_arg(args, char *); \
217 char *a2 = va_arg(args, char *); \
218 char *a3 = va_arg(args, char *); \
219 fprintf (file, msg, a0, a1, a2, a3); \
223 #define PRINTF_PROTO_1(ARGS) PRINTF_PROTO(ARGS, 1, 2)
224 #define PRINTF_PROTO_2(ARGS) PRINTF_PROTO(ARGS, 2, 3)
225 #define PRINTF_PROTO_3(ARGS) PRINTF_PROTO(ARGS, 3, 4)
231 /* VMS-specific definitions */
234 #define O_RDONLY 0 /* Open arg for Read/Only */
235 #define O_WRONLY 1 /* Open arg for Write/Only */
236 #define read(fd,buf,size) VMS_read (fd,buf,size)
237 #define write(fd,buf,size) VMS_write (fd,buf,size)
238 #define open(fname,mode,prot) VMS_open (fname,mode,prot)
239 #define fopen(fname,mode) VMS_fopen (fname,mode)
240 #define freopen(fname,mode,ofile) VMS_freopen (fname,mode,ofile)
241 #define strncat(dst,src,cnt) VMS_strncat (dst,src,cnt)
242 #define fstat(fd,stbuf) VMS_fstat (fd,stbuf)
243 static int VMS_fstat (), VMS_stat ();
244 static char * VMS_strncat ();
245 static int VMS_read ();
246 static int VMS_write ();
247 static int VMS_open ();
248 static FILE * VMS_fopen ();
249 static FILE * VMS_freopen ();
250 static void hack_vms_include_specification ();
251 typedef struct { unsigned :16, :16, :16; } vms_ino_t;
252 #define ino_t vms_ino_t
253 #define INCLUDE_LEN_FUDGE 10 /* leave room for VMS syntax conversion */
255 #define BSTRING /* VMS/GCC supplies the bstring routines */
256 #endif /* __GNUC__ */
265 #define MIN(X,Y) ((X) < (Y) ? (X) : (Y))
266 #define MAX(X,Y) ((X) > (Y) ? (X) : (Y))
268 /* Find the largest host integer type and set its size and type. */
270 #ifndef HOST_BITS_PER_WIDE_INT
272 #if HOST_BITS_PER_LONG > HOST_BITS_PER_INT
273 #define HOST_BITS_PER_WIDE_INT HOST_BITS_PER_LONG
274 #define HOST_WIDE_INT long
276 #define HOST_BITS_PER_WIDE_INT HOST_BITS_PER_INT
277 #define HOST_WIDE_INT int
283 #define S_ISREG(m) (((m) & S_IFMT) == S_IFREG)
287 #define S_ISDIR(m) (((m) & S_IFMT) == S_IFDIR)
290 /* Define a generic NULL if one hasn't already been defined. */
297 #if defined (USE_PROTOTYPES) ? USE_PROTOTYPES : defined (__STDC__)
298 #define GENERIC_PTR void *
300 #define GENERIC_PTR char *
305 #define NULL_PTR ((GENERIC_PTR)0)
308 #ifndef INCLUDE_LEN_FUDGE
309 #define INCLUDE_LEN_FUDGE 0
312 /* External declarations. */
314 extern char *version_string;
316 #ifndef HAVE_STRERROR
319 extern const char *const sys_errlist[];
321 extern char *sys_errlist[];
323 #else /* HAVE_STRERROR */
327 char *strerror (int,...);
329 int parse_escape PROTO((char **));
330 HOST_WIDE_INT parse_c_expression PROTO((char *));
336 #ifndef FAILURE_EXIT_CODE
337 #define FAILURE_EXIT_CODE 33 /* gnu cc command understands this */
340 #ifndef SUCCESS_EXIT_CODE
341 #define SUCCESS_EXIT_CODE 0 /* 0 means success on Unix. */
344 /* Name under which this program was invoked. */
346 static char *progname;
348 /* Nonzero means use extra default include directories for C++. */
350 static int cplusplus;
352 /* Nonzero means handle cplusplus style comments */
354 static int cplusplus_comments;
356 /* Nonzero means handle #import, for objective C. */
360 /* Nonzero means this is an assembly file, and allow
361 unknown directives, which could be comments. */
365 /* Current maximum length of directory names in the search path
366 for include files. (Altered as we get more of them.) */
368 static int max_include_len;
370 /* Nonzero means turn NOTREACHED into #pragma NOTREACHED etc */
372 static int for_lint = 0;
374 /* Nonzero means copy comments into the output file. */
376 static int put_out_comments = 0;
378 /* Nonzero means don't process the ANSI trigraph sequences. */
380 static int no_trigraphs = 0;
382 /* Nonzero means print the names of included files rather than
383 the preprocessed output. 1 means just the #include "...",
384 2 means #include <...> as well. */
386 static int print_deps = 0;
388 /* Nonzero if missing .h files in -M output are assumed to be generated
389 files and not errors. */
391 static int print_deps_missing_files = 0;
393 /* Nonzero means print names of header files (-H). */
395 static int print_include_names = 0;
397 /* Nonzero means don't output line number information. */
399 static int no_line_directives;
401 /* Nonzero means output the text in failing conditionals,
402 inside #failed ... #endfailed. */
404 static int output_conditionals;
406 /* dump_only means inhibit output of the preprocessed text
407 and instead output the definitions of all user-defined
408 macros in a form suitable for use as input to cccp.
409 dump_names means pass #define and the macro name through to output.
410 dump_definitions means pass the whole definition (plus #define) through
413 static enum {dump_none, dump_only, dump_names, dump_definitions}
414 dump_macros = dump_none;
416 /* Nonzero means pass all #define and #undef directives which we actually
417 process through to the output stream. This feature is used primarily
418 to allow cc1 to record the #defines and #undefs for the sake of
419 debuggers which understand about preprocessor macros, but it may
420 also be useful with -E to figure out how symbols are defined, and
421 where they are defined. */
422 static int debug_output = 0;
424 /* Nonzero indicates special processing used by the pcp program. The
425 special effects of this mode are:
427 Inhibit all macro expansion, except those inside #if directives.
429 Process #define directives normally, and output their contents
432 Output preconditions to pcp_outfile indicating all the relevant
433 preconditions for use of this file in a later cpp run.
435 static FILE *pcp_outfile;
437 /* Nonzero means we are inside an IF during a -pcp run. In this mode
438 macro expansion is done, and preconditions are output for all macro
439 uses requiring them. */
440 static int pcp_inside_if;
442 /* Nonzero means never to include precompiled files.
443 This is 1 since there's no way now to make precompiled files,
444 so it's not worth testing for them. */
445 static int no_precomp = 1;
447 /* Nonzero means give all the error messages the ANSI standard requires. */
451 /* Nonzero means try to make failure to fit ANSI C an error. */
453 static int pedantic_errors;
455 /* Nonzero means don't print warning messages. -w. */
457 static int inhibit_warnings = 0;
459 /* Nonzero means warn if slash-star appears in a comment. */
461 static int warn_comments;
463 /* Nonzero means warn if a macro argument is (or would be)
464 stringified with -traditional. */
466 static int warn_stringify;
468 /* Nonzero means warn if there are any trigraphs. */
470 static int warn_trigraphs;
472 /* Nonzero means warn if #import is used. */
474 static int warn_import = 1;
476 /* Nonzero means turn warnings into errors. */
478 static int warnings_are_errors;
480 /* Nonzero means try to imitate old fashioned non-ANSI preprocessor. */
484 /* Nonzero causes output not to be done,
485 but directives such as #define that have side effects
488 static int no_output;
490 /* Nonzero means this file was included with a -imacros or -include
491 command line and should not be recorded as an include file. */
493 static int no_record_file;
495 /* Nonzero means that we have finished processing the command line options.
496 This flag is used to decide whether or not to issue certain errors
499 static int done_initializing = 0;
501 /* Line where a newline was first seen in a string constant. */
503 static int multiline_string_line = 0;
505 /* I/O buffer structure.
506 The `fname' field is nonzero for source files and #include files
507 and for the dummy text used for -D and -U.
508 It is zero for rescanning results of macro expansion
509 and for expanding macro arguments. */
510 #define INPUT_STACK_MAX 400
511 static struct file_buf {
513 /* Filename specified with #line directive. */
515 /* Record where in the search path this file was found.
516 For #include_next. */
517 struct file_name_list *dir;
522 /* Macro that this level is the expansion of.
523 Included so that we can reenable the macro
524 at the end of this level. */
525 struct hashnode *macro;
526 /* Value of if_stack at start of this file.
527 Used to prohibit unmatched #endif (etc) in an include file. */
528 struct if_stack *if_stack;
529 /* Object to be freed at end of input at this level. */
531 /* True if this is a header file included using <FILENAME>. */
532 char system_header_p;
533 } instack[INPUT_STACK_MAX];
535 static int last_error_tick; /* Incremented each time we print it. */
536 static int input_file_stack_tick; /* Incremented when the status changes. */
538 /* Current nesting level of input sources.
539 `instack[indepth]' is the level currently being read. */
540 static int indepth = -1;
541 #define CHECK_DEPTH(code) \
542 if (indepth >= (INPUT_STACK_MAX - 1)) \
544 error_with_line (line_for_error (instack[indepth].lineno), \
545 "macro or `#include' recursion too deep"); \
549 /* Current depth in #include directives that use <...>. */
550 static int system_include_depth = 0;
552 typedef struct file_buf FILE_BUF;
554 /* The output buffer. Its LENGTH field is the amount of room allocated
555 for the buffer, not the number of chars actually present. To get
556 that, subtract outbuf.buf from outbuf.bufp. */
558 #define OUTBUF_SIZE 10 /* initial size of output buffer */
559 static FILE_BUF outbuf;
561 /* Grow output buffer OBUF points at
562 so it can hold at least NEEDED more chars. */
564 #define check_expand(OBUF, NEEDED) \
565 (((OBUF)->length - ((OBUF)->bufp - (OBUF)->buf) <= (NEEDED)) \
566 ? grow_outbuf ((OBUF), (NEEDED)) : 0)
568 struct file_name_list
570 struct file_name_list *next;
572 /* If the following is nonzero, it is a macro name.
573 Don't include the file again if that macro is defined. */
574 U_CHAR *control_macro;
575 /* If the following is nonzero, it is a C-language system include
577 int c_system_include_path;
578 /* Mapping of file names for this directory. */
579 struct file_name_map *name_map;
580 /* Non-zero if name_map is valid. */
584 /* #include "file" looks in source file dir, then stack. */
585 /* #include <file> just looks in the stack. */
586 /* -I directories are added to the end, then the defaults are added. */
588 static struct default_include {
589 char *fname; /* The name of the directory. */
590 int cplusplus; /* Only look here if we're compiling C++. */
591 int cxx_aware; /* Includes in this directory don't need to
592 be wrapped in extern "C" when compiling
594 } include_defaults_array[]
595 #ifdef INCLUDE_DEFAULTS
599 /* Pick up GNU C++ specific include files. */
600 { GPLUSPLUS_INCLUDE_DIR, 1, 1 },
602 /* This is the dir for fixincludes. Put it just before
603 the files that we fix. */
604 { GCC_INCLUDE_DIR, 0, 0 },
605 /* For cross-compilation, this dir name is generated
606 automatically in Makefile.in. */
607 { CROSS_INCLUDE_DIR, 0, 0 },
608 /* This is another place that the target system's headers might be. */
609 { TOOL_INCLUDE_DIR, 0, 0 },
610 #else /* not CROSS_COMPILE */
611 /* This should be /usr/local/include and should come before
612 the fixincludes-fixed header files. */
613 { LOCAL_INCLUDE_DIR, 0, 1 },
614 /* This is here ahead of GCC_INCLUDE_DIR because assert.h goes here.
615 Likewise, behind LOCAL_INCLUDE_DIR, where glibc puts its assert.h. */
616 { TOOL_INCLUDE_DIR, 0, 0 },
617 /* This is the dir for fixincludes. Put it just before
618 the files that we fix. */
619 { GCC_INCLUDE_DIR, 0, 0 },
620 /* Some systems have an extra dir of include files. */
621 #ifdef SYSTEM_INCLUDE_DIR
622 { SYSTEM_INCLUDE_DIR, 0, 0 },
624 { STANDARD_INCLUDE_DIR, 0, 0 },
625 #endif /* not CROSS_COMPILE */
628 #endif /* no INCLUDE_DEFAULTS */
630 /* The code looks at the defaults through this pointer, rather than through
631 the constant structure above. This pointer gets changed if an environment
632 variable specifies other defaults. */
633 static struct default_include *include_defaults = include_defaults_array;
635 static struct file_name_list *include = 0; /* First dir to search */
636 /* First dir to search for <file> */
637 /* This is the first element to use for #include <...>.
638 If it is 0, use the entire chain for such includes. */
639 static struct file_name_list *first_bracket_include = 0;
640 /* This is the first element in the chain that corresponds to
641 a directory of system header files. */
642 static struct file_name_list *first_system_include = 0;
643 static struct file_name_list *last_include = 0; /* Last in chain */
645 /* Chain of include directories to put at the end of the other chain. */
646 static struct file_name_list *after_include = 0;
647 static struct file_name_list *last_after_include = 0; /* Last in chain */
649 /* Chain to put at the start of the system include files. */
650 static struct file_name_list *before_system = 0;
651 static struct file_name_list *last_before_system = 0; /* Last in chain */
653 /* List of included files that contained #pragma once. */
654 static struct file_name_list *dont_repeat_files = 0;
656 /* List of other included files.
657 If ->control_macro if nonzero, the file had a #ifndef
658 around the entire contents, and ->control_macro gives the macro name. */
659 static struct file_name_list *all_include_files = 0;
661 /* Directory prefix that should replace `/usr' in the standard
662 include file directories. */
663 static char *include_prefix;
665 /* Global list of strings read in from precompiled files. This list
666 is kept in the order the strings are read in, with new strings being
667 added at the end through stringlist_tailp. We use this list to output
668 the strings at the end of the run.
670 static STRINGDEF *stringlist;
671 static STRINGDEF **stringlist_tailp = &stringlist;
674 /* Structure returned by create_definition */
675 typedef struct macrodef MACRODEF;
678 struct definition *defn;
683 enum sharp_token_type {
684 NO_SHARP_TOKEN = 0, /* token not present */
686 SHARP_TOKEN = '#', /* token spelled with # only */
687 WHITE_SHARP_TOKEN, /* token spelled with # and white space */
689 PERCENT_COLON_TOKEN = '%', /* token spelled with %: only */
690 WHITE_PERCENT_COLON_TOKEN /* token spelled with %: and white space */
693 /* Structure allocated for every #define. For a simple replacement
696 nargs = -1, the `pattern' list is null, and the expansion is just
697 the replacement text. Nargs = 0 means a functionlike macro with no args,
699 #define getchar() getc (stdin) .
700 When there are args, the expansion is the replacement text with the
701 args squashed out, and the reflist is a list describing how to
702 build the output from the input: e.g., "3 chars, then the 1st arg,
703 then 9 chars, then the 3rd arg, then 0 chars, then the 2nd arg".
704 The chars here come from the expansion. Whatever is left of the
705 expansion after the last arg-occurrence is copied after that arg.
706 Note that the reflist can be arbitrarily long---
707 its length depends on the number of times the arguments appear in
708 the replacement text, not how many args there are. Example:
709 #define f(x) x+x+x+x+x+x+x would have replacement text "++++++" and
711 { (0, 1), (1, 1), (1, 1), ..., (1, 1), NULL }
712 where (x, y) means (nchars, argno). */
714 typedef struct definition DEFINITION;
717 int length; /* length of expansion string */
718 int predefined; /* True if the macro was builtin or */
719 /* came from the command line */
721 int line; /* Line number of definition */
722 char *file; /* File of definition */
723 char rest_args; /* Nonzero if last arg. absorbs the rest */
725 struct reflist *next;
727 enum sharp_token_type stringify; /* set if a # operator before arg */
728 enum sharp_token_type raw_before; /* set if a ## operator before arg */
729 enum sharp_token_type raw_after; /* set if a ## operator after arg */
731 char rest_args; /* Nonzero if this arg. absorbs the rest */
732 int nchars; /* Number of literal chars to copy before
733 this arg occurrence. */
734 int argno; /* Number of arg to substitute (origin-0) */
737 /* Names of macro args, concatenated in reverse order
738 with comma-space between them.
739 The only use of this is that we warn on redefinition
740 if this differs between the old and new definitions. */
745 /* different kinds of things that can appear in the value field
746 of a hash node. Actually, this may be useless now. */
754 * special extension string that can be added to the last macro argument to
755 * allow it to absorb the "rest" of the arguments when expanded. Ex:
756 * #define wow(a, b...) process (b, a, b)
757 * { wow (1, 2, 3); } -> { process (2, 3, 1, 2, 3); }
758 * { wow (one, two); } -> { process (two, one, two); }
759 * if this "rest_arg" is used with the concat token '##' and if it is not
760 * supplied then the token attached to with ## will not be outputted. Ex:
761 * #define wow (a, b...) process (b ## , a, ## b)
762 * { wow (1, 2); } -> { process (2, 1, 2); }
763 * { wow (one); } -> { process (one); {
765 static char rest_extension[] = "...";
766 #define REST_EXTENSION_LENGTH (sizeof (rest_extension) - 1)
768 /* The structure of a node in the hash table. The hash table
769 has entries for all tokens defined by #define directives (type T_MACRO),
770 plus some special tokens like __LINE__ (these each have their own
771 type, and the appropriate code is run when that type of node is seen.
772 It does not contain control words like "#define", which are recognized
773 by a separate piece of code. */
775 /* different flavors of hash nodes --- also used in keyword table */
777 T_DEFINE = 1, /* the `#define' keyword */
778 T_INCLUDE, /* the `#include' keyword */
779 T_INCLUDE_NEXT, /* the `#include_next' keyword */
780 T_IMPORT, /* the `#import' keyword */
781 T_IFDEF, /* the `#ifdef' keyword */
782 T_IFNDEF, /* the `#ifndef' keyword */
783 T_IF, /* the `#if' keyword */
784 T_ELSE, /* `#else' */
785 T_PRAGMA, /* `#pragma' */
786 T_ELIF, /* `#elif' */
787 T_UNDEF, /* `#undef' */
788 T_LINE, /* `#line' */
789 T_ERROR, /* `#error' */
790 T_WARNING, /* `#warning' */
791 T_ENDIF, /* `#endif' */
792 T_SCCS, /* `#sccs', used on system V. */
793 T_IDENT, /* `#ident', used on system V. */
794 T_ASSERT, /* `#assert', taken from system V. */
795 T_UNASSERT, /* `#unassert', taken from system V. */
796 T_SPECLINE, /* special symbol `__LINE__' */
797 T_DATE, /* `__DATE__' */
798 T_FILE, /* `__FILE__' */
799 T_BASE_FILE, /* `__BASE_FILE__' */
800 T_INCLUDE_LEVEL, /* `__INCLUDE_LEVEL__' */
801 T_VERSION, /* `__VERSION__' */
802 T_SIZE_TYPE, /* `__SIZE_TYPE__' */
803 T_PTRDIFF_TYPE, /* `__PTRDIFF_TYPE__' */
804 T_WCHAR_TYPE, /* `__WCHAR_TYPE__' */
805 T_USER_LABEL_PREFIX_TYPE, /* `__USER_LABEL_PREFIX__' */
806 T_REGISTER_PREFIX_TYPE, /* `__REGISTER_PREFIX__' */
807 T_IMMEDIATE_PREFIX_TYPE, /* `__IMMEDIATE_PREFIX__' */
808 T_TIME, /* `__TIME__' */
809 T_CONST, /* Constant value, used by `__STDC__' */
810 T_MACRO, /* macro defined by `#define' */
811 T_DISABLED, /* macro temporarily turned off for rescan */
812 T_SPEC_DEFINED, /* special `defined' macro for use in #if statements */
813 T_PCSTRING, /* precompiled string (hashval is KEYDEF *) */
814 T_UNUSED /* Used for something not defined. */
818 struct hashnode *next; /* double links for easy deletion */
819 struct hashnode *prev;
820 struct hashnode **bucket_hdr; /* also, a back pointer to this node's hash
821 chain is kept, in case the node is the head
822 of the chain and gets deleted. */
823 enum node_type type; /* type of special token */
824 int length; /* length of token, for quick comparison */
825 U_CHAR *name; /* the actual name */
826 union hashval value; /* pointer to expansion, or whatever */
829 typedef struct hashnode HASHNODE;
831 /* Some definitions for the hash table. The hash function MUST be
832 computed as shown in hashf () below. That is because the rescan
833 loop computes the hash value `on the fly' for most tokens,
834 in order to avoid the overhead of a lot of procedure calls to
835 the hashf () function. Hashf () only exists for the sake of
836 politeness, for use when speed isn't so important. */
838 #define HASHSIZE 1403
839 static HASHNODE *hashtab[HASHSIZE];
840 #define HASHSTEP(old, c) ((old << 2) + c)
841 #define MAKE_POS(v) (v & 0x7fffffff) /* make number positive */
843 /* Symbols to predefine. */
845 #ifdef CPP_PREDEFINES
846 static char *predefs = CPP_PREDEFINES;
848 static char *predefs = "";
851 /* We let tm.h override the types used here, to handle trivial differences
852 such as the choice of unsigned int or long unsigned int for size_t.
853 When machines start needing nontrivial differences in the size type,
854 it would be best to do something here to figure out automatically
855 from other information what type to use. */
857 /* The string value for __SIZE_TYPE__. */
860 #define SIZE_TYPE "long unsigned int"
863 /* The string value for __PTRDIFF_TYPE__. */
866 #define PTRDIFF_TYPE "long int"
869 /* The string value for __WCHAR_TYPE__. */
872 #define WCHAR_TYPE "int"
874 char * wchar_type = WCHAR_TYPE;
877 /* The string value for __USER_LABEL_PREFIX__ */
879 #ifndef USER_LABEL_PREFIX
880 #define USER_LABEL_PREFIX ""
883 /* The string value for __REGISTER_PREFIX__ */
885 #ifndef REGISTER_PREFIX
886 #define REGISTER_PREFIX ""
889 /* The string value for __IMMEDIATE_PREFIX__ */
891 #ifndef IMMEDIATE_PREFIX
892 #define IMMEDIATE_PREFIX ""
895 /* In the definition of a #assert name, this structure forms
896 a list of the individual values asserted.
897 Each value is itself a list of "tokens".
898 These are strings that are compared by name. */
900 struct tokenlist_list {
901 struct tokenlist_list *next;
902 struct arglist *tokens;
905 struct assertion_hashnode {
906 struct assertion_hashnode *next; /* double links for easy deletion */
907 struct assertion_hashnode *prev;
908 /* also, a back pointer to this node's hash
909 chain is kept, in case the node is the head
910 of the chain and gets deleted. */
911 struct assertion_hashnode **bucket_hdr;
912 int length; /* length of token, for quick comparison */
913 U_CHAR *name; /* the actual name */
914 /* List of token-sequences. */
915 struct tokenlist_list *value;
918 typedef struct assertion_hashnode ASSERTION_HASHNODE;
920 /* Some definitions for the hash table. The hash function MUST be
921 computed as shown in hashf below. That is because the rescan
922 loop computes the hash value `on the fly' for most tokens,
923 in order to avoid the overhead of a lot of procedure calls to
924 the hashf function. hashf only exists for the sake of
925 politeness, for use when speed isn't so important. */
927 #define ASSERTION_HASHSIZE 37
928 static ASSERTION_HASHNODE *assertion_hashtab[ASSERTION_HASHSIZE];
930 /* Nonzero means inhibit macroexpansion of what seem to be
931 assertion tests, in rescan. For #if. */
932 static int assertions_flag;
934 /* `struct directive' defines one #-directive, including how to handle it. */
936 #define DO_PROTO PROTO((U_CHAR *, U_CHAR *, FILE_BUF *, struct directive *))
939 int length; /* Length of name */
940 int (*func) DO_PROTO; /* Function to handle directive */
941 char *name; /* Name of directive */
942 enum node_type type; /* Code which describes which directive. */
943 char angle_brackets; /* Nonzero => <...> is special. */
944 char traditional_comments; /* Nonzero: keep comments if -traditional. */
945 char pass_thru; /* Copy preprocessed directive to output file. */
948 /* These functions are declared to return int instead of void since they
949 are going to be placed in the table and some old compilers have trouble with
950 pointers to functions returning void. */
952 static int do_assert DO_PROTO;
953 static int do_define DO_PROTO;
954 static int do_elif DO_PROTO;
955 static int do_else DO_PROTO;
956 static int do_endif DO_PROTO;
957 static int do_error DO_PROTO;
958 static int do_ident DO_PROTO;
959 static int do_if DO_PROTO;
960 static int do_include DO_PROTO;
961 static int do_line DO_PROTO;
962 static int do_pragma DO_PROTO;
963 #ifdef SCCS_DIRECTIVE
964 static int do_sccs DO_PROTO;
966 static int do_unassert DO_PROTO;
967 static int do_undef DO_PROTO;
968 static int do_warning DO_PROTO;
969 static int do_xifdef DO_PROTO;
971 /* Here is the actual list of #-directives, most-often-used first. */
973 static struct directive directive_table[] = {
974 { 6, do_define, "define", T_DEFINE, 0, 1},
975 { 2, do_if, "if", T_IF},
976 { 5, do_xifdef, "ifdef", T_IFDEF},
977 { 6, do_xifdef, "ifndef", T_IFNDEF},
978 { 5, do_endif, "endif", T_ENDIF},
979 { 4, do_else, "else", T_ELSE},
980 { 4, do_elif, "elif", T_ELIF},
981 { 4, do_line, "line", T_LINE},
982 { 7, do_include, "include", T_INCLUDE, 1},
983 { 12, do_include, "include_next", T_INCLUDE_NEXT, 1},
984 { 6, do_include, "import", T_IMPORT, 1},
985 { 5, do_undef, "undef", T_UNDEF},
986 { 5, do_error, "error", T_ERROR},
987 { 7, do_warning, "warning", T_WARNING},
988 #ifdef SCCS_DIRECTIVE
989 { 4, do_sccs, "sccs", T_SCCS},
991 { 6, do_pragma, "pragma", T_PRAGMA, 0, 0, 1},
992 { 5, do_ident, "ident", T_IDENT},
993 { 6, do_assert, "assert", T_ASSERT},
994 { 8, do_unassert, "unassert", T_UNASSERT},
995 { -1, 0, "", T_UNUSED},
998 /* When a directive handler is called,
999 this points to the # (or the : of the %:) that started the directive. */
1000 U_CHAR *directive_start;
1002 /* table to tell if char can be part of a C identifier. */
1003 U_CHAR is_idchar[256];
1004 /* table to tell if char can be first char of a c identifier. */
1005 U_CHAR is_idstart[256];
1006 /* table to tell if c is horizontal space. */
1007 U_CHAR is_hor_space[256];
1008 /* table to tell if c is horizontal or vertical space. */
1009 static U_CHAR is_space[256];
1010 /* names of some characters */
1011 static char *char_name[256];
1013 #define SKIP_WHITE_SPACE(p) do { while (is_hor_space[*p]) p++; } while (0)
1014 #define SKIP_ALL_WHITE_SPACE(p) do { while (is_space[*p]) p++; } while (0)
1016 static int errors = 0; /* Error counter for exit code */
1018 /* Name of output file, for error messages. */
1019 static char *out_fname;
1021 /* Zero means dollar signs are punctuation.
1022 -$ stores 0; -traditional may store 1. Default is 1 for VMS, 0 otherwise.
1023 This must be 0 for correct processing of this ANSI C program:
1025 #define lose(b) foo (b)
1028 static int dollars_in_ident;
1029 #ifndef DOLLARS_IN_IDENTIFIERS
1030 #define DOLLARS_IN_IDENTIFIERS 1
1034 /* Stack of conditionals currently in progress
1035 (including both successful and failing conditionals). */
1038 struct if_stack *next; /* for chaining to the next stack frame */
1039 char *fname; /* copied from input when frame is made */
1040 int lineno; /* similarly */
1041 int if_succeeded; /* true if a leg of this if-group
1042 has been passed through rescan */
1043 U_CHAR *control_macro; /* For #ifndef at start of file,
1044 this is the macro name tested. */
1045 enum node_type type; /* type of last directive seen in this group */
1047 typedef struct if_stack IF_STACK_FRAME;
1048 static IF_STACK_FRAME *if_stack = NULL;
1050 /* Buffer of -M output. */
1051 static char *deps_buffer;
1053 /* Number of bytes allocated in above. */
1054 static int deps_allocated_size;
1056 /* Number of bytes used. */
1057 static int deps_size;
1059 /* Number of bytes since the last newline. */
1060 static int deps_column;
1062 /* Nonzero means -I- has been seen,
1063 so don't look for #include "foo" the source-file directory. */
1064 static int ignore_srcdir;
1066 static int safe_read PROTO((int, char *, int));
1067 static void safe_write PROTO((int, char *, int));
1069 int main PROTO((int, char **));
1071 static void path_include PROTO((char *));
1073 static U_CHAR *index0 PROTO((U_CHAR *, int, size_t));
1075 static void trigraph_pcp PROTO((FILE_BUF *));
1077 static void newline_fix PROTO((U_CHAR *));
1078 static void name_newline_fix PROTO((U_CHAR *));
1080 static char *get_lintcmd PROTO((U_CHAR *, U_CHAR *, U_CHAR **, int *, int *));
1082 static void rescan PROTO((FILE_BUF *, int));
1084 static FILE_BUF expand_to_temp_buffer PROTO((U_CHAR *, U_CHAR *, int, int));
1086 static int handle_directive PROTO((FILE_BUF *, FILE_BUF *));
1088 static struct tm *timestamp PROTO((void));
1089 static void special_symbol PROTO((HASHNODE *, FILE_BUF *));
1091 static int redundant_include_p PROTO((char *));
1092 static is_system_include PROTO((char *));
1094 static char *read_filename_string PROTO((int, FILE *));
1095 static struct file_name_map *read_name_map PROTO((char *));
1096 static int open_include_file PROTO((char *, struct file_name_list *));
1098 static void finclude PROTO((int, char *, FILE_BUF *, int, struct file_name_list *));
1099 static void record_control_macro PROTO((char *, U_CHAR *));
1101 static int import_hash PROTO((char *));
1102 static int lookup_import PROTO((char *, struct file_name_list *));
1103 static void add_import PROTO((int, char *));
1105 static char *check_precompiled PROTO((int, char *, char **));
1106 static int check_preconditions PROTO((char *));
1107 static void pcfinclude PROTO((U_CHAR *, U_CHAR *, U_CHAR *, FILE_BUF *));
1108 static void pcstring_used PROTO((HASHNODE *));
1109 static void write_output PROTO((void));
1110 static void pass_thru_directive PROTO((U_CHAR *, U_CHAR *, FILE_BUF *, struct directive *));
1112 static MACRODEF create_definition PROTO((U_CHAR *, U_CHAR *, FILE_BUF *));
1114 static int check_macro_name PROTO((U_CHAR *, char *));
1115 static int compare_defs PROTO((DEFINITION *, DEFINITION *));
1116 static int comp_def_part PROTO((int, U_CHAR *, int, U_CHAR *, int, int));
1118 static DEFINITION *collect_expansion PROTO((U_CHAR *, U_CHAR *, int, struct arglist *));
1120 int check_assertion PROTO((U_CHAR *, int, int, struct arglist *));
1121 static int compare_token_lists PROTO((struct arglist *, struct arglist *));
1123 static struct arglist *read_token_list PROTO((U_CHAR **, U_CHAR *, int *));
1124 static void free_token_list PROTO((struct arglist *));
1126 static ASSERTION_HASHNODE *assertion_install PROTO((U_CHAR *, int, int));
1127 static ASSERTION_HASHNODE *assertion_lookup PROTO((U_CHAR *, int, int));
1128 static void delete_assertion PROTO((ASSERTION_HASHNODE *));
1130 static void do_once PROTO((void));
1132 static HOST_WIDE_INT eval_if_expression PROTO((U_CHAR *, int));
1133 static void conditional_skip PROTO((FILE_BUF *, int, enum node_type, U_CHAR *, FILE_BUF *));
1134 static void skip_if_group PROTO((FILE_BUF *, int, FILE_BUF *));
1135 static void validate_else PROTO((U_CHAR *));
1137 static U_CHAR *skip_to_end_of_comment PROTO((FILE_BUF *, int *, int));
1138 static U_CHAR *skip_quoted_string PROTO((U_CHAR *, U_CHAR *, int, int *, int *, int *));
1139 static char *quote_string PROTO((char *, char *));
1140 static U_CHAR *skip_paren_group PROTO((FILE_BUF *));
1142 /* Last arg to output_line_directive. */
1143 enum file_change_code {same_file, enter_file, leave_file};
1144 static void output_line_directive PROTO((FILE_BUF *, FILE_BUF *, int, enum file_change_code));
1146 static void macroexpand PROTO((HASHNODE *, FILE_BUF *));
1149 static char *macarg PROTO((struct argdata *, int));
1151 static U_CHAR *macarg1 PROTO((U_CHAR *, U_CHAR *, int *, int *, int *, int));
1153 static int discard_comments PROTO((U_CHAR *, int, int));
1155 static int change_newlines PROTO((U_CHAR *, int));
1157 char *my_strerror PROTO((int));
1158 void error PRINTF_PROTO_1((char *, ...));
1159 static void verror PROTO((char *, va_list));
1160 static void error_from_errno PROTO((char *));
1161 void warning PRINTF_PROTO_1((char *, ...));
1162 static void vwarning PROTO((char *, va_list));
1163 static void error_with_line PRINTF_PROTO_2((int, char *, ...));
1164 static void verror_with_line PROTO((int, char *, va_list));
1165 static void vwarning_with_line PROTO((int, char *, va_list));
1166 void pedwarn PRINTF_PROTO_1((char *, ...));
1167 void pedwarn_with_line PRINTF_PROTO_2((int, char *, ...));
1168 static void pedwarn_with_file_and_line PRINTF_PROTO_3((char *, int, char *, ...));
1170 static void print_containing_files PROTO((void));
1172 static int line_for_error PROTO((int));
1173 static int grow_outbuf PROTO((FILE_BUF *, int));
1175 static HASHNODE *install PROTO((U_CHAR *, int, enum node_type, char *, int));
1176 HASHNODE *lookup PROTO((U_CHAR *, int, int));
1177 static void delete_macro PROTO((HASHNODE *));
1178 static int hashf PROTO((U_CHAR *, int, int));
1180 static void dump_single_macro PROTO((HASHNODE *, FILE *));
1181 static void dump_all_macros PROTO((void));
1182 static void dump_defn_1 PROTO((U_CHAR *, int, int, FILE *));
1183 static void dump_arg_n PROTO((DEFINITION *, int, FILE *));
1185 static void initialize_char_syntax PROTO((void));
1186 static void initialize_builtins PROTO((FILE_BUF *, FILE_BUF *));
1188 static void make_definition PROTO((char *, FILE_BUF *));
1189 static void make_undef PROTO((char *, FILE_BUF *));
1191 static void make_assertion PROTO((char *, char *));
1193 static void append_include_chain PROTO((struct file_name_list *, struct file_name_list *));
1195 static void deps_output PROTO((char *, int));
1197 static void fatal PRINTF_PROTO_1((char *, ...)) __attribute__ ((noreturn));
1198 void fancy_abort PROTO((void)) __attribute__ ((noreturn));
1199 static void perror_with_name PROTO((char *));
1200 static void pfatal_with_name PROTO((char *)) __attribute__ ((noreturn));
1201 static void pipe_closed PROTO((int)) __attribute__ ((noreturn));
1203 static void memory_full PROTO((void)) __attribute__ ((noreturn));
1204 GENERIC_PTR xmalloc PROTO((size_t));
1205 static GENERIC_PTR xrealloc PROTO((GENERIC_PTR, size_t));
1206 static GENERIC_PTR xcalloc PROTO((size_t, size_t));
1207 static char *savestring PROTO((char *));
1209 static int file_size_and_mode PROTO((int, int *, long int *));
1210 static void output_dots PROTO((FILE *, int));
1212 /* Read LEN bytes at PTR from descriptor DESC, for file FILENAME,
1213 retrying if necessary. Return a negative value if an error occurs,
1214 otherwise return the actual number of bytes read,
1215 which must be LEN unless end-of-file was reached. */
1218 safe_read (desc, ptr, len)
1225 int nchars = read (desc, ptr, left);
1242 /* Write LEN bytes at PTR to descriptor DESC,
1243 retrying if necessary, and treating any real error as fatal. */
1246 safe_write (desc, ptr, len)
1252 int written = write (desc, ptr, len);
1259 pfatal_with_name (out_fname);
1277 char **pend_files = (char **) xmalloc (argc * sizeof (char *));
1278 char **pend_defs = (char **) xmalloc (argc * sizeof (char *));
1279 char **pend_undefs = (char **) xmalloc (argc * sizeof (char *));
1280 char **pend_assertions = (char **) xmalloc (argc * sizeof (char *));
1281 char **pend_includes = (char **) xmalloc (argc * sizeof (char *));
1283 /* Record the option used with each element of pend_assertions.
1284 This is preparation for supporting more than one option for making
1286 char **pend_assertion_options = (char **) xmalloc (argc * sizeof (char *));
1287 int inhibit_predefs = 0;
1288 int no_standard_includes = 0;
1289 int no_standard_cplusplus_includes = 0;
1290 int missing_newline = 0;
1292 /* Non-0 means don't output the preprocessed program. */
1293 int inhibit_output = 0;
1294 /* Non-0 means -v, so print the full set of include dirs. */
1297 /* File name which deps are being written to.
1298 This is 0 if deps are being written to stdout. */
1299 char *deps_file = 0;
1300 /* Fopen file mode to open deps_file with. */
1301 char *deps_mode = "a";
1302 /* Stream on which to print the dependency information. */
1303 FILE *deps_stream = 0;
1304 /* Target-name to write with the dependency information. */
1305 char *deps_target = 0;
1308 /* Get rid of any avoidable limit on stack size. */
1312 /* Set the stack limit huge so that alloca (particularly stringtab
1313 * in dbxread.c) does not fail. */
1314 getrlimit (RLIMIT_STACK, &rlim);
1315 rlim.rlim_cur = rlim.rlim_max;
1316 setrlimit (RLIMIT_STACK, &rlim);
1318 #endif /* RLIMIT_STACK defined */
1321 signal (SIGPIPE, pipe_closed);
1324 cp = argv[0] + strlen (argv[0]);
1325 while (cp != argv[0] && cp[-1] != '/'
1326 #ifdef DIR_SEPARATOR
1327 && cp[-1] != DIR_SEPARATOR
1335 /* Remove directories from PROGNAME. */
1339 if ((p = rindex (s, ':')) != 0) s = p + 1; /* skip device */
1340 if ((p = rindex (s, ']')) != 0) s = p + 1; /* skip directory */
1341 if ((p = rindex (s, '>')) != 0) s = p + 1; /* alternate (int'n'l) dir */
1342 s = progname = savestring (s);
1343 if ((p = rindex (s, ';')) != 0) *p = '\0'; /* strip version number */
1344 if ((p = rindex (s, '.')) != 0 /* strip type iff ".exe" */
1345 && (p[1] == 'e' || p[1] == 'E')
1346 && (p[2] == 'x' || p[2] == 'X')
1347 && (p[3] == 'e' || p[3] == 'E')
1356 /* Initialize is_idchar to allow $. */
1357 dollars_in_ident = 1;
1358 initialize_char_syntax ();
1359 dollars_in_ident = DOLLARS_IN_IDENTIFIERS > 0;
1361 no_line_directives = 0;
1363 dump_macros = dump_none;
1366 cplusplus_comments = 0;
1368 bzero ((char *) pend_files, argc * sizeof (char *));
1369 bzero ((char *) pend_defs, argc * sizeof (char *));
1370 bzero ((char *) pend_undefs, argc * sizeof (char *));
1371 bzero ((char *) pend_assertions, argc * sizeof (char *));
1372 bzero ((char *) pend_includes, argc * sizeof (char *));
1374 /* Process switches and find input file name. */
1376 for (i = 1; i < argc; i++) {
1377 if (argv[i][0] != '-') {
1378 if (out_fname != NULL)
1379 fatal ("Usage: %s [switches] input output", argv[0]);
1380 else if (in_fname != NULL)
1381 out_fname = argv[i];
1385 switch (argv[i][1]) {
1388 if (!strcmp (argv[i], "-include")) {
1390 fatal ("Filename missing after `-include' option");
1392 pend_includes[i] = argv[i+1], i++;
1394 if (!strcmp (argv[i], "-imacros")) {
1396 fatal ("Filename missing after `-imacros' option");
1398 pend_files[i] = argv[i+1], i++;
1400 if (!strcmp (argv[i], "-iprefix")) {
1402 fatal ("Filename missing after `-iprefix' option");
1404 include_prefix = argv[++i];
1406 if (!strcmp (argv[i], "-ifoutput")) {
1407 output_conditionals = 1;
1409 if (!strcmp (argv[i], "-isystem")) {
1410 struct file_name_list *dirtmp;
1413 fatal ("Filename missing after `-isystem' option");
1415 dirtmp = (struct file_name_list *)
1416 xmalloc (sizeof (struct file_name_list));
1418 dirtmp->control_macro = 0;
1419 dirtmp->c_system_include_path = 1;
1420 dirtmp->fname = xmalloc (strlen (argv[i+1]) + 1);
1421 strcpy (dirtmp->fname, argv[++i]);
1422 dirtmp->got_name_map = 0;
1424 if (before_system == 0)
1425 before_system = dirtmp;
1427 last_before_system->next = dirtmp;
1428 last_before_system = dirtmp; /* Tail follows the last one */
1430 /* Add directory to end of path for includes,
1431 with the default prefix at the front of its name. */
1432 if (!strcmp (argv[i], "-iwithprefix")) {
1433 struct file_name_list *dirtmp;
1436 if (include_prefix != 0)
1437 prefix = include_prefix;
1439 prefix = savestring (GCC_INCLUDE_DIR);
1440 /* Remove the `include' from /usr/local/lib/gcc.../include. */
1441 if (!strcmp (prefix + strlen (prefix) - 8, "/include"))
1442 prefix[strlen (prefix) - 7] = 0;
1445 dirtmp = (struct file_name_list *)
1446 xmalloc (sizeof (struct file_name_list));
1447 dirtmp->next = 0; /* New one goes on the end */
1448 dirtmp->control_macro = 0;
1449 dirtmp->c_system_include_path = 0;
1451 fatal ("Directory name missing after `-iwithprefix' option");
1453 dirtmp->fname = xmalloc (strlen (argv[i+1]) + strlen (prefix) + 1);
1454 strcpy (dirtmp->fname, prefix);
1455 strcat (dirtmp->fname, argv[++i]);
1456 dirtmp->got_name_map = 0;
1458 if (after_include == 0)
1459 after_include = dirtmp;
1461 last_after_include->next = dirtmp;
1462 last_after_include = dirtmp; /* Tail follows the last one */
1464 /* Add directory to main path for includes,
1465 with the default prefix at the front of its name. */
1466 if (!strcmp (argv[i], "-iwithprefixbefore")) {
1467 struct file_name_list *dirtmp;
1470 if (include_prefix != 0)
1471 prefix = include_prefix;
1473 prefix = savestring (GCC_INCLUDE_DIR);
1474 /* Remove the `include' from /usr/local/lib/gcc.../include. */
1475 if (!strcmp (prefix + strlen (prefix) - 8, "/include"))
1476 prefix[strlen (prefix) - 7] = 0;
1479 dirtmp = (struct file_name_list *)
1480 xmalloc (sizeof (struct file_name_list));
1481 dirtmp->next = 0; /* New one goes on the end */
1482 dirtmp->control_macro = 0;
1483 dirtmp->c_system_include_path = 0;
1485 fatal ("Directory name missing after `-iwithprefixbefore' option");
1487 dirtmp->fname = xmalloc (strlen (argv[i+1]) + strlen (prefix) + 1);
1488 strcpy (dirtmp->fname, prefix);
1489 strcat (dirtmp->fname, argv[++i]);
1490 dirtmp->got_name_map = 0;
1492 append_include_chain (dirtmp, dirtmp);
1494 /* Add directory to end of path for includes. */
1495 if (!strcmp (argv[i], "-idirafter")) {
1496 struct file_name_list *dirtmp;
1498 dirtmp = (struct file_name_list *)
1499 xmalloc (sizeof (struct file_name_list));
1500 dirtmp->next = 0; /* New one goes on the end */
1501 dirtmp->control_macro = 0;
1502 dirtmp->c_system_include_path = 0;
1504 fatal ("Directory name missing after `-idirafter' option");
1506 dirtmp->fname = argv[++i];
1507 dirtmp->got_name_map = 0;
1509 if (after_include == 0)
1510 after_include = dirtmp;
1512 last_after_include->next = dirtmp;
1513 last_after_include = dirtmp; /* Tail follows the last one */
1518 if (out_fname != NULL)
1519 fatal ("Output filename specified twice");
1521 fatal ("Filename missing after -o option");
1522 out_fname = argv[++i];
1523 if (!strcmp (out_fname, "-"))
1528 if (!strcmp (argv[i], "-pedantic"))
1530 else if (!strcmp (argv[i], "-pedantic-errors")) {
1532 pedantic_errors = 1;
1533 } else if (!strcmp (argv[i], "-pcp")) {
1536 fatal ("Filename missing after -pcp option");
1537 pcp_fname = argv[++i];
1539 ((pcp_fname[0] != '-' || pcp_fname[1] != '\0')
1540 ? fopen (pcp_fname, "w")
1542 if (pcp_outfile == 0)
1543 pfatal_with_name (pcp_fname);
1549 if (!strcmp (argv[i], "-traditional")) {
1551 if (dollars_in_ident > 0)
1552 dollars_in_ident = 1;
1553 } else if (!strcmp (argv[i], "-trigraphs")) {
1559 if (! strcmp (argv[i], "-lang-c"))
1560 cplusplus = 0, cplusplus_comments = 0, objc = 0;
1561 if (! strcmp (argv[i], "-lang-c++"))
1562 cplusplus = 1, cplusplus_comments = 1, objc = 0;
1563 if (! strcmp (argv[i], "-lang-c-c++-comments"))
1564 cplusplus = 0, cplusplus_comments = 1, objc = 0;
1565 if (! strcmp (argv[i], "-lang-objc"))
1566 objc = 1, cplusplus = 0, cplusplus_comments = 1;
1567 if (! strcmp (argv[i], "-lang-objc++"))
1568 objc = 1, cplusplus = 1, cplusplus_comments = 1;
1569 if (! strcmp (argv[i], "-lang-asm"))
1571 if (! strcmp (argv[i], "-lint"))
1576 cplusplus = 1, cplusplus_comments = 1;
1580 inhibit_warnings = 1;
1584 if (!strcmp (argv[i], "-Wtrigraphs"))
1586 else if (!strcmp (argv[i], "-Wno-trigraphs"))
1588 else if (!strcmp (argv[i], "-Wcomment"))
1590 else if (!strcmp (argv[i], "-Wno-comment"))
1592 else if (!strcmp (argv[i], "-Wcomments"))
1594 else if (!strcmp (argv[i], "-Wno-comments"))
1596 else if (!strcmp (argv[i], "-Wtraditional"))
1598 else if (!strcmp (argv[i], "-Wno-traditional"))
1600 else if (!strcmp (argv[i], "-Wimport"))
1602 else if (!strcmp (argv[i], "-Wno-import"))
1604 else if (!strcmp (argv[i], "-Werror"))
1605 warnings_are_errors = 1;
1606 else if (!strcmp (argv[i], "-Wno-error"))
1607 warnings_are_errors = 0;
1608 else if (!strcmp (argv[i], "-Wall"))
1616 /* The style of the choices here is a bit mixed.
1617 The chosen scheme is a hybrid of keeping all options in one string
1618 and specifying each option in a separate argument:
1619 -M|-MM|-MD file|-MMD file [-MG]. An alternative is:
1620 -M|-MM|-MD file|-MMD file|-MG|-MMG; or more concisely:
1621 -M[M][G][D file]. This is awkward to handle in specs, and is not
1623 /* ??? -MG must be specified in addition to one of -M or -MM.
1624 This can be relaxed in the future without breaking anything.
1625 The converse isn't true. */
1627 /* -MG isn't valid with -MD or -MMD. This is checked for later. */
1628 if (!strcmp (argv[i], "-MG"))
1630 print_deps_missing_files = 1;
1633 if (!strcmp (argv[i], "-M"))
1635 else if (!strcmp (argv[i], "-MM"))
1637 else if (!strcmp (argv[i], "-MD"))
1639 else if (!strcmp (argv[i], "-MMD"))
1641 /* For -MD and -MMD options, write deps on file named by next arg. */
1642 if (!strcmp (argv[i], "-MD")
1643 || !strcmp (argv[i], "-MMD")) {
1645 fatal ("Filename missing after %s option", argv[i]);
1647 deps_file = argv[i];
1650 /* For -M and -MM, write deps on standard output
1651 and suppress the usual output. */
1652 deps_stream = stdout;
1659 char *p = argv[i] + 2;
1661 while ((c = *p++)) {
1662 /* Arg to -d specifies what parts of macros to dump */
1665 dump_macros = dump_only;
1669 dump_macros = dump_names;
1672 dump_macros = dump_definitions;
1680 if (argv[i][2] == '3')
1685 fprintf (stderr, "GNU CPP version %s", version_string);
1686 #ifdef TARGET_VERSION
1689 fprintf (stderr, "\n");
1694 print_include_names = 1;
1698 if (argv[i][2] != 0)
1699 pend_defs[i] = argv[i] + 2;
1700 else if (i + 1 == argc)
1701 fatal ("Macro name missing after -D option");
1703 i++, pend_defs[i] = argv[i];
1710 if (argv[i][2] != 0)
1712 else if (i + 1 == argc)
1713 fatal ("Assertion missing after -A option");
1717 if (!strcmp (p, "-")) {
1718 /* -A- eliminates all predefined macros and assertions.
1719 Let's include also any that were specified earlier
1720 on the command line. That way we can get rid of any
1721 that were passed automatically in from GCC. */
1723 inhibit_predefs = 1;
1724 for (j = 0; j < i; j++)
1725 pend_defs[j] = pend_assertions[j] = 0;
1727 pend_assertions[i] = p;
1728 pend_assertion_options[i] = "-A";
1733 case 'U': /* JF #undef something */
1734 if (argv[i][2] != 0)
1735 pend_undefs[i] = argv[i] + 2;
1736 else if (i + 1 == argc)
1737 fatal ("Macro name missing after -U option");
1739 pend_undefs[i] = argv[i+1], i++;
1743 put_out_comments = 1;
1746 case 'E': /* -E comes from cc -E; ignore it. */
1750 no_line_directives = 1;
1753 case '$': /* Don't include $ in identifiers. */
1754 dollars_in_ident = 0;
1757 case 'I': /* Add directory to path for includes. */
1759 struct file_name_list *dirtmp;
1761 if (! ignore_srcdir && !strcmp (argv[i] + 2, "-")) {
1763 /* Don't use any preceding -I directories for #include <...>. */
1764 first_bracket_include = 0;
1767 dirtmp = (struct file_name_list *)
1768 xmalloc (sizeof (struct file_name_list));
1769 dirtmp->next = 0; /* New one goes on the end */
1770 dirtmp->control_macro = 0;
1771 dirtmp->c_system_include_path = 0;
1772 if (argv[i][2] != 0)
1773 dirtmp->fname = argv[i] + 2;
1774 else if (i + 1 == argc)
1775 fatal ("Directory name missing after -I option");
1777 dirtmp->fname = argv[++i];
1778 dirtmp->got_name_map = 0;
1779 append_include_chain (dirtmp, dirtmp);
1785 if (!strcmp (argv[i], "-nostdinc"))
1786 /* -nostdinc causes no default include directories.
1787 You must specify all include-file directories with -I. */
1788 no_standard_includes = 1;
1789 else if (!strcmp (argv[i], "-nostdinc++"))
1790 /* -nostdinc++ causes no default C++-specific include directories. */
1791 no_standard_cplusplus_includes = 1;
1792 else if (!strcmp (argv[i], "-noprecomp"))
1797 /* Sun compiler passes undocumented switch "-undef".
1798 Let's assume it means to inhibit the predefined symbols. */
1799 inhibit_predefs = 1;
1802 case '\0': /* JF handle '-' as file name meaning stdin or stdout */
1803 if (in_fname == NULL) {
1806 } else if (out_fname == NULL) {
1809 } /* else fall through into error */
1812 fatal ("Invalid option `%s'", argv[i]);
1817 /* Add dirs from CPATH after dirs from -I. */
1818 /* There seems to be confusion about what CPATH should do,
1819 so for the moment it is not documented. */
1820 /* Some people say that CPATH should replace the standard include dirs,
1821 but that seems pointless: it comes before them, so it overrides them
1823 cp = getenv ("CPATH");
1824 if (cp && ! no_standard_includes)
1827 /* Now that dollars_in_ident is known, initialize is_idchar. */
1828 initialize_char_syntax ();
1830 /* Initialize output buffer */
1832 outbuf.buf = (U_CHAR *) xmalloc (OUTBUF_SIZE);
1833 outbuf.bufp = outbuf.buf;
1834 outbuf.length = OUTBUF_SIZE;
1836 /* Do partial setup of input buffer for the sake of generating
1837 early #line directives (when -g is in effect). */
1839 fp = &instack[++indepth];
1840 if (in_fname == NULL)
1842 fp->nominal_fname = fp->fname = in_fname;
1845 /* In C++, wchar_t is a distinct basic type, and we can expect
1846 __wchar_t to be defined by cc1plus. */
1848 wchar_type = "__wchar_t";
1850 /* Install __LINE__, etc. Must follow initialize_char_syntax
1851 and option processing. */
1852 initialize_builtins (fp, &outbuf);
1854 /* Do standard #defines and assertions
1855 that identify system and machine type. */
1857 if (!inhibit_predefs) {
1858 char *p = (char *) alloca (strlen (predefs) + 1);
1859 strcpy (p, predefs);
1862 while (*p == ' ' || *p == '\t')
1864 /* Handle -D options. */
1865 if (p[0] == '-' && p[1] == 'D') {
1867 while (*p && *p != ' ' && *p != '\t')
1872 output_line_directive (fp, &outbuf, 0, same_file);
1873 make_definition (q, &outbuf);
1874 while (*p == ' ' || *p == '\t')
1876 } else if (p[0] == '-' && p[1] == 'A') {
1877 /* Handle -A options (assertions). */
1886 past_name = assertion;
1887 /* Locate end of name. */
1888 while (*past_name && *past_name != ' '
1889 && *past_name != '\t' && *past_name != '(')
1891 /* Locate `(' at start of value. */
1893 while (*value && (*value == ' ' || *value == '\t'))
1895 if (*value++ != '(')
1897 while (*value && (*value == ' ' || *value == '\t'))
1900 /* Locate end of value. */
1901 while (*past_value && *past_value != ' '
1902 && *past_value != '\t' && *past_value != ')')
1904 termination = past_value;
1905 while (*termination && (*termination == ' ' || *termination == '\t'))
1907 if (*termination++ != ')')
1909 if (*termination && *termination != ' ' && *termination != '\t')
1911 /* Temporarily null-terminate the value. */
1912 save_char = *termination;
1913 *termination = '\0';
1914 /* Install the assertion. */
1915 make_assertion ("-A", assertion);
1916 *termination = (char) save_char;
1918 while (*p == ' ' || *p == '\t')
1926 /* Now handle the command line options. */
1928 /* Do -U's, -D's and -A's in the order they were seen. */
1929 for (i = 1; i < argc; i++) {
1930 if (pend_undefs[i]) {
1932 output_line_directive (fp, &outbuf, 0, same_file);
1933 make_undef (pend_undefs[i], &outbuf);
1937 output_line_directive (fp, &outbuf, 0, same_file);
1938 make_definition (pend_defs[i], &outbuf);
1940 if (pend_assertions[i])
1941 make_assertion (pend_assertion_options[i], pend_assertions[i]);
1944 done_initializing = 1;
1946 { /* read the appropriate environment variable and if it exists
1947 replace include_defaults with the listed path. */
1949 switch ((objc << 1) + cplusplus)
1952 epath = getenv ("C_INCLUDE_PATH");
1955 epath = getenv ("CPLUS_INCLUDE_PATH");
1958 epath = getenv ("OBJC_INCLUDE_PATH");
1961 epath = getenv ("OBJCPLUS_INCLUDE_PATH");
1964 /* If the environment var for this language is set,
1965 add to the default list of include directories. */
1967 char *nstore = (char *) alloca (strlen (epath) + 2);
1969 char *startp, *endp;
1971 for (num_dirs = 1, startp = epath; *startp; startp++)
1972 if (*startp == PATH_SEPARATOR)
1975 = (struct default_include *) xmalloc ((num_dirs
1976 * sizeof (struct default_include))
1977 + sizeof (include_defaults_array));
1978 startp = endp = epath;
1981 /* Handle cases like c:/usr/lib:d:/gcc/lib */
1982 if ((*endp == PATH_SEPARATOR
1983 #if 0 /* Obsolete, now that we use semicolons as the path separator. */
1985 && (endp-startp != 1 || !isalpha (*startp))
1990 strncpy (nstore, startp, endp-startp);
1992 strcpy (nstore, ".");
1994 nstore[endp-startp] = '\0';
1996 include_defaults[num_dirs].fname = savestring (nstore);
1997 include_defaults[num_dirs].cplusplus = cplusplus;
1998 include_defaults[num_dirs].cxx_aware = 1;
2002 endp = startp = endp + 1;
2006 /* Put the usual defaults back in at the end. */
2007 bcopy ((char *) include_defaults_array,
2008 (char *) &include_defaults[num_dirs],
2009 sizeof (include_defaults_array));
2013 append_include_chain (before_system, last_before_system);
2014 first_system_include = before_system;
2016 /* Unless -fnostdinc,
2017 tack on the standard include file dirs to the specified list */
2018 if (!no_standard_includes) {
2019 struct default_include *p = include_defaults;
2020 char *specd_prefix = include_prefix;
2021 char *default_prefix = savestring (GCC_INCLUDE_DIR);
2022 int default_len = 0;
2023 /* Remove the `include' from /usr/local/lib/gcc.../include. */
2024 if (!strcmp (default_prefix + strlen (default_prefix) - 8, "/include")) {
2025 default_len = strlen (default_prefix) - 7;
2026 default_prefix[default_len] = 0;
2028 /* Search "translated" versions of GNU directories.
2029 These have /usr/local/lib/gcc... replaced by specd_prefix. */
2030 if (specd_prefix != 0 && default_len != 0)
2031 for (p = include_defaults; p->fname; p++) {
2032 /* Some standard dirs are only for C++. */
2033 if (!p->cplusplus || (cplusplus && !no_standard_cplusplus_includes)) {
2034 /* Does this dir start with the prefix? */
2035 if (!strncmp (p->fname, default_prefix, default_len)) {
2036 /* Yes; change prefix and add to search list. */
2037 struct file_name_list *new
2038 = (struct file_name_list *) xmalloc (sizeof (struct file_name_list));
2039 int this_len = strlen (specd_prefix) + strlen (p->fname) - default_len;
2040 char *str = xmalloc (this_len + 1);
2041 strcpy (str, specd_prefix);
2042 strcat (str, p->fname + default_len);
2044 new->control_macro = 0;
2045 new->c_system_include_path = !p->cxx_aware;
2046 new->got_name_map = 0;
2047 append_include_chain (new, new);
2048 if (first_system_include == 0)
2049 first_system_include = new;
2053 /* Search ordinary names for GNU include directories. */
2054 for (p = include_defaults; p->fname; p++) {
2055 /* Some standard dirs are only for C++. */
2056 if (!p->cplusplus || (cplusplus && !no_standard_cplusplus_includes)) {
2057 struct file_name_list *new
2058 = (struct file_name_list *) xmalloc (sizeof (struct file_name_list));
2059 new->control_macro = 0;
2060 new->c_system_include_path = !p->cxx_aware;
2061 new->fname = p->fname;
2062 new->got_name_map = 0;
2063 append_include_chain (new, new);
2064 if (first_system_include == 0)
2065 first_system_include = new;
2070 /* Tack the after_include chain at the end of the include chain. */
2071 append_include_chain (after_include, last_after_include);
2072 if (first_system_include == 0)
2073 first_system_include = after_include;
2075 /* With -v, print the list of dirs to search. */
2077 struct file_name_list *p;
2078 fprintf (stderr, "#include \"...\" search starts here:\n");
2079 for (p = include; p; p = p->next) {
2080 if (p == first_bracket_include)
2081 fprintf (stderr, "#include <...> search starts here:\n");
2082 fprintf (stderr, " %s\n", p->fname);
2084 fprintf (stderr, "End of search list.\n");
2087 /* Scan the -imacros files before the main input.
2088 Much like #including them, but with no_output set
2089 so that only their macro definitions matter. */
2091 no_output++; no_record_file++;
2092 for (i = 1; i < argc; i++)
2093 if (pend_files[i]) {
2094 int fd = open (pend_files[i], O_RDONLY, 0666);
2096 perror_with_name (pend_files[i]);
2097 return FAILURE_EXIT_CODE;
2099 finclude (fd, pend_files[i], &outbuf, 0, NULL_PTR);
2101 no_output--; no_record_file--;
2103 /* Copy the entire contents of the main input file into
2104 the stacked input buffer previously allocated for it. */
2106 /* JF check for stdin */
2107 if (in_fname == NULL || *in_fname == 0) {
2110 } else if ((f = open (in_fname, O_RDONLY, 0666)) < 0)
2113 /* -MG doesn't select the form of output and must be specified with one of
2114 -M or -MM. -MG doesn't make sense with -MD or -MMD since they don't
2115 inhibit compilation. */
2116 if (print_deps_missing_files && (print_deps == 0 || !inhibit_output))
2117 fatal ("-MG must be specified with one of -M or -MM");
2119 /* Either of two environment variables can specify output of deps.
2120 Its value is either "OUTPUT_FILE" or "OUTPUT_FILE DEPS_TARGET",
2121 where OUTPUT_FILE is the file to write deps info to
2122 and DEPS_TARGET is the target to mention in the deps. */
2125 && (getenv ("SUNPRO_DEPENDENCIES") != 0
2126 || getenv ("DEPENDENCIES_OUTPUT") != 0)) {
2127 char *spec = getenv ("DEPENDENCIES_OUTPUT");
2132 spec = getenv ("SUNPRO_DEPENDENCIES");
2139 /* Find the space before the DEPS_TARGET, if there is one. */
2140 /* This should use index. (mrs) */
2141 while (*s != 0 && *s != ' ') s++;
2143 deps_target = s + 1;
2144 output_file = xmalloc (s - spec + 1);
2145 bcopy (spec, output_file, s - spec);
2146 output_file[s - spec] = 0;
2153 deps_file = output_file;
2157 /* For -M, print the expected object file name
2158 as the target of this Make-rule. */
2160 deps_allocated_size = 200;
2161 deps_buffer = xmalloc (deps_allocated_size);
2167 deps_output (deps_target, ':');
2168 } else if (*in_fname == 0) {
2169 deps_output ("-", ':');
2174 /* Discard all directory prefixes from filename. */
2175 if ((q = rindex (in_fname, '/')) != NULL
2176 #ifdef DIR_SEPARATOR
2177 && (q = rindex (in_fname, DIR_SEPARATOR)) != NULL
2184 /* Copy remainder to mungable area. */
2185 p = (char *) alloca (strlen(q) + 8);
2188 /* Output P, but remove known suffixes. */
2192 && p[len - 2] == '.'
2193 && index("cCsSm", p[len - 1]))
2196 && p[len - 3] == '.'
2197 && p[len - 2] == 'c'
2198 && p[len - 1] == 'c')
2201 && p[len - 4] == '.'
2202 && p[len - 3] == 'c'
2203 && p[len - 2] == 'x'
2204 && p[len - 1] == 'x')
2207 && p[len - 4] == '.'
2208 && p[len - 3] == 'c'
2209 && p[len - 2] == 'p'
2210 && p[len - 1] == 'p')
2213 /* Supply our own suffix. */
2220 deps_output (p, ':');
2221 deps_output (in_fname, ' ');
2225 file_size_and_mode (f, &st_mode, &st_size);
2226 fp->nominal_fname = fp->fname = in_fname;
2228 fp->system_header_p = 0;
2229 /* JF all this is mine about reading pipes and ttys */
2230 if (! S_ISREG (st_mode)) {
2231 /* Read input from a file that is not a normal disk file.
2232 We cannot preallocate a buffer with the correct size,
2233 so we must read in the file a piece at the time and make it bigger. */
2240 fp->buf = (U_CHAR *) xmalloc (bsize + 2);
2242 cnt = safe_read (f, (char *) fp->buf + size, bsize - size);
2243 if (cnt < 0) goto perror; /* error! */
2245 if (size != bsize) break; /* End of file */
2247 fp->buf = (U_CHAR *) xrealloc (fp->buf, bsize + 2);
2251 /* Read a file whose size we can determine in advance.
2252 For the sake of VMS, st_size is just an upper bound. */
2253 fp->buf = (U_CHAR *) xmalloc (st_size + 2);
2254 fp->length = safe_read (f, (char *) fp->buf, st_size);
2255 if (fp->length < 0) goto perror;
2258 fp->if_stack = if_stack;
2260 /* Make sure data ends with a newline. And put a null after it. */
2262 if ((fp->length > 0 && fp->buf[fp->length - 1] != '\n')
2263 /* Backslash-newline at end is not good enough. */
2264 || (fp->length > 1 && fp->buf[fp->length - 2] == '\\')) {
2265 fp->buf[fp->length++] = '\n';
2266 missing_newline = 1;
2268 fp->buf[fp->length] = '\0';
2270 /* Unless inhibited, convert trigraphs in the input. */
2275 /* Now that we know the input file is valid, open the output. */
2277 if (!out_fname || !strcmp (out_fname, ""))
2278 out_fname = "stdout";
2279 else if (! freopen (out_fname, "w", stdout))
2280 pfatal_with_name (out_fname);
2282 output_line_directive (fp, &outbuf, 0, same_file);
2284 /* Scan the -include files before the main input. */
2287 for (i = 1; i < argc; i++)
2288 if (pend_includes[i]) {
2289 int fd = open (pend_includes[i], O_RDONLY, 0666);
2291 perror_with_name (pend_includes[i]);
2292 return FAILURE_EXIT_CODE;
2294 finclude (fd, pend_includes[i], &outbuf, 0, NULL_PTR);
2298 /* Scan the input, processing macros and directives. */
2300 rescan (&outbuf, 0);
2302 if (missing_newline)
2305 if (pedantic && missing_newline)
2306 pedwarn ("file does not end in newline");
2308 /* Now we have processed the entire input
2309 Write whichever kind of output has been requested. */
2311 if (dump_macros == dump_only)
2313 else if (! inhibit_output) {
2318 /* Don't actually write the deps file if compilation has failed. */
2320 if (deps_file && ! (deps_stream = fopen (deps_file, deps_mode)))
2321 pfatal_with_name (deps_file);
2322 fputs (deps_buffer, deps_stream);
2323 putc ('\n', deps_stream);
2325 if (ferror (deps_stream) || fclose (deps_stream) != 0)
2326 fatal ("I/O error on output");
2331 if (pcp_outfile && pcp_outfile != stdout
2332 && (ferror (pcp_outfile) || fclose (pcp_outfile) != 0))
2333 fatal ("I/O error on `-pcp' output");
2335 if (ferror (stdout) || fclose (stdout) != 0)
2336 fatal ("I/O error on output");
2339 exit (FAILURE_EXIT_CODE);
2340 exit (SUCCESS_EXIT_CODE);
2343 pfatal_with_name (in_fname);
2347 /* Given a colon-separated list of file names PATH,
2348 add all the names to the search path for include files. */
2362 struct file_name_list *dirtmp;
2364 /* Find the end of this name. */
2365 while (*q != 0 && *q != PATH_SEPARATOR) q++;
2367 /* An empty name in the path stands for the current directory. */
2372 /* Otherwise use the directory that is named. */
2373 name = xmalloc (q - p + 1);
2374 bcopy (p, name, q - p);
2378 dirtmp = (struct file_name_list *)
2379 xmalloc (sizeof (struct file_name_list));
2380 dirtmp->next = 0; /* New one goes on the end */
2381 dirtmp->control_macro = 0;
2382 dirtmp->c_system_include_path = 0;
2383 dirtmp->fname = name;
2384 dirtmp->got_name_map = 0;
2385 append_include_chain (dirtmp, dirtmp);
2387 /* Advance past this name. */
2391 /* Skip the colon. */
2396 /* Return the address of the first character in S that equals C.
2397 S is an array of length N, possibly containing '\0's, and followed by '\0'.
2398 Return 0 if there is no such character. Assume that C itself is not '\0'.
2399 If we knew we could use memchr, we could just invoke memchr (S, C, N),
2400 but unfortunately memchr isn't autoconfigured yet. */
2408 char *p = (char *) s;
2410 char *q = index (p, c);
2412 return (U_CHAR *) q;
2414 size_t l = strlen (p);
2424 /* Pre-C-Preprocessor to translate ANSI trigraph idiocy in BUF
2425 before main CCCP processing. Name `pcp' is also in honor of the
2426 drugs the trigraph designers must have been on.
2428 Using an extra pass through the buffer takes a little extra time,
2429 but is infinitely less hairy than trying to handle trigraphs inside
2430 strings, etc. everywhere, and also makes sure that trigraphs are
2431 only translated in the top level of processing. */
2437 register U_CHAR c, *fptr, *bptr, *sptr, *lptr;
2440 fptr = bptr = sptr = buf->buf;
2441 lptr = fptr + buf->length;
2442 while ((sptr = index0 (sptr, '?', (size_t) (lptr - sptr))) != NULL) {
2479 len = sptr - fptr - 2;
2481 /* BSD doc says bcopy () works right for overlapping strings. In ANSI
2482 C, this will be memmove (). */
2483 if (bptr != fptr && len > 0)
2484 bcopy ((char *) fptr, (char *) bptr, len);
2490 len = buf->length - (fptr - buf->buf);
2491 if (bptr != fptr && len > 0)
2492 bcopy ((char *) fptr, (char *) bptr, len);
2493 buf->length -= fptr - bptr;
2494 buf->buf[buf->length] = '\0';
2495 if (warn_trigraphs && fptr != bptr)
2496 warning ("%d trigraph(s) encountered", (fptr - bptr) / 2);
2499 /* Move all backslash-newline pairs out of embarrassing places.
2500 Exchange all such pairs following BP
2501 with any potentially-embarrassing characters that follow them.
2502 Potentially-embarrassing characters are / and *
2503 (because a backslash-newline inside a comment delimiter
2504 would cause it not to be recognized). */
2510 register U_CHAR *p = bp;
2512 /* First count the backslash-newline pairs here. */
2514 while (p[0] == '\\' && p[1] == '\n')
2517 /* What follows the backslash-newlines is not embarrassing. */
2519 if (*p != '/' && *p != '*')
2522 /* Copy all potentially embarrassing characters
2523 that follow the backslash-newline pairs
2524 down to where the pairs originally started. */
2526 while (*p == '*' || *p == '/')
2529 /* Now write the same number of pairs after the embarrassing chars. */
2536 /* Like newline_fix but for use within a directive-name.
2537 Move any backslash-newlines up past any following symbol constituents. */
2540 name_newline_fix (bp)
2543 register U_CHAR *p = bp;
2545 /* First count the backslash-newline pairs here. */
2546 while (p[0] == '\\' && p[1] == '\n')
2549 /* What follows the backslash-newlines is not embarrassing. */
2554 /* Copy all potentially embarrassing characters
2555 that follow the backslash-newline pairs
2556 down to where the pairs originally started. */
2558 while (is_idchar[*p])
2561 /* Now write the same number of pairs after the embarrassing chars. */
2568 /* Look for lint commands in comments.
2570 When we come in here, ibp points into a comment. Limit is as one expects.
2571 scan within the comment -- it should start, after lwsp, with a lint command.
2572 If so that command is returned as a (constant) string.
2574 Upon return, any arg will be pointed to with argstart and will be
2575 arglen long. Note that we don't parse that arg since it will just
2576 be printed out again.
2580 get_lintcmd (ibp, limit, argstart, arglen, cmdlen)
2581 register U_CHAR *ibp;
2582 register U_CHAR *limit;
2583 U_CHAR **argstart; /* point to command arg */
2584 int *arglen, *cmdlen; /* how long they are */
2587 register U_CHAR *numptr; /* temp for arg parsing */
2591 SKIP_WHITE_SPACE (ibp);
2593 if (ibp >= limit) return NULL;
2595 linsize = limit - ibp;
2597 /* Oh, I wish C had lexical functions... hell, I'll just open-code the set */
2598 if ((linsize >= 10) && !bcmp (ibp, "NOTREACHED", 10)) {
2600 return "NOTREACHED";
2602 if ((linsize >= 8) && !bcmp (ibp, "ARGSUSED", 8)) {
2606 if ((linsize >= 11) && !bcmp (ibp, "LINTLIBRARY", 11)) {
2608 return "LINTLIBRARY";
2610 if ((linsize >= 7) && !bcmp (ibp, "VARARGS", 7)) {
2612 ibp += 7; linsize -= 7;
2613 if ((linsize == 0) || ! isdigit (*ibp)) return "VARARGS";
2615 /* OK, read a number */
2616 for (numptr = *argstart = ibp; (numptr < limit) && isdigit (*numptr);
2618 *arglen = numptr - *argstart;
2625 * The main loop of the program.
2627 * Read characters from the input stack, transferring them to the
2630 * Macros are expanded and push levels on the input stack.
2631 * At the end of such a level it is popped off and we keep reading.
2632 * At the end of any other kind of level, we return.
2633 * #-directives are handled, except within macros.
2635 * If OUTPUT_MARKS is nonzero, keep Newline markers found in the input
2636 * and insert them when appropriate. This is set while scanning macro
2637 * arguments before substitution. It is zero when scanning for final output.
2638 * There are three types of Newline markers:
2639 * * Newline - follows a macro name that was not expanded
2640 * because it appeared inside an expansion of the same macro.
2641 * This marker prevents future expansion of that identifier.
2642 * When the input is rescanned into the final output, these are deleted.
2643 * These are also deleted by ## concatenation.
2644 * * Newline Space (or Newline and any other whitespace character)
2645 * stands for a place that tokens must be separated or whitespace
2646 * is otherwise desirable, but where the ANSI standard specifies there
2647 * is no whitespace. This marker turns into a Space (or whichever other
2648 * whitespace char appears in the marker) in the final output,
2649 * but it turns into nothing in an argument that is stringified with #.
2650 * Such stringified arguments are the only place where the ANSI standard
2651 * specifies with precision that whitespace may not appear.
2653 * During this function, IP->bufp is kept cached in IBP for speed of access.
2654 * Likewise, OP->bufp is kept in OBP. Before calling a subroutine
2655 * IBP, IP and OBP must be copied back to memory. IP and IBP are
2656 * copied back with the RECACHE macro. OBP must be copied back from OP->bufp
2657 * explicitly, and before RECACHE, since RECACHE uses OBP.
2661 rescan (op, output_marks)
2665 /* Character being scanned in main loop. */
2668 /* Length of pending accumulated identifier. */
2669 register int ident_length = 0;
2671 /* Hash code of pending accumulated identifier. */
2672 register int hash = 0;
2674 /* Current input level (&instack[indepth]). */
2677 /* Pointer for scanning input. */
2678 register U_CHAR *ibp;
2680 /* Pointer to end of input. End of scan is controlled by LIMIT. */
2681 register U_CHAR *limit;
2683 /* Pointer for storing output. */
2684 register U_CHAR *obp;
2686 /* REDO_CHAR is nonzero if we are processing an identifier
2687 after backing up over the terminating character.
2688 Sometimes we process an identifier without backing up over
2689 the terminating character, if the terminating character
2690 is not special. Backing up is done so that the terminating character
2691 will be dispatched on again once the identifier is dealt with. */
2694 /* 1 if within an identifier inside of which a concatenation
2695 marker (Newline -) has been seen. */
2696 int concatenated = 0;
2698 /* While scanning a comment or a string constant,
2699 this records the line it started on, for error messages. */
2702 /* Record position of last `real' newline. */
2703 U_CHAR *beg_of_line;
2705 /* Pop the innermost input stack level, assuming it is a macro expansion. */
2708 do { ip->macro->type = T_MACRO; \
2709 if (ip->free_ptr) free (ip->free_ptr); \
2710 --indepth; } while (0)
2712 /* Reload `rescan's local variables that describe the current
2713 level of the input stack. */
2716 do { ip = &instack[indepth]; \
2718 limit = ip->buf + ip->length; \
2720 check_expand (op, limit - ibp); \
2722 obp = op->bufp; } while (0)
2724 if (no_output && instack[indepth].fname != 0)
2725 skip_if_group (&instack[indepth], 1, NULL);
2732 /* Our caller must always put a null after the end of
2733 the input at each input stack level. */
2743 if (*ibp == '\n' && !ip->macro) {
2744 /* At the top level, always merge lines ending with backslash-newline,
2745 even in middle of identifier. But do not merge lines in a macro,
2746 since backslash might be followed by a newline-space marker. */
2749 --obp; /* remove backslash from obuf */
2752 /* If ANSI, backslash is just another character outside a string. */
2755 /* Otherwise, backslash suppresses specialness of following char,
2756 so copy it here to prevent the switch from seeing it.
2757 But first get any pending identifier processed. */
2758 if (ident_length > 0)
2765 if (ident_length || ip->macro || traditional)
2767 while (*ibp == '\\' && ibp[1] == '\n') {
2773 /* Treat this %: digraph as if it were #. */
2777 if (assertions_flag) {
2778 /* Copy #foo (bar lose) without macro expansion. */
2779 obp[-1] = '#'; /* In case it was '%'. */
2780 SKIP_WHITE_SPACE (ibp);
2781 while (is_idchar[*ibp])
2783 SKIP_WHITE_SPACE (ibp);
2786 skip_paren_group (ip);
2787 bcopy ((char *) ibp, (char *) obp, ip->bufp - ibp);
2788 obp += ip->bufp - ibp;
2793 /* If this is expanding a macro definition, don't recognize
2794 preprocessing directives. */
2797 /* If this is expand_into_temp_buffer,
2798 don't recognize them either. Warn about them
2799 only after an actual newline at this level,
2800 not at the beginning of the input level. */
2802 if (ip->buf != beg_of_line)
2803 warning ("preprocessing directive not recognized within macro arg");
2810 /* # keyword: a # must be first nonblank char on the line */
2811 if (beg_of_line == 0)
2816 /* Scan from start of line, skipping whitespace, comments
2817 and backslash-newlines, and see if we reach this #.
2818 If not, this # is not special. */
2820 /* If -traditional, require # to be at beginning of line. */
2823 if (is_hor_space[*bp])
2825 else if (*bp == '\\' && bp[1] == '\n')
2827 else if (*bp == '/' && bp[1] == '*') {
2829 while (!(*bp == '*' && bp[1] == '/'))
2833 /* There is no point in trying to deal with C++ // comments here,
2834 because if there is one, then this # must be part of the
2835 comment and we would never reach here. */
2841 while (bp[1] == '\\' && bp[2] == '\n')
2845 /* %: appears at start of line; skip past the ':' too. */
2854 /* This # can start a directive. */
2856 --obp; /* Don't copy the '#' */
2860 if (! handle_directive (ip, op)) {
2864 /* Not a known directive: treat it as ordinary text.
2865 IP, OP, IBP, etc. have not been changed. */
2866 if (no_output && instack[indepth].fname) {
2867 /* If not generating expanded output,
2868 what we do with ordinary text is skip it.
2869 Discard everything until next # directive. */
2870 skip_if_group (&instack[indepth], 1, 0);
2875 *obp++ = '#'; /* Copy # (even if it was originally %:). */
2876 /* Don't expand an identifier that could be a macro directive.
2877 (Section 3.8.3 of the ANSI C standard) */
2878 SKIP_WHITE_SPACE (ibp);
2879 if (is_idstart[*ibp])
2882 while (is_idchar[*ibp])
2890 /* A # directive has been successfully processed. */
2891 /* If not generating expanded output, ignore everything until
2892 next # directive. */
2893 if (no_output && instack[indepth].fname)
2894 skip_if_group (&instack[indepth], 1, 0);
2900 case '\"': /* skip quoted string */
2902 /* A single quoted string is treated like a double -- some
2903 programs (e.g., troff) are perverse this way */
2908 start_line = ip->lineno;
2910 /* Skip ahead to a matching quote. */
2914 if (ip->macro != 0) {
2915 /* try harder: this string crosses a macro expansion boundary.
2916 This can happen naturally if -traditional.
2917 Otherwise, only -D can make a macro with an unmatched quote. */
2923 error_with_line (line_for_error (start_line),
2924 "unterminated string or character constant");
2925 error_with_line (multiline_string_line,
2926 "possible real start of unterminated constant");
2927 multiline_string_line = 0;
2936 /* Traditionally, end of line ends a string constant with no error.
2937 So exit the loop and record the new line. */
2943 error_with_line (line_for_error (start_line),
2944 "unterminated character constant");
2947 if (pedantic && multiline_string_line == 0) {
2948 pedwarn_with_line (line_for_error (start_line),
2949 "string constant runs past end of line");
2951 if (multiline_string_line == 0)
2952 multiline_string_line = ip->lineno - 1;
2959 /* Backslash newline is replaced by nothing at all,
2960 but keep the line counts correct. */
2965 /* ANSI stupidly requires that in \\ the second \
2966 is *not* prevented from combining with a newline. */
2967 while (*ibp == '\\' && ibp[1] == '\n') {
2986 if (*ibp == '\\' && ibp[1] == '\n')
2990 && !(cplusplus_comments && *ibp == '/'))
2998 /* C++ style comment... */
2999 start_line = ip->lineno;
3001 --ibp; /* Back over the slash */
3004 /* Comments are equivalent to spaces. */
3005 if (! put_out_comments)
3008 /* must fake up a comment here */
3013 U_CHAR *before_bp = ibp+2;
3015 while (ibp < limit) {
3016 if (ibp[-1] != '\\' && *ibp == '\n') {
3017 if (put_out_comments) {
3018 bcopy ((char *) before_bp, (char *) obp, ibp - before_bp);
3019 obp += ibp - before_bp;
3025 /* Copy the newline into the output buffer, in order to
3026 avoid the pain of a #line every time a multiline comment
3028 if (!put_out_comments)
3039 /* Ordinary C comment. Skip it, optionally copying it to output. */
3041 start_line = ip->lineno;
3043 ++ibp; /* Skip the star. */
3045 /* If this cpp is for lint, we peek inside the comments: */
3049 char *lintcmd = get_lintcmd (ibp, limit, &argbp, &arglen, &cmdlen);
3051 if (lintcmd != NULL) {
3053 check_expand (op, cmdlen + arglen + 14);
3055 /* I believe it is always safe to emit this newline: */
3057 bcopy ("#pragma lint ", (char *) obp, 13);
3059 bcopy (lintcmd, (char *) obp, cmdlen);
3064 bcopy (argbp, (char *) obp, arglen);
3068 /* OK, now bring us back to the state we were in before we entered
3069 this branch. We need #line because the #pragma's newline always
3070 messes up the line count. */
3072 output_line_directive (ip, op, 0, same_file);
3073 check_expand (op, limit - ibp + 2);
3079 /* Comments are equivalent to spaces.
3080 Note that we already output the slash; we might not want it.
3081 For -traditional, a comment is equivalent to nothing. */
3082 if (! put_out_comments) {
3092 U_CHAR *before_bp = ibp;
3094 while (ibp < limit) {
3097 if (warn_comments && *ibp == '*')
3098 warning ("`/*' within comment");
3101 if (*ibp == '\\' && ibp[1] == '\n')
3103 if (ibp >= limit || *ibp == '/')
3108 /* Copy the newline into the output buffer, in order to
3109 avoid the pain of a #line every time a multiline comment
3111 if (!put_out_comments)
3119 error_with_line (line_for_error (start_line),
3120 "unterminated comment");
3123 if (put_out_comments) {
3124 bcopy ((char *) before_bp, (char *) obp, ibp - before_bp);
3125 obp += ibp - before_bp;
3132 if (!dollars_in_ident)
3136 case '0': case '1': case '2': case '3': case '4':
3137 case '5': case '6': case '7': case '8': case '9':
3138 /* If digit is not part of identifier, it starts a number,
3139 which means that following letters are not an identifier.
3140 "0x5" does not refer to an identifier "x5".
3141 So copy all alphanumerics that follow without accumulating
3142 as an identifier. Periods also, for sake of "3.e7". */
3144 if (ident_length == 0) {
3146 while (ibp[0] == '\\' && ibp[1] == '\n') {
3151 if (!is_idchar[c] && c != '.') {
3156 /* A sign can be part of a preprocessing number
3157 if it follows an e. */
3158 if (c == 'e' || c == 'E') {
3159 while (ibp[0] == '\\' && ibp[1] == '\n') {
3163 if (*ibp == '+' || *ibp == '-') {
3165 /* But traditional C does not let the token go past the sign. */
3176 case 'a': case 'b': case 'c': case 'd': case 'e': case 'f':
3177 case 'g': case 'h': case 'i': case 'j': case 'k': case 'l':
3178 case 'm': case 'n': case 'o': case 'p': case 'q': case 'r':
3179 case 's': case 't': case 'u': case 'v': case 'w': case 'x':
3181 case 'A': case 'B': case 'C': case 'D': case 'E': case 'F':
3182 case 'G': case 'H': case 'I': case 'J': case 'K': case 'L':
3183 case 'M': case 'N': case 'O': case 'P': case 'Q': case 'R':
3184 case 'S': case 'T': case 'U': case 'V': case 'W': case 'X':
3188 /* Compute step of hash function, to avoid a proc call on every token */
3189 hash = HASHSTEP (hash, c);
3193 if (ip->fname == 0 && *ibp == '-') {
3194 /* Newline - inhibits expansion of preceding token.
3195 If expanding a macro arg, we keep the newline -.
3196 In final output, it is deleted.
3197 We recognize Newline - in macro bodies and macro args. */
3198 if (! concatenated) {
3203 if (!output_marks) {
3206 /* If expanding a macro arg, keep the newline -. */
3212 /* If reprocessing a macro expansion, newline is a special marker. */
3213 else if (ip->macro != 0) {
3214 /* Newline White is a "funny space" to separate tokens that are
3215 supposed to be separate but without space between.
3216 Here White means any whitespace character.
3217 Newline - marks a recursive macro use that is not
3218 supposed to be expandable. */
3220 if (is_space[*ibp]) {
3221 /* Newline Space does not prevent expansion of preceding token
3222 so expand the preceding token and then come back. */
3223 if (ident_length > 0)
3226 /* If generating final output, newline space makes a space. */
3227 if (!output_marks) {
3229 /* And Newline Newline makes a newline, so count it. */
3230 if (obp[-1] == '\n')
3233 /* If expanding a macro arg, keep the newline space.
3234 If the arg gets stringified, newline space makes nothing. */
3237 } else abort (); /* Newline followed by something random? */
3241 /* If there is a pending identifier, handle it and come back here. */
3242 if (ident_length > 0)
3247 /* Update the line counts and output a #line if necessary. */
3250 if (ip->lineno != op->lineno) {
3252 output_line_directive (ip, op, 1, same_file);
3253 check_expand (op, limit - ibp);
3258 /* Come here either after (1) a null character that is part of the input
3259 or (2) at the end of the input, because there is a null there. */
3262 /* Our input really contains a null character. */
3265 /* At end of a macro-expansion level, pop it and read next level. */
3266 if (ip->macro != 0) {
3269 /* If traditional, and we have an identifier that ends here,
3270 process it now, so we get the right error for recursion. */
3271 if (traditional && ident_length
3272 && ! is_idchar[*instack[indepth - 1].bufp]) {
3281 /* If we don't have a pending identifier,
3282 return at end of input. */
3283 if (ident_length == 0) {
3291 /* If we do have a pending identifier, just consider this null
3292 a special character and arrange to dispatch on it again.
3293 The second time, IDENT_LENGTH will be zero so we will return. */
3299 /* Handle the case of a character such as /, ', " or null
3300 seen following an identifier. Back over it so that
3301 after the identifier is processed the special char
3302 will be dispatched on again. */
3312 if (ident_length > 0) {
3313 register HASHNODE *hp;
3315 /* We have just seen an identifier end. If it's a macro, expand it.
3317 IDENT_LENGTH is the length of the identifier
3318 and HASH is its hash code.
3320 The identifier has already been copied to the output,
3321 so if it is a macro we must remove it.
3323 If REDO_CHAR is 0, the char that terminated the identifier
3324 has been skipped in the output and the input.
3325 OBP-IDENT_LENGTH-1 points to the identifier.
3326 If the identifier is a macro, we must back over the terminator.
3328 If REDO_CHAR is 1, the terminating char has already been
3329 backed over. OBP-IDENT_LENGTH points to the identifier. */
3331 if (!pcp_outfile || pcp_inside_if) {
3332 for (hp = hashtab[MAKE_POS (hash) % HASHSIZE]; hp != NULL;
3335 if (hp->length == ident_length) {
3336 int obufp_before_macroname;
3337 int op_lineno_before_macroname;
3338 register int i = ident_length;
3339 register U_CHAR *p = hp->name;
3340 register U_CHAR *q = obp - i;
3346 do { /* All this to avoid a strncmp () */
3351 /* We found a use of a macro name.
3352 see if the context shows it is a macro call. */
3354 /* Back up over terminating character if not already done. */
3360 /* Save this as a displacement from the beginning of the output
3361 buffer. We can not save this as a position in the output
3362 buffer, because it may get realloc'ed by RECACHE. */
3363 obufp_before_macroname = (obp - op->buf) - ident_length;
3364 op_lineno_before_macroname = op->lineno;
3366 if (hp->type == T_PCSTRING) {
3367 pcstring_used (hp); /* Mark the definition of this key
3368 as needed, ensuring that it
3370 break; /* Exit loop, since the key cannot have a
3371 definition any longer. */
3374 /* Record whether the macro is disabled. */
3375 disabled = hp->type == T_DISABLED;
3377 /* This looks like a macro ref, but if the macro was disabled,
3378 just copy its name and put in a marker if requested. */
3382 /* This error check caught useful cases such as
3383 #define foo(x,y) bar (x (y,0), y)
3386 error ("recursive use of macro `%s'", hp->name);
3390 check_expand (op, limit - ibp + 2);
3397 /* If macro wants an arglist, verify that a '(' follows.
3398 first skip all whitespace, copying it to the output
3399 after the macro name. Then, if there is no '(',
3400 decide this is not a macro call and leave things that way. */
3401 if ((hp->type == T_MACRO || hp->type == T_DISABLED)
3402 && hp->value.defn->nargs >= 0)
3404 U_CHAR *old_ibp = ibp;
3405 U_CHAR *old_obp = obp;
3406 int old_iln = ip->lineno;
3407 int old_oln = op->lineno;
3410 /* Scan forward over whitespace, copying it to the output. */
3411 if (ibp == limit && ip->macro != 0) {
3416 old_iln = ip->lineno;
3417 old_oln = op->lineno;
3419 /* A comment: copy it unchanged or discard it. */
3420 else if (*ibp == '/' && ibp[1] == '*') {
3421 if (put_out_comments) {
3424 } else if (! traditional) {
3428 while (ibp + 1 != limit
3429 && !(ibp[0] == '*' && ibp[1] == '/')) {
3430 /* We need not worry about newline-marks,
3431 since they are never found in comments. */
3433 /* Newline in a file. Count it. */
3437 if (put_out_comments)
3443 if (put_out_comments) {
3448 else if (is_space[*ibp]) {
3450 if (ibp[-1] == '\n') {
3451 if (ip->macro == 0) {
3452 /* Newline in a file. Count it. */
3455 } else if (!output_marks) {
3456 /* A newline mark, and we don't want marks
3457 in the output. If it is newline-hyphen,
3458 discard it entirely. Otherwise, it is
3459 newline-whitechar, so keep the whitechar. */
3469 /* A newline mark; copy both chars to the output. */
3477 /* It isn't a macro call.
3478 Put back the space that we just skipped. */
3481 ip->lineno = old_iln;
3482 op->lineno = old_oln;
3483 /* Exit the for loop. */
3488 /* This is now known to be a macro call.
3489 Discard the macro name from the output,
3490 along with any following whitespace just copied,
3491 but preserve newlines if not outputting marks since this
3492 is more likely to do the right thing with line numbers. */
3493 obp = op->buf + obufp_before_macroname;
3495 op->lineno = op_lineno_before_macroname;
3497 int newlines = op->lineno - op_lineno_before_macroname;
3498 while (0 < newlines--)
3502 /* Prevent accidental token-pasting with a character
3503 before the macro call. */
3504 if (!traditional && obp != op->buf) {
3506 case '!': case '%': case '&': case '*':
3507 case '+': case '-': case '/': case ':':
3508 case '<': case '=': case '>': case '^':
3510 /* If we are expanding a macro arg, make a newline marker
3511 to separate the tokens. If we are making real output,
3512 a plain space will do. */
3519 /* Expand the macro, reading arguments as needed,
3520 and push the expansion on the input stack. */
3523 macroexpand (hp, op);
3525 /* Reexamine input stack, since macroexpand has pushed
3526 a new level on it. */
3533 } /* End hash-table-search loop */
3535 ident_length = hash = 0; /* Stop collecting identifier */
3538 } /* End if (ident_length > 0) */
3540 } /* End per-char loop */
3542 /* Come here to return -- but first give an error message
3543 if there was an unterminated successful conditional. */
3545 if (if_stack != ip->if_stack)
3549 switch (if_stack->type)
3570 error_with_line (line_for_error (if_stack->lineno),
3571 "unterminated `#%s' conditional", str);
3573 if_stack = ip->if_stack;
3577 * Rescan a string into a temporary buffer and return the result
3578 * as a FILE_BUF. Note this function returns a struct, not a pointer.
3580 * OUTPUT_MARKS nonzero means keep Newline markers found in the input
3581 * and insert such markers when appropriate. See `rescan' for details.
3582 * OUTPUT_MARKS is 1 for macroexpanding a macro argument separately
3583 * before substitution; it is 0 for other uses.
3586 expand_to_temp_buffer (buf, limit, output_marks, assertions)
3587 U_CHAR *buf, *limit;
3588 int output_marks, assertions;
3590 register FILE_BUF *ip;
3592 int length = limit - buf;
3594 int odepth = indepth;
3595 int save_assertions_flag = assertions_flag;
3597 assertions_flag = assertions;
3602 /* Set up the input on the input stack. */
3604 buf1 = (U_CHAR *) alloca (length + 1);
3606 register U_CHAR *p1 = buf;
3607 register U_CHAR *p2 = buf1;
3614 /* Set up to receive the output. */
3616 obuf.length = length * 2 + 100; /* Usually enough. Why be stingy? */
3617 obuf.bufp = obuf.buf = (U_CHAR *) xmalloc (obuf.length);
3622 CHECK_DEPTH ({return obuf;});
3626 ip = &instack[indepth];
3628 ip->nominal_fname = 0;
3629 ip->system_header_p = 0;
3632 ip->length = length;
3633 ip->buf = ip->bufp = buf1;
3634 ip->if_stack = if_stack;
3636 ip->lineno = obuf.lineno = 1;
3638 /* Scan the input, create the output. */
3639 rescan (&obuf, output_marks);
3641 /* Pop input stack to original state. */
3644 if (indepth != odepth)
3647 /* Record the output. */
3648 obuf.length = obuf.bufp - obuf.buf;
3650 assertions_flag = save_assertions_flag;
3655 * Process a # directive. Expects IP->bufp to point after the '#', as in
3656 * `#define foo bar'. Passes to the directive handler
3657 * (do_define, do_include, etc.): the addresses of the 1st and
3658 * last chars of the directive (starting immediately after the #
3659 * keyword), plus op and the keyword table pointer. If the directive
3660 * contains comments it is copied into a temporary buffer sans comments
3661 * and the temporary buffer is passed to the directive handler instead.
3662 * Likewise for backslash-newlines.
3664 * Returns nonzero if this was a known # directive.
3665 * Otherwise, returns zero, without advancing the input pointer.
3669 handle_directive (ip, op)
3672 register U_CHAR *bp, *cp;
3673 register struct directive *kt;
3674 register int ident_length;
3677 /* Nonzero means we must copy the entire directive
3678 to get rid of comments or backslash-newlines. */
3679 int copy_directive = 0;
3681 U_CHAR *ident, *after_ident;
3685 /* Record where the directive started. do_xifdef needs this. */
3686 directive_start = bp - 1;
3688 /* Skip whitespace and \-newline. */
3690 if (is_hor_space[*bp]) {
3691 if (*bp != ' ' && *bp != '\t' && pedantic)
3692 pedwarn ("%s in preprocessing directive", char_name[*bp]);
3694 } else if (*bp == '/' && (bp[1] == '*'
3695 || (cplusplus_comments && bp[1] == '/'))) {
3697 skip_to_end_of_comment (ip, &ip->lineno, 0);
3699 } else if (*bp == '\\' && bp[1] == '\n') {
3700 bp += 2; ip->lineno++;
3704 /* Now find end of directive name.
3705 If we encounter a backslash-newline, exchange it with any following
3706 symbol-constituents so that we end up with a contiguous name. */
3713 if (*cp == '\\' && cp[1] == '\n')
3714 name_newline_fix (cp);
3720 ident_length = cp - bp;
3724 /* A line of just `#' becomes blank. */
3726 if (ident_length == 0 && *after_ident == '\n') {
3727 ip->bufp = after_ident;
3731 if (ident_length == 0 || !is_idstart[*ident]) {
3733 while (is_idchar[*p]) {
3734 if (*p < '0' || *p > '9')
3738 /* Handle # followed by a line number. */
3739 if (p != ident && !is_idchar[*p]) {
3740 static struct directive line_directive_table[] = {
3741 { 4, do_line, "line", T_LINE},
3744 pedwarn ("`#' followed by integer");
3745 after_ident = ident;
3746 kt = line_directive_table;
3750 /* Avoid error for `###' and similar cases unless -pedantic. */
3752 while (*p == '#' || is_hor_space[*p]) p++;
3754 if (pedantic && !lang_asm)
3755 warning ("invalid preprocessing directive");
3761 error ("invalid preprocessing directive name");
3767 * Decode the keyword and call the appropriate expansion
3768 * routine, after moving the input pointer up to the next line.
3770 for (kt = directive_table; kt->length > 0; kt++) {
3771 if (kt->length == ident_length && !bcmp (kt->name, ident, ident_length)) {
3772 register U_CHAR *buf;
3773 register U_CHAR *limit;
3776 int *already_output;
3778 /* Nonzero means do not delete comments within the directive.
3779 #define needs this when -traditional. */
3784 limit = ip->buf + ip->length;
3787 keep_comments = traditional && kt->traditional_comments;
3788 /* #import is defined only in Objective C, or when on the NeXT. */
3789 if (kt->type == T_IMPORT
3790 && !(objc || lookup ((U_CHAR *) "__NeXT__", -1, -1)))
3793 /* Find the end of this directive (first newline not backslashed
3794 and not in a string or comment).
3795 Set COPY_DIRECTIVE if the directive must be copied
3796 (it contains a backslash-newline or a comment). */
3798 buf = bp = after_ident;
3799 while (bp < limit) {
3800 register U_CHAR c = *bp++;
3808 } else if (traditional)
3815 bp = skip_quoted_string (bp - 1, limit, ip->lineno, &ip->lineno, ©_directive, &unterminated);
3816 /* Don't bother calling the directive if we already got an error
3817 message due to unterminated string. Skip everything and pretend
3818 we called the directive. */
3821 /* Traditional preprocessing permits unterminated strings. */
3830 /* <...> is special for #include. */
3832 if (!kt->angle_brackets)
3834 while (bp < limit && *bp != '>' && *bp != '\n') {
3835 if (*bp == '\\' && bp[1] == '\n') {
3845 if (*bp == '\\' && bp[1] == '\n')
3848 || (cplusplus_comments && *bp == '/')) {
3849 U_CHAR *obp = bp - 1;
3851 skip_to_end_of_comment (ip, &ip->lineno, 0);
3853 /* No need to copy the directive because of a comment at the end;
3854 just don't include the comment in the directive. */
3855 if (bp == limit || *bp == '\n') {
3859 /* Don't remove the comments if -traditional. */
3860 if (! keep_comments)
3869 pedwarn ("%s in preprocessing directive", char_name[c]);
3873 --bp; /* Point to the newline */
3881 resume_p = ip->bufp;
3882 /* BP is the end of the directive.
3883 RESUME_P is the next interesting data after the directive.
3884 A comment may come between. */
3886 /* If a directive should be copied through, and -E was given,
3887 pass it through before removing comments. */
3888 if (!no_output && kt->pass_thru && put_out_comments) {
3891 /* Output directive name. */
3892 check_expand (op, kt->length + 2);
3893 /* Make sure # is at the start of a line */
3894 if (op->bufp > op->buf && op->bufp[-1] != '\n') {
3899 bcopy (kt->name, op->bufp, kt->length);
3900 op->bufp += kt->length;
3902 /* Output arguments. */
3904 check_expand (op, len);
3905 bcopy (buf, (char *) op->bufp, len);
3907 /* Take account of any (escaped) newlines just output. */
3909 if (buf[len] == '\n')
3912 already_output = &junk;
3913 } /* Don't we need a newline or #line? */
3915 if (copy_directive) {
3916 register U_CHAR *xp = buf;
3917 /* Need to copy entire directive into temp buffer before dispatching */
3919 cp = (U_CHAR *) alloca (bp - buf + 5); /* room for directive plus
3923 /* Copy to the new buffer, deleting comments
3924 and backslash-newlines (and whitespace surrounding the latter). */
3927 register U_CHAR c = *xp++;
3932 abort (); /* A bare newline should never part of the line. */
3935 /* <...> is special for #include. */
3937 if (!kt->angle_brackets)
3939 while (xp < bp && c != '>') {
3941 if (c == '\\' && xp < bp && *xp == '\n')
3952 if (cp != buf && is_space[cp[-1]]) {
3953 while (cp != buf && is_space[cp[-1]]) cp--;
3955 SKIP_WHITE_SPACE (xp);
3956 } else if (is_space[*xp]) {
3958 SKIP_WHITE_SPACE (xp);
3960 } else if (traditional && xp < bp) {
3968 register U_CHAR *bp1
3969 = skip_quoted_string (xp - 1, bp, ip->lineno,
3970 NULL_PTR, NULL_PTR, NULL_PTR);
3984 || (cplusplus_comments && *xp == '/')) {
3986 /* If we already copied the directive through,
3987 already_output != 0 prevents outputting comment now. */
3988 skip_to_end_of_comment (ip, already_output, 0);
3990 while (xp != ip->bufp)
3992 /* Delete or replace the slash. */
3993 else if (traditional)
4002 /* Null-terminate the copy. */
4008 ip->bufp = resume_p;
4010 /* Some directives should be written out for cc1 to process,
4011 just as if they were not defined. And sometimes we're copying
4012 definitions through. */
4014 if (!no_output && already_output == 0
4016 || (kt->type == T_DEFINE
4017 && (dump_macros == dump_names
4018 || dump_macros == dump_definitions)))) {
4021 /* Output directive name. */
4022 check_expand (op, kt->length + 1);
4024 bcopy (kt->name, (char *) op->bufp, kt->length);
4025 op->bufp += kt->length;
4027 if (kt->pass_thru || dump_macros == dump_definitions) {
4028 /* Output arguments. */
4030 check_expand (op, len);
4031 bcopy (buf, (char *) op->bufp, len);
4033 } else if (kt->type == T_DEFINE && dump_macros == dump_names) {
4036 SKIP_WHITE_SPACE (xp);
4038 while (is_idchar[*xp]) xp++;
4040 check_expand (op, len + 1);
4042 bcopy (yp, op->bufp, len);
4045 } /* Don't we need a newline or #line? */
4047 /* Call the appropriate directive handler. buf now points to
4048 either the appropriate place in the input buffer, or to
4049 the temp buffer if it was necessary to make one. cp
4050 points to the first char after the contents of the (possibly
4051 copied) directive, in either case. */
4052 (*kt->func) (buf, cp, op, kt);
4053 check_expand (op, ip->length - (ip->bufp - ip->buf));
4059 /* It is deliberate that we don't warn about undefined directives.
4060 That is the responsibility of cc1. */
4067 static struct tm *timebuf;
4069 time_t t = time ((time_t *)0);
4070 timebuf = localtime (&t);
4075 static char *monthnames[] = {"Jan", "Feb", "Mar", "Apr", "May", "Jun",
4076 "Jul", "Aug", "Sep", "Oct", "Nov", "Dec",
4080 * expand things like __FILE__. Place the expansion into the output
4081 * buffer *without* rescanning.
4085 special_symbol (hp, op)
4092 FILE_BUF *ip = NULL;
4095 int paren = 0; /* For special `defined' keyword */
4097 if (pcp_outfile && pcp_inside_if
4098 && hp->type != T_SPEC_DEFINED && hp->type != T_CONST)
4099 error ("Predefined macro `%s' used inside `#if' during precompilation",
4102 for (i = indepth; i >= 0; i--)
4103 if (instack[i].fname != NULL) {
4108 error ("cccp error: not in any file?!");
4109 return; /* the show must go on */
4117 if (hp->type == T_FILE)
4118 string = ip->nominal_fname;
4120 string = instack[0].nominal_fname;
4124 buf = (char *) alloca (3 + 4 * strlen (string));
4125 quote_string (buf, string);
4133 case T_INCLUDE_LEVEL:
4135 for (i = indepth; i >= 0; i--)
4136 if (instack[i].fname != NULL)
4139 buf = (char *) alloca (8); /* Eight bytes ought to be more than enough */
4140 sprintf (buf, "%d", true_indepth - 1);
4144 buf = (char *) alloca (3 + strlen (version_string));
4145 sprintf (buf, "\"%s\"", version_string);
4148 #ifndef NO_BUILTIN_SIZE_TYPE
4154 #ifndef NO_BUILTIN_PTRDIFF_TYPE
4155 case T_PTRDIFF_TYPE:
4164 case T_USER_LABEL_PREFIX_TYPE:
4165 buf = USER_LABEL_PREFIX;
4168 case T_REGISTER_PREFIX_TYPE:
4169 buf = REGISTER_PREFIX;
4172 case T_IMMEDIATE_PREFIX_TYPE:
4173 buf = IMMEDIATE_PREFIX;
4177 buf = hp->value.cpval;
4178 if (pcp_inside_if && pcp_outfile)
4179 /* Output a precondition for this macro use */
4180 fprintf (pcp_outfile, "#define %s %s\n", hp->name, buf);
4184 buf = (char *) alloca (10);
4185 sprintf (buf, "%d", ip->lineno);
4190 buf = (char *) alloca (20);
4191 timebuf = timestamp ();
4192 if (hp->type == T_DATE)
4193 sprintf (buf, "\"%s %2d %4d\"", monthnames[timebuf->tm_mon],
4194 timebuf->tm_mday, timebuf->tm_year + 1900);
4196 sprintf (buf, "\"%02d:%02d:%02d\"", timebuf->tm_hour, timebuf->tm_min,
4200 case T_SPEC_DEFINED:
4201 buf = " 0 "; /* Assume symbol is not defined */
4202 ip = &instack[indepth];
4203 SKIP_WHITE_SPACE (ip->bufp);
4204 if (*ip->bufp == '(') {
4206 ip->bufp++; /* Skip over the paren */
4207 SKIP_WHITE_SPACE (ip->bufp);
4210 if (!is_idstart[*ip->bufp])
4212 if ((hp = lookup (ip->bufp, -1, -1))) {
4213 if (pcp_outfile && pcp_inside_if
4214 && (hp->type == T_CONST
4215 || (hp->type == T_MACRO && hp->value.defn->predefined)))
4216 /* Output a precondition for this macro use. */
4217 fprintf (pcp_outfile, "#define %s\n", hp->name);
4221 if (pcp_outfile && pcp_inside_if) {
4222 /* Output a precondition for this macro use */
4223 U_CHAR *cp = ip->bufp;
4224 fprintf (pcp_outfile, "#undef ");
4225 while (is_idchar[*cp]) /* Ick! */
4226 fputc (*cp++, pcp_outfile);
4227 putc ('\n', pcp_outfile);
4229 while (is_idchar[*ip->bufp])
4231 SKIP_WHITE_SPACE (ip->bufp);
4233 if (*ip->bufp != ')')
4241 error ("`defined' without an identifier");
4245 error ("cccp error: invalid special hash type"); /* time for gdb */
4249 check_expand (op, len);
4250 bcopy (buf, (char *) op->bufp, len);
4257 /* Routines to handle #directives */
4259 /* Handle #include and #import.
4260 This function expects to see "fname" or <fname> on the input. */
4263 do_include (buf, limit, op, keyword)
4264 U_CHAR *buf, *limit;
4266 struct directive *keyword;
4268 int importing = (keyword->type == T_IMPORT);
4269 int skip_dirs = (keyword->type == T_INCLUDE_NEXT);
4270 static int import_warning = 0;
4271 char *fname; /* Dynamically allocated fname buffer */
4274 U_CHAR *fbeg, *fend; /* Beginning and end of fname */
4276 struct file_name_list *search_start = include; /* Chain of dirs to search */
4277 struct file_name_list dsp[1]; /* First in chain, if #include "..." */
4278 struct file_name_list *searchptr = 0;
4281 int f; /* file number */
4283 int retried = 0; /* Have already tried macro
4284 expanding the include line*/
4285 int angle_brackets = 0; /* 0 for "...", 1 for <...> */
4290 f= -1; /* JF we iz paranoid! */
4292 if (importing && warn_import && !inhibit_warnings
4293 && !instack[indepth].system_header_p && !import_warning) {
4295 warning ("using `#import' is not recommended");
4296 fprintf (stderr, "The fact that a certain header file need not be processed more than once\n");
4297 fprintf (stderr, "should be indicated in the header file, not where it is used.\n");
4298 fprintf (stderr, "The best way to do this is with a conditional of this form:\n\n");
4299 fprintf (stderr, " #ifndef _FOO_H_INCLUDED\n");
4300 fprintf (stderr, " #define _FOO_H_INCLUDED\n");
4301 fprintf (stderr, " ... <real contents of file> ...\n");
4302 fprintf (stderr, " #endif /* Not _FOO_H_INCLUDED */\n\n");
4303 fprintf (stderr, "Then users can use `#include' any number of times.\n");
4304 fprintf (stderr, "GNU C automatically avoids processing the file more than once\n");
4305 fprintf (stderr, "when it is equipped with such a conditional.\n");
4311 SKIP_WHITE_SPACE (fbeg);
4312 /* Discard trailing whitespace so we can easily see
4313 if we have parsed all the significant chars we were given. */
4314 while (limit != fbeg && is_hor_space[limit[-1]]) limit--;
4320 /* Copy the operand text, concatenating the strings. */
4323 fbeg = (U_CHAR *) alloca (limit - fbeg + 1);
4325 while (fin != limit) {
4326 while (fin != limit && *fin != '\"')
4331 /* If not at the end, there had better be another string. */
4332 /* Skip just horiz space, and don't go past limit. */
4333 while (fin != limit && is_hor_space[*fin]) fin++;
4334 if (fin != limit && *fin == '\"')
4342 /* We have "filename". Figure out directory this source
4343 file is coming from and put it on the front of the list. */
4345 /* If -I- was specified, don't search current dir, only spec'd ones. */
4346 if (ignore_srcdir) break;
4348 for (fp = &instack[indepth]; fp >= instack; fp--)
4353 if ((nam = fp->nominal_fname) != NULL) {
4354 /* Found a named file. Figure out dir of the file,
4355 and put it in front of the search list. */
4356 dsp[0].next = search_start;
4359 ep = rindex (nam, '/');
4360 #ifdef DIR_SEPARATOR
4361 if (ep == NULL) ep = rindex (nam, DIR_SEPARATOR);
4363 char *tmp = rindex (nam, DIR_SEPARATOR);
4364 if (tmp != NULL && tmp > ep) ep = tmp;
4368 ep = rindex (nam, ']');
4369 if (ep == NULL) ep = rindex (nam, '>');
4370 if (ep == NULL) ep = rindex (nam, ':');
4371 if (ep != NULL) ep++;
4375 dsp[0].fname = (char *) alloca (n + 1);
4376 strncpy (dsp[0].fname, nam, n);
4377 dsp[0].fname[n] = '\0';
4378 if (n + INCLUDE_LEN_FUDGE > max_include_len)
4379 max_include_len = n + INCLUDE_LEN_FUDGE;
4381 dsp[0].fname = 0; /* Current directory */
4383 dsp[0].got_name_map = 0;
4392 while (fend != limit && *fend != '>') fend++;
4393 if (*fend == '>' && fend + 1 == limit) {
4395 /* If -I-, start with the first -I dir after the -I-. */
4396 if (first_bracket_include)
4397 search_start = first_bracket_include;
4405 * Support '#include xyz' like VAX-C to allow for easy use of all the
4406 * decwindow include files. It defaults to '#include <xyz.h>' (so the
4407 * code from case '<' is repeated here) and generates a warning.
4408 * (Note: macro expansion of `xyz' takes precedence.)
4410 if (retried && isalpha(*(--fbeg))) {
4412 while (fend != limit && (!isspace(*fend))) fend++;
4413 warning ("VAX-C-style include specification found, use '#include <filename.h>' !");
4414 if (fend == limit) {
4416 /* If -I-, start with the first -I dir after the -I-. */
4417 if (first_bracket_include)
4418 search_start = first_bracket_include;
4426 error ("`#%s' expects \"FILENAME\" or <FILENAME>", keyword->name);
4429 /* Expand buffer and then remove any newline markers.
4430 We can't just tell expand_to_temp_buffer to omit the markers,
4431 since it would put extra spaces in include file names. */
4434 trybuf = expand_to_temp_buffer (buf, limit, 1, 0);
4436 buf = (U_CHAR *) alloca (trybuf.bufp - trybuf.buf + 1);
4438 while (src != trybuf.bufp) {
4439 switch ((*limit++ = *src++)) {
4448 U_CHAR *src1 = skip_quoted_string (src - 1, trybuf.bufp, 0,
4449 NULL_PTR, NULL_PTR, NULL_PTR);
4463 /* For #include_next, skip in the search path
4464 past the dir in which the containing file was found. */
4467 for (fp = &instack[indepth]; fp >= instack; fp--)
4468 if (fp->fname != NULL) {
4469 /* fp->dir is null if the containing file was specified
4470 with an absolute file name. In that case, don't skip anything. */
4472 search_start = fp->dir->next;
4481 error ("empty file name in `#%s'", keyword->name);
4485 /* Allocate this permanently, because it gets stored in the definitions
4487 fname = xmalloc (max_include_len + flen + 4);
4488 /* + 2 above for slash and terminating null. */
4489 /* + 2 added for '.h' on VMS (to support '#include filename') */
4491 /* If specified file name is absolute, just open it. */
4494 #ifdef DIR_SEPARATOR
4495 || *fbeg == DIR_SEPARATOR
4498 strncpy (fname, (char *) fbeg, flen);
4500 if (redundant_include_p (fname))
4503 f = lookup_import (fname, NULL_PTR);
4505 f = open_include_file (fname, NULL_PTR);
4507 return 0; /* Already included this file */
4509 /* Search directory path, trying to open the file.
4510 Copy each filename tried into FNAME. */
4512 for (searchptr = search_start; searchptr; searchptr = searchptr->next) {
4513 if (searchptr->fname) {
4514 /* The empty string in a search path is ignored.
4515 This makes it possible to turn off entirely
4516 a standard piece of the list. */
4517 if (searchptr->fname[0] == 0)
4519 strcpy (fname, searchptr->fname);
4520 strcat (fname, "/");
4521 fname[strlen (fname) + flen] = 0;
4525 strncat (fname, (char *) fbeg, flen);
4527 /* Change this 1/2 Unix 1/2 VMS file specification into a
4528 full VMS file specification */
4529 if (searchptr->fname && (searchptr->fname[0] != 0)) {
4530 /* Fix up the filename */
4531 hack_vms_include_specification (fname);
4533 /* This is a normal VMS filespec, so use it unchanged. */
4534 strncpy (fname, fbeg, flen);
4536 /* if it's '#include filename', add the missing .h */
4537 if (index(fname,'.')==NULL) {
4538 strcat (fname, ".h");
4542 /* ??? There are currently 3 separate mechanisms for avoiding processing
4543 of redundant include files: #import, #pragma once, and
4544 redundant_include_p. It would be nice if they were unified. */
4545 if (redundant_include_p (fname))
4548 f = lookup_import (fname, searchptr);
4550 f = open_include_file (fname, searchptr);
4552 return 0; /* Already included this file */
4554 else if (f == -1 && errno == EACCES)
4555 warning ("Header file %s exists, but is not readable", fname);
4563 /* A file that was not found. */
4565 strncpy (fname, (char *) fbeg, flen);
4567 /* If generating dependencies and -MG was specified, we assume missing
4568 files are leaf files, living in the same directory as the source file
4569 or other similar place; these missing files may be generated from
4570 other files and may not exist yet (eg: y.tab.h). */
4571 if (print_deps_missing_files
4572 && print_deps > (angle_brackets || (system_include_depth > 0)))
4574 /* If it was requested as a system header file,
4575 then assume it belongs in the first place to look for such. */
4578 for (searchptr = search_start; searchptr; searchptr = searchptr->next)
4580 if (searchptr->fname)
4584 if (searchptr->fname[0] == 0)
4586 p = (char *) alloca (strlen (searchptr->fname)
4587 + strlen (fname) + 2);
4588 strcpy (p, searchptr->fname);
4591 deps_output (p, ' ');
4598 /* Otherwise, omit the directory, as if the file existed
4599 in the directory with the source. */
4600 deps_output (fname, ' ');
4603 /* If -M was specified, and this header file won't be added to the
4604 dependency list, then don't count this as an error, because we can
4605 still produce correct output. Otherwise, we can't produce correct
4606 output, because there may be dependencies we need inside the missing
4607 file, and we don't know what directory this missing file exists in. */
4609 && (print_deps <= (angle_brackets || (system_include_depth > 0))))
4610 warning ("No include path in which to find %s", fname);
4611 else if (search_start)
4612 error_from_errno (fname);
4614 error ("No include path in which to find %s", fname);
4616 /* Check to see if this include file is a once-only include file.
4619 struct file_name_list* ptr;
4621 for (ptr = dont_repeat_files; ptr; ptr = ptr->next) {
4622 if (!strcmp (ptr->fname, fname)) {
4624 return 0; /* This file was once'd. */
4628 for (ptr = all_include_files; ptr; ptr = ptr->next) {
4629 if (!strcmp (ptr->fname, fname))
4630 break; /* This file was included before. */
4634 /* This is the first time for this file. */
4635 /* Add it to list of files included. */
4637 ptr = (struct file_name_list *) xmalloc (sizeof (struct file_name_list));
4638 ptr->control_macro = 0;
4639 ptr->c_system_include_path = 0;
4640 ptr->next = all_include_files;
4641 all_include_files = ptr;
4642 ptr->fname = savestring (fname);
4643 ptr->got_name_map = 0;
4645 /* For -M, add this file to the dependencies. */
4646 if (print_deps > (angle_brackets || (system_include_depth > 0)))
4647 deps_output (fname, ' ');
4650 /* Handle -H option. */
4651 if (print_include_names) {
4652 output_dots (stderr, indepth);
4653 fprintf (stderr, "%s\n", fname);
4657 system_include_depth++;
4659 /* Actually process the file. */
4660 add_import (f, fname); /* Record file on "seen" list for #import. */
4662 pcftry = (char *) alloca (strlen (fname) + 30);
4673 sprintf (pcftry, "%s%d", fname, pcfnum++);
4675 pcf = open (pcftry, O_RDONLY, 0666);
4681 if (bcmp ((char *) &stat_f.st_ino, (char *) &s.st_ino,
4683 || stat_f.st_dev != s.st_dev)
4685 pcfbuf = check_precompiled (pcf, fname, &pcfbuflimit);
4686 /* Don't need it any more. */
4691 /* Don't need it at all. */
4696 } while (pcf != -1 && !pcfbuf);
4699 /* Actually process the file */
4701 pcfname = xmalloc (strlen (pcftry) + 1);
4702 strcpy (pcfname, pcftry);
4703 pcfinclude ((U_CHAR *) pcfbuf, (U_CHAR *) pcfbuflimit,
4704 (U_CHAR *) fname, op);
4707 finclude (f, fname, op, is_system_include (fname), searchptr);
4710 system_include_depth--;
4715 /* Return nonzero if there is no need to include file NAME
4716 because it has already been included and it contains a conditional
4717 to make a repeated include do nothing. */
4720 redundant_include_p (name)
4723 struct file_name_list *l = all_include_files;
4724 for (; l; l = l->next)
4725 if (! strcmp (name, l->fname)
4727 && lookup (l->control_macro, -1, -1))
4732 /* Return nonzero if the given FILENAME is an absolute pathname which
4733 designates a file within one of the known "system" include file
4734 directories. We assume here that if the given FILENAME looks like
4735 it is the name of a file which resides either directly in a "system"
4736 include file directory, or within any subdirectory thereof, then the
4737 given file must be a "system" include file. This function tells us
4738 if we should suppress pedantic errors/warnings for the given FILENAME.
4740 The value is 2 if the file is a C-language system header file
4741 for which C++ should (on most systems) assume `extern "C"'. */
4744 is_system_include (filename)
4745 register char *filename;
4747 struct file_name_list *searchptr;
4749 for (searchptr = first_system_include; searchptr;
4750 searchptr = searchptr->next)
4751 if (searchptr->fname) {
4752 register char *sys_dir = searchptr->fname;
4753 register unsigned length = strlen (sys_dir);
4755 if (! strncmp (sys_dir, filename, length)
4756 && (filename[length] == '/'
4757 #ifdef DIR_SEPARATOR
4758 || filename[length] == DIR_SEPARATOR
4761 if (searchptr->c_system_include_path)
4770 /* The file_name_map structure holds a mapping of file names for a
4771 particular directory. This mapping is read from the file named
4772 FILE_NAME_MAP_FILE in that directory. Such a file can be used to
4773 map filenames on a file system with severe filename restrictions,
4774 such as DOS. The format of the file name map file is just a series
4775 of lines with two tokens on each line. The first token is the name
4776 to map, and the second token is the actual name to use. */
4778 struct file_name_map
4780 struct file_name_map *map_next;
4785 #define FILE_NAME_MAP_FILE "header.gcc"
4787 /* Read a space delimited string of unlimited length from a stdio
4791 read_filename_string (ch, f)
4799 set = alloc = xmalloc (len + 1);
4803 while ((ch = getc (f)) != EOF && ! is_space[ch])
4805 if (set - alloc == len)
4808 alloc = xrealloc (alloc, len + 1);
4809 set = alloc + len / 2;
4819 /* Read the file name map file for DIRNAME. */
4821 static struct file_name_map *
4822 read_name_map (dirname)
4825 /* This structure holds a linked list of file name maps, one per
4827 struct file_name_map_list
4829 struct file_name_map_list *map_list_next;
4830 char *map_list_name;
4831 struct file_name_map *map_list_map;
4833 static struct file_name_map_list *map_list;
4834 register struct file_name_map_list *map_list_ptr;
4838 for (map_list_ptr = map_list; map_list_ptr;
4839 map_list_ptr = map_list_ptr->map_list_next)
4840 if (! strcmp (map_list_ptr->map_list_name, dirname))
4841 return map_list_ptr->map_list_map;
4843 map_list_ptr = ((struct file_name_map_list *)
4844 xmalloc (sizeof (struct file_name_map_list)));
4845 map_list_ptr->map_list_name = savestring (dirname);
4846 map_list_ptr->map_list_map = NULL;
4848 name = (char *) alloca (strlen (dirname) + strlen (FILE_NAME_MAP_FILE) + 2);
4849 strcpy (name, dirname);
4852 strcat (name, FILE_NAME_MAP_FILE);
4853 f = fopen (name, "r");
4855 map_list_ptr->map_list_map = NULL;
4859 int dirlen = strlen (dirname);
4861 while ((ch = getc (f)) != EOF)
4864 struct file_name_map *ptr;
4868 from = read_filename_string (ch, f);
4869 while ((ch = getc (f)) != EOF && is_hor_space[ch])
4871 to = read_filename_string (ch, f);
4873 ptr = ((struct file_name_map *)
4874 xmalloc (sizeof (struct file_name_map)));
4875 ptr->map_from = from;
4877 /* Make the real filename absolute. */
4882 ptr->map_to = xmalloc (dirlen + strlen (to) + 2);
4883 strcpy (ptr->map_to, dirname);
4884 ptr->map_to[dirlen] = '/';
4885 strcpy (ptr->map_to + dirlen + 1, to);
4889 ptr->map_next = map_list_ptr->map_list_map;
4890 map_list_ptr->map_list_map = ptr;
4892 while ((ch = getc (f)) != '\n')
4899 map_list_ptr->map_list_next = map_list;
4900 map_list = map_list_ptr;
4902 return map_list_ptr->map_list_map;
4905 /* Try to open include file FILENAME. SEARCHPTR is the directory
4906 being tried from the include file search path. This function maps
4907 filenames on file systems based on information read by
4911 open_include_file (filename, searchptr)
4913 struct file_name_list *searchptr;
4915 register struct file_name_map *map;
4916 register char *from;
4919 if (searchptr && ! searchptr->got_name_map)
4921 searchptr->name_map = read_name_map (searchptr->fname
4922 ? searchptr->fname : ".");
4923 searchptr->got_name_map = 1;
4926 /* First check the mapping for the directory we are using. */
4927 if (searchptr && searchptr->name_map)
4930 if (searchptr->fname)
4931 from += strlen (searchptr->fname) + 1;
4932 for (map = searchptr->name_map; map; map = map->map_next)
4934 if (! strcmp (map->map_from, from))
4936 /* Found a match. */
4937 return open (map->map_to, O_RDONLY, 0666);
4942 /* Try to find a mapping file for the particular directory we are
4943 looking in. Thus #include <sys/types.h> will look up sys/types.h
4944 in /usr/include/header.gcc and look up types.h in
4945 /usr/include/sys/header.gcc. */
4946 p = rindex (filename, '/');
4947 #ifdef DIR_SEPARATOR
4948 if (! p) p = rindex (filename, DIR_SEPARATOR);
4950 char *tmp = rindex (filename, DIR_SEPARATOR);
4951 if (tmp != NULL && tmp > p) p = tmp;
4958 && strlen (searchptr->fname) == p - filename
4959 && ! strncmp (searchptr->fname, filename, p - filename))
4961 /* FILENAME is in SEARCHPTR, which we've already checked. */
4962 return open (filename, O_RDONLY, 0666);
4972 dir = (char *) alloca (p - filename + 1);
4973 bcopy (filename, dir, p - filename);
4974 dir[p - filename] = '\0';
4977 for (map = read_name_map (dir); map; map = map->map_next)
4978 if (! strcmp (map->map_from, from))
4979 return open (map->map_to, O_RDONLY, 0666);
4981 return open (filename, O_RDONLY, 0666);
4984 /* Process the contents of include file FNAME, already open on descriptor F,
4986 SYSTEM_HEADER_P is 1 if this file resides in any one of the known
4987 "system" include directories (as decided by the `is_system_include'
4989 DIRPTR is the link in the dir path through which this file was found,
4990 or 0 if the file name was absolute. */
4993 finclude (f, fname, op, system_header_p, dirptr)
4997 int system_header_p;
4998 struct file_name_list *dirptr;
5003 FILE_BUF *fp; /* For input stack frame */
5004 int missing_newline = 0;
5006 CHECK_DEPTH (return;);
5008 if (file_size_and_mode (f, &st_mode, &st_size) < 0)
5010 perror_with_name (fname);
5015 fp = &instack[indepth + 1];
5016 bzero ((char *) fp, sizeof (FILE_BUF));
5017 fp->nominal_fname = fp->fname = fname;
5020 fp->if_stack = if_stack;
5021 fp->system_header_p = system_header_p;
5024 if (S_ISREG (st_mode)) {
5025 fp->buf = (U_CHAR *) xmalloc (st_size + 2);
5028 /* Read the file contents, knowing that st_size is an upper bound
5029 on the number of bytes we can read. */
5030 fp->length = safe_read (f, (char *) fp->buf, st_size);
5031 if (fp->length < 0) goto nope;
5033 else if (S_ISDIR (st_mode)) {
5034 error ("directory `%s' specified in #include", fname);
5038 /* Cannot count its file size before reading.
5039 First read the entire file into heap and
5040 copy them into buffer on stack. */
5045 fp->buf = (U_CHAR *) xmalloc (bsize + 2);
5048 i = safe_read (f, (char *) fp->buf + st_size, bsize - st_size);
5050 goto nope; /* error! */
5052 if (st_size != bsize)
5053 break; /* End of file */
5055 fp->buf = (U_CHAR *) xrealloc (fp->buf, bsize + 2);
5058 fp->length = st_size;
5061 if ((fp->length > 0 && fp->buf[fp->length - 1] != '\n')
5062 /* Backslash-newline at end is not good enough. */
5063 || (fp->length > 1 && fp->buf[fp->length - 2] == '\\')) {
5064 fp->buf[fp->length++] = '\n';
5065 missing_newline = 1;
5067 fp->buf[fp->length] = '\0';
5069 /* Close descriptor now, so nesting does not use lots of descriptors. */
5072 /* Must do this before calling trigraph_pcp, so that the correct file name
5073 will be printed in warning messages. */
5076 input_file_stack_tick++;
5081 output_line_directive (fp, op, 0, enter_file);
5084 if (missing_newline)
5087 if (pedantic && missing_newline)
5088 pedwarn ("file does not end in newline");
5091 input_file_stack_tick++;
5092 output_line_directive (&instack[indepth], op, 0, leave_file);
5098 perror_with_name (fname);
5103 /* Record that inclusion of the file named FILE
5104 should be controlled by the macro named MACRO_NAME.
5105 This means that trying to include the file again
5106 will do something if that macro is defined. */
5109 record_control_macro (file, macro_name)
5113 struct file_name_list *new;
5115 for (new = all_include_files; new; new = new->next) {
5116 if (!strcmp (new->fname, file)) {
5117 new->control_macro = macro_name;
5122 /* If the file is not in all_include_files, something's wrong. */
5126 /* Maintain and search list of included files, for #import. */
5128 #define IMPORT_HASH_SIZE 31
5130 struct import_file {
5134 struct import_file *next;
5137 /* Hash table of files already included with #include or #import. */
5139 static struct import_file *import_hash_table[IMPORT_HASH_SIZE];
5141 /* Hash a file name for import_hash_table. */
5149 while (*f) val += *f++;
5150 return (val%IMPORT_HASH_SIZE);
5153 /* Search for file FILENAME in import_hash_table.
5154 Return -2 if found, either a matching name or a matching inode.
5155 Otherwise, open the file and return a file descriptor if successful
5156 or -1 if unsuccessful. */
5159 lookup_import (filename, searchptr)
5161 struct file_name_list *searchptr;
5163 struct import_file *i;
5169 hashval = import_hash (filename);
5171 /* Attempt to find file in list of already included files */
5172 i = import_hash_table[hashval];
5175 if (!strcmp (filename, i->name))
5176 return -2; /* return found */
5179 /* Open it and try a match on inode/dev */
5180 fd = open_include_file (filename, searchptr);
5184 for (h = 0; h < IMPORT_HASH_SIZE; h++) {
5185 i = import_hash_table[h];
5187 /* Compare the inode and the device.
5188 Supposedly on some systems the inode is not a scalar. */
5189 if (!bcmp ((char *) &i->inode, (char *) &sb.st_ino, sizeof (sb.st_ino))
5190 && i->dev == sb.st_dev) {
5192 return -2; /* return found */
5197 return fd; /* Not found, return open file */
5200 /* Add the file FNAME, open on descriptor FD, to import_hash_table. */
5203 add_import (fd, fname)
5207 struct import_file *i;
5211 hashval = import_hash (fname);
5213 i = (struct import_file *)xmalloc (sizeof (struct import_file));
5214 i->name = xmalloc (strlen (fname)+1);
5215 strcpy (i->name, fname);
5216 bcopy ((char *) &sb.st_ino, (char *) &i->inode, sizeof (sb.st_ino));
5218 i->next = import_hash_table[hashval];
5219 import_hash_table[hashval] = i;
5222 /* Load the specified precompiled header into core, and verify its
5223 preconditions. PCF indicates the file descriptor to read, which must
5224 be a regular file. FNAME indicates the file name of the original
5225 header. *LIMIT will be set to an address one past the end of the file.
5226 If the preconditions of the file are not satisfied, the buffer is
5227 freed and we return 0. If the preconditions are satisfied, return
5228 the address of the buffer following the preconditions. The buffer, in
5229 this case, should never be freed because various pieces of it will
5230 be referred to until all precompiled strings are output at the end of
5234 check_precompiled (pcf, fname, limit)
5248 if (file_size_and_mode (pcf, &st_mode, &st_size) < 0)
5251 if (S_ISREG (st_mode))
5253 buf = xmalloc (st_size + 2);
5254 length = safe_read (pcf, buf, st_size);
5261 if (length > 0 && buf[length-1] != '\n')
5262 buf[length++] = '\n';
5265 *limit = buf + length;
5267 /* File is in core. Check the preconditions. */
5268 if (!check_preconditions (buf))
5270 for (cp = buf; *cp; cp++)
5273 fprintf (stderr, "Using preinclude %s\n", fname);
5279 fprintf (stderr, "Cannot use preinclude %s\n", fname);
5285 /* PREC (null terminated) points to the preconditions of a
5286 precompiled header. These are a series of #define and #undef
5287 lines which must match the current contents of the hash
5290 check_preconditions (prec)
5297 lineend = index (prec, '\n');
5299 if (*prec++ != '#') {
5300 error ("Bad format encountered while reading precompiled file");
5303 if (!strncmp (prec, "define", 6)) {
5307 mdef = create_definition ((U_CHAR *) prec, (U_CHAR *) lineend, NULL_PTR);
5312 if ((hp = lookup (mdef.symnam, mdef.symlen, -1)) == NULL
5313 || (hp->type != T_MACRO && hp->type != T_CONST)
5314 || (hp->type == T_MACRO
5315 && !compare_defs (mdef.defn, hp->value.defn)
5316 && (mdef.defn->length != 2
5317 || mdef.defn->expansion[0] != '\n'
5318 || mdef.defn->expansion[1] != ' ')))
5320 } else if (!strncmp (prec, "undef", 5)) {
5325 while (is_hor_space[(U_CHAR) *prec])
5328 while (is_idchar[(U_CHAR) *prec])
5332 if (lookup ((U_CHAR *) name, len, -1))
5335 error ("Bad format encountered while reading precompiled file");
5340 /* They all passed successfully */
5344 /* Process the main body of a precompiled file. BUF points to the
5345 string section of the file, following the preconditions. LIMIT is one
5346 character past the end. NAME is the name of the file being read
5347 in. OP is the main output buffer */
5349 pcfinclude (buf, limit, name, op)
5350 U_CHAR *buf, *limit, *name;
5357 /* First in the file comes 4 bytes indicating the number of strings, */
5358 /* in network byte order. (MSB first). */
5360 nstrings = (nstrings << 8) | *cp++;
5361 nstrings = (nstrings << 8) | *cp++;
5362 nstrings = (nstrings << 8) | *cp++;
5364 /* Looping over each string... */
5365 while (nstrings--) {
5366 U_CHAR *string_start;
5367 U_CHAR *endofthiskey;
5371 /* Each string starts with a STRINGDEF structure (str), followed */
5372 /* by the text of the string (string_start) */
5374 /* First skip to a longword boundary */
5375 /* ??? Why a 4-byte boundary? On all machines? */
5376 /* NOTE: This works correctly even if HOST_WIDE_INT
5377 is narrower than a pointer.
5378 Do not try risky measures here to get another type to use!
5379 Do not include stddef.h--it will fail! */
5380 if ((HOST_WIDE_INT) cp & 3)
5381 cp += 4 - ((HOST_WIDE_INT) cp & 3);
5383 /* Now get the string. */
5384 str = (STRINGDEF *) (GENERIC_PTR) cp;
5385 string_start = cp += sizeof (STRINGDEF);
5387 for (; *cp; cp++) /* skip the string */
5390 /* We need to macro expand the string here to ensure that the
5391 proper definition environment is in place. If it were only
5392 expanded when we find out it is needed, macros necessary for
5393 its proper expansion might have had their definitions changed. */
5394 tmpbuf = expand_to_temp_buffer (string_start, cp++, 0, 0);
5395 /* Lineno is already set in the precompiled file */
5396 str->contents = tmpbuf.buf;
5397 str->len = tmpbuf.length;
5399 str->filename = name;
5400 str->output_mark = outbuf.bufp - outbuf.buf;
5403 *stringlist_tailp = str;
5404 stringlist_tailp = &str->chain;
5406 /* Next comes a fourbyte number indicating the number of keys */
5407 /* for this string. */
5409 nkeys = (nkeys << 8) | *cp++;
5410 nkeys = (nkeys << 8) | *cp++;
5411 nkeys = (nkeys << 8) | *cp++;
5413 /* If this number is -1, then the string is mandatory. */
5417 /* Otherwise, for each key, */
5418 for (; nkeys--; free (tmpbuf.buf), cp = endofthiskey + 1) {
5419 KEYDEF *kp = (KEYDEF *) (GENERIC_PTR) cp;
5422 /* It starts with a KEYDEF structure */
5423 cp += sizeof (KEYDEF);
5425 /* Find the end of the key. At the end of this for loop we
5426 advance CP to the start of the next key using this variable. */
5427 endofthiskey = cp + strlen ((char *) cp);
5430 /* Expand the key, and enter it into the hash table. */
5431 tmpbuf = expand_to_temp_buffer (cp, endofthiskey, 0, 0);
5432 tmpbuf.bufp = tmpbuf.buf;
5434 while (is_hor_space[*tmpbuf.bufp])
5436 if (!is_idstart[*tmpbuf.bufp]
5437 || tmpbuf.bufp == tmpbuf.buf + tmpbuf.length) {
5442 hp = lookup (tmpbuf.bufp, -1, -1);
5445 install (tmpbuf.bufp, -1, T_PCSTRING, (char *) kp, -1);
5447 else if (hp->type == T_PCSTRING) {
5448 kp->chain = hp->value.keydef;
5449 hp->value.keydef = kp;
5455 /* This output_line_directive serves to switch us back to the current
5456 input file in case some of these strings get output (which will
5457 result in line directives for the header file being output). */
5458 output_line_directive (&instack[indepth], op, 0, enter_file);
5461 /* Called from rescan when it hits a key for strings. Mark them all */
5462 /* used and clean up. */
5469 for (kp = hp->value.keydef; kp; kp = kp->chain)
5470 kp->str->writeflag = 1;
5474 /* Write the output, interspersing precompiled strings in their */
5475 /* appropriate places. */
5479 STRINGDEF *next_string;
5480 U_CHAR *cur_buf_loc;
5481 int line_directive_len = 80;
5482 char *line_directive = xmalloc (line_directive_len);
5485 /* In each run through the loop, either cur_buf_loc == */
5486 /* next_string_loc, in which case we print a series of strings, or */
5487 /* it is less than next_string_loc, in which case we write some of */
5489 cur_buf_loc = outbuf.buf;
5490 next_string = stringlist;
5492 while (cur_buf_loc < outbuf.bufp || next_string) {
5494 && cur_buf_loc - outbuf.buf == next_string->output_mark) {
5495 if (next_string->writeflag) {
5496 len = 4 * strlen ((char *) next_string->filename) + 32;
5497 while (len > line_directive_len)
5498 line_directive = xrealloc (line_directive,
5499 line_directive_len *= 2);
5500 sprintf (line_directive, "\n# %d ", next_string->lineno);
5501 strcpy (quote_string (line_directive + strlen (line_directive),
5502 (char *) next_string->filename),
5504 safe_write (fileno (stdout), line_directive, strlen (line_directive));
5505 safe_write (fileno (stdout),
5506 (char *) next_string->contents, next_string->len);
5508 next_string = next_string->chain;
5512 ? (next_string->output_mark
5513 - (cur_buf_loc - outbuf.buf))
5514 : outbuf.bufp - cur_buf_loc);
5516 safe_write (fileno (stdout), (char *) cur_buf_loc, len);
5520 free (line_directive);
5523 /* Pass a directive through to the output file.
5524 BUF points to the contents of the directive, as a contiguous string.
5525 LIMIT points to the first character past the end of the directive.
5526 KEYWORD is the keyword-table entry for the directive. */
5529 pass_thru_directive (buf, limit, op, keyword)
5530 U_CHAR *buf, *limit;
5532 struct directive *keyword;
5534 register unsigned keyword_length = keyword->length;
5536 check_expand (op, 1 + keyword_length + (limit - buf));
5538 bcopy (keyword->name, (char *) op->bufp, keyword_length);
5539 op->bufp += keyword_length;
5540 if (limit != buf && buf[0] != ' ')
5542 bcopy ((char *) buf, (char *) op->bufp, limit - buf);
5543 op->bufp += (limit - buf);
5546 /* Count the line we have just made in the output,
5547 to get in sync properly. */
5552 /* The arglist structure is built by do_define to tell
5553 collect_definition where the argument names begin. That
5554 is, for a define like "#define f(x,y,z) foo+x-bar*y", the arglist
5555 would contain pointers to the strings x, y, and z.
5556 Collect_definition would then build a DEFINITION node,
5557 with reflist nodes pointing to the places x, y, and z had
5558 appeared. So the arglist is just convenience data passed
5559 between these two routines. It is not kept around after
5560 the current #define has been processed and entered into the
5564 struct arglist *next;
5571 /* Create a DEFINITION node from a #define directive. Arguments are
5572 as for do_define. */
5574 create_definition (buf, limit, op)
5575 U_CHAR *buf, *limit;
5578 U_CHAR *bp; /* temp ptr into input buffer */
5579 U_CHAR *symname; /* remember where symbol name starts */
5580 int sym_length; /* and how long it is */
5581 int line = instack[indepth].lineno;
5582 char *file = instack[indepth].nominal_fname;
5586 int arglengths = 0; /* Accumulate lengths of arg names
5587 plus number of args. */
5592 while (is_hor_space[*bp])
5595 symname = bp; /* remember where it starts */
5596 sym_length = check_macro_name (bp, "macro");
5599 /* Lossage will occur if identifiers or control keywords are broken
5600 across lines using backslash. This is not the right place to take
5604 struct arglist *arg_ptrs = NULL;
5607 bp++; /* skip '(' */
5608 SKIP_WHITE_SPACE (bp);
5610 /* Loop over macro argument names. */
5611 while (*bp != ')') {
5612 struct arglist *temp;
5614 temp = (struct arglist *) alloca (sizeof (struct arglist));
5616 temp->next = arg_ptrs;
5617 temp->argno = argno++;
5618 temp->rest_args = 0;
5622 pedwarn ("another parameter follows `%s'",
5625 if (!is_idstart[*bp])
5626 pedwarn ("invalid character in macro parameter name");
5628 /* Find the end of the arg name. */
5629 while (is_idchar[*bp]) {
5631 /* do we have a "special" rest-args extension here? */
5632 if (limit - bp > REST_EXTENSION_LENGTH &&
5633 bcmp (rest_extension, bp, REST_EXTENSION_LENGTH) == 0) {
5635 temp->rest_args = 1;
5639 temp->length = bp - temp->name;
5641 bp += REST_EXTENSION_LENGTH;
5642 arglengths += temp->length + 2;
5643 SKIP_WHITE_SPACE (bp);
5644 if (temp->length == 0 || (*bp != ',' && *bp != ')')) {
5645 error ("badly punctuated parameter list in `#define'");
5650 SKIP_WHITE_SPACE (bp);
5651 /* A comma at this point can only be followed by an identifier. */
5652 if (!is_idstart[*bp]) {
5653 error ("badly punctuated parameter list in `#define'");
5658 error ("unterminated parameter list in `#define'");
5662 struct arglist *otemp;
5664 for (otemp = temp->next; otemp != NULL; otemp = otemp->next)
5665 if (temp->length == otemp->length &&
5666 bcmp (temp->name, otemp->name, temp->length) == 0) {
5667 error ("duplicate argument name `%.*s' in `#define'",
5668 temp->length, temp->name);
5674 ++bp; /* skip paren */
5675 SKIP_WHITE_SPACE (bp);
5676 /* now everything from bp before limit is the definition. */
5677 defn = collect_expansion (bp, limit, argno, arg_ptrs);
5678 defn->rest_args = rest_args;
5680 /* Now set defn->args.argnames to the result of concatenating
5681 the argument names in reverse order
5682 with comma-space between them. */
5683 defn->args.argnames = (U_CHAR *) xmalloc (arglengths + 1);
5685 struct arglist *temp;
5687 for (temp = arg_ptrs; temp; temp = temp->next) {
5688 bcopy (temp->name, &defn->args.argnames[i], temp->length);
5690 if (temp->next != 0) {
5691 defn->args.argnames[i++] = ',';
5692 defn->args.argnames[i++] = ' ';
5695 defn->args.argnames[i] = 0;
5698 /* Simple expansion or empty definition. */
5702 if (is_hor_space[*bp]) {
5704 SKIP_WHITE_SPACE (bp);
5707 case '!': case '"': case '#': case '%': case '&': case '\'':
5708 case ')': case '*': case '+': case ',': case '-': case '.':
5709 case '/': case ':': case ';': case '<': case '=': case '>':
5710 case '?': case '[': case '\\': case ']': case '^': case '{':
5711 case '|': case '}': case '~':
5712 warning ("missing white space after `#define %.*s'",
5713 sym_length, symname);
5717 pedwarn ("missing white space after `#define %.*s'",
5718 sym_length, symname);
5723 /* Now everything from bp before limit is the definition. */
5724 defn = collect_expansion (bp, limit, -1, NULL_PTR);
5725 defn->args.argnames = (U_CHAR *) "";
5731 /* OP is null if this is a predefinition */
5732 defn->predefined = !op;
5734 mdef.symnam = symname;
5735 mdef.symlen = sym_length;
5744 /* Process a #define directive.
5745 BUF points to the contents of the #define directive, as a contiguous string.
5746 LIMIT points to the first character past the end of the definition.
5747 KEYWORD is the keyword-table entry for #define. */
5750 do_define (buf, limit, op, keyword)
5751 U_CHAR *buf, *limit;
5753 struct directive *keyword;
5758 /* If this is a precompiler run (with -pcp) pass thru #define directives. */
5759 if (pcp_outfile && op)
5760 pass_thru_directive (buf, limit, op, keyword);
5762 mdef = create_definition (buf, limit, op);
5766 hashcode = hashf (mdef.symnam, mdef.symlen, HASHSIZE);
5770 if ((hp = lookup (mdef.symnam, mdef.symlen, hashcode)) != NULL) {
5772 /* Redefining a precompiled key is ok. */
5773 if (hp->type == T_PCSTRING)
5775 /* Redefining a macro is ok if the definitions are the same. */
5776 else if (hp->type == T_MACRO)
5777 ok = ! compare_defs (mdef.defn, hp->value.defn);
5778 /* Redefining a constant is ok with -D. */
5779 else if (hp->type == T_CONST)
5780 ok = ! done_initializing;
5781 /* Print the warning if it's not ok. */
5783 /* If we are passing through #define and #undef directives, do
5784 that for this re-definition now. */
5785 if (debug_output && op)
5786 pass_thru_directive (buf, limit, op, keyword);
5788 pedwarn ("`%.*s' redefined", mdef.symlen, mdef.symnam);
5789 if (hp->type == T_MACRO)
5790 pedwarn_with_file_and_line (hp->value.defn->file, hp->value.defn->line,
5791 "this is the location of the previous definition");
5793 /* Replace the old definition. */
5795 hp->value.defn = mdef.defn;
5797 /* If we are passing through #define and #undef directives, do
5798 that for this new definition now. */
5799 if (debug_output && op)
5800 pass_thru_directive (buf, limit, op, keyword);
5801 install (mdef.symnam, mdef.symlen, T_MACRO,
5802 (char *) mdef.defn, hashcode);
5813 /* Check a purported macro name SYMNAME, and yield its length.
5814 USAGE is the kind of name this is intended for. */
5817 check_macro_name (symname, usage)
5824 for (p = symname; is_idchar[*p]; p++)
5826 sym_length = p - symname;
5827 if (sym_length == 0)
5828 error ("invalid %s name", usage);
5829 else if (!is_idstart[*symname]
5830 || (sym_length == 7 && ! bcmp (symname, "defined", 7)))
5831 error ("invalid %s name `%.*s'", usage, sym_length, symname);
5836 * return zero if two DEFINITIONs are isomorphic
5839 compare_defs (d1, d2)
5840 DEFINITION *d1, *d2;
5842 register struct reflist *a1, *a2;
5843 register U_CHAR *p1 = d1->expansion;
5844 register U_CHAR *p2 = d2->expansion;
5847 if (d1->nargs != d2->nargs)
5849 if (strcmp ((char *)d1->args.argnames, (char *)d2->args.argnames))
5851 for (a1 = d1->pattern, a2 = d2->pattern; a1 && a2;
5852 a1 = a1->next, a2 = a2->next) {
5853 if (!((a1->nchars == a2->nchars && ! bcmp (p1, p2, a1->nchars))
5854 || ! comp_def_part (first, p1, a1->nchars, p2, a2->nchars, 0))
5855 || a1->argno != a2->argno
5856 || a1->stringify != a2->stringify
5857 || a1->raw_before != a2->raw_before
5858 || a1->raw_after != a2->raw_after)
5866 if (comp_def_part (first, p1, d1->length - (p1 - d1->expansion),
5867 p2, d2->length - (p2 - d2->expansion), 1))
5872 /* Return 1 if two parts of two macro definitions are effectively different.
5873 One of the parts starts at BEG1 and has LEN1 chars;
5874 the other has LEN2 chars at BEG2.
5875 Any sequence of whitespace matches any other sequence of whitespace.
5876 FIRST means these parts are the first of a macro definition;
5877 so ignore leading whitespace entirely.
5878 LAST means these parts are the last of a macro definition;
5879 so ignore trailing whitespace entirely. */
5882 comp_def_part (first, beg1, len1, beg2, len2, last)
5884 U_CHAR *beg1, *beg2;
5888 register U_CHAR *end1 = beg1 + len1;
5889 register U_CHAR *end2 = beg2 + len2;
5891 while (beg1 != end1 && is_space[*beg1]) beg1++;
5892 while (beg2 != end2 && is_space[*beg2]) beg2++;
5895 while (beg1 != end1 && is_space[end1[-1]]) end1--;
5896 while (beg2 != end2 && is_space[end2[-1]]) end2--;
5898 while (beg1 != end1 && beg2 != end2) {
5899 if (is_space[*beg1] && is_space[*beg2]) {
5900 while (beg1 != end1 && is_space[*beg1]) beg1++;
5901 while (beg2 != end2 && is_space[*beg2]) beg2++;
5902 } else if (*beg1 == *beg2) {
5906 return (beg1 != end1) || (beg2 != end2);
5909 /* Read a replacement list for a macro with parameters.
5910 Build the DEFINITION structure.
5911 Reads characters of text starting at BUF until END.
5912 ARGLIST specifies the formal parameters to look for
5913 in the text of the definition; NARGS is the number of args
5914 in that list, or -1 for a macro name that wants no argument list.
5915 MACRONAME is the macro name itself (so we can avoid recursive expansion)
5916 and NAMELEN is its length in characters.
5918 Note that comments, backslash-newlines, and leading white space
5919 have already been deleted from the argument. */
5921 /* If there is no trailing whitespace, a Newline Space is added at the end
5922 to prevent concatenation that would be contrary to the standard. */
5925 collect_expansion (buf, end, nargs, arglist)
5928 struct arglist *arglist;
5931 register U_CHAR *p, *limit, *lastp, *exp_p;
5932 struct reflist *endpat = NULL;
5933 /* Pointer to first nonspace after last ## seen. */
5935 /* Pointer to first nonspace after last single-# seen. */
5936 U_CHAR *stringify = 0;
5937 /* How those tokens were spelled. */
5938 enum sharp_token_type concat_sharp_token_type = NO_SHARP_TOKEN;
5939 enum sharp_token_type stringify_sharp_token_type = NO_SHARP_TOKEN;
5941 int expected_delimiter = '\0';
5943 /* Scan thru the replacement list, ignoring comments and quoted
5944 strings, picking up on the macro calls. It does a linear search
5945 thru the arg list on every potential symbol. Profiling might say
5946 that something smarter should happen. */
5951 /* Find the beginning of the trailing whitespace. */
5954 while (p < limit && is_space[limit[-1]]) limit--;
5956 /* Allocate space for the text in the macro definition.
5957 Each input char may or may not need 1 byte,
5958 so this is an upper bound.
5959 The extra 3 are for invented trailing newline-marker and final null. */
5960 maxsize = (sizeof (DEFINITION)
5962 defn = (DEFINITION *) xcalloc (1, maxsize);
5964 defn->nargs = nargs;
5965 exp_p = defn->expansion = (U_CHAR *) defn + sizeof (DEFINITION);
5970 : p[0] == '%' && p[1] == ':' && p[2] == '%' && p[3] == ':') {
5971 error ("`##' at start of macro definition");
5972 p += p[0] == '#' ? 2 : 4;
5975 /* Process the main body of the definition. */
5977 int skipped_arg = 0;
5978 register U_CHAR c = *p++;
5986 if (expected_delimiter != '\0') {
5987 if (c == expected_delimiter)
5988 expected_delimiter = '\0';
5990 expected_delimiter = c;
5994 if (p < limit && expected_delimiter) {
5995 /* In a string, backslash goes through
5996 and makes next char ordinary. */
6002 if (!expected_delimiter && *p == ':') {
6003 /* %: is not a digraph if preceded by an odd number of '<'s. */
6005 while (buf < p0 && p0[-1] == '<')
6008 /* Treat %:%: as ## and %: as #. */
6009 if (p[1] == '%' && p[2] == ':') {
6011 goto sharp_sharp_token;
6022 /* # is ordinary inside a string. */
6023 if (expected_delimiter)
6027 /* ##: concatenate preceding and following tokens. */
6028 /* Take out the first #, discard preceding whitespace. */
6030 while (exp_p > lastp && is_hor_space[exp_p[-1]])
6032 /* Skip the second #. */
6034 concat_sharp_token_type = c;
6035 if (is_hor_space[*p]) {
6036 concat_sharp_token_type++;
6038 SKIP_WHITE_SPACE (p);
6042 error ("`##' at end of macro definition");
6043 } else if (nargs >= 0) {
6044 /* Single #: stringify following argument ref.
6045 Don't leave the # in the expansion. */
6048 stringify_sharp_token_type = c;
6049 if (is_hor_space[*p]) {
6050 stringify_sharp_token_type++;
6052 SKIP_WHITE_SPACE (p);
6054 if (! is_idstart[*p] || nargs == 0)
6055 error ("`#' operator is not followed by a macro argument name");
6062 /* In -traditional mode, recognize arguments inside strings and
6063 and character constants, and ignore special properties of #.
6064 Arguments inside strings are considered "stringified", but no
6065 extra quote marks are supplied. */
6069 if (expected_delimiter != '\0') {
6070 if (c == expected_delimiter)
6071 expected_delimiter = '\0';
6073 expected_delimiter = c;
6077 /* Backslash quotes delimiters and itself, but not macro args. */
6078 if (expected_delimiter != 0 && p < limit
6079 && (*p == expected_delimiter || *p == '\\')) {
6086 if (expected_delimiter != '\0') /* No comments inside strings. */
6089 /* If we find a comment that wasn't removed by handle_directive,
6090 this must be -traditional. So replace the comment with
6094 while (p < limit && !(p[-2] == '*' && p[-1] == '/'))
6097 /* Mark this as a concatenation-point, as if it had been ##. */
6105 /* Handle the start of a symbol. */
6106 if (is_idchar[c] && nargs > 0) {
6107 U_CHAR *id_beg = p - 1;
6111 while (p != limit && is_idchar[*p]) p++;
6112 id_len = p - id_beg;
6114 if (is_idstart[c]) {
6115 register struct arglist *arg;
6117 for (arg = arglist; arg != NULL; arg = arg->next) {
6118 struct reflist *tpat;
6120 if (arg->name[0] == c
6121 && arg->length == id_len
6122 && bcmp (arg->name, id_beg, id_len) == 0) {
6123 enum sharp_token_type tpat_stringify;
6124 if (expected_delimiter) {
6125 if (warn_stringify) {
6127 warning ("macro argument `%.*s' is stringified.",
6130 warning ("macro arg `%.*s' would be stringified with -traditional.",
6134 /* If ANSI, don't actually substitute inside a string. */
6137 tpat_stringify = SHARP_TOKEN;
6140 = (stringify == id_beg
6141 ? stringify_sharp_token_type : NO_SHARP_TOKEN);
6143 /* make a pat node for this arg and append it to the end of
6145 tpat = (struct reflist *) xmalloc (sizeof (struct reflist));
6148 = concat == id_beg ? concat_sharp_token_type : NO_SHARP_TOKEN;
6149 tpat->raw_after = NO_SHARP_TOKEN;
6150 tpat->rest_args = arg->rest_args;
6151 tpat->stringify = tpat_stringify;
6154 defn->pattern = tpat;
6156 endpat->next = tpat;
6159 tpat->argno = arg->argno;
6160 tpat->nchars = exp_p - lastp;
6162 register U_CHAR *p1 = p;
6163 SKIP_WHITE_SPACE (p1);
6166 : p1[0]=='%' && p1[1]==':' && p1[2]=='%' && p1[3]==':')
6167 tpat->raw_after = p1[0] + (p != p1);
6169 lastp = exp_p; /* place to start copying from next time */
6176 /* If this was not a macro arg, copy it into the expansion. */
6177 if (! skipped_arg) {
6178 register U_CHAR *lim1 = p;
6182 if (stringify == id_beg)
6183 error ("`#' operator should be followed by a macro argument name");
6188 if (!traditional && expected_delimiter == 0) {
6189 /* If ANSI, put in a newline-space marker to prevent token pasting.
6190 But not if "inside a string" (which in ANSI mode happens only for
6198 defn->length = exp_p - defn->expansion;
6200 /* Crash now if we overrun the allocated size. */
6201 if (defn->length + 1 > maxsize)
6205 /* This isn't worth the time it takes. */
6206 /* give back excess storage */
6207 defn->expansion = (U_CHAR *) xrealloc (defn->expansion, defn->length + 1);
6214 do_assert (buf, limit, op, keyword)
6215 U_CHAR *buf, *limit;
6217 struct directive *keyword;
6219 U_CHAR *bp; /* temp ptr into input buffer */
6220 U_CHAR *symname; /* remember where symbol name starts */
6221 int sym_length; /* and how long it is */
6222 struct arglist *tokens = NULL;
6224 if (pedantic && done_initializing && !instack[indepth].system_header_p)
6225 pedwarn ("ANSI C does not allow `#assert'");
6229 while (is_hor_space[*bp])
6232 symname = bp; /* remember where it starts */
6233 sym_length = check_macro_name (bp, "assertion");
6235 /* #define doesn't do this, but we should. */
6236 SKIP_WHITE_SPACE (bp);
6238 /* Lossage will occur if identifiers or control tokens are broken
6239 across lines using backslash. This is not the right place to take
6243 error ("missing token-sequence in `#assert'");
6250 bp++; /* skip '(' */
6251 SKIP_WHITE_SPACE (bp);
6253 tokens = read_token_list (&bp, limit, &error_flag);
6257 error ("empty token-sequence in `#assert'");
6261 ++bp; /* skip paren */
6262 SKIP_WHITE_SPACE (bp);
6265 /* If this name isn't already an assertion name, make it one.
6266 Error if it was already in use in some other way. */
6269 ASSERTION_HASHNODE *hp;
6270 int hashcode = hashf (symname, sym_length, ASSERTION_HASHSIZE);
6271 struct tokenlist_list *value
6272 = (struct tokenlist_list *) xmalloc (sizeof (struct tokenlist_list));
6274 hp = assertion_lookup (symname, sym_length, hashcode);
6276 if (sym_length == 7 && ! bcmp (symname, "defined", 7))
6277 error ("`defined' redefined as assertion");
6278 hp = assertion_install (symname, sym_length, hashcode);
6281 /* Add the spec'd token-sequence to the list of such. */
6282 value->tokens = tokens;
6283 value->next = hp->value;
6291 do_unassert (buf, limit, op, keyword)
6292 U_CHAR *buf, *limit;
6294 struct directive *keyword;
6296 U_CHAR *bp; /* temp ptr into input buffer */
6297 U_CHAR *symname; /* remember where symbol name starts */
6298 int sym_length; /* and how long it is */
6300 struct arglist *tokens = NULL;
6301 int tokens_specified = 0;
6303 if (pedantic && done_initializing && !instack[indepth].system_header_p)
6304 pedwarn ("ANSI C does not allow `#unassert'");
6308 while (is_hor_space[*bp])
6311 symname = bp; /* remember where it starts */
6312 sym_length = check_macro_name (bp, "assertion");
6314 /* #define doesn't do this, but we should. */
6315 SKIP_WHITE_SPACE (bp);
6317 /* Lossage will occur if identifiers or control tokens are broken
6318 across lines using backslash. This is not the right place to take
6324 bp++; /* skip '(' */
6325 SKIP_WHITE_SPACE (bp);
6327 tokens = read_token_list (&bp, limit, &error_flag);
6331 error ("empty token list in `#unassert'");
6335 tokens_specified = 1;
6337 ++bp; /* skip paren */
6338 SKIP_WHITE_SPACE (bp);
6342 ASSERTION_HASHNODE *hp;
6343 int hashcode = hashf (symname, sym_length, ASSERTION_HASHSIZE);
6344 struct tokenlist_list *tail, *prev;
6346 hp = assertion_lookup (symname, sym_length, hashcode);
6350 /* If no token list was specified, then eliminate this assertion
6352 if (! tokens_specified) {
6353 struct tokenlist_list *next;
6354 for (tail = hp->value; tail; tail = next) {
6356 free_token_list (tail->tokens);
6359 delete_assertion (hp);
6361 /* If a list of tokens was given, then delete any matching list. */
6366 struct tokenlist_list *next = tail->next;
6367 if (compare_token_lists (tail->tokens, tokens)) {
6371 hp->value = tail->next;
6372 free_token_list (tail->tokens);
6385 /* Test whether there is an assertion named NAME
6386 and optionally whether it has an asserted token list TOKENS.
6387 NAME is not null terminated; its length is SYM_LENGTH.
6388 If TOKENS_SPECIFIED is 0, then don't check for any token list. */
6391 check_assertion (name, sym_length, tokens_specified, tokens)
6394 int tokens_specified;
6395 struct arglist *tokens;
6397 ASSERTION_HASHNODE *hp;
6398 int hashcode = hashf (name, sym_length, ASSERTION_HASHSIZE);
6400 if (pedantic && !instack[indepth].system_header_p)
6401 pedwarn ("ANSI C does not allow testing assertions");
6403 hp = assertion_lookup (name, sym_length, hashcode);
6405 /* It is not an assertion; just return false. */
6408 /* If no token list was specified, then value is 1. */
6409 if (! tokens_specified)
6413 struct tokenlist_list *tail;
6417 /* If a list of tokens was given,
6418 then succeed if the assertion records a matching list. */
6421 if (compare_token_lists (tail->tokens, tokens))
6426 /* Fail if the assertion has no matching list. */
6431 /* Compare two lists of tokens for equality including order of tokens. */
6434 compare_token_lists (l1, l2)
6435 struct arglist *l1, *l2;
6438 if (l1->length != l2->length)
6440 if (bcmp (l1->name, l2->name, l1->length))
6446 /* Succeed if both lists end at the same time. */
6450 /* Read a space-separated list of tokens ending in a close parenthesis.
6451 Return a list of strings, in the order they were written.
6452 (In case of error, return 0 and store -1 in *ERROR_FLAG.)
6453 Parse the text starting at *BPP, and update *BPP.
6454 Don't parse beyond LIMIT. */
6456 static struct arglist *
6457 read_token_list (bpp, limit, error_flag)
6462 struct arglist *token_ptrs = 0;
6468 /* Loop over the assertion value tokens. */
6470 struct arglist *temp;
6474 /* Find the end of the token. */
6478 } else if (*bp == ')') {
6483 } else if (*bp == '"' || *bp == '\'')
6484 bp = skip_quoted_string (bp, limit, 0, NULL_PTR, NULL_PTR, &eofp);
6486 while (! is_hor_space[*bp] && *bp != '(' && *bp != ')'
6487 && *bp != '"' && *bp != '\'' && bp != limit)
6490 temp = (struct arglist *) xmalloc (sizeof (struct arglist));
6491 temp->name = (U_CHAR *) xmalloc (bp - beg + 1);
6492 bcopy ((char *) beg, (char *) temp->name, bp - beg);
6493 temp->name[bp - beg] = 0;
6494 temp->next = token_ptrs;
6496 temp->length = bp - beg;
6498 SKIP_WHITE_SPACE (bp);
6501 error ("unterminated token sequence in `#assert' or `#unassert'");
6508 /* We accumulated the names in reverse order.
6509 Now reverse them to get the proper order. */
6511 register struct arglist *prev = 0, *this, *next;
6512 for (this = token_ptrs; this; this = next) {
6522 free_token_list (tokens)
6523 struct arglist *tokens;
6526 struct arglist *next = tokens->next;
6527 free (tokens->name);
6534 * Install a name in the assertion hash table.
6536 * If LEN is >= 0, it is the length of the name.
6537 * Otherwise, compute the length by scanning the entire name.
6539 * If HASH is >= 0, it is the precomputed hash code.
6540 * Otherwise, compute the hash code.
6542 static ASSERTION_HASHNODE *
6543 assertion_install (name, len, hash)
6548 register ASSERTION_HASHNODE *hp;
6549 register int i, bucket;
6550 register U_CHAR *p, *q;
6552 i = sizeof (ASSERTION_HASHNODE) + len + 1;
6553 hp = (ASSERTION_HASHNODE *) xmalloc (i);
6555 hp->bucket_hdr = &assertion_hashtab[bucket];
6556 hp->next = assertion_hashtab[bucket];
6557 assertion_hashtab[bucket] = hp;
6559 if (hp->next != NULL)
6560 hp->next->prev = hp;
6563 hp->name = ((U_CHAR *) hp) + sizeof (ASSERTION_HASHNODE);
6566 for (i = 0; i < len; i++)
6573 * find the most recent hash node for name name (ending with first
6574 * non-identifier char) installed by install
6576 * If LEN is >= 0, it is the length of the name.
6577 * Otherwise, compute the length by scanning the entire name.
6579 * If HASH is >= 0, it is the precomputed hash code.
6580 * Otherwise, compute the hash code.
6582 static ASSERTION_HASHNODE *
6583 assertion_lookup (name, len, hash)
6588 register ASSERTION_HASHNODE *bucket;
6590 bucket = assertion_hashtab[hash];
6592 if (bucket->length == len && bcmp (bucket->name, name, len) == 0)
6594 bucket = bucket->next;
6600 delete_assertion (hp)
6601 ASSERTION_HASHNODE *hp;
6604 if (hp->prev != NULL)
6605 hp->prev->next = hp->next;
6606 if (hp->next != NULL)
6607 hp->next->prev = hp->prev;
6609 /* make sure that the bucket chain header that
6610 the deleted guy was on points to the right thing afterwards. */
6611 if (hp == *hp->bucket_hdr)
6612 *hp->bucket_hdr = hp->next;
6618 * interpret #line directive. Remembers previously seen fnames
6619 * in its very own hash table.
6621 #define FNAME_HASHSIZE 37
6624 do_line (buf, limit, op, keyword)
6625 U_CHAR *buf, *limit;
6627 struct directive *keyword;
6629 register U_CHAR *bp;
6630 FILE_BUF *ip = &instack[indepth];
6633 enum file_change_code file_change = same_file;
6635 /* Expand any macros. */
6636 tem = expand_to_temp_buffer (buf, limit, 0, 0);
6638 /* Point to macroexpanded line, which is null-terminated now. */
6640 SKIP_WHITE_SPACE (bp);
6642 if (!isdigit (*bp)) {
6643 error ("invalid format `#line' directive");
6647 /* The Newline at the end of this line remains to be processed.
6648 To put the next line at the specified line number,
6649 we must store a line number now that is one less. */
6650 new_lineno = atoi ((char *) bp) - 1;
6652 /* NEW_LINENO is one less than the actual line number here. */
6653 if (pedantic && new_lineno < 0)
6654 pedwarn ("line number out of range in `#line' directive");
6656 /* skip over the line number. */
6657 while (isdigit (*bp))
6660 #if 0 /* #line 10"foo.c" is supposed to be allowed. */
6661 if (*bp && !is_space[*bp]) {
6662 error ("invalid format `#line' directive");
6667 SKIP_WHITE_SPACE (bp);
6670 static HASHNODE *fname_table[FNAME_HASHSIZE];
6671 HASHNODE *hp, **hash_bucket;
6677 /* Turn the file name, which is a character string literal,
6678 into a null-terminated string. Do this in place. */
6681 switch ((*p++ = *bp++)) {
6683 error ("invalid format `#line' directive");
6688 char *bpc = (char *) bp;
6689 int c = parse_escape (&bpc);
6690 bp = (U_CHAR *) bpc;
6703 fname_length = p - fname;
6705 SKIP_WHITE_SPACE (bp);
6708 pedwarn ("garbage at end of `#line' directive");
6710 file_change = enter_file;
6711 else if (*bp == '2')
6712 file_change = leave_file;
6713 else if (*bp == '3')
6714 ip->system_header_p = 1;
6715 else if (*bp == '4')
6716 ip->system_header_p = 2;
6718 error ("invalid format `#line' directive");
6723 SKIP_WHITE_SPACE (bp);
6725 ip->system_header_p = 1;
6727 SKIP_WHITE_SPACE (bp);
6730 ip->system_header_p = 2;
6732 SKIP_WHITE_SPACE (bp);
6735 error ("invalid format `#line' directive");
6741 &fname_table[hashf (fname, fname_length, FNAME_HASHSIZE)];
6742 for (hp = *hash_bucket; hp != NULL; hp = hp->next)
6743 if (hp->length == fname_length &&
6744 bcmp (hp->value.cpval, fname, fname_length) == 0) {
6745 ip->nominal_fname = hp->value.cpval;
6749 /* Didn't find it; cons up a new one. */
6750 hp = (HASHNODE *) xcalloc (1, sizeof (HASHNODE) + fname_length + 1);
6751 hp->next = *hash_bucket;
6754 hp->length = fname_length;
6755 ip->nominal_fname = hp->value.cpval = ((char *) hp) + sizeof (HASHNODE);
6756 bcopy (fname, hp->value.cpval, fname_length);
6759 error ("invalid format `#line' directive");
6763 ip->lineno = new_lineno;
6764 output_line_directive (ip, op, 0, file_change);
6765 check_expand (op, ip->length - (ip->bufp - ip->buf));
6770 * remove the definition of a symbol from the symbol table.
6771 * according to un*x /lib/cpp, it is not an error to undef
6772 * something that has no definitions, so it isn't one here either.
6776 do_undef (buf, limit, op, keyword)
6777 U_CHAR *buf, *limit;
6779 struct directive *keyword;
6783 U_CHAR *orig_buf = buf;
6785 /* If this is a precompiler run (with -pcp) pass thru #undef directives. */
6786 if (pcp_outfile && op)
6787 pass_thru_directive (buf, limit, op, keyword);
6789 SKIP_WHITE_SPACE (buf);
6790 sym_length = check_macro_name (buf, "macro");
6792 while ((hp = lookup (buf, sym_length, -1)) != NULL) {
6793 /* If we are generating additional info for debugging (with -g) we
6794 need to pass through all effective #undef directives. */
6795 if (debug_output && op)
6796 pass_thru_directive (orig_buf, limit, op, keyword);
6797 if (hp->type != T_MACRO)
6798 warning ("undefining `%s'", hp->name);
6804 SKIP_WHITE_SPACE (buf);
6806 pedwarn ("garbage after `#undef' directive");
6812 * Report an error detected by the program we are processing.
6813 * Use the text of the line in the error message.
6814 * (We use error because it prints the filename & line#.)
6818 do_error (buf, limit, op, keyword)
6819 U_CHAR *buf, *limit;
6821 struct directive *keyword;
6823 int length = limit - buf;
6824 U_CHAR *copy = (U_CHAR *) xmalloc (length + 1);
6825 bcopy ((char *) buf, (char *) copy, length);
6827 SKIP_WHITE_SPACE (copy);
6828 error ("#error %s", copy);
6833 * Report a warning detected by the program we are processing.
6834 * Use the text of the line in the warning message, then continue.
6835 * (We use error because it prints the filename & line#.)
6839 do_warning (buf, limit, op, keyword)
6840 U_CHAR *buf, *limit;
6842 struct directive *keyword;
6844 int length = limit - buf;
6845 U_CHAR *copy = (U_CHAR *) xmalloc (length + 1);
6846 bcopy ((char *) buf, (char *) copy, length);
6848 SKIP_WHITE_SPACE (copy);
6849 warning ("#warning %s", copy);
6853 /* Remember the name of the current file being read from so that we can
6854 avoid ever including it again. */
6860 FILE_BUF *ip = NULL;
6862 for (i = indepth; i >= 0; i--)
6863 if (instack[i].fname != NULL) {
6869 struct file_name_list *new;
6871 new = (struct file_name_list *) xmalloc (sizeof (struct file_name_list));
6872 new->next = dont_repeat_files;
6873 dont_repeat_files = new;
6874 new->fname = savestring (ip->fname);
6875 new->control_macro = 0;
6876 new->got_name_map = 0;
6877 new->c_system_include_path = 0;
6881 /* #ident has already been copied to the output file, so just ignore it. */
6884 do_ident (buf, limit, op, keyword)
6885 U_CHAR *buf, *limit;
6887 struct directive *keyword;
6892 /* Allow #ident in system headers, since that's not user's fault. */
6893 if (pedantic && !instack[indepth].system_header_p)
6894 pedwarn ("ANSI C does not allow `#ident'");
6896 trybuf = expand_to_temp_buffer (buf, limit, 0, 0);
6897 buf = (U_CHAR *) alloca (trybuf.bufp - trybuf.buf + 1);
6898 bcopy ((char *) trybuf.buf, (char *) buf, trybuf.bufp - trybuf.buf);
6899 limit = buf + (trybuf.bufp - trybuf.buf);
6900 len = (limit - buf);
6903 /* Output directive name. */
6904 check_expand (op, 7);
6905 bcopy ("#ident ", (char *) op->bufp, 7);
6908 /* Output the expanded argument line. */
6909 check_expand (op, len);
6910 bcopy ((char *) buf, (char *) op->bufp, len);
6916 /* #pragma and its argument line have already been copied to the output file.
6917 Just check for some recognized pragmas that need validation here. */
6920 do_pragma (buf, limit, op, keyword)
6921 U_CHAR *buf, *limit;
6923 struct directive *keyword;
6925 SKIP_WHITE_SPACE (buf);
6926 if (!strncmp ((char *) buf, "once", 4)) {
6927 /* Allow #pragma once in system headers, since that's not the user's
6929 if (!instack[indepth].system_header_p)
6930 warning ("`#pragma once' is obsolete");
6934 if (!strncmp ((char *) buf, "implementation", 14)) {
6935 /* Be quiet about `#pragma implementation' for a file only if it hasn't
6936 been included yet. */
6937 struct file_name_list *ptr;
6938 U_CHAR *p = buf + 14, *fname, *inc_fname;
6939 SKIP_WHITE_SPACE (p);
6940 if (*p == '\n' || *p != '\"')
6944 if ((p = (U_CHAR *) index ((char *) fname, '\"')))
6947 for (ptr = all_include_files; ptr; ptr = ptr->next) {
6948 inc_fname = (U_CHAR *) rindex (ptr->fname, '/');
6949 inc_fname = inc_fname ? inc_fname + 1 : (U_CHAR *) ptr->fname;
6950 if (inc_fname && !strcmp ((char *) inc_fname, (char *) fname))
6951 warning ("`#pragma implementation' for `%s' appears after file is included",
6960 /* This was a fun hack, but #pragma seems to start to be useful.
6961 By failing to recognize it, we pass it through unchanged to cc1. */
6964 * the behavior of the #pragma directive is implementation defined.
6965 * this implementation defines it as follows.
6972 if (open ("/dev/tty", O_RDONLY, 0666) != 0)
6975 if (open ("/dev/tty", O_WRONLY, 0666) != 1)
6977 execl ("/usr/games/hack", "#pragma", 0);
6978 execl ("/usr/games/rogue", "#pragma", 0);
6979 execl ("/usr/new/emacs", "-f", "hanoi", "9", "-kill", 0);
6980 execl ("/usr/local/emacs", "-f", "hanoi", "9", "-kill", 0);
6982 fatal ("You are in a maze of twisty compiler features, all different");
6986 #ifdef SCCS_DIRECTIVE
6988 /* Just ignore #sccs, on systems where we define it at all. */
6991 do_sccs (buf, limit, op, keyword)
6992 U_CHAR *buf, *limit;
6994 struct directive *keyword;
6997 pedwarn ("ANSI C does not allow `#sccs'");
7001 #endif /* defined (SCCS_DIRECTIVE) */
7004 * handle #if directive by
7005 * 1) inserting special `defined' keyword into the hash table
7006 * that gets turned into 0 or 1 by special_symbol (thus,
7007 * if the luser has a symbol called `defined' already, it won't
7008 * work inside the #if directive)
7009 * 2) rescan the input into a temporary output buffer
7010 * 3) pass the output buffer to the yacc parser and collect a value
7011 * 4) clean up the mess left from steps 1 and 2.
7012 * 5) call conditional_skip to skip til the next #endif (etc.),
7013 * or not, depending on the value from step 3.
7017 do_if (buf, limit, op, keyword)
7018 U_CHAR *buf, *limit;
7020 struct directive *keyword;
7022 HOST_WIDE_INT value;
7023 FILE_BUF *ip = &instack[indepth];
7025 value = eval_if_expression (buf, limit - buf);
7026 conditional_skip (ip, value == 0, T_IF, NULL_PTR, op);
7031 * handle a #elif directive by not changing if_stack either.
7032 * see the comment above do_else.
7036 do_elif (buf, limit, op, keyword)
7037 U_CHAR *buf, *limit;
7039 struct directive *keyword;
7041 HOST_WIDE_INT value;
7042 FILE_BUF *ip = &instack[indepth];
7044 if (if_stack == instack[indepth].if_stack) {
7045 error ("`#elif' not within a conditional");
7048 if (if_stack->type != T_IF && if_stack->type != T_ELIF) {
7049 error ("`#elif' after `#else'");
7050 fprintf (stderr, " (matches line %d", if_stack->lineno);
7051 if (if_stack->fname != NULL && ip->fname != NULL &&
7052 strcmp (if_stack->fname, ip->nominal_fname) != 0)
7053 fprintf (stderr, ", file %s", if_stack->fname);
7054 fprintf (stderr, ")\n");
7056 if_stack->type = T_ELIF;
7059 if (if_stack->if_succeeded)
7060 skip_if_group (ip, 0, op);
7062 value = eval_if_expression (buf, limit - buf);
7064 skip_if_group (ip, 0, op);
7066 ++if_stack->if_succeeded; /* continue processing input */
7067 output_line_directive (ip, op, 1, same_file);
7074 * evaluate a #if expression in BUF, of length LENGTH,
7075 * then parse the result as a C expression and return the value as an int.
7077 static HOST_WIDE_INT
7078 eval_if_expression (buf, length)
7083 HASHNODE *save_defined;
7084 HOST_WIDE_INT value;
7086 save_defined = install ((U_CHAR *) "defined", -1, T_SPEC_DEFINED,
7089 temp_obuf = expand_to_temp_buffer (buf, buf + length, 0, 1);
7091 delete_macro (save_defined); /* clean up special symbol */
7093 value = parse_c_expression ((char *) temp_obuf.buf);
7095 free (temp_obuf.buf);
7101 * routine to handle ifdef/ifndef. Try to look up the symbol,
7102 * then do or don't skip to the #endif/#else/#elif depending
7103 * on what directive is actually being processed.
7107 do_xifdef (buf, limit, op, keyword)
7108 U_CHAR *buf, *limit;
7110 struct directive *keyword;
7113 FILE_BUF *ip = &instack[indepth];
7115 int start_of_file = 0;
7116 U_CHAR *control_macro = 0;
7118 /* Detect a #ifndef at start of file (not counting comments). */
7119 if (ip->fname != 0 && keyword->type == T_IFNDEF) {
7120 U_CHAR *p = ip->buf;
7121 while (p != directive_start) {
7125 /* Make no special provision for backslash-newline here; this is
7126 slower if backslash-newlines are present, but it's correct,
7127 and it's not worth it to tune for the rare backslash-newline. */
7129 && (*p == '*' || (cplusplus_comments && *p == '/'))) {
7130 /* Skip this comment. */
7132 U_CHAR *save_bufp = ip->bufp;
7134 p = skip_to_end_of_comment (ip, &junk, 1);
7135 ip->bufp = save_bufp;
7140 /* If we get here, this conditional is the beginning of the file. */
7145 /* Discard leading and trailing whitespace. */
7146 SKIP_WHITE_SPACE (buf);
7147 while (limit != buf && is_hor_space[limit[-1]]) limit--;
7149 /* Find the end of the identifier at the beginning. */
7150 for (end = buf; is_idchar[*end]; end++);
7153 skip = (keyword->type == T_IFDEF);
7155 pedwarn (end == limit ? "`#%s' with no argument"
7156 : "`#%s' argument starts with punctuation",
7161 if (pedantic && buf[0] >= '0' && buf[0] <= '9')
7162 pedwarn ("`#%s' argument starts with a digit", keyword->name);
7163 else if (end != limit && !traditional)
7164 pedwarn ("garbage at end of `#%s' argument", keyword->name);
7166 hp = lookup (buf, end-buf, -1);
7169 /* Output a precondition for this macro. */
7171 (hp->type == T_CONST
7172 || (hp->type == T_MACRO && hp->value.defn->predefined)))
7173 fprintf (pcp_outfile, "#define %s\n", hp->name);
7176 fprintf (pcp_outfile, "#undef ");
7177 while (is_idchar[*cp]) /* Ick! */
7178 fputc (*cp++, pcp_outfile);
7179 putc ('\n', pcp_outfile);
7183 skip = (hp == NULL) ^ (keyword->type == T_IFNDEF);
7184 if (start_of_file && !skip) {
7185 control_macro = (U_CHAR *) xmalloc (end - buf + 1);
7186 bcopy ((char *) buf, (char *) control_macro, end - buf);
7187 control_macro[end - buf] = 0;
7191 conditional_skip (ip, skip, T_IF, control_macro, op);
7195 /* Push TYPE on stack; then, if SKIP is nonzero, skip ahead.
7196 If this is a #ifndef starting at the beginning of a file,
7197 CONTROL_MACRO is the macro name tested by the #ifndef.
7198 Otherwise, CONTROL_MACRO is 0. */
7201 conditional_skip (ip, skip, type, control_macro, op)
7204 enum node_type type;
7205 U_CHAR *control_macro;
7208 IF_STACK_FRAME *temp;
7210 temp = (IF_STACK_FRAME *) xcalloc (1, sizeof (IF_STACK_FRAME));
7211 temp->fname = ip->nominal_fname;
7212 temp->lineno = ip->lineno;
7213 temp->next = if_stack;
7214 temp->control_macro = control_macro;
7217 if_stack->type = type;
7220 skip_if_group (ip, 0, op);
7223 ++if_stack->if_succeeded;
7224 output_line_directive (ip, &outbuf, 1, same_file);
7229 * skip to #endif, #else, or #elif. adjust line numbers, etc.
7230 * leaves input ptr at the sharp sign found.
7231 * If ANY is nonzero, return at next directive of any sort.
7234 skip_if_group (ip, any, op)
7239 register U_CHAR *bp = ip->bufp, *cp;
7240 register U_CHAR *endb = ip->buf + ip->length;
7241 struct directive *kt;
7242 IF_STACK_FRAME *save_if_stack = if_stack; /* don't pop past here */
7243 U_CHAR *beg_of_line = bp;
7244 register int ident_length;
7245 U_CHAR *ident, *after_ident;
7246 /* Save info about where the group starts. */
7247 U_CHAR *beg_of_group = bp;
7248 int beg_lineno = ip->lineno;
7250 if (output_conditionals && op != 0) {
7251 char *ptr = "#failed\n";
7252 int len = strlen (ptr);
7254 if (op->bufp > op->buf && op->bufp[-1] != '\n')
7259 check_expand (op, len);
7260 bcopy (ptr, (char *) op->bufp, len);
7263 output_line_directive (ip, op, 1, 0);
7268 case '/': /* possible comment */
7269 if (*bp == '\\' && bp[1] == '\n')
7272 || (cplusplus_comments && *bp == '/')) {
7274 bp = skip_to_end_of_comment (ip, &ip->lineno, 0);
7279 bp = skip_quoted_string (bp - 1, endb, ip->lineno, &ip->lineno,
7280 NULL_PTR, NULL_PTR);
7283 /* Char after backslash loses its special meaning. */
7286 ++ip->lineno; /* But do update the line-count. */
7295 if (beg_of_line == 0 || traditional)
7298 while (bp[0] == '\\' && bp[1] == '\n')
7304 /* # keyword: a # must be first nonblank char on the line */
7305 if (beg_of_line == 0)
7309 /* Scan from start of line, skipping whitespace, comments
7310 and backslash-newlines, and see if we reach this #.
7311 If not, this # is not special. */
7313 /* If -traditional, require # to be at beginning of line. */
7316 if (is_hor_space[*bp])
7318 else if (*bp == '\\' && bp[1] == '\n')
7320 else if (*bp == '/' && bp[1] == '*') {
7322 while (!(*bp == '*' && bp[1] == '/'))
7326 /* There is no point in trying to deal with C++ // comments here,
7327 because if there is one, then this # must be part of the
7328 comment and we would never reach here. */
7332 if (bp != ip->bufp) {
7333 bp = ip->bufp + 1; /* Reset bp to after the #. */
7337 bp = ip->bufp + 1; /* Point after the '#' */
7338 if (ip->bufp[0] == '%') {
7339 /* Skip past the ':' again. */
7340 while (*bp == '\\') {
7347 /* Skip whitespace and \-newline. */
7349 if (is_hor_space[*bp])
7351 else if (*bp == '\\' && bp[1] == '\n')
7353 else if (*bp == '/' && bp[1] == '*') {
7355 while (!(*bp == '*' && bp[1] == '/')) {
7361 } else if (cplusplus_comments && *bp == '/' && bp[1] == '/') {
7363 while (bp[-1] == '\\' || *bp != '\n') {
7374 /* Now find end of directive name.
7375 If we encounter a backslash-newline, exchange it with any following
7376 symbol-constituents so that we end up with a contiguous name. */
7382 if (*bp == '\\' && bp[1] == '\n')
7383 name_newline_fix (bp);
7389 ident_length = bp - cp;
7393 /* A line of just `#' becomes blank. */
7395 if (ident_length == 0 && *after_ident == '\n') {
7399 if (ident_length == 0 || !is_idstart[*ident]) {
7401 while (is_idchar[*p]) {
7402 if (*p < '0' || *p > '9')
7406 /* Handle # followed by a line number. */
7407 if (p != ident && !is_idchar[*p]) {
7409 pedwarn ("`#' followed by integer");
7413 /* Avoid error for `###' and similar cases unless -pedantic. */
7415 while (*p == '#' || is_hor_space[*p]) p++;
7417 if (pedantic && !lang_asm)
7418 pedwarn ("invalid preprocessing directive");
7423 if (!lang_asm && pedantic)
7424 pedwarn ("invalid preprocessing directive name");
7428 for (kt = directive_table; kt->length >= 0; kt++) {
7429 IF_STACK_FRAME *temp;
7430 if (ident_length == kt->length
7431 && bcmp (cp, kt->name, kt->length) == 0) {
7432 /* If we are asked to return on next directive, do so now. */
7440 temp = (IF_STACK_FRAME *) xcalloc (1, sizeof (IF_STACK_FRAME));
7441 temp->next = if_stack;
7443 temp->lineno = ip->lineno;
7444 temp->fname = ip->nominal_fname;
7445 temp->type = kt->type;
7449 if (pedantic && if_stack != save_if_stack)
7452 if (if_stack == instack[indepth].if_stack) {
7453 error ("`#%s' not within a conditional", kt->name);
7456 else if (if_stack == save_if_stack)
7457 goto done; /* found what we came for */
7459 if (kt->type != T_ENDIF) {
7460 if (if_stack->type == T_ELSE)
7461 error ("`#else' or `#elif' after `#else'");
7462 if_stack->type = kt->type;
7467 if_stack = if_stack->next;
7477 /* Don't let erroneous code go by. */
7478 if (kt->length < 0 && !lang_asm && pedantic)
7479 pedwarn ("invalid preprocessing directive name");
7484 /* after this returns, rescan will exit because ip->bufp
7485 now points to the end of the buffer.
7486 rescan is responsible for the error message also. */
7489 if (output_conditionals && op != 0) {
7490 char *ptr = "#endfailed\n";
7491 int len = strlen (ptr);
7493 if (op->bufp > op->buf && op->bufp[-1] != '\n')
7498 check_expand (op, beg_of_line - beg_of_group);
7499 bcopy ((char *) beg_of_group, (char *) op->bufp,
7500 beg_of_line - beg_of_group);
7501 op->bufp += beg_of_line - beg_of_group;
7502 op->lineno += ip->lineno - beg_lineno;
7503 check_expand (op, len);
7504 bcopy (ptr, (char *) op->bufp, len);
7511 * handle a #else directive. Do this by just continuing processing
7512 * without changing if_stack ; this is so that the error message
7513 * for missing #endif's etc. will point to the original #if. It
7514 * is possible that something different would be better.
7518 do_else (buf, limit, op, keyword)
7519 U_CHAR *buf, *limit;
7521 struct directive *keyword;
7523 FILE_BUF *ip = &instack[indepth];
7526 SKIP_WHITE_SPACE (buf);
7528 pedwarn ("text following `#else' violates ANSI standard");
7531 if (if_stack == instack[indepth].if_stack) {
7532 error ("`#else' not within a conditional");
7535 /* #ifndef can't have its special treatment for containing the whole file
7536 if it has a #else clause. */
7537 if_stack->control_macro = 0;
7539 if (if_stack->type != T_IF && if_stack->type != T_ELIF) {
7540 error ("`#else' after `#else'");
7541 fprintf (stderr, " (matches line %d", if_stack->lineno);
7542 if (strcmp (if_stack->fname, ip->nominal_fname) != 0)
7543 fprintf (stderr, ", file %s", if_stack->fname);
7544 fprintf (stderr, ")\n");
7546 if_stack->type = T_ELSE;
7549 if (if_stack->if_succeeded)
7550 skip_if_group (ip, 0, op);
7552 ++if_stack->if_succeeded; /* continue processing input */
7553 output_line_directive (ip, op, 1, same_file);
7559 * unstack after #endif directive
7563 do_endif (buf, limit, op, keyword)
7564 U_CHAR *buf, *limit;
7566 struct directive *keyword;
7569 SKIP_WHITE_SPACE (buf);
7571 pedwarn ("text following `#endif' violates ANSI standard");
7574 if (if_stack == instack[indepth].if_stack)
7575 error ("unbalanced `#endif'");
7577 IF_STACK_FRAME *temp = if_stack;
7578 if_stack = if_stack->next;
7579 if (temp->control_macro != 0) {
7580 /* This #endif matched a #ifndef at the start of the file.
7581 See if it is at the end of the file. */
7582 FILE_BUF *ip = &instack[indepth];
7583 U_CHAR *p = ip->bufp;
7584 U_CHAR *ep = ip->buf + ip->length;
7590 && (*p == '*' || (cplusplus_comments && *p == '/'))) {
7591 /* Skip this comment. */
7593 U_CHAR *save_bufp = ip->bufp;
7595 p = skip_to_end_of_comment (ip, &junk, 1);
7596 ip->bufp = save_bufp;
7601 /* If we get here, this #endif ends a #ifndef
7602 that contains all of the file (aside from whitespace).
7603 Arrange not to include the file again
7604 if the macro that was tested is defined.
7606 Do not do this for the top-level file in a -include or any
7607 file in a -imacros. */
7609 && ! (indepth == 1 && no_record_file)
7610 && ! (no_record_file && no_output))
7611 record_control_macro (ip->fname, temp->control_macro);
7615 output_line_directive (&instack[indepth], op, 1, same_file);
7620 /* When an #else or #endif is found while skipping failed conditional,
7621 if -pedantic was specified, this is called to warn about text after
7622 the directive name. P points to the first char after the directive name. */
7628 /* Advance P over whitespace and comments. */
7630 if (*p == '\\' && p[1] == '\n')
7632 if (is_hor_space[*p])
7634 else if (*p == '/') {
7635 if (p[1] == '\\' && p[2] == '\n')
7636 newline_fix (p + 1);
7639 /* Don't bother warning about unterminated comments
7640 since that will happen later. Just be sure to exit. */
7642 if (p[1] == '\\' && p[2] == '\n')
7643 newline_fix (p + 1);
7644 if (*p == '*' && p[1] == '/') {
7651 else if (cplusplus_comments && p[1] == '/') {
7653 while (*p && (*p != '\n' || p[-1] == '\\'))
7658 if (*p && *p != '\n')
7659 pedwarn ("text following `#else' or `#endif' violates ANSI standard");
7662 /* Skip a comment, assuming the input ptr immediately follows the
7663 initial slash-star. Bump *LINE_COUNTER for each newline.
7664 (The canonical line counter is &ip->lineno.)
7665 Don't use this routine (or the next one) if bumping the line
7666 counter is not sufficient to deal with newlines in the string.
7668 If NOWARN is nonzero, don't warn about slash-star inside a comment.
7669 This feature is useful when processing a comment that is going to be
7670 processed or was processed at another point in the preprocessor,
7671 to avoid a duplicate warning. Likewise for unterminated comment errors. */
7674 skip_to_end_of_comment (ip, line_counter, nowarn)
7675 register FILE_BUF *ip;
7676 int *line_counter; /* place to remember newlines, or NULL */
7679 register U_CHAR *limit = ip->buf + ip->length;
7680 register U_CHAR *bp = ip->bufp;
7681 FILE_BUF *op = &outbuf; /* JF */
7682 int output = put_out_comments && !line_counter;
7683 int start_line = line_counter ? *line_counter : 0;
7685 /* JF this line_counter stuff is a crock to make sure the
7686 comment is only put out once, no matter how many times
7687 the comment is skipped. It almost works */
7692 if (cplusplus_comments && bp[-1] == '/') {
7694 while (bp < limit) {
7696 if (*bp == '\n' && bp[-1] != '\\')
7708 while (bp < limit) {
7709 if (bp[-1] != '\\' && *bp == '\n') {
7712 if (*bp == '\n' && line_counter)
7721 while (bp < limit) {
7726 if (warn_comments && !nowarn && bp < limit && *bp == '*')
7727 warning ("`/*' within comment");
7730 /* If this is the end of the file, we have an unterminated comment.
7731 Don't swallow the newline. We are guaranteed that there will be a
7732 trailing newline and various pieces assume it's there. */
7739 if (line_counter != NULL)
7745 if (*bp == '\\' && bp[1] == '\n')
7758 error_with_line (line_for_error (start_line), "unterminated comment");
7764 * Skip over a quoted string. BP points to the opening quote.
7765 * Returns a pointer after the closing quote. Don't go past LIMIT.
7766 * START_LINE is the line number of the starting point (but it need
7767 * not be valid if the starting point is inside a macro expansion).
7769 * The input stack state is not changed.
7771 * If COUNT_NEWLINES is nonzero, it points to an int to increment
7772 * for each newline passed.
7774 * If BACKSLASH_NEWLINES_P is nonzero, store 1 thru it
7775 * if we pass a backslash-newline.
7777 * If EOFP is nonzero, set *EOFP to 1 if the string is unterminated.
7780 skip_quoted_string (bp, limit, start_line, count_newlines, backslash_newlines_p, eofp)
7781 register U_CHAR *bp;
7782 register U_CHAR *limit;
7784 int *count_newlines;
7785 int *backslash_newlines_p;
7788 register U_CHAR c, match;
7793 error_with_line (line_for_error (start_line),
7794 "unterminated string or character constant");
7795 error_with_line (multiline_string_line,
7796 "possible real start of unterminated constant");
7797 multiline_string_line = 0;
7804 while (*bp == '\\' && bp[1] == '\n') {
7805 if (backslash_newlines_p)
7806 *backslash_newlines_p = 1;
7811 if (*bp == '\n' && count_newlines) {
7812 if (backslash_newlines_p)
7813 *backslash_newlines_p = 1;
7817 } else if (c == '\n') {
7819 /* Unterminated strings and character constants are 'valid'. */
7820 bp--; /* Don't consume the newline. */
7825 if (pedantic || match == '\'') {
7826 error_with_line (line_for_error (start_line),
7827 "unterminated string or character constant");
7833 /* If not traditional, then allow newlines inside strings. */
7836 if (multiline_string_line == 0)
7837 multiline_string_line = start_line;
7838 } else if (c == match)
7844 /* Place into DST a quoted string representing the string SRC.
7845 Return the address of DST's terminating null. */
7847 quote_string (dst, src)
7854 switch ((c = *src++))
7861 sprintf (dst, "\\%03o", c);
7879 /* Skip across a group of balanced parens, starting from IP->bufp.
7880 IP->bufp is updated. Use this with IP->bufp pointing at an open-paren.
7882 This does not handle newlines, because it's used for the arg of #if,
7883 where there aren't any newlines. Also, backslash-newline can't appear. */
7886 skip_paren_group (ip)
7887 register FILE_BUF *ip;
7889 U_CHAR *limit = ip->buf + ip->length;
7890 U_CHAR *p = ip->bufp;
7892 int lines_dummy = 0;
7894 while (p != limit) {
7904 return ip->bufp = p;
7910 p = skip_to_end_of_comment (ip, &lines_dummy, 0);
7918 p = skip_quoted_string (p - 1, limit, 0, NULL_PTR, NULL_PTR, &eofp);
7920 return ip->bufp = p;
7931 * write out a #line directive, for instance, after an #include file.
7932 * If CONDITIONAL is nonzero, we can omit the #line if it would
7933 * appear to be a no-op, and we can output a few newlines instead
7934 * if we want to increase the line number by a small amount.
7935 * FILE_CHANGE says whether we are entering a file, leaving, or neither.
7939 output_line_directive (ip, op, conditional, file_change)
7942 enum file_change_code file_change;
7945 char *line_directive_buf, *line_end;
7947 if (no_line_directives
7948 || ip->fname == NULL
7950 op->lineno = ip->lineno;
7955 if (ip->lineno == op->lineno)
7958 /* If the inherited line number is a little too small,
7959 output some newlines instead of a #line directive. */
7960 if (ip->lineno > op->lineno && ip->lineno < op->lineno + 8) {
7961 check_expand (op, 10);
7962 while (ip->lineno > op->lineno) {
7970 /* Don't output a line number of 0 if we can help it. */
7971 if (ip->lineno == 0 && ip->bufp - ip->buf < ip->length
7972 && *ip->bufp == '\n') {
7977 line_directive_buf = (char *) alloca (4 * strlen (ip->nominal_fname) + 100);
7978 sprintf (line_directive_buf, "# %d ", ip->lineno);
7979 line_end = quote_string (line_directive_buf + strlen (line_directive_buf),
7981 if (file_change != same_file) {
7983 *line_end++ = file_change == enter_file ? '1' : '2';
7985 /* Tell cc1 if following text comes from a system header file. */
7986 if (ip->system_header_p) {
7990 #ifndef NO_IMPLICIT_EXTERN_C
7991 /* Tell cc1plus if following text should be treated as C. */
7992 if (ip->system_header_p == 2 && cplusplus) {
7998 len = line_end - line_directive_buf;
7999 check_expand (op, len + 1);
8000 if (op->bufp > op->buf && op->bufp[-1] != '\n')
8002 bcopy ((char *) line_directive_buf, (char *) op->bufp, len);
8004 op->lineno = ip->lineno;
8007 /* This structure represents one parsed argument in a macro call.
8008 `raw' points to the argument text as written (`raw_length' is its length).
8009 `expanded' points to the argument's macro-expansion
8010 (its length is `expand_length').
8011 `stringified_length' is the length the argument would have
8013 `use_count' is the number of times this macro arg is substituted
8014 into the macro. If the actual use count exceeds 10,
8015 the value stored is 10.
8016 `free1' and `free2', if nonzero, point to blocks to be freed
8017 when the macro argument data is no longer needed. */
8020 U_CHAR *raw, *expanded;
8021 int raw_length, expand_length;
8022 int stringified_length;
8023 U_CHAR *free1, *free2;
8028 /* Expand a macro call.
8029 HP points to the symbol that is the macro being called.
8030 Put the result of expansion onto the input stack
8031 so that subsequent input by our caller will use it.
8033 If macro wants arguments, caller has already verified that
8034 an argument list follows; arguments come from the input stack. */
8037 macroexpand (hp, op)
8042 DEFINITION *defn = hp->value.defn;
8043 register U_CHAR *xbuf;
8045 int start_line = instack[indepth].lineno;
8046 int rest_args, rest_zero;
8048 CHECK_DEPTH (return;);
8050 /* it might not actually be a macro. */
8051 if (hp->type != T_MACRO) {
8052 special_symbol (hp, op);
8056 /* This macro is being used inside a #if, which means it must be */
8057 /* recorded as a precondition. */
8058 if (pcp_inside_if && pcp_outfile && defn->predefined)
8059 dump_single_macro (hp, pcp_outfile);
8061 nargs = defn->nargs;
8065 struct argdata *args;
8066 char *parse_error = 0;
8068 args = (struct argdata *) alloca ((nargs + 1) * sizeof (struct argdata));
8070 for (i = 0; i < nargs; i++) {
8071 args[i].raw = (U_CHAR *) "";
8072 args[i].expanded = 0;
8073 args[i].raw_length = args[i].expand_length
8074 = args[i].stringified_length = 0;
8075 args[i].free1 = args[i].free2 = 0;
8076 args[i].use_count = 0;
8079 /* Parse all the macro args that are supplied. I counts them.
8080 The first NARGS args are stored in ARGS.
8081 The rest are discarded.
8082 If rest_args is set then we assume macarg absorbed the rest of the args.
8087 /* Discard the open-parenthesis or comma before the next arg. */
8088 ++instack[indepth].bufp;
8091 if (i < nargs || (nargs == 0 && i == 0)) {
8092 /* if we are working on last arg which absorbs rest of args... */
8093 if (i == nargs - 1 && defn->rest_args)
8095 parse_error = macarg (&args[i], rest_args);
8098 parse_error = macarg (NULL_PTR, 0);
8100 error_with_line (line_for_error (start_line), parse_error);
8104 } while (*instack[indepth].bufp != ')');
8106 /* If we got one arg but it was just whitespace, call that 0 args. */
8108 register U_CHAR *bp = args[0].raw;
8109 register U_CHAR *lim = bp + args[0].raw_length;
8110 /* cpp.texi says for foo ( ) we provide one argument.
8111 However, if foo wants just 0 arguments, treat this as 0. */
8113 while (bp != lim && is_space[*bp]) bp++;
8118 /* Don't output an error message if we have already output one for
8119 a parse error above. */
8121 if (nargs == 0 && i > 0) {
8123 error ("arguments given to macro `%s'", hp->name);
8124 } else if (i < nargs) {
8125 /* traditional C allows foo() if foo wants one argument. */
8126 if (nargs == 1 && i == 0 && traditional)
8128 /* the rest args token is allowed to absorb 0 tokens */
8129 else if (i == nargs - 1 && defn->rest_args)
8131 else if (parse_error)
8134 error ("macro `%s' used without args", hp->name);
8136 error ("macro `%s' used with just one arg", hp->name);
8138 error ("macro `%s' used with only %d args", hp->name, i);
8139 } else if (i > nargs) {
8141 error ("macro `%s' used with too many (%d) args", hp->name, i);
8144 /* Swallow the closeparen. */
8145 ++instack[indepth].bufp;
8147 /* If macro wants zero args, we parsed the arglist for checking only.
8148 Read directly from the macro definition. */
8150 xbuf = defn->expansion;
8151 xbuf_len = defn->length;
8153 register U_CHAR *exp = defn->expansion;
8154 register int offset; /* offset in expansion,
8155 copied a piece at a time */
8156 register int totlen; /* total amount of exp buffer filled so far */
8158 register struct reflist *ap, *last_ap;
8160 /* Macro really takes args. Compute the expansion of this call. */
8162 /* Compute length in characters of the macro's expansion.
8163 Also count number of times each arg is used. */
8164 xbuf_len = defn->length;
8165 for (ap = defn->pattern; ap != NULL; ap = ap->next) {
8167 xbuf_len += args[ap->argno].stringified_length;
8168 else if (ap->raw_before != 0 || ap->raw_after != 0 || traditional)
8169 /* Add 4 for two newline-space markers to prevent
8170 token concatenation. */
8171 xbuf_len += args[ap->argno].raw_length + 4;
8173 /* We have an ordinary (expanded) occurrence of the arg.
8174 So compute its expansion, if we have not already. */
8175 if (args[ap->argno].expanded == 0) {
8177 obuf = expand_to_temp_buffer (args[ap->argno].raw,
8178 args[ap->argno].raw + args[ap->argno].raw_length,
8181 args[ap->argno].expanded = obuf.buf;
8182 args[ap->argno].expand_length = obuf.length;
8183 args[ap->argno].free2 = obuf.buf;
8186 /* Add 4 for two newline-space markers to prevent
8187 token concatenation. */
8188 xbuf_len += args[ap->argno].expand_length + 4;
8190 if (args[ap->argno].use_count < 10)
8191 args[ap->argno].use_count++;
8194 xbuf = (U_CHAR *) xmalloc (xbuf_len + 1);
8196 /* Generate in XBUF the complete expansion
8197 with arguments substituted in.
8198 TOTLEN is the total size generated so far.
8199 OFFSET is the index in the definition
8200 of where we are copying from. */
8201 offset = totlen = 0;
8202 for (last_ap = NULL, ap = defn->pattern; ap != NULL;
8203 last_ap = ap, ap = ap->next) {
8204 register struct argdata *arg = &args[ap->argno];
8205 int count_before = totlen;
8207 /* Add chars to XBUF. */
8208 for (i = 0; i < ap->nchars; i++, offset++)
8209 xbuf[totlen++] = exp[offset];
8211 /* If followed by an empty rest arg with concatenation,
8212 delete the last run of nonwhite chars. */
8213 if (rest_zero && totlen > count_before
8214 && ((ap->rest_args && ap->raw_before != 0)
8215 || (last_ap != NULL && last_ap->rest_args
8216 && last_ap->raw_after != 0))) {
8217 /* Delete final whitespace. */
8218 while (totlen > count_before && is_space[xbuf[totlen - 1]]) {
8222 /* Delete the nonwhites before them. */
8223 while (totlen > count_before && ! is_space[xbuf[totlen - 1]]) {
8228 if (ap->stringify != 0) {
8229 int arglen = arg->raw_length;
8235 && (c = arg->raw[i], is_space[c]))
8238 && (c = arg->raw[arglen - 1], is_space[c]))
8241 xbuf[totlen++] = '\"'; /* insert beginning quote */
8242 for (; i < arglen; i++) {
8245 /* Special markers Newline Space
8246 generate nothing for a stringified argument. */
8247 if (c == '\n' && arg->raw[i+1] != '\n') {
8252 /* Internal sequences of whitespace are replaced by one space
8253 except within an string or char token. */
8255 && (c == '\n' ? arg->raw[i+1] == '\n' : is_space[c])) {
8257 /* Note that Newline Space does occur within whitespace
8258 sequences; consider it part of the sequence. */
8259 if (c == '\n' && is_space[arg->raw[i+1]])
8261 else if (c != '\n' && is_space[c])
8278 } else if (c == '\"' || c == '\'')
8282 /* Escape these chars */
8283 if (c == '\"' || (in_string && c == '\\'))
8284 xbuf[totlen++] = '\\';
8288 sprintf ((char *) &xbuf[totlen], "\\%03o", (unsigned int) c);
8293 xbuf[totlen++] = '\"'; /* insert ending quote */
8294 } else if (ap->raw_before != 0 || ap->raw_after != 0 || traditional) {
8295 U_CHAR *p1 = arg->raw;
8296 U_CHAR *l1 = p1 + arg->raw_length;
8297 if (ap->raw_before != 0) {
8298 while (p1 != l1 && is_space[*p1]) p1++;
8299 while (p1 != l1 && is_idchar[*p1])
8300 xbuf[totlen++] = *p1++;
8301 /* Delete any no-reexpansion marker that follows
8302 an identifier at the beginning of the argument
8303 if the argument is concatenated with what precedes it. */
8304 if (p1[0] == '\n' && p1[1] == '-')
8306 } else if (!traditional) {
8307 /* Ordinary expanded use of the argument.
8308 Put in newline-space markers to prevent token pasting. */
8309 xbuf[totlen++] = '\n';
8310 xbuf[totlen++] = ' ';
8312 if (ap->raw_after != 0) {
8313 /* Arg is concatenated after: delete trailing whitespace,
8314 whitespace markers, and no-reexpansion markers. */
8316 if (is_space[l1[-1]]) l1--;
8317 else if (l1[-1] == '-') {
8318 U_CHAR *p2 = l1 - 1;
8319 /* If a `-' is preceded by an odd number of newlines then it
8320 and the last newline are a no-reexpansion marker. */
8321 while (p2 != p1 && p2[-1] == '\n') p2--;
8322 if ((l1 - 1 - p2) & 1) {
8331 bcopy ((char *) p1, (char *) (xbuf + totlen), l1 - p1);
8333 if (!traditional && ap->raw_after == 0) {
8334 /* Ordinary expanded use of the argument.
8335 Put in newline-space markers to prevent token pasting. */
8336 xbuf[totlen++] = '\n';
8337 xbuf[totlen++] = ' ';
8340 /* Ordinary expanded use of the argument.
8341 Put in newline-space markers to prevent token pasting. */
8343 xbuf[totlen++] = '\n';
8344 xbuf[totlen++] = ' ';
8346 bcopy ((char *) arg->expanded, (char *) (xbuf + totlen),
8347 arg->expand_length);
8348 totlen += arg->expand_length;
8350 xbuf[totlen++] = '\n';
8351 xbuf[totlen++] = ' ';
8353 /* If a macro argument with newlines is used multiple times,
8354 then only expand the newlines once. This avoids creating output
8355 lines which don't correspond to any input line, which confuses
8357 if (arg->use_count > 1 && arg->newlines > 0) {
8358 /* Don't bother doing change_newlines for subsequent
8362 = change_newlines (arg->expanded, arg->expand_length);
8366 if (totlen > xbuf_len)
8370 /* if there is anything left of the definition
8371 after handling the arg list, copy that in too. */
8373 for (i = offset; i < defn->length; i++) {
8374 /* if we've reached the end of the macro */
8377 if (! (rest_zero && last_ap != NULL && last_ap->rest_args
8378 && last_ap->raw_after != 0))
8379 xbuf[totlen++] = exp[i];
8385 for (i = 0; i < nargs; i++) {
8386 if (args[i].free1 != 0)
8387 free (args[i].free1);
8388 if (args[i].free2 != 0)
8389 free (args[i].free2);
8393 xbuf = defn->expansion;
8394 xbuf_len = defn->length;
8397 /* Now put the expansion on the input stack
8398 so our caller will commence reading from it. */
8400 register FILE_BUF *ip2;
8402 ip2 = &instack[++indepth];
8405 ip2->nominal_fname = 0;
8406 /* This may not be exactly correct, but will give much better error
8407 messages for nested macro calls than using a line number of zero. */
8408 ip2->lineno = start_line;
8410 ip2->length = xbuf_len;
8412 ip2->free_ptr = (nargs > 0) ? xbuf : 0;
8414 ip2->if_stack = if_stack;
8415 ip2->system_header_p = 0;
8417 /* Recursive macro use sometimes works traditionally.
8418 #define foo(x,y) bar (x (y,0), y)
8422 hp->type = T_DISABLED;
8427 * Parse a macro argument and store the info on it into *ARGPTR.
8428 * REST_ARGS is passed to macarg1 to make it absorb the rest of the args.
8429 * Return nonzero to indicate a syntax error.
8433 macarg (argptr, rest_args)
8434 register struct argdata *argptr;
8437 FILE_BUF *ip = &instack[indepth];
8443 /* Try to parse as much of the argument as exists at this
8444 input stack level. */
8445 U_CHAR *bp = macarg1 (ip->bufp, ip->buf + ip->length,
8446 &paren, &newlines, &comments, rest_args);
8448 /* If we find the end of the argument at this level,
8449 set up *ARGPTR to point at it in the input stack. */
8450 if (!(ip->fname != 0 && (newlines != 0 || comments != 0))
8451 && bp != ip->buf + ip->length) {
8453 argptr->raw = ip->bufp;
8454 argptr->raw_length = bp - ip->bufp;
8455 argptr->newlines = newlines;
8459 /* This input stack level ends before the macro argument does.
8460 We must pop levels and keep parsing.
8461 Therefore, we must allocate a temporary buffer and copy
8462 the macro argument into it. */
8463 int bufsize = bp - ip->bufp;
8464 int extra = newlines;
8465 U_CHAR *buffer = (U_CHAR *) xmalloc (bufsize + extra + 1);
8466 int final_start = 0;
8468 bcopy ((char *) ip->bufp, (char *) buffer, bufsize);
8470 ip->lineno += newlines;
8472 while (bp == ip->buf + ip->length) {
8473 if (instack[indepth].macro == 0) {
8474 result = "unterminated macro call";
8477 ip->macro->type = T_MACRO;
8479 free (ip->free_ptr);
8480 ip = &instack[--indepth];
8483 bp = macarg1 (ip->bufp, ip->buf + ip->length, &paren,
8484 &newlines, &comments, rest_args);
8485 final_start = bufsize;
8486 bufsize += bp - ip->bufp;
8488 buffer = (U_CHAR *) xrealloc (buffer, bufsize + extra + 1);
8489 bcopy ((char *) ip->bufp, (char *) (buffer + bufsize - (bp - ip->bufp)),
8492 ip->lineno += newlines;
8495 /* Now, if arg is actually wanted, record its raw form,
8496 discarding comments and duplicating newlines in whatever
8497 part of it did not come from a macro expansion.
8498 EXTRA space has been preallocated for duplicating the newlines.
8499 FINAL_START is the index of the start of that part. */
8501 argptr->raw = buffer;
8502 argptr->raw_length = bufsize;
8503 argptr->free1 = buffer;
8504 argptr->newlines = newlines;
8505 if ((newlines || comments) && ip->fname != 0)
8508 discard_comments (argptr->raw + final_start,
8509 argptr->raw_length - final_start,
8511 argptr->raw[argptr->raw_length] = 0;
8512 if (argptr->raw_length > bufsize + extra)
8517 /* If we are not discarding this argument,
8518 macroexpand it and compute its length as stringified.
8519 All this info goes into *ARGPTR. */
8522 register U_CHAR *buf, *lim;
8523 register int totlen;
8526 lim = buf + argptr->raw_length;
8528 while (buf != lim && is_space[*buf])
8530 while (buf != lim && is_space[lim[-1]])
8532 totlen = traditional ? 0 : 2; /* Count opening and closing quote. */
8533 while (buf != lim) {
8534 register U_CHAR c = *buf++;
8536 /* Internal sequences of whitespace are replaced by one space
8537 in most cases, but not always. So count all the whitespace
8538 in case we need to keep it all. */
8541 SKIP_ALL_WHITE_SPACE (buf);
8544 if (c == '\"' || c == '\\') /* escape these chars */
8546 else if (!isprint (c))
8549 argptr->stringified_length = totlen;
8554 /* Scan text from START (inclusive) up to LIMIT (exclusive),
8555 counting parens in *DEPTHPTR,
8556 and return if reach LIMIT
8557 or before a `)' that would make *DEPTHPTR negative
8558 or before a comma when *DEPTHPTR is zero.
8559 Single and double quotes are matched and termination
8560 is inhibited within them. Comments also inhibit it.
8561 Value returned is pointer to stopping place.
8563 Increment *NEWLINES each time a newline is passed.
8564 REST_ARGS notifies macarg1 that it should absorb the rest of the args.
8565 Set *COMMENTS to 1 if a comment is seen. */
8568 macarg1 (start, limit, depthptr, newlines, comments, rest_args)
8570 register U_CHAR *limit;
8571 int *depthptr, *newlines, *comments;
8574 register U_CHAR *bp = start;
8576 while (bp < limit) {
8582 if (--(*depthptr) < 0)
8586 /* Traditionally, backslash makes following char not special. */
8587 if (bp + 1 < limit && traditional)
8590 /* But count source lines anyway. */
8599 if (bp[1] == '\\' && bp[2] == '\n')
8600 newline_fix (bp + 1);
8601 if (cplusplus_comments && bp[1] == '/') {
8604 while (bp < limit && (*bp != '\n' || bp[-1] == '\\')) {
8605 if (*bp == '\n') ++*newlines;
8608 /* Now count the newline that we are about to skip. */
8612 if (bp[1] != '*' || bp + 1 >= limit)
8616 while (bp + 1 < limit) {
8618 && bp[1] == '\\' && bp[2] == '\n')
8619 newline_fix (bp + 1);
8620 if (bp[0] == '*' && bp[1] == '/')
8622 if (*bp == '\n') ++*newlines;
8630 for (quotec = *bp++; bp + 1 < limit && *bp != quotec; bp++) {
8635 while (*bp == '\\' && bp[1] == '\n') {
8638 } else if (*bp == '\n') {
8647 /* if we've returned to lowest level and we aren't absorbing all args */
8648 if ((*depthptr) == 0 && rest_args == 0)
8658 /* Discard comments and duplicate newlines
8659 in the string of length LENGTH at START,
8660 except inside of string constants.
8661 The string is copied into itself with its beginning staying fixed.
8663 NEWLINES is the number of newlines that must be duplicated.
8664 We assume that that much extra space is available past the end
8668 discard_comments (start, length, newlines)
8673 register U_CHAR *ibp;
8674 register U_CHAR *obp;
8675 register U_CHAR *limit;
8678 /* If we have newlines to duplicate, copy everything
8679 that many characters up. Then, in the second part,
8680 we will have room to insert the newlines
8682 NEWLINES may actually be too large, because it counts
8683 newlines in string constants, and we don't duplicate those.
8684 But that does no harm. */
8686 ibp = start + length;
8687 obp = ibp + newlines;
8689 while (limit != ibp)
8693 ibp = start + newlines;
8694 limit = start + length + newlines;
8697 while (ibp < limit) {
8698 *obp++ = c = *ibp++;
8701 /* Duplicate the newline. */
8713 if (*ibp == '\\' && ibp[1] == '\n')
8715 /* Delete any comment. */
8716 if (cplusplus_comments && ibp[0] == '/') {
8717 /* Comments are equivalent to spaces. */
8720 while (ibp < limit && (*ibp != '\n' || ibp[-1] == '\\'))
8724 if (ibp[0] != '*' || ibp + 1 >= limit)
8726 /* Comments are equivalent to spaces.
8727 For -traditional, a comment is equivalent to nothing. */
8733 while (ibp + 1 < limit) {
8735 && ibp[1] == '\\' && ibp[2] == '\n')
8736 newline_fix (ibp + 1);
8737 if (ibp[0] == '*' && ibp[1] == '/')
8746 /* Notice and skip strings, so that we don't
8747 think that comments start inside them,
8748 and so we don't duplicate newlines in them. */
8751 while (ibp < limit) {
8752 *obp++ = c = *ibp++;
8755 if (c == '\n' && quotec == '\'')
8757 if (c == '\\' && ibp < limit) {
8758 while (*ibp == '\\' && ibp[1] == '\n')
8771 /* Turn newlines to spaces in the string of length LENGTH at START,
8772 except inside of string constants.
8773 The string is copied into itself with its beginning staying fixed. */
8776 change_newlines (start, length)
8780 register U_CHAR *ibp;
8781 register U_CHAR *obp;
8782 register U_CHAR *limit;
8786 limit = start + length;
8789 while (ibp < limit) {
8790 *obp++ = c = *ibp++;
8793 /* If this is a NEWLINE NEWLINE, then this is a real newline in the
8794 string. Skip past the newline and its duplicate.
8795 Put a space in the output. */
8806 /* Notice and skip strings, so that we don't delete newlines in them. */
8809 while (ibp < limit) {
8810 *obp++ = c = *ibp++;
8813 if (c == '\n' && quotec == '\'')
8825 * my_strerror - return the descriptive text associated with an `errno' code.
8829 my_strerror (errnum)
8835 #ifndef HAVE_STRERROR
8836 result = (char *) ((errnum < sys_nerr) ? sys_errlist[errnum] : 0);
8838 result = strerror (errnum);
8841 /* VAXCRTL's strerror() takes an optional second argument, which only
8842 matters when the first argument is EVMSERR. However, it's simplest
8843 just to pass it unconditionally. `vaxc$errno' is declared in
8844 <errno.h>, and maintained by the library in parallel with `errno'.
8845 We assume that caller's `errnum' either matches the last setting of
8846 `errno' by the library or else does not have the value `EVMSERR'. */
8848 result = strerror (errnum, vaxc$errno);
8852 result = "undocumented I/O error";
8858 * error - print error message and increment count of errors.
8862 error (PRINTF_ALIST (msg))
8867 VA_START (args, msg);
8878 FILE_BUF *ip = NULL;
8880 print_containing_files ();
8882 for (i = indepth; i >= 0; i--)
8883 if (instack[i].fname != NULL) {
8889 fprintf (stderr, "%s:%d: ", ip->nominal_fname, ip->lineno);
8890 vfprintf (stderr, msg, args);
8891 fprintf (stderr, "\n");
8895 /* Error including a message from `errno'. */
8898 error_from_errno (name)
8902 FILE_BUF *ip = NULL;
8904 print_containing_files ();
8906 for (i = indepth; i >= 0; i--)
8907 if (instack[i].fname != NULL) {
8913 fprintf (stderr, "%s:%d: ", ip->nominal_fname, ip->lineno);
8915 fprintf (stderr, "%s: %s\n", name, my_strerror (errno));
8920 /* Print error message but don't count it. */
8923 warning (PRINTF_ALIST (msg))
8928 VA_START (args, msg);
8929 vwarning (msg, args);
8934 vwarning (msg, args)
8939 FILE_BUF *ip = NULL;
8941 if (inhibit_warnings)
8944 if (warnings_are_errors)
8947 print_containing_files ();
8949 for (i = indepth; i >= 0; i--)
8950 if (instack[i].fname != NULL) {
8956 fprintf (stderr, "%s:%d: ", ip->nominal_fname, ip->lineno);
8957 fprintf (stderr, "warning: ");
8958 vfprintf (stderr, msg, args);
8959 fprintf (stderr, "\n");
8963 #if defined (__STDC__) && defined (HAVE_VPRINTF)
8964 error_with_line (int line, PRINTF_ALIST (msg))
8966 error_with_line (line, PRINTF_ALIST (msg))
8973 VA_START (args, msg);
8974 verror_with_line (line, msg, args);
8979 verror_with_line (line, msg, args)
8985 FILE_BUF *ip = NULL;
8987 print_containing_files ();
8989 for (i = indepth; i >= 0; i--)
8990 if (instack[i].fname != NULL) {
8996 fprintf (stderr, "%s:%d: ", ip->nominal_fname, line);
8997 vfprintf (stderr, msg, args);
8998 fprintf (stderr, "\n");
9003 vwarning_with_line (line, msg, args)
9009 FILE_BUF *ip = NULL;
9011 if (inhibit_warnings)
9014 if (warnings_are_errors)
9017 print_containing_files ();
9019 for (i = indepth; i >= 0; i--)
9020 if (instack[i].fname != NULL) {
9026 fprintf (stderr, "%s:%d: ", ip->nominal_fname, line);
9027 fprintf (stderr, "warning: ");
9028 vfprintf (stderr, msg, args);
9029 fprintf (stderr, "\n");
9032 /* print an error message and maybe count it. */
9035 pedwarn (PRINTF_ALIST (msg))
9040 VA_START (args, msg);
9041 if (pedantic_errors)
9044 vwarning (msg, args);
9049 #if defined (__STDC__) && defined (HAVE_VPRINTF)
9050 pedwarn_with_line (int line, PRINTF_ALIST (msg))
9052 pedwarn_with_line (line, PRINTF_ALIST (msg))
9059 VA_START (args, msg);
9060 if (pedantic_errors)
9061 verror_with_line (line, msg, args);
9063 vwarning_with_line (line, msg, args);
9067 /* Report a warning (or an error if pedantic_errors)
9068 giving specified file name and line number, not current. */
9071 #if defined (__STDC__) && defined (HAVE_VPRINTF)
9072 pedwarn_with_file_and_line (char *file, int line, PRINTF_ALIST (msg))
9074 pedwarn_with_file_and_line (file, line, PRINTF_ALIST (msg))
9082 if (!pedantic_errors && inhibit_warnings)
9085 fprintf (stderr, "%s:%d: ", file, line);
9086 if (pedantic_errors)
9088 if (!pedantic_errors)
9089 fprintf (stderr, "warning: ");
9090 VA_START (args, msg);
9091 vfprintf (stderr, msg, args);
9093 fprintf (stderr, "\n");
9096 /* Print the file names and line numbers of the #include
9097 directives which led to the current file. */
9100 print_containing_files ()
9102 FILE_BUF *ip = NULL;
9106 /* If stack of files hasn't changed since we last printed
9107 this info, don't repeat it. */
9108 if (last_error_tick == input_file_stack_tick)
9111 for (i = indepth; i >= 0; i--)
9112 if (instack[i].fname != NULL) {
9117 /* Give up if we don't find a source file. */
9121 /* Find the other, outer source files. */
9122 for (i--; i >= 0; i--)
9123 if (instack[i].fname != NULL) {
9127 fprintf (stderr, "In file included");
9129 fprintf (stderr, ",\n ");
9132 fprintf (stderr, " from %s:%d", ip->nominal_fname, ip->lineno);
9135 fprintf (stderr, ":\n");
9137 /* Record we have printed the status as of this time. */
9138 last_error_tick = input_file_stack_tick;
9141 /* Return the line at which an error occurred.
9142 The error is not necessarily associated with the current spot
9143 in the input stack, so LINE says where. LINE will have been
9144 copied from ip->lineno for the current input level.
9145 If the current level is for a file, we return LINE.
9146 But if the current level is not for a file, LINE is meaningless.
9147 In that case, we return the lineno of the innermost file. */
9150 line_for_error (line)
9156 for (i = indepth; i >= 0; ) {
9157 if (instack[i].fname != 0)
9162 line1 = instack[i].lineno;
9170 * If OBUF doesn't have NEEDED bytes after OPTR, make it bigger.
9172 * As things stand, nothing is ever placed in the output buffer to be
9173 * removed again except when it's KNOWN to be part of an identifier,
9174 * so flushing and moving down everything left, instead of expanding,
9178 /* You might think void was cleaner for the return type,
9179 but that would get type mismatch in check_expand in strict ANSI. */
9181 grow_outbuf (obuf, needed)
9182 register FILE_BUF *obuf;
9183 register int needed;
9188 if (obuf->length - (obuf->bufp - obuf->buf) > needed)
9191 /* Make it at least twice as big as it is now. */
9193 /* Make it have at least 150% of the free space we will need. */
9194 minsize = (3 * needed) / 2 + (obuf->bufp - obuf->buf);
9195 if (minsize > obuf->length)
9196 obuf->length = minsize;
9198 if ((p = (U_CHAR *) xrealloc (obuf->buf, obuf->length)) == NULL)
9201 obuf->bufp = p + (obuf->bufp - obuf->buf);
9207 /* Symbol table for macro names and special symbols */
9210 * install a name in the main hash table, even if it is already there.
9211 * name stops with first non alphanumeric, except leading '#'.
9212 * caller must check against redefinition if that is desired.
9213 * delete_macro () removes things installed by install () in fifo order.
9214 * this is important because of the `defined' special symbol used
9215 * in #if, and also if pushdef/popdef directives are ever implemented.
9217 * If LEN is >= 0, it is the length of the name.
9218 * Otherwise, compute the length by scanning the entire name.
9220 * If HASH is >= 0, it is the precomputed hash code.
9221 * Otherwise, compute the hash code.
9224 install (name, len, type, value, hash)
9227 enum node_type type;
9231 register HASHNODE *hp;
9232 register int i, bucket;
9233 register U_CHAR *p, *q;
9237 while (is_idchar[*p])
9243 hash = hashf (name, len, HASHSIZE);
9245 i = sizeof (HASHNODE) + len + 1;
9246 hp = (HASHNODE *) xmalloc (i);
9248 hp->bucket_hdr = &hashtab[bucket];
9249 hp->next = hashtab[bucket];
9250 hashtab[bucket] = hp;
9252 if (hp->next != NULL)
9253 hp->next->prev = hp;
9256 hp->value.cpval = value;
9257 hp->name = ((U_CHAR *) hp) + sizeof (HASHNODE);
9260 for (i = 0; i < len; i++)
9267 * find the most recent hash node for name name (ending with first
9268 * non-identifier char) installed by install
9270 * If LEN is >= 0, it is the length of the name.
9271 * Otherwise, compute the length by scanning the entire name.
9273 * If HASH is >= 0, it is the precomputed hash code.
9274 * Otherwise, compute the hash code.
9277 lookup (name, len, hash)
9282 register U_CHAR *bp;
9283 register HASHNODE *bucket;
9286 for (bp = name; is_idchar[*bp]; bp++) ;
9291 hash = hashf (name, len, HASHSIZE);
9293 bucket = hashtab[hash];
9295 if (bucket->length == len && bcmp (bucket->name, name, len) == 0)
9297 bucket = bucket->next;
9303 * Delete a hash node. Some weirdness to free junk from macros.
9304 * More such weirdness will have to be added if you define more hash
9305 * types that need it.
9308 /* Note that the DEFINITION of a macro is removed from the hash table
9309 but its storage is not freed. This would be a storage leak
9310 except that it is not reasonable to keep undefining and redefining
9311 large numbers of macros many times.
9312 In any case, this is necessary, because a macro can be #undef'd
9313 in the middle of reading the arguments to a call to it.
9314 If #undef freed the DEFINITION, that would crash. */
9321 if (hp->prev != NULL)
9322 hp->prev->next = hp->next;
9323 if (hp->next != NULL)
9324 hp->next->prev = hp->prev;
9326 /* make sure that the bucket chain header that
9327 the deleted guy was on points to the right thing afterwards. */
9328 if (hp == *hp->bucket_hdr)
9329 *hp->bucket_hdr = hp->next;
9332 if (hp->type == T_MACRO) {
9333 DEFINITION *d = hp->value.defn;
9334 struct reflist *ap, *nextap;
9336 for (ap = d->pattern; ap != NULL; ap = nextap) {
9347 * return hash function on name. must be compatible with the one
9348 * computed a step at a time, elsewhere
9351 hashf (name, len, hashsize)
9352 register U_CHAR *name;
9359 r = HASHSTEP (r, *name++);
9361 return MAKE_POS (r) % hashsize;
9365 /* Dump the definition of a single macro HP to OF. */
9367 dump_single_macro (hp, of)
9368 register HASHNODE *hp;
9371 register DEFINITION *defn = hp->value.defn;
9377 /* Print the definition of the macro HP. */
9379 fprintf (of, "#define %s", hp->name);
9381 if (defn->nargs >= 0) {
9385 for (i = 0; i < defn->nargs; i++) {
9386 dump_arg_n (defn, i, of);
9387 if (i + 1 < defn->nargs)
9397 for (ap = defn->pattern; ap != NULL; ap = ap->next) {
9398 dump_defn_1 (defn->expansion, offset, ap->nchars, of);
9399 offset += ap->nchars;
9401 if (ap->nchars != 0)
9403 if (ap->stringify) {
9404 switch (ap->stringify) {
9405 case SHARP_TOKEN: fprintf (of, "#"); break;
9406 case WHITE_SHARP_TOKEN: fprintf (of, "# "); break;
9407 case PERCENT_COLON_TOKEN: fprintf (of, "%%:"); break;
9408 case WHITE_PERCENT_COLON_TOKEN: fprintf (of, "%%: "); break;
9412 if (ap->raw_before != 0) {
9414 switch (ap->raw_before) {
9415 case WHITE_SHARP_TOKEN:
9416 case WHITE_PERCENT_COLON_TOKEN:
9423 switch (ap->raw_before) {
9424 case SHARP_TOKEN: fprintf (of, "##"); break;
9425 case WHITE_SHARP_TOKEN: fprintf (of, "## "); break;
9426 case PERCENT_COLON_TOKEN: fprintf (of, "%%:%%:"); break;
9427 case WHITE_PERCENT_COLON_TOKEN: fprintf (of, "%%:%%: "); break;
9434 dump_arg_n (defn, ap->argno, of);
9435 if (!traditional && ap->raw_after != 0) {
9436 switch (ap->raw_after) {
9437 case SHARP_TOKEN: fprintf (of, "##"); break;
9438 case WHITE_SHARP_TOKEN: fprintf (of, " ##"); break;
9439 case PERCENT_COLON_TOKEN: fprintf (of, "%%:%%:"); break;
9440 case WHITE_PERCENT_COLON_TOKEN: fprintf (of, " %%:%%:"); break;
9446 dump_defn_1 (defn->expansion, offset, defn->length - offset, of);
9450 /* Dump all macro definitions as #defines to stdout. */
9457 for (bucket = 0; bucket < HASHSIZE; bucket++) {
9458 register HASHNODE *hp;
9460 for (hp = hashtab[bucket]; hp; hp= hp->next) {
9461 if (hp->type == T_MACRO)
9462 dump_single_macro (hp, stdout);
9467 /* Output to OF a substring of a macro definition.
9468 BASE is the beginning of the definition.
9469 Output characters START thru LENGTH.
9470 Unless traditional, discard newlines outside of strings, thus
9471 converting funny-space markers to ordinary spaces. */
9474 dump_defn_1 (base, start, length, of)
9480 U_CHAR *p = base + start;
9481 U_CHAR *limit = base + start + length;
9484 fwrite (p, sizeof (*p), length, of);
9487 if (*p == '\"' || *p =='\'') {
9488 U_CHAR *p1 = skip_quoted_string (p, limit, 0, NULL_PTR,
9489 NULL_PTR, NULL_PTR);
9490 fwrite (p, sizeof (*p), p1 - p, of);
9501 /* Print the name of argument number ARGNUM of macro definition DEFN
9503 Recall that DEFN->args.argnames contains all the arg names
9504 concatenated in reverse order with comma-space in between. */
9507 dump_arg_n (defn, argnum, of)
9512 register U_CHAR *p = defn->args.argnames;
9513 while (argnum + 1 < defn->nargs) {
9514 p = (U_CHAR *) index ((char *) p, ' ') + 1;
9518 while (*p && *p != ',') {
9524 /* Initialize syntactic classifications of characters. */
9527 initialize_char_syntax ()
9532 * Set up is_idchar and is_idstart tables. These should be
9533 * faster than saying (is_alpha (c) || c == '_'), etc.
9534 * Set up these things before calling any routines tthat
9537 for (i = 'a'; i <= 'z'; i++) {
9538 is_idchar[i - 'a' + 'A'] = 1;
9540 is_idstart[i - 'a' + 'A'] = 1;
9543 for (i = '0'; i <= '9'; i++)
9546 is_idstart['_'] = 1;
9547 is_idchar['$'] = dollars_in_ident;
9548 is_idstart['$'] = dollars_in_ident;
9550 /* horizontal space table */
9551 is_hor_space[' '] = 1;
9552 is_hor_space['\t'] = 1;
9553 is_hor_space['\v'] = 1;
9554 is_hor_space['\f'] = 1;
9555 is_hor_space['\r'] = 1;
9564 char_name['\v'] = "vertical tab";
9565 char_name['\f'] = "formfeed";
9566 char_name['\r'] = "carriage return";
9569 /* Initialize the built-in macros. */
9572 initialize_builtins (inp, outp)
9576 install ((U_CHAR *) "__LINE__", -1, T_SPECLINE, NULL_PTR, -1);
9577 install ((U_CHAR *) "__DATE__", -1, T_DATE, NULL_PTR, -1);
9578 install ((U_CHAR *) "__FILE__", -1, T_FILE, NULL_PTR, -1);
9579 install ((U_CHAR *) "__BASE_FILE__", -1, T_BASE_FILE, NULL_PTR, -1);
9580 install ((U_CHAR *) "__INCLUDE_LEVEL__", -1, T_INCLUDE_LEVEL, NULL_PTR, -1);
9581 install ((U_CHAR *) "__VERSION__", -1, T_VERSION, NULL_PTR, -1);
9582 #ifndef NO_BUILTIN_SIZE_TYPE
9583 install ((U_CHAR *) "__SIZE_TYPE__", -1, T_SIZE_TYPE, NULL_PTR, -1);
9585 #ifndef NO_BUILTIN_PTRDIFF_TYPE
9586 install ((U_CHAR *) "__PTRDIFF_TYPE__ ", -1, T_PTRDIFF_TYPE, NULL_PTR, -1);
9588 install ((U_CHAR *) "__WCHAR_TYPE__", -1, T_WCHAR_TYPE, NULL_PTR, -1);
9589 install ((U_CHAR *) "__USER_LABEL_PREFIX__", -1, T_USER_LABEL_PREFIX_TYPE,
9591 install ((U_CHAR *) "__REGISTER_PREFIX__", -1, T_REGISTER_PREFIX_TYPE,
9593 install ((U_CHAR *) "__IMMEDIATE_PREFIX__", -1, T_IMMEDIATE_PREFIX_TYPE,
9595 install ((U_CHAR *) "__TIME__", -1, T_TIME, NULL_PTR, -1);
9597 install ((U_CHAR *) "__STDC__", -1, T_CONST, "1", -1);
9598 install ((U_CHAR *) "__STDC_VERSION__", -1, T_CONST, "199409L", -1);
9601 install ((U_CHAR *) "__OBJC__", -1, T_CONST, "1", -1);
9602 /* This is supplied using a -D by the compiler driver
9603 so that it is present only when truly compiling with GNU C. */
9604 /* install ((U_CHAR *) "__GNUC__", -1, T_CONST, "2", -1); */
9608 char directive[2048];
9609 U_CHAR *udirective = (U_CHAR *) directive;
9610 register struct directive *dp = &directive_table[0];
9611 struct tm *timebuf = timestamp ();
9613 sprintf (directive, " __BASE_FILE__ \"%s\"\n",
9614 instack[0].nominal_fname);
9615 output_line_directive (inp, outp, 0, same_file);
9616 pass_thru_directive (udirective, &udirective[strlen (directive)],
9619 sprintf (directive, " __VERSION__ \"%s\"\n", version_string);
9620 output_line_directive (inp, outp, 0, same_file);
9621 pass_thru_directive (udirective, &udirective[strlen (directive)],
9624 #ifndef NO_BUILTIN_SIZE_TYPE
9625 sprintf (directive, " __SIZE_TYPE__ %s\n", SIZE_TYPE);
9626 output_line_directive (inp, outp, 0, same_file);
9627 pass_thru_directive (udirective, &udirective[strlen (directive)],
9631 #ifndef NO_BUILTIN_PTRDIFF_TYPE
9632 sprintf (directive, " __PTRDIFF_TYPE__ %s\n", PTRDIFF_TYPE);
9633 output_line_directive (inp, outp, 0, same_file);
9634 pass_thru_directive (udirective, &udirective[strlen (directive)],
9638 sprintf (directive, " __WCHAR_TYPE__ %s\n", wchar_type);
9639 output_line_directive (inp, outp, 0, same_file);
9640 pass_thru_directive (udirective, &udirective[strlen (directive)],
9643 sprintf (directive, " __DATE__ \"%s %2d %4d\"\n",
9644 monthnames[timebuf->tm_mon],
9645 timebuf->tm_mday, timebuf->tm_year + 1900);
9646 output_line_directive (inp, outp, 0, same_file);
9647 pass_thru_directive (udirective, &udirective[strlen (directive)],
9650 sprintf (directive, " __TIME__ \"%02d:%02d:%02d\"\n",
9651 timebuf->tm_hour, timebuf->tm_min, timebuf->tm_sec);
9652 output_line_directive (inp, outp, 0, same_file);
9653 pass_thru_directive (udirective, &udirective[strlen (directive)],
9658 sprintf (directive, " __STDC__ 1");
9659 output_line_directive (inp, outp, 0, same_file);
9660 pass_thru_directive (udirective, &udirective[strlen (directive)],
9665 sprintf (directive, " __OBJC__ 1");
9666 output_line_directive (inp, outp, 0, same_file);
9667 pass_thru_directive (udirective, &udirective[strlen (directive)],
9674 * process a given definition string, for initialization
9675 * If STR is just an identifier, define it with value 1.
9676 * If STR has anything after the identifier, then it should
9677 * be identifier=definition.
9681 make_definition (str, op)
9686 struct directive *kt;
9689 p = buf = (U_CHAR *) str;
9690 if (!is_idstart[*p]) {
9691 error ("malformed option `-D %s'", str);
9694 while (is_idchar[*++p])
9697 while (is_idchar[*++p] || *p == ',' || is_hor_space[*p])
9700 p = (U_CHAR *) str; /* Error */
9703 buf = (U_CHAR *) alloca (p - buf + 4);
9704 strcpy ((char *)buf, str);
9705 strcat ((char *)buf, " 1");
9706 } else if (*p != '=') {
9707 error ("malformed option `-D %s'", str);
9711 /* Copy the entire option so we can modify it. */
9712 buf = (U_CHAR *) alloca (2 * strlen (str) + 1);
9713 strncpy ((char *) buf, str, p - (U_CHAR *) str);
9714 /* Change the = to a space. */
9715 buf[p - (U_CHAR *) str] = ' ';
9716 /* Scan for any backslash-newline and remove it. */
9718 q = &buf[p - (U_CHAR *) str];
9720 if (*p == '\"' || *p == '\'') {
9721 int unterminated = 0;
9722 U_CHAR *p1 = skip_quoted_string (p, p + strlen ((char *) p), 0,
9723 NULL_PTR, NULL_PTR, &unterminated);
9727 if (*p == '\\' && p[1] == '\n')
9731 } else if (*p == '\\' && p[1] == '\n')
9733 /* Change newline chars into newline-markers. */
9734 else if (*p == '\n')
9746 ip = &instack[++indepth];
9747 ip->nominal_fname = ip->fname = "*Initialization*";
9749 ip->buf = ip->bufp = buf;
9750 ip->length = strlen ((char *) buf);
9754 ip->if_stack = if_stack;
9755 ip->system_header_p = 0;
9757 for (kt = directive_table; kt->type != T_DEFINE; kt++)
9760 /* Pass NULL instead of OP, since this is a "predefined" macro. */
9761 do_define (buf, buf + strlen ((char *) buf), NULL_PTR, kt);
9765 /* JF, this does the work for the -U option */
9768 make_undef (str, op)
9773 struct directive *kt;
9775 ip = &instack[++indepth];
9776 ip->nominal_fname = ip->fname = "*undef*";
9778 ip->buf = ip->bufp = (U_CHAR *) str;
9779 ip->length = strlen (str);
9783 ip->if_stack = if_stack;
9784 ip->system_header_p = 0;
9786 for (kt = directive_table; kt->type != T_UNDEF; kt++)
9789 do_undef ((U_CHAR *) str, (U_CHAR *) str + strlen (str), op, kt);
9793 /* Process the string STR as if it appeared as the body of a #assert.
9794 OPTION is the option name for which STR was the argument. */
9797 make_assertion (option, str)
9802 struct directive *kt;
9803 U_CHAR *buf, *p, *q;
9805 /* Copy the entire option so we can modify it. */
9806 buf = (U_CHAR *) alloca (strlen (str) + 1);
9807 strcpy ((char *) buf, str);
9808 /* Scan for any backslash-newline and remove it. */
9811 if (*p == '\\' && p[1] == '\n')
9819 if (!is_idstart[*p]) {
9820 error ("malformed option `%s %s'", option, str);
9823 while (is_idchar[*++p])
9825 SKIP_WHITE_SPACE (p);
9826 if (! (*p == 0 || *p == '(')) {
9827 error ("malformed option `%s %s'", option, str);
9831 ip = &instack[++indepth];
9832 ip->nominal_fname = ip->fname = "*Initialization*";
9834 ip->buf = ip->bufp = buf;
9835 ip->length = strlen ((char *) buf);
9839 ip->if_stack = if_stack;
9840 ip->system_header_p = 0;
9842 for (kt = directive_table; kt->type != T_ASSERT; kt++)
9845 /* pass NULL as output ptr to do_define since we KNOW it never
9846 does any output.... */
9847 do_assert (buf, buf + strlen ((char *) buf) , NULL_PTR, kt);
9851 /* Append a chain of `struct file_name_list's
9852 to the end of the main include chain.
9853 FIRST is the beginning of the chain to append, and LAST is the end. */
9856 append_include_chain (first, last)
9857 struct file_name_list *first, *last;
9859 struct file_name_list *dir;
9861 if (!first || !last)
9867 last_include->next = first;
9869 if (first_bracket_include == 0)
9870 first_bracket_include = first;
9872 for (dir = first; ; dir = dir->next) {
9873 int len = strlen (dir->fname) + INCLUDE_LEN_FUDGE;
9874 if (len > max_include_len)
9875 max_include_len = len;
9881 last_include = last;
9884 /* Add output to `deps_buffer' for the -M switch.
9885 STRING points to the text to be output.
9886 SPACER is ':' for targets, ' ' for dependencies. */
9889 deps_output (string, spacer)
9893 int size = strlen (string);
9898 #ifndef MAX_OUTPUT_COLUMNS
9899 #define MAX_OUTPUT_COLUMNS 72
9901 if (MAX_OUTPUT_COLUMNS - 1 /*spacer*/ - 2 /*` \'*/ < deps_column + size
9902 && 1 < deps_column) {
9903 bcopy (" \\\n ", &deps_buffer[deps_size], 4);
9910 if (deps_size + size + 8 > deps_allocated_size) {
9911 deps_allocated_size = (deps_size + size + 50) * 2;
9912 deps_buffer = xrealloc (deps_buffer, deps_allocated_size);
9914 if (spacer == ' ') {
9915 deps_buffer[deps_size++] = ' ';
9918 bcopy (string, &deps_buffer[deps_size], size);
9920 deps_column += size;
9921 if (spacer == ':') {
9922 deps_buffer[deps_size++] = ':';
9925 deps_buffer[deps_size] = 0;
9929 fatal (PRINTF_ALIST (msg))
9934 fprintf (stderr, "%s: ", progname);
9935 VA_START (args, msg);
9936 vfprintf (stderr, msg, args);
9938 fprintf (stderr, "\n");
9939 exit (FAILURE_EXIT_CODE);
9942 /* More 'friendly' abort that prints the line and file.
9943 config.h can #define abort fancy_abort if you like that sort of thing. */
9948 fatal ("Internal gcc abort.");
9952 perror_with_name (name)
9955 fprintf (stderr, "%s: ", progname);
9956 fprintf (stderr, "%s: %s\n", name, my_strerror (errno));
9961 pfatal_with_name (name)
9964 perror_with_name (name);
9968 exit (FAILURE_EXIT_CODE);
9972 /* Handler for SIGPIPE. */
9976 /* If this is missing, some compilers complain. */
9979 fatal ("output pipe has been closed");
9985 fatal ("Memory exhausted.");
9993 register GENERIC_PTR ptr = (GENERIC_PTR) malloc (size);
10000 xrealloc (old, size)
10004 register GENERIC_PTR ptr = (GENERIC_PTR) realloc (old, size);
10011 xcalloc (number, size)
10012 size_t number, size;
10014 register size_t total = number * size;
10015 register GENERIC_PTR ptr = (GENERIC_PTR) malloc (total);
10018 bzero (ptr, total);
10026 size_t size = strlen (input);
10027 char *output = xmalloc (size + 1);
10028 strcpy (output, input);
10032 /* Get the file-mode and data size of the file open on FD
10033 and store them in *MODE_POINTER and *SIZE_POINTER. */
10036 file_size_and_mode (fd, mode_pointer, size_pointer)
10039 long int *size_pointer;
10043 if (fstat (fd, &sbuf) < 0) return (-1);
10044 if (mode_pointer) *mode_pointer = sbuf.st_mode;
10045 if (size_pointer) *size_pointer = sbuf.st_size;
10050 output_dots (fd, depth)
10054 while (depth > 0) {
10063 /* Under VMS we need to fix up the "include" specification
10064 filename so that everything following the 1st slash is
10065 changed into its correct VMS file specification. */
10068 hack_vms_include_specification (fname)
10071 register char *cp, *cp1, *cp2;
10072 int f, check_filename_before_returning, no_prefix_seen;
10075 check_filename_before_returning = 0;
10076 no_prefix_seen = 0;
10078 /* Ignore leading "./"s */
10079 while (fname[0] == '.' && fname[1] == '/') {
10080 strcpy (fname, fname+2);
10081 no_prefix_seen = 1; /* mark this for later */
10083 /* Look for the boundary between the VMS and UNIX filespecs */
10084 cp = rindex (fname, ']'); /* Look for end of dirspec. */
10085 if (cp == 0) cp = rindex (fname, '>'); /* ... Ditto */
10086 if (cp == 0) cp = rindex (fname, ':'); /* Look for end of devspec. */
10090 cp = index (fname, '/'); /* Look for the "/" */
10094 * Check if we have a vax-c style '#include filename'
10095 * and add the missing .h
10098 if (index(fname,'.') == 0)
10099 strcat(fname, ".h");
10101 if (index(cp,'.') == 0)
10105 cp2 = Local; /* initialize */
10107 /* We are trying to do a number of things here. First of all, we are
10108 trying to hammer the filenames into a standard format, such that later
10109 processing can handle them.
10111 If the file name contains something like [dir.], then it recognizes this
10112 as a root, and strips the ".]". Later processing will add whatever is
10113 needed to get things working properly.
10115 If no device is specified, then the first directory name is taken to be
10116 a device name (or a rooted logical). */
10118 /* See if we found that 1st slash */
10119 if (cp == 0) return; /* Nothing to do!!! */
10120 if (*cp != '/') return; /* Nothing to do!!! */
10121 /* Point to the UNIX filename part (which needs to be fixed!) */
10123 /* If the directory spec is not rooted, we can just copy
10124 the UNIX filename part and we are done */
10125 if (((cp - fname) > 1) && ((cp[-1] == ']') || (cp[-1] == '>'))) {
10126 if (cp[-2] != '.') {
10128 * The VMS part ends in a `]', and the preceding character is not a `.'.
10129 * We strip the `]', and then splice the two parts of the name in the
10130 * usual way. Given the default locations for include files in cccp.c,
10131 * we will only use this code if the user specifies alternate locations
10132 * with the /include (-I) switch on the command line. */
10133 cp -= 1; /* Strip "]" */
10134 cp1--; /* backspace */
10137 * The VMS part has a ".]" at the end, and this will not do. Later
10138 * processing will add a second directory spec, and this would be a syntax
10139 * error. Thus we strip the ".]", and thus merge the directory specs.
10140 * We also backspace cp1, so that it points to a '/'. This inhibits the
10141 * generation of the 000000 root directory spec (which does not belong here
10144 cp -= 2; /* Strip ".]" */
10145 cp1--; }; /* backspace */
10148 /* We drop in here if there is no VMS style directory specification yet.
10149 * If there is no device specification either, we make the first dir a
10150 * device and try that. If we do not do this, then we will be essentially
10151 * searching the users default directory (as if they did a #include "asdf.h").
10153 * Then all we need to do is to push a '[' into the output string. Later
10154 * processing will fill this in, and close the bracket.
10156 if (cp[-1] != ':') *cp2++ = ':'; /* dev not in spec. take first dir */
10157 *cp2++ = '['; /* Open the directory specification */
10160 /* at this point we assume that we have the device spec, and (at least
10161 the opening "[" for a directory specification. We may have directories
10162 specified already */
10164 /* If there are no other slashes then the filename will be
10165 in the "root" directory. Otherwise, we need to add
10166 directory specifications. */
10167 if (index (cp1, '/') == 0) {
10168 /* Just add "000000]" as the directory string */
10169 strcpy (cp2, "000000]");
10170 cp2 += strlen (cp2);
10171 check_filename_before_returning = 1; /* we might need to fool with this later */
10173 /* As long as there are still subdirectories to add, do them. */
10174 while (index (cp1, '/') != 0) {
10175 /* If this token is "." we can ignore it */
10176 if ((cp1[0] == '.') && (cp1[1] == '/')) {
10180 /* Add a subdirectory spec. Do not duplicate "." */
10181 if (cp2[-1] != '.' && cp2[-1] != '[' && cp2[-1] != '<')
10183 /* If this is ".." then the spec becomes "-" */
10184 if ((cp1[0] == '.') && (cp1[1] == '.') && (cp[2] == '/')) {
10185 /* Add "-" and skip the ".." */
10190 /* Copy the subdirectory */
10191 while (*cp1 != '/') *cp2++= *cp1++;
10192 cp1++; /* Skip the "/" */
10194 /* Close the directory specification */
10195 if (cp2[-1] == '.') /* no trailing periods */
10199 /* Now add the filename */
10200 while (*cp1) *cp2++ = *cp1++;
10202 /* Now append it to the original VMS spec. */
10203 strcpy (cp, Local);
10205 /* If we put a [000000] in the filename, try to open it first. If this fails,
10206 remove the [000000], and return that name. This provides flexibility
10207 to the user in that they can use both rooted and non-rooted logical names
10208 to point to the location of the file. */
10210 if (check_filename_before_returning && no_prefix_seen) {
10211 f = open (fname, O_RDONLY, 0666);
10213 /* The file name is OK as it is, so return it as is. */
10217 /* The filename did not work. Try to remove the [000000] from the name,
10219 cp = index (fname, '[');
10220 cp2 = index (fname, ']') + 1;
10221 strcpy (cp, cp2); /* this gets rid of it */
10229 /* These are the read/write replacement routines for
10230 VAX-11 "C". They make read/write behave enough
10231 like their UNIX counterparts that CCCP will work */
10234 read (fd, buf, size)
10239 #undef read /* Get back the REAL read routine */
10241 register int total = 0;
10243 /* Read until the buffer is exhausted */
10245 /* Limit each read to 32KB */
10246 i = (size > (32*1024)) ? (32*1024) : size;
10247 i = read (fd, buf, i);
10249 if (i == 0) return (total);
10252 /* Account for this read */
10261 write (fd, buf, size)
10266 #undef write /* Get back the REAL write routine */
10270 /* Limit individual writes to 32Kb */
10273 j = (i > (32*1024)) ? (32*1024) : i;
10274 if (write (fd, buf, j) < 0) return (-1);
10275 /* Account for the data written */
10282 /* The following wrapper functions supply additional arguments to the VMS
10283 I/O routines to optimize performance with file handling. The arguments
10285 "mbc=16" - Set multi-block count to 16 (use a 8192 byte buffer).
10286 "deq=64" - When extending the file, extend it in chunks of 32Kbytes.
10287 "fop=tef"- Truncate unused portions of file when closing file.
10288 "shr=nil"- Disallow file sharing while file is open.
10292 freopen (fname, type, oldfile)
10297 #undef freopen /* Get back the REAL fopen routine */
10298 if (strcmp (type, "w") == 0)
10299 return freopen (fname, type, oldfile, "mbc=16", "deq=64", "fop=tef", "shr=nil");
10300 return freopen (fname, type, oldfile, "mbc=16");
10304 fopen (fname, type)
10308 #undef fopen /* Get back the REAL fopen routine */
10309 /* The gcc-vms-1.42 distribution's header files prototype fopen with two
10310 fixed arguments, which matches ANSI's specification but not VAXCRTL's
10311 pre-ANSI implementation. This hack circumvents the mismatch problem. */
10312 FILE *(*vmslib_fopen)() = (FILE *(*)()) fopen;
10315 return (*vmslib_fopen) (fname, type, "mbc=32",
10316 "deq=64", "fop=tef", "shr=nil");
10318 return (*vmslib_fopen) (fname, type, "mbc=32");
10322 open (fname, flags, prot)
10327 #undef open /* Get back the REAL open routine */
10328 return open (fname, flags, prot, "mbc=16", "deq=64", "fop=tef");
10331 /* Avoid run-time library bug, where copying M out of N+M characters with
10332 N >= 65535 results in VAXCRTL's strncat falling into an infinite loop.
10333 gcc-cpp exercises this particular bug. [Fixed in V5.5-2's VAXCRTL.] */
10336 strncat (dst, src, cnt)
10341 register char *d = dst, *s = (char *) src;
10342 register int n = cnt; /* convert to _signed_ type */
10344 while (*d) d++; /* advance to end */
10346 if (!(*d++ = *s++)) break;
10347 if (n < 0) *d = '\0';
10351 /* more VMS hackery */
10355 extern unsigned long sys$parse(), sys$search();
10357 /* Work around another library bug. If a file is located via a searchlist,
10358 and if the device it's on is not the same device as the one specified
10359 in the first element of that searchlist, then both stat() and fstat()
10360 will fail to return info about it. `errno' will be set to EVMSERR, and
10361 `vaxc$errno' will be set to SS$_NORMAL due yet another bug in stat()!
10362 We can get around this by fully parsing the filename and then passing
10363 that absolute name to stat().
10365 Without this fix, we can end up failing to find header files, which is
10366 bad enough, but then compounding the problem by reporting the reason for
10367 failure as "normal successful completion." */
10369 #undef fstat /* get back to library version */
10372 VMS_fstat (fd, statbuf)
10374 struct stat *statbuf;
10376 int result = fstat (fd, statbuf);
10381 char nambuf[NAM$C_MAXRSS+1];
10383 if ((fp = fdopen (fd, "r")) != 0 && fgetname (fp, nambuf) != 0)
10384 result = VMS_stat (nambuf, statbuf);
10385 /* No fclose(fp) here; that would close(fd) as well. */
10392 VMS_stat (name, statbuf)
10394 struct stat *statbuf;
10396 int result = stat (name, statbuf);
10402 char exp_nam[NAM$C_MAXRSS+1], /* expanded name buffer for sys$parse */
10403 res_nam[NAM$C_MAXRSS+1]; /* resultant name buffer for sys$search */
10406 fab.fab$l_fna = (char *) name;
10407 fab.fab$b_fns = (unsigned char) strlen (name);
10408 fab.fab$l_nam = (void *) &nam;
10410 nam.nam$l_esa = exp_nam, nam.nam$b_ess = sizeof exp_nam - 1;
10411 nam.nam$l_rsa = res_nam, nam.nam$b_rss = sizeof res_nam - 1;
10412 nam.nam$b_nop = NAM$M_PWD | NAM$M_NOCONCEAL;
10413 if (sys$parse (&fab) & 1)
10415 if (sys$search (&fab) & 1)
10417 res_nam[nam.nam$b_rsl] = '\0';
10418 result = stat (res_nam, statbuf);
10420 /* Clean up searchlist context cached by the system. */
10421 nam.nam$b_nop = NAM$M_SYNCHK;
10422 fab.fab$l_fna = 0, fab.fab$b_fns = 0;
10423 (void) sys$parse (&fab);
OSDN Git Service
