1 /* C Compatible Compiler Preprocessor (CCCP)
2 Copyright (C) 1986, 87, 89, 92-95, 1996 Free Software Foundation, Inc.
3 Written by Paul Rubin, June 1986
4 Adapted to ANSI C, Richard Stallman, Jan 1987
6 This program is free software; you can redistribute it and/or modify it
7 under the terms of the GNU General Public License as published by the
8 Free Software Foundation; either version 2, or (at your option) any
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with this program; if not, write to the Free Software
18 Foundation, 59 Temple Place - Suite 330,
19 Boston, MA 02111-1307, USA.
21 In other words, you are welcome to use, share and improve this program.
22 You are forbidden to forbid anyone else to use, share and improve
23 what you give them. Help stamp out software-hoarding! */
25 typedef unsigned char U_CHAR;
29 #include "../src/config.h"
37 /* The macro EMACS is defined when cpp is distributed as part of Emacs,
38 for the sake of machines with limited C compilers. */
41 #endif /* not EMACS */
43 #ifndef STANDARD_INCLUDE_DIR
44 #define STANDARD_INCLUDE_DIR "/usr/include"
47 #ifndef LOCAL_INCLUDE_DIR
48 #define LOCAL_INCLUDE_DIR "/usr/local/include"
53 /* By default, colon separates directories in a path. */
54 #ifndef PATH_SEPARATOR
55 #define PATH_SEPARATOR ':'
58 #include <sys/types.h>
64 /* The following symbols should be autoconfigured:
71 In the mean time, we'll get by with approximations based
72 on existing GCC configuration symbols. */
75 # ifndef HAVE_STDLIB_H
76 # define HAVE_STDLIB_H 1
78 # ifndef HAVE_UNISTD_H
79 # define HAVE_UNISTD_H 1
82 # define STDC_HEADERS 1
84 #endif /* defined (POSIX) */
86 #if defined (POSIX) || (defined (USG) && !defined (VMS))
88 # define HAVE_FCNTL_H 1
95 # if TIME_WITH_SYS_TIME
96 # include <sys/time.h>
100 # include <sys/time.h>
105 # include <sys/resource.h>
123 # define bcmp(a, b, n) memcmp (a, b, n)
126 # define bcopy(s, d, n) memcpy (d, s, n)
129 # define bzero(d, n) memset (d, 0, n)
131 #else /* !STDC_HEADERS */
135 # if !defined (BSTRING) && (defined (USG) || defined (VMS))
138 # define bcmp my_bcmp
151 # endif /* !defined (bcmp) */
154 # define bcopy my_bcopy
164 # endif /* !defined (bcopy) */
167 # define bzero my_bzero
171 register unsigned length;
176 # endif /* !defined (bzero) */
178 # endif /* !defined (BSTRING) && (defined (USG) || defined (VMS)) */
179 #endif /* ! STDC_HEADERS */
181 #if __GNUC__ < 2 || (__GNUC__ == 2 && __GNUC_MINOR__ < 6)
182 # define __attribute__(x)
186 # if defined (USE_PROTOTYPES) ? USE_PROTOTYPES : defined (__STDC__)
187 # define PROTO(ARGS) ARGS
189 # define PROTO(ARGS) ()
193 #if defined (__STDC__) && defined (HAVE_VPRINTF)
195 # define VA_START(va_list, var) va_start (va_list, var)
196 # define PRINTF_ALIST(msg) char *msg, ...
197 # define PRINTF_DCL(msg)
198 # define PRINTF_PROTO(ARGS, m, n) PROTO (ARGS) __attribute__ ((format (printf, m, n)))
200 # include <varargs.h>
201 # define VA_START(va_list, var) va_start (va_list)
202 # define PRINTF_ALIST(msg) msg, va_alist
203 # define PRINTF_DCL(msg) char *msg; va_dcl
204 # define PRINTF_PROTO(ARGS, m, n) () __attribute__ ((format (printf, m, n)))
205 # define vfprintf(file, msg, args) \
207 char *a0 = va_arg(args, char *); \
208 char *a1 = va_arg(args, char *); \
209 char *a2 = va_arg(args, char *); \
210 char *a3 = va_arg(args, char *); \
211 fprintf (file, msg, a0, a1, a2, a3); \
215 #define PRINTF_PROTO_1(ARGS) PRINTF_PROTO(ARGS, 1, 2)
216 #define PRINTF_PROTO_2(ARGS) PRINTF_PROTO(ARGS, 2, 3)
217 #define PRINTF_PROTO_3(ARGS) PRINTF_PROTO(ARGS, 3, 4)
223 /* VMS-specific definitions */
226 #define O_RDONLY 0 /* Open arg for Read/Only */
227 #define O_WRONLY 1 /* Open arg for Write/Only */
228 #define read(fd,buf,size) VMS_read (fd,buf,size)
229 #define write(fd,buf,size) VMS_write (fd,buf,size)
230 #define open(fname,mode,prot) VMS_open (fname,mode,prot)
231 #define fopen(fname,mode) VMS_fopen (fname,mode)
232 #define freopen(fname,mode,ofile) VMS_freopen (fname,mode,ofile)
233 #define fstat(fd,stbuf) VMS_fstat (fd,stbuf)
234 static int VMS_fstat (), VMS_stat ();
235 static int VMS_read ();
236 static int VMS_write ();
237 static int VMS_open ();
238 static FILE * VMS_fopen ();
239 static FILE * VMS_freopen ();
240 static void hack_vms_include_specification ();
241 #define INO_T_EQ(a, b) (!bcmp((char *) &(a), (char *) &(b), sizeof (a)))
242 #define INO_T_HASH(a) 0
243 #define INCLUDE_LEN_FUDGE 12 /* leave room for VMS syntax conversion */
245 #define BSTRING /* VMS/GCC supplies the bstring routines */
246 #endif /* __GNUC__ */
255 #define MIN(X,Y) ((X) < (Y) ? (X) : (Y))
256 #define MAX(X,Y) ((X) > (Y) ? (X) : (Y))
258 /* Find the largest host integer type and set its size and type.
259 Don't blindly use `long'; on some crazy hosts it is shorter than `int'. */
261 #ifndef HOST_BITS_PER_WIDE_INT
263 #if HOST_BITS_PER_LONG > HOST_BITS_PER_INT
264 #define HOST_BITS_PER_WIDE_INT HOST_BITS_PER_LONG
265 #define HOST_WIDE_INT long
267 #define HOST_BITS_PER_WIDE_INT HOST_BITS_PER_INT
268 #define HOST_WIDE_INT int
274 #define S_ISREG(m) (((m) & S_IFMT) == S_IFREG)
278 #define S_ISDIR(m) (((m) & S_IFMT) == S_IFDIR)
282 #define INO_T_EQ(a, b) ((a) == (b))
286 #define INO_T_HASH(a) (a)
289 /* Define a generic NULL if one hasn't already been defined. */
296 #if defined (USE_PROTOTYPES) ? USE_PROTOTYPES : defined (__STDC__)
297 #define GENERIC_PTR void *
299 #define GENERIC_PTR char *
304 #define NULL_PTR ((GENERIC_PTR)0)
307 #ifndef INCLUDE_LEN_FUDGE
308 #define INCLUDE_LEN_FUDGE 0
311 /* External declarations. */
313 extern char *version_string;
315 #ifndef HAVE_STRERROR
318 extern const char *const sys_errlist[];
320 extern char *sys_errlist[];
322 #else /* HAVE_STRERROR */
326 char *strerror (int,...);
328 HOST_WIDE_INT parse_escape PROTO((char **, HOST_WIDE_INT));
329 HOST_WIDE_INT parse_c_expression PROTO((char *));
335 /* Name under which this program was invoked. */
337 static char *progname;
339 /* Nonzero means use extra default include directories for C++. */
341 static int cplusplus;
343 /* Nonzero means handle cplusplus style comments */
345 static int cplusplus_comments;
347 /* Nonzero means handle #import, for objective C. */
351 /* Nonzero means this is an assembly file, and allow
352 unknown directives, which could be comments. */
356 /* Current maximum length of directory names in the search path
357 for include files. (Altered as we get more of them.) */
359 static int max_include_len;
361 /* Nonzero means turn NOTREACHED into #pragma NOTREACHED etc */
363 static int for_lint = 0;
365 /* Nonzero means copy comments into the output file. */
367 static int put_out_comments = 0;
369 /* Nonzero means don't process the ANSI trigraph sequences. */
371 static int no_trigraphs = 0;
373 /* Nonzero means print the names of included files rather than
374 the preprocessed output. 1 means just the #include "...",
375 2 means #include <...> as well. */
377 static int print_deps = 0;
379 /* Nonzero if missing .h files in -M output are assumed to be generated
380 files and not errors. */
382 static int print_deps_missing_files = 0;
384 /* Nonzero means print names of header files (-H). */
386 static int print_include_names = 0;
388 /* Nonzero means don't output line number information. */
390 static int no_line_directives;
392 /* Nonzero means output the text in failing conditionals,
393 inside #failed ... #endfailed. */
395 static int output_conditionals;
397 /* dump_only means inhibit output of the preprocessed text
398 and instead output the definitions of all user-defined
399 macros in a form suitable for use as input to cccp.
400 dump_names means pass #define and the macro name through to output.
401 dump_definitions means pass the whole definition (plus #define) through
404 static enum {dump_none, dump_only, dump_names, dump_definitions}
405 dump_macros = dump_none;
407 /* Nonzero means pass all #define and #undef directives which we actually
408 process through to the output stream. This feature is used primarily
409 to allow cc1 to record the #defines and #undefs for the sake of
410 debuggers which understand about preprocessor macros, but it may
411 also be useful with -E to figure out how symbols are defined, and
412 where they are defined. */
413 static int debug_output = 0;
415 /* Nonzero indicates special processing used by the pcp program. The
416 special effects of this mode are:
418 Inhibit all macro expansion, except those inside #if directives.
420 Process #define directives normally, and output their contents
423 Output preconditions to pcp_outfile indicating all the relevant
424 preconditions for use of this file in a later cpp run.
426 static FILE *pcp_outfile;
428 /* Nonzero means we are inside an IF during a -pcp run. In this mode
429 macro expansion is done, and preconditions are output for all macro
430 uses requiring them. */
431 static int pcp_inside_if;
433 /* Nonzero means never to include precompiled files.
434 This is 1 since there's no way now to make precompiled files,
435 so it's not worth testing for them. */
436 static int no_precomp = 1;
438 /* Nonzero means give all the error messages the ANSI standard requires. */
442 /* Nonzero means try to make failure to fit ANSI C an error. */
444 static int pedantic_errors;
446 /* Nonzero means don't print warning messages. -w. */
448 static int inhibit_warnings = 0;
450 /* Nonzero means warn if slash-star appears in a slash-star comment,
451 or if newline-backslash appears in a slash-slash comment. */
453 static int warn_comments;
455 /* Nonzero means warn if a macro argument is (or would be)
456 stringified with -traditional. */
458 static int warn_stringify;
460 /* Nonzero means warn if there are any trigraphs. */
462 static int warn_trigraphs;
464 /* Nonzero means warn if #import is used. */
466 static int warn_import = 1;
468 /* Nonzero means turn warnings into errors. */
470 static int warnings_are_errors;
472 /* Nonzero means try to imitate old fashioned non-ANSI preprocessor. */
476 /* Nonzero causes output not to be done,
477 but directives such as #define that have side effects
480 static int no_output;
482 /* Nonzero means this file was included with a -imacros or -include
483 command line and should not be recorded as an include file. */
485 static int no_record_file;
487 /* Nonzero means that we have finished processing the command line options.
488 This flag is used to decide whether or not to issue certain errors
491 static int done_initializing = 0;
493 /* Line where a newline was first seen in a string constant. */
495 static int multiline_string_line = 0;
497 /* I/O buffer structure.
498 The `fname' field is nonzero for source files and #include files
499 and for the dummy text used for -D and -U.
500 It is zero for rescanning results of macro expansion
501 and for expanding macro arguments. */
502 #define INPUT_STACK_MAX 400
503 static struct file_buf {
505 /* Filename specified with #line directive. */
507 /* Include file description. */
508 struct include_file *inc;
509 /* Record where in the search path this file was found.
510 For #include_next. */
511 struct file_name_list *dir;
516 /* Macro that this level is the expansion of.
517 Included so that we can reenable the macro
518 at the end of this level. */
519 struct hashnode *macro;
520 /* Value of if_stack at start of this file.
521 Used to prohibit unmatched #endif (etc) in an include file. */
522 struct if_stack *if_stack;
523 /* Object to be freed at end of input at this level. */
525 /* True if this is a header file included using <FILENAME>. */
526 char system_header_p;
527 } instack[INPUT_STACK_MAX];
529 static int last_error_tick; /* Incremented each time we print it. */
530 static int input_file_stack_tick; /* Incremented when the status changes. */
532 /* Current nesting level of input sources.
533 `instack[indepth]' is the level currently being read. */
534 static int indepth = -1;
535 #define CHECK_DEPTH(code) \
536 if (indepth >= (INPUT_STACK_MAX - 1)) \
538 error_with_line (line_for_error (instack[indepth].lineno), \
539 "macro or `#include' recursion too deep"); \
543 /* Current depth in #include directives that use <...>. */
544 static int system_include_depth = 0;
546 typedef struct file_buf FILE_BUF;
548 /* The output buffer. Its LENGTH field is the amount of room allocated
549 for the buffer, not the number of chars actually present. To get
550 that, subtract outbuf.buf from outbuf.bufp. */
552 #define OUTBUF_SIZE 10 /* initial size of output buffer */
553 static FILE_BUF outbuf;
555 /* Grow output buffer OBUF points at
556 so it can hold at least NEEDED more chars. */
558 #define check_expand(OBUF, NEEDED) \
559 (((OBUF)->length - ((OBUF)->bufp - (OBUF)->buf) <= (NEEDED)) \
560 ? grow_outbuf ((OBUF), (NEEDED)) : 0)
562 struct file_name_list
564 struct file_name_list *next;
565 /* If the following is 1, it is a C-language system include
567 int c_system_include_path;
568 /* Mapping of file names for this directory. */
569 struct file_name_map *name_map;
570 /* Non-zero if name_map is valid. */
572 /* The include directory status. */
574 /* The include prefix: "" denotes the working directory,
575 otherwise fname must end in '/'.
576 The actual size is dynamically allocated. */
580 /* #include "file" looks in source file dir, then stack. */
581 /* #include <file> just looks in the stack. */
582 /* -I directories are added to the end, then the defaults are added. */
584 static struct default_include {
585 char *fname; /* The name of the directory. */
586 int cplusplus; /* Only look here if we're compiling C++. */
587 int cxx_aware; /* Includes in this directory don't need to
588 be wrapped in extern "C" when compiling
590 } include_defaults_array[]
591 #ifdef INCLUDE_DEFAULTS
595 /* Pick up GNU C++ specific include files. */
596 { GPLUSPLUS_INCLUDE_DIR, 1, 1 },
597 { OLD_GPLUSPLUS_INCLUDE_DIR, 1, 1 },
599 /* This is the dir for fixincludes. Put it just before
600 the files that we fix. */
601 { GCC_INCLUDE_DIR, 0, 0 },
602 /* For cross-compilation, this dir name is generated
603 automatically in Makefile.in. */
604 { CROSS_INCLUDE_DIR, 0, 0 },
605 /* This is another place that the target system's headers might be. */
606 { TOOL_INCLUDE_DIR, 0, 0 },
607 #else /* not CROSS_COMPILE */
608 /* This should be /usr/local/include and should come before
609 the fixincludes-fixed header files. */
610 { LOCAL_INCLUDE_DIR, 0, 1 },
611 /* This is here ahead of GCC_INCLUDE_DIR because assert.h goes here.
612 Likewise, behind LOCAL_INCLUDE_DIR, where glibc puts its assert.h. */
613 { TOOL_INCLUDE_DIR, 0, 0 },
614 /* This is the dir for fixincludes. Put it just before
615 the files that we fix. */
616 { GCC_INCLUDE_DIR, 0, 0 },
617 /* Some systems have an extra dir of include files. */
618 #ifdef SYSTEM_INCLUDE_DIR
619 { SYSTEM_INCLUDE_DIR, 0, 0 },
621 { STANDARD_INCLUDE_DIR, 0, 0 },
622 #endif /* not CROSS_COMPILE */
625 #endif /* no INCLUDE_DEFAULTS */
627 /* The code looks at the defaults through this pointer, rather than through
628 the constant structure above. This pointer gets changed if an environment
629 variable specifies other defaults. */
630 static struct default_include *include_defaults = include_defaults_array;
632 static struct file_name_list *include = 0; /* First dir to search */
633 /* First dir to search for <file> */
634 /* This is the first element to use for #include <...>.
635 If it is 0, use the entire chain for such includes. */
636 static struct file_name_list *first_bracket_include = 0;
637 /* This is the first element in the chain that corresponds to
638 a directory of system header files. */
639 static struct file_name_list *first_system_include = 0;
640 static struct file_name_list *last_include = 0; /* Last in chain */
642 /* Chain of include directories to put at the end of the other chain. */
643 static struct file_name_list *after_include = 0;
644 static struct file_name_list *last_after_include = 0; /* Last in chain */
646 /* Chain to put at the start of the system include files. */
647 static struct file_name_list *before_system = 0;
648 static struct file_name_list *last_before_system = 0; /* Last in chain */
650 /* Directory prefix that should replace `/usr' in the standard
651 include file directories. */
652 static char *include_prefix;
654 /* Maintain and search list of included files. */
656 struct include_file {
657 struct include_file *next; /* for include_hashtab */
658 struct include_file *next_ino; /* for include_ino_hashtab */
660 /* If the following is the empty string, it means #pragma once
661 was seen in this include file, or #import was applied to the file.
662 Otherwise, if it is nonzero, it is a macro name.
663 Don't include the file again if that macro is defined. */
664 U_CHAR *control_macro;
665 /* Nonzero if the dependency on this include file has been output. */
670 /* Hash tables of files already included with #include or #import.
671 include_hashtab is by full name; include_ino_hashtab is by inode number. */
673 #define INCLUDE_HASHSIZE 61
674 static struct include_file *include_hashtab[INCLUDE_HASHSIZE];
675 static struct include_file *include_ino_hashtab[INCLUDE_HASHSIZE];
677 /* Global list of strings read in from precompiled files. This list
678 is kept in the order the strings are read in, with new strings being
679 added at the end through stringlist_tailp. We use this list to output
680 the strings at the end of the run.
682 static STRINGDEF *stringlist;
683 static STRINGDEF **stringlist_tailp = &stringlist;
686 /* Structure returned by create_definition */
687 typedef struct macrodef MACRODEF;
690 struct definition *defn;
695 enum sharp_token_type {
696 NO_SHARP_TOKEN = 0, /* token not present */
698 SHARP_TOKEN = '#', /* token spelled with # only */
699 WHITE_SHARP_TOKEN, /* token spelled with # and white space */
701 PERCENT_COLON_TOKEN = '%', /* token spelled with %: only */
702 WHITE_PERCENT_COLON_TOKEN /* token spelled with %: and white space */
705 /* Structure allocated for every #define. For a simple replacement
708 nargs = -1, the `pattern' list is null, and the expansion is just
709 the replacement text. Nargs = 0 means a functionlike macro with no args,
711 #define getchar() getc (stdin) .
712 When there are args, the expansion is the replacement text with the
713 args squashed out, and the reflist is a list describing how to
714 build the output from the input: e.g., "3 chars, then the 1st arg,
715 then 9 chars, then the 3rd arg, then 0 chars, then the 2nd arg".
716 The chars here come from the expansion. Whatever is left of the
717 expansion after the last arg-occurrence is copied after that arg.
718 Note that the reflist can be arbitrarily long---
719 its length depends on the number of times the arguments appear in
720 the replacement text, not how many args there are. Example:
721 #define f(x) x+x+x+x+x+x+x would have replacement text "++++++" and
723 { (0, 1), (1, 1), (1, 1), ..., (1, 1), NULL }
724 where (x, y) means (nchars, argno). */
726 typedef struct definition DEFINITION;
729 int length; /* length of expansion string */
730 int predefined; /* True if the macro was builtin or */
731 /* came from the command line */
733 int line; /* Line number of definition */
734 char *file; /* File of definition */
735 char rest_args; /* Nonzero if last arg. absorbs the rest */
737 struct reflist *next;
739 enum sharp_token_type stringify; /* set if a # operator before arg */
740 enum sharp_token_type raw_before; /* set if a ## operator before arg */
741 enum sharp_token_type raw_after; /* set if a ## operator after arg */
743 char rest_args; /* Nonzero if this arg. absorbs the rest */
744 int nchars; /* Number of literal chars to copy before
745 this arg occurrence. */
746 int argno; /* Number of arg to substitute (origin-0) */
749 /* Names of macro args, concatenated in reverse order
750 with comma-space between them.
751 The only use of this is that we warn on redefinition
752 if this differs between the old and new definitions. */
757 /* different kinds of things that can appear in the value field
758 of a hash node. Actually, this may be useless now. */
766 * special extension string that can be added to the last macro argument to
767 * allow it to absorb the "rest" of the arguments when expanded. Ex:
768 * #define wow(a, b...) process (b, a, b)
769 * { wow (1, 2, 3); } -> { process (2, 3, 1, 2, 3); }
770 * { wow (one, two); } -> { process (two, one, two); }
771 * if this "rest_arg" is used with the concat token '##' and if it is not
772 * supplied then the token attached to with ## will not be outputted. Ex:
773 * #define wow (a, b...) process (b ## , a, ## b)
774 * { wow (1, 2); } -> { process (2, 1, 2); }
775 * { wow (one); } -> { process (one); {
777 static char rest_extension[] = "...";
778 #define REST_EXTENSION_LENGTH (sizeof (rest_extension) - 1)
780 /* The structure of a node in the hash table. The hash table
781 has entries for all tokens defined by #define directives (type T_MACRO),
782 plus some special tokens like __LINE__ (these each have their own
783 type, and the appropriate code is run when that type of node is seen.
784 It does not contain control words like "#define", which are recognized
785 by a separate piece of code. */
787 /* different flavors of hash nodes --- also used in keyword table */
789 T_DEFINE = 1, /* the `#define' keyword */
790 T_INCLUDE, /* the `#include' keyword */
791 T_INCLUDE_NEXT, /* the `#include_next' keyword */
792 T_IMPORT, /* the `#import' keyword */
793 T_IFDEF, /* the `#ifdef' keyword */
794 T_IFNDEF, /* the `#ifndef' keyword */
795 T_IF, /* the `#if' keyword */
796 T_ELSE, /* `#else' */
797 T_PRAGMA, /* `#pragma' */
798 T_ELIF, /* `#elif' */
799 T_UNDEF, /* `#undef' */
800 T_LINE, /* `#line' */
801 T_ERROR, /* `#error' */
802 T_WARNING, /* `#warning' */
803 T_ENDIF, /* `#endif' */
804 T_SCCS, /* `#sccs', used on system V. */
805 T_IDENT, /* `#ident', used on system V. */
806 T_ASSERT, /* `#assert', taken from system V. */
807 T_UNASSERT, /* `#unassert', taken from system V. */
808 T_SPECLINE, /* special symbol `__LINE__' */
809 T_DATE, /* `__DATE__' */
810 T_FILE, /* `__FILE__' */
811 T_BASE_FILE, /* `__BASE_FILE__' */
812 T_INCLUDE_LEVEL, /* `__INCLUDE_LEVEL__' */
813 T_VERSION, /* `__VERSION__' */
814 T_SIZE_TYPE, /* `__SIZE_TYPE__' */
815 T_PTRDIFF_TYPE, /* `__PTRDIFF_TYPE__' */
816 T_WCHAR_TYPE, /* `__WCHAR_TYPE__' */
817 T_USER_LABEL_PREFIX_TYPE, /* `__USER_LABEL_PREFIX__' */
818 T_REGISTER_PREFIX_TYPE, /* `__REGISTER_PREFIX__' */
819 T_IMMEDIATE_PREFIX_TYPE, /* `__IMMEDIATE_PREFIX__' */
820 T_TIME, /* `__TIME__' */
821 T_CONST, /* Constant value, used by `__STDC__' */
822 T_MACRO, /* macro defined by `#define' */
823 T_DISABLED, /* macro temporarily turned off for rescan */
824 T_SPEC_DEFINED, /* special `defined' macro for use in #if statements */
825 T_PCSTRING, /* precompiled string (hashval is KEYDEF *) */
826 T_UNUSED /* Used for something not defined. */
830 struct hashnode *next; /* double links for easy deletion */
831 struct hashnode *prev;
832 struct hashnode **bucket_hdr; /* also, a back pointer to this node's hash
833 chain is kept, in case the node is the head
834 of the chain and gets deleted. */
835 enum node_type type; /* type of special token */
836 int length; /* length of token, for quick comparison */
837 U_CHAR *name; /* the actual name */
838 union hashval value; /* pointer to expansion, or whatever */
841 typedef struct hashnode HASHNODE;
843 /* Some definitions for the hash table. The hash function MUST be
844 computed as shown in hashf () below. That is because the rescan
845 loop computes the hash value `on the fly' for most tokens,
846 in order to avoid the overhead of a lot of procedure calls to
847 the hashf () function. Hashf () only exists for the sake of
848 politeness, for use when speed isn't so important. */
850 #define HASHSIZE 1403
851 static HASHNODE *hashtab[HASHSIZE];
852 #define HASHSTEP(old, c) ((old << 2) + c)
853 #define MAKE_POS(v) (v & 0x7fffffff) /* make number positive */
855 /* Symbols to predefine. */
857 #ifdef CPP_PREDEFINES
858 static char *predefs = CPP_PREDEFINES;
860 static char *predefs = "";
863 /* We let tm.h override the types used here, to handle trivial differences
864 such as the choice of unsigned int or long unsigned int for size_t.
865 When machines start needing nontrivial differences in the size type,
866 it would be best to do something here to figure out automatically
867 from other information what type to use. */
869 /* The string value for __SIZE_TYPE__. */
872 #define SIZE_TYPE "long unsigned int"
875 /* The string value for __PTRDIFF_TYPE__. */
878 #define PTRDIFF_TYPE "long int"
881 /* The string value for __WCHAR_TYPE__. */
884 #define WCHAR_TYPE "int"
886 char * wchar_type = WCHAR_TYPE;
889 /* The string value for __USER_LABEL_PREFIX__ */
891 #ifndef USER_LABEL_PREFIX
892 #define USER_LABEL_PREFIX ""
895 /* The string value for __REGISTER_PREFIX__ */
897 #ifndef REGISTER_PREFIX
898 #define REGISTER_PREFIX ""
901 /* The string value for __IMMEDIATE_PREFIX__ */
903 #ifndef IMMEDIATE_PREFIX
904 #define IMMEDIATE_PREFIX ""
907 /* In the definition of a #assert name, this structure forms
908 a list of the individual values asserted.
909 Each value is itself a list of "tokens".
910 These are strings that are compared by name. */
912 struct tokenlist_list {
913 struct tokenlist_list *next;
914 struct arglist *tokens;
917 struct assertion_hashnode {
918 struct assertion_hashnode *next; /* double links for easy deletion */
919 struct assertion_hashnode *prev;
920 /* also, a back pointer to this node's hash
921 chain is kept, in case the node is the head
922 of the chain and gets deleted. */
923 struct assertion_hashnode **bucket_hdr;
924 int length; /* length of token, for quick comparison */
925 U_CHAR *name; /* the actual name */
926 /* List of token-sequences. */
927 struct tokenlist_list *value;
930 typedef struct assertion_hashnode ASSERTION_HASHNODE;
932 /* Some definitions for the hash table. The hash function MUST be
933 computed as shown in hashf below. That is because the rescan
934 loop computes the hash value `on the fly' for most tokens,
935 in order to avoid the overhead of a lot of procedure calls to
936 the hashf function. hashf only exists for the sake of
937 politeness, for use when speed isn't so important. */
939 #define ASSERTION_HASHSIZE 37
940 static ASSERTION_HASHNODE *assertion_hashtab[ASSERTION_HASHSIZE];
942 /* Nonzero means inhibit macroexpansion of what seem to be
943 assertion tests, in rescan. For #if. */
944 static int assertions_flag;
946 /* `struct directive' defines one #-directive, including how to handle it. */
948 #define DO_PROTO PROTO((U_CHAR *, U_CHAR *, FILE_BUF *, struct directive *))
951 int length; /* Length of name */
952 int (*func) DO_PROTO; /* Function to handle directive */
953 char *name; /* Name of directive */
954 enum node_type type; /* Code which describes which directive. */
955 char angle_brackets; /* Nonzero => <...> is special. */
956 char traditional_comments; /* Nonzero: keep comments if -traditional. */
957 char pass_thru; /* Copy preprocessed directive to output file. */
960 /* These functions are declared to return int instead of void since they
961 are going to be placed in the table and some old compilers have trouble with
962 pointers to functions returning void. */
964 static int do_assert DO_PROTO;
965 static int do_define DO_PROTO;
966 static int do_elif DO_PROTO;
967 static int do_else DO_PROTO;
968 static int do_endif DO_PROTO;
969 static int do_error DO_PROTO;
970 static int do_ident DO_PROTO;
971 static int do_if DO_PROTO;
972 static int do_include DO_PROTO;
973 static int do_line DO_PROTO;
974 static int do_pragma DO_PROTO;
975 #ifdef SCCS_DIRECTIVE
976 static int do_sccs DO_PROTO;
978 static int do_unassert DO_PROTO;
979 static int do_undef DO_PROTO;
980 static int do_warning DO_PROTO;
981 static int do_xifdef DO_PROTO;
983 /* Here is the actual list of #-directives, most-often-used first. */
985 static struct directive directive_table[] = {
986 { 6, do_define, "define", T_DEFINE, 0, 1},
987 { 2, do_if, "if", T_IF},
988 { 5, do_xifdef, "ifdef", T_IFDEF},
989 { 6, do_xifdef, "ifndef", T_IFNDEF},
990 { 5, do_endif, "endif", T_ENDIF},
991 { 4, do_else, "else", T_ELSE},
992 { 4, do_elif, "elif", T_ELIF},
993 { 4, do_line, "line", T_LINE},
994 { 7, do_include, "include", T_INCLUDE, 1},
995 { 12, do_include, "include_next", T_INCLUDE_NEXT, 1},
996 { 6, do_include, "import", T_IMPORT, 1},
997 { 5, do_undef, "undef", T_UNDEF},
998 { 5, do_error, "error", T_ERROR},
999 { 7, do_warning, "warning", T_WARNING},
1000 #ifdef SCCS_DIRECTIVE
1001 { 4, do_sccs, "sccs", T_SCCS},
1003 { 6, do_pragma, "pragma", T_PRAGMA, 0, 0, 1},
1004 { 5, do_ident, "ident", T_IDENT},
1005 { 6, do_assert, "assert", T_ASSERT},
1006 { 8, do_unassert, "unassert", T_UNASSERT},
1007 { -1, 0, "", T_UNUSED},
1010 /* When a directive handler is called,
1011 this points to the # (or the : of the %:) that started the directive. */
1012 U_CHAR *directive_start;
1014 /* table to tell if char can be part of a C identifier. */
1015 U_CHAR is_idchar[256];
1016 /* table to tell if char can be first char of a c identifier. */
1017 U_CHAR is_idstart[256];
1018 /* table to tell if c is horizontal space. */
1019 U_CHAR is_hor_space[256];
1020 /* table to tell if c is horizontal or vertical space. */
1021 static U_CHAR is_space[256];
1022 /* names of some characters */
1023 static char *char_name[256];
1025 #define SKIP_WHITE_SPACE(p) do { while (is_hor_space[*p]) p++; } while (0)
1026 #define SKIP_ALL_WHITE_SPACE(p) do { while (is_space[*p]) p++; } while (0)
1028 static int errors = 0; /* Error counter for exit code */
1030 /* Name of output file, for error messages. */
1031 static char *out_fname;
1033 /* Zero means dollar signs are punctuation.
1034 -$ stores 0; -traditional may store 1. Default is 1 for VMS, 0 otherwise.
1035 This must be 0 for correct processing of this ANSI C program:
1037 #define lose(b) foo (b)
1040 static int dollars_in_ident;
1041 #ifndef DOLLARS_IN_IDENTIFIERS
1042 #define DOLLARS_IN_IDENTIFIERS 1
1046 /* Stack of conditionals currently in progress
1047 (including both successful and failing conditionals). */
1050 struct if_stack *next; /* for chaining to the next stack frame */
1051 char *fname; /* copied from input when frame is made */
1052 int lineno; /* similarly */
1053 int if_succeeded; /* true if a leg of this if-group
1054 has been passed through rescan */
1055 U_CHAR *control_macro; /* For #ifndef at start of file,
1056 this is the macro name tested. */
1057 enum node_type type; /* type of last directive seen in this group */
1059 typedef struct if_stack IF_STACK_FRAME;
1060 static IF_STACK_FRAME *if_stack = NULL;
1062 /* Buffer of -M output. */
1063 static char *deps_buffer;
1065 /* Number of bytes allocated in above. */
1066 static int deps_allocated_size;
1068 /* Number of bytes used. */
1069 static int deps_size;
1071 /* Number of bytes since the last newline. */
1072 static int deps_column;
1074 /* Nonzero means -I- has been seen,
1075 so don't look for #include "foo" the source-file directory. */
1076 static int ignore_srcdir;
1078 static int safe_read PROTO((int, char *, int));
1079 static void safe_write PROTO((int, char *, int));
1081 int main PROTO((int, char **));
1083 static void path_include PROTO((char *));
1085 static U_CHAR *index0 PROTO((U_CHAR *, int, size_t));
1087 static void trigraph_pcp PROTO((FILE_BUF *));
1089 static void newline_fix PROTO((U_CHAR *));
1090 static void name_newline_fix PROTO((U_CHAR *));
1092 static char *get_lintcmd PROTO((U_CHAR *, U_CHAR *, U_CHAR **, int *, int *));
1094 static void rescan PROTO((FILE_BUF *, int));
1096 static FILE_BUF expand_to_temp_buffer PROTO((U_CHAR *, U_CHAR *, int, int));
1098 static int handle_directive PROTO((FILE_BUF *, FILE_BUF *));
1100 static struct tm *timestamp PROTO((void));
1101 static void special_symbol PROTO((HASHNODE *, FILE_BUF *));
1103 static int is_system_include PROTO((char *));
1104 static char *base_name PROTO((char *));
1105 static int absolute_filename PROTO((char *));
1106 static size_t simplify_filename PROTO((char *));
1108 static char *read_filename_string PROTO((int, FILE *));
1109 static struct file_name_map *read_name_map PROTO((char *));
1110 static int open_include_file PROTO((char *, struct file_name_list *, U_CHAR *, struct include_file **));
1111 static char *remap_include_file PROTO((char *, struct file_name_list *));
1112 static int lookup_ino_include PROTO((struct include_file *));
1114 static void finclude PROTO((int, struct include_file *, FILE_BUF *, int, struct file_name_list *));
1115 static void record_control_macro PROTO((struct include_file *, U_CHAR *));
1117 static char *check_precompiled PROTO((int, struct stat *, char *, char **));
1118 static int check_preconditions PROTO((char *));
1119 static void pcfinclude PROTO((U_CHAR *, U_CHAR *, U_CHAR *, FILE_BUF *));
1120 static void pcstring_used PROTO((HASHNODE *));
1121 static void write_output PROTO((void));
1122 static void pass_thru_directive PROTO((U_CHAR *, U_CHAR *, FILE_BUF *, struct directive *));
1124 static MACRODEF create_definition PROTO((U_CHAR *, U_CHAR *, FILE_BUF *));
1126 static int check_macro_name PROTO((U_CHAR *, char *));
1127 static int compare_defs PROTO((DEFINITION *, DEFINITION *));
1128 static int comp_def_part PROTO((int, U_CHAR *, int, U_CHAR *, int, int));
1130 static DEFINITION *collect_expansion PROTO((U_CHAR *, U_CHAR *, int, struct arglist *));
1132 int check_assertion PROTO((U_CHAR *, int, int, struct arglist *));
1133 static int compare_token_lists PROTO((struct arglist *, struct arglist *));
1135 static struct arglist *read_token_list PROTO((U_CHAR **, U_CHAR *, int *));
1136 static void free_token_list PROTO((struct arglist *));
1138 static ASSERTION_HASHNODE *assertion_install PROTO((U_CHAR *, int, int));
1139 static ASSERTION_HASHNODE *assertion_lookup PROTO((U_CHAR *, int, int));
1140 static void delete_assertion PROTO((ASSERTION_HASHNODE *));
1142 static void do_once PROTO((void));
1144 static HOST_WIDE_INT eval_if_expression PROTO((U_CHAR *, int));
1145 static void conditional_skip PROTO((FILE_BUF *, int, enum node_type, U_CHAR *, FILE_BUF *));
1146 static void skip_if_group PROTO((FILE_BUF *, int, FILE_BUF *));
1147 static void validate_else PROTO((U_CHAR *, U_CHAR *));
1149 static U_CHAR *skip_to_end_of_comment PROTO((FILE_BUF *, int *, int));
1150 static U_CHAR *skip_quoted_string PROTO((U_CHAR *, U_CHAR *, int, int *, int *, int *));
1151 static char *quote_string PROTO((char *, char *));
1152 static U_CHAR *skip_paren_group PROTO((FILE_BUF *));
1154 /* Last arg to output_line_directive. */
1155 enum file_change_code {same_file, enter_file, leave_file};
1156 static void output_line_directive PROTO((FILE_BUF *, FILE_BUF *, int, enum file_change_code));
1158 static void macroexpand PROTO((HASHNODE *, FILE_BUF *));
1161 static char *macarg PROTO((struct argdata *, int));
1163 static U_CHAR *macarg1 PROTO((U_CHAR *, U_CHAR *, int *, int *, int *, int));
1165 static int discard_comments PROTO((U_CHAR *, int, int));
1167 static int change_newlines PROTO((U_CHAR *, int));
1169 char *my_strerror PROTO((int));
1170 void error PRINTF_PROTO_1((char *, ...));
1171 static void verror PROTO((char *, va_list));
1172 static void error_from_errno PROTO((char *));
1173 void warning PRINTF_PROTO_1((char *, ...));
1174 static void vwarning PROTO((char *, va_list));
1175 static void error_with_line PRINTF_PROTO_2((int, char *, ...));
1176 static void verror_with_line PROTO((int, char *, va_list));
1177 static void vwarning_with_line PROTO((int, char *, va_list));
1178 static void warning_with_line PRINTF_PROTO_2((int, char *, ...));
1179 void pedwarn PRINTF_PROTO_1((char *, ...));
1180 void pedwarn_with_line PRINTF_PROTO_2((int, char *, ...));
1181 static void pedwarn_with_file_and_line PRINTF_PROTO_3((char *, int, char *, ...));
1183 static void print_containing_files PROTO((void));
1185 static int line_for_error PROTO((int));
1186 static int grow_outbuf PROTO((FILE_BUF *, int));
1188 static HASHNODE *install PROTO((U_CHAR *, int, enum node_type, char *, int));
1189 HASHNODE *lookup PROTO((U_CHAR *, int, int));
1190 static void delete_macro PROTO((HASHNODE *));
1191 static int hashf PROTO((U_CHAR *, int, int));
1193 static void dump_single_macro PROTO((HASHNODE *, FILE *));
1194 static void dump_all_macros PROTO((void));
1195 static void dump_defn_1 PROTO((U_CHAR *, int, int, FILE *));
1196 static void dump_arg_n PROTO((DEFINITION *, int, FILE *));
1198 static void initialize_char_syntax PROTO((void));
1199 static void initialize_builtins PROTO((FILE_BUF *, FILE_BUF *));
1201 static void make_definition PROTO((char *, FILE_BUF *));
1202 static void make_undef PROTO((char *, FILE_BUF *));
1204 static void make_assertion PROTO((char *, char *));
1206 static struct file_name_list *new_include_prefix PROTO((struct file_name_list *, char *, char *));
1207 static void append_include_chain PROTO((struct file_name_list *, struct file_name_list *));
1209 static void deps_output PROTO((char *, int));
1211 static void fatal PRINTF_PROTO_1((char *, ...)) __attribute__ ((noreturn));
1212 void fancy_abort PROTO((void)) __attribute__ ((noreturn));
1213 static void perror_with_name PROTO((char *));
1214 static void pfatal_with_name PROTO((char *)) __attribute__ ((noreturn));
1215 static void pipe_closed PROTO((int)) __attribute__ ((noreturn));
1217 static void memory_full PROTO((void)) __attribute__ ((noreturn));
1218 GENERIC_PTR xmalloc PROTO((size_t));
1219 static GENERIC_PTR xrealloc PROTO((GENERIC_PTR, size_t));
1220 static GENERIC_PTR xcalloc PROTO((size_t, size_t));
1221 static char *savestring PROTO((char *));
1223 /* Read LEN bytes at PTR from descriptor DESC, for file FILENAME,
1224 retrying if necessary. Return a negative value if an error occurs,
1225 otherwise return the actual number of bytes read,
1226 which must be LEN unless end-of-file was reached. */
1229 safe_read (desc, ptr, len)
1236 int nchars = read (desc, ptr, left);
1253 /* Write LEN bytes at PTR to descriptor DESC,
1254 retrying if necessary, and treating any real error as fatal. */
1257 safe_write (desc, ptr, len)
1263 int written = write (desc, ptr, len);
1270 pfatal_with_name (out_fname);
1287 char **pend_files = (char **) xmalloc (argc * sizeof (char *));
1288 char **pend_defs = (char **) xmalloc (argc * sizeof (char *));
1289 char **pend_undefs = (char **) xmalloc (argc * sizeof (char *));
1290 char **pend_assertions = (char **) xmalloc (argc * sizeof (char *));
1291 char **pend_includes = (char **) xmalloc (argc * sizeof (char *));
1293 /* Record the option used with each element of pend_assertions.
1294 This is preparation for supporting more than one option for making
1296 char **pend_assertion_options = (char **) xmalloc (argc * sizeof (char *));
1297 int inhibit_predefs = 0;
1298 int no_standard_includes = 0;
1299 int no_standard_cplusplus_includes = 0;
1300 int missing_newline = 0;
1302 /* Non-0 means don't output the preprocessed program. */
1303 int inhibit_output = 0;
1304 /* Non-0 means -v, so print the full set of include dirs. */
1307 /* File name which deps are being written to.
1308 This is 0 if deps are being written to stdout. */
1309 char *deps_file = 0;
1310 /* Fopen file mode to open deps_file with. */
1311 char *deps_mode = "a";
1312 /* Stream on which to print the dependency information. */
1313 FILE *deps_stream = 0;
1314 /* Target-name to write with the dependency information. */
1315 char *deps_target = 0;
1318 /* Get rid of any avoidable limit on stack size. */
1322 /* Set the stack limit huge so that alloca (particularly stringtab
1323 * in dbxread.c) does not fail. */
1324 getrlimit (RLIMIT_STACK, &rlim);
1325 rlim.rlim_cur = rlim.rlim_max;
1326 setrlimit (RLIMIT_STACK, &rlim);
1328 #endif /* RLIMIT_STACK defined */
1331 signal (SIGPIPE, pipe_closed);
1334 progname = base_name (argv[0]);
1338 /* Remove extension from PROGNAME. */
1340 char *s = progname = savestring (progname);
1342 if ((p = rindex (s, ';')) != 0) *p = '\0'; /* strip version number */
1343 if ((p = rindex (s, '.')) != 0 /* strip type iff ".exe" */
1344 && (p[1] == 'e' || p[1] == 'E')
1345 && (p[2] == 'x' || p[2] == 'X')
1346 && (p[3] == 'e' || p[3] == 'E')
1355 /* Initialize is_idchar to allow $. */
1356 dollars_in_ident = 1;
1357 initialize_char_syntax ();
1358 dollars_in_ident = DOLLARS_IN_IDENTIFIERS > 0;
1360 no_line_directives = 0;
1362 dump_macros = dump_none;
1365 cplusplus_comments = 1;
1367 bzero ((char *) pend_files, argc * sizeof (char *));
1368 bzero ((char *) pend_defs, argc * sizeof (char *));
1369 bzero ((char *) pend_undefs, argc * sizeof (char *));
1370 bzero ((char *) pend_assertions, argc * sizeof (char *));
1371 bzero ((char *) pend_includes, argc * sizeof (char *));
1373 /* Process switches and find input file name. */
1375 for (i = 1; i < argc; i++) {
1376 if (argv[i][0] != '-') {
1377 if (out_fname != NULL)
1378 fatal ("Usage: %s [switches] input output", argv[0]);
1379 else if (in_fname != NULL)
1380 out_fname = argv[i];
1384 switch (argv[i][1]) {
1387 if (!strcmp (argv[i], "-include")) {
1389 fatal ("Filename missing after `-include' option");
1391 simplify_filename (pend_includes[i] = argv[++i]);
1393 if (!strcmp (argv[i], "-imacros")) {
1395 fatal ("Filename missing after `-imacros' option");
1397 simplify_filename (pend_files[i] = argv[++i]);
1399 if (!strcmp (argv[i], "-iprefix")) {
1401 fatal ("Filename missing after `-iprefix' option");
1403 include_prefix = argv[++i];
1405 if (!strcmp (argv[i], "-ifoutput")) {
1406 output_conditionals = 1;
1408 if (!strcmp (argv[i], "-isystem")) {
1409 struct file_name_list *dirtmp;
1411 if (! (dirtmp = new_include_prefix (NULL_PTR, "", argv[++i])))
1413 dirtmp->c_system_include_path = 1;
1415 if (before_system == 0)
1416 before_system = dirtmp;
1418 last_before_system->next = dirtmp;
1419 last_before_system = dirtmp; /* Tail follows the last one */
1421 /* Add directory to end of path for includes,
1422 with the default prefix at the front of its name. */
1423 if (!strcmp (argv[i], "-iwithprefix")) {
1424 struct file_name_list *dirtmp;
1427 if (include_prefix != 0)
1428 prefix = include_prefix;
1430 prefix = savestring (GCC_INCLUDE_DIR);
1431 /* Remove the `include' from /usr/local/lib/gcc.../include. */
1432 if (!strcmp (prefix + strlen (prefix) - 8, "/include"))
1433 prefix[strlen (prefix) - 7] = 0;
1436 if (! (dirtmp = new_include_prefix (NULL_PTR, prefix, argv[++i])))
1439 if (after_include == 0)
1440 after_include = dirtmp;
1442 last_after_include->next = dirtmp;
1443 last_after_include = dirtmp; /* Tail follows the last one */
1445 /* Add directory to main path for includes,
1446 with the default prefix at the front of its name. */
1447 if (!strcmp (argv[i], "-iwithprefixbefore")) {
1448 struct file_name_list *dirtmp;
1451 if (include_prefix != 0)
1452 prefix = include_prefix;
1454 prefix = savestring (GCC_INCLUDE_DIR);
1455 /* Remove the `include' from /usr/local/lib/gcc.../include. */
1456 if (!strcmp (prefix + strlen (prefix) - 8, "/include"))
1457 prefix[strlen (prefix) - 7] = 0;
1460 dirtmp = new_include_prefix (NULL_PTR, prefix, argv[++i]);
1461 append_include_chain (dirtmp, dirtmp);
1463 /* Add directory to end of path for includes. */
1464 if (!strcmp (argv[i], "-idirafter")) {
1465 struct file_name_list *dirtmp;
1467 if (! (dirtmp = new_include_prefix (NULL_PTR, "", argv[++i])))
1470 if (after_include == 0)
1471 after_include = dirtmp;
1473 last_after_include->next = dirtmp;
1474 last_after_include = dirtmp; /* Tail follows the last one */
1479 if (out_fname != NULL)
1480 fatal ("Output filename specified twice");
1482 fatal ("Filename missing after -o option");
1483 out_fname = argv[++i];
1484 if (!strcmp (out_fname, "-"))
1489 if (!strcmp (argv[i], "-pedantic"))
1491 else if (!strcmp (argv[i], "-pedantic-errors")) {
1493 pedantic_errors = 1;
1494 } else if (!strcmp (argv[i], "-pcp")) {
1497 fatal ("Filename missing after -pcp option");
1498 pcp_fname = argv[++i];
1500 ((pcp_fname[0] != '-' || pcp_fname[1] != '\0')
1501 ? fopen (pcp_fname, "w")
1503 if (pcp_outfile == 0)
1504 pfatal_with_name (pcp_fname);
1510 if (!strcmp (argv[i], "-traditional")) {
1512 cplusplus_comments = 0;
1513 if (dollars_in_ident > 0)
1514 dollars_in_ident = 1;
1515 } else if (!strcmp (argv[i], "-trigraphs")) {
1521 if (! strcmp (argv[i], "-lang-c"))
1522 cplusplus = 0, cplusplus_comments = 1, objc = 0;
1523 if (! strcmp (argv[i], "-lang-c89"))
1524 cplusplus = 0, cplusplus_comments = 0, objc = 0;
1525 if (! strcmp (argv[i], "-lang-c++"))
1526 cplusplus = 1, cplusplus_comments = 1, objc = 0;
1527 if (! strcmp (argv[i], "-lang-objc"))
1528 objc = 1, cplusplus = 0, cplusplus_comments = 1;
1529 if (! strcmp (argv[i], "-lang-objc++"))
1530 objc = 1, cplusplus = 1, cplusplus_comments = 1;
1531 if (! strcmp (argv[i], "-lang-asm"))
1533 if (! strcmp (argv[i], "-lint"))
1538 cplusplus = 1, cplusplus_comments = 1;
1542 inhibit_warnings = 1;
1546 if (!strcmp (argv[i], "-Wtrigraphs"))
1548 else if (!strcmp (argv[i], "-Wno-trigraphs"))
1550 else if (!strcmp (argv[i], "-Wcomment"))
1552 else if (!strcmp (argv[i], "-Wno-comment"))
1554 else if (!strcmp (argv[i], "-Wcomments"))
1556 else if (!strcmp (argv[i], "-Wno-comments"))
1558 else if (!strcmp (argv[i], "-Wtraditional"))
1560 else if (!strcmp (argv[i], "-Wno-traditional"))
1562 else if (!strcmp (argv[i], "-Wimport"))
1564 else if (!strcmp (argv[i], "-Wno-import"))
1566 else if (!strcmp (argv[i], "-Werror"))
1567 warnings_are_errors = 1;
1568 else if (!strcmp (argv[i], "-Wno-error"))
1569 warnings_are_errors = 0;
1570 else if (!strcmp (argv[i], "-Wall"))
1578 /* The style of the choices here is a bit mixed.
1579 The chosen scheme is a hybrid of keeping all options in one string
1580 and specifying each option in a separate argument:
1581 -M|-MM|-MD file|-MMD file [-MG]. An alternative is:
1582 -M|-MM|-MD file|-MMD file|-MG|-MMG; or more concisely:
1583 -M[M][G][D file]. This is awkward to handle in specs, and is not
1585 /* ??? -MG must be specified in addition to one of -M or -MM.
1586 This can be relaxed in the future without breaking anything.
1587 The converse isn't true. */
1589 /* -MG isn't valid with -MD or -MMD. This is checked for later. */
1590 if (!strcmp (argv[i], "-MG"))
1592 print_deps_missing_files = 1;
1595 if (!strcmp (argv[i], "-M"))
1597 else if (!strcmp (argv[i], "-MM"))
1599 else if (!strcmp (argv[i], "-MD"))
1601 else if (!strcmp (argv[i], "-MMD"))
1603 /* For -MD and -MMD options, write deps on file named by next arg. */
1604 if (!strcmp (argv[i], "-MD")
1605 || !strcmp (argv[i], "-MMD")) {
1607 fatal ("Filename missing after %s option", argv[i]);
1609 deps_file = argv[i];
1612 /* For -M and -MM, write deps on standard output
1613 and suppress the usual output. */
1614 deps_stream = stdout;
1621 char *p = argv[i] + 2;
1623 while ((c = *p++)) {
1624 /* Arg to -d specifies what parts of macros to dump */
1627 dump_macros = dump_only;
1631 dump_macros = dump_names;
1634 dump_macros = dump_definitions;
1642 if (argv[i][2] == '3')
1647 fprintf (stderr, "GNU CPP version %s", version_string);
1648 #ifdef TARGET_VERSION
1651 fprintf (stderr, "\n");
1656 print_include_names = 1;
1660 if (argv[i][2] != 0)
1661 pend_defs[i] = argv[i] + 2;
1662 else if (i + 1 == argc)
1663 fatal ("Macro name missing after -D option");
1665 i++, pend_defs[i] = argv[i];
1672 if (argv[i][2] != 0)
1674 else if (i + 1 == argc)
1675 fatal ("Assertion missing after -A option");
1679 if (!strcmp (p, "-")) {
1680 /* -A- eliminates all predefined macros and assertions.
1681 Let's include also any that were specified earlier
1682 on the command line. That way we can get rid of any
1683 that were passed automatically in from GCC. */
1685 inhibit_predefs = 1;
1686 for (j = 0; j < i; j++)
1687 pend_defs[j] = pend_assertions[j] = 0;
1689 pend_assertions[i] = p;
1690 pend_assertion_options[i] = "-A";
1695 case 'U': /* JF #undef something */
1696 if (argv[i][2] != 0)
1697 pend_undefs[i] = argv[i] + 2;
1698 else if (i + 1 == argc)
1699 fatal ("Macro name missing after -U option");
1701 pend_undefs[i] = argv[i+1], i++;
1705 put_out_comments = 1;
1708 case 'E': /* -E comes from cc -E; ignore it. */
1712 no_line_directives = 1;
1715 case '$': /* Don't include $ in identifiers. */
1716 dollars_in_ident = 0;
1719 case 'I': /* Add directory to path for includes. */
1721 struct file_name_list *dirtmp;
1723 if (! ignore_srcdir && !strcmp (argv[i] + 2, "-")) {
1725 /* Don't use any preceding -I directories for #include <...>. */
1726 first_bracket_include = 0;
1729 dirtmp = new_include_prefix (last_include, "",
1730 argv[i][2] ? argv[i] + 2 : argv[++i]);
1731 append_include_chain (dirtmp, dirtmp);
1737 if (!strcmp (argv[i], "-nostdinc"))
1738 /* -nostdinc causes no default include directories.
1739 You must specify all include-file directories with -I. */
1740 no_standard_includes = 1;
1741 else if (!strcmp (argv[i], "-nostdinc++"))
1742 /* -nostdinc++ causes no default C++-specific include directories. */
1743 no_standard_cplusplus_includes = 1;
1744 else if (!strcmp (argv[i], "-noprecomp"))
1749 /* Sun compiler passes undocumented switch "-undef".
1750 Let's assume it means to inhibit the predefined symbols. */
1751 inhibit_predefs = 1;
1754 case '\0': /* JF handle '-' as file name meaning stdin or stdout */
1755 if (in_fname == NULL) {
1758 } else if (out_fname == NULL) {
1761 } /* else fall through into error */
1764 fatal ("Invalid option `%s'", argv[i]);
1769 /* Add dirs from CPATH after dirs from -I. */
1770 /* There seems to be confusion about what CPATH should do,
1771 so for the moment it is not documented. */
1772 /* Some people say that CPATH should replace the standard include dirs,
1773 but that seems pointless: it comes before them, so it overrides them
1775 cp = getenv ("CPATH");
1776 if (cp && ! no_standard_includes)
1779 /* Now that dollars_in_ident is known, initialize is_idchar. */
1780 initialize_char_syntax ();
1782 /* Initialize output buffer */
1784 outbuf.buf = (U_CHAR *) xmalloc (OUTBUF_SIZE);
1785 outbuf.bufp = outbuf.buf;
1786 outbuf.length = OUTBUF_SIZE;
1788 /* Do partial setup of input buffer for the sake of generating
1789 early #line directives (when -g is in effect). */
1791 fp = &instack[++indepth];
1792 if (in_fname == NULL)
1794 fp->nominal_fname = fp->fname = in_fname;
1797 /* In C++, wchar_t is a distinct basic type, and we can expect
1798 __wchar_t to be defined by cc1plus. */
1800 wchar_type = "__wchar_t";
1802 /* Install __LINE__, etc. Must follow initialize_char_syntax
1803 and option processing. */
1804 initialize_builtins (fp, &outbuf);
1806 /* Do standard #defines and assertions
1807 that identify system and machine type. */
1809 if (!inhibit_predefs) {
1810 char *p = (char *) alloca (strlen (predefs) + 1);
1811 strcpy (p, predefs);
1814 while (*p == ' ' || *p == '\t')
1816 /* Handle -D options. */
1817 if (p[0] == '-' && p[1] == 'D') {
1819 while (*p && *p != ' ' && *p != '\t')
1824 output_line_directive (fp, &outbuf, 0, same_file);
1825 make_definition (q, &outbuf);
1826 while (*p == ' ' || *p == '\t')
1828 } else if (p[0] == '-' && p[1] == 'A') {
1829 /* Handle -A options (assertions). */
1838 past_name = assertion;
1839 /* Locate end of name. */
1840 while (*past_name && *past_name != ' '
1841 && *past_name != '\t' && *past_name != '(')
1843 /* Locate `(' at start of value. */
1845 while (*value && (*value == ' ' || *value == '\t'))
1847 if (*value++ != '(')
1849 while (*value && (*value == ' ' || *value == '\t'))
1852 /* Locate end of value. */
1853 while (*past_value && *past_value != ' '
1854 && *past_value != '\t' && *past_value != ')')
1856 termination = past_value;
1857 while (*termination && (*termination == ' ' || *termination == '\t'))
1859 if (*termination++ != ')')
1861 if (*termination && *termination != ' ' && *termination != '\t')
1863 /* Temporarily null-terminate the value. */
1864 save_char = *termination;
1865 *termination = '\0';
1866 /* Install the assertion. */
1867 make_assertion ("-A", assertion);
1868 *termination = (char) save_char;
1870 while (*p == ' ' || *p == '\t')
1878 /* Now handle the command line options. */
1880 /* Do -U's, -D's and -A's in the order they were seen. */
1881 for (i = 1; i < argc; i++) {
1882 if (pend_undefs[i]) {
1884 output_line_directive (fp, &outbuf, 0, same_file);
1885 make_undef (pend_undefs[i], &outbuf);
1889 output_line_directive (fp, &outbuf, 0, same_file);
1890 make_definition (pend_defs[i], &outbuf);
1892 if (pend_assertions[i])
1893 make_assertion (pend_assertion_options[i], pend_assertions[i]);
1896 done_initializing = 1;
1898 { /* read the appropriate environment variable and if it exists
1899 replace include_defaults with the listed path. */
1901 switch ((objc << 1) + cplusplus)
1904 epath = getenv ("C_INCLUDE_PATH");
1907 epath = getenv ("CPLUS_INCLUDE_PATH");
1910 epath = getenv ("OBJC_INCLUDE_PATH");
1913 epath = getenv ("OBJCPLUS_INCLUDE_PATH");
1916 /* If the environment var for this language is set,
1917 add to the default list of include directories. */
1920 char *startp, *endp;
1922 for (num_dirs = 1, startp = epath; *startp; startp++)
1923 if (*startp == PATH_SEPARATOR)
1926 = (struct default_include *) xmalloc ((num_dirs
1927 * sizeof (struct default_include))
1928 + sizeof (include_defaults_array));
1929 startp = endp = epath;
1933 if (c == PATH_SEPARATOR || !c) {
1935 include_defaults[num_dirs].fname
1936 = startp == endp ? "." : savestring (startp);
1938 include_defaults[num_dirs].cplusplus = cplusplus;
1939 include_defaults[num_dirs].cxx_aware = 1;
1946 /* Put the usual defaults back in at the end. */
1947 bcopy ((char *) include_defaults_array,
1948 (char *) &include_defaults[num_dirs],
1949 sizeof (include_defaults_array));
1953 append_include_chain (before_system, last_before_system);
1954 first_system_include = before_system;
1956 /* Unless -fnostdinc,
1957 tack on the standard include file dirs to the specified list */
1958 if (!no_standard_includes) {
1959 struct default_include *p = include_defaults;
1960 char *specd_prefix = include_prefix;
1961 char *default_prefix = savestring (GCC_INCLUDE_DIR);
1962 int default_len = 0;
1963 /* Remove the `include' from /usr/local/lib/gcc.../include. */
1964 if (!strcmp (default_prefix + strlen (default_prefix) - 8, "/include")) {
1965 default_len = strlen (default_prefix) - 7;
1966 default_prefix[default_len] = 0;
1968 /* Search "translated" versions of GNU directories.
1969 These have /usr/local/lib/gcc... replaced by specd_prefix. */
1970 if (specd_prefix != 0 && default_len != 0)
1971 for (p = include_defaults; p->fname; p++) {
1972 /* Some standard dirs are only for C++. */
1973 if (!p->cplusplus || (cplusplus && !no_standard_cplusplus_includes)) {
1974 /* Does this dir start with the prefix? */
1975 if (!strncmp (p->fname, default_prefix, default_len)) {
1976 /* Yes; change prefix and add to search list. */
1977 struct file_name_list *new
1978 = new_include_prefix (NULL_PTR, specd_prefix,
1979 p->fname + default_len);
1981 new->c_system_include_path = !p->cxx_aware;
1982 append_include_chain (new, new);
1983 if (first_system_include == 0)
1984 first_system_include = new;
1989 /* Search ordinary names for GNU include directories. */
1990 for (p = include_defaults; p->fname; p++) {
1991 /* Some standard dirs are only for C++. */
1992 if (!p->cplusplus || (cplusplus && !no_standard_cplusplus_includes)) {
1993 struct file_name_list *new
1994 = new_include_prefix (NULL_PTR, "", p->fname);
1996 new->c_system_include_path = !p->cxx_aware;
1997 append_include_chain (new, new);
1998 if (first_system_include == 0)
1999 first_system_include = new;
2005 /* Tack the after_include chain at the end of the include chain. */
2006 append_include_chain (after_include, last_after_include);
2007 if (first_system_include == 0)
2008 first_system_include = after_include;
2010 /* With -v, print the list of dirs to search. */
2012 struct file_name_list *p;
2013 fprintf (stderr, "#include \"...\" search starts here:\n");
2014 for (p = include; p; p = p->next) {
2015 if (p == first_bracket_include)
2016 fprintf (stderr, "#include <...> search starts here:\n");
2018 fprintf (stderr, " .\n");
2019 else if (!strcmp (p->fname, "/") || !strcmp (p->fname, "//"))
2020 fprintf (stderr, " %s\n", p->fname);
2022 /* Omit trailing '/'. */
2023 fprintf (stderr, " %.*s\n", (int) strlen (p->fname) - 1, p->fname);
2025 fprintf (stderr, "End of search list.\n");
2028 /* -MG doesn't select the form of output and must be specified with one of
2029 -M or -MM. -MG doesn't make sense with -MD or -MMD since they don't
2030 inhibit compilation. */
2031 if (print_deps_missing_files && (print_deps == 0 || !inhibit_output))
2032 fatal ("-MG must be specified with one of -M or -MM");
2034 /* Either of two environment variables can specify output of deps.
2035 Its value is either "OUTPUT_FILE" or "OUTPUT_FILE DEPS_TARGET",
2036 where OUTPUT_FILE is the file to write deps info to
2037 and DEPS_TARGET is the target to mention in the deps. */
2040 && (getenv ("SUNPRO_DEPENDENCIES") != 0
2041 || getenv ("DEPENDENCIES_OUTPUT") != 0)) {
2042 char *spec = getenv ("DEPENDENCIES_OUTPUT");
2047 spec = getenv ("SUNPRO_DEPENDENCIES");
2054 /* Find the space before the DEPS_TARGET, if there is one. */
2055 /* This should use index. (mrs) */
2056 while (*s != 0 && *s != ' ') s++;
2058 deps_target = s + 1;
2059 output_file = xmalloc (s - spec + 1);
2060 bcopy (spec, output_file, s - spec);
2061 output_file[s - spec] = 0;
2068 deps_file = output_file;
2072 /* For -M, print the expected object file name
2073 as the target of this Make-rule. */
2075 deps_allocated_size = 200;
2076 deps_buffer = xmalloc (deps_allocated_size);
2082 deps_output (deps_target, ':');
2083 } else if (*in_fname == 0) {
2084 deps_output ("-", ':');
2089 q = base_name (in_fname);
2091 /* Copy remainder to mungable area. */
2092 p = (char *) alloca (strlen(q) + 8);
2095 /* Output P, but remove known suffixes. */
2099 && p[len - 2] == '.'
2100 && index("cCsSm", p[len - 1]))
2103 && p[len - 3] == '.'
2104 && p[len - 2] == 'c'
2105 && p[len - 1] == 'c')
2108 && p[len - 4] == '.'
2109 && p[len - 3] == 'c'
2110 && p[len - 2] == 'x'
2111 && p[len - 1] == 'x')
2114 && p[len - 4] == '.'
2115 && p[len - 3] == 'c'
2116 && p[len - 2] == 'p'
2117 && p[len - 1] == 'p')
2120 /* Supply our own suffix. */
2127 deps_output (p, ':');
2128 deps_output (in_fname, ' ');
2132 /* Scan the -imacros files before the main input.
2133 Much like #including them, but with no_output set
2134 so that only their macro definitions matter. */
2136 no_output++; no_record_file++;
2137 for (i = 1; i < argc; i++)
2138 if (pend_files[i]) {
2139 struct include_file *inc;
2140 int fd = open_include_file (pend_files[i], NULL_PTR, NULL_PTR, &inc);
2142 perror_with_name (pend_files[i]);
2143 return FATAL_EXIT_CODE;
2145 finclude (fd, inc, &outbuf, 0, NULL_PTR);
2147 no_output--; no_record_file--;
2149 /* Copy the entire contents of the main input file into
2150 the stacked input buffer previously allocated for it. */
2152 /* JF check for stdin */
2153 if (in_fname == NULL || *in_fname == 0) {
2156 } else if ((f = open (in_fname, O_RDONLY, 0666)) < 0)
2159 if (fstat (f, &st) != 0)
2160 pfatal_with_name (in_fname);
2161 fp->nominal_fname = fp->fname = in_fname;
2163 fp->system_header_p = 0;
2164 /* JF all this is mine about reading pipes and ttys */
2165 if (! S_ISREG (st.st_mode)) {
2166 /* Read input from a file that is not a normal disk file.
2167 We cannot preallocate a buffer with the correct size,
2168 so we must read in the file a piece at the time and make it bigger. */
2173 if (S_ISDIR (st.st_mode))
2174 fatal ("Input file `%s' is a directory", in_fname);
2178 fp->buf = (U_CHAR *) xmalloc (bsize + 2);
2180 cnt = safe_read (f, (char *) fp->buf + size, bsize - size);
2181 if (cnt < 0) goto perror; /* error! */
2183 if (size != bsize) break; /* End of file */
2185 fp->buf = (U_CHAR *) xrealloc (fp->buf, bsize + 2);
2189 /* Read a file whose size we can determine in advance.
2190 For the sake of VMS, st.st_size is just an upper bound. */
2191 fp->buf = (U_CHAR *) xmalloc (st.st_size + 2);
2192 fp->length = safe_read (f, (char *) fp->buf, st.st_size);
2193 if (fp->length < 0) goto perror;
2196 fp->if_stack = if_stack;
2198 /* Make sure data ends with a newline. And put a null after it. */
2200 if ((fp->length > 0 && fp->buf[fp->length - 1] != '\n')
2201 /* Backslash-newline at end is not good enough. */
2202 || (fp->length > 1 && fp->buf[fp->length - 2] == '\\')) {
2203 fp->buf[fp->length++] = '\n';
2204 missing_newline = 1;
2206 fp->buf[fp->length] = '\0';
2208 /* Unless inhibited, convert trigraphs in the input. */
2213 /* Now that we know the input file is valid, open the output. */
2215 if (!out_fname || !strcmp (out_fname, ""))
2216 out_fname = "stdout";
2217 else if (! freopen (out_fname, "w", stdout))
2218 pfatal_with_name (out_fname);
2220 output_line_directive (fp, &outbuf, 0, same_file);
2222 /* Scan the -include files before the main input. */
2225 for (i = 1; i < argc; i++)
2226 if (pend_includes[i]) {
2227 struct include_file *inc;
2228 int fd = open_include_file (pend_includes[i], NULL_PTR, NULL_PTR, &inc);
2230 perror_with_name (pend_includes[i]);
2231 return FATAL_EXIT_CODE;
2233 finclude (fd, inc, &outbuf, 0, NULL_PTR);
2237 /* Scan the input, processing macros and directives. */
2239 rescan (&outbuf, 0);
2241 if (missing_newline)
2244 if (pedantic && missing_newline)
2245 pedwarn ("file does not end in newline");
2247 /* Now we have processed the entire input
2248 Write whichever kind of output has been requested. */
2250 if (dump_macros == dump_only)
2252 else if (! inhibit_output) {
2257 /* Don't actually write the deps file if compilation has failed. */
2259 if (deps_file && ! (deps_stream = fopen (deps_file, deps_mode)))
2260 pfatal_with_name (deps_file);
2261 fputs (deps_buffer, deps_stream);
2262 putc ('\n', deps_stream);
2264 if (ferror (deps_stream) || fclose (deps_stream) != 0)
2265 fatal ("I/O error on output");
2270 if (pcp_outfile && pcp_outfile != stdout
2271 && (ferror (pcp_outfile) || fclose (pcp_outfile) != 0))
2272 fatal ("I/O error on `-pcp' output");
2274 if (ferror (stdout) || fclose (stdout) != 0)
2275 fatal ("I/O error on output");
2278 exit (FATAL_EXIT_CODE);
2279 exit (SUCCESS_EXIT_CODE);
2282 pfatal_with_name (in_fname);
2286 /* Given a colon-separated list of file names PATH,
2287 add all the names to the search path for include files. */
2301 struct file_name_list *dirtmp;
2303 /* Find the end of this name. */
2304 while ((c = *q++) != PATH_SEPARATOR && c)
2308 dirtmp = new_include_prefix (last_include, "", p == q ? "." : p);
2310 append_include_chain (dirtmp, dirtmp);
2312 /* Advance past this name. */
2319 /* Return the address of the first character in S that equals C.
2320 S is an array of length N, possibly containing '\0's, and followed by '\0'.
2321 Return 0 if there is no such character. Assume that C itself is not '\0'.
2322 If we knew we could use memchr, we could just invoke memchr (S, C, N),
2323 but unfortunately memchr isn't autoconfigured yet. */
2331 char *p = (char *) s;
2333 char *q = index (p, c);
2335 return (U_CHAR *) q;
2337 size_t l = strlen (p);
2347 /* Pre-C-Preprocessor to translate ANSI trigraph idiocy in BUF
2348 before main CCCP processing. Name `pcp' is also in honor of the
2349 drugs the trigraph designers must have been on.
2351 Using an extra pass through the buffer takes a little extra time,
2352 but is infinitely less hairy than trying to handle trigraphs inside
2353 strings, etc. everywhere, and also makes sure that trigraphs are
2354 only translated in the top level of processing. */
2360 register U_CHAR c, *fptr, *bptr, *sptr, *lptr;
2363 fptr = bptr = sptr = buf->buf;
2364 lptr = fptr + buf->length;
2365 while ((sptr = index0 (sptr, '?', (size_t) (lptr - sptr))) != NULL) {
2402 len = sptr - fptr - 2;
2404 /* BSD doc says bcopy () works right for overlapping strings. In ANSI
2405 C, this will be memmove (). */
2406 if (bptr != fptr && len > 0)
2407 bcopy ((char *) fptr, (char *) bptr, len);
2413 len = buf->length - (fptr - buf->buf);
2414 if (bptr != fptr && len > 0)
2415 bcopy ((char *) fptr, (char *) bptr, len);
2416 buf->length -= fptr - bptr;
2417 buf->buf[buf->length] = '\0';
2418 if (warn_trigraphs && fptr != bptr)
2419 warning_with_line (0, "%lu trigraph(s) encountered",
2420 (unsigned long) (fptr - bptr) / 2);
2423 /* Move all backslash-newline pairs out of embarrassing places.
2424 Exchange all such pairs following BP
2425 with any potentially-embarrassing characters that follow them.
2426 Potentially-embarrassing characters are / and *
2427 (because a backslash-newline inside a comment delimiter
2428 would cause it not to be recognized). */
2434 register U_CHAR *p = bp;
2436 /* First count the backslash-newline pairs here. */
2438 while (p[0] == '\\' && p[1] == '\n')
2441 /* What follows the backslash-newlines is not embarrassing. */
2443 if (*p != '/' && *p != '*')
2446 /* Copy all potentially embarrassing characters
2447 that follow the backslash-newline pairs
2448 down to where the pairs originally started. */
2450 while (*p == '*' || *p == '/')
2453 /* Now write the same number of pairs after the embarrassing chars. */
2460 /* Like newline_fix but for use within a directive-name.
2461 Move any backslash-newlines up past any following symbol constituents. */
2464 name_newline_fix (bp)
2467 register U_CHAR *p = bp;
2469 /* First count the backslash-newline pairs here. */
2470 while (p[0] == '\\' && p[1] == '\n')
2473 /* What follows the backslash-newlines is not embarrassing. */
2478 /* Copy all potentially embarrassing characters
2479 that follow the backslash-newline pairs
2480 down to where the pairs originally started. */
2482 while (is_idchar[*p])
2485 /* Now write the same number of pairs after the embarrassing chars. */
2492 /* Look for lint commands in comments.
2494 When we come in here, ibp points into a comment. Limit is as one expects.
2495 scan within the comment -- it should start, after lwsp, with a lint command.
2496 If so that command is returned as a (constant) string.
2498 Upon return, any arg will be pointed to with argstart and will be
2499 arglen long. Note that we don't parse that arg since it will just
2500 be printed out again.
2504 get_lintcmd (ibp, limit, argstart, arglen, cmdlen)
2505 register U_CHAR *ibp;
2506 register U_CHAR *limit;
2507 U_CHAR **argstart; /* point to command arg */
2508 int *arglen, *cmdlen; /* how long they are */
2510 HOST_WIDE_INT linsize;
2511 register U_CHAR *numptr; /* temp for arg parsing */
2515 SKIP_WHITE_SPACE (ibp);
2517 if (ibp >= limit) return NULL;
2519 linsize = limit - ibp;
2521 /* Oh, I wish C had lexical functions... hell, I'll just open-code the set */
2522 if ((linsize >= 10) && !bcmp (ibp, "NOTREACHED", 10)) {
2524 return "NOTREACHED";
2526 if ((linsize >= 8) && !bcmp (ibp, "ARGSUSED", 8)) {
2530 if ((linsize >= 11) && !bcmp (ibp, "LINTLIBRARY", 11)) {
2532 return "LINTLIBRARY";
2534 if ((linsize >= 7) && !bcmp (ibp, "VARARGS", 7)) {
2536 ibp += 7; linsize -= 7;
2537 if ((linsize == 0) || ! isdigit (*ibp)) return "VARARGS";
2539 /* OK, read a number */
2540 for (numptr = *argstart = ibp; (numptr < limit) && isdigit (*numptr);
2542 *arglen = numptr - *argstart;
2549 * The main loop of the program.
2551 * Read characters from the input stack, transferring them to the
2554 * Macros are expanded and push levels on the input stack.
2555 * At the end of such a level it is popped off and we keep reading.
2556 * At the end of any other kind of level, we return.
2557 * #-directives are handled, except within macros.
2559 * If OUTPUT_MARKS is nonzero, keep Newline markers found in the input
2560 * and insert them when appropriate. This is set while scanning macro
2561 * arguments before substitution. It is zero when scanning for final output.
2562 * There are three types of Newline markers:
2563 * * Newline - follows a macro name that was not expanded
2564 * because it appeared inside an expansion of the same macro.
2565 * This marker prevents future expansion of that identifier.
2566 * When the input is rescanned into the final output, these are deleted.
2567 * These are also deleted by ## concatenation.
2568 * * Newline Space (or Newline and any other whitespace character)
2569 * stands for a place that tokens must be separated or whitespace
2570 * is otherwise desirable, but where the ANSI standard specifies there
2571 * is no whitespace. This marker turns into a Space (or whichever other
2572 * whitespace char appears in the marker) in the final output,
2573 * but it turns into nothing in an argument that is stringified with #.
2574 * Such stringified arguments are the only place where the ANSI standard
2575 * specifies with precision that whitespace may not appear.
2577 * During this function, IP->bufp is kept cached in IBP for speed of access.
2578 * Likewise, OP->bufp is kept in OBP. Before calling a subroutine
2579 * IBP, IP and OBP must be copied back to memory. IP and IBP are
2580 * copied back with the RECACHE macro. OBP must be copied back from OP->bufp
2581 * explicitly, and before RECACHE, since RECACHE uses OBP.
2585 rescan (op, output_marks)
2589 /* Character being scanned in main loop. */
2592 /* Length of pending accumulated identifier. */
2593 register int ident_length = 0;
2595 /* Hash code of pending accumulated identifier. */
2596 register int hash = 0;
2598 /* Current input level (&instack[indepth]). */
2601 /* Pointer for scanning input. */
2602 register U_CHAR *ibp;
2604 /* Pointer to end of input. End of scan is controlled by LIMIT. */
2605 register U_CHAR *limit;
2607 /* Pointer for storing output. */
2608 register U_CHAR *obp;
2610 /* REDO_CHAR is nonzero if we are processing an identifier
2611 after backing up over the terminating character.
2612 Sometimes we process an identifier without backing up over
2613 the terminating character, if the terminating character
2614 is not special. Backing up is done so that the terminating character
2615 will be dispatched on again once the identifier is dealt with. */
2618 /* 1 if within an identifier inside of which a concatenation
2619 marker (Newline -) has been seen. */
2620 int concatenated = 0;
2622 /* While scanning a comment or a string constant,
2623 this records the line it started on, for error messages. */
2626 /* Record position of last `real' newline. */
2627 U_CHAR *beg_of_line;
2629 /* Pop the innermost input stack level, assuming it is a macro expansion. */
2632 do { ip->macro->type = T_MACRO; \
2633 if (ip->free_ptr) free (ip->free_ptr); \
2634 --indepth; } while (0)
2636 /* Reload `rescan's local variables that describe the current
2637 level of the input stack. */
2640 do { ip = &instack[indepth]; \
2642 limit = ip->buf + ip->length; \
2644 check_expand (op, limit - ibp); \
2646 obp = op->bufp; } while (0)
2648 if (no_output && instack[indepth].fname != 0)
2649 skip_if_group (&instack[indepth], 1, NULL);
2656 /* Our caller must always put a null after the end of
2657 the input at each input stack level. */
2667 if (*ibp == '\n' && !ip->macro) {
2668 /* At the top level, always merge lines ending with backslash-newline,
2669 even in middle of identifier. But do not merge lines in a macro,
2670 since backslash might be followed by a newline-space marker. */
2673 --obp; /* remove backslash from obuf */
2676 /* If ANSI, backslash is just another character outside a string. */
2679 /* Otherwise, backslash suppresses specialness of following char,
2680 so copy it here to prevent the switch from seeing it.
2681 But first get any pending identifier processed. */
2682 if (ident_length > 0)
2689 if (ident_length || ip->macro || traditional)
2691 while (*ibp == '\\' && ibp[1] == '\n') {
2697 /* Treat this %: digraph as if it were #. */
2701 if (assertions_flag) {
2704 /* Copy #foo (bar lose) without macro expansion. */
2705 obp[-1] = '#'; /* In case it was '%'. */
2706 SKIP_WHITE_SPACE (ibp);
2707 while (is_idchar[*ibp])
2709 SKIP_WHITE_SPACE (ibp);
2712 skip_paren_group (ip);
2713 bcopy ((char *) ibp, (char *) obp, ip->bufp - ibp);
2714 obp += ip->bufp - ibp;
2720 /* If this is expanding a macro definition, don't recognize
2721 preprocessing directives. */
2724 /* If this is expand_into_temp_buffer,
2725 don't recognize them either. Warn about them
2726 only after an actual newline at this level,
2727 not at the beginning of the input level. */
2729 if (ip->buf != beg_of_line)
2730 warning ("preprocessing directive not recognized within macro arg");
2737 /* # keyword: a # must be first nonblank char on the line */
2738 if (beg_of_line == 0)
2743 /* Scan from start of line, skipping whitespace, comments
2744 and backslash-newlines, and see if we reach this #.
2745 If not, this # is not special. */
2747 /* If -traditional, require # to be at beginning of line. */
2750 if (is_hor_space[*bp])
2752 else if (*bp == '\\' && bp[1] == '\n')
2754 else if (*bp == '/' && bp[1] == '*') {
2756 while (!(*bp == '*' && bp[1] == '/'))
2760 /* There is no point in trying to deal with C++ // comments here,
2761 because if there is one, then this # must be part of the
2762 comment and we would never reach here. */
2768 while (bp[1] == '\\' && bp[2] == '\n')
2772 /* %: appears at start of line; skip past the ':' too. */
2781 /* This # can start a directive. */
2783 --obp; /* Don't copy the '#' */
2787 if (! handle_directive (ip, op)) {
2791 /* Not a known directive: treat it as ordinary text.
2792 IP, OP, IBP, etc. have not been changed. */
2793 if (no_output && instack[indepth].fname) {
2794 /* If not generating expanded output,
2795 what we do with ordinary text is skip it.
2796 Discard everything until next # directive. */
2797 skip_if_group (&instack[indepth], 1, 0);
2802 *obp++ = '#'; /* Copy # (even if it was originally %:). */
2803 /* Don't expand an identifier that could be a macro directive.
2804 (Section 3.8.3 of the ANSI C standard) */
2805 SKIP_WHITE_SPACE (ibp);
2806 if (is_idstart[*ibp])
2809 while (is_idchar[*ibp])
2817 /* A # directive has been successfully processed. */
2818 /* If not generating expanded output, ignore everything until
2819 next # directive. */
2820 if (no_output && instack[indepth].fname)
2821 skip_if_group (&instack[indepth], 1, 0);
2827 case '\"': /* skip quoted string */
2829 /* A single quoted string is treated like a double -- some
2830 programs (e.g., troff) are perverse this way */
2835 start_line = ip->lineno;
2837 /* Skip ahead to a matching quote. */
2841 if (ip->macro != 0) {
2842 /* try harder: this string crosses a macro expansion boundary.
2843 This can happen naturally if -traditional.
2844 Otherwise, only -D can make a macro with an unmatched quote. */
2850 error_with_line (line_for_error (start_line),
2851 "unterminated string or character constant");
2852 error_with_line (multiline_string_line,
2853 "possible real start of unterminated constant");
2854 multiline_string_line = 0;
2863 /* Traditionally, end of line ends a string constant with no error.
2864 So exit the loop and record the new line. */
2870 error_with_line (line_for_error (start_line),
2871 "unterminated character constant");
2874 if (multiline_string_line == 0) {
2876 pedwarn_with_line (line_for_error (start_line),
2877 "string constant runs past end of line");
2878 multiline_string_line = ip->lineno - 1;
2886 /* Backslash newline is replaced by nothing at all,
2887 but keep the line counts correct. */
2892 /* ANSI stupidly requires that in \\ the second \
2893 is *not* prevented from combining with a newline. */
2894 while (*ibp == '\\' && ibp[1] == '\n') {
2913 if (*ibp == '\\' && ibp[1] == '\n')
2917 && !(cplusplus_comments && *ibp == '/'))
2925 /* C++ style comment... */
2926 start_line = ip->lineno;
2928 /* Comments are equivalent to spaces. */
2929 if (! put_out_comments)
2933 U_CHAR *before_bp = ibp;
2935 while (++ibp < limit) {
2937 if (ibp[-1] != '\\') {
2938 if (put_out_comments) {
2939 bcopy ((char *) before_bp, (char *) obp, ibp - before_bp);
2940 obp += ibp - before_bp;
2945 warning ("multiline `//' comment");
2947 /* Copy the newline into the output buffer, in order to
2948 avoid the pain of a #line every time a multiline comment
2950 if (!put_out_comments)
2959 /* Ordinary C comment. Skip it, optionally copying it to output. */
2961 start_line = ip->lineno;
2963 ++ibp; /* Skip the star. */
2965 /* If this cpp is for lint, we peek inside the comments: */
2969 char *lintcmd = get_lintcmd (ibp, limit, &argbp, &arglen, &cmdlen);
2971 if (lintcmd != NULL) {
2973 check_expand (op, cmdlen + arglen + 14);
2975 /* I believe it is always safe to emit this newline: */
2977 bcopy ("#pragma lint ", (char *) obp, 13);
2979 bcopy (lintcmd, (char *) obp, cmdlen);
2984 bcopy (argbp, (char *) obp, arglen);
2988 /* OK, now bring us back to the state we were in before we entered
2989 this branch. We need #line because the #pragma's newline always
2990 messes up the line count. */
2992 output_line_directive (ip, op, 0, same_file);
2993 check_expand (op, limit - ibp + 2);
2999 /* Comments are equivalent to spaces.
3000 Note that we already output the slash; we might not want it.
3001 For -traditional, a comment is equivalent to nothing. */
3002 if (! put_out_comments) {
3012 U_CHAR *before_bp = ibp;
3017 if (ibp[-2] == '/' && warn_comments)
3018 warning ("`/*' within comment");
3019 if (*ibp == '\\' && ibp[1] == '\n')
3027 /* Copy the newline into the output buffer, in order to
3028 avoid the pain of a #line every time a multiline comment
3030 if (!put_out_comments)
3037 error_with_line (line_for_error (start_line),
3038 "unterminated comment");
3047 if (put_out_comments) {
3048 bcopy ((char *) before_bp, (char *) obp, ibp - before_bp);
3049 obp += ibp - before_bp;
3055 if (!dollars_in_ident)
3059 case '0': case '1': case '2': case '3': case '4':
3060 case '5': case '6': case '7': case '8': case '9':
3061 /* If digit is not part of identifier, it starts a number,
3062 which means that following letters are not an identifier.
3063 "0x5" does not refer to an identifier "x5".
3064 So copy all alphanumerics that follow without accumulating
3065 as an identifier. Periods also, for sake of "3.e7". */
3067 if (ident_length == 0) {
3069 while (ibp[0] == '\\' && ibp[1] == '\n') {
3074 if (!is_idchar[c] && c != '.') {
3079 /* A sign can be part of a preprocessing number
3080 if it follows an e. */
3081 if (c == 'e' || c == 'E') {
3082 while (ibp[0] == '\\' && ibp[1] == '\n') {
3086 if (*ibp == '+' || *ibp == '-') {
3088 /* But traditional C does not let the token go past the sign. */
3099 case 'a': case 'b': case 'c': case 'd': case 'e': case 'f':
3100 case 'g': case 'h': case 'i': case 'j': case 'k': case 'l':
3101 case 'm': case 'n': case 'o': case 'p': case 'q': case 'r':
3102 case 's': case 't': case 'u': case 'v': case 'w': case 'x':
3104 case 'A': case 'B': case 'C': case 'D': case 'E': case 'F':
3105 case 'G': case 'H': case 'I': case 'J': case 'K': case 'L':
3106 case 'M': case 'N': case 'O': case 'P': case 'Q': case 'R':
3107 case 'S': case 'T': case 'U': case 'V': case 'W': case 'X':
3111 /* Compute step of hash function, to avoid a proc call on every token */
3112 hash = HASHSTEP (hash, c);
3116 if (ip->fname == 0 && *ibp == '-') {
3117 /* Newline - inhibits expansion of preceding token.
3118 If expanding a macro arg, we keep the newline -.
3119 In final output, it is deleted.
3120 We recognize Newline - in macro bodies and macro args. */
3121 if (! concatenated) {
3126 if (!output_marks) {
3129 /* If expanding a macro arg, keep the newline -. */
3135 /* If reprocessing a macro expansion, newline is a special marker. */
3136 else if (ip->macro != 0) {
3137 /* Newline White is a "funny space" to separate tokens that are
3138 supposed to be separate but without space between.
3139 Here White means any whitespace character.
3140 Newline - marks a recursive macro use that is not
3141 supposed to be expandable. */
3143 if (is_space[*ibp]) {
3144 /* Newline Space does not prevent expansion of preceding token
3145 so expand the preceding token and then come back. */
3146 if (ident_length > 0)
3149 /* If generating final output, newline space makes a space. */
3150 if (!output_marks) {
3152 /* And Newline Newline makes a newline, so count it. */
3153 if (obp[-1] == '\n')
3156 /* If expanding a macro arg, keep the newline space.
3157 If the arg gets stringified, newline space makes nothing. */
3160 } else abort (); /* Newline followed by something random? */
3164 /* If there is a pending identifier, handle it and come back here. */
3165 if (ident_length > 0)
3170 /* Update the line counts and output a #line if necessary. */
3173 if (ip->lineno != op->lineno) {
3175 output_line_directive (ip, op, 1, same_file);
3176 check_expand (op, limit - ibp);
3181 /* Come here either after (1) a null character that is part of the input
3182 or (2) at the end of the input, because there is a null there. */
3185 /* Our input really contains a null character. */
3189 /* At end of a macro-expansion level, pop it and read next level. */
3190 if (ip->macro != 0) {
3193 /* If traditional, and we have an identifier that ends here,
3194 process it now, so we get the right error for recursion. */
3195 if (traditional && ident_length
3196 && ! is_idchar[*instack[indepth - 1].bufp]) {
3205 /* If we don't have a pending identifier,
3206 return at end of input. */
3207 if (ident_length == 0) {
3215 /* If we do have a pending identifier, just consider this null
3216 a special character and arrange to dispatch on it again.
3217 The second time, IDENT_LENGTH will be zero so we will return. */
3223 /* Handle the case of a character such as /, ', " or null
3224 seen following an identifier. Back over it so that
3225 after the identifier is processed the special char
3226 will be dispatched on again. */
3236 if (ident_length > 0) {
3237 register HASHNODE *hp;
3239 /* We have just seen an identifier end. If it's a macro, expand it.
3241 IDENT_LENGTH is the length of the identifier
3242 and HASH is its hash code.
3244 The identifier has already been copied to the output,
3245 so if it is a macro we must remove it.
3247 If REDO_CHAR is 0, the char that terminated the identifier
3248 has been skipped in the output and the input.
3249 OBP-IDENT_LENGTH-1 points to the identifier.
3250 If the identifier is a macro, we must back over the terminator.
3252 If REDO_CHAR is 1, the terminating char has already been
3253 backed over. OBP-IDENT_LENGTH points to the identifier. */
3255 if (!pcp_outfile || pcp_inside_if) {
3256 for (hp = hashtab[MAKE_POS (hash) % HASHSIZE]; hp != NULL;
3259 if (hp->length == ident_length) {
3260 int obufp_before_macroname;
3261 int op_lineno_before_macroname;
3262 register int i = ident_length;
3263 register U_CHAR *p = hp->name;
3264 register U_CHAR *q = obp - i;
3270 do { /* All this to avoid a strncmp () */
3275 /* We found a use of a macro name.
3276 see if the context shows it is a macro call. */
3278 /* Back up over terminating character if not already done. */
3284 /* Save this as a displacement from the beginning of the output
3285 buffer. We can not save this as a position in the output
3286 buffer, because it may get realloc'ed by RECACHE. */
3287 obufp_before_macroname = (obp - op->buf) - ident_length;
3288 op_lineno_before_macroname = op->lineno;
3290 if (hp->type == T_PCSTRING) {
3291 pcstring_used (hp); /* Mark the definition of this key
3292 as needed, ensuring that it
3294 break; /* Exit loop, since the key cannot have a
3295 definition any longer. */
3298 /* Record whether the macro is disabled. */
3299 disabled = hp->type == T_DISABLED;
3301 /* This looks like a macro ref, but if the macro was disabled,
3302 just copy its name and put in a marker if requested. */
3306 /* This error check caught useful cases such as
3307 #define foo(x,y) bar (x (y,0), y)
3310 error ("recursive use of macro `%s'", hp->name);
3314 check_expand (op, limit - ibp + 2);
3321 /* If macro wants an arglist, verify that a '(' follows.
3322 first skip all whitespace, copying it to the output
3323 after the macro name. Then, if there is no '(',
3324 decide this is not a macro call and leave things that way. */
3325 if ((hp->type == T_MACRO || hp->type == T_DISABLED)
3326 && hp->value.defn->nargs >= 0)
3328 U_CHAR *old_ibp = ibp;
3329 U_CHAR *old_obp = obp;
3330 int old_iln = ip->lineno;
3331 int old_oln = op->lineno;
3334 /* Scan forward over whitespace, copying it to the output. */
3335 if (ibp == limit && ip->macro != 0) {
3340 old_iln = ip->lineno;
3341 old_oln = op->lineno;
3343 /* A comment: copy it unchanged or discard it. */
3344 else if (*ibp == '/' && ibp[1] == '*') {
3345 if (put_out_comments) {
3348 } else if (! traditional) {
3352 while (ibp + 1 != limit
3353 && !(ibp[0] == '*' && ibp[1] == '/')) {
3354 /* We need not worry about newline-marks,
3355 since they are never found in comments. */
3357 /* Newline in a file. Count it. */
3361 if (put_out_comments)
3367 if (put_out_comments) {
3372 else if (is_space[*ibp]) {
3374 if (ibp[-1] == '\n') {
3375 if (ip->macro == 0) {
3376 /* Newline in a file. Count it. */
3379 } else if (!output_marks) {
3380 /* A newline mark, and we don't want marks
3381 in the output. If it is newline-hyphen,
3382 discard it entirely. Otherwise, it is
3383 newline-whitechar, so keep the whitechar. */
3393 /* A newline mark; copy both chars to the output. */
3401 /* It isn't a macro call.
3402 Put back the space that we just skipped. */
3405 ip->lineno = old_iln;
3406 op->lineno = old_oln;
3407 /* Exit the for loop. */
3412 /* This is now known to be a macro call.
3413 Discard the macro name from the output,
3414 along with any following whitespace just copied,
3415 but preserve newlines if not outputting marks since this
3416 is more likely to do the right thing with line numbers. */
3417 obp = op->buf + obufp_before_macroname;
3419 op->lineno = op_lineno_before_macroname;
3421 int newlines = op->lineno - op_lineno_before_macroname;
3422 while (0 < newlines--)
3426 /* Prevent accidental token-pasting with a character
3427 before the macro call. */
3428 if (!traditional && obp != op->buf) {
3430 case '!': case '%': case '&': case '*':
3431 case '+': case '-': case '/': case ':':
3432 case '<': case '=': case '>': case '^':
3434 /* If we are expanding a macro arg, make a newline marker
3435 to separate the tokens. If we are making real output,
3436 a plain space will do. */
3443 /* Expand the macro, reading arguments as needed,
3444 and push the expansion on the input stack. */
3447 macroexpand (hp, op);
3449 /* Reexamine input stack, since macroexpand has pushed
3450 a new level on it. */
3457 } /* End hash-table-search loop */
3459 ident_length = hash = 0; /* Stop collecting identifier */
3462 } /* End if (ident_length > 0) */
3464 } /* End per-char loop */
3466 /* Come here to return -- but first give an error message
3467 if there was an unterminated successful conditional. */
3469 if (if_stack != ip->if_stack)
3473 switch (if_stack->type)
3494 error_with_line (line_for_error (if_stack->lineno),
3495 "unterminated `#%s' conditional", str);
3497 if_stack = ip->if_stack;
3501 * Rescan a string into a temporary buffer and return the result
3502 * as a FILE_BUF. Note this function returns a struct, not a pointer.
3504 * OUTPUT_MARKS nonzero means keep Newline markers found in the input
3505 * and insert such markers when appropriate. See `rescan' for details.
3506 * OUTPUT_MARKS is 1 for macroexpanding a macro argument separately
3507 * before substitution; it is 0 for other uses.
3510 expand_to_temp_buffer (buf, limit, output_marks, assertions)
3511 U_CHAR *buf, *limit;
3512 int output_marks, assertions;
3514 register FILE_BUF *ip;
3516 int length = limit - buf;
3518 int odepth = indepth;
3519 int save_assertions_flag = assertions_flag;
3521 assertions_flag = assertions;
3526 /* Set up the input on the input stack. */
3528 buf1 = (U_CHAR *) alloca (length + 1);
3530 register U_CHAR *p1 = buf;
3531 register U_CHAR *p2 = buf1;
3538 /* Set up to receive the output. */
3540 obuf.length = length * 2 + 100; /* Usually enough. Why be stingy? */
3541 obuf.bufp = obuf.buf = (U_CHAR *) xmalloc (obuf.length);
3546 CHECK_DEPTH ({return obuf;});
3550 ip = &instack[indepth];
3552 ip->nominal_fname = 0;
3554 ip->system_header_p = 0;
3557 ip->length = length;
3558 ip->buf = ip->bufp = buf1;
3559 ip->if_stack = if_stack;
3561 ip->lineno = obuf.lineno = 1;
3563 /* Scan the input, create the output. */
3564 rescan (&obuf, output_marks);
3566 /* Pop input stack to original state. */
3569 if (indepth != odepth)
3572 /* Record the output. */
3573 obuf.length = obuf.bufp - obuf.buf;
3575 assertions_flag = save_assertions_flag;
3580 * Process a # directive. Expects IP->bufp to point after the '#', as in
3581 * `#define foo bar'. Passes to the directive handler
3582 * (do_define, do_include, etc.): the addresses of the 1st and
3583 * last chars of the directive (starting immediately after the #
3584 * keyword), plus op and the keyword table pointer. If the directive
3585 * contains comments it is copied into a temporary buffer sans comments
3586 * and the temporary buffer is passed to the directive handler instead.
3587 * Likewise for backslash-newlines.
3589 * Returns nonzero if this was a known # directive.
3590 * Otherwise, returns zero, without advancing the input pointer.
3594 handle_directive (ip, op)
3597 register U_CHAR *bp, *cp;
3598 register struct directive *kt;
3599 register int ident_length;
3602 /* Nonzero means we must copy the entire directive
3603 to get rid of comments or backslash-newlines. */
3604 int copy_directive = 0;
3606 U_CHAR *ident, *after_ident;
3610 /* Record where the directive started. do_xifdef needs this. */
3611 directive_start = bp - 1;
3613 /* Skip whitespace and \-newline. */
3615 if (is_hor_space[*bp]) {
3616 if (*bp != ' ' && *bp != '\t' && pedantic)
3617 pedwarn ("%s in preprocessing directive", char_name[*bp]);
3619 } else if (*bp == '/' && (bp[1] == '*'
3620 || (cplusplus_comments && bp[1] == '/'))) {
3622 skip_to_end_of_comment (ip, &ip->lineno, 0);
3624 } else if (*bp == '\\' && bp[1] == '\n') {
3625 bp += 2; ip->lineno++;
3629 /* Now find end of directive name.
3630 If we encounter a backslash-newline, exchange it with any following
3631 symbol-constituents so that we end up with a contiguous name. */
3638 if (*cp == '\\' && cp[1] == '\n')
3639 name_newline_fix (cp);
3645 ident_length = cp - bp;
3649 /* A line of just `#' becomes blank. */
3651 if (ident_length == 0 && *after_ident == '\n') {
3652 ip->bufp = after_ident;
3656 if (ident_length == 0 || !is_idstart[*ident]) {
3658 while (is_idchar[*p]) {
3659 if (*p < '0' || *p > '9')
3663 /* Handle # followed by a line number. */
3664 if (p != ident && !is_idchar[*p]) {
3665 static struct directive line_directive_table[] = {
3666 { 4, do_line, "line", T_LINE},
3669 pedwarn ("`#' followed by integer");
3670 after_ident = ident;
3671 kt = line_directive_table;
3675 /* Avoid error for `###' and similar cases unless -pedantic. */
3677 while (*p == '#' || is_hor_space[*p]) p++;
3679 if (pedantic && !lang_asm)
3680 warning ("invalid preprocessing directive");
3686 error ("invalid preprocessing directive name");
3692 * Decode the keyword and call the appropriate expansion
3693 * routine, after moving the input pointer up to the next line.
3695 for (kt = directive_table; kt->length > 0; kt++) {
3696 if (kt->length == ident_length && !bcmp (kt->name, ident, ident_length)) {
3697 register U_CHAR *buf;
3698 register U_CHAR *limit;
3701 int *already_output;
3703 /* Nonzero means do not delete comments within the directive.
3704 #define needs this when -traditional. */
3709 limit = ip->buf + ip->length;
3712 keep_comments = traditional && kt->traditional_comments;
3713 /* #import is defined only in Objective C, or when on the NeXT. */
3714 if (kt->type == T_IMPORT
3715 && !(objc || lookup ((U_CHAR *) "__NeXT__", -1, -1)))
3718 /* Find the end of this directive (first newline not backslashed
3719 and not in a string or comment).
3720 Set COPY_DIRECTIVE if the directive must be copied
3721 (it contains a backslash-newline or a comment). */
3723 buf = bp = after_ident;
3724 while (bp < limit) {
3725 register U_CHAR c = *bp++;
3733 } else if (traditional)
3740 bp = skip_quoted_string (bp - 1, limit, ip->lineno, &ip->lineno, ©_directive, &unterminated);
3741 /* Don't bother calling the directive if we already got an error
3742 message due to unterminated string. Skip everything and pretend
3743 we called the directive. */
3746 /* Traditional preprocessing permits unterminated strings. */
3755 /* <...> is special for #include. */
3757 if (!kt->angle_brackets)
3759 while (bp < limit && *bp != '>' && *bp != '\n') {
3760 if (*bp == '\\' && bp[1] == '\n') {
3770 if (*bp == '\\' && bp[1] == '\n')
3773 || (cplusplus_comments && *bp == '/')) {
3774 U_CHAR *obp = bp - 1;
3776 skip_to_end_of_comment (ip, &ip->lineno, 0);
3778 /* No need to copy the directive because of a comment at the end;
3779 just don't include the comment in the directive. */
3780 if (bp == limit || *bp == '\n') {
3784 /* Don't remove the comments if -traditional. */
3785 if (! keep_comments)
3794 pedwarn ("%s in preprocessing directive", char_name[c]);
3798 --bp; /* Point to the newline */
3806 resume_p = ip->bufp;
3807 /* BP is the end of the directive.
3808 RESUME_P is the next interesting data after the directive.
3809 A comment may come between. */
3811 /* If a directive should be copied through, and -E was given,
3812 pass it through before removing comments. */
3813 if (!no_output && kt->pass_thru && put_out_comments) {
3816 /* Output directive name. */
3817 check_expand (op, kt->length + 2);
3818 /* Make sure # is at the start of a line */
3819 if (op->bufp > op->buf && op->bufp[-1] != '\n') {
3824 bcopy (kt->name, op->bufp, kt->length);
3825 op->bufp += kt->length;
3827 /* Output arguments. */
3829 check_expand (op, len);
3830 bcopy (buf, (char *) op->bufp, len);
3832 /* Take account of any (escaped) newlines just output. */
3834 if (buf[len] == '\n')
3837 already_output = &junk;
3838 } /* Don't we need a newline or #line? */
3840 if (copy_directive) {
3841 register U_CHAR *xp = buf;
3842 /* Need to copy entire directive into temp buffer before dispatching */
3844 cp = (U_CHAR *) alloca (bp - buf + 5); /* room for directive plus
3848 /* Copy to the new buffer, deleting comments
3849 and backslash-newlines (and whitespace surrounding the latter). */
3852 register U_CHAR c = *xp++;
3857 abort (); /* A bare newline should never part of the line. */
3860 /* <...> is special for #include. */
3862 if (!kt->angle_brackets)
3864 while (xp < bp && c != '>') {
3866 if (c == '\\' && xp < bp && *xp == '\n')
3877 if (cp != buf && is_hor_space[cp[-1]]) {
3878 while (cp - 1 != buf && is_hor_space[cp[-2]])
3880 SKIP_WHITE_SPACE (xp);
3881 } else if (is_hor_space[*xp]) {
3883 SKIP_WHITE_SPACE (xp);
3885 } else if (traditional && xp < bp) {
3893 register U_CHAR *bp1
3894 = skip_quoted_string (xp - 1, bp, ip->lineno,
3895 NULL_PTR, NULL_PTR, NULL_PTR);
3909 || (cplusplus_comments && *xp == '/')) {
3911 /* If we already copied the directive through,
3912 already_output != 0 prevents outputting comment now. */
3913 skip_to_end_of_comment (ip, already_output, 0);
3915 while (xp != ip->bufp)
3917 /* Delete or replace the slash. */
3918 else if (traditional)
3927 /* Null-terminate the copy. */
3933 ip->bufp = resume_p;
3935 /* Some directives should be written out for cc1 to process,
3936 just as if they were not defined. And sometimes we're copying
3937 definitions through. */
3939 if (!no_output && already_output == 0
3941 || (kt->type == T_DEFINE
3942 && (dump_macros == dump_names
3943 || dump_macros == dump_definitions)))) {
3946 /* Output directive name. */
3947 check_expand (op, kt->length + 1);
3949 bcopy (kt->name, (char *) op->bufp, kt->length);
3950 op->bufp += kt->length;
3952 if (kt->pass_thru || dump_macros == dump_definitions) {
3953 /* Output arguments. */
3955 check_expand (op, len);
3956 bcopy (buf, (char *) op->bufp, len);
3958 } else if (kt->type == T_DEFINE && dump_macros == dump_names) {
3961 SKIP_WHITE_SPACE (xp);
3963 while (is_idchar[*xp]) xp++;
3965 check_expand (op, len + 1);
3967 bcopy (yp, op->bufp, len);
3970 } /* Don't we need a newline or #line? */
3972 /* Call the appropriate directive handler. buf now points to
3973 either the appropriate place in the input buffer, or to
3974 the temp buffer if it was necessary to make one. cp
3975 points to the first char after the contents of the (possibly
3976 copied) directive, in either case. */
3977 (*kt->func) (buf, cp, op, kt);
3978 check_expand (op, ip->length - (ip->bufp - ip->buf));
3984 /* It is deliberate that we don't warn about undefined directives.
3985 That is the responsibility of cc1. */
3992 static struct tm *timebuf;
3994 time_t t = time ((time_t *)0);
3995 timebuf = localtime (&t);
4000 static char *monthnames[] = {"Jan", "Feb", "Mar", "Apr", "May", "Jun",
4001 "Jul", "Aug", "Sep", "Oct", "Nov", "Dec",
4005 * expand things like __FILE__. Place the expansion into the output
4006 * buffer *without* rescanning.
4010 special_symbol (hp, op)
4017 FILE_BUF *ip = NULL;
4020 int paren = 0; /* For special `defined' keyword */
4022 if (pcp_outfile && pcp_inside_if
4023 && hp->type != T_SPEC_DEFINED && hp->type != T_CONST)
4024 error ("Predefined macro `%s' used inside `#if' during precompilation",
4027 for (i = indepth; i >= 0; i--)
4028 if (instack[i].fname != NULL) {
4033 error ("cccp error: not in any file?!");
4034 return; /* the show must go on */
4042 if (hp->type == T_FILE)
4043 string = ip->nominal_fname;
4045 string = instack[0].nominal_fname;
4049 buf = (char *) alloca (3 + 4 * strlen (string));
4050 quote_string (buf, string);
4058 case T_INCLUDE_LEVEL:
4060 for (i = indepth; i >= 0; i--)
4061 if (instack[i].fname != NULL)
4064 buf = (char *) alloca (8); /* Eight bytes ought to be more than enough */
4065 sprintf (buf, "%d", true_indepth - 1);
4069 buf = (char *) alloca (3 + strlen (version_string));
4070 sprintf (buf, "\"%s\"", version_string);
4073 #ifndef NO_BUILTIN_SIZE_TYPE
4079 #ifndef NO_BUILTIN_PTRDIFF_TYPE
4080 case T_PTRDIFF_TYPE:
4089 case T_USER_LABEL_PREFIX_TYPE:
4090 buf = USER_LABEL_PREFIX;
4093 case T_REGISTER_PREFIX_TYPE:
4094 buf = REGISTER_PREFIX;
4097 case T_IMMEDIATE_PREFIX_TYPE:
4098 buf = IMMEDIATE_PREFIX;
4102 buf = hp->value.cpval;
4103 if (pcp_inside_if && pcp_outfile)
4104 /* Output a precondition for this macro use */
4105 fprintf (pcp_outfile, "#define %s %s\n", hp->name, buf);
4109 buf = (char *) alloca (10);
4110 sprintf (buf, "%d", ip->lineno);
4115 buf = (char *) alloca (20);
4116 timebuf = timestamp ();
4117 if (hp->type == T_DATE)
4118 sprintf (buf, "\"%s %2d %4d\"", monthnames[timebuf->tm_mon],
4119 timebuf->tm_mday, timebuf->tm_year + 1900);
4121 sprintf (buf, "\"%02d:%02d:%02d\"", timebuf->tm_hour, timebuf->tm_min,
4125 case T_SPEC_DEFINED:
4126 buf = " 0 "; /* Assume symbol is not defined */
4127 ip = &instack[indepth];
4128 SKIP_WHITE_SPACE (ip->bufp);
4129 if (*ip->bufp == '(') {
4131 ip->bufp++; /* Skip over the paren */
4132 SKIP_WHITE_SPACE (ip->bufp);
4135 if (!is_idstart[*ip->bufp])
4137 if ((hp = lookup (ip->bufp, -1, -1))) {
4138 if (pcp_outfile && pcp_inside_if
4139 && (hp->type == T_CONST
4140 || (hp->type == T_MACRO && hp->value.defn->predefined)))
4141 /* Output a precondition for this macro use. */
4142 fprintf (pcp_outfile, "#define %s\n", hp->name);
4146 if (pcp_outfile && pcp_inside_if) {
4147 /* Output a precondition for this macro use */
4148 U_CHAR *cp = ip->bufp;
4149 fprintf (pcp_outfile, "#undef ");
4150 while (is_idchar[*cp]) /* Ick! */
4151 fputc (*cp++, pcp_outfile);
4152 putc ('\n', pcp_outfile);
4154 while (is_idchar[*ip->bufp])
4156 SKIP_WHITE_SPACE (ip->bufp);
4158 if (*ip->bufp != ')')
4166 error ("`defined' without an identifier");
4170 error ("cccp error: invalid special hash type"); /* time for gdb */
4174 check_expand (op, len);
4175 bcopy (buf, (char *) op->bufp, len);
4182 /* Routines to handle #directives */
4184 /* Handle #include and #import.
4185 This function expects to see "fname" or <fname> on the input. */
4188 do_include (buf, limit, op, keyword)
4189 U_CHAR *buf, *limit;
4191 struct directive *keyword;
4193 U_CHAR *importing = keyword->type == T_IMPORT ? (U_CHAR *) "" : (U_CHAR *) 0;
4194 int skip_dirs = (keyword->type == T_INCLUDE_NEXT);
4195 static int import_warning = 0;
4196 char *fname; /* Dynamically allocated fname buffer */
4199 char *fbeg, *fend; /* Beginning and end of fname */
4202 struct file_name_list *search_start = include; /* Chain of dirs to search */
4203 struct file_name_list *dsp; /* First in chain, if #include "..." */
4204 struct file_name_list *searchptr = 0;
4207 int f = -3; /* file number */
4208 struct include_file *inc = 0;
4210 int retried = 0; /* Have already tried macro
4211 expanding the include line*/
4212 int angle_brackets = 0; /* 0 for "...", 1 for <...> */
4218 if (importing && warn_import && !inhibit_warnings
4219 && !instack[indepth].system_header_p && !import_warning) {
4221 warning ("using `#import' is not recommended");
4222 fprintf (stderr, "The fact that a certain header file need not be processed more than once\n");
4223 fprintf (stderr, "should be indicated in the header file, not where it is used.\n");
4224 fprintf (stderr, "The best way to do this is with a conditional of this form:\n\n");
4225 fprintf (stderr, " #ifndef _FOO_H_INCLUDED\n");
4226 fprintf (stderr, " #define _FOO_H_INCLUDED\n");
4227 fprintf (stderr, " ... <real contents of file> ...\n");
4228 fprintf (stderr, " #endif /* Not _FOO_H_INCLUDED */\n\n");
4229 fprintf (stderr, "Then users can use `#include' any number of times.\n");
4230 fprintf (stderr, "GNU C automatically avoids processing the file more than once\n");
4231 fprintf (stderr, "when it is equipped with such a conditional.\n");
4237 SKIP_WHITE_SPACE (fin);
4238 /* Discard trailing whitespace so we can easily see
4239 if we have parsed all the significant chars we were given. */
4240 while (limit != fin && is_hor_space[limit[-1]]) limit--;
4241 fbeg = fend = (char *) alloca (limit - fin);
4247 /* Copy the operand text, concatenating the strings. */
4249 while (fin != limit) {
4250 while (fin != limit && *fin != '\"')
4255 /* If not at the end, there had better be another string. */
4256 /* Skip just horiz space, and don't go past limit. */
4257 while (fin != limit && is_hor_space[*fin]) fin++;
4258 if (fin != limit && *fin == '\"')
4265 /* We have "filename". Figure out directory this source
4266 file is coming from and put it on the front of the list. */
4268 /* If -I- was specified, don't search current dir, only spec'd ones. */
4269 if (ignore_srcdir) break;
4271 for (fp = &instack[indepth]; fp >= instack; fp--)
4276 if ((nam = fp->nominal_fname) != NULL) {
4277 /* Found a named file. Figure out dir of the file,
4278 and put it in front of the search list. */
4279 dsp = ((struct file_name_list *)
4280 alloca (sizeof (struct file_name_list) + strlen (nam)));
4281 strcpy (dsp->fname, nam);
4282 simplify_filename (dsp->fname);
4283 nam = base_name (dsp->fname);
4285 /* But for efficiency's sake, do not insert the dir
4286 if it matches the search list's first dir. */
4287 dsp->next = search_start;
4288 if (!search_start || strcmp (dsp->fname, search_start->fname)) {
4290 n = nam - dsp->fname;
4291 if (n + INCLUDE_LEN_FUDGE > max_include_len)
4292 max_include_len = n + INCLUDE_LEN_FUDGE;
4294 dsp[0].got_name_map = 0;
4302 while (fin != limit && *fin != '>')
4304 if (*fin == '>' && fin + 1 == limit) {
4306 /* If -I-, start with the first -I dir after the -I-. */
4307 search_start = first_bracket_include;
4315 * Support '#include xyz' like VAX-C to allow for easy use of all the
4316 * decwindow include files. It defaults to '#include <xyz.h>' (so the
4317 * code from case '<' is repeated here) and generates a warning.
4318 * (Note: macro expansion of `xyz' takes precedence.)
4320 if (retried && isalpha(*(U_CHAR *)(--fbeg))) {
4321 while (fin != limit && (!isspace(*fin)))
4323 warning ("VAX-C-style include specification found, use '#include <filename.h>' !");
4326 /* If -I-, start with the first -I dir after the -I-. */
4327 search_start = first_bracket_include;
4335 error ("`#%s' expects \"FILENAME\" or <FILENAME>", keyword->name);
4338 /* Expand buffer and then remove any newline markers.
4339 We can't just tell expand_to_temp_buffer to omit the markers,
4340 since it would put extra spaces in include file names. */
4343 trybuf = expand_to_temp_buffer (buf, limit, 1, 0);
4345 buf = (U_CHAR *) alloca (trybuf.bufp - trybuf.buf + 1);
4347 while (src != trybuf.bufp) {
4348 switch ((*limit++ = *src++)) {
4357 U_CHAR *src1 = skip_quoted_string (src - 1, trybuf.bufp, 0,
4358 NULL_PTR, NULL_PTR, NULL_PTR);
4372 /* For #include_next, skip in the search path
4373 past the dir in which the containing file was found. */
4376 for (fp = &instack[indepth]; fp >= instack; fp--)
4377 if (fp->fname != NULL) {
4378 /* fp->dir is null if the containing file was specified
4379 with an absolute file name. In that case, don't skip anything. */
4381 search_start = fp->dir->next;
4387 flen = simplify_filename (fbeg);
4391 error ("empty file name in `#%s'", keyword->name);
4395 /* Allocate this permanently, because it gets stored in the definitions
4397 fname = xmalloc (max_include_len + flen + 1);
4398 /* + 1 above for terminating null. */
4400 system_include_depth += angle_brackets;
4402 /* If specified file name is absolute, just open it. */
4404 if (absolute_filename (fbeg)) {
4405 strcpy (fname, fbeg);
4406 f = open_include_file (fname, NULL_PTR, importing, &inc);
4410 struct bypass_dir *next;
4412 struct file_name_list *searchptr;
4413 } **bypass_slot = 0;
4415 /* Search directory path, trying to open the file.
4416 Copy each filename tried into FNAME. */
4418 for (searchptr = search_start; searchptr; searchptr = searchptr->next) {
4420 if (searchptr == first_bracket_include) {
4421 /* Go to bypass directory if we know we've seen this file before. */
4422 static struct bypass_dir *bypass_hashtab[INCLUDE_HASHSIZE];
4423 struct bypass_dir *p;
4424 bypass_slot = &bypass_hashtab[hashf ((U_CHAR *) fbeg, flen,
4426 for (p = *bypass_slot; p; p = p->next)
4427 if (!strcmp (fbeg, p->fname)) {
4428 searchptr = p->searchptr;
4434 strcpy (fname, searchptr->fname);
4435 strcat (fname, fbeg);
4437 /* Change this 1/2 Unix 1/2 VMS file specification into a
4438 full VMS file specification */
4439 if (searchptr->fname[0]) {
4440 /* Fix up the filename */
4441 hack_vms_include_specification (fname);
4443 /* This is a normal VMS filespec, so use it unchanged. */
4444 strcpy (fname, fbeg);
4445 /* if it's '#include filename', add the missing .h */
4446 if (index(fname,'.')==NULL) {
4447 strcat (fname, ".h");
4451 f = open_include_file (fname, searchptr, importing, &inc);
4453 if (bypass_slot && searchptr != first_bracket_include) {
4454 /* This is the first time we found this include file,
4455 and we found it after first_bracket_include.
4456 Record its location so that we can bypass to here next time. */
4457 struct bypass_dir *p
4458 = (struct bypass_dir *) xmalloc (sizeof (struct bypass_dir));
4459 p->next = *bypass_slot;
4460 p->fname = fname + strlen (searchptr->fname);
4461 p->searchptr = searchptr;
4467 /* Our VMS hacks can produce invalid filespecs, so don't worry
4468 about errors other than EACCES. */
4469 if (errno == EACCES)
4472 if (errno != ENOENT)
4482 /* The file was already included. */
4484 /* If generating dependencies and -MG was specified, we assume missing
4485 files are leaf files, living in the same directory as the source file
4486 or other similar place; these missing files may be generated from
4487 other files and may not exist yet (eg: y.tab.h). */
4488 } else if (print_deps_missing_files
4489 && (system_include_depth != 0) < print_deps)
4491 /* If it was requested as a system header file,
4492 then assume it belongs in the first place to look for such. */
4496 char *p = (char *) alloca (strlen (search_start->fname)
4497 + strlen (fbeg) + 1);
4498 strcpy (p, search_start->fname);
4500 deps_output (p, ' ');
4505 /* Otherwise, omit the directory, as if the file existed
4506 in the directory with the source. */
4507 deps_output (fbeg, ' ');
4510 /* If -M was specified, and this header file won't be added to the
4511 dependency list, then don't count this as an error, because we can
4512 still produce correct output. Otherwise, we can't produce correct
4513 output, because there may be dependencies we need inside the missing
4514 file, and we don't know what directory this missing file exists in. */
4515 else if (0 < print_deps && print_deps <= (system_include_depth != 0))
4516 warning ("No include path in which to find %s", fbeg);
4518 error_from_errno (fbeg);
4520 error ("No include path in which to find %s", fbeg);
4524 /* Actually process the file. */
4526 pcftry = (char *) alloca (strlen (fname) + 30);
4533 sprintf (pcftry, "%s%d", fname, pcfnum++);
4535 pcf = open (pcftry, O_RDONLY, 0666);
4540 if (fstat (pcf, &s) != 0)
4541 pfatal_with_name (pcftry);
4542 if (! INO_T_EQ (inc->st.st_ino, s.st_ino)
4543 || inc->st.st_dev != s.st_dev)
4545 pcfbuf = check_precompiled (pcf, &s, fname, &pcfbuflimit);
4546 /* Don't need it any more. */
4551 /* Don't need it at all. */
4556 } while (pcf != -1 && !pcfbuf);
4559 /* Actually process the file */
4561 pcfname = xmalloc (strlen (pcftry) + 1);
4562 strcpy (pcfname, pcftry);
4563 pcfinclude ((U_CHAR *) pcfbuf, (U_CHAR *) pcfbuflimit,
4564 (U_CHAR *) fname, op);
4567 finclude (f, inc, op, is_system_include (fname), searchptr);
4570 system_include_depth -= angle_brackets;
4575 /* Return nonzero if the given FILENAME is an absolute pathname which
4576 designates a file within one of the known "system" include file
4577 directories. We assume here that if the given FILENAME looks like
4578 it is the name of a file which resides either directly in a "system"
4579 include file directory, or within any subdirectory thereof, then the
4580 given file must be a "system" include file. This function tells us
4581 if we should suppress pedantic errors/warnings for the given FILENAME.
4583 The value is 2 if the file is a C-language system header file
4584 for which C++ should (on most systems) assume `extern "C"'. */
4587 is_system_include (filename)
4588 register char *filename;
4590 struct file_name_list *searchptr;
4592 for (searchptr = first_system_include; searchptr;
4593 searchptr = searchptr->next)
4594 if (! strncmp (searchptr->fname, filename, strlen (searchptr->fname)))
4595 return searchptr->c_system_include_path + 1;
4599 /* Yield the non-directory suffix of a file name. */
4607 #if defined (__MSDOS__) || defined (_WIN32)
4608 if (isalpha (s[0]) && s[1] == ':') s += 2;
4611 if ((p = rindex (s, ':'))) s = p + 1; /* Skip device. */
4612 if ((p = rindex (s, ']'))) s = p + 1; /* Skip directory. */
4613 if ((p = rindex (s, '>'))) s = p + 1; /* Skip alternate (int'n'l) dir. */
4617 if ((p = rindex (s, '/'))) s = p + 1;
4618 #ifdef DIR_SEPARATOR
4619 if ((p = rindex (s, DIR_SEPARATOR))) s = p + 1;
4624 /* Yield nonzero if FILENAME is absolute (i.e. not relative). */
4626 absolute_filename (filename)
4629 #if defined (__MSDOS__) || defined (_WIN32)
4630 if (isalpha (filename[0]) && filename[1] == ':') filename += 2;
4632 if (filename[0] == '/') return 1;
4633 #ifdef DIR_SEPARATOR
4634 if (filename[0] == DIR_SEPARATOR) return 1;
4639 /* Remove unnecessary characters from FILENAME in place,
4640 to avoid unnecessary filename aliasing.
4641 Return the length of the resulting string.
4643 Do only the simplifications allowed by Posix.
4644 It is OK to miss simplifications on non-Posix hosts,
4645 since this merely leads to suboptimial results. */
4648 simplify_filename (filename)
4651 register char *from = filename;
4652 register char *to = filename;
4655 /* Remove redundant initial /s. */
4658 if (*++from == '/') {
4659 if (*++from == '/') {
4660 /* 3 or more initial /s are equivalent to 1 /. */
4661 while (*++from == '/')
4664 /* On some hosts // differs from /; Posix allows this. */
4665 static int slashslash_vs_slash;
4666 if (slashslash_vs_slash == 0) {
4668 slashslash_vs_slash = ((stat ("/", &s1) == 0 && stat ("//", &s2) == 0
4669 && INO_T_EQ (s1.st_ino, s2.st_ino)
4670 && s1.st_dev == s2.st_dev)
4673 if (slashslash_vs_slash < 0)
4681 if (from[0] == '.' && from[1] == '/')
4684 /* Copy this component and trailing /, if any. */
4685 while ((*to++ = *from++) != '/') {
4687 /* Trim . component at end of nonempty name. */
4688 to -= filename <= to - 3 && to[-3] == '/' && to[-2] == '.';
4690 /* Trim unnecessary trailing /s. */
4691 while (to0 < --to && to[-1] == '/')
4695 return to - filename;
4700 /* Skip /s after a /. */
4701 while (*from == '/')
4706 /* The file_name_map structure holds a mapping of file names for a
4707 particular directory. This mapping is read from the file named
4708 FILE_NAME_MAP_FILE in that directory. Such a file can be used to
4709 map filenames on a file system with severe filename restrictions,
4710 such as DOS. The format of the file name map file is just a series
4711 of lines with two tokens on each line. The first token is the name
4712 to map, and the second token is the actual name to use. */
4714 struct file_name_map
4716 struct file_name_map *map_next;
4721 #define FILE_NAME_MAP_FILE "header.gcc"
4723 /* Read a space delimited string of unlimited length from a stdio
4727 read_filename_string (ch, f)
4735 set = alloc = xmalloc (len + 1);
4739 while ((ch = getc (f)) != EOF && ! is_space[ch])
4741 if (set - alloc == len)
4744 alloc = xrealloc (alloc, len + 1);
4745 set = alloc + len / 2;
4755 /* Read the file name map file for DIRNAME.
4756 If DIRNAME is empty, read the map file for the working directory;
4757 otherwise DIRNAME must end in '/'. */
4759 static struct file_name_map *
4760 read_name_map (dirname)
4763 /* This structure holds a linked list of file name maps, one per
4765 struct file_name_map_list
4767 struct file_name_map_list *map_list_next;
4768 char *map_list_name;
4769 struct file_name_map *map_list_map;
4771 static struct file_name_map_list *map_list;
4772 register struct file_name_map_list *map_list_ptr;
4777 for (map_list_ptr = map_list; map_list_ptr;
4778 map_list_ptr = map_list_ptr->map_list_next)
4779 if (! strcmp (map_list_ptr->map_list_name, dirname))
4780 return map_list_ptr->map_list_map;
4782 map_list_ptr = ((struct file_name_map_list *)
4783 xmalloc (sizeof (struct file_name_map_list)));
4784 map_list_ptr->map_list_name = savestring (dirname);
4785 map_list_ptr->map_list_map = NULL;
4787 dirlen = strlen (dirname);
4788 name = (char *) alloca (dirlen + strlen (FILE_NAME_MAP_FILE) + 1);
4789 strcpy (name, dirname);
4790 strcat (name, FILE_NAME_MAP_FILE);
4791 f = fopen (name, "r");
4793 map_list_ptr->map_list_map = NULL;
4798 while ((ch = getc (f)) != EOF)
4801 struct file_name_map *ptr;
4806 from = read_filename_string (ch, f);
4807 while ((ch = getc (f)) != EOF && is_hor_space[ch])
4809 to = read_filename_string (ch, f);
4811 simplify_filename (from);
4812 tolen = simplify_filename (to);
4814 ptr = ((struct file_name_map *)
4815 xmalloc (sizeof (struct file_name_map)));
4816 ptr->map_from = from;
4818 /* Make the real filename absolute. */
4819 if (absolute_filename (to))
4823 ptr->map_to = xmalloc (dirlen + tolen + 1);
4824 strcpy (ptr->map_to, dirname);
4825 strcat (ptr->map_to, to);
4829 ptr->map_next = map_list_ptr->map_list_map;
4830 map_list_ptr->map_list_map = ptr;
4832 while ((ch = getc (f)) != '\n')
4839 map_list_ptr->map_list_next = map_list;
4840 map_list = map_list_ptr;
4842 return map_list_ptr->map_list_map;
4845 /* Try to open include file FILENAME. SEARCHPTR is the directory
4846 being tried from the include file search path.
4847 IMPORTING is "" if we are importing, null otherwise.
4848 Return -2 if found, either a matching name or a matching inode.
4849 Otherwise, open the file and return a file descriptor if successful
4850 or -1 if unsuccessful.
4851 Unless unsuccessful, put a descriptor of the included file into *PINC.
4852 This function maps filenames on file systems based on information read by
4856 open_include_file (filename, searchptr, importing, pinc)
4858 struct file_name_list *searchptr;
4860 struct include_file **pinc;
4862 char *fname = remap_include_file (filename, searchptr);
4865 /* Look up FNAME in include_hashtab. */
4866 struct include_file **phead = &include_hashtab[hashf ((U_CHAR *) fname,
4869 struct include_file *inc, *head = *phead;
4870 for (inc = head; inc; inc = inc->next)
4871 if (!strcmp (fname, inc->fname))
4875 || ! inc->control_macro
4876 || (inc->control_macro[0] && ! lookup (inc->control_macro, -1, -1))) {
4878 fd = open (fname, O_RDONLY, 0);
4884 /* FNAME was not in include_hashtab; insert a new entry. */
4885 inc = (struct include_file *) xmalloc (sizeof (struct include_file));
4888 inc->control_macro = 0;
4889 inc->deps_output = 0;
4890 if (fstat (fd, &inc->st) != 0)
4891 pfatal_with_name (fname);
4894 /* Look for another file with the same inode and device. */
4895 if (lookup_ino_include (inc)
4896 && inc->control_macro
4897 && (!inc->control_macro[0] || lookup (inc->control_macro, -1, -1))) {
4903 /* For -M, add this file to the dependencies. */
4904 if (! inc->deps_output && (system_include_depth != 0) < print_deps) {
4905 inc->deps_output = 1;
4906 deps_output (fname, ' ');
4909 /* Handle -H option. */
4910 if (print_include_names)
4911 fprintf (stderr, "%*s%s\n", indepth, "", fname);
4915 inc->control_macro = importing;
4921 /* Return the remapped name of the the include file FILENAME.
4922 SEARCHPTR is the directory being tried from the include file path. */
4925 remap_include_file (filename, searchptr)
4927 struct file_name_list *searchptr;
4929 register struct file_name_map *map;
4930 register char *from;
4934 if (! searchptr->got_name_map)
4936 searchptr->name_map = read_name_map (searchptr->fname);
4937 searchptr->got_name_map = 1;
4940 /* Check the mapping for the directory we are using. */
4941 from = filename + strlen (searchptr->fname);
4942 for (map = searchptr->name_map; map; map = map->map_next)
4943 if (! strcmp (map->map_from, from))
4947 from = base_name (filename);
4949 if (from != filename || !searchptr)
4951 /* Try to find a mapping file for the particular directory we are
4952 looking in. Thus #include <sys/types.h> will look up sys/types.h
4953 in /usr/include/header.gcc and look up types.h in
4954 /usr/include/sys/header.gcc. */
4956 char *dir = (char *) alloca (from - filename + 1);
4957 bcopy (filename, dir, from - filename);
4958 dir[from - filename] = '\0';
4960 for (map = read_name_map (dir); map; map = map->map_next)
4961 if (! strcmp (map->map_from, from))
4968 /* Insert INC into the include file table, hashed by device and inode number.
4969 If a file with different name but same dev+ino was already in the table,
4970 return 1 and set INC's control macro to the already-known macro. */
4973 lookup_ino_include (inc)
4974 struct include_file *inc;
4976 int hash = ((unsigned) (inc->st.st_dev + INO_T_HASH (inc->st.st_ino))
4977 % INCLUDE_HASHSIZE);
4978 struct include_file *i = include_ino_hashtab[hash];
4980 include_ino_hashtab[hash] = inc;
4982 for (; i; i = i->next_ino)
4983 if (INO_T_EQ (inc->st.st_ino, i->st.st_ino)
4984 && inc->st.st_dev == i->st.st_dev) {
4985 inc->control_macro = i->control_macro;
4992 /* Process file descriptor F, which corresponds to include file INC,
4994 SYSTEM_HEADER_P is 1 if this file resides in any one of the known
4995 "system" include directories (as decided by the `is_system_include'
4997 DIRPTR is the link in the dir path through which this file was found,
4998 or 0 if the file name was absolute. */
5001 finclude (f, inc, op, system_header_p, dirptr)
5003 struct include_file *inc;
5005 int system_header_p;
5006 struct file_name_list *dirptr;
5008 char *fname = inc->fname;
5010 FILE_BUF *fp; /* For input stack frame */
5011 int missing_newline = 0;
5013 CHECK_DEPTH (return;);
5015 fp = &instack[indepth + 1];
5016 bzero ((char *) fp, sizeof (FILE_BUF));
5017 fp->nominal_fname = fp->fname = fname;
5021 fp->if_stack = if_stack;
5022 fp->system_header_p = system_header_p;
5025 if (S_ISREG (inc->st.st_mode)) {
5026 fp->buf = (U_CHAR *) xmalloc (inc->st.st_size + 2);
5029 /* Read the file contents, knowing that inc->st.st_size is an upper bound
5030 on the number of bytes we can read. */
5031 fp->length = safe_read (f, (char *) fp->buf, inc->st.st_size);
5032 if (fp->length < 0) goto nope;
5034 else if (S_ISDIR (inc->st.st_mode)) {
5035 error ("directory `%s' specified in #include", fname);
5039 /* Cannot count its file size before reading.
5040 First read the entire file into heap and
5041 copy them into buffer on stack. */
5046 fp->buf = (U_CHAR *) xmalloc (bsize + 2);
5049 i = safe_read (f, (char *) fp->buf + st_size, bsize - st_size);
5051 goto nope; /* error! */
5053 if (st_size != bsize)
5054 break; /* End of file */
5056 fp->buf = (U_CHAR *) xrealloc (fp->buf, bsize + 2);
5059 fp->length = st_size;
5062 if ((fp->length > 0 && fp->buf[fp->length - 1] != '\n')
5063 /* Backslash-newline at end is not good enough. */
5064 || (fp->length > 1 && fp->buf[fp->length - 2] == '\\')) {
5065 fp->buf[fp->length++] = '\n';
5066 missing_newline = 1;
5068 fp->buf[fp->length] = '\0';
5070 /* Close descriptor now, so nesting does not use lots of descriptors. */
5073 /* Must do this before calling trigraph_pcp, so that the correct file name
5074 will be printed in warning messages. */
5077 input_file_stack_tick++;
5082 output_line_directive (fp, op, 0, enter_file);
5085 if (missing_newline)
5088 if (pedantic && missing_newline)
5089 pedwarn ("file does not end in newline");
5092 input_file_stack_tick++;
5093 output_line_directive (&instack[indepth], op, 0, leave_file);
5099 perror_with_name (fname);
5104 /* Record that inclusion of the include file INC
5105 should be controlled by the macro named MACRO_NAME.
5106 This means that trying to include the file again
5107 will do something if that macro is defined. */
5110 record_control_macro (inc, macro_name)
5111 struct include_file *inc;
5114 if (!inc->control_macro || inc->control_macro[0])
5115 inc->control_macro = macro_name;
5118 /* Load the specified precompiled header into core, and verify its
5119 preconditions. PCF indicates the file descriptor to read, which must
5120 be a regular file. *ST is its file status.
5121 FNAME indicates the file name of the original header.
5122 *LIMIT will be set to an address one past the end of the file.
5123 If the preconditions of the file are not satisfied, the buffer is
5124 freed and we return 0. If the preconditions are satisfied, return
5125 the address of the buffer following the preconditions. The buffer, in
5126 this case, should never be freed because various pieces of it will
5127 be referred to until all precompiled strings are output at the end of
5131 check_precompiled (pcf, st, fname, limit)
5144 if (S_ISREG (st->st_mode))
5146 buf = xmalloc (st->st_size + 2);
5147 length = safe_read (pcf, buf, st->st_size);
5154 if (length > 0 && buf[length-1] != '\n')
5155 buf[length++] = '\n';
5158 *limit = buf + length;
5160 /* File is in core. Check the preconditions. */
5161 if (!check_preconditions (buf))
5163 for (cp = buf; *cp; cp++)
5166 fprintf (stderr, "Using preinclude %s\n", fname);
5172 fprintf (stderr, "Cannot use preinclude %s\n", fname);
5178 /* PREC (null terminated) points to the preconditions of a
5179 precompiled header. These are a series of #define and #undef
5180 lines which must match the current contents of the hash
5183 check_preconditions (prec)
5190 lineend = index (prec, '\n');
5192 if (*prec++ != '#') {
5193 error ("Bad format encountered while reading precompiled file");
5196 if (!strncmp (prec, "define", 6)) {
5200 mdef = create_definition ((U_CHAR *) prec, (U_CHAR *) lineend, NULL_PTR);
5205 if ((hp = lookup (mdef.symnam, mdef.symlen, -1)) == NULL
5206 || (hp->type != T_MACRO && hp->type != T_CONST)
5207 || (hp->type == T_MACRO
5208 && !compare_defs (mdef.defn, hp->value.defn)
5209 && (mdef.defn->length != 2
5210 || mdef.defn->expansion[0] != '\n'
5211 || mdef.defn->expansion[1] != ' ')))
5213 } else if (!strncmp (prec, "undef", 5)) {
5218 while (is_hor_space[(U_CHAR) *prec])
5221 while (is_idchar[(U_CHAR) *prec])
5225 if (lookup ((U_CHAR *) name, len, -1))
5228 error ("Bad format encountered while reading precompiled file");
5233 /* They all passed successfully */
5237 /* Process the main body of a precompiled file. BUF points to the
5238 string section of the file, following the preconditions. LIMIT is one
5239 character past the end. NAME is the name of the file being read
5240 in. OP is the main output buffer */
5242 pcfinclude (buf, limit, name, op)
5243 U_CHAR *buf, *limit, *name;
5250 /* First in the file comes 4 bytes indicating the number of strings, */
5251 /* in network byte order. (MSB first). */
5253 nstrings = (nstrings << 8) | *cp++;
5254 nstrings = (nstrings << 8) | *cp++;
5255 nstrings = (nstrings << 8) | *cp++;
5257 /* Looping over each string... */
5258 while (nstrings--) {
5259 U_CHAR *string_start;
5260 U_CHAR *endofthiskey;
5264 /* Each string starts with a STRINGDEF structure (str), followed */
5265 /* by the text of the string (string_start) */
5267 /* First skip to a longword boundary */
5268 /* ??? Why a 4-byte boundary? On all machines? */
5269 /* NOTE: This works correctly even if HOST_WIDE_INT
5270 is narrower than a pointer.
5271 Do not try risky measures here to get another type to use!
5272 Do not include stddef.h--it will fail! */
5273 if ((HOST_WIDE_INT) cp & 3)
5274 cp += 4 - ((HOST_WIDE_INT) cp & 3);
5276 /* Now get the string. */
5277 str = (STRINGDEF *) (GENERIC_PTR) cp;
5278 string_start = cp += sizeof (STRINGDEF);
5280 for (; *cp; cp++) /* skip the string */
5283 /* We need to macro expand the string here to ensure that the
5284 proper definition environment is in place. If it were only
5285 expanded when we find out it is needed, macros necessary for
5286 its proper expansion might have had their definitions changed. */
5287 tmpbuf = expand_to_temp_buffer (string_start, cp++, 0, 0);
5288 /* Lineno is already set in the precompiled file */
5289 str->contents = tmpbuf.buf;
5290 str->len = tmpbuf.length;
5292 str->filename = name;
5293 str->output_mark = outbuf.bufp - outbuf.buf;
5296 *stringlist_tailp = str;
5297 stringlist_tailp = &str->chain;
5299 /* Next comes a fourbyte number indicating the number of keys */
5300 /* for this string. */
5302 nkeys = (nkeys << 8) | *cp++;
5303 nkeys = (nkeys << 8) | *cp++;
5304 nkeys = (nkeys << 8) | *cp++;
5306 /* If this number is -1, then the string is mandatory. */
5310 /* Otherwise, for each key, */
5311 for (; nkeys--; free (tmpbuf.buf), cp = endofthiskey + 1) {
5312 KEYDEF *kp = (KEYDEF *) (GENERIC_PTR) cp;
5315 /* It starts with a KEYDEF structure */
5316 cp += sizeof (KEYDEF);
5318 /* Find the end of the key. At the end of this for loop we
5319 advance CP to the start of the next key using this variable. */
5320 endofthiskey = cp + strlen ((char *) cp);
5323 /* Expand the key, and enter it into the hash table. */
5324 tmpbuf = expand_to_temp_buffer (cp, endofthiskey, 0, 0);
5325 tmpbuf.bufp = tmpbuf.buf;
5327 while (is_hor_space[*tmpbuf.bufp])
5329 if (!is_idstart[*tmpbuf.bufp]
5330 || tmpbuf.bufp == tmpbuf.buf + tmpbuf.length) {
5335 hp = lookup (tmpbuf.bufp, -1, -1);
5338 install (tmpbuf.bufp, -1, T_PCSTRING, (char *) kp, -1);
5340 else if (hp->type == T_PCSTRING) {
5341 kp->chain = hp->value.keydef;
5342 hp->value.keydef = kp;
5348 /* This output_line_directive serves to switch us back to the current
5349 input file in case some of these strings get output (which will
5350 result in line directives for the header file being output). */
5351 output_line_directive (&instack[indepth], op, 0, enter_file);
5354 /* Called from rescan when it hits a key for strings. Mark them all */
5355 /* used and clean up. */
5362 for (kp = hp->value.keydef; kp; kp = kp->chain)
5363 kp->str->writeflag = 1;
5367 /* Write the output, interspersing precompiled strings in their */
5368 /* appropriate places. */
5372 STRINGDEF *next_string;
5373 U_CHAR *cur_buf_loc;
5374 int line_directive_len = 80;
5375 char *line_directive = xmalloc (line_directive_len);
5378 /* In each run through the loop, either cur_buf_loc == */
5379 /* next_string_loc, in which case we print a series of strings, or */
5380 /* it is less than next_string_loc, in which case we write some of */
5382 cur_buf_loc = outbuf.buf;
5383 next_string = stringlist;
5385 while (cur_buf_loc < outbuf.bufp || next_string) {
5387 && cur_buf_loc - outbuf.buf == next_string->output_mark) {
5388 if (next_string->writeflag) {
5389 len = 4 * strlen ((char *) next_string->filename) + 32;
5390 while (len > line_directive_len)
5391 line_directive = xrealloc (line_directive,
5392 line_directive_len *= 2);
5393 sprintf (line_directive, "\n# %d ", next_string->lineno);
5394 strcpy (quote_string (line_directive + strlen (line_directive),
5395 (char *) next_string->filename),
5397 safe_write (fileno (stdout), line_directive, strlen (line_directive));
5398 safe_write (fileno (stdout),
5399 (char *) next_string->contents, next_string->len);
5401 next_string = next_string->chain;
5405 ? (next_string->output_mark
5406 - (cur_buf_loc - outbuf.buf))
5407 : outbuf.bufp - cur_buf_loc);
5409 safe_write (fileno (stdout), (char *) cur_buf_loc, len);
5413 free (line_directive);
5416 /* Pass a directive through to the output file.
5417 BUF points to the contents of the directive, as a contiguous string.
5418 LIMIT points to the first character past the end of the directive.
5419 KEYWORD is the keyword-table entry for the directive. */
5422 pass_thru_directive (buf, limit, op, keyword)
5423 U_CHAR *buf, *limit;
5425 struct directive *keyword;
5427 register unsigned keyword_length = keyword->length;
5429 check_expand (op, 1 + keyword_length + (limit - buf));
5431 bcopy (keyword->name, (char *) op->bufp, keyword_length);
5432 op->bufp += keyword_length;
5433 if (limit != buf && buf[0] != ' ')
5435 bcopy ((char *) buf, (char *) op->bufp, limit - buf);
5436 op->bufp += (limit - buf);
5439 /* Count the line we have just made in the output,
5440 to get in sync properly. */
5445 /* The arglist structure is built by do_define to tell
5446 collect_definition where the argument names begin. That
5447 is, for a define like "#define f(x,y,z) foo+x-bar*y", the arglist
5448 would contain pointers to the strings x, y, and z.
5449 Collect_definition would then build a DEFINITION node,
5450 with reflist nodes pointing to the places x, y, and z had
5451 appeared. So the arglist is just convenience data passed
5452 between these two routines. It is not kept around after
5453 the current #define has been processed and entered into the
5457 struct arglist *next;
5464 /* Create a DEFINITION node from a #define directive. Arguments are
5465 as for do_define. */
5467 create_definition (buf, limit, op)
5468 U_CHAR *buf, *limit;
5471 U_CHAR *bp; /* temp ptr into input buffer */
5472 U_CHAR *symname; /* remember where symbol name starts */
5473 int sym_length; /* and how long it is */
5474 int line = instack[indepth].lineno;
5475 char *file = instack[indepth].nominal_fname;
5479 int arglengths = 0; /* Accumulate lengths of arg names
5480 plus number of args. */
5485 while (is_hor_space[*bp])
5488 symname = bp; /* remember where it starts */
5489 sym_length = check_macro_name (bp, "macro");
5492 /* Lossage will occur if identifiers or control keywords are broken
5493 across lines using backslash. This is not the right place to take
5497 struct arglist *arg_ptrs = NULL;
5500 bp++; /* skip '(' */
5501 SKIP_WHITE_SPACE (bp);
5503 /* Loop over macro argument names. */
5504 while (*bp != ')') {
5505 struct arglist *temp;
5507 temp = (struct arglist *) alloca (sizeof (struct arglist));
5509 temp->next = arg_ptrs;
5510 temp->argno = argno++;
5511 temp->rest_args = 0;
5515 pedwarn ("another parameter follows `%s'",
5518 if (!is_idstart[*bp])
5519 pedwarn ("invalid character in macro parameter name");
5521 /* Find the end of the arg name. */
5522 while (is_idchar[*bp]) {
5524 /* do we have a "special" rest-args extension here? */
5525 if (limit - bp > REST_EXTENSION_LENGTH &&
5526 bcmp (rest_extension, bp, REST_EXTENSION_LENGTH) == 0) {
5528 temp->rest_args = 1;
5532 temp->length = bp - temp->name;
5534 bp += REST_EXTENSION_LENGTH;
5535 arglengths += temp->length + 2;
5536 SKIP_WHITE_SPACE (bp);
5537 if (temp->length == 0 || (*bp != ',' && *bp != ')')) {
5538 error ("badly punctuated parameter list in `#define'");
5543 SKIP_WHITE_SPACE (bp);
5544 /* A comma at this point can only be followed by an identifier. */
5545 if (!is_idstart[*bp]) {
5546 error ("badly punctuated parameter list in `#define'");
5551 error ("unterminated parameter list in `#define'");
5555 struct arglist *otemp;
5557 for (otemp = temp->next; otemp != NULL; otemp = otemp->next)
5558 if (temp->length == otemp->length &&
5559 bcmp (temp->name, otemp->name, temp->length) == 0) {
5560 error ("duplicate argument name `%.*s' in `#define'",
5561 temp->length, temp->name);
5567 ++bp; /* skip paren */
5568 SKIP_WHITE_SPACE (bp);
5569 /* now everything from bp before limit is the definition. */
5570 defn = collect_expansion (bp, limit, argno, arg_ptrs);
5571 defn->rest_args = rest_args;
5573 /* Now set defn->args.argnames to the result of concatenating
5574 the argument names in reverse order
5575 with comma-space between them. */
5576 defn->args.argnames = (U_CHAR *) xmalloc (arglengths + 1);
5578 struct arglist *temp;
5580 for (temp = arg_ptrs; temp; temp = temp->next) {
5581 bcopy (temp->name, &defn->args.argnames[i], temp->length);
5583 if (temp->next != 0) {
5584 defn->args.argnames[i++] = ',';
5585 defn->args.argnames[i++] = ' ';
5588 defn->args.argnames[i] = 0;
5591 /* Simple expansion or empty definition. */
5595 if (is_hor_space[*bp]) {
5597 SKIP_WHITE_SPACE (bp);
5598 } else if (sym_length) {
5600 case '!': case '"': case '#': case '%': case '&': case '\'':
5601 case ')': case '*': case '+': case ',': case '-': case '.':
5602 case '/': case ':': case ';': case '<': case '=': case '>':
5603 case '?': case '[': case '\\': case ']': case '^': case '{':
5604 case '|': case '}': case '~':
5605 warning ("missing white space after `#define %.*s'",
5606 sym_length, symname);
5610 pedwarn ("missing white space after `#define %.*s'",
5611 sym_length, symname);
5616 /* Now everything from bp before limit is the definition. */
5617 defn = collect_expansion (bp, limit, -1, NULL_PTR);
5618 defn->args.argnames = (U_CHAR *) "";
5624 /* OP is null if this is a predefinition */
5625 defn->predefined = !op;
5627 mdef.symnam = symname;
5628 mdef.symlen = sym_length;
5637 /* Process a #define directive.
5638 BUF points to the contents of the #define directive, as a contiguous string.
5639 LIMIT points to the first character past the end of the definition.
5640 KEYWORD is the keyword-table entry for #define. */
5643 do_define (buf, limit, op, keyword)
5644 U_CHAR *buf, *limit;
5646 struct directive *keyword;
5651 /* If this is a precompiler run (with -pcp) pass thru #define directives. */
5652 if (pcp_outfile && op)
5653 pass_thru_directive (buf, limit, op, keyword);
5655 mdef = create_definition (buf, limit, op);
5659 hashcode = hashf (mdef.symnam, mdef.symlen, HASHSIZE);
5663 if ((hp = lookup (mdef.symnam, mdef.symlen, hashcode)) != NULL) {
5665 /* Redefining a precompiled key is ok. */
5666 if (hp->type == T_PCSTRING)
5668 /* Redefining a macro is ok if the definitions are the same. */
5669 else if (hp->type == T_MACRO)
5670 ok = ! compare_defs (mdef.defn, hp->value.defn);
5671 /* Redefining a constant is ok with -D. */
5672 else if (hp->type == T_CONST)
5673 ok = ! done_initializing;
5674 /* Print the warning if it's not ok. */
5676 /* If we are passing through #define and #undef directives, do
5677 that for this re-definition now. */
5678 if (debug_output && op)
5679 pass_thru_directive (buf, limit, op, keyword);
5681 pedwarn ("`%.*s' redefined", mdef.symlen, mdef.symnam);
5682 if (hp->type == T_MACRO)
5683 pedwarn_with_file_and_line (hp->value.defn->file, hp->value.defn->line,
5684 "this is the location of the previous definition");
5686 /* Replace the old definition. */
5688 hp->value.defn = mdef.defn;
5690 /* If we are passing through #define and #undef directives, do
5691 that for this new definition now. */
5692 if (debug_output && op)
5693 pass_thru_directive (buf, limit, op, keyword);
5694 install (mdef.symnam, mdef.symlen, T_MACRO,
5695 (char *) mdef.defn, hashcode);
5706 /* Check a purported macro name SYMNAME, and yield its length.
5707 USAGE is the kind of name this is intended for. */
5710 check_macro_name (symname, usage)
5717 for (p = symname; is_idchar[*p]; p++)
5719 sym_length = p - symname;
5720 if (sym_length == 0)
5721 error ("invalid %s name", usage);
5722 else if (!is_idstart[*symname]
5723 || (sym_length == 7 && ! bcmp (symname, "defined", 7)))
5724 error ("invalid %s name `%.*s'", usage, sym_length, symname);
5729 * return zero if two DEFINITIONs are isomorphic
5732 compare_defs (d1, d2)
5733 DEFINITION *d1, *d2;
5735 register struct reflist *a1, *a2;
5736 register U_CHAR *p1 = d1->expansion;
5737 register U_CHAR *p2 = d2->expansion;
5740 if (d1->nargs != d2->nargs)
5742 if (strcmp ((char *)d1->args.argnames, (char *)d2->args.argnames))
5744 for (a1 = d1->pattern, a2 = d2->pattern; a1 && a2;
5745 a1 = a1->next, a2 = a2->next) {
5746 if (!((a1->nchars == a2->nchars && ! bcmp (p1, p2, a1->nchars))
5747 || ! comp_def_part (first, p1, a1->nchars, p2, a2->nchars, 0))
5748 || a1->argno != a2->argno
5749 || a1->stringify != a2->stringify
5750 || a1->raw_before != a2->raw_before
5751 || a1->raw_after != a2->raw_after)
5759 if (comp_def_part (first, p1, d1->length - (p1 - d1->expansion),
5760 p2, d2->length - (p2 - d2->expansion), 1))
5765 /* Return 1 if two parts of two macro definitions are effectively different.
5766 One of the parts starts at BEG1 and has LEN1 chars;
5767 the other has LEN2 chars at BEG2.
5768 Any sequence of whitespace matches any other sequence of whitespace.
5769 FIRST means these parts are the first of a macro definition;
5770 so ignore leading whitespace entirely.
5771 LAST means these parts are the last of a macro definition;
5772 so ignore trailing whitespace entirely. */
5775 comp_def_part (first, beg1, len1, beg2, len2, last)
5777 U_CHAR *beg1, *beg2;
5781 register U_CHAR *end1 = beg1 + len1;
5782 register U_CHAR *end2 = beg2 + len2;
5784 while (beg1 != end1 && is_space[*beg1]) beg1++;
5785 while (beg2 != end2 && is_space[*beg2]) beg2++;
5788 while (beg1 != end1 && is_space[end1[-1]]) end1--;
5789 while (beg2 != end2 && is_space[end2[-1]]) end2--;
5791 while (beg1 != end1 && beg2 != end2) {
5792 if (is_space[*beg1] && is_space[*beg2]) {
5793 while (beg1 != end1 && is_space[*beg1]) beg1++;
5794 while (beg2 != end2 && is_space[*beg2]) beg2++;
5795 } else if (*beg1 == *beg2) {
5799 return (beg1 != end1) || (beg2 != end2);
5802 /* Read a replacement list for a macro with parameters.
5803 Build the DEFINITION structure.
5804 Reads characters of text starting at BUF until END.
5805 ARGLIST specifies the formal parameters to look for
5806 in the text of the definition; NARGS is the number of args
5807 in that list, or -1 for a macro name that wants no argument list.
5808 MACRONAME is the macro name itself (so we can avoid recursive expansion)
5809 and NAMELEN is its length in characters.
5811 Note that comments, backslash-newlines, and leading white space
5812 have already been deleted from the argument. */
5814 /* If there is no trailing whitespace, a Newline Space is added at the end
5815 to prevent concatenation that would be contrary to the standard. */
5818 collect_expansion (buf, end, nargs, arglist)
5821 struct arglist *arglist;
5824 register U_CHAR *p, *limit, *lastp, *exp_p;
5825 struct reflist *endpat = NULL;
5826 /* Pointer to first nonspace after last ## seen. */
5828 /* Pointer to first nonspace after last single-# seen. */
5829 U_CHAR *stringify = 0;
5830 /* How those tokens were spelled. */
5831 enum sharp_token_type concat_sharp_token_type = NO_SHARP_TOKEN;
5832 enum sharp_token_type stringify_sharp_token_type = NO_SHARP_TOKEN;
5834 int expected_delimiter = '\0';
5836 /* Scan thru the replacement list, ignoring comments and quoted
5837 strings, picking up on the macro calls. It does a linear search
5838 thru the arg list on every potential symbol. Profiling might say
5839 that something smarter should happen. */
5844 /* Find the beginning of the trailing whitespace. */
5847 while (p < limit && is_space[limit[-1]]) limit--;
5849 /* Allocate space for the text in the macro definition.
5850 Each input char may or may not need 1 byte,
5851 so this is an upper bound.
5852 The extra 3 are for invented trailing newline-marker and final null. */
5853 maxsize = (sizeof (DEFINITION)
5855 defn = (DEFINITION *) xcalloc (1, maxsize);
5857 defn->nargs = nargs;
5858 exp_p = defn->expansion = (U_CHAR *) defn + sizeof (DEFINITION);
5863 : p[0] == '%' && p[1] == ':' && p[2] == '%' && p[3] == ':') {
5864 error ("`##' at start of macro definition");
5865 p += p[0] == '#' ? 2 : 4;
5868 /* Process the main body of the definition. */
5870 int skipped_arg = 0;
5871 register U_CHAR c = *p++;
5879 if (expected_delimiter != '\0') {
5880 if (c == expected_delimiter)
5881 expected_delimiter = '\0';
5883 expected_delimiter = c;
5887 if (p < limit && expected_delimiter) {
5888 /* In a string, backslash goes through
5889 and makes next char ordinary. */
5895 if (!expected_delimiter && *p == ':') {
5896 /* %: is not a digraph if preceded by an odd number of '<'s. */
5898 while (buf < p0 && p0[-1] == '<')
5901 /* Treat %:%: as ## and %: as #. */
5902 if (p[1] == '%' && p[2] == ':') {
5904 goto sharp_sharp_token;
5915 /* # is ordinary inside a string. */
5916 if (expected_delimiter)
5920 /* ##: concatenate preceding and following tokens. */
5921 /* Take out the first #, discard preceding whitespace. */
5923 while (exp_p > lastp && is_hor_space[exp_p[-1]])
5925 /* Skip the second #. */
5927 concat_sharp_token_type = c;
5928 if (is_hor_space[*p]) {
5929 concat_sharp_token_type = c + 1;
5931 SKIP_WHITE_SPACE (p);
5935 error ("`##' at end of macro definition");
5936 } else if (nargs >= 0) {
5937 /* Single #: stringify following argument ref.
5938 Don't leave the # in the expansion. */
5941 stringify_sharp_token_type = c;
5942 if (is_hor_space[*p]) {
5943 stringify_sharp_token_type = c + 1;
5945 SKIP_WHITE_SPACE (p);
5947 if (! is_idstart[*p] || nargs == 0)
5948 error ("`#' operator is not followed by a macro argument name");
5955 /* In -traditional mode, recognize arguments inside strings and
5956 and character constants, and ignore special properties of #.
5957 Arguments inside strings are considered "stringified", but no
5958 extra quote marks are supplied. */
5962 if (expected_delimiter != '\0') {
5963 if (c == expected_delimiter)
5964 expected_delimiter = '\0';
5966 expected_delimiter = c;
5970 /* Backslash quotes delimiters and itself, but not macro args. */
5971 if (expected_delimiter != 0 && p < limit
5972 && (*p == expected_delimiter || *p == '\\')) {
5979 if (expected_delimiter != '\0') /* No comments inside strings. */
5982 /* If we find a comment that wasn't removed by handle_directive,
5983 this must be -traditional. So replace the comment with
5986 while (++p < limit) {
5987 if (p[0] == '*' && p[1] == '/') {
5993 /* Mark this as a concatenation-point, as if it had been ##. */
6001 /* Handle the start of a symbol. */
6002 if (is_idchar[c] && nargs > 0) {
6003 U_CHAR *id_beg = p - 1;
6007 while (p != limit && is_idchar[*p]) p++;
6008 id_len = p - id_beg;
6010 if (is_idstart[c]) {
6011 register struct arglist *arg;
6013 for (arg = arglist; arg != NULL; arg = arg->next) {
6014 struct reflist *tpat;
6016 if (arg->name[0] == c
6017 && arg->length == id_len
6018 && bcmp (arg->name, id_beg, id_len) == 0) {
6019 enum sharp_token_type tpat_stringify;
6020 if (expected_delimiter) {
6021 if (warn_stringify) {
6023 warning ("macro argument `%.*s' is stringified.",
6026 warning ("macro arg `%.*s' would be stringified with -traditional.",
6030 /* If ANSI, don't actually substitute inside a string. */
6033 tpat_stringify = SHARP_TOKEN;
6036 = (stringify == id_beg
6037 ? stringify_sharp_token_type : NO_SHARP_TOKEN);
6039 /* make a pat node for this arg and append it to the end of
6041 tpat = (struct reflist *) xmalloc (sizeof (struct reflist));
6044 = concat == id_beg ? concat_sharp_token_type : NO_SHARP_TOKEN;
6045 tpat->raw_after = NO_SHARP_TOKEN;
6046 tpat->rest_args = arg->rest_args;
6047 tpat->stringify = tpat_stringify;
6050 defn->pattern = tpat;
6052 endpat->next = tpat;
6055 tpat->argno = arg->argno;
6056 tpat->nchars = exp_p - lastp;
6058 register U_CHAR *p1 = p;
6059 SKIP_WHITE_SPACE (p1);
6062 : p1[0]=='%' && p1[1]==':' && p1[2]=='%' && p1[3]==':')
6063 tpat->raw_after = p1[0] + (p != p1);
6065 lastp = exp_p; /* place to start copying from next time */
6072 /* If this was not a macro arg, copy it into the expansion. */
6073 if (! skipped_arg) {
6074 register U_CHAR *lim1 = p;
6078 if (stringify == id_beg)
6079 error ("`#' operator should be followed by a macro argument name");
6084 if (!traditional && expected_delimiter == 0) {
6085 /* If ANSI, put in a newline-space marker to prevent token pasting.
6086 But not if "inside a string" (which in ANSI mode happens only for
6094 defn->length = exp_p - defn->expansion;
6096 /* Crash now if we overrun the allocated size. */
6097 if (defn->length + 1 > maxsize)
6101 /* This isn't worth the time it takes. */
6102 /* give back excess storage */
6103 defn->expansion = (U_CHAR *) xrealloc (defn->expansion, defn->length + 1);
6110 do_assert (buf, limit, op, keyword)
6111 U_CHAR *buf, *limit;
6113 struct directive *keyword;
6115 U_CHAR *bp; /* temp ptr into input buffer */
6116 U_CHAR *symname; /* remember where symbol name starts */
6117 int sym_length; /* and how long it is */
6118 struct arglist *tokens = NULL;
6120 if (pedantic && done_initializing && !instack[indepth].system_header_p)
6121 pedwarn ("ANSI C does not allow `#assert'");
6125 while (is_hor_space[*bp])
6128 symname = bp; /* remember where it starts */
6129 sym_length = check_macro_name (bp, "assertion");
6131 /* #define doesn't do this, but we should. */
6132 SKIP_WHITE_SPACE (bp);
6134 /* Lossage will occur if identifiers or control tokens are broken
6135 across lines using backslash. This is not the right place to take
6139 error ("missing token-sequence in `#assert'");
6146 bp++; /* skip '(' */
6147 SKIP_WHITE_SPACE (bp);
6149 tokens = read_token_list (&bp, limit, &error_flag);
6153 error ("empty token-sequence in `#assert'");
6157 ++bp; /* skip paren */
6158 SKIP_WHITE_SPACE (bp);
6161 /* If this name isn't already an assertion name, make it one.
6162 Error if it was already in use in some other way. */
6165 ASSERTION_HASHNODE *hp;
6166 int hashcode = hashf (symname, sym_length, ASSERTION_HASHSIZE);
6167 struct tokenlist_list *value
6168 = (struct tokenlist_list *) xmalloc (sizeof (struct tokenlist_list));
6170 hp = assertion_lookup (symname, sym_length, hashcode);
6172 if (sym_length == 7 && ! bcmp (symname, "defined", 7))
6173 error ("`defined' redefined as assertion");
6174 hp = assertion_install (symname, sym_length, hashcode);
6177 /* Add the spec'd token-sequence to the list of such. */
6178 value->tokens = tokens;
6179 value->next = hp->value;
6187 do_unassert (buf, limit, op, keyword)
6188 U_CHAR *buf, *limit;
6190 struct directive *keyword;
6192 U_CHAR *bp; /* temp ptr into input buffer */
6193 U_CHAR *symname; /* remember where symbol name starts */
6194 int sym_length; /* and how long it is */
6196 struct arglist *tokens = NULL;
6197 int tokens_specified = 0;
6199 if (pedantic && done_initializing && !instack[indepth].system_header_p)
6200 pedwarn ("ANSI C does not allow `#unassert'");
6204 while (is_hor_space[*bp])
6207 symname = bp; /* remember where it starts */
6208 sym_length = check_macro_name (bp, "assertion");
6210 /* #define doesn't do this, but we should. */
6211 SKIP_WHITE_SPACE (bp);
6213 /* Lossage will occur if identifiers or control tokens are broken
6214 across lines using backslash. This is not the right place to take
6220 bp++; /* skip '(' */
6221 SKIP_WHITE_SPACE (bp);
6223 tokens = read_token_list (&bp, limit, &error_flag);
6227 error ("empty token list in `#unassert'");
6231 tokens_specified = 1;
6233 ++bp; /* skip paren */
6234 SKIP_WHITE_SPACE (bp);
6238 ASSERTION_HASHNODE *hp;
6239 int hashcode = hashf (symname, sym_length, ASSERTION_HASHSIZE);
6240 struct tokenlist_list *tail, *prev;
6242 hp = assertion_lookup (symname, sym_length, hashcode);
6246 /* If no token list was specified, then eliminate this assertion
6248 if (! tokens_specified) {
6249 struct tokenlist_list *next;
6250 for (tail = hp->value; tail; tail = next) {
6252 free_token_list (tail->tokens);
6255 delete_assertion (hp);
6257 /* If a list of tokens was given, then delete any matching list. */
6262 struct tokenlist_list *next = tail->next;
6263 if (compare_token_lists (tail->tokens, tokens)) {
6267 hp->value = tail->next;
6268 free_token_list (tail->tokens);
6281 /* Test whether there is an assertion named NAME
6282 and optionally whether it has an asserted token list TOKENS.
6283 NAME is not null terminated; its length is SYM_LENGTH.
6284 If TOKENS_SPECIFIED is 0, then don't check for any token list. */
6287 check_assertion (name, sym_length, tokens_specified, tokens)
6290 int tokens_specified;
6291 struct arglist *tokens;
6293 ASSERTION_HASHNODE *hp;
6294 int hashcode = hashf (name, sym_length, ASSERTION_HASHSIZE);
6296 if (pedantic && !instack[indepth].system_header_p)
6297 pedwarn ("ANSI C does not allow testing assertions");
6299 hp = assertion_lookup (name, sym_length, hashcode);
6301 /* It is not an assertion; just return false. */
6304 /* If no token list was specified, then value is 1. */
6305 if (! tokens_specified)
6309 struct tokenlist_list *tail;
6313 /* If a list of tokens was given,
6314 then succeed if the assertion records a matching list. */
6317 if (compare_token_lists (tail->tokens, tokens))
6322 /* Fail if the assertion has no matching list. */
6327 /* Compare two lists of tokens for equality including order of tokens. */
6330 compare_token_lists (l1, l2)
6331 struct arglist *l1, *l2;
6334 if (l1->length != l2->length)
6336 if (bcmp (l1->name, l2->name, l1->length))
6342 /* Succeed if both lists end at the same time. */
6346 /* Read a space-separated list of tokens ending in a close parenthesis.
6347 Return a list of strings, in the order they were written.
6348 (In case of error, return 0 and store -1 in *ERROR_FLAG.)
6349 Parse the text starting at *BPP, and update *BPP.
6350 Don't parse beyond LIMIT. */
6352 static struct arglist *
6353 read_token_list (bpp, limit, error_flag)
6358 struct arglist *token_ptrs = 0;
6364 /* Loop over the assertion value tokens. */
6366 struct arglist *temp;
6370 /* Find the end of the token. */
6374 } else if (*bp == ')') {
6379 } else if (*bp == '"' || *bp == '\'')
6380 bp = skip_quoted_string (bp, limit, 0, NULL_PTR, NULL_PTR, &eofp);
6382 while (! is_hor_space[*bp] && *bp != '(' && *bp != ')'
6383 && *bp != '"' && *bp != '\'' && bp != limit)
6386 temp = (struct arglist *) xmalloc (sizeof (struct arglist));
6387 temp->name = (U_CHAR *) xmalloc (bp - beg + 1);
6388 bcopy ((char *) beg, (char *) temp->name, bp - beg);
6389 temp->name[bp - beg] = 0;
6390 temp->next = token_ptrs;
6392 temp->length = bp - beg;
6394 SKIP_WHITE_SPACE (bp);
6397 error ("unterminated token sequence in `#assert' or `#unassert'");
6404 /* We accumulated the names in reverse order.
6405 Now reverse them to get the proper order. */
6407 register struct arglist *prev = 0, *this, *next;
6408 for (this = token_ptrs; this; this = next) {
6418 free_token_list (tokens)
6419 struct arglist *tokens;
6422 struct arglist *next = tokens->next;
6423 free (tokens->name);
6430 * Install a name in the assertion hash table.
6432 * If LEN is >= 0, it is the length of the name.
6433 * Otherwise, compute the length by scanning the entire name.
6435 * If HASH is >= 0, it is the precomputed hash code.
6436 * Otherwise, compute the hash code.
6438 static ASSERTION_HASHNODE *
6439 assertion_install (name, len, hash)
6444 register ASSERTION_HASHNODE *hp;
6445 register int i, bucket;
6446 register U_CHAR *p, *q;
6448 i = sizeof (ASSERTION_HASHNODE) + len + 1;
6449 hp = (ASSERTION_HASHNODE *) xmalloc (i);
6451 hp->bucket_hdr = &assertion_hashtab[bucket];
6452 hp->next = assertion_hashtab[bucket];
6453 assertion_hashtab[bucket] = hp;
6455 if (hp->next != NULL)
6456 hp->next->prev = hp;
6459 hp->name = ((U_CHAR *) hp) + sizeof (ASSERTION_HASHNODE);
6462 for (i = 0; i < len; i++)
6469 * find the most recent hash node for name name (ending with first
6470 * non-identifier char) installed by install
6472 * If LEN is >= 0, it is the length of the name.
6473 * Otherwise, compute the length by scanning the entire name.
6475 * If HASH is >= 0, it is the precomputed hash code.
6476 * Otherwise, compute the hash code.
6478 static ASSERTION_HASHNODE *
6479 assertion_lookup (name, len, hash)
6484 register ASSERTION_HASHNODE *bucket;
6486 bucket = assertion_hashtab[hash];
6488 if (bucket->length == len && bcmp (bucket->name, name, len) == 0)
6490 bucket = bucket->next;
6496 delete_assertion (hp)
6497 ASSERTION_HASHNODE *hp;
6500 if (hp->prev != NULL)
6501 hp->prev->next = hp->next;
6502 if (hp->next != NULL)
6503 hp->next->prev = hp->prev;
6505 /* make sure that the bucket chain header that
6506 the deleted guy was on points to the right thing afterwards. */
6507 if (hp == *hp->bucket_hdr)
6508 *hp->bucket_hdr = hp->next;
6514 * interpret #line directive. Remembers previously seen fnames
6515 * in its very own hash table.
6517 #define FNAME_HASHSIZE 37
6520 do_line (buf, limit, op, keyword)
6521 U_CHAR *buf, *limit;
6523 struct directive *keyword;
6525 register U_CHAR *bp;
6526 FILE_BUF *ip = &instack[indepth];
6529 enum file_change_code file_change = same_file;
6531 /* Expand any macros. */
6532 tem = expand_to_temp_buffer (buf, limit, 0, 0);
6534 /* Point to macroexpanded line, which is null-terminated now. */
6536 SKIP_WHITE_SPACE (bp);
6538 if (!isdigit (*bp)) {
6539 error ("invalid format `#line' directive");
6543 /* The Newline at the end of this line remains to be processed.
6544 To put the next line at the specified line number,
6545 we must store a line number now that is one less. */
6546 new_lineno = atoi ((char *) bp) - 1;
6548 /* NEW_LINENO is one less than the actual line number here. */
6549 if (pedantic && new_lineno < 0)
6550 pedwarn ("line number out of range in `#line' directive");
6552 /* skip over the line number. */
6553 while (isdigit (*bp))
6556 #if 0 /* #line 10"foo.c" is supposed to be allowed. */
6557 if (*bp && !is_space[*bp]) {
6558 error ("invalid format `#line' directive");
6563 SKIP_WHITE_SPACE (bp);
6566 static HASHNODE *fname_table[FNAME_HASHSIZE];
6567 HASHNODE *hp, **hash_bucket;
6573 /* Turn the file name, which is a character string literal,
6574 into a null-terminated string. Do this in place. */
6577 switch ((*p++ = *bp++)) {
6579 error ("invalid format `#line' directive");
6584 char *bpc = (char *) bp;
6585 HOST_WIDE_INT c = parse_escape (&bpc, (HOST_WIDE_INT) (U_CHAR) (-1));
6586 bp = (U_CHAR *) bpc;
6599 fname_length = p - fname;
6601 SKIP_WHITE_SPACE (bp);
6604 pedwarn ("garbage at end of `#line' directive");
6606 file_change = enter_file;
6607 else if (*bp == '2')
6608 file_change = leave_file;
6609 else if (*bp == '3')
6610 ip->system_header_p = 1;
6611 else if (*bp == '4')
6612 ip->system_header_p = 2;
6614 error ("invalid format `#line' directive");
6619 SKIP_WHITE_SPACE (bp);
6621 ip->system_header_p = 1;
6623 SKIP_WHITE_SPACE (bp);
6626 ip->system_header_p = 2;
6628 SKIP_WHITE_SPACE (bp);
6631 error ("invalid format `#line' directive");
6637 &fname_table[hashf (fname, fname_length, FNAME_HASHSIZE)];
6638 for (hp = *hash_bucket; hp != NULL; hp = hp->next)
6639 if (hp->length == fname_length &&
6640 bcmp (hp->value.cpval, fname, fname_length) == 0) {
6641 ip->nominal_fname = hp->value.cpval;
6645 /* Didn't find it; cons up a new one. */
6646 hp = (HASHNODE *) xcalloc (1, sizeof (HASHNODE) + fname_length + 1);
6647 hp->next = *hash_bucket;
6650 hp->length = fname_length;
6651 ip->nominal_fname = hp->value.cpval = ((char *) hp) + sizeof (HASHNODE);
6652 bcopy (fname, hp->value.cpval, fname_length);
6655 error ("invalid format `#line' directive");
6659 ip->lineno = new_lineno;
6660 output_line_directive (ip, op, 0, file_change);
6661 check_expand (op, ip->length - (ip->bufp - ip->buf));
6666 * remove the definition of a symbol from the symbol table.
6667 * according to un*x /lib/cpp, it is not an error to undef
6668 * something that has no definitions, so it isn't one here either.
6672 do_undef (buf, limit, op, keyword)
6673 U_CHAR *buf, *limit;
6675 struct directive *keyword;
6679 U_CHAR *orig_buf = buf;
6681 /* If this is a precompiler run (with -pcp) pass thru #undef directives. */
6682 if (pcp_outfile && op)
6683 pass_thru_directive (buf, limit, op, keyword);
6685 SKIP_WHITE_SPACE (buf);
6686 sym_length = check_macro_name (buf, "macro");
6688 while ((hp = lookup (buf, sym_length, -1)) != NULL) {
6689 /* If we are generating additional info for debugging (with -g) we
6690 need to pass through all effective #undef directives. */
6691 if (debug_output && op)
6692 pass_thru_directive (orig_buf, limit, op, keyword);
6693 if (hp->type != T_MACRO)
6694 warning ("undefining `%s'", hp->name);
6700 SKIP_WHITE_SPACE (buf);
6702 pedwarn ("garbage after `#undef' directive");
6708 * Report an error detected by the program we are processing.
6709 * Use the text of the line in the error message.
6710 * (We use error because it prints the filename & line#.)
6714 do_error (buf, limit, op, keyword)
6715 U_CHAR *buf, *limit;
6717 struct directive *keyword;
6719 int length = limit - buf;
6720 U_CHAR *copy = (U_CHAR *) xmalloc (length + 1);
6721 bcopy ((char *) buf, (char *) copy, length);
6723 SKIP_WHITE_SPACE (copy);
6724 error ("#error %s", copy);
6729 * Report a warning detected by the program we are processing.
6730 * Use the text of the line in the warning message, then continue.
6731 * (We use error because it prints the filename & line#.)
6735 do_warning (buf, limit, op, keyword)
6736 U_CHAR *buf, *limit;
6738 struct directive *keyword;
6740 int length = limit - buf;
6741 U_CHAR *copy = (U_CHAR *) xmalloc (length + 1);
6742 bcopy ((char *) buf, (char *) copy, length);
6744 SKIP_WHITE_SPACE (copy);
6745 warning ("#warning %s", copy);
6749 /* Remember the name of the current file being read from so that we can
6750 avoid ever including it again. */
6757 for (i = indepth; i >= 0; i--)
6758 if (instack[i].inc) {
6759 record_control_macro (instack[i].inc, (U_CHAR *) "");
6764 /* #ident has already been copied to the output file, so just ignore it. */
6767 do_ident (buf, limit, op, keyword)
6768 U_CHAR *buf, *limit;
6770 struct directive *keyword;
6775 /* Allow #ident in system headers, since that's not user's fault. */
6776 if (pedantic && !instack[indepth].system_header_p)
6777 pedwarn ("ANSI C does not allow `#ident'");
6779 trybuf = expand_to_temp_buffer (buf, limit, 0, 0);
6780 buf = (U_CHAR *) alloca (trybuf.bufp - trybuf.buf + 1);
6781 bcopy ((char *) trybuf.buf, (char *) buf, trybuf.bufp - trybuf.buf);
6782 limit = buf + (trybuf.bufp - trybuf.buf);
6783 len = (limit - buf);
6786 /* Output directive name. */
6787 check_expand (op, 7);
6788 bcopy ("#ident ", (char *) op->bufp, 7);
6791 /* Output the expanded argument line. */
6792 check_expand (op, len);
6793 bcopy ((char *) buf, (char *) op->bufp, len);
6799 /* #pragma and its argument line have already been copied to the output file.
6800 Just check for some recognized pragmas that need validation here. */
6803 do_pragma (buf, limit, op, keyword)
6804 U_CHAR *buf, *limit;
6806 struct directive *keyword;
6808 SKIP_WHITE_SPACE (buf);
6809 if (!strncmp ((char *) buf, "once", 4)) {
6810 /* Allow #pragma once in system headers, since that's not the user's
6812 if (!instack[indepth].system_header_p)
6813 warning ("`#pragma once' is obsolete");
6817 if (!strncmp ((char *) buf, "implementation", 14)) {
6818 /* Be quiet about `#pragma implementation' for a file only if it hasn't
6819 been included yet. */
6822 U_CHAR *p = buf + 14, *fname;
6823 SKIP_WHITE_SPACE (p);
6824 if (*p == '\n' || *p != '\"')
6828 if ((p = (U_CHAR *) index ((char *) fname, '\"')))
6831 for (h = 0; h < INCLUDE_HASHSIZE; h++) {
6832 struct include_file *inc;
6833 for (inc = include_hashtab[h]; inc; inc = inc->next) {
6834 if (!strcmp (base_name (inc->fname), (char *) fname)) {
6835 warning ("`#pragma implementation' for \"%s\" appears after its #include",fname);
6845 /* This was a fun hack, but #pragma seems to start to be useful.
6846 By failing to recognize it, we pass it through unchanged to cc1. */
6849 * the behavior of the #pragma directive is implementation defined.
6850 * this implementation defines it as follows.
6857 if (open ("/dev/tty", O_RDONLY, 0666) != 0)
6860 if (open ("/dev/tty", O_WRONLY, 0666) != 1)
6862 execl ("/usr/games/hack", "#pragma", 0);
6863 execl ("/usr/games/rogue", "#pragma", 0);
6864 execl ("/usr/new/emacs", "-f", "hanoi", "9", "-kill", 0);
6865 execl ("/usr/local/emacs", "-f", "hanoi", "9", "-kill", 0);
6867 fatal ("You are in a maze of twisty compiler features, all different");
6871 #ifdef SCCS_DIRECTIVE
6873 /* Just ignore #sccs, on systems where we define it at all. */
6876 do_sccs (buf, limit, op, keyword)
6877 U_CHAR *buf, *limit;
6879 struct directive *keyword;
6882 pedwarn ("ANSI C does not allow `#sccs'");
6886 #endif /* defined (SCCS_DIRECTIVE) */
6889 * handle #if directive by
6890 * 1) inserting special `defined' keyword into the hash table
6891 * that gets turned into 0 or 1 by special_symbol (thus,
6892 * if the luser has a symbol called `defined' already, it won't
6893 * work inside the #if directive)
6894 * 2) rescan the input into a temporary output buffer
6895 * 3) pass the output buffer to the yacc parser and collect a value
6896 * 4) clean up the mess left from steps 1 and 2.
6897 * 5) call conditional_skip to skip til the next #endif (etc.),
6898 * or not, depending on the value from step 3.
6902 do_if (buf, limit, op, keyword)
6903 U_CHAR *buf, *limit;
6905 struct directive *keyword;
6907 HOST_WIDE_INT value;
6908 FILE_BUF *ip = &instack[indepth];
6910 value = eval_if_expression (buf, limit - buf);
6911 conditional_skip (ip, value == 0, T_IF, NULL_PTR, op);
6916 * handle a #elif directive by not changing if_stack either.
6917 * see the comment above do_else.
6921 do_elif (buf, limit, op, keyword)
6922 U_CHAR *buf, *limit;
6924 struct directive *keyword;
6926 HOST_WIDE_INT value;
6927 FILE_BUF *ip = &instack[indepth];
6929 if (if_stack == instack[indepth].if_stack) {
6930 error ("`#elif' not within a conditional");
6933 if (if_stack->type != T_IF && if_stack->type != T_ELIF) {
6934 error ("`#elif' after `#else'");
6935 fprintf (stderr, " (matches line %d", if_stack->lineno);
6936 if (if_stack->fname != NULL && ip->fname != NULL &&
6937 strcmp (if_stack->fname, ip->nominal_fname) != 0)
6938 fprintf (stderr, ", file %s", if_stack->fname);
6939 fprintf (stderr, ")\n");
6941 if_stack->type = T_ELIF;
6944 if (if_stack->if_succeeded)
6945 skip_if_group (ip, 0, op);
6947 value = eval_if_expression (buf, limit - buf);
6949 skip_if_group (ip, 0, op);
6951 ++if_stack->if_succeeded; /* continue processing input */
6952 output_line_directive (ip, op, 1, same_file);
6959 * evaluate a #if expression in BUF, of length LENGTH,
6960 * then parse the result as a C expression and return the value as an int.
6962 static HOST_WIDE_INT
6963 eval_if_expression (buf, length)
6968 HASHNODE *save_defined;
6969 HOST_WIDE_INT value;
6971 save_defined = install ((U_CHAR *) "defined", -1, T_SPEC_DEFINED,
6974 temp_obuf = expand_to_temp_buffer (buf, buf + length, 0, 1);
6976 delete_macro (save_defined); /* clean up special symbol */
6978 temp_obuf.buf[temp_obuf.length] = '\n';
6979 value = parse_c_expression ((char *) temp_obuf.buf);
6981 free (temp_obuf.buf);
6987 * routine to handle ifdef/ifndef. Try to look up the symbol,
6988 * then do or don't skip to the #endif/#else/#elif depending
6989 * on what directive is actually being processed.
6993 do_xifdef (buf, limit, op, keyword)
6994 U_CHAR *buf, *limit;
6996 struct directive *keyword;
6999 FILE_BUF *ip = &instack[indepth];
7001 int start_of_file = 0;
7002 U_CHAR *control_macro = 0;
7004 /* Detect a #ifndef at start of file (not counting comments). */
7005 if (ip->fname != 0 && keyword->type == T_IFNDEF) {
7006 U_CHAR *p = ip->buf;
7007 while (p != directive_start) {
7011 /* Make no special provision for backslash-newline here; this is
7012 slower if backslash-newlines are present, but it's correct,
7013 and it's not worth it to tune for the rare backslash-newline. */
7015 && (*p == '*' || (cplusplus_comments && *p == '/'))) {
7016 /* Skip this comment. */
7018 U_CHAR *save_bufp = ip->bufp;
7020 p = skip_to_end_of_comment (ip, &junk, 1);
7021 ip->bufp = save_bufp;
7026 /* If we get here, this conditional is the beginning of the file. */
7031 /* Discard leading and trailing whitespace. */
7032 SKIP_WHITE_SPACE (buf);
7033 while (limit != buf && is_hor_space[limit[-1]]) limit--;
7035 /* Find the end of the identifier at the beginning. */
7036 for (end = buf; is_idchar[*end]; end++);
7039 skip = (keyword->type == T_IFDEF);
7041 pedwarn (end == limit ? "`#%s' with no argument"
7042 : "`#%s' argument starts with punctuation",
7047 if (! traditional) {
7048 if (isdigit (buf[0]))
7049 pedwarn ("`#%s' argument starts with a digit", keyword->name);
7050 else if (end != limit)
7051 pedwarn ("garbage at end of `#%s' argument", keyword->name);
7054 hp = lookup (buf, end-buf, -1);
7057 /* Output a precondition for this macro. */
7059 (hp->type == T_CONST
7060 || (hp->type == T_MACRO && hp->value.defn->predefined)))
7061 fprintf (pcp_outfile, "#define %s\n", hp->name);
7064 fprintf (pcp_outfile, "#undef ");
7065 while (is_idchar[*cp]) /* Ick! */
7066 fputc (*cp++, pcp_outfile);
7067 putc ('\n', pcp_outfile);
7071 skip = (hp == NULL) ^ (keyword->type == T_IFNDEF);
7072 if (start_of_file && !skip) {
7073 control_macro = (U_CHAR *) xmalloc (end - buf + 1);
7074 bcopy ((char *) buf, (char *) control_macro, end - buf);
7075 control_macro[end - buf] = 0;
7079 conditional_skip (ip, skip, T_IF, control_macro, op);
7083 /* Push TYPE on stack; then, if SKIP is nonzero, skip ahead.
7084 If this is a #ifndef starting at the beginning of a file,
7085 CONTROL_MACRO is the macro name tested by the #ifndef.
7086 Otherwise, CONTROL_MACRO is 0. */
7089 conditional_skip (ip, skip, type, control_macro, op)
7092 enum node_type type;
7093 U_CHAR *control_macro;
7096 IF_STACK_FRAME *temp;
7098 temp = (IF_STACK_FRAME *) xcalloc (1, sizeof (IF_STACK_FRAME));
7099 temp->fname = ip->nominal_fname;
7100 temp->lineno = ip->lineno;
7101 temp->next = if_stack;
7102 temp->control_macro = control_macro;
7105 if_stack->type = type;
7108 skip_if_group (ip, 0, op);
7111 ++if_stack->if_succeeded;
7112 output_line_directive (ip, &outbuf, 1, same_file);
7117 * skip to #endif, #else, or #elif. adjust line numbers, etc.
7118 * leaves input ptr at the sharp sign found.
7119 * If ANY is nonzero, return at next directive of any sort.
7122 skip_if_group (ip, any, op)
7127 register U_CHAR *bp = ip->bufp, *cp;
7128 register U_CHAR *endb = ip->buf + ip->length;
7129 struct directive *kt;
7130 IF_STACK_FRAME *save_if_stack = if_stack; /* don't pop past here */
7131 U_CHAR *beg_of_line = bp;
7132 register int ident_length;
7133 U_CHAR *ident, *after_ident;
7134 /* Save info about where the group starts. */
7135 U_CHAR *beg_of_group = bp;
7136 int beg_lineno = ip->lineno;
7138 if (output_conditionals && op != 0) {
7139 char *ptr = "#failed\n";
7140 int len = strlen (ptr);
7142 if (op->bufp > op->buf && op->bufp[-1] != '\n')
7147 check_expand (op, len);
7148 bcopy (ptr, (char *) op->bufp, len);
7151 output_line_directive (ip, op, 1, 0);
7156 case '/': /* possible comment */
7157 if (*bp == '\\' && bp[1] == '\n')
7160 || (cplusplus_comments && *bp == '/')) {
7162 bp = skip_to_end_of_comment (ip, &ip->lineno, 0);
7167 bp = skip_quoted_string (bp - 1, endb, ip->lineno, &ip->lineno,
7168 NULL_PTR, NULL_PTR);
7171 /* Char after backslash loses its special meaning. */
7174 ++ip->lineno; /* But do update the line-count. */
7183 if (beg_of_line == 0 || traditional)
7186 while (bp[0] == '\\' && bp[1] == '\n')
7192 /* # keyword: a # must be first nonblank char on the line */
7193 if (beg_of_line == 0)
7197 /* Scan from start of line, skipping whitespace, comments
7198 and backslash-newlines, and see if we reach this #.
7199 If not, this # is not special. */
7201 /* If -traditional, require # to be at beginning of line. */
7204 if (is_hor_space[*bp])
7206 else if (*bp == '\\' && bp[1] == '\n')
7208 else if (*bp == '/' && bp[1] == '*') {
7210 while (!(*bp == '*' && bp[1] == '/'))
7214 /* There is no point in trying to deal with C++ // comments here,
7215 because if there is one, then this # must be part of the
7216 comment and we would never reach here. */
7220 if (bp != ip->bufp) {
7221 bp = ip->bufp + 1; /* Reset bp to after the #. */
7225 bp = ip->bufp + 1; /* Point after the '#' */
7226 if (ip->bufp[0] == '%') {
7227 /* Skip past the ':' again. */
7228 while (*bp == '\\') {
7235 /* Skip whitespace and \-newline. */
7237 if (is_hor_space[*bp])
7239 else if (*bp == '\\' && bp[1] == '\n')
7241 else if (*bp == '/') {
7243 for (bp += 2; ; bp++) {
7246 else if (*bp == '*') {
7247 if (bp[-1] == '/' && warn_comments)
7248 warning ("`/*' within comment");
7254 } else if (bp[1] == '/' && cplusplus_comments) {
7255 for (bp += 2; ; bp++) {
7260 warning ("multiline `//' comment");
7272 /* Now find end of directive name.
7273 If we encounter a backslash-newline, exchange it with any following
7274 symbol-constituents so that we end up with a contiguous name. */
7280 if (*bp == '\\' && bp[1] == '\n')
7281 name_newline_fix (bp);
7287 ident_length = bp - cp;
7291 /* A line of just `#' becomes blank. */
7293 if (ident_length == 0 && *after_ident == '\n') {
7297 if (ident_length == 0 || !is_idstart[*ident]) {
7299 while (is_idchar[*p]) {
7300 if (*p < '0' || *p > '9')
7304 /* Handle # followed by a line number. */
7305 if (p != ident && !is_idchar[*p]) {
7307 pedwarn ("`#' followed by integer");
7311 /* Avoid error for `###' and similar cases unless -pedantic. */
7313 while (*p == '#' || is_hor_space[*p]) p++;
7315 if (pedantic && !lang_asm)
7316 pedwarn ("invalid preprocessing directive");
7321 if (!lang_asm && pedantic)
7322 pedwarn ("invalid preprocessing directive name");
7326 for (kt = directive_table; kt->length >= 0; kt++) {
7327 IF_STACK_FRAME *temp;
7328 if (ident_length == kt->length
7329 && bcmp (cp, kt->name, kt->length) == 0) {
7330 /* If we are asked to return on next directive, do so now. */
7338 temp = (IF_STACK_FRAME *) xcalloc (1, sizeof (IF_STACK_FRAME));
7339 temp->next = if_stack;
7341 temp->lineno = ip->lineno;
7342 temp->fname = ip->nominal_fname;
7343 temp->type = kt->type;
7347 if (pedantic && if_stack != save_if_stack)
7348 validate_else (bp, endb);
7350 if (if_stack == instack[indepth].if_stack) {
7351 error ("`#%s' not within a conditional", kt->name);
7354 else if (if_stack == save_if_stack)
7355 goto done; /* found what we came for */
7357 if (kt->type != T_ENDIF) {
7358 if (if_stack->type == T_ELSE)
7359 error ("`#else' or `#elif' after `#else'");
7360 if_stack->type = kt->type;
7365 if_stack = if_stack->next;
7375 /* Don't let erroneous code go by. */
7376 if (kt->length < 0 && !lang_asm && pedantic)
7377 pedwarn ("invalid preprocessing directive name");
7382 /* after this returns, rescan will exit because ip->bufp
7383 now points to the end of the buffer.
7384 rescan is responsible for the error message also. */
7387 if (output_conditionals && op != 0) {
7388 char *ptr = "#endfailed\n";
7389 int len = strlen (ptr);
7391 if (op->bufp > op->buf && op->bufp[-1] != '\n')
7396 check_expand (op, beg_of_line - beg_of_group);
7397 bcopy ((char *) beg_of_group, (char *) op->bufp,
7398 beg_of_line - beg_of_group);
7399 op->bufp += beg_of_line - beg_of_group;
7400 op->lineno += ip->lineno - beg_lineno;
7401 check_expand (op, len);
7402 bcopy (ptr, (char *) op->bufp, len);
7409 * handle a #else directive. Do this by just continuing processing
7410 * without changing if_stack ; this is so that the error message
7411 * for missing #endif's etc. will point to the original #if. It
7412 * is possible that something different would be better.
7416 do_else (buf, limit, op, keyword)
7417 U_CHAR *buf, *limit;
7419 struct directive *keyword;
7421 FILE_BUF *ip = &instack[indepth];
7424 SKIP_WHITE_SPACE (buf);
7426 pedwarn ("text following `#else' violates ANSI standard");
7429 if (if_stack == instack[indepth].if_stack) {
7430 error ("`#else' not within a conditional");
7433 /* #ifndef can't have its special treatment for containing the whole file
7434 if it has a #else clause. */
7435 if_stack->control_macro = 0;
7437 if (if_stack->type != T_IF && if_stack->type != T_ELIF) {
7438 error ("`#else' after `#else'");
7439 fprintf (stderr, " (matches line %d", if_stack->lineno);
7440 if (strcmp (if_stack->fname, ip->nominal_fname) != 0)
7441 fprintf (stderr, ", file %s", if_stack->fname);
7442 fprintf (stderr, ")\n");
7444 if_stack->type = T_ELSE;
7447 if (if_stack->if_succeeded)
7448 skip_if_group (ip, 0, op);
7450 ++if_stack->if_succeeded; /* continue processing input */
7451 output_line_directive (ip, op, 1, same_file);
7457 * unstack after #endif directive
7461 do_endif (buf, limit, op, keyword)
7462 U_CHAR *buf, *limit;
7464 struct directive *keyword;
7467 SKIP_WHITE_SPACE (buf);
7469 pedwarn ("text following `#endif' violates ANSI standard");
7472 if (if_stack == instack[indepth].if_stack)
7473 error ("unbalanced `#endif'");
7475 IF_STACK_FRAME *temp = if_stack;
7476 if_stack = if_stack->next;
7477 if (temp->control_macro != 0) {
7478 /* This #endif matched a #ifndef at the start of the file.
7479 See if it is at the end of the file. */
7480 FILE_BUF *ip = &instack[indepth];
7481 U_CHAR *p = ip->bufp;
7482 U_CHAR *ep = ip->buf + ip->length;
7488 && (*p == '*' || (cplusplus_comments && *p == '/'))) {
7489 /* Skip this comment. */
7491 U_CHAR *save_bufp = ip->bufp;
7493 p = skip_to_end_of_comment (ip, &junk, 1);
7494 ip->bufp = save_bufp;
7499 /* If we get here, this #endif ends a #ifndef
7500 that contains all of the file (aside from whitespace).
7501 Arrange not to include the file again
7502 if the macro that was tested is defined.
7504 Do not do this for the top-level file in a -include or any
7505 file in a -imacros. */
7507 && ! (indepth == 1 && no_record_file)
7508 && ! (no_record_file && no_output))
7509 record_control_macro (ip->inc, temp->control_macro);
7513 output_line_directive (&instack[indepth], op, 1, same_file);
7518 /* When an #else or #endif is found while skipping failed conditional,
7519 if -pedantic was specified, this is called to warn about text after
7520 the directive name. P points to the first char after the directive name. */
7523 validate_else (p, limit)
7525 register U_CHAR *limit;
7527 /* Advance P over whitespace and comments. */
7529 while (*p == '\\' && p[1] == '\n')
7531 if (is_hor_space[*p])
7533 else if (*p == '/') {
7534 while (p[1] == '\\' && p[2] == '\n')
7537 /* Don't bother warning about unterminated comments
7538 since that will happen later. Just be sure to exit. */
7539 for (p += 2; ; p++) {
7543 while (p[1] == '\\' && p[2] == '\n')
7552 else if (cplusplus_comments && p[1] == '/')
7558 pedwarn ("text following `#else' or `#endif' violates ANSI standard");
7561 /* Skip a comment, assuming the input ptr immediately follows the
7562 initial slash-star. Bump *LINE_COUNTER for each newline.
7563 (The canonical line counter is &ip->lineno.)
7564 Don't use this routine (or the next one) if bumping the line
7565 counter is not sufficient to deal with newlines in the string.
7567 If NOWARN is nonzero, don't warn about slash-star inside a comment.
7568 This feature is useful when processing a comment that is going to be
7569 processed or was processed at another point in the preprocessor,
7570 to avoid a duplicate warning. Likewise for unterminated comment errors. */
7573 skip_to_end_of_comment (ip, line_counter, nowarn)
7574 register FILE_BUF *ip;
7575 int *line_counter; /* place to remember newlines, or NULL */
7578 register U_CHAR *limit = ip->buf + ip->length;
7579 register U_CHAR *bp = ip->bufp;
7580 FILE_BUF *op = put_out_comments && !line_counter ? &outbuf : (FILE_BUF *) 0;
7581 int start_line = line_counter ? *line_counter : 0;
7583 /* JF this line_counter stuff is a crock to make sure the
7584 comment is only put out once, no matter how many times
7585 the comment is skipped. It almost works */
7588 *op->bufp++ = bp[-1];
7590 if (cplusplus_comments && bp[-1] == '/') {
7591 for (; bp < limit; bp++) {
7597 if (!nowarn && warn_comments)
7598 warning ("multiline `//' comment");
7608 while (bp < limit) {
7613 /* If this is the end of the file, we have an unterminated comment.
7614 Don't swallow the newline. We are guaranteed that there will be a
7615 trailing newline and various pieces assume it's there. */
7622 if (line_counter != NULL)
7628 if (bp[-2] == '/' && !nowarn && warn_comments)
7629 warning ("`/*' within comment");
7630 if (*bp == '\\' && bp[1] == '\n')
7643 error_with_line (line_for_error (start_line), "unterminated comment");
7649 * Skip over a quoted string. BP points to the opening quote.
7650 * Returns a pointer after the closing quote. Don't go past LIMIT.
7651 * START_LINE is the line number of the starting point (but it need
7652 * not be valid if the starting point is inside a macro expansion).
7654 * The input stack state is not changed.
7656 * If COUNT_NEWLINES is nonzero, it points to an int to increment
7657 * for each newline passed.
7659 * If BACKSLASH_NEWLINES_P is nonzero, store 1 thru it
7660 * if we pass a backslash-newline.
7662 * If EOFP is nonzero, set *EOFP to 1 if the string is unterminated.
7665 skip_quoted_string (bp, limit, start_line, count_newlines, backslash_newlines_p, eofp)
7666 register U_CHAR *bp;
7667 register U_CHAR *limit;
7669 int *count_newlines;
7670 int *backslash_newlines_p;
7673 register U_CHAR c, match;
7678 error_with_line (line_for_error (start_line),
7679 "unterminated string or character constant");
7680 error_with_line (multiline_string_line,
7681 "possible real start of unterminated constant");
7682 multiline_string_line = 0;
7689 while (*bp == '\\' && bp[1] == '\n') {
7690 if (backslash_newlines_p)
7691 *backslash_newlines_p = 1;
7696 if (*bp == '\n' && count_newlines) {
7697 if (backslash_newlines_p)
7698 *backslash_newlines_p = 1;
7702 } else if (c == '\n') {
7704 /* Unterminated strings and character constants are 'valid'. */
7705 bp--; /* Don't consume the newline. */
7710 if (match == '\'') {
7711 error_with_line (line_for_error (start_line),
7712 "unterminated string or character constant");
7718 /* If not traditional, then allow newlines inside strings. */
7721 if (multiline_string_line == 0) {
7723 pedwarn_with_line (line_for_error (start_line),
7724 "string constant runs past end of line");
7725 multiline_string_line = start_line;
7727 } else if (c == match)
7733 /* Place into DST a quoted string representing the string SRC.
7734 Return the address of DST's terminating null. */
7736 quote_string (dst, src)
7743 switch ((c = *src++))
7750 sprintf (dst, "\\%03o", c);
7768 /* Skip across a group of balanced parens, starting from IP->bufp.
7769 IP->bufp is updated. Use this with IP->bufp pointing at an open-paren.
7771 This does not handle newlines, because it's used for the arg of #if,
7772 where there aren't any newlines. Also, backslash-newline can't appear. */
7775 skip_paren_group (ip)
7776 register FILE_BUF *ip;
7778 U_CHAR *limit = ip->buf + ip->length;
7779 U_CHAR *p = ip->bufp;
7781 int lines_dummy = 0;
7783 while (p != limit) {
7793 return ip->bufp = p;
7799 p = skip_to_end_of_comment (ip, &lines_dummy, 0);
7807 p = skip_quoted_string (p - 1, limit, 0, NULL_PTR, NULL_PTR, &eofp);
7809 return ip->bufp = p;
7820 * write out a #line directive, for instance, after an #include file.
7821 * If CONDITIONAL is nonzero, we can omit the #line if it would
7822 * appear to be a no-op, and we can output a few newlines instead
7823 * if we want to increase the line number by a small amount.
7824 * FILE_CHANGE says whether we are entering a file, leaving, or neither.
7828 output_line_directive (ip, op, conditional, file_change)
7831 enum file_change_code file_change;
7834 char *line_directive_buf, *line_end;
7836 if (no_line_directives
7837 || ip->fname == NULL
7839 op->lineno = ip->lineno;
7844 if (ip->lineno == op->lineno)
7847 /* If the inherited line number is a little too small,
7848 output some newlines instead of a #line directive. */
7849 if (ip->lineno > op->lineno && ip->lineno < op->lineno + 8) {
7850 check_expand (op, 10);
7851 while (ip->lineno > op->lineno) {
7859 /* Don't output a line number of 0 if we can help it. */
7860 if (ip->lineno == 0 && ip->bufp - ip->buf < ip->length
7861 && *ip->bufp == '\n') {
7866 line_directive_buf = (char *) alloca (4 * strlen (ip->nominal_fname) + 100);
7867 sprintf (line_directive_buf, "# %d ", ip->lineno);
7868 line_end = quote_string (line_directive_buf + strlen (line_directive_buf),
7870 if (file_change != same_file) {
7872 *line_end++ = file_change == enter_file ? '1' : '2';
7874 /* Tell cc1 if following text comes from a system header file. */
7875 if (ip->system_header_p) {
7879 #ifndef NO_IMPLICIT_EXTERN_C
7880 /* Tell cc1plus if following text should be treated as C. */
7881 if (ip->system_header_p == 2 && cplusplus) {
7887 len = line_end - line_directive_buf;
7888 check_expand (op, len + 1);
7889 if (op->bufp > op->buf && op->bufp[-1] != '\n')
7891 bcopy ((char *) line_directive_buf, (char *) op->bufp, len);
7893 op->lineno = ip->lineno;
7896 /* This structure represents one parsed argument in a macro call.
7897 `raw' points to the argument text as written (`raw_length' is its length).
7898 `expanded' points to the argument's macro-expansion
7899 (its length is `expand_length').
7900 `stringified_length' is the length the argument would have
7902 `use_count' is the number of times this macro arg is substituted
7903 into the macro. If the actual use count exceeds 10,
7904 the value stored is 10.
7905 `free1' and `free2', if nonzero, point to blocks to be freed
7906 when the macro argument data is no longer needed. */
7909 U_CHAR *raw, *expanded;
7910 int raw_length, expand_length;
7911 int stringified_length;
7912 U_CHAR *free1, *free2;
7917 /* Expand a macro call.
7918 HP points to the symbol that is the macro being called.
7919 Put the result of expansion onto the input stack
7920 so that subsequent input by our caller will use it.
7922 If macro wants arguments, caller has already verified that
7923 an argument list follows; arguments come from the input stack. */
7926 macroexpand (hp, op)
7931 DEFINITION *defn = hp->value.defn;
7932 register U_CHAR *xbuf;
7934 int start_line = instack[indepth].lineno;
7935 int rest_args, rest_zero;
7937 CHECK_DEPTH (return;);
7939 /* it might not actually be a macro. */
7940 if (hp->type != T_MACRO) {
7941 special_symbol (hp, op);
7945 /* This macro is being used inside a #if, which means it must be */
7946 /* recorded as a precondition. */
7947 if (pcp_inside_if && pcp_outfile && defn->predefined)
7948 dump_single_macro (hp, pcp_outfile);
7950 nargs = defn->nargs;
7954 struct argdata *args;
7955 char *parse_error = 0;
7957 args = (struct argdata *) alloca ((nargs + 1) * sizeof (struct argdata));
7959 for (i = 0; i < nargs; i++) {
7960 args[i].raw = (U_CHAR *) "";
7961 args[i].expanded = 0;
7962 args[i].raw_length = args[i].expand_length
7963 = args[i].stringified_length = 0;
7964 args[i].free1 = args[i].free2 = 0;
7965 args[i].use_count = 0;
7968 /* Parse all the macro args that are supplied. I counts them.
7969 The first NARGS args are stored in ARGS.
7970 The rest are discarded.
7971 If rest_args is set then we assume macarg absorbed the rest of the args.
7976 /* Discard the open-parenthesis or comma before the next arg. */
7977 ++instack[indepth].bufp;
7980 if (i < nargs || (nargs == 0 && i == 0)) {
7981 /* if we are working on last arg which absorbs rest of args... */
7982 if (i == nargs - 1 && defn->rest_args)
7984 parse_error = macarg (&args[i], rest_args);
7987 parse_error = macarg (NULL_PTR, 0);
7989 error_with_line (line_for_error (start_line), parse_error);
7993 } while (*instack[indepth].bufp != ')');
7995 /* If we got one arg but it was just whitespace, call that 0 args. */
7997 register U_CHAR *bp = args[0].raw;
7998 register U_CHAR *lim = bp + args[0].raw_length;
7999 /* cpp.texi says for foo ( ) we provide one argument.
8000 However, if foo wants just 0 arguments, treat this as 0. */
8002 while (bp != lim && is_space[*bp]) bp++;
8007 /* Don't output an error message if we have already output one for
8008 a parse error above. */
8010 if (nargs == 0 && i > 0) {
8012 error ("arguments given to macro `%s'", hp->name);
8013 } else if (i < nargs) {
8014 /* traditional C allows foo() if foo wants one argument. */
8015 if (nargs == 1 && i == 0 && traditional)
8017 /* the rest args token is allowed to absorb 0 tokens */
8018 else if (i == nargs - 1 && defn->rest_args)
8020 else if (parse_error)
8023 error ("macro `%s' used without args", hp->name);
8025 error ("macro `%s' used with just one arg", hp->name);
8027 error ("macro `%s' used with only %d args", hp->name, i);
8028 } else if (i > nargs) {
8030 error ("macro `%s' used with too many (%d) args", hp->name, i);
8033 /* Swallow the closeparen. */
8034 ++instack[indepth].bufp;
8036 /* If macro wants zero args, we parsed the arglist for checking only.
8037 Read directly from the macro definition. */
8039 xbuf = defn->expansion;
8040 xbuf_len = defn->length;
8042 register U_CHAR *exp = defn->expansion;
8043 register int offset; /* offset in expansion,
8044 copied a piece at a time */
8045 register int totlen; /* total amount of exp buffer filled so far */
8047 register struct reflist *ap, *last_ap;
8049 /* Macro really takes args. Compute the expansion of this call. */
8051 /* Compute length in characters of the macro's expansion.
8052 Also count number of times each arg is used. */
8053 xbuf_len = defn->length;
8054 for (ap = defn->pattern; ap != NULL; ap = ap->next) {
8056 xbuf_len += args[ap->argno].stringified_length;
8057 else if (ap->raw_before != 0 || ap->raw_after != 0 || traditional)
8058 /* Add 4 for two newline-space markers to prevent
8059 token concatenation. */
8060 xbuf_len += args[ap->argno].raw_length + 4;
8062 /* We have an ordinary (expanded) occurrence of the arg.
8063 So compute its expansion, if we have not already. */
8064 if (args[ap->argno].expanded == 0) {
8066 obuf = expand_to_temp_buffer (args[ap->argno].raw,
8067 args[ap->argno].raw + args[ap->argno].raw_length,
8070 args[ap->argno].expanded = obuf.buf;
8071 args[ap->argno].expand_length = obuf.length;
8072 args[ap->argno].free2 = obuf.buf;
8075 /* Add 4 for two newline-space markers to prevent
8076 token concatenation. */
8077 xbuf_len += args[ap->argno].expand_length + 4;
8079 if (args[ap->argno].use_count < 10)
8080 args[ap->argno].use_count++;
8083 xbuf = (U_CHAR *) xmalloc (xbuf_len + 1);
8085 /* Generate in XBUF the complete expansion
8086 with arguments substituted in.
8087 TOTLEN is the total size generated so far.
8088 OFFSET is the index in the definition
8089 of where we are copying from. */
8090 offset = totlen = 0;
8091 for (last_ap = NULL, ap = defn->pattern; ap != NULL;
8092 last_ap = ap, ap = ap->next) {
8093 register struct argdata *arg = &args[ap->argno];
8094 int count_before = totlen;
8096 /* Add chars to XBUF. */
8097 for (i = 0; i < ap->nchars; i++, offset++)
8098 xbuf[totlen++] = exp[offset];
8100 /* If followed by an empty rest arg with concatenation,
8101 delete the last run of nonwhite chars. */
8102 if (rest_zero && totlen > count_before
8103 && ((ap->rest_args && ap->raw_before != 0)
8104 || (last_ap != NULL && last_ap->rest_args
8105 && last_ap->raw_after != 0))) {
8106 /* Delete final whitespace. */
8107 while (totlen > count_before && is_space[xbuf[totlen - 1]]) {
8111 /* Delete the nonwhites before them. */
8112 while (totlen > count_before && ! is_space[xbuf[totlen - 1]]) {
8117 if (ap->stringify != 0) {
8118 int arglen = arg->raw_length;
8124 && (c = arg->raw[i], is_space[c]))
8127 && (c = arg->raw[arglen - 1], is_space[c]))
8130 xbuf[totlen++] = '\"'; /* insert beginning quote */
8131 for (; i < arglen; i++) {
8134 /* Special markers Newline Space
8135 generate nothing for a stringified argument. */
8136 if (c == '\n' && arg->raw[i+1] != '\n') {
8141 /* Internal sequences of whitespace are replaced by one space
8142 except within an string or char token. */
8144 && (c == '\n' ? arg->raw[i+1] == '\n' : is_space[c])) {
8146 /* Note that Newline Space does occur within whitespace
8147 sequences; consider it part of the sequence. */
8148 if (c == '\n' && is_space[arg->raw[i+1]])
8150 else if (c != '\n' && is_space[c])
8167 } else if (c == '\"' || c == '\'')
8171 /* Escape these chars */
8172 if (c == '\"' || (in_string && c == '\\'))
8173 xbuf[totlen++] = '\\';
8177 sprintf ((char *) &xbuf[totlen], "\\%03o", (unsigned int) c);
8182 xbuf[totlen++] = '\"'; /* insert ending quote */
8183 } else if (ap->raw_before != 0 || ap->raw_after != 0 || traditional) {
8184 U_CHAR *p1 = arg->raw;
8185 U_CHAR *l1 = p1 + arg->raw_length;
8186 if (ap->raw_before != 0) {
8187 while (p1 != l1 && is_space[*p1]) p1++;
8188 while (p1 != l1 && is_idchar[*p1])
8189 xbuf[totlen++] = *p1++;
8190 /* Delete any no-reexpansion marker that follows
8191 an identifier at the beginning of the argument
8192 if the argument is concatenated with what precedes it. */
8193 if (p1[0] == '\n' && p1[1] == '-')
8195 } else if (!traditional) {
8196 /* Ordinary expanded use of the argument.
8197 Put in newline-space markers to prevent token pasting. */
8198 xbuf[totlen++] = '\n';
8199 xbuf[totlen++] = ' ';
8201 if (ap->raw_after != 0) {
8202 /* Arg is concatenated after: delete trailing whitespace,
8203 whitespace markers, and no-reexpansion markers. */
8205 if (is_space[l1[-1]]) l1--;
8206 else if (l1[-1] == '-') {
8207 U_CHAR *p2 = l1 - 1;
8208 /* If a `-' is preceded by an odd number of newlines then it
8209 and the last newline are a no-reexpansion marker. */
8210 while (p2 != p1 && p2[-1] == '\n') p2--;
8211 if ((l1 - 1 - p2) & 1) {
8220 bcopy ((char *) p1, (char *) (xbuf + totlen), l1 - p1);
8222 if (!traditional && ap->raw_after == 0) {
8223 /* Ordinary expanded use of the argument.
8224 Put in newline-space markers to prevent token pasting. */
8225 xbuf[totlen++] = '\n';
8226 xbuf[totlen++] = ' ';
8229 /* Ordinary expanded use of the argument.
8230 Put in newline-space markers to prevent token pasting. */
8232 xbuf[totlen++] = '\n';
8233 xbuf[totlen++] = ' ';
8235 bcopy ((char *) arg->expanded, (char *) (xbuf + totlen),
8236 arg->expand_length);
8237 totlen += arg->expand_length;
8239 xbuf[totlen++] = '\n';
8240 xbuf[totlen++] = ' ';
8242 /* If a macro argument with newlines is used multiple times,
8243 then only expand the newlines once. This avoids creating output
8244 lines which don't correspond to any input line, which confuses
8246 if (arg->use_count > 1 && arg->newlines > 0) {
8247 /* Don't bother doing change_newlines for subsequent
8251 = change_newlines (arg->expanded, arg->expand_length);
8255 if (totlen > xbuf_len)
8259 /* if there is anything left of the definition
8260 after handling the arg list, copy that in too. */
8262 for (i = offset; i < defn->length; i++) {
8263 /* if we've reached the end of the macro */
8266 if (! (rest_zero && last_ap != NULL && last_ap->rest_args
8267 && last_ap->raw_after != 0))
8268 xbuf[totlen++] = exp[i];
8274 for (i = 0; i < nargs; i++) {
8275 if (args[i].free1 != 0)
8276 free (args[i].free1);
8277 if (args[i].free2 != 0)
8278 free (args[i].free2);
8282 xbuf = defn->expansion;
8283 xbuf_len = defn->length;
8286 /* Now put the expansion on the input stack
8287 so our caller will commence reading from it. */
8289 register FILE_BUF *ip2;
8291 ip2 = &instack[++indepth];
8294 ip2->nominal_fname = 0;
8296 /* This may not be exactly correct, but will give much better error
8297 messages for nested macro calls than using a line number of zero. */
8298 ip2->lineno = start_line;
8300 ip2->length = xbuf_len;
8302 ip2->free_ptr = (nargs > 0) ? xbuf : 0;
8304 ip2->if_stack = if_stack;
8305 ip2->system_header_p = 0;
8307 /* Recursive macro use sometimes works traditionally.
8308 #define foo(x,y) bar (x (y,0), y)
8312 hp->type = T_DISABLED;
8317 * Parse a macro argument and store the info on it into *ARGPTR.
8318 * REST_ARGS is passed to macarg1 to make it absorb the rest of the args.
8319 * Return nonzero to indicate a syntax error.
8323 macarg (argptr, rest_args)
8324 register struct argdata *argptr;
8327 FILE_BUF *ip = &instack[indepth];
8333 /* Try to parse as much of the argument as exists at this
8334 input stack level. */
8335 U_CHAR *bp = macarg1 (ip->bufp, ip->buf + ip->length,
8336 &paren, &newlines, &comments, rest_args);
8338 /* If we find the end of the argument at this level,
8339 set up *ARGPTR to point at it in the input stack. */
8340 if (!(ip->fname != 0 && (newlines != 0 || comments != 0))
8341 && bp != ip->buf + ip->length) {
8343 argptr->raw = ip->bufp;
8344 argptr->raw_length = bp - ip->bufp;
8345 argptr->newlines = newlines;
8349 /* This input stack level ends before the macro argument does.
8350 We must pop levels and keep parsing.
8351 Therefore, we must allocate a temporary buffer and copy
8352 the macro argument into it. */
8353 int bufsize = bp - ip->bufp;
8354 int extra = newlines;
8355 U_CHAR *buffer = (U_CHAR *) xmalloc (bufsize + extra + 1);
8356 int final_start = 0;
8358 bcopy ((char *) ip->bufp, (char *) buffer, bufsize);
8360 ip->lineno += newlines;
8362 while (bp == ip->buf + ip->length) {
8363 if (instack[indepth].macro == 0) {
8364 result = "unterminated macro call";
8367 ip->macro->type = T_MACRO;
8369 free (ip->free_ptr);
8370 ip = &instack[--indepth];
8373 bp = macarg1 (ip->bufp, ip->buf + ip->length, &paren,
8374 &newlines, &comments, rest_args);
8375 final_start = bufsize;
8376 bufsize += bp - ip->bufp;
8378 buffer = (U_CHAR *) xrealloc (buffer, bufsize + extra + 1);
8379 bcopy ((char *) ip->bufp, (char *) (buffer + bufsize - (bp - ip->bufp)),
8382 ip->lineno += newlines;
8385 /* Now, if arg is actually wanted, record its raw form,
8386 discarding comments and duplicating newlines in whatever
8387 part of it did not come from a macro expansion.
8388 EXTRA space has been preallocated for duplicating the newlines.
8389 FINAL_START is the index of the start of that part. */
8391 argptr->raw = buffer;
8392 argptr->raw_length = bufsize;
8393 argptr->free1 = buffer;
8394 argptr->newlines = newlines;
8395 if ((newlines || comments) && ip->fname != 0)
8398 discard_comments (argptr->raw + final_start,
8399 argptr->raw_length - final_start,
8401 argptr->raw[argptr->raw_length] = 0;
8402 if (argptr->raw_length > bufsize + extra)
8407 /* If we are not discarding this argument,
8408 macroexpand it and compute its length as stringified.
8409 All this info goes into *ARGPTR. */
8412 register U_CHAR *buf, *lim;
8413 register int totlen;
8416 lim = buf + argptr->raw_length;
8418 while (buf != lim && is_space[*buf])
8420 while (buf != lim && is_space[lim[-1]])
8422 totlen = traditional ? 0 : 2; /* Count opening and closing quote. */
8423 while (buf != lim) {
8424 register U_CHAR c = *buf++;
8426 /* Internal sequences of whitespace are replaced by one space
8427 in most cases, but not always. So count all the whitespace
8428 in case we need to keep it all. */
8431 SKIP_ALL_WHITE_SPACE (buf);
8434 if (c == '\"' || c == '\\') /* escape these chars */
8436 else if (!isprint (c))
8439 argptr->stringified_length = totlen;
8444 /* Scan text from START (inclusive) up to LIMIT (exclusive),
8445 counting parens in *DEPTHPTR,
8446 and return if reach LIMIT
8447 or before a `)' that would make *DEPTHPTR negative
8448 or before a comma when *DEPTHPTR is zero.
8449 Single and double quotes are matched and termination
8450 is inhibited within them. Comments also inhibit it.
8451 Value returned is pointer to stopping place.
8453 Increment *NEWLINES each time a newline is passed.
8454 REST_ARGS notifies macarg1 that it should absorb the rest of the args.
8455 Set *COMMENTS to 1 if a comment is seen. */
8458 macarg1 (start, limit, depthptr, newlines, comments, rest_args)
8460 register U_CHAR *limit;
8461 int *depthptr, *newlines, *comments;
8464 register U_CHAR *bp = start;
8466 while (bp < limit) {
8472 if (--(*depthptr) < 0)
8476 /* Traditionally, backslash makes following char not special. */
8477 if (bp + 1 < limit && traditional)
8480 /* But count source lines anyway. */
8489 if (bp[1] == '\\' && bp[2] == '\n')
8490 newline_fix (bp + 1);
8493 for (bp += 2; bp < limit; bp++) {
8496 else if (*bp == '*') {
8497 if (bp[-1] == '/' && warn_comments)
8498 warning ("`/*' within comment");
8499 if (bp[1] == '\\' && bp[2] == '\n')
8500 newline_fix (bp + 1);
8507 } else if (bp[1] == '/' && cplusplus_comments) {
8509 for (bp += 2; bp < limit; bp++) {
8515 warning ("multiline `//' comment");
8524 for (quotec = *bp++; bp + 1 < limit && *bp != quotec; bp++) {
8529 while (*bp == '\\' && bp[1] == '\n') {
8532 } else if (*bp == '\n') {
8541 /* if we've returned to lowest level and we aren't absorbing all args */
8542 if ((*depthptr) == 0 && rest_args == 0)
8552 /* Discard comments and duplicate newlines
8553 in the string of length LENGTH at START,
8554 except inside of string constants.
8555 The string is copied into itself with its beginning staying fixed.
8557 NEWLINES is the number of newlines that must be duplicated.
8558 We assume that that much extra space is available past the end
8562 discard_comments (start, length, newlines)
8567 register U_CHAR *ibp;
8568 register U_CHAR *obp;
8569 register U_CHAR *limit;
8572 /* If we have newlines to duplicate, copy everything
8573 that many characters up. Then, in the second part,
8574 we will have room to insert the newlines
8576 NEWLINES may actually be too large, because it counts
8577 newlines in string constants, and we don't duplicate those.
8578 But that does no harm. */
8580 ibp = start + length;
8581 obp = ibp + newlines;
8583 while (limit != ibp)
8587 ibp = start + newlines;
8588 limit = start + length + newlines;
8591 while (ibp < limit) {
8592 *obp++ = c = *ibp++;
8595 /* Duplicate the newline. */
8607 if (*ibp == '\\' && ibp[1] == '\n')
8609 /* Delete any comment. */
8610 if (cplusplus_comments && ibp[0] == '/') {
8611 /* Comments are equivalent to spaces. */
8614 while (ibp < limit && (*ibp != '\n' || ibp[-1] == '\\'))
8618 if (ibp[0] != '*' || ibp + 1 >= limit)
8620 /* Comments are equivalent to spaces.
8621 For -traditional, a comment is equivalent to nothing. */
8627 while (ibp + 1 < limit) {
8629 && ibp[1] == '\\' && ibp[2] == '\n')
8630 newline_fix (ibp + 1);
8631 if (ibp[0] == '*' && ibp[1] == '/')
8640 /* Notice and skip strings, so that we don't
8641 think that comments start inside them,
8642 and so we don't duplicate newlines in them. */
8645 while (ibp < limit) {
8646 *obp++ = c = *ibp++;
8649 if (c == '\n' && quotec == '\'')
8651 if (c == '\\' && ibp < limit) {
8652 while (*ibp == '\\' && ibp[1] == '\n')
8665 /* Turn newlines to spaces in the string of length LENGTH at START,
8666 except inside of string constants.
8667 The string is copied into itself with its beginning staying fixed. */
8670 change_newlines (start, length)
8674 register U_CHAR *ibp;
8675 register U_CHAR *obp;
8676 register U_CHAR *limit;
8680 limit = start + length;
8683 while (ibp < limit) {
8684 *obp++ = c = *ibp++;
8687 /* If this is a NEWLINE NEWLINE, then this is a real newline in the
8688 string. Skip past the newline and its duplicate.
8689 Put a space in the output. */
8700 /* Notice and skip strings, so that we don't delete newlines in them. */
8703 while (ibp < limit) {
8704 *obp++ = c = *ibp++;
8707 if (c == '\n' && quotec == '\'')
8719 * my_strerror - return the descriptive text associated with an `errno' code.
8723 my_strerror (errnum)
8729 #ifndef HAVE_STRERROR
8730 result = (char *) ((errnum < sys_nerr) ? sys_errlist[errnum] : 0);
8732 result = strerror (errnum);
8735 /* VAXCRTL's strerror() takes an optional second argument, which only
8736 matters when the first argument is EVMSERR. However, it's simplest
8737 just to pass it unconditionally. `vaxc$errno' is declared in
8738 <errno.h>, and maintained by the library in parallel with `errno'.
8739 We assume that caller's `errnum' either matches the last setting of
8740 `errno' by the library or else does not have the value `EVMSERR'. */
8742 result = strerror (errnum, vaxc$errno);
8746 result = "undocumented I/O error";
8752 * error - print error message and increment count of errors.
8756 error (PRINTF_ALIST (msg))
8761 VA_START (args, msg);
8772 FILE_BUF *ip = NULL;
8774 print_containing_files ();
8776 for (i = indepth; i >= 0; i--)
8777 if (instack[i].fname != NULL) {
8783 fprintf (stderr, "%s:%d: ", ip->nominal_fname, ip->lineno);
8784 vfprintf (stderr, msg, args);
8785 fprintf (stderr, "\n");
8789 /* Error including a message from `errno'. */
8792 error_from_errno (name)
8796 FILE_BUF *ip = NULL;
8798 print_containing_files ();
8800 for (i = indepth; i >= 0; i--)
8801 if (instack[i].fname != NULL) {
8807 fprintf (stderr, "%s:%d: ", ip->nominal_fname, ip->lineno);
8809 fprintf (stderr, "%s: %s\n", name, my_strerror (errno));
8814 /* Print error message but don't count it. */
8817 warning (PRINTF_ALIST (msg))
8822 VA_START (args, msg);
8823 vwarning (msg, args);
8828 vwarning (msg, args)
8833 FILE_BUF *ip = NULL;
8835 if (inhibit_warnings)
8838 if (warnings_are_errors)
8841 print_containing_files ();
8843 for (i = indepth; i >= 0; i--)
8844 if (instack[i].fname != NULL) {
8850 fprintf (stderr, "%s:%d: ", ip->nominal_fname, ip->lineno);
8851 fprintf (stderr, "warning: ");
8852 vfprintf (stderr, msg, args);
8853 fprintf (stderr, "\n");
8857 #if defined (__STDC__) && defined (HAVE_VPRINTF)
8858 error_with_line (int line, PRINTF_ALIST (msg))
8860 error_with_line (line, PRINTF_ALIST (msg))
8867 VA_START (args, msg);
8868 verror_with_line (line, msg, args);
8873 verror_with_line (line, msg, args)
8879 FILE_BUF *ip = NULL;
8881 print_containing_files ();
8883 for (i = indepth; i >= 0; i--)
8884 if (instack[i].fname != NULL) {
8890 fprintf (stderr, "%s:%d: ", ip->nominal_fname, line);
8891 vfprintf (stderr, msg, args);
8892 fprintf (stderr, "\n");
8897 #if defined (__STDC__) && defined (HAVE_VPRINTF)
8898 warning_with_line (int line, PRINTF_ALIST (msg))
8900 warning_with_line (line, PRINTF_ALIST (msg))
8907 VA_START (args, msg);
8908 vwarning_with_line (line, msg, args);
8913 vwarning_with_line (line, msg, args)
8919 FILE_BUF *ip = NULL;
8921 if (inhibit_warnings)
8924 if (warnings_are_errors)
8927 print_containing_files ();
8929 for (i = indepth; i >= 0; i--)
8930 if (instack[i].fname != NULL) {
8936 fprintf (stderr, line ? "%s:%d: " : "%s: ", ip->nominal_fname, line);
8937 fprintf (stderr, "warning: ");
8938 vfprintf (stderr, msg, args);
8939 fprintf (stderr, "\n");
8942 /* print an error message and maybe count it. */
8945 pedwarn (PRINTF_ALIST (msg))
8950 VA_START (args, msg);
8951 if (pedantic_errors)
8954 vwarning (msg, args);
8959 #if defined (__STDC__) && defined (HAVE_VPRINTF)
8960 pedwarn_with_line (int line, PRINTF_ALIST (msg))
8962 pedwarn_with_line (line, PRINTF_ALIST (msg))
8969 VA_START (args, msg);
8970 if (pedantic_errors)
8971 verror_with_line (line, msg, args);
8973 vwarning_with_line (line, msg, args);
8977 /* Report a warning (or an error if pedantic_errors)
8978 giving specified file name and line number, not current. */
8981 #if defined (__STDC__) && defined (HAVE_VPRINTF)
8982 pedwarn_with_file_and_line (char *file, int line, PRINTF_ALIST (msg))
8984 pedwarn_with_file_and_line (file, line, PRINTF_ALIST (msg))
8992 if (!pedantic_errors && inhibit_warnings)
8995 fprintf (stderr, "%s:%d: ", file, line);
8996 if (pedantic_errors)
8998 if (!pedantic_errors)
8999 fprintf (stderr, "warning: ");
9000 VA_START (args, msg);
9001 vfprintf (stderr, msg, args);
9003 fprintf (stderr, "\n");
9006 /* Print the file names and line numbers of the #include
9007 directives which led to the current file. */
9010 print_containing_files ()
9012 FILE_BUF *ip = NULL;
9016 /* If stack of files hasn't changed since we last printed
9017 this info, don't repeat it. */
9018 if (last_error_tick == input_file_stack_tick)
9021 for (i = indepth; i >= 0; i--)
9022 if (instack[i].fname != NULL) {
9027 /* Give up if we don't find a source file. */
9031 /* Find the other, outer source files. */
9032 for (i--; i >= 0; i--)
9033 if (instack[i].fname != NULL) {
9037 fprintf (stderr, "In file included");
9039 fprintf (stderr, ",\n ");
9042 fprintf (stderr, " from %s:%d", ip->nominal_fname, ip->lineno);
9045 fprintf (stderr, ":\n");
9047 /* Record we have printed the status as of this time. */
9048 last_error_tick = input_file_stack_tick;
9051 /* Return the line at which an error occurred.
9052 The error is not necessarily associated with the current spot
9053 in the input stack, so LINE says where. LINE will have been
9054 copied from ip->lineno for the current input level.
9055 If the current level is for a file, we return LINE.
9056 But if the current level is not for a file, LINE is meaningless.
9057 In that case, we return the lineno of the innermost file. */
9060 line_for_error (line)
9066 for (i = indepth; i >= 0; ) {
9067 if (instack[i].fname != 0)
9072 line1 = instack[i].lineno;
9080 * If OBUF doesn't have NEEDED bytes after OPTR, make it bigger.
9082 * As things stand, nothing is ever placed in the output buffer to be
9083 * removed again except when it's KNOWN to be part of an identifier,
9084 * so flushing and moving down everything left, instead of expanding,
9088 /* You might think void was cleaner for the return type,
9089 but that would get type mismatch in check_expand in strict ANSI. */
9091 grow_outbuf (obuf, needed)
9092 register FILE_BUF *obuf;
9093 register int needed;
9098 if (obuf->length - (obuf->bufp - obuf->buf) > needed)
9101 /* Make it at least twice as big as it is now. */
9103 /* Make it have at least 150% of the free space we will need. */
9104 minsize = (3 * needed) / 2 + (obuf->bufp - obuf->buf);
9105 if (minsize > obuf->length)
9106 obuf->length = minsize;
9108 if ((p = (U_CHAR *) xrealloc (obuf->buf, obuf->length)) == NULL)
9111 obuf->bufp = p + (obuf->bufp - obuf->buf);
9117 /* Symbol table for macro names and special symbols */
9120 * install a name in the main hash table, even if it is already there.
9121 * name stops with first non alphanumeric, except leading '#'.
9122 * caller must check against redefinition if that is desired.
9123 * delete_macro () removes things installed by install () in fifo order.
9124 * this is important because of the `defined' special symbol used
9125 * in #if, and also if pushdef/popdef directives are ever implemented.
9127 * If LEN is >= 0, it is the length of the name.
9128 * Otherwise, compute the length by scanning the entire name.
9130 * If HASH is >= 0, it is the precomputed hash code.
9131 * Otherwise, compute the hash code.
9134 install (name, len, type, value, hash)
9137 enum node_type type;
9141 register HASHNODE *hp;
9142 register int i, bucket;
9143 register U_CHAR *p, *q;
9147 while (is_idchar[*p])
9153 hash = hashf (name, len, HASHSIZE);
9155 i = sizeof (HASHNODE) + len + 1;
9156 hp = (HASHNODE *) xmalloc (i);
9158 hp->bucket_hdr = &hashtab[bucket];
9159 hp->next = hashtab[bucket];
9160 hashtab[bucket] = hp;
9162 if (hp->next != NULL)
9163 hp->next->prev = hp;
9166 hp->value.cpval = value;
9167 hp->name = ((U_CHAR *) hp) + sizeof (HASHNODE);
9170 for (i = 0; i < len; i++)
9177 * find the most recent hash node for name name (ending with first
9178 * non-identifier char) installed by install
9180 * If LEN is >= 0, it is the length of the name.
9181 * Otherwise, compute the length by scanning the entire name.
9183 * If HASH is >= 0, it is the precomputed hash code.
9184 * Otherwise, compute the hash code.
9187 lookup (name, len, hash)
9192 register U_CHAR *bp;
9193 register HASHNODE *bucket;
9196 for (bp = name; is_idchar[*bp]; bp++) ;
9201 hash = hashf (name, len, HASHSIZE);
9203 bucket = hashtab[hash];
9205 if (bucket->length == len && bcmp (bucket->name, name, len) == 0)
9207 bucket = bucket->next;
9213 * Delete a hash node. Some weirdness to free junk from macros.
9214 * More such weirdness will have to be added if you define more hash
9215 * types that need it.
9218 /* Note that the DEFINITION of a macro is removed from the hash table
9219 but its storage is not freed. This would be a storage leak
9220 except that it is not reasonable to keep undefining and redefining
9221 large numbers of macros many times.
9222 In any case, this is necessary, because a macro can be #undef'd
9223 in the middle of reading the arguments to a call to it.
9224 If #undef freed the DEFINITION, that would crash. */
9231 if (hp->prev != NULL)
9232 hp->prev->next = hp->next;
9233 if (hp->next != NULL)
9234 hp->next->prev = hp->prev;
9236 /* make sure that the bucket chain header that
9237 the deleted guy was on points to the right thing afterwards. */
9238 if (hp == *hp->bucket_hdr)
9239 *hp->bucket_hdr = hp->next;
9242 if (hp->type == T_MACRO) {
9243 DEFINITION *d = hp->value.defn;
9244 struct reflist *ap, *nextap;
9246 for (ap = d->pattern; ap != NULL; ap = nextap) {
9257 * return hash function on name. must be compatible with the one
9258 * computed a step at a time, elsewhere
9261 hashf (name, len, hashsize)
9262 register U_CHAR *name;
9269 r = HASHSTEP (r, *name++);
9271 return MAKE_POS (r) % hashsize;
9275 /* Dump the definition of a single macro HP to OF. */
9277 dump_single_macro (hp, of)
9278 register HASHNODE *hp;
9281 register DEFINITION *defn = hp->value.defn;
9287 /* Print the definition of the macro HP. */
9289 fprintf (of, "#define %s", hp->name);
9291 if (defn->nargs >= 0) {
9295 for (i = 0; i < defn->nargs; i++) {
9296 dump_arg_n (defn, i, of);
9297 if (i + 1 < defn->nargs)
9307 for (ap = defn->pattern; ap != NULL; ap = ap->next) {
9308 dump_defn_1 (defn->expansion, offset, ap->nchars, of);
9309 offset += ap->nchars;
9311 if (ap->nchars != 0)
9313 if (ap->stringify) {
9314 switch (ap->stringify) {
9315 case SHARP_TOKEN: fprintf (of, "#"); break;
9316 case WHITE_SHARP_TOKEN: fprintf (of, "# "); break;
9317 case PERCENT_COLON_TOKEN: fprintf (of, "%%:"); break;
9318 case WHITE_PERCENT_COLON_TOKEN: fprintf (of, "%%: "); break;
9322 if (ap->raw_before != 0) {
9324 switch (ap->raw_before) {
9325 case WHITE_SHARP_TOKEN:
9326 case WHITE_PERCENT_COLON_TOKEN:
9333 switch (ap->raw_before) {
9334 case SHARP_TOKEN: fprintf (of, "##"); break;
9335 case WHITE_SHARP_TOKEN: fprintf (of, "## "); break;
9336 case PERCENT_COLON_TOKEN: fprintf (of, "%%:%%:"); break;
9337 case WHITE_PERCENT_COLON_TOKEN: fprintf (of, "%%:%%: "); break;
9344 dump_arg_n (defn, ap->argno, of);
9345 if (!traditional && ap->raw_after != 0) {
9346 switch (ap->raw_after) {
9347 case SHARP_TOKEN: fprintf (of, "##"); break;
9348 case WHITE_SHARP_TOKEN: fprintf (of, " ##"); break;
9349 case PERCENT_COLON_TOKEN: fprintf (of, "%%:%%:"); break;
9350 case WHITE_PERCENT_COLON_TOKEN: fprintf (of, " %%:%%:"); break;
9356 dump_defn_1 (defn->expansion, offset, defn->length - offset, of);
9360 /* Dump all macro definitions as #defines to stdout. */
9367 for (bucket = 0; bucket < HASHSIZE; bucket++) {
9368 register HASHNODE *hp;
9370 for (hp = hashtab[bucket]; hp; hp= hp->next) {
9371 if (hp->type == T_MACRO)
9372 dump_single_macro (hp, stdout);
9377 /* Output to OF a substring of a macro definition.
9378 BASE is the beginning of the definition.
9379 Output characters START thru LENGTH.
9380 Unless traditional, discard newlines outside of strings, thus
9381 converting funny-space markers to ordinary spaces. */
9384 dump_defn_1 (base, start, length, of)
9390 U_CHAR *p = base + start;
9391 U_CHAR *limit = base + start + length;
9394 fwrite (p, sizeof (*p), length, of);
9397 if (*p == '\"' || *p =='\'') {
9398 U_CHAR *p1 = skip_quoted_string (p, limit, 0, NULL_PTR,
9399 NULL_PTR, NULL_PTR);
9400 fwrite (p, sizeof (*p), p1 - p, of);
9411 /* Print the name of argument number ARGNUM of macro definition DEFN
9413 Recall that DEFN->args.argnames contains all the arg names
9414 concatenated in reverse order with comma-space in between. */
9417 dump_arg_n (defn, argnum, of)
9422 register U_CHAR *p = defn->args.argnames;
9423 while (argnum + 1 < defn->nargs) {
9424 p = (U_CHAR *) index ((char *) p, ' ') + 1;
9428 while (*p && *p != ',') {
9434 /* Initialize syntactic classifications of characters. */
9437 initialize_char_syntax ()
9442 * Set up is_idchar and is_idstart tables. These should be
9443 * faster than saying (is_alpha (c) || c == '_'), etc.
9444 * Set up these things before calling any routines tthat
9447 for (i = 'a'; i <= 'z'; i++) {
9448 is_idchar[i - 'a' + 'A'] = 1;
9450 is_idstart[i - 'a' + 'A'] = 1;
9453 for (i = '0'; i <= '9'; i++)
9456 is_idstart['_'] = 1;
9457 is_idchar['$'] = dollars_in_ident;
9458 is_idstart['$'] = dollars_in_ident;
9460 /* horizontal space table */
9461 is_hor_space[' '] = 1;
9462 is_hor_space['\t'] = 1;
9463 is_hor_space['\v'] = 1;
9464 is_hor_space['\f'] = 1;
9465 is_hor_space['\r'] = 1;
9474 char_name['\v'] = "vertical tab";
9475 char_name['\f'] = "formfeed";
9476 char_name['\r'] = "carriage return";
9479 /* Initialize the built-in macros. */
9482 initialize_builtins (inp, outp)
9486 install ((U_CHAR *) "__LINE__", -1, T_SPECLINE, NULL_PTR, -1);
9487 install ((U_CHAR *) "__DATE__", -1, T_DATE, NULL_PTR, -1);
9488 install ((U_CHAR *) "__FILE__", -1, T_FILE, NULL_PTR, -1);
9489 install ((U_CHAR *) "__BASE_FILE__", -1, T_BASE_FILE, NULL_PTR, -1);
9490 install ((U_CHAR *) "__INCLUDE_LEVEL__", -1, T_INCLUDE_LEVEL, NULL_PTR, -1);
9491 install ((U_CHAR *) "__VERSION__", -1, T_VERSION, NULL_PTR, -1);
9492 #ifndef NO_BUILTIN_SIZE_TYPE
9493 install ((U_CHAR *) "__SIZE_TYPE__", -1, T_SIZE_TYPE, NULL_PTR, -1);
9495 #ifndef NO_BUILTIN_PTRDIFF_TYPE
9496 install ((U_CHAR *) "__PTRDIFF_TYPE__ ", -1, T_PTRDIFF_TYPE, NULL_PTR, -1);
9498 install ((U_CHAR *) "__WCHAR_TYPE__", -1, T_WCHAR_TYPE, NULL_PTR, -1);
9499 install ((U_CHAR *) "__USER_LABEL_PREFIX__", -1, T_USER_LABEL_PREFIX_TYPE,
9501 install ((U_CHAR *) "__REGISTER_PREFIX__", -1, T_REGISTER_PREFIX_TYPE,
9503 install ((U_CHAR *) "__IMMEDIATE_PREFIX__", -1, T_IMMEDIATE_PREFIX_TYPE,
9505 install ((U_CHAR *) "__TIME__", -1, T_TIME, NULL_PTR, -1);
9507 install ((U_CHAR *) "__STDC__", -1, T_CONST, "1", -1);
9508 install ((U_CHAR *) "__STDC_VERSION__", -1, T_CONST, "199409L", -1);
9511 install ((U_CHAR *) "__OBJC__", -1, T_CONST, "1", -1);
9512 /* This is supplied using a -D by the compiler driver
9513 so that it is present only when truly compiling with GNU C. */
9514 /* install ((U_CHAR *) "__GNUC__", -1, T_CONST, "2", -1); */
9515 install ((U_CHAR *) "__HAVE_BUILTIN_SETJMP__", -1, T_CONST, "1", -1);
9519 char directive[2048];
9520 U_CHAR *udirective = (U_CHAR *) directive;
9521 register struct directive *dp = &directive_table[0];
9522 struct tm *timebuf = timestamp ();
9524 sprintf (directive, " __BASE_FILE__ \"%s\"\n",
9525 instack[0].nominal_fname);
9526 output_line_directive (inp, outp, 0, same_file);
9527 pass_thru_directive (udirective, &udirective[strlen (directive)],
9530 sprintf (directive, " __VERSION__ \"%s\"\n", version_string);
9531 output_line_directive (inp, outp, 0, same_file);
9532 pass_thru_directive (udirective, &udirective[strlen (directive)],
9535 #ifndef NO_BUILTIN_SIZE_TYPE
9536 sprintf (directive, " __SIZE_TYPE__ %s\n", SIZE_TYPE);
9537 output_line_directive (inp, outp, 0, same_file);
9538 pass_thru_directive (udirective, &udirective[strlen (directive)],
9542 #ifndef NO_BUILTIN_PTRDIFF_TYPE
9543 sprintf (directive, " __PTRDIFF_TYPE__ %s\n", PTRDIFF_TYPE);
9544 output_line_directive (inp, outp, 0, same_file);
9545 pass_thru_directive (udirective, &udirective[strlen (directive)],
9549 sprintf (directive, " __WCHAR_TYPE__ %s\n", wchar_type);
9550 output_line_directive (inp, outp, 0, same_file);
9551 pass_thru_directive (udirective, &udirective[strlen (directive)],
9554 sprintf (directive, " __DATE__ \"%s %2d %4d\"\n",
9555 monthnames[timebuf->tm_mon],
9556 timebuf->tm_mday, timebuf->tm_year + 1900);
9557 output_line_directive (inp, outp, 0, same_file);
9558 pass_thru_directive (udirective, &udirective[strlen (directive)],
9561 sprintf (directive, " __TIME__ \"%02d:%02d:%02d\"\n",
9562 timebuf->tm_hour, timebuf->tm_min, timebuf->tm_sec);
9563 output_line_directive (inp, outp, 0, same_file);
9564 pass_thru_directive (udirective, &udirective[strlen (directive)],
9569 sprintf (directive, " __STDC__ 1");
9570 output_line_directive (inp, outp, 0, same_file);
9571 pass_thru_directive (udirective, &udirective[strlen (directive)],
9576 sprintf (directive, " __OBJC__ 1");
9577 output_line_directive (inp, outp, 0, same_file);
9578 pass_thru_directive (udirective, &udirective[strlen (directive)],
9585 * process a given definition string, for initialization
9586 * If STR is just an identifier, define it with value 1.
9587 * If STR has anything after the identifier, then it should
9588 * be identifier=definition.
9592 make_definition (str, op)
9597 struct directive *kt;
9600 p = buf = (U_CHAR *) str;
9601 if (!is_idstart[*p]) {
9602 error ("malformed option `-D %s'", str);
9605 while (is_idchar[*++p])
9608 while (is_idchar[*++p] || *p == ',' || is_hor_space[*p])
9611 p = (U_CHAR *) str; /* Error */
9614 buf = (U_CHAR *) alloca (p - buf + 4);
9615 strcpy ((char *)buf, str);
9616 strcat ((char *)buf, " 1");
9617 } else if (*p != '=') {
9618 error ("malformed option `-D %s'", str);
9622 /* Copy the entire option so we can modify it. */
9623 buf = (U_CHAR *) alloca (2 * strlen (str) + 1);
9624 strncpy ((char *) buf, str, p - (U_CHAR *) str);
9625 /* Change the = to a space. */
9626 buf[p - (U_CHAR *) str] = ' ';
9627 /* Scan for any backslash-newline and remove it. */
9629 q = &buf[p - (U_CHAR *) str];
9631 if (*p == '\"' || *p == '\'') {
9632 int unterminated = 0;
9633 U_CHAR *p1 = skip_quoted_string (p, p + strlen ((char *) p), 0,
9634 NULL_PTR, NULL_PTR, &unterminated);
9638 if (*p == '\\' && p[1] == '\n')
9642 } else if (*p == '\\' && p[1] == '\n')
9644 /* Change newline chars into newline-markers. */
9645 else if (*p == '\n')
9657 ip = &instack[++indepth];
9658 ip->nominal_fname = ip->fname = "*Initialization*";
9660 ip->buf = ip->bufp = buf;
9661 ip->length = strlen ((char *) buf);
9665 ip->if_stack = if_stack;
9666 ip->system_header_p = 0;
9668 for (kt = directive_table; kt->type != T_DEFINE; kt++)
9671 /* Pass NULL instead of OP, since this is a "predefined" macro. */
9672 do_define (buf, buf + strlen ((char *) buf), NULL_PTR, kt);
9676 /* JF, this does the work for the -U option */
9679 make_undef (str, op)
9684 struct directive *kt;
9686 ip = &instack[++indepth];
9687 ip->nominal_fname = ip->fname = "*undef*";
9689 ip->buf = ip->bufp = (U_CHAR *) str;
9690 ip->length = strlen (str);
9694 ip->if_stack = if_stack;
9695 ip->system_header_p = 0;
9697 for (kt = directive_table; kt->type != T_UNDEF; kt++)
9700 do_undef ((U_CHAR *) str, (U_CHAR *) str + strlen (str), op, kt);
9704 /* Process the string STR as if it appeared as the body of a #assert.
9705 OPTION is the option name for which STR was the argument. */
9708 make_assertion (option, str)
9713 struct directive *kt;
9714 U_CHAR *buf, *p, *q;
9716 /* Copy the entire option so we can modify it. */
9717 buf = (U_CHAR *) alloca (strlen (str) + 1);
9718 strcpy ((char *) buf, str);
9719 /* Scan for any backslash-newline and remove it. */
9722 if (*p == '\\' && p[1] == '\n')
9730 if (!is_idstart[*p]) {
9731 error ("malformed option `%s %s'", option, str);
9734 while (is_idchar[*++p])
9736 SKIP_WHITE_SPACE (p);
9737 if (! (*p == 0 || *p == '(')) {
9738 error ("malformed option `%s %s'", option, str);
9742 ip = &instack[++indepth];
9743 ip->nominal_fname = ip->fname = "*Initialization*";
9745 ip->buf = ip->bufp = buf;
9746 ip->length = strlen ((char *) buf);
9750 ip->if_stack = if_stack;
9751 ip->system_header_p = 0;
9753 for (kt = directive_table; kt->type != T_ASSERT; kt++)
9756 /* pass NULL as output ptr to do_define since we KNOW it never
9757 does any output.... */
9758 do_assert (buf, buf + strlen ((char *) buf) , NULL_PTR, kt);
9762 /* The previous include prefix, if any, is PREV_FILE_NAME.
9763 Allocate a new include prefix whose name is the
9764 simplified concatenation of PREFIX and NAME,
9765 with a trailing / added if needed.
9766 But return 0 if the include prefix should be ignored,
9767 e.g. because it is a duplicate of PREV_FILE_NAME. */
9769 static struct file_name_list *
9770 new_include_prefix (prev_file_name, prefix, name)
9771 struct file_name_list *prev_file_name;
9776 fatal ("Directory name missing after command line option");
9779 /* Ignore the empty string. */
9782 struct file_name_list *dir
9783 = ((struct file_name_list *)
9784 xmalloc (sizeof (struct file_name_list)
9785 + strlen (prefix) + strlen (name) + 1 /* for trailing / */));
9787 strcpy (dir->fname, prefix);
9788 strcat (dir->fname, name);
9789 len = simplify_filename (dir->fname);
9791 /* Convert directory name to a prefix. */
9792 if (dir->fname[len - 1] != '/') {
9793 if (len == 1 && dir->fname[len - 1] == '.')
9796 dir->fname[len++] = '/';
9797 dir->fname[len] = 0;
9800 /* Ignore a directory whose name matches the previous one. */
9801 if (prev_file_name && !strcmp (prev_file_name->fname, dir->fname)) {
9802 /* But treat `-Idir -I- -Idir' as `-I- -Idir'. */
9803 if (!first_bracket_include)
9804 first_bracket_include = prev_file_name;
9810 /* VMS can't stat dir prefixes, so skip these optimizations in VMS. */
9812 /* Ignore a nonexistent directory. */
9813 if (stat (len ? dir->fname : ".", &dir->st) != 0) {
9814 if (errno != ENOENT && errno != ENOTDIR)
9815 error_from_errno (dir->fname);
9820 /* Ignore a directory whose identity matches the previous one. */
9822 && INO_T_EQ (prev_file_name->st.st_ino, dir->st.st_ino)
9823 && prev_file_name->st.st_dev == dir->st.st_dev) {
9824 /* But treat `-Idir -I- -Idir' as `-I- -Idir'. */
9825 if (!first_bracket_include)
9826 first_bracket_include = prev_file_name;
9833 dir->c_system_include_path = 0;
9834 dir->got_name_map = 0;
9840 /* Append a chain of `struct file_name_list's
9841 to the end of the main include chain.
9842 FIRST is the beginning of the chain to append, and LAST is the end. */
9845 append_include_chain (first, last)
9846 struct file_name_list *first, *last;
9848 struct file_name_list *dir;
9850 if (!first || !last)
9856 last_include->next = first;
9858 if (first_bracket_include == 0)
9859 first_bracket_include = first;
9861 for (dir = first; ; dir = dir->next) {
9862 int len = strlen (dir->fname) + INCLUDE_LEN_FUDGE;
9863 if (len > max_include_len)
9864 max_include_len = len;
9870 last_include = last;
9873 /* Add output to `deps_buffer' for the -M switch.
9874 STRING points to the text to be output.
9875 SPACER is ':' for targets, ' ' for dependencies. */
9878 deps_output (string, spacer)
9882 int size = strlen (string);
9887 #ifndef MAX_OUTPUT_COLUMNS
9888 #define MAX_OUTPUT_COLUMNS 72
9890 if (MAX_OUTPUT_COLUMNS - 1 /*spacer*/ - 2 /*` \'*/ < deps_column + size
9891 && 1 < deps_column) {
9892 bcopy (" \\\n ", &deps_buffer[deps_size], 4);
9899 if (deps_size + size + 8 > deps_allocated_size) {
9900 deps_allocated_size = (deps_size + size + 50) * 2;
9901 deps_buffer = xrealloc (deps_buffer, deps_allocated_size);
9903 if (spacer == ' ') {
9904 deps_buffer[deps_size++] = ' ';
9907 bcopy (string, &deps_buffer[deps_size], size);
9909 deps_column += size;
9910 if (spacer == ':') {
9911 deps_buffer[deps_size++] = ':';
9914 deps_buffer[deps_size] = 0;
9918 fatal (PRINTF_ALIST (msg))
9923 fprintf (stderr, "%s: ", progname);
9924 VA_START (args, msg);
9925 vfprintf (stderr, msg, args);
9927 fprintf (stderr, "\n");
9928 exit (FATAL_EXIT_CODE);
9931 /* More 'friendly' abort that prints the line and file.
9932 config.h can #define abort fancy_abort if you like that sort of thing. */
9937 fatal ("Internal gcc abort.");
9941 perror_with_name (name)
9944 fprintf (stderr, "%s: ", progname);
9945 fprintf (stderr, "%s: %s\n", name, my_strerror (errno));
9950 pfatal_with_name (name)
9953 perror_with_name (name);
9957 exit (FATAL_EXIT_CODE);
9961 /* Handler for SIGPIPE. */
9965 /* If this is missing, some compilers complain. */
9968 fatal ("output pipe has been closed");
9974 fatal ("Memory exhausted.");
9982 register GENERIC_PTR ptr = (GENERIC_PTR) malloc (size);
9989 xrealloc (old, size)
9993 register GENERIC_PTR ptr = (GENERIC_PTR) realloc (old, size);
10000 xcalloc (number, size)
10001 size_t number, size;
10003 register size_t total = number * size;
10004 register GENERIC_PTR ptr = (GENERIC_PTR) malloc (total);
10007 bzero (ptr, total);
10015 size_t size = strlen (input);
10016 char *output = xmalloc (size + 1);
10017 strcpy (output, input);
10023 /* Under VMS we need to fix up the "include" specification
10024 filename so that everything following the 1st slash is
10025 changed into its correct VMS file specification. */
10028 hack_vms_include_specification (fname)
10031 register char *cp, *cp1, *cp2;
10032 int f, check_filename_before_returning;
10035 check_filename_before_returning = 0;
10037 cp = base_name (fname);
10040 * Check if we have a vax-c style '#include filename'
10041 * and add the missing .h
10043 if (!index (cp,'.'))
10046 cp2 = Local; /* initialize */
10048 /* We are trying to do a number of things here. First of all, we are
10049 trying to hammer the filenames into a standard format, such that later
10050 processing can handle them.
10052 If the file name contains something like [dir.], then it recognizes this
10053 as a root, and strips the ".]". Later processing will add whatever is
10054 needed to get things working properly.
10056 If no device is specified, then the first directory name is taken to be
10057 a device name (or a rooted logical). */
10059 /* See if we found that 1st slash */
10060 if (cp == 0) return; /* Nothing to do!!! */
10061 if (*cp != '/') return; /* Nothing to do!!! */
10062 /* Point to the UNIX filename part (which needs to be fixed!) */
10064 /* If the directory spec is not rooted, we can just copy
10065 the UNIX filename part and we are done */
10066 if (((cp - fname) > 1) && ((cp[-1] == ']') || (cp[-1] == '>'))) {
10067 if (cp[-2] != '.') {
10069 * The VMS part ends in a `]', and the preceding character is not a `.'.
10070 * We strip the `]', and then splice the two parts of the name in the
10071 * usual way. Given the default locations for include files in cccp.c,
10072 * we will only use this code if the user specifies alternate locations
10073 * with the /include (-I) switch on the command line. */
10074 cp -= 1; /* Strip "]" */
10075 cp1--; /* backspace */
10078 * The VMS part has a ".]" at the end, and this will not do. Later
10079 * processing will add a second directory spec, and this would be a syntax
10080 * error. Thus we strip the ".]", and thus merge the directory specs.
10081 * We also backspace cp1, so that it points to a '/'. This inhibits the
10082 * generation of the 000000 root directory spec (which does not belong here
10085 cp -= 2; /* Strip ".]" */
10086 cp1--; }; /* backspace */
10089 /* We drop in here if there is no VMS style directory specification yet.
10090 * If there is no device specification either, we make the first dir a
10091 * device and try that. If we do not do this, then we will be essentially
10092 * searching the users default directory (as if they did a #include "asdf.h").
10094 * Then all we need to do is to push a '[' into the output string. Later
10095 * processing will fill this in, and close the bracket.
10097 if (cp[-1] != ':') *cp2++ = ':'; /* dev not in spec. take first dir */
10098 *cp2++ = '['; /* Open the directory specification */
10101 /* at this point we assume that we have the device spec, and (at least
10102 the opening "[" for a directory specification. We may have directories
10103 specified already */
10105 /* If there are no other slashes then the filename will be
10106 in the "root" directory. Otherwise, we need to add
10107 directory specifications. */
10108 if (index (cp1, '/') == 0) {
10109 /* Just add "000000]" as the directory string */
10110 strcpy (cp2, "000000]");
10111 cp2 += strlen (cp2);
10112 check_filename_before_returning = 1; /* we might need to fool with this later */
10114 /* As long as there are still subdirectories to add, do them. */
10115 while (index (cp1, '/') != 0) {
10116 /* If this token is "." we can ignore it */
10117 if ((cp1[0] == '.') && (cp1[1] == '/')) {
10121 /* Add a subdirectory spec. Do not duplicate "." */
10122 if (cp2[-1] != '.' && cp2[-1] != '[' && cp2[-1] != '<')
10124 /* If this is ".." then the spec becomes "-" */
10125 if ((cp1[0] == '.') && (cp1[1] == '.') && (cp[2] == '/')) {
10126 /* Add "-" and skip the ".." */
10131 /* Copy the subdirectory */
10132 while (*cp1 != '/') *cp2++= *cp1++;
10133 cp1++; /* Skip the "/" */
10135 /* Close the directory specification */
10136 if (cp2[-1] == '.') /* no trailing periods */
10140 /* Now add the filename */
10141 while (*cp1) *cp2++ = *cp1++;
10143 /* Now append it to the original VMS spec. */
10144 strcpy (cp, Local);
10146 /* If we put a [000000] in the filename, try to open it first. If this fails,
10147 remove the [000000], and return that name. This provides flexibility
10148 to the user in that they can use both rooted and non-rooted logical names
10149 to point to the location of the file. */
10151 if (check_filename_before_returning) {
10152 f = open (fname, O_RDONLY, 0666);
10154 /* The file name is OK as it is, so return it as is. */
10158 /* The filename did not work. Try to remove the [000000] from the name,
10160 cp = index (fname, '[');
10161 cp2 = index (fname, ']') + 1;
10162 strcpy (cp, cp2); /* this gets rid of it */
10170 /* These are the read/write replacement routines for
10171 VAX-11 "C". They make read/write behave enough
10172 like their UNIX counterparts that CCCP will work */
10175 read (fd, buf, size)
10180 #undef read /* Get back the REAL read routine */
10182 register int total = 0;
10184 /* Read until the buffer is exhausted */
10186 /* Limit each read to 32KB */
10187 i = (size > (32*1024)) ? (32*1024) : size;
10188 i = read (fd, buf, i);
10190 if (i == 0) return (total);
10193 /* Account for this read */
10202 write (fd, buf, size)
10207 #undef write /* Get back the REAL write routine */
10211 /* Limit individual writes to 32Kb */
10214 j = (i > (32*1024)) ? (32*1024) : i;
10215 if (write (fd, buf, j) < 0) return (-1);
10216 /* Account for the data written */
10223 /* The following wrapper functions supply additional arguments to the VMS
10224 I/O routines to optimize performance with file handling. The arguments
10226 "mbc=16" - Set multi-block count to 16 (use a 8192 byte buffer).
10227 "deq=64" - When extending the file, extend it in chunks of 32Kbytes.
10228 "fop=tef"- Truncate unused portions of file when closing file.
10229 "shr=nil"- Disallow file sharing while file is open.
10233 freopen (fname, type, oldfile)
10238 #undef freopen /* Get back the REAL fopen routine */
10239 if (strcmp (type, "w") == 0)
10240 return freopen (fname, type, oldfile, "mbc=16", "deq=64", "fop=tef", "shr=nil");
10241 return freopen (fname, type, oldfile, "mbc=16");
10245 fopen (fname, type)
10249 #undef fopen /* Get back the REAL fopen routine */
10250 /* The gcc-vms-1.42 distribution's header files prototype fopen with two
10251 fixed arguments, which matches ANSI's specification but not VAXCRTL's
10252 pre-ANSI implementation. This hack circumvents the mismatch problem. */
10253 FILE *(*vmslib_fopen)() = (FILE *(*)()) fopen;
10256 return (*vmslib_fopen) (fname, type, "mbc=32",
10257 "deq=64", "fop=tef", "shr=nil");
10259 return (*vmslib_fopen) (fname, type, "mbc=32");
10263 open (fname, flags, prot)
10268 #undef open /* Get back the REAL open routine */
10269 return open (fname, flags, prot, "mbc=16", "deq=64", "fop=tef");
10272 /* more VMS hackery */
10276 extern unsigned long sys$parse(), sys$search();
10278 /* Work around another library bug. If a file is located via a searchlist,
10279 and if the device it's on is not the same device as the one specified
10280 in the first element of that searchlist, then both stat() and fstat()
10281 will fail to return info about it. `errno' will be set to EVMSERR, and
10282 `vaxc$errno' will be set to SS$_NORMAL due yet another bug in stat()!
10283 We can get around this by fully parsing the filename and then passing
10284 that absolute name to stat().
10286 Without this fix, we can end up failing to find header files, which is
10287 bad enough, but then compounding the problem by reporting the reason for
10288 failure as "normal successful completion." */
10290 #undef fstat /* get back to library version */
10293 VMS_fstat (fd, statbuf)
10295 struct stat *statbuf;
10297 int result = fstat (fd, statbuf);
10302 char nambuf[NAM$C_MAXRSS+1];
10304 if ((fp = fdopen (fd, "r")) != 0 && fgetname (fp, nambuf) != 0)
10305 result = VMS_stat (nambuf, statbuf);
10306 /* No fclose(fp) here; that would close(fd) as well. */
10313 VMS_stat (name, statbuf)
10315 struct stat *statbuf;
10317 int result = stat (name, statbuf);
10323 char exp_nam[NAM$C_MAXRSS+1], /* expanded name buffer for sys$parse */
10324 res_nam[NAM$C_MAXRSS+1]; /* resultant name buffer for sys$search */
10327 fab.fab$l_fna = (char *) name;
10328 fab.fab$b_fns = (unsigned char) strlen (name);
10329 fab.fab$l_nam = (void *) &nam;
10331 nam.nam$l_esa = exp_nam, nam.nam$b_ess = sizeof exp_nam - 1;
10332 nam.nam$l_rsa = res_nam, nam.nam$b_rss = sizeof res_nam - 1;
10333 nam.nam$b_nop = NAM$M_PWD | NAM$M_NOCONCEAL;
10334 if (sys$parse (&fab) & 1)
10336 if (sys$search (&fab) & 1)
10338 res_nam[nam.nam$b_rsl] = '\0';
10339 result = stat (res_nam, statbuf);
10341 /* Clean up searchlist context cached by the system. */
10342 nam.nam$b_nop = NAM$M_SYNCHK;
10343 fab.fab$l_fna = 0, fab.fab$b_fns = 0;
10344 (void) sys$parse (&fab);