1 /* C Compatible Compiler Preprocessor (CCCP)
2 Copyright (C) 1986, 87, 89, 92, 93, 94, 1995 Free Software Foundation, Inc.
3 Written by Paul Rubin, June 1986
4 Adapted to ANSI C, Richard Stallman, Jan 1987
6 This program is free software; you can redistribute it and/or modify it
7 under the terms of the GNU General Public License as published by the
8 Free Software Foundation; either version 2, or (at your option) any
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with this program; if not, write to the Free Software
18 Foundation, 59 Temple Place - Suite 330,
19 Boston, MA 02111-1307, USA.
21 In other words, you are welcome to use, share and improve this program.
22 You are forbidden to forbid anyone else to use, share and improve
23 what you give them. Help stamp out software-hoarding! */
25 typedef unsigned char U_CHAR
;
29 #include "../src/config.h"
37 /* The macro EMACS is defined when cpp is distributed as part of Emacs,
38 for the sake of machines with limited C compilers. */
41 #endif /* not EMACS */
43 #ifndef STANDARD_INCLUDE_DIR
44 #define STANDARD_INCLUDE_DIR "/usr/include"
47 #ifndef LOCAL_INCLUDE_DIR
48 #define LOCAL_INCLUDE_DIR "/usr/local/include"
51 #if 0 /* We can't get ptrdiff_t, so I arranged not to need PTR_INT_TYPE. */
53 #define PTR_INT_TYPE ptrdiff_t
55 #define PTR_INT_TYPE long
61 /* By default, colon separates directories in a path. */
62 #ifndef PATH_SEPARATOR
63 #define PATH_SEPARATOR ':'
66 #include <sys/types.h>
72 /* The following symbols should be autoconfigured:
79 In the mean time, we'll get by with approximations based
80 on existing GCC configuration symbols. */
83 # ifndef HAVE_STDLIB_H
84 # define HAVE_STDLIB_H 1
86 # ifndef HAVE_UNISTD_H
87 # define HAVE_UNISTD_H 1
90 # define STDC_HEADERS 1
92 #endif /* defined (POSIX) */
94 #if defined (POSIX) || (defined (USG) && !defined (VMS))
96 # define HAVE_FCNTL_H 1
103 # if TIME_WITH_SYS_TIME
104 # include <sys/time.h>
108 # include <sys/time.h>
113 # include <sys/resource.h>
120 /* This defines "errno" properly for VMS, and gives us EACCES. */
132 # define bcmp(a, b, n) memcmp (a, b, n)
135 # define bcopy(s, d, n) memcpy (d, s, n)
138 # define bzero(d, n) memset (d, 0, n)
140 #else /* !STDC_HEADERS */
144 # if !defined (BSTRING) && (defined (USG) || defined (VMS))
147 # define bcmp my_bcmp
160 # endif /* !defined (bcmp) */
163 # define bcopy my_bcopy
173 # endif /* !defined (bcopy) */
176 # define bzero my_bzero
180 register unsigned length
;
185 # endif /* !defined (bzero) */
187 # endif /* !defined (BSTRING) && (defined (USG) || defined (VMS)) */
188 #endif /* ! STDC_HEADERS */
190 #if __GNUC__ < 2 || (__GNUC__ == 2 && __GNUC_MINOR__ < 6)
191 # define __attribute__(x)
195 # if defined (USE_PROTOTYPES) ? USE_PROTOTYPES : defined (__STDC__)
196 # define PROTO(ARGS) ARGS
198 # define PROTO(ARGS) ()
202 #if defined (__STDC__) && defined (HAVE_VPRINTF)
204 # define VA_START(va_list, var) va_start (va_list, var)
205 # define PRINTF_ALIST(msg) char *msg, ...
206 # define PRINTF_DCL(msg)
207 # define PRINTF_PROTO(ARGS, m, n) PROTO (ARGS) __attribute__ ((format (printf, m, n)))
209 # include <varargs.h>
210 # define VA_START(va_list, var) va_start (va_list)
211 # define PRINTF_ALIST(msg) msg, va_alist
212 # define PRINTF_DCL(msg) char *msg; va_dcl
213 # define PRINTF_PROTO(ARGS, m, n) () __attribute__ ((format (printf, m, n)))
214 # define vfprintf(file, msg, args) \
216 char *a0 = va_arg(args, char *); \
217 char *a1 = va_arg(args, char *); \
218 char *a2 = va_arg(args, char *); \
219 char *a3 = va_arg(args, char *); \
220 fprintf (file, msg, a0, a1, a2, a3); \
224 #define PRINTF_PROTO_1(ARGS) PRINTF_PROTO(ARGS, 1, 2)
225 #define PRINTF_PROTO_2(ARGS) PRINTF_PROTO(ARGS, 2, 3)
226 #define PRINTF_PROTO_3(ARGS) PRINTF_PROTO(ARGS, 3, 4)
232 /* VMS-specific definitions */
235 #define O_RDONLY 0 /* Open arg for Read/Only */
236 #define O_WRONLY 1 /* Open arg for Write/Only */
237 #define read(fd,buf,size) VMS_read (fd,buf,size)
238 #define write(fd,buf,size) VMS_write (fd,buf,size)
239 #define open(fname,mode,prot) VMS_open (fname,mode,prot)
240 #define fopen(fname,mode) VMS_fopen (fname,mode)
241 #define freopen(fname,mode,ofile) VMS_freopen (fname,mode,ofile)
242 #define strncat(dst,src,cnt) VMS_strncat (dst,src,cnt)
243 #define fstat(fd,stbuf) VMS_fstat (fd,stbuf)
244 static int VMS_fstat (), VMS_stat ();
245 static char * VMS_strncat ();
246 static int VMS_read ();
247 static int VMS_write ();
248 static int VMS_open ();
249 static FILE * VMS_fopen ();
250 static FILE * VMS_freopen ();
251 static void hack_vms_include_specification ();
252 typedef struct { unsigned :16, :16, :16; } vms_ino_t
;
253 #define ino_t vms_ino_t
254 #define INCLUDE_LEN_FUDGE 10 /* leave room for VMS syntax conversion */
256 #define BSTRING /* VMS/GCC supplies the bstring routines */
257 #endif /* __GNUC__ */
266 #define MIN(X,Y) ((X) < (Y) ? (X) : (Y))
267 #define MAX(X,Y) ((X) > (Y) ? (X) : (Y))
269 /* Find the largest host integer type and set its size and type. */
271 #ifndef HOST_BITS_PER_WIDE_INT
273 #if HOST_BITS_PER_LONG > HOST_BITS_PER_INT
274 #define HOST_BITS_PER_WIDE_INT HOST_BITS_PER_LONG
275 #define HOST_WIDE_INT long
277 #define HOST_BITS_PER_WIDE_INT HOST_BITS_PER_INT
278 #define HOST_WIDE_INT int
284 #define S_ISREG(m) (((m) & S_IFMT) == S_IFREG)
288 #define S_ISDIR(m) (((m) & S_IFMT) == S_IFDIR)
291 /* Define a generic NULL if one hasn't already been defined. */
298 #if defined (USE_PROTOTYPES) ? USE_PROTOTYPES : defined (__STDC__)
299 #define GENERIC_PTR void *
301 #define GENERIC_PTR char *
306 #define NULL_PTR ((GENERIC_PTR)0)
309 #ifndef INCLUDE_LEN_FUDGE
310 #define INCLUDE_LEN_FUDGE 0
313 /* External declarations. */
315 extern char *version_string
;
317 #ifndef HAVE_STRERROR
320 extern const char *const sys_errlist
[];
322 extern char *sys_errlist
[];
324 #else /* HAVE_STRERROR */
328 char *strerror (int,...);
330 int parse_escape
PROTO((char **));
331 HOST_WIDE_INT parse_c_expression
PROTO((char *));
337 /* Name under which this program was invoked. */
339 static char *progname
;
341 /* Nonzero means use extra default include directories for C++. */
343 static int cplusplus
;
345 /* Nonzero means handle cplusplus style comments */
347 static int cplusplus_comments
;
349 /* Nonzero means handle #import, for objective C. */
353 /* Nonzero means this is an assembly file, and allow
354 unknown directives, which could be comments. */
358 /* Current maximum length of directory names in the search path
359 for include files. (Altered as we get more of them.) */
361 static int max_include_len
;
363 /* Nonzero means turn NOTREACHED into #pragma NOTREACHED etc */
365 static int for_lint
= 0;
367 /* Nonzero means copy comments into the output file. */
369 static int put_out_comments
= 0;
371 /* Nonzero means don't process the ANSI trigraph sequences. */
373 static int no_trigraphs
= 0;
375 /* Nonzero means print the names of included files rather than
376 the preprocessed output. 1 means just the #include "...",
377 2 means #include <...> as well. */
379 static int print_deps
= 0;
381 /* Nonzero if missing .h files in -M output are assumed to be generated
382 files and not errors. */
384 static int print_deps_missing_files
= 0;
386 /* Nonzero means print names of header files (-H). */
388 static int print_include_names
= 0;
390 /* Nonzero means don't output line number information. */
392 static int no_line_directives
;
394 /* Nonzero means output the text in failing conditionals,
395 inside #failed ... #endfailed. */
397 static int output_conditionals
;
399 /* dump_only means inhibit output of the preprocessed text
400 and instead output the definitions of all user-defined
401 macros in a form suitable for use as input to cccp.
402 dump_names means pass #define and the macro name through to output.
403 dump_definitions means pass the whole definition (plus #define) through
406 static enum {dump_none
, dump_only
, dump_names
, dump_definitions
}
407 dump_macros
= dump_none
;
409 /* Nonzero means pass all #define and #undef directives which we actually
410 process through to the output stream. This feature is used primarily
411 to allow cc1 to record the #defines and #undefs for the sake of
412 debuggers which understand about preprocessor macros, but it may
413 also be useful with -E to figure out how symbols are defined, and
414 where they are defined. */
415 static int debug_output
= 0;
417 /* Nonzero indicates special processing used by the pcp program. The
418 special effects of this mode are:
420 Inhibit all macro expansion, except those inside #if directives.
422 Process #define directives normally, and output their contents
425 Output preconditions to pcp_outfile indicating all the relevant
426 preconditions for use of this file in a later cpp run.
428 static FILE *pcp_outfile
;
430 /* Nonzero means we are inside an IF during a -pcp run. In this mode
431 macro expansion is done, and preconditions are output for all macro
432 uses requiring them. */
433 static int pcp_inside_if
;
435 /* Nonzero means never to include precompiled files.
436 This is 1 since there's no way now to make precompiled files,
437 so it's not worth testing for them. */
438 static int no_precomp
= 1;
440 /* Nonzero means give all the error messages the ANSI standard requires. */
444 /* Nonzero means try to make failure to fit ANSI C an error. */
446 static int pedantic_errors
;
448 /* Nonzero means don't print warning messages. -w. */
450 static int inhibit_warnings
= 0;
452 /* Nonzero means warn if slash-star appears in a comment. */
454 static int warn_comments
;
456 /* Nonzero means warn if a macro argument is (or would be)
457 stringified with -traditional. */
459 static int warn_stringify
;
461 /* Nonzero means warn if there are any trigraphs. */
463 static int warn_trigraphs
;
465 /* Nonzero means warn if #import is used. */
467 static int warn_import
= 1;
469 /* Nonzero means turn warnings into errors. */
471 static int warnings_are_errors
;
473 /* Nonzero means try to imitate old fashioned non-ANSI preprocessor. */
477 /* Nonzero causes output not to be done,
478 but directives such as #define that have side effects
481 static int no_output
;
483 /* Nonzero means this file was included with a -imacros or -include
484 command line and should not be recorded as an include file. */
486 static int no_record_file
;
488 /* Nonzero means that we have finished processing the command line options.
489 This flag is used to decide whether or not to issue certain errors
492 static int done_initializing
= 0;
494 /* Line where a newline was first seen in a string constant. */
496 static int multiline_string_line
= 0;
498 /* I/O buffer structure.
499 The `fname' field is nonzero for source files and #include files
500 and for the dummy text used for -D and -U.
501 It is zero for rescanning results of macro expansion
502 and for expanding macro arguments. */
503 #define INPUT_STACK_MAX 400
504 static struct file_buf
{
506 /* Filename specified with #line directive. */
508 /* Record where in the search path this file was found.
509 For #include_next. */
510 struct file_name_list
*dir
;
515 /* Macro that this level is the expansion of.
516 Included so that we can reenable the macro
517 at the end of this level. */
518 struct hashnode
*macro
;
519 /* Value of if_stack at start of this file.
520 Used to prohibit unmatched #endif (etc) in an include file. */
521 struct if_stack
*if_stack
;
522 /* Object to be freed at end of input at this level. */
524 /* True if this is a header file included using <FILENAME>. */
525 char system_header_p
;
526 } instack
[INPUT_STACK_MAX
];
528 static int last_error_tick
; /* Incremented each time we print it. */
529 static int input_file_stack_tick
; /* Incremented when the status changes. */
531 /* Current nesting level of input sources.
532 `instack[indepth]' is the level currently being read. */
533 static int indepth
= -1;
534 #define CHECK_DEPTH(code) \
535 if (indepth >= (INPUT_STACK_MAX - 1)) \
537 error_with_line (line_for_error (instack[indepth].lineno), \
538 "macro or `#include' recursion too deep"); \
542 /* Current depth in #include directives that use <...>. */
543 static int system_include_depth
= 0;
545 typedef struct file_buf FILE_BUF
;
547 /* The output buffer. Its LENGTH field is the amount of room allocated
548 for the buffer, not the number of chars actually present. To get
549 that, subtract outbuf.buf from outbuf.bufp. */
551 #define OUTBUF_SIZE 10 /* initial size of output buffer */
552 static FILE_BUF outbuf
;
554 /* Grow output buffer OBUF points at
555 so it can hold at least NEEDED more chars. */
557 #define check_expand(OBUF, NEEDED) \
558 (((OBUF)->length - ((OBUF)->bufp - (OBUF)->buf) <= (NEEDED)) \
559 ? grow_outbuf ((OBUF), (NEEDED)) : 0)
561 struct file_name_list
563 struct file_name_list
*next
;
565 /* If the following is nonzero, it is a macro name.
566 Don't include the file again if that macro is defined. */
567 U_CHAR
*control_macro
;
568 /* If the following is nonzero, it is a C-language system include
570 int c_system_include_path
;
571 /* Mapping of file names for this directory. */
572 struct file_name_map
*name_map
;
573 /* Non-zero if name_map is valid. */
577 /* #include "file" looks in source file dir, then stack. */
578 /* #include <file> just looks in the stack. */
579 /* -I directories are added to the end, then the defaults are added. */
581 static struct default_include
{
582 char *fname
; /* The name of the directory. */
583 int cplusplus
; /* Only look here if we're compiling C++. */
584 int cxx_aware
; /* Includes in this directory don't need to
585 be wrapped in extern "C" when compiling
587 } include_defaults_array
[]
588 #ifdef INCLUDE_DEFAULTS
592 /* Pick up GNU C++ specific include files. */
593 { GPLUSPLUS_INCLUDE_DIR
, 1, 1 },
595 /* This is the dir for fixincludes. Put it just before
596 the files that we fix. */
597 { GCC_INCLUDE_DIR
, 0, 0 },
598 /* For cross-compilation, this dir name is generated
599 automatically in Makefile.in. */
600 { CROSS_INCLUDE_DIR
, 0, 0 },
601 /* This is another place that the target system's headers might be. */
602 { TOOL_INCLUDE_DIR
, 0, 0 },
603 #else /* not CROSS_COMPILE */
604 /* This should be /usr/local/include and should come before
605 the fixincludes-fixed header files. */
606 { LOCAL_INCLUDE_DIR
, 0, 1 },
607 /* This is here ahead of GCC_INCLUDE_DIR because assert.h goes here.
608 Likewise, behind LOCAL_INCLUDE_DIR, where glibc puts its assert.h. */
609 { TOOL_INCLUDE_DIR
, 0, 0 },
610 /* This is the dir for fixincludes. Put it just before
611 the files that we fix. */
612 { GCC_INCLUDE_DIR
, 0, 0 },
613 /* Some systems have an extra dir of include files. */
614 #ifdef SYSTEM_INCLUDE_DIR
615 { SYSTEM_INCLUDE_DIR
, 0, 0 },
617 { STANDARD_INCLUDE_DIR
, 0, 0 },
618 #endif /* not CROSS_COMPILE */
621 #endif /* no INCLUDE_DEFAULTS */
623 /* The code looks at the defaults through this pointer, rather than through
624 the constant structure above. This pointer gets changed if an environment
625 variable specifies other defaults. */
626 static struct default_include
*include_defaults
= include_defaults_array
;
628 static struct file_name_list
*include
= 0; /* First dir to search */
629 /* First dir to search for <file> */
630 /* This is the first element to use for #include <...>.
631 If it is 0, use the entire chain for such includes. */
632 static struct file_name_list
*first_bracket_include
= 0;
633 /* This is the first element in the chain that corresponds to
634 a directory of system header files. */
635 static struct file_name_list
*first_system_include
= 0;
636 static struct file_name_list
*last_include
= 0; /* Last in chain */
638 /* Chain of include directories to put at the end of the other chain. */
639 static struct file_name_list
*after_include
= 0;
640 static struct file_name_list
*last_after_include
= 0; /* Last in chain */
642 /* Chain to put at the start of the system include files. */
643 static struct file_name_list
*before_system
= 0;
644 static struct file_name_list
*last_before_system
= 0; /* Last in chain */
646 /* List of included files that contained #pragma once. */
647 static struct file_name_list
*dont_repeat_files
= 0;
649 /* List of other included files.
650 If ->control_macro if nonzero, the file had a #ifndef
651 around the entire contents, and ->control_macro gives the macro name. */
652 static struct file_name_list
*all_include_files
= 0;
654 /* Directory prefix that should replace `/usr' in the standard
655 include file directories. */
656 static char *include_prefix
;
658 /* Global list of strings read in from precompiled files. This list
659 is kept in the order the strings are read in, with new strings being
660 added at the end through stringlist_tailp. We use this list to output
661 the strings at the end of the run.
663 static STRINGDEF
*stringlist
;
664 static STRINGDEF
**stringlist_tailp
= &stringlist
;
667 /* Structure returned by create_definition */
668 typedef struct macrodef MACRODEF
;
671 struct definition
*defn
;
676 enum sharp_token_type
{
677 NO_SHARP_TOKEN
= 0, /* token not present */
679 SHARP_TOKEN
= '#', /* token spelled with # only */
680 WHITE_SHARP_TOKEN
, /* token spelled with # and white space */
682 PERCENT_COLON_TOKEN
= '%', /* token spelled with %: only */
683 WHITE_PERCENT_COLON_TOKEN
/* token spelled with %: and white space */
686 /* Structure allocated for every #define. For a simple replacement
689 nargs = -1, the `pattern' list is null, and the expansion is just
690 the replacement text. Nargs = 0 means a functionlike macro with no args,
692 #define getchar() getc (stdin) .
693 When there are args, the expansion is the replacement text with the
694 args squashed out, and the reflist is a list describing how to
695 build the output from the input: e.g., "3 chars, then the 1st arg,
696 then 9 chars, then the 3rd arg, then 0 chars, then the 2nd arg".
697 The chars here come from the expansion. Whatever is left of the
698 expansion after the last arg-occurrence is copied after that arg.
699 Note that the reflist can be arbitrarily long---
700 its length depends on the number of times the arguments appear in
701 the replacement text, not how many args there are. Example:
702 #define f(x) x+x+x+x+x+x+x would have replacement text "++++++" and
704 { (0, 1), (1, 1), (1, 1), ..., (1, 1), NULL }
705 where (x, y) means (nchars, argno). */
707 typedef struct definition DEFINITION
;
710 int length
; /* length of expansion string */
711 int predefined
; /* True if the macro was builtin or */
712 /* came from the command line */
714 int line
; /* Line number of definition */
715 char *file
; /* File of definition */
716 char rest_args
; /* Nonzero if last arg. absorbs the rest */
718 struct reflist
*next
;
720 enum sharp_token_type stringify
; /* set if a # operator before arg */
721 enum sharp_token_type raw_before
; /* set if a ## operator before arg */
722 enum sharp_token_type raw_after
; /* set if a ## operator after arg */
724 char rest_args
; /* Nonzero if this arg. absorbs the rest */
725 int nchars
; /* Number of literal chars to copy before
726 this arg occurrence. */
727 int argno
; /* Number of arg to substitute (origin-0) */
730 /* Names of macro args, concatenated in reverse order
731 with comma-space between them.
732 The only use of this is that we warn on redefinition
733 if this differs between the old and new definitions. */
738 /* different kinds of things that can appear in the value field
739 of a hash node. Actually, this may be useless now. */
747 * special extension string that can be added to the last macro argument to
748 * allow it to absorb the "rest" of the arguments when expanded. Ex:
749 * #define wow(a, b...) process (b, a, b)
750 * { wow (1, 2, 3); } -> { process (2, 3, 1, 2, 3); }
751 * { wow (one, two); } -> { process (two, one, two); }
752 * if this "rest_arg" is used with the concat token '##' and if it is not
753 * supplied then the token attached to with ## will not be outputted. Ex:
754 * #define wow (a, b...) process (b ## , a, ## b)
755 * { wow (1, 2); } -> { process (2, 1, 2); }
756 * { wow (one); } -> { process (one); {
758 static char rest_extension
[] = "...";
759 #define REST_EXTENSION_LENGTH (sizeof (rest_extension) - 1)
761 /* The structure of a node in the hash table. The hash table
762 has entries for all tokens defined by #define directives (type T_MACRO),
763 plus some special tokens like __LINE__ (these each have their own
764 type, and the appropriate code is run when that type of node is seen.
765 It does not contain control words like "#define", which are recognized
766 by a separate piece of code. */
768 /* different flavors of hash nodes --- also used in keyword table */
770 T_DEFINE
= 1, /* the `#define' keyword */
771 T_INCLUDE
, /* the `#include' keyword */
772 T_INCLUDE_NEXT
, /* the `#include_next' keyword */
773 T_IMPORT
, /* the `#import' keyword */
774 T_IFDEF
, /* the `#ifdef' keyword */
775 T_IFNDEF
, /* the `#ifndef' keyword */
776 T_IF
, /* the `#if' keyword */
777 T_ELSE
, /* `#else' */
778 T_PRAGMA
, /* `#pragma' */
779 T_ELIF
, /* `#elif' */
780 T_UNDEF
, /* `#undef' */
781 T_LINE
, /* `#line' */
782 T_ERROR
, /* `#error' */
783 T_WARNING
, /* `#warning' */
784 T_ENDIF
, /* `#endif' */
785 T_SCCS
, /* `#sccs', used on system V. */
786 T_IDENT
, /* `#ident', used on system V. */
787 T_ASSERT
, /* `#assert', taken from system V. */
788 T_UNASSERT
, /* `#unassert', taken from system V. */
789 T_SPECLINE
, /* special symbol `__LINE__' */
790 T_DATE
, /* `__DATE__' */
791 T_FILE
, /* `__FILE__' */
792 T_BASE_FILE
, /* `__BASE_FILE__' */
793 T_INCLUDE_LEVEL
, /* `__INCLUDE_LEVEL__' */
794 T_VERSION
, /* `__VERSION__' */
795 T_SIZE_TYPE
, /* `__SIZE_TYPE__' */
796 T_PTRDIFF_TYPE
, /* `__PTRDIFF_TYPE__' */
797 T_WCHAR_TYPE
, /* `__WCHAR_TYPE__' */
798 T_USER_LABEL_PREFIX_TYPE
, /* `__USER_LABEL_PREFIX__' */
799 T_REGISTER_PREFIX_TYPE
, /* `__REGISTER_PREFIX__' */
800 T_IMMEDIATE_PREFIX_TYPE
, /* `__IMMEDIATE_PREFIX__' */
801 T_TIME
, /* `__TIME__' */
802 T_CONST
, /* Constant value, used by `__STDC__' */
803 T_MACRO
, /* macro defined by `#define' */
804 T_DISABLED
, /* macro temporarily turned off for rescan */
805 T_SPEC_DEFINED
, /* special `defined' macro for use in #if statements */
806 T_PCSTRING
, /* precompiled string (hashval is KEYDEF *) */
807 T_UNUSED
/* Used for something not defined. */
811 struct hashnode
*next
; /* double links for easy deletion */
812 struct hashnode
*prev
;
813 struct hashnode
**bucket_hdr
; /* also, a back pointer to this node's hash
814 chain is kept, in case the node is the head
815 of the chain and gets deleted. */
816 enum node_type type
; /* type of special token */
817 int length
; /* length of token, for quick comparison */
818 U_CHAR
*name
; /* the actual name */
819 union hashval value
; /* pointer to expansion, or whatever */
822 typedef struct hashnode HASHNODE
;
824 /* Some definitions for the hash table. The hash function MUST be
825 computed as shown in hashf () below. That is because the rescan
826 loop computes the hash value `on the fly' for most tokens,
827 in order to avoid the overhead of a lot of procedure calls to
828 the hashf () function. Hashf () only exists for the sake of
829 politeness, for use when speed isn't so important. */
831 #define HASHSIZE 1403
832 static HASHNODE
*hashtab
[HASHSIZE
];
833 #define HASHSTEP(old, c) ((old << 2) + c)
834 #define MAKE_POS(v) (v & 0x7fffffff) /* make number positive */
836 /* Symbols to predefine. */
838 #ifdef CPP_PREDEFINES
839 static char *predefs
= CPP_PREDEFINES
;
841 static char *predefs
= "";
844 /* We let tm.h override the types used here, to handle trivial differences
845 such as the choice of unsigned int or long unsigned int for size_t.
846 When machines start needing nontrivial differences in the size type,
847 it would be best to do something here to figure out automatically
848 from other information what type to use. */
850 /* The string value for __SIZE_TYPE__. */
853 #define SIZE_TYPE "long unsigned int"
856 /* The string value for __PTRDIFF_TYPE__. */
859 #define PTRDIFF_TYPE "long int"
862 /* The string value for __WCHAR_TYPE__. */
865 #define WCHAR_TYPE "int"
867 char * wchar_type
= WCHAR_TYPE
;
870 /* The string value for __USER_LABEL_PREFIX__ */
872 #ifndef USER_LABEL_PREFIX
873 #define USER_LABEL_PREFIX ""
876 /* The string value for __REGISTER_PREFIX__ */
878 #ifndef REGISTER_PREFIX
879 #define REGISTER_PREFIX ""
882 /* The string value for __IMMEDIATE_PREFIX__ */
884 #ifndef IMMEDIATE_PREFIX
885 #define IMMEDIATE_PREFIX ""
888 /* In the definition of a #assert name, this structure forms
889 a list of the individual values asserted.
890 Each value is itself a list of "tokens".
891 These are strings that are compared by name. */
893 struct tokenlist_list
{
894 struct tokenlist_list
*next
;
895 struct arglist
*tokens
;
898 struct assertion_hashnode
{
899 struct assertion_hashnode
*next
; /* double links for easy deletion */
900 struct assertion_hashnode
*prev
;
901 /* also, a back pointer to this node's hash
902 chain is kept, in case the node is the head
903 of the chain and gets deleted. */
904 struct assertion_hashnode
**bucket_hdr
;
905 int length
; /* length of token, for quick comparison */
906 U_CHAR
*name
; /* the actual name */
907 /* List of token-sequences. */
908 struct tokenlist_list
*value
;
911 typedef struct assertion_hashnode ASSERTION_HASHNODE
;
913 /* Some definitions for the hash table. The hash function MUST be
914 computed as shown in hashf below. That is because the rescan
915 loop computes the hash value `on the fly' for most tokens,
916 in order to avoid the overhead of a lot of procedure calls to
917 the hashf function. hashf only exists for the sake of
918 politeness, for use when speed isn't so important. */
920 #define ASSERTION_HASHSIZE 37
921 static ASSERTION_HASHNODE
*assertion_hashtab
[ASSERTION_HASHSIZE
];
923 /* Nonzero means inhibit macroexpansion of what seem to be
924 assertion tests, in rescan. For #if. */
925 static int assertions_flag
;
927 /* `struct directive' defines one #-directive, including how to handle it. */
929 #define DO_PROTO PROTO((U_CHAR *, U_CHAR *, FILE_BUF *, struct directive *))
932 int length
; /* Length of name */
933 int (*func
) DO_PROTO
; /* Function to handle directive */
934 char *name
; /* Name of directive */
935 enum node_type type
; /* Code which describes which directive. */
936 char angle_brackets
; /* Nonzero => <...> is special. */
937 char traditional_comments
; /* Nonzero: keep comments if -traditional. */
938 char pass_thru
; /* Copy preprocessed directive to output file. */
941 /* These functions are declared to return int instead of void since they
942 are going to be placed in the table and some old compilers have trouble with
943 pointers to functions returning void. */
945 static int do_assert DO_PROTO
;
946 static int do_define DO_PROTO
;
947 static int do_elif DO_PROTO
;
948 static int do_else DO_PROTO
;
949 static int do_endif DO_PROTO
;
950 static int do_error DO_PROTO
;
951 static int do_ident DO_PROTO
;
952 static int do_if DO_PROTO
;
953 static int do_include DO_PROTO
;
954 static int do_line DO_PROTO
;
955 static int do_pragma DO_PROTO
;
956 #ifdef SCCS_DIRECTIVE
957 static int do_sccs DO_PROTO
;
959 static int do_unassert DO_PROTO
;
960 static int do_undef DO_PROTO
;
961 static int do_warning DO_PROTO
;
962 static int do_xifdef DO_PROTO
;
964 /* Here is the actual list of #-directives, most-often-used first. */
966 static struct directive directive_table
[] = {
967 { 6, do_define
, "define", T_DEFINE
, 0, 1},
968 { 2, do_if
, "if", T_IF
},
969 { 5, do_xifdef
, "ifdef", T_IFDEF
},
970 { 6, do_xifdef
, "ifndef", T_IFNDEF
},
971 { 5, do_endif
, "endif", T_ENDIF
},
972 { 4, do_else
, "else", T_ELSE
},
973 { 4, do_elif
, "elif", T_ELIF
},
974 { 4, do_line
, "line", T_LINE
},
975 { 7, do_include
, "include", T_INCLUDE
, 1},
976 { 12, do_include
, "include_next", T_INCLUDE_NEXT
, 1},
977 { 6, do_include
, "import", T_IMPORT
, 1},
978 { 5, do_undef
, "undef", T_UNDEF
},
979 { 5, do_error
, "error", T_ERROR
},
980 { 7, do_warning
, "warning", T_WARNING
},
981 #ifdef SCCS_DIRECTIVE
982 { 4, do_sccs
, "sccs", T_SCCS
},
984 { 6, do_pragma
, "pragma", T_PRAGMA
, 0, 0, 1},
985 { 5, do_ident
, "ident", T_IDENT
},
986 { 6, do_assert
, "assert", T_ASSERT
},
987 { 8, do_unassert
, "unassert", T_UNASSERT
},
988 { -1, 0, "", T_UNUSED
},
991 /* When a directive handler is called,
992 this points to the # (or the : of the %:) that started the directive. */
993 U_CHAR
*directive_start
;
995 /* table to tell if char can be part of a C identifier. */
996 U_CHAR is_idchar
[256];
997 /* table to tell if char can be first char of a c identifier. */
998 U_CHAR is_idstart
[256];
999 /* table to tell if c is horizontal space. */
1000 U_CHAR is_hor_space
[256];
1001 /* table to tell if c is horizontal or vertical space. */
1002 static U_CHAR is_space
[256];
1003 /* names of some characters */
1004 static char *char_name
[256];
1006 #define SKIP_WHITE_SPACE(p) do { while (is_hor_space[*p]) p++; } while (0)
1007 #define SKIP_ALL_WHITE_SPACE(p) do { while (is_space[*p]) p++; } while (0)
1009 static int errors
= 0; /* Error counter for exit code */
1011 /* Name of output file, for error messages. */
1012 static char *out_fname
;
1014 /* Zero means dollar signs are punctuation.
1015 -$ stores 0; -traditional may store 1. Default is 1 for VMS, 0 otherwise.
1016 This must be 0 for correct processing of this ANSI C program:
1018 #define lose(b) foo (b)
1021 static int dollars_in_ident
;
1022 #ifndef DOLLARS_IN_IDENTIFIERS
1023 #define DOLLARS_IN_IDENTIFIERS 1
1027 /* Stack of conditionals currently in progress
1028 (including both successful and failing conditionals). */
1031 struct if_stack
*next
; /* for chaining to the next stack frame */
1032 char *fname
; /* copied from input when frame is made */
1033 int lineno
; /* similarly */
1034 int if_succeeded
; /* true if a leg of this if-group
1035 has been passed through rescan */
1036 U_CHAR
*control_macro
; /* For #ifndef at start of file,
1037 this is the macro name tested. */
1038 enum node_type type
; /* type of last directive seen in this group */
1040 typedef struct if_stack IF_STACK_FRAME
;
1041 static IF_STACK_FRAME
*if_stack
= NULL
;
1043 /* Buffer of -M output. */
1044 static char *deps_buffer
;
1046 /* Number of bytes allocated in above. */
1047 static int deps_allocated_size
;
1049 /* Number of bytes used. */
1050 static int deps_size
;
1052 /* Number of bytes since the last newline. */
1053 static int deps_column
;
1055 /* Nonzero means -I- has been seen,
1056 so don't look for #include "foo" the source-file directory. */
1057 static int ignore_srcdir
;
1059 static int safe_read
PROTO((int, char *, int));
1060 static void safe_write
PROTO((int, char *, int));
1062 int main
PROTO((int, char **));
1064 static void path_include
PROTO((char *));
1066 static U_CHAR
*index0
PROTO((U_CHAR
*, int, size_t));
1068 static void trigraph_pcp
PROTO((FILE_BUF
*));
1070 static void newline_fix
PROTO((U_CHAR
*));
1071 static void name_newline_fix
PROTO((U_CHAR
*));
1073 static char *get_lintcmd
PROTO((U_CHAR
*, U_CHAR
*, U_CHAR
**, int *, int *));
1075 static void rescan
PROTO((FILE_BUF
*, int));
1077 static FILE_BUF expand_to_temp_buffer
PROTO((U_CHAR
*, U_CHAR
*, int, int));
1079 static int handle_directive
PROTO((FILE_BUF
*, FILE_BUF
*));
1081 static struct tm
*timestamp
PROTO((void));
1082 static void special_symbol
PROTO((HASHNODE
*, FILE_BUF
*));
1084 static int redundant_include_p
PROTO((char *));
1085 static is_system_include
PROTO((char *));
1087 static char *read_filename_string
PROTO((int, FILE *));
1088 static struct file_name_map
*read_name_map
PROTO((char *));
1089 static int open_include_file
PROTO((char *, struct file_name_list
*));
1091 static void finclude
PROTO((int, char *, FILE_BUF
*, int, struct file_name_list
*));
1092 static void record_control_macro
PROTO((char *, U_CHAR
*));
1094 static int import_hash
PROTO((char *));
1095 static int lookup_import
PROTO((char *, struct file_name_list
*));
1096 static void add_import
PROTO((int, char *));
1098 static char *check_precompiled
PROTO((int, char *, char **));
1099 static int check_preconditions
PROTO((char *));
1100 static void pcfinclude
PROTO((U_CHAR
*, U_CHAR
*, U_CHAR
*, FILE_BUF
*));
1101 static void pcstring_used
PROTO((HASHNODE
*));
1102 static void write_output
PROTO((void));
1103 static void pass_thru_directive
PROTO((U_CHAR
*, U_CHAR
*, FILE_BUF
*, struct directive
*));
1105 static MACRODEF create_definition
PROTO((U_CHAR
*, U_CHAR
*, FILE_BUF
*));
1107 static int check_macro_name
PROTO((U_CHAR
*, char *));
1108 static int compare_defs
PROTO((DEFINITION
*, DEFINITION
*));
1109 static int comp_def_part
PROTO((int, U_CHAR
*, int, U_CHAR
*, int, int));
1111 static DEFINITION
*collect_expansion
PROTO((U_CHAR
*, U_CHAR
*, int, struct arglist
*));
1113 int check_assertion
PROTO((U_CHAR
*, int, int, struct arglist
*));
1114 static int compare_token_lists
PROTO((struct arglist
*, struct arglist
*));
1116 static struct arglist
*read_token_list
PROTO((U_CHAR
**, U_CHAR
*, int *));
1117 static void free_token_list
PROTO((struct arglist
*));
1119 static ASSERTION_HASHNODE
*assertion_install
PROTO((U_CHAR
*, int, int));
1120 static ASSERTION_HASHNODE
*assertion_lookup
PROTO((U_CHAR
*, int, int));
1121 static void delete_assertion
PROTO((ASSERTION_HASHNODE
*));
1123 static void do_once
PROTO((void));
1125 static HOST_WIDE_INT eval_if_expression
PROTO((U_CHAR
*, int));
1126 static void conditional_skip
PROTO((FILE_BUF
*, int, enum node_type
, U_CHAR
*, FILE_BUF
*));
1127 static void skip_if_group
PROTO((FILE_BUF
*, int, FILE_BUF
*));
1128 static void validate_else
PROTO((U_CHAR
*));
1130 static U_CHAR
*skip_to_end_of_comment
PROTO((FILE_BUF
*, int *, int));
1131 static U_CHAR
*skip_quoted_string
PROTO((U_CHAR
*, U_CHAR
*, int, int *, int *, int *));
1132 static char *quote_string
PROTO((char *, char *));
1133 static U_CHAR
*skip_paren_group
PROTO((FILE_BUF
*));
1135 /* Last arg to output_line_directive. */
1136 enum file_change_code
{same_file
, enter_file
, leave_file
};
1137 static void output_line_directive
PROTO((FILE_BUF
*, FILE_BUF
*, int, enum file_change_code
));
1139 static void macroexpand
PROTO((HASHNODE
*, FILE_BUF
*));
1142 static char *macarg
PROTO((struct argdata
*, int));
1144 static U_CHAR
*macarg1
PROTO((U_CHAR
*, U_CHAR
*, int *, int *, int *, int));
1146 static int discard_comments
PROTO((U_CHAR
*, int, int));
1148 static int change_newlines
PROTO((U_CHAR
*, int));
1150 char *my_strerror
PROTO((int));
1151 void error
PRINTF_PROTO_1((char *, ...));
1152 static void verror
PROTO((char *, va_list));
1153 static void error_from_errno
PROTO((char *));
1154 void warning
PRINTF_PROTO_1((char *, ...));
1155 static void vwarning
PROTO((char *, va_list));
1156 static void error_with_line
PRINTF_PROTO_2((int, char *, ...));
1157 static void verror_with_line
PROTO((int, char *, va_list));
1158 static void vwarning_with_line
PROTO((int, char *, va_list));
1159 void pedwarn
PRINTF_PROTO_1((char *, ...));
1160 void pedwarn_with_line
PRINTF_PROTO_2((int, char *, ...));
1161 static void pedwarn_with_file_and_line
PRINTF_PROTO_3((char *, int, char *, ...));
1163 static void print_containing_files
PROTO((void));
1165 static int line_for_error
PROTO((int));
1166 static int grow_outbuf
PROTO((FILE_BUF
*, int));
1168 static HASHNODE
*install
PROTO((U_CHAR
*, int, enum node_type
, char *, int));
1169 HASHNODE
*lookup
PROTO((U_CHAR
*, int, int));
1170 static void delete_macro
PROTO((HASHNODE
*));
1171 static int hashf
PROTO((U_CHAR
*, int, int));
1173 static void dump_single_macro
PROTO((HASHNODE
*, FILE *));
1174 static void dump_all_macros
PROTO((void));
1175 static void dump_defn_1
PROTO((U_CHAR
*, int, int, FILE *));
1176 static void dump_arg_n
PROTO((DEFINITION
*, int, FILE *));
1178 static void initialize_char_syntax
PROTO((void));
1179 static void initialize_builtins
PROTO((FILE_BUF
*, FILE_BUF
*));
1181 static void make_definition
PROTO((char *, FILE_BUF
*));
1182 static void make_undef
PROTO((char *, FILE_BUF
*));
1184 static void make_assertion
PROTO((char *, char *));
1186 static void append_include_chain
PROTO((struct file_name_list
*, struct file_name_list
*));
1188 static void deps_output
PROTO((char *, int));
1190 static void fatal
PRINTF_PROTO_1((char *, ...)) __attribute__ ((noreturn
));
1191 void fancy_abort
PROTO((void)) __attribute__ ((noreturn
));
1192 static void perror_with_name
PROTO((char *));
1193 static void pfatal_with_name
PROTO((char *)) __attribute__ ((noreturn
));
1194 static void pipe_closed
PROTO((int)) __attribute__ ((noreturn
));
1196 static void memory_full
PROTO((void)) __attribute__ ((noreturn
));
1197 GENERIC_PTR xmalloc
PROTO((size_t));
1198 static GENERIC_PTR xrealloc
PROTO((GENERIC_PTR
, size_t));
1199 static GENERIC_PTR xcalloc
PROTO((size_t, size_t));
1200 static char *savestring
PROTO((char *));
1202 static int file_size_and_mode
PROTO((int, int *, long int *));
1203 static void output_dots
PROTO((FILE *, int));
1205 /* Read LEN bytes at PTR from descriptor DESC, for file FILENAME,
1206 retrying if necessary. Return a negative value if an error occurs,
1207 otherwise return the actual number of bytes read,
1208 which must be LEN unless end-of-file was reached. */
1211 safe_read (desc
, ptr
, len
)
1218 int nchars
= read (desc
, ptr
, left
);
1235 /* Write LEN bytes at PTR to descriptor DESC,
1236 retrying if necessary, and treating any real error as fatal. */
1239 safe_write (desc
, ptr
, len
)
1245 int written
= write (desc
, ptr
, len
);
1252 pfatal_with_name (out_fname
);
1270 char **pend_files
= (char **) xmalloc (argc
* sizeof (char *));
1271 char **pend_defs
= (char **) xmalloc (argc
* sizeof (char *));
1272 char **pend_undefs
= (char **) xmalloc (argc
* sizeof (char *));
1273 char **pend_assertions
= (char **) xmalloc (argc
* sizeof (char *));
1274 char **pend_includes
= (char **) xmalloc (argc
* sizeof (char *));
1276 /* Record the option used with each element of pend_assertions.
1277 This is preparation for supporting more than one option for making
1279 char **pend_assertion_options
= (char **) xmalloc (argc
* sizeof (char *));
1280 int inhibit_predefs
= 0;
1281 int no_standard_includes
= 0;
1282 int no_standard_cplusplus_includes
= 0;
1283 int missing_newline
= 0;
1285 /* Non-0 means don't output the preprocessed program. */
1286 int inhibit_output
= 0;
1287 /* Non-0 means -v, so print the full set of include dirs. */
1290 /* File name which deps are being written to.
1291 This is 0 if deps are being written to stdout. */
1292 char *deps_file
= 0;
1293 /* Fopen file mode to open deps_file with. */
1294 char *deps_mode
= "a";
1295 /* Stream on which to print the dependency information. */
1296 FILE *deps_stream
= 0;
1297 /* Target-name to write with the dependency information. */
1298 char *deps_target
= 0;
1301 /* Get rid of any avoidable limit on stack size. */
1305 /* Set the stack limit huge so that alloca (particularly stringtab
1306 * in dbxread.c) does not fail. */
1307 getrlimit (RLIMIT_STACK
, &rlim
);
1308 rlim
.rlim_cur
= rlim
.rlim_max
;
1309 setrlimit (RLIMIT_STACK
, &rlim
);
1311 #endif /* RLIMIT_STACK defined */
1314 signal (SIGPIPE
, pipe_closed
);
1317 cp
= argv
[0] + strlen (argv
[0]);
1318 while (cp
!= argv
[0] && cp
[-1] != '/'
1319 #ifdef DIR_SEPARATOR
1320 && cp
[-1] != DIR_SEPARATOR
1328 /* Remove directories from PROGNAME. */
1332 if ((p
= rindex (s
, ':')) != 0) s
= p
+ 1; /* skip device */
1333 if ((p
= rindex (s
, ']')) != 0) s
= p
+ 1; /* skip directory */
1334 if ((p
= rindex (s
, '>')) != 0) s
= p
+ 1; /* alternate (int'n'l) dir */
1335 s
= progname
= savestring (s
);
1336 if ((p
= rindex (s
, ';')) != 0) *p
= '\0'; /* strip version number */
1337 if ((p
= rindex (s
, '.')) != 0 /* strip type iff ".exe" */
1338 && (p
[1] == 'e' || p
[1] == 'E')
1339 && (p
[2] == 'x' || p
[2] == 'X')
1340 && (p
[3] == 'e' || p
[3] == 'E')
1349 /* Initialize is_idchar to allow $. */
1350 dollars_in_ident
= 1;
1351 initialize_char_syntax ();
1352 dollars_in_ident
= DOLLARS_IN_IDENTIFIERS
> 0;
1354 no_line_directives
= 0;
1356 dump_macros
= dump_none
;
1359 cplusplus_comments
= 1;
1361 bzero ((char *) pend_files
, argc
* sizeof (char *));
1362 bzero ((char *) pend_defs
, argc
* sizeof (char *));
1363 bzero ((char *) pend_undefs
, argc
* sizeof (char *));
1364 bzero ((char *) pend_assertions
, argc
* sizeof (char *));
1365 bzero ((char *) pend_includes
, argc
* sizeof (char *));
1367 /* Process switches and find input file name. */
1369 for (i
= 1; i
< argc
; i
++) {
1370 if (argv
[i
][0] != '-') {
1371 if (out_fname
!= NULL
)
1372 fatal ("Usage: %s [switches] input output", argv
[0]);
1373 else if (in_fname
!= NULL
)
1374 out_fname
= argv
[i
];
1378 switch (argv
[i
][1]) {
1381 if (!strcmp (argv
[i
], "-include")) {
1383 fatal ("Filename missing after `-include' option");
1385 pend_includes
[i
] = argv
[i
+1], i
++;
1387 if (!strcmp (argv
[i
], "-imacros")) {
1389 fatal ("Filename missing after `-imacros' option");
1391 pend_files
[i
] = argv
[i
+1], i
++;
1393 if (!strcmp (argv
[i
], "-iprefix")) {
1395 fatal ("Filename missing after `-iprefix' option");
1397 include_prefix
= argv
[++i
];
1399 if (!strcmp (argv
[i
], "-ifoutput")) {
1400 output_conditionals
= 1;
1402 if (!strcmp (argv
[i
], "-isystem")) {
1403 struct file_name_list
*dirtmp
;
1406 fatal ("Filename missing after `-isystem' option");
1408 dirtmp
= (struct file_name_list
*)
1409 xmalloc (sizeof (struct file_name_list
));
1411 dirtmp
->control_macro
= 0;
1412 dirtmp
->c_system_include_path
= 1;
1413 dirtmp
->fname
= xmalloc (strlen (argv
[i
+1]) + 1);
1414 strcpy (dirtmp
->fname
, argv
[++i
]);
1415 dirtmp
->got_name_map
= 0;
1417 if (before_system
== 0)
1418 before_system
= dirtmp
;
1420 last_before_system
->next
= dirtmp
;
1421 last_before_system
= dirtmp
; /* Tail follows the last one */
1423 /* Add directory to end of path for includes,
1424 with the default prefix at the front of its name. */
1425 if (!strcmp (argv
[i
], "-iwithprefix")) {
1426 struct file_name_list
*dirtmp
;
1429 if (include_prefix
!= 0)
1430 prefix
= include_prefix
;
1432 prefix
= savestring (GCC_INCLUDE_DIR
);
1433 /* Remove the `include' from /usr/local/lib/gcc.../include. */
1434 if (!strcmp (prefix
+ strlen (prefix
) - 8, "/include"))
1435 prefix
[strlen (prefix
) - 7] = 0;
1438 dirtmp
= (struct file_name_list
*)
1439 xmalloc (sizeof (struct file_name_list
));
1440 dirtmp
->next
= 0; /* New one goes on the end */
1441 dirtmp
->control_macro
= 0;
1442 dirtmp
->c_system_include_path
= 0;
1444 fatal ("Directory name missing after `-iwithprefix' option");
1446 dirtmp
->fname
= xmalloc (strlen (argv
[i
+1]) + strlen (prefix
) + 1);
1447 strcpy (dirtmp
->fname
, prefix
);
1448 strcat (dirtmp
->fname
, argv
[++i
]);
1449 dirtmp
->got_name_map
= 0;
1451 if (after_include
== 0)
1452 after_include
= dirtmp
;
1454 last_after_include
->next
= dirtmp
;
1455 last_after_include
= dirtmp
; /* Tail follows the last one */
1457 /* Add directory to main path for includes,
1458 with the default prefix at the front of its name. */
1459 if (!strcmp (argv
[i
], "-iwithprefixbefore")) {
1460 struct file_name_list
*dirtmp
;
1463 if (include_prefix
!= 0)
1464 prefix
= include_prefix
;
1466 prefix
= savestring (GCC_INCLUDE_DIR
);
1467 /* Remove the `include' from /usr/local/lib/gcc.../include. */
1468 if (!strcmp (prefix
+ strlen (prefix
) - 8, "/include"))
1469 prefix
[strlen (prefix
) - 7] = 0;
1472 dirtmp
= (struct file_name_list
*)
1473 xmalloc (sizeof (struct file_name_list
));
1474 dirtmp
->next
= 0; /* New one goes on the end */
1475 dirtmp
->control_macro
= 0;
1476 dirtmp
->c_system_include_path
= 0;
1478 fatal ("Directory name missing after `-iwithprefixbefore' option");
1480 dirtmp
->fname
= xmalloc (strlen (argv
[i
+1]) + strlen (prefix
) + 1);
1481 strcpy (dirtmp
->fname
, prefix
);
1482 strcat (dirtmp
->fname
, argv
[++i
]);
1483 dirtmp
->got_name_map
= 0;
1485 append_include_chain (dirtmp
, dirtmp
);
1487 /* Add directory to end of path for includes. */
1488 if (!strcmp (argv
[i
], "-idirafter")) {
1489 struct file_name_list
*dirtmp
;
1491 dirtmp
= (struct file_name_list
*)
1492 xmalloc (sizeof (struct file_name_list
));
1493 dirtmp
->next
= 0; /* New one goes on the end */
1494 dirtmp
->control_macro
= 0;
1495 dirtmp
->c_system_include_path
= 0;
1497 fatal ("Directory name missing after `-idirafter' option");
1499 dirtmp
->fname
= argv
[++i
];
1500 dirtmp
->got_name_map
= 0;
1502 if (after_include
== 0)
1503 after_include
= dirtmp
;
1505 last_after_include
->next
= dirtmp
;
1506 last_after_include
= dirtmp
; /* Tail follows the last one */
1511 if (out_fname
!= NULL
)
1512 fatal ("Output filename specified twice");
1514 fatal ("Filename missing after -o option");
1515 out_fname
= argv
[++i
];
1516 if (!strcmp (out_fname
, "-"))
1521 if (!strcmp (argv
[i
], "-pedantic"))
1523 else if (!strcmp (argv
[i
], "-pedantic-errors")) {
1525 pedantic_errors
= 1;
1526 } else if (!strcmp (argv
[i
], "-pcp")) {
1529 fatal ("Filename missing after -pcp option");
1530 pcp_fname
= argv
[++i
];
1532 ((pcp_fname
[0] != '-' || pcp_fname
[1] != '\0')
1533 ? fopen (pcp_fname
, "w")
1535 if (pcp_outfile
== 0)
1536 pfatal_with_name (pcp_fname
);
1542 if (!strcmp (argv
[i
], "-traditional")) {
1544 cplusplus_comments
= 0;
1545 if (dollars_in_ident
> 0)
1546 dollars_in_ident
= 1;
1547 } else if (!strcmp (argv
[i
], "-trigraphs")) {
1553 if (! strcmp (argv
[i
], "-lang-c"))
1554 cplusplus
= 0, cplusplus_comments
= 1, objc
= 0;
1555 if (! strcmp (argv
[i
], "-lang-c89"))
1556 cplusplus
= 0, cplusplus_comments
= 0, objc
= 0;
1557 if (! strcmp (argv
[i
], "-lang-c++"))
1558 cplusplus
= 1, cplusplus_comments
= 1, objc
= 0;
1559 if (! strcmp (argv
[i
], "-lang-objc"))
1560 objc
= 1, cplusplus
= 0, cplusplus_comments
= 1;
1561 if (! strcmp (argv
[i
], "-lang-objc++"))
1562 objc
= 1, cplusplus
= 1, cplusplus_comments
= 1;
1563 if (! strcmp (argv
[i
], "-lang-asm"))
1565 if (! strcmp (argv
[i
], "-lint"))
1570 cplusplus
= 1, cplusplus_comments
= 1;
1574 inhibit_warnings
= 1;
1578 if (!strcmp (argv
[i
], "-Wtrigraphs"))
1580 else if (!strcmp (argv
[i
], "-Wno-trigraphs"))
1582 else if (!strcmp (argv
[i
], "-Wcomment"))
1584 else if (!strcmp (argv
[i
], "-Wno-comment"))
1586 else if (!strcmp (argv
[i
], "-Wcomments"))
1588 else if (!strcmp (argv
[i
], "-Wno-comments"))
1590 else if (!strcmp (argv
[i
], "-Wtraditional"))
1592 else if (!strcmp (argv
[i
], "-Wno-traditional"))
1594 else if (!strcmp (argv
[i
], "-Wimport"))
1596 else if (!strcmp (argv
[i
], "-Wno-import"))
1598 else if (!strcmp (argv
[i
], "-Werror"))
1599 warnings_are_errors
= 1;
1600 else if (!strcmp (argv
[i
], "-Wno-error"))
1601 warnings_are_errors
= 0;
1602 else if (!strcmp (argv
[i
], "-Wall"))
1610 /* The style of the choices here is a bit mixed.
1611 The chosen scheme is a hybrid of keeping all options in one string
1612 and specifying each option in a separate argument:
1613 -M|-MM|-MD file|-MMD file [-MG]. An alternative is:
1614 -M|-MM|-MD file|-MMD file|-MG|-MMG; or more concisely:
1615 -M[M][G][D file]. This is awkward to handle in specs, and is not
1617 /* ??? -MG must be specified in addition to one of -M or -MM.
1618 This can be relaxed in the future without breaking anything.
1619 The converse isn't true. */
1621 /* -MG isn't valid with -MD or -MMD. This is checked for later. */
1622 if (!strcmp (argv
[i
], "-MG"))
1624 print_deps_missing_files
= 1;
1627 if (!strcmp (argv
[i
], "-M"))
1629 else if (!strcmp (argv
[i
], "-MM"))
1631 else if (!strcmp (argv
[i
], "-MD"))
1633 else if (!strcmp (argv
[i
], "-MMD"))
1635 /* For -MD and -MMD options, write deps on file named by next arg. */
1636 if (!strcmp (argv
[i
], "-MD")
1637 || !strcmp (argv
[i
], "-MMD")) {
1639 fatal ("Filename missing after %s option", argv
[i
]);
1641 deps_file
= argv
[i
];
1644 /* For -M and -MM, write deps on standard output
1645 and suppress the usual output. */
1646 deps_stream
= stdout
;
1653 char *p
= argv
[i
] + 2;
1655 while ((c
= *p
++)) {
1656 /* Arg to -d specifies what parts of macros to dump */
1659 dump_macros
= dump_only
;
1663 dump_macros
= dump_names
;
1666 dump_macros
= dump_definitions
;
1674 if (argv
[i
][2] == '3')
1679 fprintf (stderr
, "GNU CPP version %s", version_string
);
1680 #ifdef TARGET_VERSION
1683 fprintf (stderr
, "\n");
1688 print_include_names
= 1;
1692 if (argv
[i
][2] != 0)
1693 pend_defs
[i
] = argv
[i
] + 2;
1694 else if (i
+ 1 == argc
)
1695 fatal ("Macro name missing after -D option");
1697 i
++, pend_defs
[i
] = argv
[i
];
1704 if (argv
[i
][2] != 0)
1706 else if (i
+ 1 == argc
)
1707 fatal ("Assertion missing after -A option");
1711 if (!strcmp (p
, "-")) {
1712 /* -A- eliminates all predefined macros and assertions.
1713 Let's include also any that were specified earlier
1714 on the command line. That way we can get rid of any
1715 that were passed automatically in from GCC. */
1717 inhibit_predefs
= 1;
1718 for (j
= 0; j
< i
; j
++)
1719 pend_defs
[j
] = pend_assertions
[j
] = 0;
1721 pend_assertions
[i
] = p
;
1722 pend_assertion_options
[i
] = "-A";
1727 case 'U': /* JF #undef something */
1728 if (argv
[i
][2] != 0)
1729 pend_undefs
[i
] = argv
[i
] + 2;
1730 else if (i
+ 1 == argc
)
1731 fatal ("Macro name missing after -U option");
1733 pend_undefs
[i
] = argv
[i
+1], i
++;
1737 put_out_comments
= 1;
1740 case 'E': /* -E comes from cc -E; ignore it. */
1744 no_line_directives
= 1;
1747 case '$': /* Don't include $ in identifiers. */
1748 dollars_in_ident
= 0;
1751 case 'I': /* Add directory to path for includes. */
1753 struct file_name_list
*dirtmp
;
1755 if (! ignore_srcdir
&& !strcmp (argv
[i
] + 2, "-")) {
1757 /* Don't use any preceding -I directories for #include <...>. */
1758 first_bracket_include
= 0;
1761 dirtmp
= (struct file_name_list
*)
1762 xmalloc (sizeof (struct file_name_list
));
1763 dirtmp
->next
= 0; /* New one goes on the end */
1764 dirtmp
->control_macro
= 0;
1765 dirtmp
->c_system_include_path
= 0;
1766 if (argv
[i
][2] != 0)
1767 dirtmp
->fname
= argv
[i
] + 2;
1768 else if (i
+ 1 == argc
)
1769 fatal ("Directory name missing after -I option");
1771 dirtmp
->fname
= argv
[++i
];
1772 dirtmp
->got_name_map
= 0;
1773 append_include_chain (dirtmp
, dirtmp
);
1779 if (!strcmp (argv
[i
], "-nostdinc"))
1780 /* -nostdinc causes no default include directories.
1781 You must specify all include-file directories with -I. */
1782 no_standard_includes
= 1;
1783 else if (!strcmp (argv
[i
], "-nostdinc++"))
1784 /* -nostdinc++ causes no default C++-specific include directories. */
1785 no_standard_cplusplus_includes
= 1;
1786 else if (!strcmp (argv
[i
], "-noprecomp"))
1791 /* Sun compiler passes undocumented switch "-undef".
1792 Let's assume it means to inhibit the predefined symbols. */
1793 inhibit_predefs
= 1;
1796 case '\0': /* JF handle '-' as file name meaning stdin or stdout */
1797 if (in_fname
== NULL
) {
1800 } else if (out_fname
== NULL
) {
1803 } /* else fall through into error */
1806 fatal ("Invalid option `%s'", argv
[i
]);
1811 /* Add dirs from CPATH after dirs from -I. */
1812 /* There seems to be confusion about what CPATH should do,
1813 so for the moment it is not documented. */
1814 /* Some people say that CPATH should replace the standard include dirs,
1815 but that seems pointless: it comes before them, so it overrides them
1817 cp
= getenv ("CPATH");
1818 if (cp
&& ! no_standard_includes
)
1821 /* Now that dollars_in_ident is known, initialize is_idchar. */
1822 initialize_char_syntax ();
1824 /* Initialize output buffer */
1826 outbuf
.buf
= (U_CHAR
*) xmalloc (OUTBUF_SIZE
);
1827 outbuf
.bufp
= outbuf
.buf
;
1828 outbuf
.length
= OUTBUF_SIZE
;
1830 /* Do partial setup of input buffer for the sake of generating
1831 early #line directives (when -g is in effect). */
1833 fp
= &instack
[++indepth
];
1834 if (in_fname
== NULL
)
1836 fp
->nominal_fname
= fp
->fname
= in_fname
;
1839 /* In C++, wchar_t is a distinct basic type, and we can expect
1840 __wchar_t to be defined by cc1plus. */
1842 wchar_type
= "__wchar_t";
1844 /* Install __LINE__, etc. Must follow initialize_char_syntax
1845 and option processing. */
1846 initialize_builtins (fp
, &outbuf
);
1848 /* Do standard #defines and assertions
1849 that identify system and machine type. */
1851 if (!inhibit_predefs
) {
1852 char *p
= (char *) alloca (strlen (predefs
) + 1);
1853 strcpy (p
, predefs
);
1856 while (*p
== ' ' || *p
== '\t')
1858 /* Handle -D options. */
1859 if (p
[0] == '-' && p
[1] == 'D') {
1861 while (*p
&& *p
!= ' ' && *p
!= '\t')
1866 output_line_directive (fp
, &outbuf
, 0, same_file
);
1867 make_definition (q
, &outbuf
);
1868 while (*p
== ' ' || *p
== '\t')
1870 } else if (p
[0] == '-' && p
[1] == 'A') {
1871 /* Handle -A options (assertions). */
1880 past_name
= assertion
;
1881 /* Locate end of name. */
1882 while (*past_name
&& *past_name
!= ' '
1883 && *past_name
!= '\t' && *past_name
!= '(')
1885 /* Locate `(' at start of value. */
1887 while (*value
&& (*value
== ' ' || *value
== '\t'))
1889 if (*value
++ != '(')
1891 while (*value
&& (*value
== ' ' || *value
== '\t'))
1894 /* Locate end of value. */
1895 while (*past_value
&& *past_value
!= ' '
1896 && *past_value
!= '\t' && *past_value
!= ')')
1898 termination
= past_value
;
1899 while (*termination
&& (*termination
== ' ' || *termination
== '\t'))
1901 if (*termination
++ != ')')
1903 if (*termination
&& *termination
!= ' ' && *termination
!= '\t')
1905 /* Temporarily null-terminate the value. */
1906 save_char
= *termination
;
1907 *termination
= '\0';
1908 /* Install the assertion. */
1909 make_assertion ("-A", assertion
);
1910 *termination
= (char) save_char
;
1912 while (*p
== ' ' || *p
== '\t')
1920 /* Now handle the command line options. */
1922 /* Do -U's, -D's and -A's in the order they were seen. */
1923 for (i
= 1; i
< argc
; i
++) {
1924 if (pend_undefs
[i
]) {
1926 output_line_directive (fp
, &outbuf
, 0, same_file
);
1927 make_undef (pend_undefs
[i
], &outbuf
);
1931 output_line_directive (fp
, &outbuf
, 0, same_file
);
1932 make_definition (pend_defs
[i
], &outbuf
);
1934 if (pend_assertions
[i
])
1935 make_assertion (pend_assertion_options
[i
], pend_assertions
[i
]);
1938 done_initializing
= 1;
1940 { /* read the appropriate environment variable and if it exists
1941 replace include_defaults with the listed path. */
1943 switch ((objc
<< 1) + cplusplus
)
1946 epath
= getenv ("C_INCLUDE_PATH");
1949 epath
= getenv ("CPLUS_INCLUDE_PATH");
1952 epath
= getenv ("OBJC_INCLUDE_PATH");
1955 epath
= getenv ("OBJCPLUS_INCLUDE_PATH");
1958 /* If the environment var for this language is set,
1959 add to the default list of include directories. */
1961 char *nstore
= (char *) alloca (strlen (epath
) + 2);
1963 char *startp
, *endp
;
1965 for (num_dirs
= 1, startp
= epath
; *startp
; startp
++)
1966 if (*startp
== PATH_SEPARATOR
)
1969 = (struct default_include
*) xmalloc ((num_dirs
1970 * sizeof (struct default_include
))
1971 + sizeof (include_defaults_array
));
1972 startp
= endp
= epath
;
1975 /* Handle cases like c:/usr/lib:d:/gcc/lib */
1976 if ((*endp
== PATH_SEPARATOR
1977 #if 0 /* Obsolete, now that we use semicolons as the path separator. */
1979 && (endp
-startp
!= 1 || !isalpha (*startp
))
1984 strncpy (nstore
, startp
, endp
-startp
);
1986 strcpy (nstore
, ".");
1988 nstore
[endp
-startp
] = '\0';
1990 include_defaults
[num_dirs
].fname
= savestring (nstore
);
1991 include_defaults
[num_dirs
].cplusplus
= cplusplus
;
1992 include_defaults
[num_dirs
].cxx_aware
= 1;
1996 endp
= startp
= endp
+ 1;
2000 /* Put the usual defaults back in at the end. */
2001 bcopy ((char *) include_defaults_array
,
2002 (char *) &include_defaults
[num_dirs
],
2003 sizeof (include_defaults_array
));
2007 append_include_chain (before_system
, last_before_system
);
2008 first_system_include
= before_system
;
2010 /* Unless -fnostdinc,
2011 tack on the standard include file dirs to the specified list */
2012 if (!no_standard_includes
) {
2013 struct default_include
*p
= include_defaults
;
2014 char *specd_prefix
= include_prefix
;
2015 char *default_prefix
= savestring (GCC_INCLUDE_DIR
);
2016 int default_len
= 0;
2017 /* Remove the `include' from /usr/local/lib/gcc.../include. */
2018 if (!strcmp (default_prefix
+ strlen (default_prefix
) - 8, "/include")) {
2019 default_len
= strlen (default_prefix
) - 7;
2020 default_prefix
[default_len
] = 0;
2022 /* Search "translated" versions of GNU directories.
2023 These have /usr/local/lib/gcc... replaced by specd_prefix. */
2024 if (specd_prefix
!= 0 && default_len
!= 0)
2025 for (p
= include_defaults
; p
->fname
; p
++) {
2026 /* Some standard dirs are only for C++. */
2027 if (!p
->cplusplus
|| (cplusplus
&& !no_standard_cplusplus_includes
)) {
2028 /* Does this dir start with the prefix? */
2029 if (!strncmp (p
->fname
, default_prefix
, default_len
)) {
2030 /* Yes; change prefix and add to search list. */
2031 struct file_name_list
*new
2032 = (struct file_name_list
*) xmalloc (sizeof (struct file_name_list
));
2033 int this_len
= strlen (specd_prefix
) + strlen (p
->fname
) - default_len
;
2034 char *str
= xmalloc (this_len
+ 1);
2035 strcpy (str
, specd_prefix
);
2036 strcat (str
, p
->fname
+ default_len
);
2038 new->control_macro
= 0;
2039 new->c_system_include_path
= !p
->cxx_aware
;
2040 new->got_name_map
= 0;
2041 append_include_chain (new, new);
2042 if (first_system_include
== 0)
2043 first_system_include
= new;
2047 /* Search ordinary names for GNU include directories. */
2048 for (p
= include_defaults
; p
->fname
; p
++) {
2049 /* Some standard dirs are only for C++. */
2050 if (!p
->cplusplus
|| (cplusplus
&& !no_standard_cplusplus_includes
)) {
2051 struct file_name_list
*new
2052 = (struct file_name_list
*) xmalloc (sizeof (struct file_name_list
));
2053 new->control_macro
= 0;
2054 new->c_system_include_path
= !p
->cxx_aware
;
2055 new->fname
= p
->fname
;
2056 new->got_name_map
= 0;
2057 append_include_chain (new, new);
2058 if (first_system_include
== 0)
2059 first_system_include
= new;
2064 /* Tack the after_include chain at the end of the include chain. */
2065 append_include_chain (after_include
, last_after_include
);
2066 if (first_system_include
== 0)
2067 first_system_include
= after_include
;
2069 /* With -v, print the list of dirs to search. */
2071 struct file_name_list
*p
;
2072 fprintf (stderr
, "#include \"...\" search starts here:\n");
2073 for (p
= include
; p
; p
= p
->next
) {
2074 if (p
== first_bracket_include
)
2075 fprintf (stderr
, "#include <...> search starts here:\n");
2076 fprintf (stderr
, " %s\n", p
->fname
);
2078 fprintf (stderr
, "End of search list.\n");
2081 /* Scan the -imacros files before the main input.
2082 Much like #including them, but with no_output set
2083 so that only their macro definitions matter. */
2085 no_output
++; no_record_file
++;
2086 for (i
= 1; i
< argc
; i
++)
2087 if (pend_files
[i
]) {
2088 int fd
= open (pend_files
[i
], O_RDONLY
, 0666);
2090 perror_with_name (pend_files
[i
]);
2091 return FATAL_EXIT_CODE
;
2093 finclude (fd
, pend_files
[i
], &outbuf
, 0, NULL_PTR
);
2095 no_output
--; no_record_file
--;
2097 /* Copy the entire contents of the main input file into
2098 the stacked input buffer previously allocated for it. */
2100 /* JF check for stdin */
2101 if (in_fname
== NULL
|| *in_fname
== 0) {
2104 } else if ((f
= open (in_fname
, O_RDONLY
, 0666)) < 0)
2107 /* -MG doesn't select the form of output and must be specified with one of
2108 -M or -MM. -MG doesn't make sense with -MD or -MMD since they don't
2109 inhibit compilation. */
2110 if (print_deps_missing_files
&& (print_deps
== 0 || !inhibit_output
))
2111 fatal ("-MG must be specified with one of -M or -MM");
2113 /* Either of two environment variables can specify output of deps.
2114 Its value is either "OUTPUT_FILE" or "OUTPUT_FILE DEPS_TARGET",
2115 where OUTPUT_FILE is the file to write deps info to
2116 and DEPS_TARGET is the target to mention in the deps. */
2119 && (getenv ("SUNPRO_DEPENDENCIES") != 0
2120 || getenv ("DEPENDENCIES_OUTPUT") != 0)) {
2121 char *spec
= getenv ("DEPENDENCIES_OUTPUT");
2126 spec
= getenv ("SUNPRO_DEPENDENCIES");
2133 /* Find the space before the DEPS_TARGET, if there is one. */
2134 /* This should use index. (mrs) */
2135 while (*s
!= 0 && *s
!= ' ') s
++;
2137 deps_target
= s
+ 1;
2138 output_file
= xmalloc (s
- spec
+ 1);
2139 bcopy (spec
, output_file
, s
- spec
);
2140 output_file
[s
- spec
] = 0;
2147 deps_file
= output_file
;
2151 /* For -M, print the expected object file name
2152 as the target of this Make-rule. */
2154 deps_allocated_size
= 200;
2155 deps_buffer
= xmalloc (deps_allocated_size
);
2161 deps_output (deps_target
, ':');
2162 } else if (*in_fname
== 0) {
2163 deps_output ("-", ':');
2168 /* Discard all directory prefixes from filename. */
2169 if ((q
= rindex (in_fname
, '/')) != NULL
2170 #ifdef DIR_SEPARATOR
2171 && (q
= rindex (in_fname
, DIR_SEPARATOR
)) != NULL
2178 /* Copy remainder to mungable area. */
2179 p
= (char *) alloca (strlen(q
) + 8);
2182 /* Output P, but remove known suffixes. */
2186 && p
[len
- 2] == '.'
2187 && index("cCsSm", p
[len
- 1]))
2190 && p
[len
- 3] == '.'
2191 && p
[len
- 2] == 'c'
2192 && p
[len
- 1] == 'c')
2195 && p
[len
- 4] == '.'
2196 && p
[len
- 3] == 'c'
2197 && p
[len
- 2] == 'x'
2198 && p
[len
- 1] == 'x')
2201 && p
[len
- 4] == '.'
2202 && p
[len
- 3] == 'c'
2203 && p
[len
- 2] == 'p'
2204 && p
[len
- 1] == 'p')
2207 /* Supply our own suffix. */
2214 deps_output (p
, ':');
2215 deps_output (in_fname
, ' ');
2219 file_size_and_mode (f
, &st_mode
, &st_size
);
2220 fp
->nominal_fname
= fp
->fname
= in_fname
;
2222 fp
->system_header_p
= 0;
2223 /* JF all this is mine about reading pipes and ttys */
2224 if (! S_ISREG (st_mode
)) {
2225 /* Read input from a file that is not a normal disk file.
2226 We cannot preallocate a buffer with the correct size,
2227 so we must read in the file a piece at the time and make it bigger. */
2234 fp
->buf
= (U_CHAR
*) xmalloc (bsize
+ 2);
2236 cnt
= safe_read (f
, (char *) fp
->buf
+ size
, bsize
- size
);
2237 if (cnt
< 0) goto perror
; /* error! */
2239 if (size
!= bsize
) break; /* End of file */
2241 fp
->buf
= (U_CHAR
*) xrealloc (fp
->buf
, bsize
+ 2);
2245 /* Read a file whose size we can determine in advance.
2246 For the sake of VMS, st_size is just an upper bound. */
2247 fp
->buf
= (U_CHAR
*) xmalloc (st_size
+ 2);
2248 fp
->length
= safe_read (f
, (char *) fp
->buf
, st_size
);
2249 if (fp
->length
< 0) goto perror
;
2252 fp
->if_stack
= if_stack
;
2254 /* Make sure data ends with a newline. And put a null after it. */
2256 if ((fp
->length
> 0 && fp
->buf
[fp
->length
- 1] != '\n')
2257 /* Backslash-newline at end is not good enough. */
2258 || (fp
->length
> 1 && fp
->buf
[fp
->length
- 2] == '\\')) {
2259 fp
->buf
[fp
->length
++] = '\n';
2260 missing_newline
= 1;
2262 fp
->buf
[fp
->length
] = '\0';
2264 /* Unless inhibited, convert trigraphs in the input. */
2269 /* Now that we know the input file is valid, open the output. */
2271 if (!out_fname
|| !strcmp (out_fname
, ""))
2272 out_fname
= "stdout";
2273 else if (! freopen (out_fname
, "w", stdout
))
2274 pfatal_with_name (out_fname
);
2276 output_line_directive (fp
, &outbuf
, 0, same_file
);
2278 /* Scan the -include files before the main input. */
2281 for (i
= 1; i
< argc
; i
++)
2282 if (pend_includes
[i
]) {
2283 int fd
= open (pend_includes
[i
], O_RDONLY
, 0666);
2285 perror_with_name (pend_includes
[i
]);
2286 return FATAL_EXIT_CODE
;
2288 finclude (fd
, pend_includes
[i
], &outbuf
, 0, NULL_PTR
);
2292 /* Scan the input, processing macros and directives. */
2294 rescan (&outbuf
, 0);
2296 if (missing_newline
)
2299 if (pedantic
&& missing_newline
)
2300 pedwarn ("file does not end in newline");
2302 /* Now we have processed the entire input
2303 Write whichever kind of output has been requested. */
2305 if (dump_macros
== dump_only
)
2307 else if (! inhibit_output
) {
2312 /* Don't actually write the deps file if compilation has failed. */
2314 if (deps_file
&& ! (deps_stream
= fopen (deps_file
, deps_mode
)))
2315 pfatal_with_name (deps_file
);
2316 fputs (deps_buffer
, deps_stream
);
2317 putc ('\n', deps_stream
);
2319 if (ferror (deps_stream
) || fclose (deps_stream
) != 0)
2320 fatal ("I/O error on output");
2325 if (pcp_outfile
&& pcp_outfile
!= stdout
2326 && (ferror (pcp_outfile
) || fclose (pcp_outfile
) != 0))
2327 fatal ("I/O error on `-pcp' output");
2329 if (ferror (stdout
) || fclose (stdout
) != 0)
2330 fatal ("I/O error on output");
2333 exit (FATAL_EXIT_CODE
);
2334 exit (SUCCESS_EXIT_CODE
);
2337 pfatal_with_name (in_fname
);
2341 /* Given a colon-separated list of file names PATH,
2342 add all the names to the search path for include files. */
2356 struct file_name_list
*dirtmp
;
2358 /* Find the end of this name. */
2359 while (*q
!= 0 && *q
!= PATH_SEPARATOR
) q
++;
2361 /* An empty name in the path stands for the current directory. */
2366 /* Otherwise use the directory that is named. */
2367 name
= xmalloc (q
- p
+ 1);
2368 bcopy (p
, name
, q
- p
);
2372 dirtmp
= (struct file_name_list
*)
2373 xmalloc (sizeof (struct file_name_list
));
2374 dirtmp
->next
= 0; /* New one goes on the end */
2375 dirtmp
->control_macro
= 0;
2376 dirtmp
->c_system_include_path
= 0;
2377 dirtmp
->fname
= name
;
2378 dirtmp
->got_name_map
= 0;
2379 append_include_chain (dirtmp
, dirtmp
);
2381 /* Advance past this name. */
2385 /* Skip the colon. */
2390 /* Return the address of the first character in S that equals C.
2391 S is an array of length N, possibly containing '\0's, and followed by '\0'.
2392 Return 0 if there is no such character. Assume that C itself is not '\0'.
2393 If we knew we could use memchr, we could just invoke memchr (S, C, N),
2394 but unfortunately memchr isn't autoconfigured yet. */
2402 char *p
= (char *) s
;
2404 char *q
= index (p
, c
);
2406 return (U_CHAR
*) q
;
2408 size_t l
= strlen (p
);
2418 /* Pre-C-Preprocessor to translate ANSI trigraph idiocy in BUF
2419 before main CCCP processing. Name `pcp' is also in honor of the
2420 drugs the trigraph designers must have been on.
2422 Using an extra pass through the buffer takes a little extra time,
2423 but is infinitely less hairy than trying to handle trigraphs inside
2424 strings, etc. everywhere, and also makes sure that trigraphs are
2425 only translated in the top level of processing. */
2431 register U_CHAR c
, *fptr
, *bptr
, *sptr
, *lptr
;
2434 fptr
= bptr
= sptr
= buf
->buf
;
2435 lptr
= fptr
+ buf
->length
;
2436 while ((sptr
= index0 (sptr
, '?', (size_t) (lptr
- sptr
))) != NULL
) {
2473 len
= sptr
- fptr
- 2;
2475 /* BSD doc says bcopy () works right for overlapping strings. In ANSI
2476 C, this will be memmove (). */
2477 if (bptr
!= fptr
&& len
> 0)
2478 bcopy ((char *) fptr
, (char *) bptr
, len
);
2484 len
= buf
->length
- (fptr
- buf
->buf
);
2485 if (bptr
!= fptr
&& len
> 0)
2486 bcopy ((char *) fptr
, (char *) bptr
, len
);
2487 buf
->length
-= fptr
- bptr
;
2488 buf
->buf
[buf
->length
] = '\0';
2489 if (warn_trigraphs
&& fptr
!= bptr
)
2490 warning ("%d trigraph(s) encountered", (fptr
- bptr
) / 2);
2493 /* Move all backslash-newline pairs out of embarrassing places.
2494 Exchange all such pairs following BP
2495 with any potentially-embarrassing characters that follow them.
2496 Potentially-embarrassing characters are / and *
2497 (because a backslash-newline inside a comment delimiter
2498 would cause it not to be recognized). */
2504 register U_CHAR
*p
= bp
;
2506 /* First count the backslash-newline pairs here. */
2508 while (p
[0] == '\\' && p
[1] == '\n')
2511 /* What follows the backslash-newlines is not embarrassing. */
2513 if (*p
!= '/' && *p
!= '*')
2516 /* Copy all potentially embarrassing characters
2517 that follow the backslash-newline pairs
2518 down to where the pairs originally started. */
2520 while (*p
== '*' || *p
== '/')
2523 /* Now write the same number of pairs after the embarrassing chars. */
2530 /* Like newline_fix but for use within a directive-name.
2531 Move any backslash-newlines up past any following symbol constituents. */
2534 name_newline_fix (bp
)
2537 register U_CHAR
*p
= bp
;
2539 /* First count the backslash-newline pairs here. */
2540 while (p
[0] == '\\' && p
[1] == '\n')
2543 /* What follows the backslash-newlines is not embarrassing. */
2548 /* Copy all potentially embarrassing characters
2549 that follow the backslash-newline pairs
2550 down to where the pairs originally started. */
2552 while (is_idchar
[*p
])
2555 /* Now write the same number of pairs after the embarrassing chars. */
2562 /* Look for lint commands in comments.
2564 When we come in here, ibp points into a comment. Limit is as one expects.
2565 scan within the comment -- it should start, after lwsp, with a lint command.
2566 If so that command is returned as a (constant) string.
2568 Upon return, any arg will be pointed to with argstart and will be
2569 arglen long. Note that we don't parse that arg since it will just
2570 be printed out again.
2574 get_lintcmd (ibp
, limit
, argstart
, arglen
, cmdlen
)
2575 register U_CHAR
*ibp
;
2576 register U_CHAR
*limit
;
2577 U_CHAR
**argstart
; /* point to command arg */
2578 int *arglen
, *cmdlen
; /* how long they are */
2581 register U_CHAR
*numptr
; /* temp for arg parsing */
2585 SKIP_WHITE_SPACE (ibp
);
2587 if (ibp
>= limit
) return NULL
;
2589 linsize
= limit
- ibp
;
2591 /* Oh, I wish C had lexical functions... hell, I'll just open-code the set */
2592 if ((linsize
>= 10) && !bcmp (ibp
, "NOTREACHED", 10)) {
2594 return "NOTREACHED";
2596 if ((linsize
>= 8) && !bcmp (ibp
, "ARGSUSED", 8)) {
2600 if ((linsize
>= 11) && !bcmp (ibp
, "LINTLIBRARY", 11)) {
2602 return "LINTLIBRARY";
2604 if ((linsize
>= 7) && !bcmp (ibp
, "VARARGS", 7)) {
2606 ibp
+= 7; linsize
-= 7;
2607 if ((linsize
== 0) || ! isdigit (*ibp
)) return "VARARGS";
2609 /* OK, read a number */
2610 for (numptr
= *argstart
= ibp
; (numptr
< limit
) && isdigit (*numptr
);
2612 *arglen
= numptr
- *argstart
;
2619 * The main loop of the program.
2621 * Read characters from the input stack, transferring them to the
2624 * Macros are expanded and push levels on the input stack.
2625 * At the end of such a level it is popped off and we keep reading.
2626 * At the end of any other kind of level, we return.
2627 * #-directives are handled, except within macros.
2629 * If OUTPUT_MARKS is nonzero, keep Newline markers found in the input
2630 * and insert them when appropriate. This is set while scanning macro
2631 * arguments before substitution. It is zero when scanning for final output.
2632 * There are three types of Newline markers:
2633 * * Newline - follows a macro name that was not expanded
2634 * because it appeared inside an expansion of the same macro.
2635 * This marker prevents future expansion of that identifier.
2636 * When the input is rescanned into the final output, these are deleted.
2637 * These are also deleted by ## concatenation.
2638 * * Newline Space (or Newline and any other whitespace character)
2639 * stands for a place that tokens must be separated or whitespace
2640 * is otherwise desirable, but where the ANSI standard specifies there
2641 * is no whitespace. This marker turns into a Space (or whichever other
2642 * whitespace char appears in the marker) in the final output,
2643 * but it turns into nothing in an argument that is stringified with #.
2644 * Such stringified arguments are the only place where the ANSI standard
2645 * specifies with precision that whitespace may not appear.
2647 * During this function, IP->bufp is kept cached in IBP for speed of access.
2648 * Likewise, OP->bufp is kept in OBP. Before calling a subroutine
2649 * IBP, IP and OBP must be copied back to memory. IP and IBP are
2650 * copied back with the RECACHE macro. OBP must be copied back from OP->bufp
2651 * explicitly, and before RECACHE, since RECACHE uses OBP.
2655 rescan (op
, output_marks
)
2659 /* Character being scanned in main loop. */
2662 /* Length of pending accumulated identifier. */
2663 register int ident_length
= 0;
2665 /* Hash code of pending accumulated identifier. */
2666 register int hash
= 0;
2668 /* Current input level (&instack[indepth]). */
2671 /* Pointer for scanning input. */
2672 register U_CHAR
*ibp
;
2674 /* Pointer to end of input. End of scan is controlled by LIMIT. */
2675 register U_CHAR
*limit
;
2677 /* Pointer for storing output. */
2678 register U_CHAR
*obp
;
2680 /* REDO_CHAR is nonzero if we are processing an identifier
2681 after backing up over the terminating character.
2682 Sometimes we process an identifier without backing up over
2683 the terminating character, if the terminating character
2684 is not special. Backing up is done so that the terminating character
2685 will be dispatched on again once the identifier is dealt with. */
2688 /* 1 if within an identifier inside of which a concatenation
2689 marker (Newline -) has been seen. */
2690 int concatenated
= 0;
2692 /* While scanning a comment or a string constant,
2693 this records the line it started on, for error messages. */
2696 /* Record position of last `real' newline. */
2697 U_CHAR
*beg_of_line
;
2699 /* Pop the innermost input stack level, assuming it is a macro expansion. */
2702 do { ip->macro->type = T_MACRO; \
2703 if (ip->free_ptr) free (ip->free_ptr); \
2704 --indepth; } while (0)
2706 /* Reload `rescan's local variables that describe the current
2707 level of the input stack. */
2710 do { ip = &instack[indepth]; \
2712 limit = ip->buf + ip->length; \
2714 check_expand (op, limit - ibp); \
2716 obp = op->bufp; } while (0)
2718 if (no_output
&& instack
[indepth
].fname
!= 0)
2719 skip_if_group (&instack
[indepth
], 1, NULL
);
2726 /* Our caller must always put a null after the end of
2727 the input at each input stack level. */
2737 if (*ibp
== '\n' && !ip
->macro
) {
2738 /* At the top level, always merge lines ending with backslash-newline,
2739 even in middle of identifier. But do not merge lines in a macro,
2740 since backslash might be followed by a newline-space marker. */
2743 --obp
; /* remove backslash from obuf */
2746 /* If ANSI, backslash is just another character outside a string. */
2749 /* Otherwise, backslash suppresses specialness of following char,
2750 so copy it here to prevent the switch from seeing it.
2751 But first get any pending identifier processed. */
2752 if (ident_length
> 0)
2759 if (ident_length
|| ip
->macro
|| traditional
)
2761 while (*ibp
== '\\' && ibp
[1] == '\n') {
2767 /* Treat this %: digraph as if it were #. */
2771 if (assertions_flag
) {
2772 /* Copy #foo (bar lose) without macro expansion. */
2773 obp
[-1] = '#'; /* In case it was '%'. */
2774 SKIP_WHITE_SPACE (ibp
);
2775 while (is_idchar
[*ibp
])
2777 SKIP_WHITE_SPACE (ibp
);
2780 skip_paren_group (ip
);
2781 bcopy ((char *) ibp
, (char *) obp
, ip
->bufp
- ibp
);
2782 obp
+= ip
->bufp
- ibp
;
2787 /* If this is expanding a macro definition, don't recognize
2788 preprocessing directives. */
2791 /* If this is expand_into_temp_buffer,
2792 don't recognize them either. Warn about them
2793 only after an actual newline at this level,
2794 not at the beginning of the input level. */
2796 if (ip
->buf
!= beg_of_line
)
2797 warning ("preprocessing directive not recognized within macro arg");
2804 /* # keyword: a # must be first nonblank char on the line */
2805 if (beg_of_line
== 0)
2810 /* Scan from start of line, skipping whitespace, comments
2811 and backslash-newlines, and see if we reach this #.
2812 If not, this # is not special. */
2814 /* If -traditional, require # to be at beginning of line. */
2817 if (is_hor_space
[*bp
])
2819 else if (*bp
== '\\' && bp
[1] == '\n')
2821 else if (*bp
== '/' && bp
[1] == '*') {
2823 while (!(*bp
== '*' && bp
[1] == '/'))
2827 /* There is no point in trying to deal with C++ // comments here,
2828 because if there is one, then this # must be part of the
2829 comment and we would never reach here. */
2835 while (bp
[1] == '\\' && bp
[2] == '\n')
2839 /* %: appears at start of line; skip past the ':' too. */
2848 /* This # can start a directive. */
2850 --obp
; /* Don't copy the '#' */
2854 if (! handle_directive (ip
, op
)) {
2858 /* Not a known directive: treat it as ordinary text.
2859 IP, OP, IBP, etc. have not been changed. */
2860 if (no_output
&& instack
[indepth
].fname
) {
2861 /* If not generating expanded output,
2862 what we do with ordinary text is skip it.
2863 Discard everything until next # directive. */
2864 skip_if_group (&instack
[indepth
], 1, 0);
2869 *obp
++ = '#'; /* Copy # (even if it was originally %:). */
2870 /* Don't expand an identifier that could be a macro directive.
2871 (Section 3.8.3 of the ANSI C standard) */
2872 SKIP_WHITE_SPACE (ibp
);
2873 if (is_idstart
[*ibp
])
2876 while (is_idchar
[*ibp
])
2884 /* A # directive has been successfully processed. */
2885 /* If not generating expanded output, ignore everything until
2886 next # directive. */
2887 if (no_output
&& instack
[indepth
].fname
)
2888 skip_if_group (&instack
[indepth
], 1, 0);
2894 case '\"': /* skip quoted string */
2896 /* A single quoted string is treated like a double -- some
2897 programs (e.g., troff) are perverse this way */
2902 start_line
= ip
->lineno
;
2904 /* Skip ahead to a matching quote. */
2908 if (ip
->macro
!= 0) {
2909 /* try harder: this string crosses a macro expansion boundary.
2910 This can happen naturally if -traditional.
2911 Otherwise, only -D can make a macro with an unmatched quote. */
2917 error_with_line (line_for_error (start_line
),
2918 "unterminated string or character constant");
2919 error_with_line (multiline_string_line
,
2920 "possible real start of unterminated constant");
2921 multiline_string_line
= 0;
2930 /* Traditionally, end of line ends a string constant with no error.
2931 So exit the loop and record the new line. */
2937 error_with_line (line_for_error (start_line
),
2938 "unterminated character constant");
2941 if (pedantic
&& multiline_string_line
== 0) {
2942 pedwarn_with_line (line_for_error (start_line
),
2943 "string constant runs past end of line");
2945 if (multiline_string_line
== 0)
2946 multiline_string_line
= ip
->lineno
- 1;
2953 /* Backslash newline is replaced by nothing at all,
2954 but keep the line counts correct. */
2959 /* ANSI stupidly requires that in \\ the second \
2960 is *not* prevented from combining with a newline. */
2961 while (*ibp
== '\\' && ibp
[1] == '\n') {
2980 if (*ibp
== '\\' && ibp
[1] == '\n')
2984 && !(cplusplus_comments
&& *ibp
== '/'))
2992 /* C++ style comment... */
2993 start_line
= ip
->lineno
;
2995 /* Comments are equivalent to spaces. */
2996 if (! put_out_comments
)
3000 U_CHAR
*before_bp
= ibp
;
3002 while (++ibp
< limit
) {
3004 if (ibp
[-1] != '\\') {
3005 if (put_out_comments
) {
3006 bcopy ((char *) before_bp
, (char *) obp
, ibp
- before_bp
);
3007 obp
+= ibp
- before_bp
;
3012 /* Copy the newline into the output buffer, in order to
3013 avoid the pain of a #line every time a multiline comment
3015 if (!put_out_comments
)
3024 /* Ordinary C comment. Skip it, optionally copying it to output. */
3026 start_line
= ip
->lineno
;
3028 ++ibp
; /* Skip the star. */
3030 /* If this cpp is for lint, we peek inside the comments: */
3034 char *lintcmd
= get_lintcmd (ibp
, limit
, &argbp
, &arglen
, &cmdlen
);
3036 if (lintcmd
!= NULL
) {
3038 check_expand (op
, cmdlen
+ arglen
+ 14);
3040 /* I believe it is always safe to emit this newline: */
3042 bcopy ("#pragma lint ", (char *) obp
, 13);
3044 bcopy (lintcmd
, (char *) obp
, cmdlen
);
3049 bcopy (argbp
, (char *) obp
, arglen
);
3053 /* OK, now bring us back to the state we were in before we entered
3054 this branch. We need #line because the #pragma's newline always
3055 messes up the line count. */
3057 output_line_directive (ip
, op
, 0, same_file
);
3058 check_expand (op
, limit
- ibp
+ 2);
3064 /* Comments are equivalent to spaces.
3065 Note that we already output the slash; we might not want it.
3066 For -traditional, a comment is equivalent to nothing. */
3067 if (! put_out_comments
) {
3077 U_CHAR
*before_bp
= ibp
;
3079 while (ibp
< limit
) {
3082 if (warn_comments
&& *ibp
== '*')
3083 warning ("`/*' within comment");
3086 if (*ibp
== '\\' && ibp
[1] == '\n')
3088 if (ibp
>= limit
|| *ibp
== '/')
3093 /* Copy the newline into the output buffer, in order to
3094 avoid the pain of a #line every time a multiline comment
3096 if (!put_out_comments
)
3104 error_with_line (line_for_error (start_line
),
3105 "unterminated comment");
3108 if (put_out_comments
) {
3109 bcopy ((char *) before_bp
, (char *) obp
, ibp
- before_bp
);
3110 obp
+= ibp
- before_bp
;
3117 if (!dollars_in_ident
)
3121 case '0': case '1': case '2': case '3': case '4':
3122 case '5': case '6': case '7': case '8': case '9':
3123 /* If digit is not part of identifier, it starts a number,
3124 which means that following letters are not an identifier.
3125 "0x5" does not refer to an identifier "x5".
3126 So copy all alphanumerics that follow without accumulating
3127 as an identifier. Periods also, for sake of "3.e7". */
3129 if (ident_length
== 0) {
3131 while (ibp
[0] == '\\' && ibp
[1] == '\n') {
3136 if (!is_idchar
[c
] && c
!= '.') {
3141 /* A sign can be part of a preprocessing number
3142 if it follows an e. */
3143 if (c
== 'e' || c
== 'E') {
3144 while (ibp
[0] == '\\' && ibp
[1] == '\n') {
3148 if (*ibp
== '+' || *ibp
== '-') {
3150 /* But traditional C does not let the token go past the sign. */
3161 case 'a': case 'b': case 'c': case 'd': case 'e': case 'f':
3162 case 'g': case 'h': case 'i': case 'j': case 'k': case 'l':
3163 case 'm': case 'n': case 'o': case 'p': case 'q': case 'r':
3164 case 's': case 't': case 'u': case 'v': case 'w': case 'x':
3166 case 'A': case 'B': case 'C': case 'D': case 'E': case 'F':
3167 case 'G': case 'H': case 'I': case 'J': case 'K': case 'L':
3168 case 'M': case 'N': case 'O': case 'P': case 'Q': case 'R':
3169 case 'S': case 'T': case 'U': case 'V': case 'W': case 'X':
3173 /* Compute step of hash function, to avoid a proc call on every token */
3174 hash
= HASHSTEP (hash
, c
);
3178 if (ip
->fname
== 0 && *ibp
== '-') {
3179 /* Newline - inhibits expansion of preceding token.
3180 If expanding a macro arg, we keep the newline -.
3181 In final output, it is deleted.
3182 We recognize Newline - in macro bodies and macro args. */
3183 if (! concatenated
) {
3188 if (!output_marks
) {
3191 /* If expanding a macro arg, keep the newline -. */
3197 /* If reprocessing a macro expansion, newline is a special marker. */
3198 else if (ip
->macro
!= 0) {
3199 /* Newline White is a "funny space" to separate tokens that are
3200 supposed to be separate but without space between.
3201 Here White means any whitespace character.
3202 Newline - marks a recursive macro use that is not
3203 supposed to be expandable. */
3205 if (is_space
[*ibp
]) {
3206 /* Newline Space does not prevent expansion of preceding token
3207 so expand the preceding token and then come back. */
3208 if (ident_length
> 0)
3211 /* If generating final output, newline space makes a space. */
3212 if (!output_marks
) {
3214 /* And Newline Newline makes a newline, so count it. */
3215 if (obp
[-1] == '\n')
3218 /* If expanding a macro arg, keep the newline space.
3219 If the arg gets stringified, newline space makes nothing. */
3222 } else abort (); /* Newline followed by something random? */
3226 /* If there is a pending identifier, handle it and come back here. */
3227 if (ident_length
> 0)
3232 /* Update the line counts and output a #line if necessary. */
3235 if (ip
->lineno
!= op
->lineno
) {
3237 output_line_directive (ip
, op
, 1, same_file
);
3238 check_expand (op
, limit
- ibp
);
3243 /* Come here either after (1) a null character that is part of the input
3244 or (2) at the end of the input, because there is a null there. */
3247 /* Our input really contains a null character. */
3250 /* At end of a macro-expansion level, pop it and read next level. */
3251 if (ip
->macro
!= 0) {
3254 /* If traditional, and we have an identifier that ends here,
3255 process it now, so we get the right error for recursion. */
3256 if (traditional
&& ident_length
3257 && ! is_idchar
[*instack
[indepth
- 1].bufp
]) {
3266 /* If we don't have a pending identifier,
3267 return at end of input. */
3268 if (ident_length
== 0) {
3276 /* If we do have a pending identifier, just consider this null
3277 a special character and arrange to dispatch on it again.
3278 The second time, IDENT_LENGTH will be zero so we will return. */
3284 /* Handle the case of a character such as /, ', " or null
3285 seen following an identifier. Back over it so that
3286 after the identifier is processed the special char
3287 will be dispatched on again. */
3297 if (ident_length
> 0) {
3298 register HASHNODE
*hp
;
3300 /* We have just seen an identifier end. If it's a macro, expand it.
3302 IDENT_LENGTH is the length of the identifier
3303 and HASH is its hash code.
3305 The identifier has already been copied to the output,
3306 so if it is a macro we must remove it.
3308 If REDO_CHAR is 0, the char that terminated the identifier
3309 has been skipped in the output and the input.
3310 OBP-IDENT_LENGTH-1 points to the identifier.
3311 If the identifier is a macro, we must back over the terminator.
3313 If REDO_CHAR is 1, the terminating char has already been
3314 backed over. OBP-IDENT_LENGTH points to the identifier. */
3316 if (!pcp_outfile
|| pcp_inside_if
) {
3317 for (hp
= hashtab
[MAKE_POS (hash
) % HASHSIZE
]; hp
!= NULL
;
3320 if (hp
->length
== ident_length
) {
3321 int obufp_before_macroname
;
3322 int op_lineno_before_macroname
;
3323 register int i
= ident_length
;
3324 register U_CHAR
*p
= hp
->name
;
3325 register U_CHAR
*q
= obp
- i
;
3331 do { /* All this to avoid a strncmp () */
3336 /* We found a use of a macro name.
3337 see if the context shows it is a macro call. */
3339 /* Back up over terminating character if not already done. */
3345 /* Save this as a displacement from the beginning of the output
3346 buffer. We can not save this as a position in the output
3347 buffer, because it may get realloc'ed by RECACHE. */
3348 obufp_before_macroname
= (obp
- op
->buf
) - ident_length
;
3349 op_lineno_before_macroname
= op
->lineno
;
3351 if (hp
->type
== T_PCSTRING
) {
3352 pcstring_used (hp
); /* Mark the definition of this key
3353 as needed, ensuring that it
3355 break; /* Exit loop, since the key cannot have a
3356 definition any longer. */
3359 /* Record whether the macro is disabled. */
3360 disabled
= hp
->type
== T_DISABLED
;
3362 /* This looks like a macro ref, but if the macro was disabled,
3363 just copy its name and put in a marker if requested. */
3367 /* This error check caught useful cases such as
3368 #define foo(x,y) bar (x (y,0), y)
3371 error ("recursive use of macro `%s'", hp
->name
);
3375 check_expand (op
, limit
- ibp
+ 2);
3382 /* If macro wants an arglist, verify that a '(' follows.
3383 first skip all whitespace, copying it to the output
3384 after the macro name. Then, if there is no '(',
3385 decide this is not a macro call and leave things that way. */
3386 if ((hp
->type
== T_MACRO
|| hp
->type
== T_DISABLED
)
3387 && hp
->value
.defn
->nargs
>= 0)
3389 U_CHAR
*old_ibp
= ibp
;
3390 U_CHAR
*old_obp
= obp
;
3391 int old_iln
= ip
->lineno
;
3392 int old_oln
= op
->lineno
;
3395 /* Scan forward over whitespace, copying it to the output. */
3396 if (ibp
== limit
&& ip
->macro
!= 0) {
3401 old_iln
= ip
->lineno
;
3402 old_oln
= op
->lineno
;
3404 /* A comment: copy it unchanged or discard it. */
3405 else if (*ibp
== '/' && ibp
[1] == '*') {
3406 if (put_out_comments
) {
3409 } else if (! traditional
) {
3413 while (ibp
+ 1 != limit
3414 && !(ibp
[0] == '*' && ibp
[1] == '/')) {
3415 /* We need not worry about newline-marks,
3416 since they are never found in comments. */
3418 /* Newline in a file. Count it. */
3422 if (put_out_comments
)
3428 if (put_out_comments
) {
3433 else if (is_space
[*ibp
]) {
3435 if (ibp
[-1] == '\n') {
3436 if (ip
->macro
== 0) {
3437 /* Newline in a file. Count it. */
3440 } else if (!output_marks
) {
3441 /* A newline mark, and we don't want marks
3442 in the output. If it is newline-hyphen,
3443 discard it entirely. Otherwise, it is
3444 newline-whitechar, so keep the whitechar. */
3454 /* A newline mark; copy both chars to the output. */
3462 /* It isn't a macro call.
3463 Put back the space that we just skipped. */
3466 ip
->lineno
= old_iln
;
3467 op
->lineno
= old_oln
;
3468 /* Exit the for loop. */
3473 /* This is now known to be a macro call.
3474 Discard the macro name from the output,
3475 along with any following whitespace just copied,
3476 but preserve newlines if not outputting marks since this
3477 is more likely to do the right thing with line numbers. */
3478 obp
= op
->buf
+ obufp_before_macroname
;
3480 op
->lineno
= op_lineno_before_macroname
;
3482 int newlines
= op
->lineno
- op_lineno_before_macroname
;
3483 while (0 < newlines
--)
3487 /* Prevent accidental token-pasting with a character
3488 before the macro call. */
3489 if (!traditional
&& obp
!= op
->buf
) {
3491 case '!': case '%': case '&': case '*':
3492 case '+': case '-': case '/': case ':':
3493 case '<': case '=': case '>': case '^':
3495 /* If we are expanding a macro arg, make a newline marker
3496 to separate the tokens. If we are making real output,
3497 a plain space will do. */
3504 /* Expand the macro, reading arguments as needed,
3505 and push the expansion on the input stack. */
3508 macroexpand (hp
, op
);
3510 /* Reexamine input stack, since macroexpand has pushed
3511 a new level on it. */
3518 } /* End hash-table-search loop */
3520 ident_length
= hash
= 0; /* Stop collecting identifier */
3523 } /* End if (ident_length > 0) */
3525 } /* End per-char loop */
3527 /* Come here to return -- but first give an error message
3528 if there was an unterminated successful conditional. */
3530 if (if_stack
!= ip
->if_stack
)
3534 switch (if_stack
->type
)
3555 error_with_line (line_for_error (if_stack
->lineno
),
3556 "unterminated `#%s' conditional", str
);
3558 if_stack
= ip
->if_stack
;
3562 * Rescan a string into a temporary buffer and return the result
3563 * as a FILE_BUF. Note this function returns a struct, not a pointer.
3565 * OUTPUT_MARKS nonzero means keep Newline markers found in the input
3566 * and insert such markers when appropriate. See `rescan' for details.
3567 * OUTPUT_MARKS is 1 for macroexpanding a macro argument separately
3568 * before substitution; it is 0 for other uses.
3571 expand_to_temp_buffer (buf
, limit
, output_marks
, assertions
)
3572 U_CHAR
*buf
, *limit
;
3573 int output_marks
, assertions
;
3575 register FILE_BUF
*ip
;
3577 int length
= limit
- buf
;
3579 int odepth
= indepth
;
3580 int save_assertions_flag
= assertions_flag
;
3582 assertions_flag
= assertions
;
3587 /* Set up the input on the input stack. */
3589 buf1
= (U_CHAR
*) alloca (length
+ 1);
3591 register U_CHAR
*p1
= buf
;
3592 register U_CHAR
*p2
= buf1
;
3599 /* Set up to receive the output. */
3601 obuf
.length
= length
* 2 + 100; /* Usually enough. Why be stingy? */
3602 obuf
.bufp
= obuf
.buf
= (U_CHAR
*) xmalloc (obuf
.length
);
3607 CHECK_DEPTH ({return obuf
;});
3611 ip
= &instack
[indepth
];
3613 ip
->nominal_fname
= 0;
3614 ip
->system_header_p
= 0;
3617 ip
->length
= length
;
3618 ip
->buf
= ip
->bufp
= buf1
;
3619 ip
->if_stack
= if_stack
;
3621 ip
->lineno
= obuf
.lineno
= 1;
3623 /* Scan the input, create the output. */
3624 rescan (&obuf
, output_marks
);
3626 /* Pop input stack to original state. */
3629 if (indepth
!= odepth
)
3632 /* Record the output. */
3633 obuf
.length
= obuf
.bufp
- obuf
.buf
;
3635 assertions_flag
= save_assertions_flag
;
3640 * Process a # directive. Expects IP->bufp to point after the '#', as in
3641 * `#define foo bar'. Passes to the directive handler
3642 * (do_define, do_include, etc.): the addresses of the 1st and
3643 * last chars of the directive (starting immediately after the #
3644 * keyword), plus op and the keyword table pointer. If the directive
3645 * contains comments it is copied into a temporary buffer sans comments
3646 * and the temporary buffer is passed to the directive handler instead.
3647 * Likewise for backslash-newlines.
3649 * Returns nonzero if this was a known # directive.
3650 * Otherwise, returns zero, without advancing the input pointer.
3654 handle_directive (ip
, op
)
3657 register U_CHAR
*bp
, *cp
;
3658 register struct directive
*kt
;
3659 register int ident_length
;
3662 /* Nonzero means we must copy the entire directive
3663 to get rid of comments or backslash-newlines. */
3664 int copy_directive
= 0;
3666 U_CHAR
*ident
, *after_ident
;
3670 /* Record where the directive started. do_xifdef needs this. */
3671 directive_start
= bp
- 1;
3673 /* Skip whitespace and \-newline. */
3675 if (is_hor_space
[*bp
]) {
3676 if (*bp
!= ' ' && *bp
!= '\t' && pedantic
)
3677 pedwarn ("%s in preprocessing directive", char_name
[*bp
]);
3679 } else if (*bp
== '/' && (bp
[1] == '*'
3680 || (cplusplus_comments
&& bp
[1] == '/'))) {
3682 skip_to_end_of_comment (ip
, &ip
->lineno
, 0);
3684 } else if (*bp
== '\\' && bp
[1] == '\n') {
3685 bp
+= 2; ip
->lineno
++;
3689 /* Now find end of directive name.
3690 If we encounter a backslash-newline, exchange it with any following
3691 symbol-constituents so that we end up with a contiguous name. */
3698 if (*cp
== '\\' && cp
[1] == '\n')
3699 name_newline_fix (cp
);
3705 ident_length
= cp
- bp
;
3709 /* A line of just `#' becomes blank. */
3711 if (ident_length
== 0 && *after_ident
== '\n') {
3712 ip
->bufp
= after_ident
;
3716 if (ident_length
== 0 || !is_idstart
[*ident
]) {
3718 while (is_idchar
[*p
]) {
3719 if (*p
< '0' || *p
> '9')
3723 /* Handle # followed by a line number. */
3724 if (p
!= ident
&& !is_idchar
[*p
]) {
3725 static struct directive line_directive_table
[] = {
3726 { 4, do_line
, "line", T_LINE
},
3729 pedwarn ("`#' followed by integer");
3730 after_ident
= ident
;
3731 kt
= line_directive_table
;
3735 /* Avoid error for `###' and similar cases unless -pedantic. */
3737 while (*p
== '#' || is_hor_space
[*p
]) p
++;
3739 if (pedantic
&& !lang_asm
)
3740 warning ("invalid preprocessing directive");
3746 error ("invalid preprocessing directive name");
3752 * Decode the keyword and call the appropriate expansion
3753 * routine, after moving the input pointer up to the next line.
3755 for (kt
= directive_table
; kt
->length
> 0; kt
++) {
3756 if (kt
->length
== ident_length
&& !bcmp (kt
->name
, ident
, ident_length
)) {
3757 register U_CHAR
*buf
;
3758 register U_CHAR
*limit
;
3761 int *already_output
;
3763 /* Nonzero means do not delete comments within the directive.
3764 #define needs this when -traditional. */
3769 limit
= ip
->buf
+ ip
->length
;
3772 keep_comments
= traditional
&& kt
->traditional_comments
;
3773 /* #import is defined only in Objective C, or when on the NeXT. */
3774 if (kt
->type
== T_IMPORT
3775 && !(objc
|| lookup ((U_CHAR
*) "__NeXT__", -1, -1)))
3778 /* Find the end of this directive (first newline not backslashed
3779 and not in a string or comment).
3780 Set COPY_DIRECTIVE if the directive must be copied
3781 (it contains a backslash-newline or a comment). */
3783 buf
= bp
= after_ident
;
3784 while (bp
< limit
) {
3785 register U_CHAR c
= *bp
++;
3793 } else if (traditional
)
3800 bp
= skip_quoted_string (bp
- 1, limit
, ip
->lineno
, &ip
->lineno
, ©_directive
, &unterminated
);
3801 /* Don't bother calling the directive if we already got an error
3802 message due to unterminated string. Skip everything and pretend
3803 we called the directive. */
3806 /* Traditional preprocessing permits unterminated strings. */
3815 /* <...> is special for #include. */
3817 if (!kt
->angle_brackets
)
3819 while (bp
< limit
&& *bp
!= '>' && *bp
!= '\n') {
3820 if (*bp
== '\\' && bp
[1] == '\n') {
3830 if (*bp
== '\\' && bp
[1] == '\n')
3833 || (cplusplus_comments
&& *bp
== '/')) {
3834 U_CHAR
*obp
= bp
- 1;
3836 skip_to_end_of_comment (ip
, &ip
->lineno
, 0);
3838 /* No need to copy the directive because of a comment at the end;
3839 just don't include the comment in the directive. */
3840 if (bp
== limit
|| *bp
== '\n') {
3844 /* Don't remove the comments if -traditional. */
3845 if (! keep_comments
)
3854 pedwarn ("%s in preprocessing directive", char_name
[c
]);
3858 --bp
; /* Point to the newline */
3866 resume_p
= ip
->bufp
;
3867 /* BP is the end of the directive.
3868 RESUME_P is the next interesting data after the directive.
3869 A comment may come between. */
3871 /* If a directive should be copied through, and -E was given,
3872 pass it through before removing comments. */
3873 if (!no_output
&& kt
->pass_thru
&& put_out_comments
) {
3876 /* Output directive name. */
3877 check_expand (op
, kt
->length
+ 2);
3878 /* Make sure # is at the start of a line */
3879 if (op
->bufp
> op
->buf
&& op
->bufp
[-1] != '\n') {
3884 bcopy (kt
->name
, op
->bufp
, kt
->length
);
3885 op
->bufp
+= kt
->length
;
3887 /* Output arguments. */
3889 check_expand (op
, len
);
3890 bcopy (buf
, (char *) op
->bufp
, len
);
3892 /* Take account of any (escaped) newlines just output. */
3894 if (buf
[len
] == '\n')
3897 already_output
= &junk
;
3898 } /* Don't we need a newline or #line? */
3900 if (copy_directive
) {
3901 register U_CHAR
*xp
= buf
;
3902 /* Need to copy entire directive into temp buffer before dispatching */
3904 cp
= (U_CHAR
*) alloca (bp
- buf
+ 5); /* room for directive plus
3908 /* Copy to the new buffer, deleting comments
3909 and backslash-newlines (and whitespace surrounding the latter). */
3912 register U_CHAR c
= *xp
++;
3917 abort (); /* A bare newline should never part of the line. */
3920 /* <...> is special for #include. */
3922 if (!kt
->angle_brackets
)
3924 while (xp
< bp
&& c
!= '>') {
3926 if (c
== '\\' && xp
< bp
&& *xp
== '\n')
3937 if (cp
!= buf
&& is_space
[cp
[-1]]) {
3938 while (cp
!= buf
&& is_space
[cp
[-1]]) cp
--;
3940 SKIP_WHITE_SPACE (xp
);
3941 } else if (is_space
[*xp
]) {
3943 SKIP_WHITE_SPACE (xp
);
3945 } else if (traditional
&& xp
< bp
) {
3953 register U_CHAR
*bp1
3954 = skip_quoted_string (xp
- 1, bp
, ip
->lineno
,
3955 NULL_PTR
, NULL_PTR
, NULL_PTR
);
3969 || (cplusplus_comments
&& *xp
== '/')) {
3971 /* If we already copied the directive through,
3972 already_output != 0 prevents outputting comment now. */
3973 skip_to_end_of_comment (ip
, already_output
, 0);
3975 while (xp
!= ip
->bufp
)
3977 /* Delete or replace the slash. */
3978 else if (traditional
)
3987 /* Null-terminate the copy. */
3993 ip
->bufp
= resume_p
;
3995 /* Some directives should be written out for cc1 to process,
3996 just as if they were not defined. And sometimes we're copying
3997 definitions through. */
3999 if (!no_output
&& already_output
== 0
4001 || (kt
->type
== T_DEFINE
4002 && (dump_macros
== dump_names
4003 || dump_macros
== dump_definitions
)))) {
4006 /* Output directive name. */
4007 check_expand (op
, kt
->length
+ 1);
4009 bcopy (kt
->name
, (char *) op
->bufp
, kt
->length
);
4010 op
->bufp
+= kt
->length
;
4012 if (kt
->pass_thru
|| dump_macros
== dump_definitions
) {
4013 /* Output arguments. */
4015 check_expand (op
, len
);
4016 bcopy (buf
, (char *) op
->bufp
, len
);
4018 } else if (kt
->type
== T_DEFINE
&& dump_macros
== dump_names
) {
4021 SKIP_WHITE_SPACE (xp
);
4023 while (is_idchar
[*xp
]) xp
++;
4025 check_expand (op
, len
+ 1);
4027 bcopy (yp
, op
->bufp
, len
);
4030 } /* Don't we need a newline or #line? */
4032 /* Call the appropriate directive handler. buf now points to
4033 either the appropriate place in the input buffer, or to
4034 the temp buffer if it was necessary to make one. cp
4035 points to the first char after the contents of the (possibly
4036 copied) directive, in either case. */
4037 (*kt
->func
) (buf
, cp
, op
, kt
);
4038 check_expand (op
, ip
->length
- (ip
->bufp
- ip
->buf
));
4044 /* It is deliberate that we don't warn about undefined directives.
4045 That is the responsibility of cc1. */
4052 static struct tm
*timebuf
;
4054 time_t t
= time ((time_t *)0);
4055 timebuf
= localtime (&t
);
4060 static char *monthnames
[] = {"Jan", "Feb", "Mar", "Apr", "May", "Jun",
4061 "Jul", "Aug", "Sep", "Oct", "Nov", "Dec",
4065 * expand things like __FILE__. Place the expansion into the output
4066 * buffer *without* rescanning.
4070 special_symbol (hp
, op
)
4077 FILE_BUF
*ip
= NULL
;
4080 int paren
= 0; /* For special `defined' keyword */
4082 if (pcp_outfile
&& pcp_inside_if
4083 && hp
->type
!= T_SPEC_DEFINED
&& hp
->type
!= T_CONST
)
4084 error ("Predefined macro `%s' used inside `#if' during precompilation",
4087 for (i
= indepth
; i
>= 0; i
--)
4088 if (instack
[i
].fname
!= NULL
) {
4093 error ("cccp error: not in any file?!");
4094 return; /* the show must go on */
4102 if (hp
->type
== T_FILE
)
4103 string
= ip
->nominal_fname
;
4105 string
= instack
[0].nominal_fname
;
4109 buf
= (char *) alloca (3 + 4 * strlen (string
));
4110 quote_string (buf
, string
);
4118 case T_INCLUDE_LEVEL
:
4120 for (i
= indepth
; i
>= 0; i
--)
4121 if (instack
[i
].fname
!= NULL
)
4124 buf
= (char *) alloca (8); /* Eight bytes ought to be more than enough */
4125 sprintf (buf
, "%d", true_indepth
- 1);
4129 buf
= (char *) alloca (3 + strlen (version_string
));
4130 sprintf (buf
, "\"%s\"", version_string
);
4133 #ifndef NO_BUILTIN_SIZE_TYPE
4139 #ifndef NO_BUILTIN_PTRDIFF_TYPE
4140 case T_PTRDIFF_TYPE
:
4149 case T_USER_LABEL_PREFIX_TYPE
:
4150 buf
= USER_LABEL_PREFIX
;
4153 case T_REGISTER_PREFIX_TYPE
:
4154 buf
= REGISTER_PREFIX
;
4157 case T_IMMEDIATE_PREFIX_TYPE
:
4158 buf
= IMMEDIATE_PREFIX
;
4162 buf
= hp
->value
.cpval
;
4163 if (pcp_inside_if
&& pcp_outfile
)
4164 /* Output a precondition for this macro use */
4165 fprintf (pcp_outfile
, "#define %s %s\n", hp
->name
, buf
);
4169 buf
= (char *) alloca (10);
4170 sprintf (buf
, "%d", ip
->lineno
);
4175 buf
= (char *) alloca (20);
4176 timebuf
= timestamp ();
4177 if (hp
->type
== T_DATE
)
4178 sprintf (buf
, "\"%s %2d %4d\"", monthnames
[timebuf
->tm_mon
],
4179 timebuf
->tm_mday
, timebuf
->tm_year
+ 1900);
4181 sprintf (buf
, "\"%02d:%02d:%02d\"", timebuf
->tm_hour
, timebuf
->tm_min
,
4185 case T_SPEC_DEFINED
:
4186 buf
= " 0 "; /* Assume symbol is not defined */
4187 ip
= &instack
[indepth
];
4188 SKIP_WHITE_SPACE (ip
->bufp
);
4189 if (*ip
->bufp
== '(') {
4191 ip
->bufp
++; /* Skip over the paren */
4192 SKIP_WHITE_SPACE (ip
->bufp
);
4195 if (!is_idstart
[*ip
->bufp
])
4197 if ((hp
= lookup (ip
->bufp
, -1, -1))) {
4198 if (pcp_outfile
&& pcp_inside_if
4199 && (hp
->type
== T_CONST
4200 || (hp
->type
== T_MACRO
&& hp
->value
.defn
->predefined
)))
4201 /* Output a precondition for this macro use. */
4202 fprintf (pcp_outfile
, "#define %s\n", hp
->name
);
4206 if (pcp_outfile
&& pcp_inside_if
) {
4207 /* Output a precondition for this macro use */
4208 U_CHAR
*cp
= ip
->bufp
;
4209 fprintf (pcp_outfile
, "#undef ");
4210 while (is_idchar
[*cp
]) /* Ick! */
4211 fputc (*cp
++, pcp_outfile
);
4212 putc ('\n', pcp_outfile
);
4214 while (is_idchar
[*ip
->bufp
])
4216 SKIP_WHITE_SPACE (ip
->bufp
);
4218 if (*ip
->bufp
!= ')')
4226 error ("`defined' without an identifier");
4230 error ("cccp error: invalid special hash type"); /* time for gdb */
4234 check_expand (op
, len
);
4235 bcopy (buf
, (char *) op
->bufp
, len
);
4242 /* Routines to handle #directives */
4244 /* Handle #include and #import.
4245 This function expects to see "fname" or <fname> on the input. */
4248 do_include (buf
, limit
, op
, keyword
)
4249 U_CHAR
*buf
, *limit
;
4251 struct directive
*keyword
;
4253 int importing
= (keyword
->type
== T_IMPORT
);
4254 int skip_dirs
= (keyword
->type
== T_INCLUDE_NEXT
);
4255 static int import_warning
= 0;
4256 char *fname
; /* Dynamically allocated fname buffer */
4259 U_CHAR
*fbeg
, *fend
; /* Beginning and end of fname */
4261 struct file_name_list
*search_start
= include
; /* Chain of dirs to search */
4262 struct file_name_list dsp
[1]; /* First in chain, if #include "..." */
4263 struct file_name_list
*searchptr
= 0;
4266 int f
; /* file number */
4268 int retried
= 0; /* Have already tried macro
4269 expanding the include line*/
4270 int angle_brackets
= 0; /* 0 for "...", 1 for <...> */
4275 f
= -1; /* JF we iz paranoid! */
4277 if (importing
&& warn_import
&& !inhibit_warnings
4278 && !instack
[indepth
].system_header_p
&& !import_warning
) {
4280 warning ("using `#import' is not recommended");
4281 fprintf (stderr
, "The fact that a certain header file need not be processed more than once\n");
4282 fprintf (stderr
, "should be indicated in the header file, not where it is used.\n");
4283 fprintf (stderr
, "The best way to do this is with a conditional of this form:\n\n");
4284 fprintf (stderr
, " #ifndef _FOO_H_INCLUDED\n");
4285 fprintf (stderr
, " #define _FOO_H_INCLUDED\n");
4286 fprintf (stderr
, " ... <real contents of file> ...\n");
4287 fprintf (stderr
, " #endif /* Not _FOO_H_INCLUDED */\n\n");
4288 fprintf (stderr
, "Then users can use `#include' any number of times.\n");
4289 fprintf (stderr
, "GNU C automatically avoids processing the file more than once\n");
4290 fprintf (stderr
, "when it is equipped with such a conditional.\n");
4296 SKIP_WHITE_SPACE (fbeg
);
4297 /* Discard trailing whitespace so we can easily see
4298 if we have parsed all the significant chars we were given. */
4299 while (limit
!= fbeg
&& is_hor_space
[limit
[-1]]) limit
--;
4305 /* Copy the operand text, concatenating the strings. */
4308 fbeg
= (U_CHAR
*) alloca (limit
- fbeg
+ 1);
4310 while (fin
!= limit
) {
4311 while (fin
!= limit
&& *fin
!= '\"')
4316 /* If not at the end, there had better be another string. */
4317 /* Skip just horiz space, and don't go past limit. */
4318 while (fin
!= limit
&& is_hor_space
[*fin
]) fin
++;
4319 if (fin
!= limit
&& *fin
== '\"')
4327 /* We have "filename". Figure out directory this source
4328 file is coming from and put it on the front of the list. */
4330 /* If -I- was specified, don't search current dir, only spec'd ones. */
4331 if (ignore_srcdir
) break;
4333 for (fp
= &instack
[indepth
]; fp
>= instack
; fp
--)
4338 if ((nam
= fp
->nominal_fname
) != NULL
) {
4339 /* Found a named file. Figure out dir of the file,
4340 and put it in front of the search list. */
4341 dsp
[0].next
= search_start
;
4344 ep
= rindex (nam
, '/');
4345 #ifdef DIR_SEPARATOR
4346 if (ep
== NULL
) ep
= rindex (nam
, DIR_SEPARATOR
);
4348 char *tmp
= rindex (nam
, DIR_SEPARATOR
);
4349 if (tmp
!= NULL
&& tmp
> ep
) ep
= tmp
;
4353 ep
= rindex (nam
, ']');
4354 if (ep
== NULL
) ep
= rindex (nam
, '>');
4355 if (ep
== NULL
) ep
= rindex (nam
, ':');
4356 if (ep
!= NULL
) ep
++;
4360 dsp
[0].fname
= (char *) alloca (n
+ 1);
4361 strncpy (dsp
[0].fname
, nam
, n
);
4362 dsp
[0].fname
[n
] = '\0';
4363 if (n
+ INCLUDE_LEN_FUDGE
> max_include_len
)
4364 max_include_len
= n
+ INCLUDE_LEN_FUDGE
;
4366 dsp
[0].fname
= 0; /* Current directory */
4368 dsp
[0].got_name_map
= 0;
4377 while (fend
!= limit
&& *fend
!= '>') fend
++;
4378 if (*fend
== '>' && fend
+ 1 == limit
) {
4380 /* If -I-, start with the first -I dir after the -I-. */
4381 if (first_bracket_include
)
4382 search_start
= first_bracket_include
;
4390 * Support '#include xyz' like VAX-C to allow for easy use of all the
4391 * decwindow include files. It defaults to '#include <xyz.h>' (so the
4392 * code from case '<' is repeated here) and generates a warning.
4393 * (Note: macro expansion of `xyz' takes precedence.)
4395 if (retried
&& isalpha(*(--fbeg
))) {
4397 while (fend
!= limit
&& (!isspace(*fend
))) fend
++;
4398 warning ("VAX-C-style include specification found, use '#include <filename.h>' !");
4399 if (fend
== limit
) {
4401 /* If -I-, start with the first -I dir after the -I-. */
4402 if (first_bracket_include
)
4403 search_start
= first_bracket_include
;
4411 error ("`#%s' expects \"FILENAME\" or <FILENAME>", keyword
->name
);
4414 /* Expand buffer and then remove any newline markers.
4415 We can't just tell expand_to_temp_buffer to omit the markers,
4416 since it would put extra spaces in include file names. */
4419 trybuf
= expand_to_temp_buffer (buf
, limit
, 1, 0);
4421 buf
= (U_CHAR
*) alloca (trybuf
.bufp
- trybuf
.buf
+ 1);
4423 while (src
!= trybuf
.bufp
) {
4424 switch ((*limit
++ = *src
++)) {
4433 U_CHAR
*src1
= skip_quoted_string (src
- 1, trybuf
.bufp
, 0,
4434 NULL_PTR
, NULL_PTR
, NULL_PTR
);
4448 /* For #include_next, skip in the search path
4449 past the dir in which the containing file was found. */
4452 for (fp
= &instack
[indepth
]; fp
>= instack
; fp
--)
4453 if (fp
->fname
!= NULL
) {
4454 /* fp->dir is null if the containing file was specified
4455 with an absolute file name. In that case, don't skip anything. */
4457 search_start
= fp
->dir
->next
;
4466 error ("empty file name in `#%s'", keyword
->name
);
4470 /* Allocate this permanently, because it gets stored in the definitions
4472 fname
= xmalloc (max_include_len
+ flen
+ 4);
4473 /* + 2 above for slash and terminating null. */
4474 /* + 2 added for '.h' on VMS (to support '#include filename') */
4476 /* If specified file name is absolute, just open it. */
4479 #ifdef DIR_SEPARATOR
4480 || *fbeg
== DIR_SEPARATOR
4483 strncpy (fname
, (char *) fbeg
, flen
);
4485 if (redundant_include_p (fname
))
4488 f
= lookup_import (fname
, NULL_PTR
);
4490 f
= open_include_file (fname
, NULL_PTR
);
4492 return 0; /* Already included this file */
4494 /* Search directory path, trying to open the file.
4495 Copy each filename tried into FNAME. */
4497 for (searchptr
= search_start
; searchptr
; searchptr
= searchptr
->next
) {
4498 if (searchptr
->fname
) {
4499 /* The empty string in a search path is ignored.
4500 This makes it possible to turn off entirely
4501 a standard piece of the list. */
4502 if (searchptr
->fname
[0] == 0)
4504 strcpy (fname
, searchptr
->fname
);
4505 strcat (fname
, "/");
4506 fname
[strlen (fname
) + flen
] = 0;
4510 strncat (fname
, (char *) fbeg
, flen
);
4512 /* Change this 1/2 Unix 1/2 VMS file specification into a
4513 full VMS file specification */
4514 if (searchptr
->fname
&& (searchptr
->fname
[0] != 0)) {
4515 /* Fix up the filename */
4516 hack_vms_include_specification (fname
);
4518 /* This is a normal VMS filespec, so use it unchanged. */
4519 strncpy (fname
, fbeg
, flen
);
4521 /* if it's '#include filename', add the missing .h */
4522 if (index(fname
,'.')==NULL
) {
4523 strcat (fname
, ".h");
4527 /* ??? There are currently 3 separate mechanisms for avoiding processing
4528 of redundant include files: #import, #pragma once, and
4529 redundant_include_p. It would be nice if they were unified. */
4530 if (redundant_include_p (fname
))
4533 f
= lookup_import (fname
, searchptr
);
4535 f
= open_include_file (fname
, searchptr
);
4537 return 0; /* Already included this file */
4539 else if (f
== -1 && errno
== EACCES
)
4540 warning ("Header file %s exists, but is not readable", fname
);
4548 /* A file that was not found. */
4550 strncpy (fname
, (char *) fbeg
, flen
);
4552 /* If generating dependencies and -MG was specified, we assume missing
4553 files are leaf files, living in the same directory as the source file
4554 or other similar place; these missing files may be generated from
4555 other files and may not exist yet (eg: y.tab.h). */
4556 if (print_deps_missing_files
4557 && print_deps
> (angle_brackets
|| (system_include_depth
> 0)))
4559 /* If it was requested as a system header file,
4560 then assume it belongs in the first place to look for such. */
4563 for (searchptr
= search_start
; searchptr
; searchptr
= searchptr
->next
)
4565 if (searchptr
->fname
)
4569 if (searchptr
->fname
[0] == 0)
4571 p
= (char *) alloca (strlen (searchptr
->fname
)
4572 + strlen (fname
) + 2);
4573 strcpy (p
, searchptr
->fname
);
4576 deps_output (p
, ' ');
4583 /* Otherwise, omit the directory, as if the file existed
4584 in the directory with the source. */
4585 deps_output (fname
, ' ');
4588 /* If -M was specified, and this header file won't be added to the
4589 dependency list, then don't count this as an error, because we can
4590 still produce correct output. Otherwise, we can't produce correct
4591 output, because there may be dependencies we need inside the missing
4592 file, and we don't know what directory this missing file exists in. */
4594 && (print_deps
<= (angle_brackets
|| (system_include_depth
> 0))))
4595 warning ("No include path in which to find %s", fname
);
4596 else if (search_start
)
4597 error_from_errno (fname
);
4599 error ("No include path in which to find %s", fname
);
4601 /* Check to see if this include file is a once-only include file.
4604 struct file_name_list
* ptr
;
4606 for (ptr
= dont_repeat_files
; ptr
; ptr
= ptr
->next
) {
4607 if (!strcmp (ptr
->fname
, fname
)) {
4609 return 0; /* This file was once'd. */
4613 for (ptr
= all_include_files
; ptr
; ptr
= ptr
->next
) {
4614 if (!strcmp (ptr
->fname
, fname
))
4615 break; /* This file was included before. */
4619 /* This is the first time for this file. */
4620 /* Add it to list of files included. */
4622 ptr
= (struct file_name_list
*) xmalloc (sizeof (struct file_name_list
));
4623 ptr
->control_macro
= 0;
4624 ptr
->c_system_include_path
= 0;
4625 ptr
->next
= all_include_files
;
4626 all_include_files
= ptr
;
4627 ptr
->fname
= savestring (fname
);
4628 ptr
->got_name_map
= 0;
4630 /* For -M, add this file to the dependencies. */
4631 if (print_deps
> (angle_brackets
|| (system_include_depth
> 0)))
4632 deps_output (fname
, ' ');
4635 /* Handle -H option. */
4636 if (print_include_names
) {
4637 output_dots (stderr
, indepth
);
4638 fprintf (stderr
, "%s\n", fname
);
4642 system_include_depth
++;
4644 /* Actually process the file. */
4645 add_import (f
, fname
); /* Record file on "seen" list for #import. */
4647 pcftry
= (char *) alloca (strlen (fname
) + 30);
4658 sprintf (pcftry
, "%s%d", fname
, pcfnum
++);
4660 pcf
= open (pcftry
, O_RDONLY
, 0666);
4666 if (bcmp ((char *) &stat_f
.st_ino
, (char *) &s
.st_ino
,
4668 || stat_f
.st_dev
!= s
.st_dev
)
4670 pcfbuf
= check_precompiled (pcf
, fname
, &pcfbuflimit
);
4671 /* Don't need it any more. */
4676 /* Don't need it at all. */
4681 } while (pcf
!= -1 && !pcfbuf
);
4684 /* Actually process the file */
4686 pcfname
= xmalloc (strlen (pcftry
) + 1);
4687 strcpy (pcfname
, pcftry
);
4688 pcfinclude ((U_CHAR
*) pcfbuf
, (U_CHAR
*) pcfbuflimit
,
4689 (U_CHAR
*) fname
, op
);
4692 finclude (f
, fname
, op
, is_system_include (fname
), searchptr
);
4695 system_include_depth
--;
4700 /* Return nonzero if there is no need to include file NAME
4701 because it has already been included and it contains a conditional
4702 to make a repeated include do nothing. */
4705 redundant_include_p (name
)
4708 struct file_name_list
*l
= all_include_files
;
4709 for (; l
; l
= l
->next
)
4710 if (! strcmp (name
, l
->fname
)
4712 && lookup (l
->control_macro
, -1, -1))
4717 /* Return nonzero if the given FILENAME is an absolute pathname which
4718 designates a file within one of the known "system" include file
4719 directories. We assume here that if the given FILENAME looks like
4720 it is the name of a file which resides either directly in a "system"
4721 include file directory, or within any subdirectory thereof, then the
4722 given file must be a "system" include file. This function tells us
4723 if we should suppress pedantic errors/warnings for the given FILENAME.
4725 The value is 2 if the file is a C-language system header file
4726 for which C++ should (on most systems) assume `extern "C"'. */
4729 is_system_include (filename
)
4730 register char *filename
;
4732 struct file_name_list
*searchptr
;
4734 for (searchptr
= first_system_include
; searchptr
;
4735 searchptr
= searchptr
->next
)
4736 if (searchptr
->fname
) {
4737 register char *sys_dir
= searchptr
->fname
;
4738 register unsigned length
= strlen (sys_dir
);
4740 if (! strncmp (sys_dir
, filename
, length
)
4741 && (filename
[length
] == '/'
4742 #ifdef DIR_SEPARATOR
4743 || filename
[length
] == DIR_SEPARATOR
4746 if (searchptr
->c_system_include_path
)
4755 /* The file_name_map structure holds a mapping of file names for a
4756 particular directory. This mapping is read from the file named
4757 FILE_NAME_MAP_FILE in that directory. Such a file can be used to
4758 map filenames on a file system with severe filename restrictions,
4759 such as DOS. The format of the file name map file is just a series
4760 of lines with two tokens on each line. The first token is the name
4761 to map, and the second token is the actual name to use. */
4763 struct file_name_map
4765 struct file_name_map
*map_next
;
4770 #define FILE_NAME_MAP_FILE "header.gcc"
4772 /* Read a space delimited string of unlimited length from a stdio
4776 read_filename_string (ch
, f
)
4784 set
= alloc
= xmalloc (len
+ 1);
4788 while ((ch
= getc (f
)) != EOF
&& ! is_space
[ch
])
4790 if (set
- alloc
== len
)
4793 alloc
= xrealloc (alloc
, len
+ 1);
4794 set
= alloc
+ len
/ 2;
4804 /* Read the file name map file for DIRNAME. */
4806 static struct file_name_map
*
4807 read_name_map (dirname
)
4810 /* This structure holds a linked list of file name maps, one per
4812 struct file_name_map_list
4814 struct file_name_map_list
*map_list_next
;
4815 char *map_list_name
;
4816 struct file_name_map
*map_list_map
;
4818 static struct file_name_map_list
*map_list
;
4819 register struct file_name_map_list
*map_list_ptr
;
4823 for (map_list_ptr
= map_list
; map_list_ptr
;
4824 map_list_ptr
= map_list_ptr
->map_list_next
)
4825 if (! strcmp (map_list_ptr
->map_list_name
, dirname
))
4826 return map_list_ptr
->map_list_map
;
4828 map_list_ptr
= ((struct file_name_map_list
*)
4829 xmalloc (sizeof (struct file_name_map_list
)));
4830 map_list_ptr
->map_list_name
= savestring (dirname
);
4831 map_list_ptr
->map_list_map
= NULL
;
4833 name
= (char *) alloca (strlen (dirname
) + strlen (FILE_NAME_MAP_FILE
) + 2);
4834 strcpy (name
, dirname
);
4837 strcat (name
, FILE_NAME_MAP_FILE
);
4838 f
= fopen (name
, "r");
4840 map_list_ptr
->map_list_map
= NULL
;
4844 int dirlen
= strlen (dirname
);
4846 while ((ch
= getc (f
)) != EOF
)
4849 struct file_name_map
*ptr
;
4853 from
= read_filename_string (ch
, f
);
4854 while ((ch
= getc (f
)) != EOF
&& is_hor_space
[ch
])
4856 to
= read_filename_string (ch
, f
);
4858 ptr
= ((struct file_name_map
*)
4859 xmalloc (sizeof (struct file_name_map
)));
4860 ptr
->map_from
= from
;
4862 /* Make the real filename absolute. */
4867 ptr
->map_to
= xmalloc (dirlen
+ strlen (to
) + 2);
4868 strcpy (ptr
->map_to
, dirname
);
4869 ptr
->map_to
[dirlen
] = '/';
4870 strcpy (ptr
->map_to
+ dirlen
+ 1, to
);
4874 ptr
->map_next
= map_list_ptr
->map_list_map
;
4875 map_list_ptr
->map_list_map
= ptr
;
4877 while ((ch
= getc (f
)) != '\n')
4884 map_list_ptr
->map_list_next
= map_list
;
4885 map_list
= map_list_ptr
;
4887 return map_list_ptr
->map_list_map
;
4890 /* Try to open include file FILENAME. SEARCHPTR is the directory
4891 being tried from the include file search path. This function maps
4892 filenames on file systems based on information read by
4896 open_include_file (filename
, searchptr
)
4898 struct file_name_list
*searchptr
;
4900 register struct file_name_map
*map
;
4901 register char *from
;
4904 if (searchptr
&& ! searchptr
->got_name_map
)
4906 searchptr
->name_map
= read_name_map (searchptr
->fname
4907 ? searchptr
->fname
: ".");
4908 searchptr
->got_name_map
= 1;
4911 /* First check the mapping for the directory we are using. */
4912 if (searchptr
&& searchptr
->name_map
)
4915 if (searchptr
->fname
)
4916 from
+= strlen (searchptr
->fname
) + 1;
4917 for (map
= searchptr
->name_map
; map
; map
= map
->map_next
)
4919 if (! strcmp (map
->map_from
, from
))
4921 /* Found a match. */
4922 return open (map
->map_to
, O_RDONLY
, 0666);
4927 /* Try to find a mapping file for the particular directory we are
4928 looking in. Thus #include <sys/types.h> will look up sys/types.h
4929 in /usr/include/header.gcc and look up types.h in
4930 /usr/include/sys/header.gcc. */
4931 p
= rindex (filename
, '/');
4932 #ifdef DIR_SEPARATOR
4933 if (! p
) p
= rindex (filename
, DIR_SEPARATOR
);
4935 char *tmp
= rindex (filename
, DIR_SEPARATOR
);
4936 if (tmp
!= NULL
&& tmp
> p
) p
= tmp
;
4943 && strlen (searchptr
->fname
) == p
- filename
4944 && ! strncmp (searchptr
->fname
, filename
, p
- filename
))
4946 /* FILENAME is in SEARCHPTR, which we've already checked. */
4947 return open (filename
, O_RDONLY
, 0666);
4957 dir
= (char *) alloca (p
- filename
+ 1);
4958 bcopy (filename
, dir
, p
- filename
);
4959 dir
[p
- filename
] = '\0';
4962 for (map
= read_name_map (dir
); map
; map
= map
->map_next
)
4963 if (! strcmp (map
->map_from
, from
))
4964 return open (map
->map_to
, O_RDONLY
, 0666);
4966 return open (filename
, O_RDONLY
, 0666);
4969 /* Process the contents of include file FNAME, already open on descriptor F,
4971 SYSTEM_HEADER_P is 1 if this file resides in any one of the known
4972 "system" include directories (as decided by the `is_system_include'
4974 DIRPTR is the link in the dir path through which this file was found,
4975 or 0 if the file name was absolute. */
4978 finclude (f
, fname
, op
, system_header_p
, dirptr
)
4982 int system_header_p
;
4983 struct file_name_list
*dirptr
;
4988 FILE_BUF
*fp
; /* For input stack frame */
4989 int missing_newline
= 0;
4991 CHECK_DEPTH (return;);
4993 if (file_size_and_mode (f
, &st_mode
, &st_size
) < 0)
4995 perror_with_name (fname
);
5000 fp
= &instack
[indepth
+ 1];
5001 bzero ((char *) fp
, sizeof (FILE_BUF
));
5002 fp
->nominal_fname
= fp
->fname
= fname
;
5005 fp
->if_stack
= if_stack
;
5006 fp
->system_header_p
= system_header_p
;
5009 if (S_ISREG (st_mode
)) {
5010 fp
->buf
= (U_CHAR
*) xmalloc (st_size
+ 2);
5013 /* Read the file contents, knowing that st_size is an upper bound
5014 on the number of bytes we can read. */
5015 fp
->length
= safe_read (f
, (char *) fp
->buf
, st_size
);
5016 if (fp
->length
< 0) goto nope
;
5018 else if (S_ISDIR (st_mode
)) {
5019 error ("directory `%s' specified in #include", fname
);
5023 /* Cannot count its file size before reading.
5024 First read the entire file into heap and
5025 copy them into buffer on stack. */
5030 fp
->buf
= (U_CHAR
*) xmalloc (bsize
+ 2);
5033 i
= safe_read (f
, (char *) fp
->buf
+ st_size
, bsize
- st_size
);
5035 goto nope
; /* error! */
5037 if (st_size
!= bsize
)
5038 break; /* End of file */
5040 fp
->buf
= (U_CHAR
*) xrealloc (fp
->buf
, bsize
+ 2);
5043 fp
->length
= st_size
;
5046 if ((fp
->length
> 0 && fp
->buf
[fp
->length
- 1] != '\n')
5047 /* Backslash-newline at end is not good enough. */
5048 || (fp
->length
> 1 && fp
->buf
[fp
->length
- 2] == '\\')) {
5049 fp
->buf
[fp
->length
++] = '\n';
5050 missing_newline
= 1;
5052 fp
->buf
[fp
->length
] = '\0';
5054 /* Close descriptor now, so nesting does not use lots of descriptors. */
5057 /* Must do this before calling trigraph_pcp, so that the correct file name
5058 will be printed in warning messages. */
5061 input_file_stack_tick
++;
5066 output_line_directive (fp
, op
, 0, enter_file
);
5069 if (missing_newline
)
5072 if (pedantic
&& missing_newline
)
5073 pedwarn ("file does not end in newline");
5076 input_file_stack_tick
++;
5077 output_line_directive (&instack
[indepth
], op
, 0, leave_file
);
5083 perror_with_name (fname
);
5088 /* Record that inclusion of the file named FILE
5089 should be controlled by the macro named MACRO_NAME.
5090 This means that trying to include the file again
5091 will do something if that macro is defined. */
5094 record_control_macro (file
, macro_name
)
5098 struct file_name_list
*new;
5100 for (new = all_include_files
; new; new = new->next
) {
5101 if (!strcmp (new->fname
, file
)) {
5102 new->control_macro
= macro_name
;
5107 /* If the file is not in all_include_files, something's wrong. */
5111 /* Maintain and search list of included files, for #import. */
5113 #define IMPORT_HASH_SIZE 31
5115 struct import_file
{
5119 struct import_file
*next
;
5122 /* Hash table of files already included with #include or #import. */
5124 static struct import_file
*import_hash_table
[IMPORT_HASH_SIZE
];
5126 /* Hash a file name for import_hash_table. */
5134 while (*f
) val
+= *f
++;
5135 return (val
%IMPORT_HASH_SIZE
);
5138 /* Search for file FILENAME in import_hash_table.
5139 Return -2 if found, either a matching name or a matching inode.
5140 Otherwise, open the file and return a file descriptor if successful
5141 or -1 if unsuccessful. */
5144 lookup_import (filename
, searchptr
)
5146 struct file_name_list
*searchptr
;
5148 struct import_file
*i
;
5154 hashval
= import_hash (filename
);
5156 /* Attempt to find file in list of already included files */
5157 i
= import_hash_table
[hashval
];
5160 if (!strcmp (filename
, i
->name
))
5161 return -2; /* return found */
5164 /* Open it and try a match on inode/dev */
5165 fd
= open_include_file (filename
, searchptr
);
5169 for (h
= 0; h
< IMPORT_HASH_SIZE
; h
++) {
5170 i
= import_hash_table
[h
];
5172 /* Compare the inode and the device.
5173 Supposedly on some systems the inode is not a scalar. */
5174 if (!bcmp ((char *) &i
->inode
, (char *) &sb
.st_ino
, sizeof (sb
.st_ino
))
5175 && i
->dev
== sb
.st_dev
) {
5177 return -2; /* return found */
5182 return fd
; /* Not found, return open file */
5185 /* Add the file FNAME, open on descriptor FD, to import_hash_table. */
5188 add_import (fd
, fname
)
5192 struct import_file
*i
;
5196 hashval
= import_hash (fname
);
5198 i
= (struct import_file
*)xmalloc (sizeof (struct import_file
));
5199 i
->name
= xmalloc (strlen (fname
)+1);
5200 strcpy (i
->name
, fname
);
5201 bcopy ((char *) &sb
.st_ino
, (char *) &i
->inode
, sizeof (sb
.st_ino
));
5203 i
->next
= import_hash_table
[hashval
];
5204 import_hash_table
[hashval
] = i
;
5207 /* Load the specified precompiled header into core, and verify its
5208 preconditions. PCF indicates the file descriptor to read, which must
5209 be a regular file. FNAME indicates the file name of the original
5210 header. *LIMIT will be set to an address one past the end of the file.
5211 If the preconditions of the file are not satisfied, the buffer is
5212 freed and we return 0. If the preconditions are satisfied, return
5213 the address of the buffer following the preconditions. The buffer, in
5214 this case, should never be freed because various pieces of it will
5215 be referred to until all precompiled strings are output at the end of
5219 check_precompiled (pcf
, fname
, limit
)
5233 if (file_size_and_mode (pcf
, &st_mode
, &st_size
) < 0)
5236 if (S_ISREG (st_mode
))
5238 buf
= xmalloc (st_size
+ 2);
5239 length
= safe_read (pcf
, buf
, st_size
);
5246 if (length
> 0 && buf
[length
-1] != '\n')
5247 buf
[length
++] = '\n';
5250 *limit
= buf
+ length
;
5252 /* File is in core. Check the preconditions. */
5253 if (!check_preconditions (buf
))
5255 for (cp
= buf
; *cp
; cp
++)
5258 fprintf (stderr
, "Using preinclude %s\n", fname
);
5264 fprintf (stderr
, "Cannot use preinclude %s\n", fname
);
5270 /* PREC (null terminated) points to the preconditions of a
5271 precompiled header. These are a series of #define and #undef
5272 lines which must match the current contents of the hash
5275 check_preconditions (prec
)
5282 lineend
= index (prec
, '\n');
5284 if (*prec
++ != '#') {
5285 error ("Bad format encountered while reading precompiled file");
5288 if (!strncmp (prec
, "define", 6)) {
5292 mdef
= create_definition ((U_CHAR
*) prec
, (U_CHAR
*) lineend
, NULL_PTR
);
5297 if ((hp
= lookup (mdef
.symnam
, mdef
.symlen
, -1)) == NULL
5298 || (hp
->type
!= T_MACRO
&& hp
->type
!= T_CONST
)
5299 || (hp
->type
== T_MACRO
5300 && !compare_defs (mdef
.defn
, hp
->value
.defn
)
5301 && (mdef
.defn
->length
!= 2
5302 || mdef
.defn
->expansion
[0] != '\n'
5303 || mdef
.defn
->expansion
[1] != ' ')))
5305 } else if (!strncmp (prec
, "undef", 5)) {
5310 while (is_hor_space
[(U_CHAR
) *prec
])
5313 while (is_idchar
[(U_CHAR
) *prec
])
5317 if (lookup ((U_CHAR
*) name
, len
, -1))
5320 error ("Bad format encountered while reading precompiled file");
5325 /* They all passed successfully */
5329 /* Process the main body of a precompiled file. BUF points to the
5330 string section of the file, following the preconditions. LIMIT is one
5331 character past the end. NAME is the name of the file being read
5332 in. OP is the main output buffer */
5334 pcfinclude (buf
, limit
, name
, op
)
5335 U_CHAR
*buf
, *limit
, *name
;
5342 /* First in the file comes 4 bytes indicating the number of strings, */
5343 /* in network byte order. (MSB first). */
5345 nstrings
= (nstrings
<< 8) | *cp
++;
5346 nstrings
= (nstrings
<< 8) | *cp
++;
5347 nstrings
= (nstrings
<< 8) | *cp
++;
5349 /* Looping over each string... */
5350 while (nstrings
--) {
5351 U_CHAR
*string_start
;
5352 U_CHAR
*endofthiskey
;
5356 /* Each string starts with a STRINGDEF structure (str), followed */
5357 /* by the text of the string (string_start) */
5359 /* First skip to a longword boundary */
5360 /* ??? Why a 4-byte boundary? On all machines? */
5361 /* NOTE: This works correctly even if HOST_WIDE_INT
5362 is narrower than a pointer.
5363 Do not try risky measures here to get another type to use!
5364 Do not include stddef.h--it will fail! */
5365 if ((HOST_WIDE_INT
) cp
& 3)
5366 cp
+= 4 - ((HOST_WIDE_INT
) cp
& 3);
5368 /* Now get the string. */
5369 str
= (STRINGDEF
*) (GENERIC_PTR
) cp
;
5370 string_start
= cp
+= sizeof (STRINGDEF
);
5372 for (; *cp
; cp
++) /* skip the string */
5375 /* We need to macro expand the string here to ensure that the
5376 proper definition environment is in place. If it were only
5377 expanded when we find out it is needed, macros necessary for
5378 its proper expansion might have had their definitions changed. */
5379 tmpbuf
= expand_to_temp_buffer (string_start
, cp
++, 0, 0);
5380 /* Lineno is already set in the precompiled file */
5381 str
->contents
= tmpbuf
.buf
;
5382 str
->len
= tmpbuf
.length
;
5384 str
->filename
= name
;
5385 str
->output_mark
= outbuf
.bufp
- outbuf
.buf
;
5388 *stringlist_tailp
= str
;
5389 stringlist_tailp
= &str
->chain
;
5391 /* Next comes a fourbyte number indicating the number of keys */
5392 /* for this string. */
5394 nkeys
= (nkeys
<< 8) | *cp
++;
5395 nkeys
= (nkeys
<< 8) | *cp
++;
5396 nkeys
= (nkeys
<< 8) | *cp
++;
5398 /* If this number is -1, then the string is mandatory. */
5402 /* Otherwise, for each key, */
5403 for (; nkeys
--; free (tmpbuf
.buf
), cp
= endofthiskey
+ 1) {
5404 KEYDEF
*kp
= (KEYDEF
*) (GENERIC_PTR
) cp
;
5407 /* It starts with a KEYDEF structure */
5408 cp
+= sizeof (KEYDEF
);
5410 /* Find the end of the key. At the end of this for loop we
5411 advance CP to the start of the next key using this variable. */
5412 endofthiskey
= cp
+ strlen ((char *) cp
);
5415 /* Expand the key, and enter it into the hash table. */
5416 tmpbuf
= expand_to_temp_buffer (cp
, endofthiskey
, 0, 0);
5417 tmpbuf
.bufp
= tmpbuf
.buf
;
5419 while (is_hor_space
[*tmpbuf
.bufp
])
5421 if (!is_idstart
[*tmpbuf
.bufp
]
5422 || tmpbuf
.bufp
== tmpbuf
.buf
+ tmpbuf
.length
) {
5427 hp
= lookup (tmpbuf
.bufp
, -1, -1);
5430 install (tmpbuf
.bufp
, -1, T_PCSTRING
, (char *) kp
, -1);
5432 else if (hp
->type
== T_PCSTRING
) {
5433 kp
->chain
= hp
->value
.keydef
;
5434 hp
->value
.keydef
= kp
;
5440 /* This output_line_directive serves to switch us back to the current
5441 input file in case some of these strings get output (which will
5442 result in line directives for the header file being output). */
5443 output_line_directive (&instack
[indepth
], op
, 0, enter_file
);
5446 /* Called from rescan when it hits a key for strings. Mark them all */
5447 /* used and clean up. */
5454 for (kp
= hp
->value
.keydef
; kp
; kp
= kp
->chain
)
5455 kp
->str
->writeflag
= 1;
5459 /* Write the output, interspersing precompiled strings in their */
5460 /* appropriate places. */
5464 STRINGDEF
*next_string
;
5465 U_CHAR
*cur_buf_loc
;
5466 int line_directive_len
= 80;
5467 char *line_directive
= xmalloc (line_directive_len
);
5470 /* In each run through the loop, either cur_buf_loc == */
5471 /* next_string_loc, in which case we print a series of strings, or */
5472 /* it is less than next_string_loc, in which case we write some of */
5474 cur_buf_loc
= outbuf
.buf
;
5475 next_string
= stringlist
;
5477 while (cur_buf_loc
< outbuf
.bufp
|| next_string
) {
5479 && cur_buf_loc
- outbuf
.buf
== next_string
->output_mark
) {
5480 if (next_string
->writeflag
) {
5481 len
= 4 * strlen ((char *) next_string
->filename
) + 32;
5482 while (len
> line_directive_len
)
5483 line_directive
= xrealloc (line_directive
,
5484 line_directive_len
*= 2);
5485 sprintf (line_directive
, "\n# %d ", next_string
->lineno
);
5486 strcpy (quote_string (line_directive
+ strlen (line_directive
),
5487 (char *) next_string
->filename
),
5489 safe_write (fileno (stdout
), line_directive
, strlen (line_directive
));
5490 safe_write (fileno (stdout
),
5491 (char *) next_string
->contents
, next_string
->len
);
5493 next_string
= next_string
->chain
;
5497 ? (next_string
->output_mark
5498 - (cur_buf_loc
- outbuf
.buf
))
5499 : outbuf
.bufp
- cur_buf_loc
);
5501 safe_write (fileno (stdout
), (char *) cur_buf_loc
, len
);
5505 free (line_directive
);
5508 /* Pass a directive through to the output file.
5509 BUF points to the contents of the directive, as a contiguous string.
5510 LIMIT points to the first character past the end of the directive.
5511 KEYWORD is the keyword-table entry for the directive. */
5514 pass_thru_directive (buf
, limit
, op
, keyword
)
5515 U_CHAR
*buf
, *limit
;
5517 struct directive
*keyword
;
5519 register unsigned keyword_length
= keyword
->length
;
5521 check_expand (op
, 1 + keyword_length
+ (limit
- buf
));
5523 bcopy (keyword
->name
, (char *) op
->bufp
, keyword_length
);
5524 op
->bufp
+= keyword_length
;
5525 if (limit
!= buf
&& buf
[0] != ' ')
5527 bcopy ((char *) buf
, (char *) op
->bufp
, limit
- buf
);
5528 op
->bufp
+= (limit
- buf
);
5531 /* Count the line we have just made in the output,
5532 to get in sync properly. */
5537 /* The arglist structure is built by do_define to tell
5538 collect_definition where the argument names begin. That
5539 is, for a define like "#define f(x,y,z) foo+x-bar*y", the arglist
5540 would contain pointers to the strings x, y, and z.
5541 Collect_definition would then build a DEFINITION node,
5542 with reflist nodes pointing to the places x, y, and z had
5543 appeared. So the arglist is just convenience data passed
5544 between these two routines. It is not kept around after
5545 the current #define has been processed and entered into the
5549 struct arglist
*next
;
5556 /* Create a DEFINITION node from a #define directive. Arguments are
5557 as for do_define. */
5559 create_definition (buf
, limit
, op
)
5560 U_CHAR
*buf
, *limit
;
5563 U_CHAR
*bp
; /* temp ptr into input buffer */
5564 U_CHAR
*symname
; /* remember where symbol name starts */
5565 int sym_length
; /* and how long it is */
5566 int line
= instack
[indepth
].lineno
;
5567 char *file
= instack
[indepth
].nominal_fname
;
5571 int arglengths
= 0; /* Accumulate lengths of arg names
5572 plus number of args. */
5577 while (is_hor_space
[*bp
])
5580 symname
= bp
; /* remember where it starts */
5581 sym_length
= check_macro_name (bp
, "macro");
5584 /* Lossage will occur if identifiers or control keywords are broken
5585 across lines using backslash. This is not the right place to take
5589 struct arglist
*arg_ptrs
= NULL
;
5592 bp
++; /* skip '(' */
5593 SKIP_WHITE_SPACE (bp
);
5595 /* Loop over macro argument names. */
5596 while (*bp
!= ')') {
5597 struct arglist
*temp
;
5599 temp
= (struct arglist
*) alloca (sizeof (struct arglist
));
5601 temp
->next
= arg_ptrs
;
5602 temp
->argno
= argno
++;
5603 temp
->rest_args
= 0;
5607 pedwarn ("another parameter follows `%s'",
5610 if (!is_idstart
[*bp
])
5611 pedwarn ("invalid character in macro parameter name");
5613 /* Find the end of the arg name. */
5614 while (is_idchar
[*bp
]) {
5616 /* do we have a "special" rest-args extension here? */
5617 if (limit
- bp
> REST_EXTENSION_LENGTH
&&
5618 bcmp (rest_extension
, bp
, REST_EXTENSION_LENGTH
) == 0) {
5620 temp
->rest_args
= 1;
5624 temp
->length
= bp
- temp
->name
;
5626 bp
+= REST_EXTENSION_LENGTH
;
5627 arglengths
+= temp
->length
+ 2;
5628 SKIP_WHITE_SPACE (bp
);
5629 if (temp
->length
== 0 || (*bp
!= ',' && *bp
!= ')')) {
5630 error ("badly punctuated parameter list in `#define'");
5635 SKIP_WHITE_SPACE (bp
);
5636 /* A comma at this point can only be followed by an identifier. */
5637 if (!is_idstart
[*bp
]) {
5638 error ("badly punctuated parameter list in `#define'");
5643 error ("unterminated parameter list in `#define'");
5647 struct arglist
*otemp
;
5649 for (otemp
= temp
->next
; otemp
!= NULL
; otemp
= otemp
->next
)
5650 if (temp
->length
== otemp
->length
&&
5651 bcmp (temp
->name
, otemp
->name
, temp
->length
) == 0) {
5652 error ("duplicate argument name `%.*s' in `#define'",
5653 temp
->length
, temp
->name
);
5659 ++bp
; /* skip paren */
5660 SKIP_WHITE_SPACE (bp
);
5661 /* now everything from bp before limit is the definition. */
5662 defn
= collect_expansion (bp
, limit
, argno
, arg_ptrs
);
5663 defn
->rest_args
= rest_args
;
5665 /* Now set defn->args.argnames to the result of concatenating
5666 the argument names in reverse order
5667 with comma-space between them. */
5668 defn
->args
.argnames
= (U_CHAR
*) xmalloc (arglengths
+ 1);
5670 struct arglist
*temp
;
5672 for (temp
= arg_ptrs
; temp
; temp
= temp
->next
) {
5673 bcopy (temp
->name
, &defn
->args
.argnames
[i
], temp
->length
);
5675 if (temp
->next
!= 0) {
5676 defn
->args
.argnames
[i
++] = ',';
5677 defn
->args
.argnames
[i
++] = ' ';
5680 defn
->args
.argnames
[i
] = 0;
5683 /* Simple expansion or empty definition. */
5687 if (is_hor_space
[*bp
]) {
5689 SKIP_WHITE_SPACE (bp
);
5692 case '!': case '"': case '#': case '%': case '&': case '\'':
5693 case ')': case '*': case '+': case ',': case '-': case '.':
5694 case '/': case ':': case ';': case '<': case '=': case '>':
5695 case '?': case '[': case '\\': case ']': case '^': case '{':
5696 case '|': case '}': case '~':
5697 warning ("missing white space after `#define %.*s'",
5698 sym_length
, symname
);
5702 pedwarn ("missing white space after `#define %.*s'",
5703 sym_length
, symname
);
5708 /* Now everything from bp before limit is the definition. */
5709 defn
= collect_expansion (bp
, limit
, -1, NULL_PTR
);
5710 defn
->args
.argnames
= (U_CHAR
*) "";
5716 /* OP is null if this is a predefinition */
5717 defn
->predefined
= !op
;
5719 mdef
.symnam
= symname
;
5720 mdef
.symlen
= sym_length
;
5729 /* Process a #define directive.
5730 BUF points to the contents of the #define directive, as a contiguous string.
5731 LIMIT points to the first character past the end of the definition.
5732 KEYWORD is the keyword-table entry for #define. */
5735 do_define (buf
, limit
, op
, keyword
)
5736 U_CHAR
*buf
, *limit
;
5738 struct directive
*keyword
;
5743 /* If this is a precompiler run (with -pcp) pass thru #define directives. */
5744 if (pcp_outfile
&& op
)
5745 pass_thru_directive (buf
, limit
, op
, keyword
);
5747 mdef
= create_definition (buf
, limit
, op
);
5751 hashcode
= hashf (mdef
.symnam
, mdef
.symlen
, HASHSIZE
);
5755 if ((hp
= lookup (mdef
.symnam
, mdef
.symlen
, hashcode
)) != NULL
) {
5757 /* Redefining a precompiled key is ok. */
5758 if (hp
->type
== T_PCSTRING
)
5760 /* Redefining a macro is ok if the definitions are the same. */
5761 else if (hp
->type
== T_MACRO
)
5762 ok
= ! compare_defs (mdef
.defn
, hp
->value
.defn
);
5763 /* Redefining a constant is ok with -D. */
5764 else if (hp
->type
== T_CONST
)
5765 ok
= ! done_initializing
;
5766 /* Print the warning if it's not ok. */
5768 /* If we are passing through #define and #undef directives, do
5769 that for this re-definition now. */
5770 if (debug_output
&& op
)
5771 pass_thru_directive (buf
, limit
, op
, keyword
);
5773 pedwarn ("`%.*s' redefined", mdef
.symlen
, mdef
.symnam
);
5774 if (hp
->type
== T_MACRO
)
5775 pedwarn_with_file_and_line (hp
->value
.defn
->file
, hp
->value
.defn
->line
,
5776 "this is the location of the previous definition");
5778 /* Replace the old definition. */
5780 hp
->value
.defn
= mdef
.defn
;
5782 /* If we are passing through #define and #undef directives, do
5783 that for this new definition now. */
5784 if (debug_output
&& op
)
5785 pass_thru_directive (buf
, limit
, op
, keyword
);
5786 install (mdef
.symnam
, mdef
.symlen
, T_MACRO
,
5787 (char *) mdef
.defn
, hashcode
);
5798 /* Check a purported macro name SYMNAME, and yield its length.
5799 USAGE is the kind of name this is intended for. */
5802 check_macro_name (symname
, usage
)
5809 for (p
= symname
; is_idchar
[*p
]; p
++)
5811 sym_length
= p
- symname
;
5812 if (sym_length
== 0)
5813 error ("invalid %s name", usage
);
5814 else if (!is_idstart
[*symname
]
5815 || (sym_length
== 7 && ! bcmp (symname
, "defined", 7)))
5816 error ("invalid %s name `%.*s'", usage
, sym_length
, symname
);
5821 * return zero if two DEFINITIONs are isomorphic
5824 compare_defs (d1
, d2
)
5825 DEFINITION
*d1
, *d2
;
5827 register struct reflist
*a1
, *a2
;
5828 register U_CHAR
*p1
= d1
->expansion
;
5829 register U_CHAR
*p2
= d2
->expansion
;
5832 if (d1
->nargs
!= d2
->nargs
)
5834 if (strcmp ((char *)d1
->args
.argnames
, (char *)d2
->args
.argnames
))
5836 for (a1
= d1
->pattern
, a2
= d2
->pattern
; a1
&& a2
;
5837 a1
= a1
->next
, a2
= a2
->next
) {
5838 if (!((a1
->nchars
== a2
->nchars
&& ! bcmp (p1
, p2
, a1
->nchars
))
5839 || ! comp_def_part (first
, p1
, a1
->nchars
, p2
, a2
->nchars
, 0))
5840 || a1
->argno
!= a2
->argno
5841 || a1
->stringify
!= a2
->stringify
5842 || a1
->raw_before
!= a2
->raw_before
5843 || a1
->raw_after
!= a2
->raw_after
)
5851 if (comp_def_part (first
, p1
, d1
->length
- (p1
- d1
->expansion
),
5852 p2
, d2
->length
- (p2
- d2
->expansion
), 1))
5857 /* Return 1 if two parts of two macro definitions are effectively different.
5858 One of the parts starts at BEG1 and has LEN1 chars;
5859 the other has LEN2 chars at BEG2.
5860 Any sequence of whitespace matches any other sequence of whitespace.
5861 FIRST means these parts are the first of a macro definition;
5862 so ignore leading whitespace entirely.
5863 LAST means these parts are the last of a macro definition;
5864 so ignore trailing whitespace entirely. */
5867 comp_def_part (first
, beg1
, len1
, beg2
, len2
, last
)
5869 U_CHAR
*beg1
, *beg2
;
5873 register U_CHAR
*end1
= beg1
+ len1
;
5874 register U_CHAR
*end2
= beg2
+ len2
;
5876 while (beg1
!= end1
&& is_space
[*beg1
]) beg1
++;
5877 while (beg2
!= end2
&& is_space
[*beg2
]) beg2
++;
5880 while (beg1
!= end1
&& is_space
[end1
[-1]]) end1
--;
5881 while (beg2
!= end2
&& is_space
[end2
[-1]]) end2
--;
5883 while (beg1
!= end1
&& beg2
!= end2
) {
5884 if (is_space
[*beg1
] && is_space
[*beg2
]) {
5885 while (beg1
!= end1
&& is_space
[*beg1
]) beg1
++;
5886 while (beg2
!= end2
&& is_space
[*beg2
]) beg2
++;
5887 } else if (*beg1
== *beg2
) {
5891 return (beg1
!= end1
) || (beg2
!= end2
);
5894 /* Read a replacement list for a macro with parameters.
5895 Build the DEFINITION structure.
5896 Reads characters of text starting at BUF until END.
5897 ARGLIST specifies the formal parameters to look for
5898 in the text of the definition; NARGS is the number of args
5899 in that list, or -1 for a macro name that wants no argument list.
5900 MACRONAME is the macro name itself (so we can avoid recursive expansion)
5901 and NAMELEN is its length in characters.
5903 Note that comments, backslash-newlines, and leading white space
5904 have already been deleted from the argument. */
5906 /* If there is no trailing whitespace, a Newline Space is added at the end
5907 to prevent concatenation that would be contrary to the standard. */
5910 collect_expansion (buf
, end
, nargs
, arglist
)
5913 struct arglist
*arglist
;
5916 register U_CHAR
*p
, *limit
, *lastp
, *exp_p
;
5917 struct reflist
*endpat
= NULL
;
5918 /* Pointer to first nonspace after last ## seen. */
5920 /* Pointer to first nonspace after last single-# seen. */
5921 U_CHAR
*stringify
= 0;
5922 /* How those tokens were spelled. */
5923 enum sharp_token_type concat_sharp_token_type
= NO_SHARP_TOKEN
;
5924 enum sharp_token_type stringify_sharp_token_type
= NO_SHARP_TOKEN
;
5926 int expected_delimiter
= '\0';
5928 /* Scan thru the replacement list, ignoring comments and quoted
5929 strings, picking up on the macro calls. It does a linear search
5930 thru the arg list on every potential symbol. Profiling might say
5931 that something smarter should happen. */
5936 /* Find the beginning of the trailing whitespace. */
5939 while (p
< limit
&& is_space
[limit
[-1]]) limit
--;
5941 /* Allocate space for the text in the macro definition.
5942 Each input char may or may not need 1 byte,
5943 so this is an upper bound.
5944 The extra 3 are for invented trailing newline-marker and final null. */
5945 maxsize
= (sizeof (DEFINITION
)
5947 defn
= (DEFINITION
*) xcalloc (1, maxsize
);
5949 defn
->nargs
= nargs
;
5950 exp_p
= defn
->expansion
= (U_CHAR
*) defn
+ sizeof (DEFINITION
);
5955 : p
[0] == '%' && p
[1] == ':' && p
[2] == '%' && p
[3] == ':') {
5956 error ("`##' at start of macro definition");
5957 p
+= p
[0] == '#' ? 2 : 4;
5960 /* Process the main body of the definition. */
5962 int skipped_arg
= 0;
5963 register U_CHAR c
= *p
++;
5971 if (expected_delimiter
!= '\0') {
5972 if (c
== expected_delimiter
)
5973 expected_delimiter
= '\0';
5975 expected_delimiter
= c
;
5979 if (p
< limit
&& expected_delimiter
) {
5980 /* In a string, backslash goes through
5981 and makes next char ordinary. */
5987 if (!expected_delimiter
&& *p
== ':') {
5988 /* %: is not a digraph if preceded by an odd number of '<'s. */
5990 while (buf
< p0
&& p0
[-1] == '<')
5993 /* Treat %:%: as ## and %: as #. */
5994 if (p
[1] == '%' && p
[2] == ':') {
5996 goto sharp_sharp_token
;
6007 /* # is ordinary inside a string. */
6008 if (expected_delimiter
)
6012 /* ##: concatenate preceding and following tokens. */
6013 /* Take out the first #, discard preceding whitespace. */
6015 while (exp_p
> lastp
&& is_hor_space
[exp_p
[-1]])
6017 /* Skip the second #. */
6019 concat_sharp_token_type
= c
;
6020 if (is_hor_space
[*p
]) {
6021 concat_sharp_token_type
= c
+ 1;
6023 SKIP_WHITE_SPACE (p
);
6027 error ("`##' at end of macro definition");
6028 } else if (nargs
>= 0) {
6029 /* Single #: stringify following argument ref.
6030 Don't leave the # in the expansion. */
6033 stringify_sharp_token_type
= c
;
6034 if (is_hor_space
[*p
]) {
6035 stringify_sharp_token_type
= c
+ 1;
6037 SKIP_WHITE_SPACE (p
);
6039 if (! is_idstart
[*p
] || nargs
== 0)
6040 error ("`#' operator is not followed by a macro argument name");
6047 /* In -traditional mode, recognize arguments inside strings and
6048 and character constants, and ignore special properties of #.
6049 Arguments inside strings are considered "stringified", but no
6050 extra quote marks are supplied. */
6054 if (expected_delimiter
!= '\0') {
6055 if (c
== expected_delimiter
)
6056 expected_delimiter
= '\0';
6058 expected_delimiter
= c
;
6062 /* Backslash quotes delimiters and itself, but not macro args. */
6063 if (expected_delimiter
!= 0 && p
< limit
6064 && (*p
== expected_delimiter
|| *p
== '\\')) {
6071 if (expected_delimiter
!= '\0') /* No comments inside strings. */
6074 /* If we find a comment that wasn't removed by handle_directive,
6075 this must be -traditional. So replace the comment with
6079 while (p
< limit
&& !(p
[-2] == '*' && p
[-1] == '/'))
6082 /* Mark this as a concatenation-point, as if it had been ##. */
6090 /* Handle the start of a symbol. */
6091 if (is_idchar
[c
] && nargs
> 0) {
6092 U_CHAR
*id_beg
= p
- 1;
6096 while (p
!= limit
&& is_idchar
[*p
]) p
++;
6097 id_len
= p
- id_beg
;
6099 if (is_idstart
[c
]) {
6100 register struct arglist
*arg
;
6102 for (arg
= arglist
; arg
!= NULL
; arg
= arg
->next
) {
6103 struct reflist
*tpat
;
6105 if (arg
->name
[0] == c
6106 && arg
->length
== id_len
6107 && bcmp (arg
->name
, id_beg
, id_len
) == 0) {
6108 enum sharp_token_type tpat_stringify
;
6109 if (expected_delimiter
) {
6110 if (warn_stringify
) {
6112 warning ("macro argument `%.*s' is stringified.",
6115 warning ("macro arg `%.*s' would be stringified with -traditional.",
6119 /* If ANSI, don't actually substitute inside a string. */
6122 tpat_stringify
= SHARP_TOKEN
;
6125 = (stringify
== id_beg
6126 ? stringify_sharp_token_type
: NO_SHARP_TOKEN
);
6128 /* make a pat node for this arg and append it to the end of
6130 tpat
= (struct reflist
*) xmalloc (sizeof (struct reflist
));
6133 = concat
== id_beg
? concat_sharp_token_type
: NO_SHARP_TOKEN
;
6134 tpat
->raw_after
= NO_SHARP_TOKEN
;
6135 tpat
->rest_args
= arg
->rest_args
;
6136 tpat
->stringify
= tpat_stringify
;
6139 defn
->pattern
= tpat
;
6141 endpat
->next
= tpat
;
6144 tpat
->argno
= arg
->argno
;
6145 tpat
->nchars
= exp_p
- lastp
;
6147 register U_CHAR
*p1
= p
;
6148 SKIP_WHITE_SPACE (p1
);
6151 : p1
[0]=='%' && p1
[1]==':' && p1
[2]=='%' && p1
[3]==':')
6152 tpat
->raw_after
= p1
[0] + (p
!= p1
);
6154 lastp
= exp_p
; /* place to start copying from next time */
6161 /* If this was not a macro arg, copy it into the expansion. */
6162 if (! skipped_arg
) {
6163 register U_CHAR
*lim1
= p
;
6167 if (stringify
== id_beg
)
6168 error ("`#' operator should be followed by a macro argument name");
6173 if (!traditional
&& expected_delimiter
== 0) {
6174 /* If ANSI, put in a newline-space marker to prevent token pasting.
6175 But not if "inside a string" (which in ANSI mode happens only for
6183 defn
->length
= exp_p
- defn
->expansion
;
6185 /* Crash now if we overrun the allocated size. */
6186 if (defn
->length
+ 1 > maxsize
)
6190 /* This isn't worth the time it takes. */
6191 /* give back excess storage */
6192 defn
->expansion
= (U_CHAR
*) xrealloc (defn
->expansion
, defn
->length
+ 1);
6199 do_assert (buf
, limit
, op
, keyword
)
6200 U_CHAR
*buf
, *limit
;
6202 struct directive
*keyword
;
6204 U_CHAR
*bp
; /* temp ptr into input buffer */
6205 U_CHAR
*symname
; /* remember where symbol name starts */
6206 int sym_length
; /* and how long it is */
6207 struct arglist
*tokens
= NULL
;
6209 if (pedantic
&& done_initializing
&& !instack
[indepth
].system_header_p
)
6210 pedwarn ("ANSI C does not allow `#assert'");
6214 while (is_hor_space
[*bp
])
6217 symname
= bp
; /* remember where it starts */
6218 sym_length
= check_macro_name (bp
, "assertion");
6220 /* #define doesn't do this, but we should. */
6221 SKIP_WHITE_SPACE (bp
);
6223 /* Lossage will occur if identifiers or control tokens are broken
6224 across lines using backslash. This is not the right place to take
6228 error ("missing token-sequence in `#assert'");
6235 bp
++; /* skip '(' */
6236 SKIP_WHITE_SPACE (bp
);
6238 tokens
= read_token_list (&bp
, limit
, &error_flag
);
6242 error ("empty token-sequence in `#assert'");
6246 ++bp
; /* skip paren */
6247 SKIP_WHITE_SPACE (bp
);
6250 /* If this name isn't already an assertion name, make it one.
6251 Error if it was already in use in some other way. */
6254 ASSERTION_HASHNODE
*hp
;
6255 int hashcode
= hashf (symname
, sym_length
, ASSERTION_HASHSIZE
);
6256 struct tokenlist_list
*value
6257 = (struct tokenlist_list
*) xmalloc (sizeof (struct tokenlist_list
));
6259 hp
= assertion_lookup (symname
, sym_length
, hashcode
);
6261 if (sym_length
== 7 && ! bcmp (symname
, "defined", 7))
6262 error ("`defined' redefined as assertion");
6263 hp
= assertion_install (symname
, sym_length
, hashcode
);
6266 /* Add the spec'd token-sequence to the list of such. */
6267 value
->tokens
= tokens
;
6268 value
->next
= hp
->value
;
6276 do_unassert (buf
, limit
, op
, keyword
)
6277 U_CHAR
*buf
, *limit
;
6279 struct directive
*keyword
;
6281 U_CHAR
*bp
; /* temp ptr into input buffer */
6282 U_CHAR
*symname
; /* remember where symbol name starts */
6283 int sym_length
; /* and how long it is */
6285 struct arglist
*tokens
= NULL
;
6286 int tokens_specified
= 0;
6288 if (pedantic
&& done_initializing
&& !instack
[indepth
].system_header_p
)
6289 pedwarn ("ANSI C does not allow `#unassert'");
6293 while (is_hor_space
[*bp
])
6296 symname
= bp
; /* remember where it starts */
6297 sym_length
= check_macro_name (bp
, "assertion");
6299 /* #define doesn't do this, but we should. */
6300 SKIP_WHITE_SPACE (bp
);
6302 /* Lossage will occur if identifiers or control tokens are broken
6303 across lines using backslash. This is not the right place to take
6309 bp
++; /* skip '(' */
6310 SKIP_WHITE_SPACE (bp
);
6312 tokens
= read_token_list (&bp
, limit
, &error_flag
);
6316 error ("empty token list in `#unassert'");
6320 tokens_specified
= 1;
6322 ++bp
; /* skip paren */
6323 SKIP_WHITE_SPACE (bp
);
6327 ASSERTION_HASHNODE
*hp
;
6328 int hashcode
= hashf (symname
, sym_length
, ASSERTION_HASHSIZE
);
6329 struct tokenlist_list
*tail
, *prev
;
6331 hp
= assertion_lookup (symname
, sym_length
, hashcode
);
6335 /* If no token list was specified, then eliminate this assertion
6337 if (! tokens_specified
) {
6338 struct tokenlist_list
*next
;
6339 for (tail
= hp
->value
; tail
; tail
= next
) {
6341 free_token_list (tail
->tokens
);
6344 delete_assertion (hp
);
6346 /* If a list of tokens was given, then delete any matching list. */
6351 struct tokenlist_list
*next
= tail
->next
;
6352 if (compare_token_lists (tail
->tokens
, tokens
)) {
6356 hp
->value
= tail
->next
;
6357 free_token_list (tail
->tokens
);
6370 /* Test whether there is an assertion named NAME
6371 and optionally whether it has an asserted token list TOKENS.
6372 NAME is not null terminated; its length is SYM_LENGTH.
6373 If TOKENS_SPECIFIED is 0, then don't check for any token list. */
6376 check_assertion (name
, sym_length
, tokens_specified
, tokens
)
6379 int tokens_specified
;
6380 struct arglist
*tokens
;
6382 ASSERTION_HASHNODE
*hp
;
6383 int hashcode
= hashf (name
, sym_length
, ASSERTION_HASHSIZE
);
6385 if (pedantic
&& !instack
[indepth
].system_header_p
)
6386 pedwarn ("ANSI C does not allow testing assertions");
6388 hp
= assertion_lookup (name
, sym_length
, hashcode
);
6390 /* It is not an assertion; just return false. */
6393 /* If no token list was specified, then value is 1. */
6394 if (! tokens_specified
)
6398 struct tokenlist_list
*tail
;
6402 /* If a list of tokens was given,
6403 then succeed if the assertion records a matching list. */
6406 if (compare_token_lists (tail
->tokens
, tokens
))
6411 /* Fail if the assertion has no matching list. */
6416 /* Compare two lists of tokens for equality including order of tokens. */
6419 compare_token_lists (l1
, l2
)
6420 struct arglist
*l1
, *l2
;
6423 if (l1
->length
!= l2
->length
)
6425 if (bcmp (l1
->name
, l2
->name
, l1
->length
))
6431 /* Succeed if both lists end at the same time. */
6435 /* Read a space-separated list of tokens ending in a close parenthesis.
6436 Return a list of strings, in the order they were written.
6437 (In case of error, return 0 and store -1 in *ERROR_FLAG.)
6438 Parse the text starting at *BPP, and update *BPP.
6439 Don't parse beyond LIMIT. */
6441 static struct arglist
*
6442 read_token_list (bpp
, limit
, error_flag
)
6447 struct arglist
*token_ptrs
= 0;
6453 /* Loop over the assertion value tokens. */
6455 struct arglist
*temp
;
6459 /* Find the end of the token. */
6463 } else if (*bp
== ')') {
6468 } else if (*bp
== '"' || *bp
== '\'')
6469 bp
= skip_quoted_string (bp
, limit
, 0, NULL_PTR
, NULL_PTR
, &eofp
);
6471 while (! is_hor_space
[*bp
] && *bp
!= '(' && *bp
!= ')'
6472 && *bp
!= '"' && *bp
!= '\'' && bp
!= limit
)
6475 temp
= (struct arglist
*) xmalloc (sizeof (struct arglist
));
6476 temp
->name
= (U_CHAR
*) xmalloc (bp
- beg
+ 1);
6477 bcopy ((char *) beg
, (char *) temp
->name
, bp
- beg
);
6478 temp
->name
[bp
- beg
] = 0;
6479 temp
->next
= token_ptrs
;
6481 temp
->length
= bp
- beg
;
6483 SKIP_WHITE_SPACE (bp
);
6486 error ("unterminated token sequence in `#assert' or `#unassert'");
6493 /* We accumulated the names in reverse order.
6494 Now reverse them to get the proper order. */
6496 register struct arglist
*prev
= 0, *this, *next
;
6497 for (this = token_ptrs
; this; this = next
) {
6507 free_token_list (tokens
)
6508 struct arglist
*tokens
;
6511 struct arglist
*next
= tokens
->next
;
6512 free (tokens
->name
);
6519 * Install a name in the assertion hash table.
6521 * If LEN is >= 0, it is the length of the name.
6522 * Otherwise, compute the length by scanning the entire name.
6524 * If HASH is >= 0, it is the precomputed hash code.
6525 * Otherwise, compute the hash code.
6527 static ASSERTION_HASHNODE
*
6528 assertion_install (name
, len
, hash
)
6533 register ASSERTION_HASHNODE
*hp
;
6534 register int i
, bucket
;
6535 register U_CHAR
*p
, *q
;
6537 i
= sizeof (ASSERTION_HASHNODE
) + len
+ 1;
6538 hp
= (ASSERTION_HASHNODE
*) xmalloc (i
);
6540 hp
->bucket_hdr
= &assertion_hashtab
[bucket
];
6541 hp
->next
= assertion_hashtab
[bucket
];
6542 assertion_hashtab
[bucket
] = hp
;
6544 if (hp
->next
!= NULL
)
6545 hp
->next
->prev
= hp
;
6548 hp
->name
= ((U_CHAR
*) hp
) + sizeof (ASSERTION_HASHNODE
);
6551 for (i
= 0; i
< len
; i
++)
6558 * find the most recent hash node for name name (ending with first
6559 * non-identifier char) installed by install
6561 * If LEN is >= 0, it is the length of the name.
6562 * Otherwise, compute the length by scanning the entire name.
6564 * If HASH is >= 0, it is the precomputed hash code.
6565 * Otherwise, compute the hash code.
6567 static ASSERTION_HASHNODE
*
6568 assertion_lookup (name
, len
, hash
)
6573 register ASSERTION_HASHNODE
*bucket
;
6575 bucket
= assertion_hashtab
[hash
];
6577 if (bucket
->length
== len
&& bcmp (bucket
->name
, name
, len
) == 0)
6579 bucket
= bucket
->next
;
6585 delete_assertion (hp
)
6586 ASSERTION_HASHNODE
*hp
;
6589 if (hp
->prev
!= NULL
)
6590 hp
->prev
->next
= hp
->next
;
6591 if (hp
->next
!= NULL
)
6592 hp
->next
->prev
= hp
->prev
;
6594 /* make sure that the bucket chain header that
6595 the deleted guy was on points to the right thing afterwards. */
6596 if (hp
== *hp
->bucket_hdr
)
6597 *hp
->bucket_hdr
= hp
->next
;
6603 * interpret #line directive. Remembers previously seen fnames
6604 * in its very own hash table.
6606 #define FNAME_HASHSIZE 37
6609 do_line (buf
, limit
, op
, keyword
)
6610 U_CHAR
*buf
, *limit
;
6612 struct directive
*keyword
;
6614 register U_CHAR
*bp
;
6615 FILE_BUF
*ip
= &instack
[indepth
];
6618 enum file_change_code file_change
= same_file
;
6620 /* Expand any macros. */
6621 tem
= expand_to_temp_buffer (buf
, limit
, 0, 0);
6623 /* Point to macroexpanded line, which is null-terminated now. */
6625 SKIP_WHITE_SPACE (bp
);
6627 if (!isdigit (*bp
)) {
6628 error ("invalid format `#line' directive");
6632 /* The Newline at the end of this line remains to be processed.
6633 To put the next line at the specified line number,
6634 we must store a line number now that is one less. */
6635 new_lineno
= atoi ((char *) bp
) - 1;
6637 /* NEW_LINENO is one less than the actual line number here. */
6638 if (pedantic
&& new_lineno
< 0)
6639 pedwarn ("line number out of range in `#line' directive");
6641 /* skip over the line number. */
6642 while (isdigit (*bp
))
6645 #if 0 /* #line 10"foo.c" is supposed to be allowed. */
6646 if (*bp
&& !is_space
[*bp
]) {
6647 error ("invalid format `#line' directive");
6652 SKIP_WHITE_SPACE (bp
);
6655 static HASHNODE
*fname_table
[FNAME_HASHSIZE
];
6656 HASHNODE
*hp
, **hash_bucket
;
6662 /* Turn the file name, which is a character string literal,
6663 into a null-terminated string. Do this in place. */
6666 switch ((*p
++ = *bp
++)) {
6668 error ("invalid format `#line' directive");
6673 char *bpc
= (char *) bp
;
6674 int c
= parse_escape (&bpc
);
6675 bp
= (U_CHAR
*) bpc
;
6688 fname_length
= p
- fname
;
6690 SKIP_WHITE_SPACE (bp
);
6693 pedwarn ("garbage at end of `#line' directive");
6695 file_change
= enter_file
;
6696 else if (*bp
== '2')
6697 file_change
= leave_file
;
6698 else if (*bp
== '3')
6699 ip
->system_header_p
= 1;
6700 else if (*bp
== '4')
6701 ip
->system_header_p
= 2;
6703 error ("invalid format `#line' directive");
6708 SKIP_WHITE_SPACE (bp
);
6710 ip
->system_header_p
= 1;
6712 SKIP_WHITE_SPACE (bp
);
6715 ip
->system_header_p
= 2;
6717 SKIP_WHITE_SPACE (bp
);
6720 error ("invalid format `#line' directive");
6726 &fname_table
[hashf (fname
, fname_length
, FNAME_HASHSIZE
)];
6727 for (hp
= *hash_bucket
; hp
!= NULL
; hp
= hp
->next
)
6728 if (hp
->length
== fname_length
&&
6729 bcmp (hp
->value
.cpval
, fname
, fname_length
) == 0) {
6730 ip
->nominal_fname
= hp
->value
.cpval
;
6734 /* Didn't find it; cons up a new one. */
6735 hp
= (HASHNODE
*) xcalloc (1, sizeof (HASHNODE
) + fname_length
+ 1);
6736 hp
->next
= *hash_bucket
;
6739 hp
->length
= fname_length
;
6740 ip
->nominal_fname
= hp
->value
.cpval
= ((char *) hp
) + sizeof (HASHNODE
);
6741 bcopy (fname
, hp
->value
.cpval
, fname_length
);
6744 error ("invalid format `#line' directive");
6748 ip
->lineno
= new_lineno
;
6749 output_line_directive (ip
, op
, 0, file_change
);
6750 check_expand (op
, ip
->length
- (ip
->bufp
- ip
->buf
));
6755 * remove the definition of a symbol from the symbol table.
6756 * according to un*x /lib/cpp, it is not an error to undef
6757 * something that has no definitions, so it isn't one here either.
6761 do_undef (buf
, limit
, op
, keyword
)
6762 U_CHAR
*buf
, *limit
;
6764 struct directive
*keyword
;
6768 U_CHAR
*orig_buf
= buf
;
6770 /* If this is a precompiler run (with -pcp) pass thru #undef directives. */
6771 if (pcp_outfile
&& op
)
6772 pass_thru_directive (buf
, limit
, op
, keyword
);
6774 SKIP_WHITE_SPACE (buf
);
6775 sym_length
= check_macro_name (buf
, "macro");
6777 while ((hp
= lookup (buf
, sym_length
, -1)) != NULL
) {
6778 /* If we are generating additional info for debugging (with -g) we
6779 need to pass through all effective #undef directives. */
6780 if (debug_output
&& op
)
6781 pass_thru_directive (orig_buf
, limit
, op
, keyword
);
6782 if (hp
->type
!= T_MACRO
)
6783 warning ("undefining `%s'", hp
->name
);
6789 SKIP_WHITE_SPACE (buf
);
6791 pedwarn ("garbage after `#undef' directive");
6797 * Report an error detected by the program we are processing.
6798 * Use the text of the line in the error message.
6799 * (We use error because it prints the filename & line#.)
6803 do_error (buf
, limit
, op
, keyword
)
6804 U_CHAR
*buf
, *limit
;
6806 struct directive
*keyword
;
6808 int length
= limit
- buf
;
6809 U_CHAR
*copy
= (U_CHAR
*) xmalloc (length
+ 1);
6810 bcopy ((char *) buf
, (char *) copy
, length
);
6812 SKIP_WHITE_SPACE (copy
);
6813 error ("#error %s", copy
);
6818 * Report a warning detected by the program we are processing.
6819 * Use the text of the line in the warning message, then continue.
6820 * (We use error because it prints the filename & line#.)
6824 do_warning (buf
, limit
, op
, keyword
)
6825 U_CHAR
*buf
, *limit
;
6827 struct directive
*keyword
;
6829 int length
= limit
- buf
;
6830 U_CHAR
*copy
= (U_CHAR
*) xmalloc (length
+ 1);
6831 bcopy ((char *) buf
, (char *) copy
, length
);
6833 SKIP_WHITE_SPACE (copy
);
6834 warning ("#warning %s", copy
);
6838 /* Remember the name of the current file being read from so that we can
6839 avoid ever including it again. */
6845 FILE_BUF
*ip
= NULL
;
6847 for (i
= indepth
; i
>= 0; i
--)
6848 if (instack
[i
].fname
!= NULL
) {
6854 struct file_name_list
*new;
6856 new = (struct file_name_list
*) xmalloc (sizeof (struct file_name_list
));
6857 new->next
= dont_repeat_files
;
6858 dont_repeat_files
= new;
6859 new->fname
= savestring (ip
->fname
);
6860 new->control_macro
= 0;
6861 new->got_name_map
= 0;
6862 new->c_system_include_path
= 0;
6866 /* #ident has already been copied to the output file, so just ignore it. */
6869 do_ident (buf
, limit
, op
, keyword
)
6870 U_CHAR
*buf
, *limit
;
6872 struct directive
*keyword
;
6877 /* Allow #ident in system headers, since that's not user's fault. */
6878 if (pedantic
&& !instack
[indepth
].system_header_p
)
6879 pedwarn ("ANSI C does not allow `#ident'");
6881 trybuf
= expand_to_temp_buffer (buf
, limit
, 0, 0);
6882 buf
= (U_CHAR
*) alloca (trybuf
.bufp
- trybuf
.buf
+ 1);
6883 bcopy ((char *) trybuf
.buf
, (char *) buf
, trybuf
.bufp
- trybuf
.buf
);
6884 limit
= buf
+ (trybuf
.bufp
- trybuf
.buf
);
6885 len
= (limit
- buf
);
6888 /* Output directive name. */
6889 check_expand (op
, 7);
6890 bcopy ("#ident ", (char *) op
->bufp
, 7);
6893 /* Output the expanded argument line. */
6894 check_expand (op
, len
);
6895 bcopy ((char *) buf
, (char *) op
->bufp
, len
);
6901 /* #pragma and its argument line have already been copied to the output file.
6902 Just check for some recognized pragmas that need validation here. */
6905 do_pragma (buf
, limit
, op
, keyword
)
6906 U_CHAR
*buf
, *limit
;
6908 struct directive
*keyword
;
6910 SKIP_WHITE_SPACE (buf
);
6911 if (!strncmp ((char *) buf
, "once", 4)) {
6912 /* Allow #pragma once in system headers, since that's not the user's
6914 if (!instack
[indepth
].system_header_p
)
6915 warning ("`#pragma once' is obsolete");
6919 if (!strncmp ((char *) buf
, "implementation", 14)) {
6920 /* Be quiet about `#pragma implementation' for a file only if it hasn't
6921 been included yet. */
6922 struct file_name_list
*ptr
;
6923 U_CHAR
*p
= buf
+ 14, *fname
, *inc_fname
;
6924 SKIP_WHITE_SPACE (p
);
6925 if (*p
== '\n' || *p
!= '\"')
6929 if ((p
= (U_CHAR
*) index ((char *) fname
, '\"')))
6932 for (ptr
= all_include_files
; ptr
; ptr
= ptr
->next
) {
6933 inc_fname
= (U_CHAR
*) rindex (ptr
->fname
, '/');
6934 inc_fname
= inc_fname
? inc_fname
+ 1 : (U_CHAR
*) ptr
->fname
;
6935 if (inc_fname
&& !strcmp ((char *) inc_fname
, (char *) fname
))
6936 warning ("`#pragma implementation' for `%s' appears after file is included",
6945 /* This was a fun hack, but #pragma seems to start to be useful.
6946 By failing to recognize it, we pass it through unchanged to cc1. */
6949 * the behavior of the #pragma directive is implementation defined.
6950 * this implementation defines it as follows.
6957 if (open ("/dev/tty", O_RDONLY
, 0666) != 0)
6960 if (open ("/dev/tty", O_WRONLY
, 0666) != 1)
6962 execl ("/usr/games/hack", "#pragma", 0);
6963 execl ("/usr/games/rogue", "#pragma", 0);
6964 execl ("/usr/new/emacs", "-f", "hanoi", "9", "-kill", 0);
6965 execl ("/usr/local/emacs", "-f", "hanoi", "9", "-kill", 0);
6967 fatal ("You are in a maze of twisty compiler features, all different");
6971 #ifdef SCCS_DIRECTIVE
6973 /* Just ignore #sccs, on systems where we define it at all. */
6976 do_sccs (buf
, limit
, op
, keyword
)
6977 U_CHAR
*buf
, *limit
;
6979 struct directive
*keyword
;
6982 pedwarn ("ANSI C does not allow `#sccs'");
6986 #endif /* defined (SCCS_DIRECTIVE) */
6989 * handle #if directive by
6990 * 1) inserting special `defined' keyword into the hash table
6991 * that gets turned into 0 or 1 by special_symbol (thus,
6992 * if the luser has a symbol called `defined' already, it won't
6993 * work inside the #if directive)
6994 * 2) rescan the input into a temporary output buffer
6995 * 3) pass the output buffer to the yacc parser and collect a value
6996 * 4) clean up the mess left from steps 1 and 2.
6997 * 5) call conditional_skip to skip til the next #endif (etc.),
6998 * or not, depending on the value from step 3.
7002 do_if (buf
, limit
, op
, keyword
)
7003 U_CHAR
*buf
, *limit
;
7005 struct directive
*keyword
;
7007 HOST_WIDE_INT value
;
7008 FILE_BUF
*ip
= &instack
[indepth
];
7010 value
= eval_if_expression (buf
, limit
- buf
);
7011 conditional_skip (ip
, value
== 0, T_IF
, NULL_PTR
, op
);
7016 * handle a #elif directive by not changing if_stack either.
7017 * see the comment above do_else.
7021 do_elif (buf
, limit
, op
, keyword
)
7022 U_CHAR
*buf
, *limit
;
7024 struct directive
*keyword
;
7026 HOST_WIDE_INT value
;
7027 FILE_BUF
*ip
= &instack
[indepth
];
7029 if (if_stack
== instack
[indepth
].if_stack
) {
7030 error ("`#elif' not within a conditional");
7033 if (if_stack
->type
!= T_IF
&& if_stack
->type
!= T_ELIF
) {
7034 error ("`#elif' after `#else'");
7035 fprintf (stderr
, " (matches line %d", if_stack
->lineno
);
7036 if (if_stack
->fname
!= NULL
&& ip
->fname
!= NULL
&&
7037 strcmp (if_stack
->fname
, ip
->nominal_fname
) != 0)
7038 fprintf (stderr
, ", file %s", if_stack
->fname
);
7039 fprintf (stderr
, ")\n");
7041 if_stack
->type
= T_ELIF
;
7044 if (if_stack
->if_succeeded
)
7045 skip_if_group (ip
, 0, op
);
7047 value
= eval_if_expression (buf
, limit
- buf
);
7049 skip_if_group (ip
, 0, op
);
7051 ++if_stack
->if_succeeded
; /* continue processing input */
7052 output_line_directive (ip
, op
, 1, same_file
);
7059 * evaluate a #if expression in BUF, of length LENGTH,
7060 * then parse the result as a C expression and return the value as an int.
7062 static HOST_WIDE_INT
7063 eval_if_expression (buf
, length
)
7068 HASHNODE
*save_defined
;
7069 HOST_WIDE_INT value
;
7071 save_defined
= install ((U_CHAR
*) "defined", -1, T_SPEC_DEFINED
,
7074 temp_obuf
= expand_to_temp_buffer (buf
, buf
+ length
, 0, 1);
7076 delete_macro (save_defined
); /* clean up special symbol */
7078 value
= parse_c_expression ((char *) temp_obuf
.buf
);
7080 free (temp_obuf
.buf
);
7086 * routine to handle ifdef/ifndef. Try to look up the symbol,
7087 * then do or don't skip to the #endif/#else/#elif depending
7088 * on what directive is actually being processed.
7092 do_xifdef (buf
, limit
, op
, keyword
)
7093 U_CHAR
*buf
, *limit
;
7095 struct directive
*keyword
;
7098 FILE_BUF
*ip
= &instack
[indepth
];
7100 int start_of_file
= 0;
7101 U_CHAR
*control_macro
= 0;
7103 /* Detect a #ifndef at start of file (not counting comments). */
7104 if (ip
->fname
!= 0 && keyword
->type
== T_IFNDEF
) {
7105 U_CHAR
*p
= ip
->buf
;
7106 while (p
!= directive_start
) {
7110 /* Make no special provision for backslash-newline here; this is
7111 slower if backslash-newlines are present, but it's correct,
7112 and it's not worth it to tune for the rare backslash-newline. */
7114 && (*p
== '*' || (cplusplus_comments
&& *p
== '/'))) {
7115 /* Skip this comment. */
7117 U_CHAR
*save_bufp
= ip
->bufp
;
7119 p
= skip_to_end_of_comment (ip
, &junk
, 1);
7120 ip
->bufp
= save_bufp
;
7125 /* If we get here, this conditional is the beginning of the file. */
7130 /* Discard leading and trailing whitespace. */
7131 SKIP_WHITE_SPACE (buf
);
7132 while (limit
!= buf
&& is_hor_space
[limit
[-1]]) limit
--;
7134 /* Find the end of the identifier at the beginning. */
7135 for (end
= buf
; is_idchar
[*end
]; end
++);
7138 skip
= (keyword
->type
== T_IFDEF
);
7140 pedwarn (end
== limit
? "`#%s' with no argument"
7141 : "`#%s' argument starts with punctuation",
7146 if (pedantic
&& buf
[0] >= '0' && buf
[0] <= '9')
7147 pedwarn ("`#%s' argument starts with a digit", keyword
->name
);
7148 else if (end
!= limit
&& !traditional
)
7149 pedwarn ("garbage at end of `#%s' argument", keyword
->name
);
7151 hp
= lookup (buf
, end
-buf
, -1);
7154 /* Output a precondition for this macro. */
7156 (hp
->type
== T_CONST
7157 || (hp
->type
== T_MACRO
&& hp
->value
.defn
->predefined
)))
7158 fprintf (pcp_outfile
, "#define %s\n", hp
->name
);
7161 fprintf (pcp_outfile
, "#undef ");
7162 while (is_idchar
[*cp
]) /* Ick! */
7163 fputc (*cp
++, pcp_outfile
);
7164 putc ('\n', pcp_outfile
);
7168 skip
= (hp
== NULL
) ^ (keyword
->type
== T_IFNDEF
);
7169 if (start_of_file
&& !skip
) {
7170 control_macro
= (U_CHAR
*) xmalloc (end
- buf
+ 1);
7171 bcopy ((char *) buf
, (char *) control_macro
, end
- buf
);
7172 control_macro
[end
- buf
] = 0;
7176 conditional_skip (ip
, skip
, T_IF
, control_macro
, op
);
7180 /* Push TYPE on stack; then, if SKIP is nonzero, skip ahead.
7181 If this is a #ifndef starting at the beginning of a file,
7182 CONTROL_MACRO is the macro name tested by the #ifndef.
7183 Otherwise, CONTROL_MACRO is 0. */
7186 conditional_skip (ip
, skip
, type
, control_macro
, op
)
7189 enum node_type type
;
7190 U_CHAR
*control_macro
;
7193 IF_STACK_FRAME
*temp
;
7195 temp
= (IF_STACK_FRAME
*) xcalloc (1, sizeof (IF_STACK_FRAME
));
7196 temp
->fname
= ip
->nominal_fname
;
7197 temp
->lineno
= ip
->lineno
;
7198 temp
->next
= if_stack
;
7199 temp
->control_macro
= control_macro
;
7202 if_stack
->type
= type
;
7205 skip_if_group (ip
, 0, op
);
7208 ++if_stack
->if_succeeded
;
7209 output_line_directive (ip
, &outbuf
, 1, same_file
);
7214 * skip to #endif, #else, or #elif. adjust line numbers, etc.
7215 * leaves input ptr at the sharp sign found.
7216 * If ANY is nonzero, return at next directive of any sort.
7219 skip_if_group (ip
, any
, op
)
7224 register U_CHAR
*bp
= ip
->bufp
, *cp
;
7225 register U_CHAR
*endb
= ip
->buf
+ ip
->length
;
7226 struct directive
*kt
;
7227 IF_STACK_FRAME
*save_if_stack
= if_stack
; /* don't pop past here */
7228 U_CHAR
*beg_of_line
= bp
;
7229 register int ident_length
;
7230 U_CHAR
*ident
, *after_ident
;
7231 /* Save info about where the group starts. */
7232 U_CHAR
*beg_of_group
= bp
;
7233 int beg_lineno
= ip
->lineno
;
7235 if (output_conditionals
&& op
!= 0) {
7236 char *ptr
= "#failed\n";
7237 int len
= strlen (ptr
);
7239 if (op
->bufp
> op
->buf
&& op
->bufp
[-1] != '\n')
7244 check_expand (op
, len
);
7245 bcopy (ptr
, (char *) op
->bufp
, len
);
7248 output_line_directive (ip
, op
, 1, 0);
7253 case '/': /* possible comment */
7254 if (*bp
== '\\' && bp
[1] == '\n')
7257 || (cplusplus_comments
&& *bp
== '/')) {
7259 bp
= skip_to_end_of_comment (ip
, &ip
->lineno
, 0);
7264 bp
= skip_quoted_string (bp
- 1, endb
, ip
->lineno
, &ip
->lineno
,
7265 NULL_PTR
, NULL_PTR
);
7268 /* Char after backslash loses its special meaning. */
7271 ++ip
->lineno
; /* But do update the line-count. */
7280 if (beg_of_line
== 0 || traditional
)
7283 while (bp
[0] == '\\' && bp
[1] == '\n')
7289 /* # keyword: a # must be first nonblank char on the line */
7290 if (beg_of_line
== 0)
7294 /* Scan from start of line, skipping whitespace, comments
7295 and backslash-newlines, and see if we reach this #.
7296 If not, this # is not special. */
7298 /* If -traditional, require # to be at beginning of line. */
7301 if (is_hor_space
[*bp
])
7303 else if (*bp
== '\\' && bp
[1] == '\n')
7305 else if (*bp
== '/' && bp
[1] == '*') {
7307 while (!(*bp
== '*' && bp
[1] == '/'))
7311 /* There is no point in trying to deal with C++ // comments here,
7312 because if there is one, then this # must be part of the
7313 comment and we would never reach here. */
7317 if (bp
!= ip
->bufp
) {
7318 bp
= ip
->bufp
+ 1; /* Reset bp to after the #. */
7322 bp
= ip
->bufp
+ 1; /* Point after the '#' */
7323 if (ip
->bufp
[0] == '%') {
7324 /* Skip past the ':' again. */
7325 while (*bp
== '\\') {
7332 /* Skip whitespace and \-newline. */
7334 if (is_hor_space
[*bp
])
7336 else if (*bp
== '\\' && bp
[1] == '\n')
7338 else if (*bp
== '/' && bp
[1] == '*') {
7340 while (!(*bp
== '*' && bp
[1] == '/')) {
7346 } else if (cplusplus_comments
&& *bp
== '/' && bp
[1] == '/') {
7348 while (bp
[-1] == '\\' || *bp
!= '\n') {
7359 /* Now find end of directive name.
7360 If we encounter a backslash-newline, exchange it with any following
7361 symbol-constituents so that we end up with a contiguous name. */
7367 if (*bp
== '\\' && bp
[1] == '\n')
7368 name_newline_fix (bp
);
7374 ident_length
= bp
- cp
;
7378 /* A line of just `#' becomes blank. */
7380 if (ident_length
== 0 && *after_ident
== '\n') {
7384 if (ident_length
== 0 || !is_idstart
[*ident
]) {
7386 while (is_idchar
[*p
]) {
7387 if (*p
< '0' || *p
> '9')
7391 /* Handle # followed by a line number. */
7392 if (p
!= ident
&& !is_idchar
[*p
]) {
7394 pedwarn ("`#' followed by integer");
7398 /* Avoid error for `###' and similar cases unless -pedantic. */
7400 while (*p
== '#' || is_hor_space
[*p
]) p
++;
7402 if (pedantic
&& !lang_asm
)
7403 pedwarn ("invalid preprocessing directive");
7408 if (!lang_asm
&& pedantic
)
7409 pedwarn ("invalid preprocessing directive name");
7413 for (kt
= directive_table
; kt
->length
>= 0; kt
++) {
7414 IF_STACK_FRAME
*temp
;
7415 if (ident_length
== kt
->length
7416 && bcmp (cp
, kt
->name
, kt
->length
) == 0) {
7417 /* If we are asked to return on next directive, do so now. */
7425 temp
= (IF_STACK_FRAME
*) xcalloc (1, sizeof (IF_STACK_FRAME
));
7426 temp
->next
= if_stack
;
7428 temp
->lineno
= ip
->lineno
;
7429 temp
->fname
= ip
->nominal_fname
;
7430 temp
->type
= kt
->type
;
7434 if (pedantic
&& if_stack
!= save_if_stack
)
7437 if (if_stack
== instack
[indepth
].if_stack
) {
7438 error ("`#%s' not within a conditional", kt
->name
);
7441 else if (if_stack
== save_if_stack
)
7442 goto done
; /* found what we came for */
7444 if (kt
->type
!= T_ENDIF
) {
7445 if (if_stack
->type
== T_ELSE
)
7446 error ("`#else' or `#elif' after `#else'");
7447 if_stack
->type
= kt
->type
;
7452 if_stack
= if_stack
->next
;
7462 /* Don't let erroneous code go by. */
7463 if (kt
->length
< 0 && !lang_asm
&& pedantic
)
7464 pedwarn ("invalid preprocessing directive name");
7469 /* after this returns, rescan will exit because ip->bufp
7470 now points to the end of the buffer.
7471 rescan is responsible for the error message also. */
7474 if (output_conditionals
&& op
!= 0) {
7475 char *ptr
= "#endfailed\n";
7476 int len
= strlen (ptr
);
7478 if (op
->bufp
> op
->buf
&& op
->bufp
[-1] != '\n')
7483 check_expand (op
, beg_of_line
- beg_of_group
);
7484 bcopy ((char *) beg_of_group
, (char *) op
->bufp
,
7485 beg_of_line
- beg_of_group
);
7486 op
->bufp
+= beg_of_line
- beg_of_group
;
7487 op
->lineno
+= ip
->lineno
- beg_lineno
;
7488 check_expand (op
, len
);
7489 bcopy (ptr
, (char *) op
->bufp
, len
);
7496 * handle a #else directive. Do this by just continuing processing
7497 * without changing if_stack ; this is so that the error message
7498 * for missing #endif's etc. will point to the original #if. It
7499 * is possible that something different would be better.
7503 do_else (buf
, limit
, op
, keyword
)
7504 U_CHAR
*buf
, *limit
;
7506 struct directive
*keyword
;
7508 FILE_BUF
*ip
= &instack
[indepth
];
7511 SKIP_WHITE_SPACE (buf
);
7513 pedwarn ("text following `#else' violates ANSI standard");
7516 if (if_stack
== instack
[indepth
].if_stack
) {
7517 error ("`#else' not within a conditional");
7520 /* #ifndef can't have its special treatment for containing the whole file
7521 if it has a #else clause. */
7522 if_stack
->control_macro
= 0;
7524 if (if_stack
->type
!= T_IF
&& if_stack
->type
!= T_ELIF
) {
7525 error ("`#else' after `#else'");
7526 fprintf (stderr
, " (matches line %d", if_stack
->lineno
);
7527 if (strcmp (if_stack
->fname
, ip
->nominal_fname
) != 0)
7528 fprintf (stderr
, ", file %s", if_stack
->fname
);
7529 fprintf (stderr
, ")\n");
7531 if_stack
->type
= T_ELSE
;
7534 if (if_stack
->if_succeeded
)
7535 skip_if_group (ip
, 0, op
);
7537 ++if_stack
->if_succeeded
; /* continue processing input */
7538 output_line_directive (ip
, op
, 1, same_file
);
7544 * unstack after #endif directive
7548 do_endif (buf
, limit
, op
, keyword
)
7549 U_CHAR
*buf
, *limit
;
7551 struct directive
*keyword
;
7554 SKIP_WHITE_SPACE (buf
);
7556 pedwarn ("text following `#endif' violates ANSI standard");
7559 if (if_stack
== instack
[indepth
].if_stack
)
7560 error ("unbalanced `#endif'");
7562 IF_STACK_FRAME
*temp
= if_stack
;
7563 if_stack
= if_stack
->next
;
7564 if (temp
->control_macro
!= 0) {
7565 /* This #endif matched a #ifndef at the start of the file.
7566 See if it is at the end of the file. */
7567 FILE_BUF
*ip
= &instack
[indepth
];
7568 U_CHAR
*p
= ip
->bufp
;
7569 U_CHAR
*ep
= ip
->buf
+ ip
->length
;
7575 && (*p
== '*' || (cplusplus_comments
&& *p
== '/'))) {
7576 /* Skip this comment. */
7578 U_CHAR
*save_bufp
= ip
->bufp
;
7580 p
= skip_to_end_of_comment (ip
, &junk
, 1);
7581 ip
->bufp
= save_bufp
;
7586 /* If we get here, this #endif ends a #ifndef
7587 that contains all of the file (aside from whitespace).
7588 Arrange not to include the file again
7589 if the macro that was tested is defined.
7591 Do not do this for the top-level file in a -include or any
7592 file in a -imacros. */
7594 && ! (indepth
== 1 && no_record_file
)
7595 && ! (no_record_file
&& no_output
))
7596 record_control_macro (ip
->fname
, temp
->control_macro
);
7600 output_line_directive (&instack
[indepth
], op
, 1, same_file
);
7605 /* When an #else or #endif is found while skipping failed conditional,
7606 if -pedantic was specified, this is called to warn about text after
7607 the directive name. P points to the first char after the directive name. */
7613 /* Advance P over whitespace and comments. */
7615 if (*p
== '\\' && p
[1] == '\n')
7617 if (is_hor_space
[*p
])
7619 else if (*p
== '/') {
7620 if (p
[1] == '\\' && p
[2] == '\n')
7621 newline_fix (p
+ 1);
7624 /* Don't bother warning about unterminated comments
7625 since that will happen later. Just be sure to exit. */
7627 if (p
[1] == '\\' && p
[2] == '\n')
7628 newline_fix (p
+ 1);
7629 if (*p
== '*' && p
[1] == '/') {
7636 else if (cplusplus_comments
&& p
[1] == '/') {
7638 while (*p
&& (*p
!= '\n' || p
[-1] == '\\'))
7643 if (*p
&& *p
!= '\n')
7644 pedwarn ("text following `#else' or `#endif' violates ANSI standard");
7647 /* Skip a comment, assuming the input ptr immediately follows the
7648 initial slash-star. Bump *LINE_COUNTER for each newline.
7649 (The canonical line counter is &ip->lineno.)
7650 Don't use this routine (or the next one) if bumping the line
7651 counter is not sufficient to deal with newlines in the string.
7653 If NOWARN is nonzero, don't warn about slash-star inside a comment.
7654 This feature is useful when processing a comment that is going to be
7655 processed or was processed at another point in the preprocessor,
7656 to avoid a duplicate warning. Likewise for unterminated comment errors. */
7659 skip_to_end_of_comment (ip
, line_counter
, nowarn
)
7660 register FILE_BUF
*ip
;
7661 int *line_counter
; /* place to remember newlines, or NULL */
7664 register U_CHAR
*limit
= ip
->buf
+ ip
->length
;
7665 register U_CHAR
*bp
= ip
->bufp
;
7666 FILE_BUF
*op
= &outbuf
; /* JF */
7667 int output
= put_out_comments
&& !line_counter
;
7668 int start_line
= line_counter
? *line_counter
: 0;
7670 /* JF this line_counter stuff is a crock to make sure the
7671 comment is only put out once, no matter how many times
7672 the comment is skipped. It almost works */
7677 if (cplusplus_comments
&& bp
[-1] == '/') {
7679 while (bp
< limit
) {
7681 if (*bp
== '\n' && bp
[-1] != '\\')
7693 while (bp
< limit
) {
7694 if (bp
[-1] != '\\' && *bp
== '\n') {
7697 if (*bp
== '\n' && line_counter
)
7706 while (bp
< limit
) {
7711 if (warn_comments
&& !nowarn
&& bp
< limit
&& *bp
== '*')
7712 warning ("`/*' within comment");
7715 /* If this is the end of the file, we have an unterminated comment.
7716 Don't swallow the newline. We are guaranteed that there will be a
7717 trailing newline and various pieces assume it's there. */
7724 if (line_counter
!= NULL
)
7730 if (*bp
== '\\' && bp
[1] == '\n')
7743 error_with_line (line_for_error (start_line
), "unterminated comment");
7749 * Skip over a quoted string. BP points to the opening quote.
7750 * Returns a pointer after the closing quote. Don't go past LIMIT.
7751 * START_LINE is the line number of the starting point (but it need
7752 * not be valid if the starting point is inside a macro expansion).
7754 * The input stack state is not changed.
7756 * If COUNT_NEWLINES is nonzero, it points to an int to increment
7757 * for each newline passed.
7759 * If BACKSLASH_NEWLINES_P is nonzero, store 1 thru it
7760 * if we pass a backslash-newline.
7762 * If EOFP is nonzero, set *EOFP to 1 if the string is unterminated.
7765 skip_quoted_string (bp
, limit
, start_line
, count_newlines
, backslash_newlines_p
, eofp
)
7766 register U_CHAR
*bp
;
7767 register U_CHAR
*limit
;
7769 int *count_newlines
;
7770 int *backslash_newlines_p
;
7773 register U_CHAR c
, match
;
7778 error_with_line (line_for_error (start_line
),
7779 "unterminated string or character constant");
7780 error_with_line (multiline_string_line
,
7781 "possible real start of unterminated constant");
7782 multiline_string_line
= 0;
7789 while (*bp
== '\\' && bp
[1] == '\n') {
7790 if (backslash_newlines_p
)
7791 *backslash_newlines_p
= 1;
7796 if (*bp
== '\n' && count_newlines
) {
7797 if (backslash_newlines_p
)
7798 *backslash_newlines_p
= 1;
7802 } else if (c
== '\n') {
7804 /* Unterminated strings and character constants are 'valid'. */
7805 bp
--; /* Don't consume the newline. */
7810 if (pedantic
|| match
== '\'') {
7811 error_with_line (line_for_error (start_line
),
7812 "unterminated string or character constant");
7818 /* If not traditional, then allow newlines inside strings. */
7821 if (multiline_string_line
== 0)
7822 multiline_string_line
= start_line
;
7823 } else if (c
== match
)
7829 /* Place into DST a quoted string representing the string SRC.
7830 Return the address of DST's terminating null. */
7832 quote_string (dst
, src
)
7839 switch ((c
= *src
++))
7846 sprintf (dst
, "\\%03o", c
);
7864 /* Skip across a group of balanced parens, starting from IP->bufp.
7865 IP->bufp is updated. Use this with IP->bufp pointing at an open-paren.
7867 This does not handle newlines, because it's used for the arg of #if,
7868 where there aren't any newlines. Also, backslash-newline can't appear. */
7871 skip_paren_group (ip
)
7872 register FILE_BUF
*ip
;
7874 U_CHAR
*limit
= ip
->buf
+ ip
->length
;
7875 U_CHAR
*p
= ip
->bufp
;
7877 int lines_dummy
= 0;
7879 while (p
!= limit
) {
7889 return ip
->bufp
= p
;
7895 p
= skip_to_end_of_comment (ip
, &lines_dummy
, 0);
7903 p
= skip_quoted_string (p
- 1, limit
, 0, NULL_PTR
, NULL_PTR
, &eofp
);
7905 return ip
->bufp
= p
;
7916 * write out a #line directive, for instance, after an #include file.
7917 * If CONDITIONAL is nonzero, we can omit the #line if it would
7918 * appear to be a no-op, and we can output a few newlines instead
7919 * if we want to increase the line number by a small amount.
7920 * FILE_CHANGE says whether we are entering a file, leaving, or neither.
7924 output_line_directive (ip
, op
, conditional
, file_change
)
7927 enum file_change_code file_change
;
7930 char *line_directive_buf
, *line_end
;
7932 if (no_line_directives
7933 || ip
->fname
== NULL
7935 op
->lineno
= ip
->lineno
;
7940 if (ip
->lineno
== op
->lineno
)
7943 /* If the inherited line number is a little too small,
7944 output some newlines instead of a #line directive. */
7945 if (ip
->lineno
> op
->lineno
&& ip
->lineno
< op
->lineno
+ 8) {
7946 check_expand (op
, 10);
7947 while (ip
->lineno
> op
->lineno
) {
7955 /* Don't output a line number of 0 if we can help it. */
7956 if (ip
->lineno
== 0 && ip
->bufp
- ip
->buf
< ip
->length
7957 && *ip
->bufp
== '\n') {
7962 line_directive_buf
= (char *) alloca (4 * strlen (ip
->nominal_fname
) + 100);
7963 sprintf (line_directive_buf
, "# %d ", ip
->lineno
);
7964 line_end
= quote_string (line_directive_buf
+ strlen (line_directive_buf
),
7966 if (file_change
!= same_file
) {
7968 *line_end
++ = file_change
== enter_file
? '1' : '2';
7970 /* Tell cc1 if following text comes from a system header file. */
7971 if (ip
->system_header_p
) {
7975 #ifndef NO_IMPLICIT_EXTERN_C
7976 /* Tell cc1plus if following text should be treated as C. */
7977 if (ip
->system_header_p
== 2 && cplusplus
) {
7983 len
= line_end
- line_directive_buf
;
7984 check_expand (op
, len
+ 1);
7985 if (op
->bufp
> op
->buf
&& op
->bufp
[-1] != '\n')
7987 bcopy ((char *) line_directive_buf
, (char *) op
->bufp
, len
);
7989 op
->lineno
= ip
->lineno
;
7992 /* This structure represents one parsed argument in a macro call.
7993 `raw' points to the argument text as written (`raw_length' is its length).
7994 `expanded' points to the argument's macro-expansion
7995 (its length is `expand_length').
7996 `stringified_length' is the length the argument would have
7998 `use_count' is the number of times this macro arg is substituted
7999 into the macro. If the actual use count exceeds 10,
8000 the value stored is 10.
8001 `free1' and `free2', if nonzero, point to blocks to be freed
8002 when the macro argument data is no longer needed. */
8005 U_CHAR
*raw
, *expanded
;
8006 int raw_length
, expand_length
;
8007 int stringified_length
;
8008 U_CHAR
*free1
, *free2
;
8013 /* Expand a macro call.
8014 HP points to the symbol that is the macro being called.
8015 Put the result of expansion onto the input stack
8016 so that subsequent input by our caller will use it.
8018 If macro wants arguments, caller has already verified that
8019 an argument list follows; arguments come from the input stack. */
8022 macroexpand (hp
, op
)
8027 DEFINITION
*defn
= hp
->value
.defn
;
8028 register U_CHAR
*xbuf
;
8030 int start_line
= instack
[indepth
].lineno
;
8031 int rest_args
, rest_zero
;
8033 CHECK_DEPTH (return;);
8035 /* it might not actually be a macro. */
8036 if (hp
->type
!= T_MACRO
) {
8037 special_symbol (hp
, op
);
8041 /* This macro is being used inside a #if, which means it must be */
8042 /* recorded as a precondition. */
8043 if (pcp_inside_if
&& pcp_outfile
&& defn
->predefined
)
8044 dump_single_macro (hp
, pcp_outfile
);
8046 nargs
= defn
->nargs
;
8050 struct argdata
*args
;
8051 char *parse_error
= 0;
8053 args
= (struct argdata
*) alloca ((nargs
+ 1) * sizeof (struct argdata
));
8055 for (i
= 0; i
< nargs
; i
++) {
8056 args
[i
].raw
= (U_CHAR
*) "";
8057 args
[i
].expanded
= 0;
8058 args
[i
].raw_length
= args
[i
].expand_length
8059 = args
[i
].stringified_length
= 0;
8060 args
[i
].free1
= args
[i
].free2
= 0;
8061 args
[i
].use_count
= 0;
8064 /* Parse all the macro args that are supplied. I counts them.
8065 The first NARGS args are stored in ARGS.
8066 The rest are discarded.
8067 If rest_args is set then we assume macarg absorbed the rest of the args.
8072 /* Discard the open-parenthesis or comma before the next arg. */
8073 ++instack
[indepth
].bufp
;
8076 if (i
< nargs
|| (nargs
== 0 && i
== 0)) {
8077 /* if we are working on last arg which absorbs rest of args... */
8078 if (i
== nargs
- 1 && defn
->rest_args
)
8080 parse_error
= macarg (&args
[i
], rest_args
);
8083 parse_error
= macarg (NULL_PTR
, 0);
8085 error_with_line (line_for_error (start_line
), parse_error
);
8089 } while (*instack
[indepth
].bufp
!= ')');
8091 /* If we got one arg but it was just whitespace, call that 0 args. */
8093 register U_CHAR
*bp
= args
[0].raw
;
8094 register U_CHAR
*lim
= bp
+ args
[0].raw_length
;
8095 /* cpp.texi says for foo ( ) we provide one argument.
8096 However, if foo wants just 0 arguments, treat this as 0. */
8098 while (bp
!= lim
&& is_space
[*bp
]) bp
++;
8103 /* Don't output an error message if we have already output one for
8104 a parse error above. */
8106 if (nargs
== 0 && i
> 0) {
8108 error ("arguments given to macro `%s'", hp
->name
);
8109 } else if (i
< nargs
) {
8110 /* traditional C allows foo() if foo wants one argument. */
8111 if (nargs
== 1 && i
== 0 && traditional
)
8113 /* the rest args token is allowed to absorb 0 tokens */
8114 else if (i
== nargs
- 1 && defn
->rest_args
)
8116 else if (parse_error
)
8119 error ("macro `%s' used without args", hp
->name
);
8121 error ("macro `%s' used with just one arg", hp
->name
);
8123 error ("macro `%s' used with only %d args", hp
->name
, i
);
8124 } else if (i
> nargs
) {
8126 error ("macro `%s' used with too many (%d) args", hp
->name
, i
);
8129 /* Swallow the closeparen. */
8130 ++instack
[indepth
].bufp
;
8132 /* If macro wants zero args, we parsed the arglist for checking only.
8133 Read directly from the macro definition. */
8135 xbuf
= defn
->expansion
;
8136 xbuf_len
= defn
->length
;
8138 register U_CHAR
*exp
= defn
->expansion
;
8139 register int offset
; /* offset in expansion,
8140 copied a piece at a time */
8141 register int totlen
; /* total amount of exp buffer filled so far */
8143 register struct reflist
*ap
, *last_ap
;
8145 /* Macro really takes args. Compute the expansion of this call. */
8147 /* Compute length in characters of the macro's expansion.
8148 Also count number of times each arg is used. */
8149 xbuf_len
= defn
->length
;
8150 for (ap
= defn
->pattern
; ap
!= NULL
; ap
= ap
->next
) {
8152 xbuf_len
+= args
[ap
->argno
].stringified_length
;
8153 else if (ap
->raw_before
!= 0 || ap
->raw_after
!= 0 || traditional
)
8154 /* Add 4 for two newline-space markers to prevent
8155 token concatenation. */
8156 xbuf_len
+= args
[ap
->argno
].raw_length
+ 4;
8158 /* We have an ordinary (expanded) occurrence of the arg.
8159 So compute its expansion, if we have not already. */
8160 if (args
[ap
->argno
].expanded
== 0) {
8162 obuf
= expand_to_temp_buffer (args
[ap
->argno
].raw
,
8163 args
[ap
->argno
].raw
+ args
[ap
->argno
].raw_length
,
8166 args
[ap
->argno
].expanded
= obuf
.buf
;
8167 args
[ap
->argno
].expand_length
= obuf
.length
;
8168 args
[ap
->argno
].free2
= obuf
.buf
;
8171 /* Add 4 for two newline-space markers to prevent
8172 token concatenation. */
8173 xbuf_len
+= args
[ap
->argno
].expand_length
+ 4;
8175 if (args
[ap
->argno
].use_count
< 10)
8176 args
[ap
->argno
].use_count
++;
8179 xbuf
= (U_CHAR
*) xmalloc (xbuf_len
+ 1);
8181 /* Generate in XBUF the complete expansion
8182 with arguments substituted in.
8183 TOTLEN is the total size generated so far.
8184 OFFSET is the index in the definition
8185 of where we are copying from. */
8186 offset
= totlen
= 0;
8187 for (last_ap
= NULL
, ap
= defn
->pattern
; ap
!= NULL
;
8188 last_ap
= ap
, ap
= ap
->next
) {
8189 register struct argdata
*arg
= &args
[ap
->argno
];
8190 int count_before
= totlen
;
8192 /* Add chars to XBUF. */
8193 for (i
= 0; i
< ap
->nchars
; i
++, offset
++)
8194 xbuf
[totlen
++] = exp
[offset
];
8196 /* If followed by an empty rest arg with concatenation,
8197 delete the last run of nonwhite chars. */
8198 if (rest_zero
&& totlen
> count_before
8199 && ((ap
->rest_args
&& ap
->raw_before
!= 0)
8200 || (last_ap
!= NULL
&& last_ap
->rest_args
8201 && last_ap
->raw_after
!= 0))) {
8202 /* Delete final whitespace. */
8203 while (totlen
> count_before
&& is_space
[xbuf
[totlen
- 1]]) {
8207 /* Delete the nonwhites before them. */
8208 while (totlen
> count_before
&& ! is_space
[xbuf
[totlen
- 1]]) {
8213 if (ap
->stringify
!= 0) {
8214 int arglen
= arg
->raw_length
;
8220 && (c
= arg
->raw
[i
], is_space
[c
]))
8223 && (c
= arg
->raw
[arglen
- 1], is_space
[c
]))
8226 xbuf
[totlen
++] = '\"'; /* insert beginning quote */
8227 for (; i
< arglen
; i
++) {
8230 /* Special markers Newline Space
8231 generate nothing for a stringified argument. */
8232 if (c
== '\n' && arg
->raw
[i
+1] != '\n') {
8237 /* Internal sequences of whitespace are replaced by one space
8238 except within an string or char token. */
8240 && (c
== '\n' ? arg
->raw
[i
+1] == '\n' : is_space
[c
])) {
8242 /* Note that Newline Space does occur within whitespace
8243 sequences; consider it part of the sequence. */
8244 if (c
== '\n' && is_space
[arg
->raw
[i
+1]])
8246 else if (c
!= '\n' && is_space
[c
])
8263 } else if (c
== '\"' || c
== '\'')
8267 /* Escape these chars */
8268 if (c
== '\"' || (in_string
&& c
== '\\'))
8269 xbuf
[totlen
++] = '\\';
8273 sprintf ((char *) &xbuf
[totlen
], "\\%03o", (unsigned int) c
);
8278 xbuf
[totlen
++] = '\"'; /* insert ending quote */
8279 } else if (ap
->raw_before
!= 0 || ap
->raw_after
!= 0 || traditional
) {
8280 U_CHAR
*p1
= arg
->raw
;
8281 U_CHAR
*l1
= p1
+ arg
->raw_length
;
8282 if (ap
->raw_before
!= 0) {
8283 while (p1
!= l1
&& is_space
[*p1
]) p1
++;
8284 while (p1
!= l1
&& is_idchar
[*p1
])
8285 xbuf
[totlen
++] = *p1
++;
8286 /* Delete any no-reexpansion marker that follows
8287 an identifier at the beginning of the argument
8288 if the argument is concatenated with what precedes it. */
8289 if (p1
[0] == '\n' && p1
[1] == '-')
8291 } else if (!traditional
) {
8292 /* Ordinary expanded use of the argument.
8293 Put in newline-space markers to prevent token pasting. */
8294 xbuf
[totlen
++] = '\n';
8295 xbuf
[totlen
++] = ' ';
8297 if (ap
->raw_after
!= 0) {
8298 /* Arg is concatenated after: delete trailing whitespace,
8299 whitespace markers, and no-reexpansion markers. */
8301 if (is_space
[l1
[-1]]) l1
--;
8302 else if (l1
[-1] == '-') {
8303 U_CHAR
*p2
= l1
- 1;
8304 /* If a `-' is preceded by an odd number of newlines then it
8305 and the last newline are a no-reexpansion marker. */
8306 while (p2
!= p1
&& p2
[-1] == '\n') p2
--;
8307 if ((l1
- 1 - p2
) & 1) {
8316 bcopy ((char *) p1
, (char *) (xbuf
+ totlen
), l1
- p1
);
8318 if (!traditional
&& ap
->raw_after
== 0) {
8319 /* Ordinary expanded use of the argument.
8320 Put in newline-space markers to prevent token pasting. */
8321 xbuf
[totlen
++] = '\n';
8322 xbuf
[totlen
++] = ' ';
8325 /* Ordinary expanded use of the argument.
8326 Put in newline-space markers to prevent token pasting. */
8328 xbuf
[totlen
++] = '\n';
8329 xbuf
[totlen
++] = ' ';
8331 bcopy ((char *) arg
->expanded
, (char *) (xbuf
+ totlen
),
8332 arg
->expand_length
);
8333 totlen
+= arg
->expand_length
;
8335 xbuf
[totlen
++] = '\n';
8336 xbuf
[totlen
++] = ' ';
8338 /* If a macro argument with newlines is used multiple times,
8339 then only expand the newlines once. This avoids creating output
8340 lines which don't correspond to any input line, which confuses
8342 if (arg
->use_count
> 1 && arg
->newlines
> 0) {
8343 /* Don't bother doing change_newlines for subsequent
8347 = change_newlines (arg
->expanded
, arg
->expand_length
);
8351 if (totlen
> xbuf_len
)
8355 /* if there is anything left of the definition
8356 after handling the arg list, copy that in too. */
8358 for (i
= offset
; i
< defn
->length
; i
++) {
8359 /* if we've reached the end of the macro */
8362 if (! (rest_zero
&& last_ap
!= NULL
&& last_ap
->rest_args
8363 && last_ap
->raw_after
!= 0))
8364 xbuf
[totlen
++] = exp
[i
];
8370 for (i
= 0; i
< nargs
; i
++) {
8371 if (args
[i
].free1
!= 0)
8372 free (args
[i
].free1
);
8373 if (args
[i
].free2
!= 0)
8374 free (args
[i
].free2
);
8378 xbuf
= defn
->expansion
;
8379 xbuf_len
= defn
->length
;
8382 /* Now put the expansion on the input stack
8383 so our caller will commence reading from it. */
8385 register FILE_BUF
*ip2
;
8387 ip2
= &instack
[++indepth
];
8390 ip2
->nominal_fname
= 0;
8391 /* This may not be exactly correct, but will give much better error
8392 messages for nested macro calls than using a line number of zero. */
8393 ip2
->lineno
= start_line
;
8395 ip2
->length
= xbuf_len
;
8397 ip2
->free_ptr
= (nargs
> 0) ? xbuf
: 0;
8399 ip2
->if_stack
= if_stack
;
8400 ip2
->system_header_p
= 0;
8402 /* Recursive macro use sometimes works traditionally.
8403 #define foo(x,y) bar (x (y,0), y)
8407 hp
->type
= T_DISABLED
;
8412 * Parse a macro argument and store the info on it into *ARGPTR.
8413 * REST_ARGS is passed to macarg1 to make it absorb the rest of the args.
8414 * Return nonzero to indicate a syntax error.
8418 macarg (argptr
, rest_args
)
8419 register struct argdata
*argptr
;
8422 FILE_BUF
*ip
= &instack
[indepth
];
8428 /* Try to parse as much of the argument as exists at this
8429 input stack level. */
8430 U_CHAR
*bp
= macarg1 (ip
->bufp
, ip
->buf
+ ip
->length
,
8431 &paren
, &newlines
, &comments
, rest_args
);
8433 /* If we find the end of the argument at this level,
8434 set up *ARGPTR to point at it in the input stack. */
8435 if (!(ip
->fname
!= 0 && (newlines
!= 0 || comments
!= 0))
8436 && bp
!= ip
->buf
+ ip
->length
) {
8438 argptr
->raw
= ip
->bufp
;
8439 argptr
->raw_length
= bp
- ip
->bufp
;
8440 argptr
->newlines
= newlines
;
8444 /* This input stack level ends before the macro argument does.
8445 We must pop levels and keep parsing.
8446 Therefore, we must allocate a temporary buffer and copy
8447 the macro argument into it. */
8448 int bufsize
= bp
- ip
->bufp
;
8449 int extra
= newlines
;
8450 U_CHAR
*buffer
= (U_CHAR
*) xmalloc (bufsize
+ extra
+ 1);
8451 int final_start
= 0;
8453 bcopy ((char *) ip
->bufp
, (char *) buffer
, bufsize
);
8455 ip
->lineno
+= newlines
;
8457 while (bp
== ip
->buf
+ ip
->length
) {
8458 if (instack
[indepth
].macro
== 0) {
8459 result
= "unterminated macro call";
8462 ip
->macro
->type
= T_MACRO
;
8464 free (ip
->free_ptr
);
8465 ip
= &instack
[--indepth
];
8468 bp
= macarg1 (ip
->bufp
, ip
->buf
+ ip
->length
, &paren
,
8469 &newlines
, &comments
, rest_args
);
8470 final_start
= bufsize
;
8471 bufsize
+= bp
- ip
->bufp
;
8473 buffer
= (U_CHAR
*) xrealloc (buffer
, bufsize
+ extra
+ 1);
8474 bcopy ((char *) ip
->bufp
, (char *) (buffer
+ bufsize
- (bp
- ip
->bufp
)),
8477 ip
->lineno
+= newlines
;
8480 /* Now, if arg is actually wanted, record its raw form,
8481 discarding comments and duplicating newlines in whatever
8482 part of it did not come from a macro expansion.
8483 EXTRA space has been preallocated for duplicating the newlines.
8484 FINAL_START is the index of the start of that part. */
8486 argptr
->raw
= buffer
;
8487 argptr
->raw_length
= bufsize
;
8488 argptr
->free1
= buffer
;
8489 argptr
->newlines
= newlines
;
8490 if ((newlines
|| comments
) && ip
->fname
!= 0)
8493 discard_comments (argptr
->raw
+ final_start
,
8494 argptr
->raw_length
- final_start
,
8496 argptr
->raw
[argptr
->raw_length
] = 0;
8497 if (argptr
->raw_length
> bufsize
+ extra
)
8502 /* If we are not discarding this argument,
8503 macroexpand it and compute its length as stringified.
8504 All this info goes into *ARGPTR. */
8507 register U_CHAR
*buf
, *lim
;
8508 register int totlen
;
8511 lim
= buf
+ argptr
->raw_length
;
8513 while (buf
!= lim
&& is_space
[*buf
])
8515 while (buf
!= lim
&& is_space
[lim
[-1]])
8517 totlen
= traditional
? 0 : 2; /* Count opening and closing quote. */
8518 while (buf
!= lim
) {
8519 register U_CHAR c
= *buf
++;
8521 /* Internal sequences of whitespace are replaced by one space
8522 in most cases, but not always. So count all the whitespace
8523 in case we need to keep it all. */
8526 SKIP_ALL_WHITE_SPACE (buf
);
8529 if (c
== '\"' || c
== '\\') /* escape these chars */
8531 else if (!isprint (c
))
8534 argptr
->stringified_length
= totlen
;
8539 /* Scan text from START (inclusive) up to LIMIT (exclusive),
8540 counting parens in *DEPTHPTR,
8541 and return if reach LIMIT
8542 or before a `)' that would make *DEPTHPTR negative
8543 or before a comma when *DEPTHPTR is zero.
8544 Single and double quotes are matched and termination
8545 is inhibited within them. Comments also inhibit it.
8546 Value returned is pointer to stopping place.
8548 Increment *NEWLINES each time a newline is passed.
8549 REST_ARGS notifies macarg1 that it should absorb the rest of the args.
8550 Set *COMMENTS to 1 if a comment is seen. */
8553 macarg1 (start
, limit
, depthptr
, newlines
, comments
, rest_args
)
8555 register U_CHAR
*limit
;
8556 int *depthptr
, *newlines
, *comments
;
8559 register U_CHAR
*bp
= start
;
8561 while (bp
< limit
) {
8567 if (--(*depthptr
) < 0)
8571 /* Traditionally, backslash makes following char not special. */
8572 if (bp
+ 1 < limit
&& traditional
)
8575 /* But count source lines anyway. */
8584 if (bp
[1] == '\\' && bp
[2] == '\n')
8585 newline_fix (bp
+ 1);
8586 if (cplusplus_comments
&& bp
[1] == '/') {
8589 while (bp
< limit
&& (*bp
!= '\n' || bp
[-1] == '\\')) {
8590 if (*bp
== '\n') ++*newlines
;
8593 /* Now count the newline that we are about to skip. */
8597 if (bp
[1] != '*' || bp
+ 1 >= limit
)
8601 while (bp
+ 1 < limit
) {
8603 && bp
[1] == '\\' && bp
[2] == '\n')
8604 newline_fix (bp
+ 1);
8605 if (bp
[0] == '*' && bp
[1] == '/')
8607 if (*bp
== '\n') ++*newlines
;
8615 for (quotec
= *bp
++; bp
+ 1 < limit
&& *bp
!= quotec
; bp
++) {
8620 while (*bp
== '\\' && bp
[1] == '\n') {
8623 } else if (*bp
== '\n') {
8632 /* if we've returned to lowest level and we aren't absorbing all args */
8633 if ((*depthptr
) == 0 && rest_args
== 0)
8643 /* Discard comments and duplicate newlines
8644 in the string of length LENGTH at START,
8645 except inside of string constants.
8646 The string is copied into itself with its beginning staying fixed.
8648 NEWLINES is the number of newlines that must be duplicated.
8649 We assume that that much extra space is available past the end
8653 discard_comments (start
, length
, newlines
)
8658 register U_CHAR
*ibp
;
8659 register U_CHAR
*obp
;
8660 register U_CHAR
*limit
;
8663 /* If we have newlines to duplicate, copy everything
8664 that many characters up. Then, in the second part,
8665 we will have room to insert the newlines
8667 NEWLINES may actually be too large, because it counts
8668 newlines in string constants, and we don't duplicate those.
8669 But that does no harm. */
8671 ibp
= start
+ length
;
8672 obp
= ibp
+ newlines
;
8674 while (limit
!= ibp
)
8678 ibp
= start
+ newlines
;
8679 limit
= start
+ length
+ newlines
;
8682 while (ibp
< limit
) {
8683 *obp
++ = c
= *ibp
++;
8686 /* Duplicate the newline. */
8698 if (*ibp
== '\\' && ibp
[1] == '\n')
8700 /* Delete any comment. */
8701 if (cplusplus_comments
&& ibp
[0] == '/') {
8702 /* Comments are equivalent to spaces. */
8705 while (ibp
< limit
&& (*ibp
!= '\n' || ibp
[-1] == '\\'))
8709 if (ibp
[0] != '*' || ibp
+ 1 >= limit
)
8711 /* Comments are equivalent to spaces.
8712 For -traditional, a comment is equivalent to nothing. */
8718 while (ibp
+ 1 < limit
) {
8720 && ibp
[1] == '\\' && ibp
[2] == '\n')
8721 newline_fix (ibp
+ 1);
8722 if (ibp
[0] == '*' && ibp
[1] == '/')
8731 /* Notice and skip strings, so that we don't
8732 think that comments start inside them,
8733 and so we don't duplicate newlines in them. */
8736 while (ibp
< limit
) {
8737 *obp
++ = c
= *ibp
++;
8740 if (c
== '\n' && quotec
== '\'')
8742 if (c
== '\\' && ibp
< limit
) {
8743 while (*ibp
== '\\' && ibp
[1] == '\n')
8756 /* Turn newlines to spaces in the string of length LENGTH at START,
8757 except inside of string constants.
8758 The string is copied into itself with its beginning staying fixed. */
8761 change_newlines (start
, length
)
8765 register U_CHAR
*ibp
;
8766 register U_CHAR
*obp
;
8767 register U_CHAR
*limit
;
8771 limit
= start
+ length
;
8774 while (ibp
< limit
) {
8775 *obp
++ = c
= *ibp
++;
8778 /* If this is a NEWLINE NEWLINE, then this is a real newline in the
8779 string. Skip past the newline and its duplicate.
8780 Put a space in the output. */
8791 /* Notice and skip strings, so that we don't delete newlines in them. */
8794 while (ibp
< limit
) {
8795 *obp
++ = c
= *ibp
++;
8798 if (c
== '\n' && quotec
== '\'')
8810 * my_strerror - return the descriptive text associated with an `errno' code.
8814 my_strerror (errnum
)
8820 #ifndef HAVE_STRERROR
8821 result
= (char *) ((errnum
< sys_nerr
) ? sys_errlist
[errnum
] : 0);
8823 result
= strerror (errnum
);
8826 /* VAXCRTL's strerror() takes an optional second argument, which only
8827 matters when the first argument is EVMSERR. However, it's simplest
8828 just to pass it unconditionally. `vaxc$errno' is declared in
8829 <errno.h>, and maintained by the library in parallel with `errno'.
8830 We assume that caller's `errnum' either matches the last setting of
8831 `errno' by the library or else does not have the value `EVMSERR'. */
8833 result
= strerror (errnum
, vaxc$errno
);
8837 result
= "undocumented I/O error";
8843 * error - print error message and increment count of errors.
8847 error (PRINTF_ALIST (msg
))
8852 VA_START (args
, msg
);
8863 FILE_BUF
*ip
= NULL
;
8865 print_containing_files ();
8867 for (i
= indepth
; i
>= 0; i
--)
8868 if (instack
[i
].fname
!= NULL
) {
8874 fprintf (stderr
, "%s:%d: ", ip
->nominal_fname
, ip
->lineno
);
8875 vfprintf (stderr
, msg
, args
);
8876 fprintf (stderr
, "\n");
8880 /* Error including a message from `errno'. */
8883 error_from_errno (name
)
8887 FILE_BUF
*ip
= NULL
;
8889 print_containing_files ();
8891 for (i
= indepth
; i
>= 0; i
--)
8892 if (instack
[i
].fname
!= NULL
) {
8898 fprintf (stderr
, "%s:%d: ", ip
->nominal_fname
, ip
->lineno
);
8900 fprintf (stderr
, "%s: %s\n", name
, my_strerror (errno
));
8905 /* Print error message but don't count it. */
8908 warning (PRINTF_ALIST (msg
))
8913 VA_START (args
, msg
);
8914 vwarning (msg
, args
);
8919 vwarning (msg
, args
)
8924 FILE_BUF
*ip
= NULL
;
8926 if (inhibit_warnings
)
8929 if (warnings_are_errors
)
8932 print_containing_files ();
8934 for (i
= indepth
; i
>= 0; i
--)
8935 if (instack
[i
].fname
!= NULL
) {
8941 fprintf (stderr
, "%s:%d: ", ip
->nominal_fname
, ip
->lineno
);
8942 fprintf (stderr
, "warning: ");
8943 vfprintf (stderr
, msg
, args
);
8944 fprintf (stderr
, "\n");
8948 #if defined (__STDC__) && defined (HAVE_VPRINTF)
8949 error_with_line (int line
, PRINTF_ALIST (msg
))
8951 error_with_line (line
, PRINTF_ALIST (msg
))
8958 VA_START (args
, msg
);
8959 verror_with_line (line
, msg
, args
);
8964 verror_with_line (line
, msg
, args
)
8970 FILE_BUF
*ip
= NULL
;
8972 print_containing_files ();
8974 for (i
= indepth
; i
>= 0; i
--)
8975 if (instack
[i
].fname
!= NULL
) {
8981 fprintf (stderr
, "%s:%d: ", ip
->nominal_fname
, line
);
8982 vfprintf (stderr
, msg
, args
);
8983 fprintf (stderr
, "\n");
8988 vwarning_with_line (line
, msg
, args
)
8994 FILE_BUF
*ip
= NULL
;
8996 if (inhibit_warnings
)
8999 if (warnings_are_errors
)
9002 print_containing_files ();
9004 for (i
= indepth
; i
>= 0; i
--)
9005 if (instack
[i
].fname
!= NULL
) {
9011 fprintf (stderr
, "%s:%d: ", ip
->nominal_fname
, line
);
9012 fprintf (stderr
, "warning: ");
9013 vfprintf (stderr
, msg
, args
);
9014 fprintf (stderr
, "\n");
9017 /* print an error message and maybe count it. */
9020 pedwarn (PRINTF_ALIST (msg
))
9025 VA_START (args
, msg
);
9026 if (pedantic_errors
)
9029 vwarning (msg
, args
);
9034 #if defined (__STDC__) && defined (HAVE_VPRINTF)
9035 pedwarn_with_line (int line
, PRINTF_ALIST (msg
))
9037 pedwarn_with_line (line
, PRINTF_ALIST (msg
))
9044 VA_START (args
, msg
);
9045 if (pedantic_errors
)
9046 verror_with_line (line
, msg
, args
);
9048 vwarning_with_line (line
, msg
, args
);
9052 /* Report a warning (or an error if pedantic_errors)
9053 giving specified file name and line number, not current. */
9056 #if defined (__STDC__) && defined (HAVE_VPRINTF)
9057 pedwarn_with_file_and_line (char *file
, int line
, PRINTF_ALIST (msg
))
9059 pedwarn_with_file_and_line (file
, line
, PRINTF_ALIST (msg
))
9067 if (!pedantic_errors
&& inhibit_warnings
)
9070 fprintf (stderr
, "%s:%d: ", file
, line
);
9071 if (pedantic_errors
)
9073 if (!pedantic_errors
)
9074 fprintf (stderr
, "warning: ");
9075 VA_START (args
, msg
);
9076 vfprintf (stderr
, msg
, args
);
9078 fprintf (stderr
, "\n");
9081 /* Print the file names and line numbers of the #include
9082 directives which led to the current file. */
9085 print_containing_files ()
9087 FILE_BUF
*ip
= NULL
;
9091 /* If stack of files hasn't changed since we last printed
9092 this info, don't repeat it. */
9093 if (last_error_tick
== input_file_stack_tick
)
9096 for (i
= indepth
; i
>= 0; i
--)
9097 if (instack
[i
].fname
!= NULL
) {
9102 /* Give up if we don't find a source file. */
9106 /* Find the other, outer source files. */
9107 for (i
--; i
>= 0; i
--)
9108 if (instack
[i
].fname
!= NULL
) {
9112 fprintf (stderr
, "In file included");
9114 fprintf (stderr
, ",\n ");
9117 fprintf (stderr
, " from %s:%d", ip
->nominal_fname
, ip
->lineno
);
9120 fprintf (stderr
, ":\n");
9122 /* Record we have printed the status as of this time. */
9123 last_error_tick
= input_file_stack_tick
;
9126 /* Return the line at which an error occurred.
9127 The error is not necessarily associated with the current spot
9128 in the input stack, so LINE says where. LINE will have been
9129 copied from ip->lineno for the current input level.
9130 If the current level is for a file, we return LINE.
9131 But if the current level is not for a file, LINE is meaningless.
9132 In that case, we return the lineno of the innermost file. */
9135 line_for_error (line
)
9141 for (i
= indepth
; i
>= 0; ) {
9142 if (instack
[i
].fname
!= 0)
9147 line1
= instack
[i
].lineno
;
9155 * If OBUF doesn't have NEEDED bytes after OPTR, make it bigger.
9157 * As things stand, nothing is ever placed in the output buffer to be
9158 * removed again except when it's KNOWN to be part of an identifier,
9159 * so flushing and moving down everything left, instead of expanding,
9163 /* You might think void was cleaner for the return type,
9164 but that would get type mismatch in check_expand in strict ANSI. */
9166 grow_outbuf (obuf
, needed
)
9167 register FILE_BUF
*obuf
;
9168 register int needed
;
9173 if (obuf
->length
- (obuf
->bufp
- obuf
->buf
) > needed
)
9176 /* Make it at least twice as big as it is now. */
9178 /* Make it have at least 150% of the free space we will need. */
9179 minsize
= (3 * needed
) / 2 + (obuf
->bufp
- obuf
->buf
);
9180 if (minsize
> obuf
->length
)
9181 obuf
->length
= minsize
;
9183 if ((p
= (U_CHAR
*) xrealloc (obuf
->buf
, obuf
->length
)) == NULL
)
9186 obuf
->bufp
= p
+ (obuf
->bufp
- obuf
->buf
);
9192 /* Symbol table for macro names and special symbols */
9195 * install a name in the main hash table, even if it is already there.
9196 * name stops with first non alphanumeric, except leading '#'.
9197 * caller must check against redefinition if that is desired.
9198 * delete_macro () removes things installed by install () in fifo order.
9199 * this is important because of the `defined' special symbol used
9200 * in #if, and also if pushdef/popdef directives are ever implemented.
9202 * If LEN is >= 0, it is the length of the name.
9203 * Otherwise, compute the length by scanning the entire name.
9205 * If HASH is >= 0, it is the precomputed hash code.
9206 * Otherwise, compute the hash code.
9209 install (name
, len
, type
, value
, hash
)
9212 enum node_type type
;
9216 register HASHNODE
*hp
;
9217 register int i
, bucket
;
9218 register U_CHAR
*p
, *q
;
9222 while (is_idchar
[*p
])
9228 hash
= hashf (name
, len
, HASHSIZE
);
9230 i
= sizeof (HASHNODE
) + len
+ 1;
9231 hp
= (HASHNODE
*) xmalloc (i
);
9233 hp
->bucket_hdr
= &hashtab
[bucket
];
9234 hp
->next
= hashtab
[bucket
];
9235 hashtab
[bucket
] = hp
;
9237 if (hp
->next
!= NULL
)
9238 hp
->next
->prev
= hp
;
9241 hp
->value
.cpval
= value
;
9242 hp
->name
= ((U_CHAR
*) hp
) + sizeof (HASHNODE
);
9245 for (i
= 0; i
< len
; i
++)
9252 * find the most recent hash node for name name (ending with first
9253 * non-identifier char) installed by install
9255 * If LEN is >= 0, it is the length of the name.
9256 * Otherwise, compute the length by scanning the entire name.
9258 * If HASH is >= 0, it is the precomputed hash code.
9259 * Otherwise, compute the hash code.
9262 lookup (name
, len
, hash
)
9267 register U_CHAR
*bp
;
9268 register HASHNODE
*bucket
;
9271 for (bp
= name
; is_idchar
[*bp
]; bp
++) ;
9276 hash
= hashf (name
, len
, HASHSIZE
);
9278 bucket
= hashtab
[hash
];
9280 if (bucket
->length
== len
&& bcmp (bucket
->name
, name
, len
) == 0)
9282 bucket
= bucket
->next
;
9288 * Delete a hash node. Some weirdness to free junk from macros.
9289 * More such weirdness will have to be added if you define more hash
9290 * types that need it.
9293 /* Note that the DEFINITION of a macro is removed from the hash table
9294 but its storage is not freed. This would be a storage leak
9295 except that it is not reasonable to keep undefining and redefining
9296 large numbers of macros many times.
9297 In any case, this is necessary, because a macro can be #undef'd
9298 in the middle of reading the arguments to a call to it.
9299 If #undef freed the DEFINITION, that would crash. */
9306 if (hp
->prev
!= NULL
)
9307 hp
->prev
->next
= hp
->next
;
9308 if (hp
->next
!= NULL
)
9309 hp
->next
->prev
= hp
->prev
;
9311 /* make sure that the bucket chain header that
9312 the deleted guy was on points to the right thing afterwards. */
9313 if (hp
== *hp
->bucket_hdr
)
9314 *hp
->bucket_hdr
= hp
->next
;
9317 if (hp
->type
== T_MACRO
) {
9318 DEFINITION
*d
= hp
->value
.defn
;
9319 struct reflist
*ap
, *nextap
;
9321 for (ap
= d
->pattern
; ap
!= NULL
; ap
= nextap
) {
9332 * return hash function on name. must be compatible with the one
9333 * computed a step at a time, elsewhere
9336 hashf (name
, len
, hashsize
)
9337 register U_CHAR
*name
;
9344 r
= HASHSTEP (r
, *name
++);
9346 return MAKE_POS (r
) % hashsize
;
9350 /* Dump the definition of a single macro HP to OF. */
9352 dump_single_macro (hp
, of
)
9353 register HASHNODE
*hp
;
9356 register DEFINITION
*defn
= hp
->value
.defn
;
9362 /* Print the definition of the macro HP. */
9364 fprintf (of
, "#define %s", hp
->name
);
9366 if (defn
->nargs
>= 0) {
9370 for (i
= 0; i
< defn
->nargs
; i
++) {
9371 dump_arg_n (defn
, i
, of
);
9372 if (i
+ 1 < defn
->nargs
)
9382 for (ap
= defn
->pattern
; ap
!= NULL
; ap
= ap
->next
) {
9383 dump_defn_1 (defn
->expansion
, offset
, ap
->nchars
, of
);
9384 offset
+= ap
->nchars
;
9386 if (ap
->nchars
!= 0)
9388 if (ap
->stringify
) {
9389 switch (ap
->stringify
) {
9390 case SHARP_TOKEN
: fprintf (of
, "#"); break;
9391 case WHITE_SHARP_TOKEN
: fprintf (of
, "# "); break;
9392 case PERCENT_COLON_TOKEN
: fprintf (of
, "%%:"); break;
9393 case WHITE_PERCENT_COLON_TOKEN
: fprintf (of
, "%%: "); break;
9397 if (ap
->raw_before
!= 0) {
9399 switch (ap
->raw_before
) {
9400 case WHITE_SHARP_TOKEN
:
9401 case WHITE_PERCENT_COLON_TOKEN
:
9408 switch (ap
->raw_before
) {
9409 case SHARP_TOKEN
: fprintf (of
, "##"); break;
9410 case WHITE_SHARP_TOKEN
: fprintf (of
, "## "); break;
9411 case PERCENT_COLON_TOKEN
: fprintf (of
, "%%:%%:"); break;
9412 case WHITE_PERCENT_COLON_TOKEN
: fprintf (of
, "%%:%%: "); break;
9419 dump_arg_n (defn
, ap
->argno
, of
);
9420 if (!traditional
&& ap
->raw_after
!= 0) {
9421 switch (ap
->raw_after
) {
9422 case SHARP_TOKEN
: fprintf (of
, "##"); break;
9423 case WHITE_SHARP_TOKEN
: fprintf (of
, " ##"); break;
9424 case PERCENT_COLON_TOKEN
: fprintf (of
, "%%:%%:"); break;
9425 case WHITE_PERCENT_COLON_TOKEN
: fprintf (of
, " %%:%%:"); break;
9431 dump_defn_1 (defn
->expansion
, offset
, defn
->length
- offset
, of
);
9435 /* Dump all macro definitions as #defines to stdout. */
9442 for (bucket
= 0; bucket
< HASHSIZE
; bucket
++) {
9443 register HASHNODE
*hp
;
9445 for (hp
= hashtab
[bucket
]; hp
; hp
= hp
->next
) {
9446 if (hp
->type
== T_MACRO
)
9447 dump_single_macro (hp
, stdout
);
9452 /* Output to OF a substring of a macro definition.
9453 BASE is the beginning of the definition.
9454 Output characters START thru LENGTH.
9455 Unless traditional, discard newlines outside of strings, thus
9456 converting funny-space markers to ordinary spaces. */
9459 dump_defn_1 (base
, start
, length
, of
)
9465 U_CHAR
*p
= base
+ start
;
9466 U_CHAR
*limit
= base
+ start
+ length
;
9469 fwrite (p
, sizeof (*p
), length
, of
);
9472 if (*p
== '\"' || *p
=='\'') {
9473 U_CHAR
*p1
= skip_quoted_string (p
, limit
, 0, NULL_PTR
,
9474 NULL_PTR
, NULL_PTR
);
9475 fwrite (p
, sizeof (*p
), p1
- p
, of
);
9486 /* Print the name of argument number ARGNUM of macro definition DEFN
9488 Recall that DEFN->args.argnames contains all the arg names
9489 concatenated in reverse order with comma-space in between. */
9492 dump_arg_n (defn
, argnum
, of
)
9497 register U_CHAR
*p
= defn
->args
.argnames
;
9498 while (argnum
+ 1 < defn
->nargs
) {
9499 p
= (U_CHAR
*) index ((char *) p
, ' ') + 1;
9503 while (*p
&& *p
!= ',') {
9509 /* Initialize syntactic classifications of characters. */
9512 initialize_char_syntax ()
9517 * Set up is_idchar and is_idstart tables. These should be
9518 * faster than saying (is_alpha (c) || c == '_'), etc.
9519 * Set up these things before calling any routines tthat
9522 for (i
= 'a'; i
<= 'z'; i
++) {
9523 is_idchar
[i
- 'a' + 'A'] = 1;
9525 is_idstart
[i
- 'a' + 'A'] = 1;
9528 for (i
= '0'; i
<= '9'; i
++)
9531 is_idstart
['_'] = 1;
9532 is_idchar
['$'] = dollars_in_ident
;
9533 is_idstart
['$'] = dollars_in_ident
;
9535 /* horizontal space table */
9536 is_hor_space
[' '] = 1;
9537 is_hor_space
['\t'] = 1;
9538 is_hor_space
['\v'] = 1;
9539 is_hor_space
['\f'] = 1;
9540 is_hor_space
['\r'] = 1;
9549 char_name
['\v'] = "vertical tab";
9550 char_name
['\f'] = "formfeed";
9551 char_name
['\r'] = "carriage return";
9554 /* Initialize the built-in macros. */
9557 initialize_builtins (inp
, outp
)
9561 install ((U_CHAR
*) "__LINE__", -1, T_SPECLINE
, NULL_PTR
, -1);
9562 install ((U_CHAR
*) "__DATE__", -1, T_DATE
, NULL_PTR
, -1);
9563 install ((U_CHAR
*) "__FILE__", -1, T_FILE
, NULL_PTR
, -1);
9564 install ((U_CHAR
*) "__BASE_FILE__", -1, T_BASE_FILE
, NULL_PTR
, -1);
9565 install ((U_CHAR
*) "__INCLUDE_LEVEL__", -1, T_INCLUDE_LEVEL
, NULL_PTR
, -1);
9566 install ((U_CHAR
*) "__VERSION__", -1, T_VERSION
, NULL_PTR
, -1);
9567 #ifndef NO_BUILTIN_SIZE_TYPE
9568 install ((U_CHAR
*) "__SIZE_TYPE__", -1, T_SIZE_TYPE
, NULL_PTR
, -1);
9570 #ifndef NO_BUILTIN_PTRDIFF_TYPE
9571 install ((U_CHAR
*) "__PTRDIFF_TYPE__ ", -1, T_PTRDIFF_TYPE
, NULL_PTR
, -1);
9573 install ((U_CHAR
*) "__WCHAR_TYPE__", -1, T_WCHAR_TYPE
, NULL_PTR
, -1);
9574 install ((U_CHAR
*) "__USER_LABEL_PREFIX__", -1, T_USER_LABEL_PREFIX_TYPE
,
9576 install ((U_CHAR
*) "__REGISTER_PREFIX__", -1, T_REGISTER_PREFIX_TYPE
,
9578 install ((U_CHAR
*) "__IMMEDIATE_PREFIX__", -1, T_IMMEDIATE_PREFIX_TYPE
,
9580 install ((U_CHAR
*) "__TIME__", -1, T_TIME
, NULL_PTR
, -1);
9582 install ((U_CHAR
*) "__STDC__", -1, T_CONST
, "1", -1);
9583 install ((U_CHAR
*) "__STDC_VERSION__", -1, T_CONST
, "199409L", -1);
9586 install ((U_CHAR
*) "__OBJC__", -1, T_CONST
, "1", -1);
9587 /* This is supplied using a -D by the compiler driver
9588 so that it is present only when truly compiling with GNU C. */
9589 /* install ((U_CHAR *) "__GNUC__", -1, T_CONST, "2", -1); */
9593 char directive
[2048];
9594 U_CHAR
*udirective
= (U_CHAR
*) directive
;
9595 register struct directive
*dp
= &directive_table
[0];
9596 struct tm
*timebuf
= timestamp ();
9598 sprintf (directive
, " __BASE_FILE__ \"%s\"\n",
9599 instack
[0].nominal_fname
);
9600 output_line_directive (inp
, outp
, 0, same_file
);
9601 pass_thru_directive (udirective
, &udirective
[strlen (directive
)],
9604 sprintf (directive
, " __VERSION__ \"%s\"\n", version_string
);
9605 output_line_directive (inp
, outp
, 0, same_file
);
9606 pass_thru_directive (udirective
, &udirective
[strlen (directive
)],
9609 #ifndef NO_BUILTIN_SIZE_TYPE
9610 sprintf (directive
, " __SIZE_TYPE__ %s\n", SIZE_TYPE
);
9611 output_line_directive (inp
, outp
, 0, same_file
);
9612 pass_thru_directive (udirective
, &udirective
[strlen (directive
)],
9616 #ifndef NO_BUILTIN_PTRDIFF_TYPE
9617 sprintf (directive
, " __PTRDIFF_TYPE__ %s\n", PTRDIFF_TYPE
);
9618 output_line_directive (inp
, outp
, 0, same_file
);
9619 pass_thru_directive (udirective
, &udirective
[strlen (directive
)],
9623 sprintf (directive
, " __WCHAR_TYPE__ %s\n", wchar_type
);
9624 output_line_directive (inp
, outp
, 0, same_file
);
9625 pass_thru_directive (udirective
, &udirective
[strlen (directive
)],
9628 sprintf (directive
, " __DATE__ \"%s %2d %4d\"\n",
9629 monthnames
[timebuf
->tm_mon
],
9630 timebuf
->tm_mday
, timebuf
->tm_year
+ 1900);
9631 output_line_directive (inp
, outp
, 0, same_file
);
9632 pass_thru_directive (udirective
, &udirective
[strlen (directive
)],
9635 sprintf (directive
, " __TIME__ \"%02d:%02d:%02d\"\n",
9636 timebuf
->tm_hour
, timebuf
->tm_min
, timebuf
->tm_sec
);
9637 output_line_directive (inp
, outp
, 0, same_file
);
9638 pass_thru_directive (udirective
, &udirective
[strlen (directive
)],
9643 sprintf (directive
, " __STDC__ 1");
9644 output_line_directive (inp
, outp
, 0, same_file
);
9645 pass_thru_directive (udirective
, &udirective
[strlen (directive
)],
9650 sprintf (directive
, " __OBJC__ 1");
9651 output_line_directive (inp
, outp
, 0, same_file
);
9652 pass_thru_directive (udirective
, &udirective
[strlen (directive
)],
9659 * process a given definition string, for initialization
9660 * If STR is just an identifier, define it with value 1.
9661 * If STR has anything after the identifier, then it should
9662 * be identifier=definition.
9666 make_definition (str
, op
)
9671 struct directive
*kt
;
9674 p
= buf
= (U_CHAR
*) str
;
9675 if (!is_idstart
[*p
]) {
9676 error ("malformed option `-D %s'", str
);
9679 while (is_idchar
[*++p
])
9682 while (is_idchar
[*++p
] || *p
== ',' || is_hor_space
[*p
])
9685 p
= (U_CHAR
*) str
; /* Error */
9688 buf
= (U_CHAR
*) alloca (p
- buf
+ 4);
9689 strcpy ((char *)buf
, str
);
9690 strcat ((char *)buf
, " 1");
9691 } else if (*p
!= '=') {
9692 error ("malformed option `-D %s'", str
);
9696 /* Copy the entire option so we can modify it. */
9697 buf
= (U_CHAR
*) alloca (2 * strlen (str
) + 1);
9698 strncpy ((char *) buf
, str
, p
- (U_CHAR
*) str
);
9699 /* Change the = to a space. */
9700 buf
[p
- (U_CHAR
*) str
] = ' ';
9701 /* Scan for any backslash-newline and remove it. */
9703 q
= &buf
[p
- (U_CHAR
*) str
];
9705 if (*p
== '\"' || *p
== '\'') {
9706 int unterminated
= 0;
9707 U_CHAR
*p1
= skip_quoted_string (p
, p
+ strlen ((char *) p
), 0,
9708 NULL_PTR
, NULL_PTR
, &unterminated
);
9712 if (*p
== '\\' && p
[1] == '\n')
9716 } else if (*p
== '\\' && p
[1] == '\n')
9718 /* Change newline chars into newline-markers. */
9719 else if (*p
== '\n')
9731 ip
= &instack
[++indepth
];
9732 ip
->nominal_fname
= ip
->fname
= "*Initialization*";
9734 ip
->buf
= ip
->bufp
= buf
;
9735 ip
->length
= strlen ((char *) buf
);
9739 ip
->if_stack
= if_stack
;
9740 ip
->system_header_p
= 0;
9742 for (kt
= directive_table
; kt
->type
!= T_DEFINE
; kt
++)
9745 /* Pass NULL instead of OP, since this is a "predefined" macro. */
9746 do_define (buf
, buf
+ strlen ((char *) buf
), NULL_PTR
, kt
);
9750 /* JF, this does the work for the -U option */
9753 make_undef (str
, op
)
9758 struct directive
*kt
;
9760 ip
= &instack
[++indepth
];
9761 ip
->nominal_fname
= ip
->fname
= "*undef*";
9763 ip
->buf
= ip
->bufp
= (U_CHAR
*) str
;
9764 ip
->length
= strlen (str
);
9768 ip
->if_stack
= if_stack
;
9769 ip
->system_header_p
= 0;
9771 for (kt
= directive_table
; kt
->type
!= T_UNDEF
; kt
++)
9774 do_undef ((U_CHAR
*) str
, (U_CHAR
*) str
+ strlen (str
), op
, kt
);
9778 /* Process the string STR as if it appeared as the body of a #assert.
9779 OPTION is the option name for which STR was the argument. */
9782 make_assertion (option
, str
)
9787 struct directive
*kt
;
9788 U_CHAR
*buf
, *p
, *q
;
9790 /* Copy the entire option so we can modify it. */
9791 buf
= (U_CHAR
*) alloca (strlen (str
) + 1);
9792 strcpy ((char *) buf
, str
);
9793 /* Scan for any backslash-newline and remove it. */
9796 if (*p
== '\\' && p
[1] == '\n')
9804 if (!is_idstart
[*p
]) {
9805 error ("malformed option `%s %s'", option
, str
);
9808 while (is_idchar
[*++p
])
9810 SKIP_WHITE_SPACE (p
);
9811 if (! (*p
== 0 || *p
== '(')) {
9812 error ("malformed option `%s %s'", option
, str
);
9816 ip
= &instack
[++indepth
];
9817 ip
->nominal_fname
= ip
->fname
= "*Initialization*";
9819 ip
->buf
= ip
->bufp
= buf
;
9820 ip
->length
= strlen ((char *) buf
);
9824 ip
->if_stack
= if_stack
;
9825 ip
->system_header_p
= 0;
9827 for (kt
= directive_table
; kt
->type
!= T_ASSERT
; kt
++)
9830 /* pass NULL as output ptr to do_define since we KNOW it never
9831 does any output.... */
9832 do_assert (buf
, buf
+ strlen ((char *) buf
) , NULL_PTR
, kt
);
9836 /* Append a chain of `struct file_name_list's
9837 to the end of the main include chain.
9838 FIRST is the beginning of the chain to append, and LAST is the end. */
9841 append_include_chain (first
, last
)
9842 struct file_name_list
*first
, *last
;
9844 struct file_name_list
*dir
;
9846 if (!first
|| !last
)
9852 last_include
->next
= first
;
9854 if (first_bracket_include
== 0)
9855 first_bracket_include
= first
;
9857 for (dir
= first
; ; dir
= dir
->next
) {
9858 int len
= strlen (dir
->fname
) + INCLUDE_LEN_FUDGE
;
9859 if (len
> max_include_len
)
9860 max_include_len
= len
;
9866 last_include
= last
;
9869 /* Add output to `deps_buffer' for the -M switch.
9870 STRING points to the text to be output.
9871 SPACER is ':' for targets, ' ' for dependencies. */
9874 deps_output (string
, spacer
)
9878 int size
= strlen (string
);
9883 #ifndef MAX_OUTPUT_COLUMNS
9884 #define MAX_OUTPUT_COLUMNS 72
9886 if (MAX_OUTPUT_COLUMNS
- 1 /*spacer*/ - 2 /*` \'*/ < deps_column
+ size
9887 && 1 < deps_column
) {
9888 bcopy (" \\\n ", &deps_buffer
[deps_size
], 4);
9895 if (deps_size
+ size
+ 8 > deps_allocated_size
) {
9896 deps_allocated_size
= (deps_size
+ size
+ 50) * 2;
9897 deps_buffer
= xrealloc (deps_buffer
, deps_allocated_size
);
9899 if (spacer
== ' ') {
9900 deps_buffer
[deps_size
++] = ' ';
9903 bcopy (string
, &deps_buffer
[deps_size
], size
);
9905 deps_column
+= size
;
9906 if (spacer
== ':') {
9907 deps_buffer
[deps_size
++] = ':';
9910 deps_buffer
[deps_size
] = 0;
9914 fatal (PRINTF_ALIST (msg
))
9919 fprintf (stderr
, "%s: ", progname
);
9920 VA_START (args
, msg
);
9921 vfprintf (stderr
, msg
, args
);
9923 fprintf (stderr
, "\n");
9924 exit (FATAL_EXIT_CODE
);
9927 /* More 'friendly' abort that prints the line and file.
9928 config.h can #define abort fancy_abort if you like that sort of thing. */
9933 fatal ("Internal gcc abort.");
9937 perror_with_name (name
)
9940 fprintf (stderr
, "%s: ", progname
);
9941 fprintf (stderr
, "%s: %s\n", name
, my_strerror (errno
));
9946 pfatal_with_name (name
)
9949 perror_with_name (name
);
9953 exit (FATAL_EXIT_CODE
);
9957 /* Handler for SIGPIPE. */
9961 /* If this is missing, some compilers complain. */
9964 fatal ("output pipe has been closed");
9970 fatal ("Memory exhausted.");
9978 register GENERIC_PTR ptr
= (GENERIC_PTR
) malloc (size
);
9985 xrealloc (old
, size
)
9989 register GENERIC_PTR ptr
= (GENERIC_PTR
) realloc (old
, size
);
9996 xcalloc (number
, size
)
9997 size_t number
, size
;
9999 register size_t total
= number
* size
;
10000 register GENERIC_PTR ptr
= (GENERIC_PTR
) malloc (total
);
10003 bzero (ptr
, total
);
10011 size_t size
= strlen (input
);
10012 char *output
= xmalloc (size
+ 1);
10013 strcpy (output
, input
);
10017 /* Get the file-mode and data size of the file open on FD
10018 and store them in *MODE_POINTER and *SIZE_POINTER. */
10021 file_size_and_mode (fd
, mode_pointer
, size_pointer
)
10024 long int *size_pointer
;
10028 if (fstat (fd
, &sbuf
) < 0) return (-1);
10029 if (mode_pointer
) *mode_pointer
= sbuf
.st_mode
;
10030 if (size_pointer
) *size_pointer
= sbuf
.st_size
;
10035 output_dots (fd
, depth
)
10039 while (depth
> 0) {
10048 /* Under VMS we need to fix up the "include" specification
10049 filename so that everything following the 1st slash is
10050 changed into its correct VMS file specification. */
10053 hack_vms_include_specification (fname
)
10056 register char *cp
, *cp1
, *cp2
;
10057 int f
, check_filename_before_returning
, no_prefix_seen
;
10060 check_filename_before_returning
= 0;
10061 no_prefix_seen
= 0;
10063 /* Ignore leading "./"s */
10064 while (fname
[0] == '.' && fname
[1] == '/') {
10065 strcpy (fname
, fname
+2);
10066 no_prefix_seen
= 1; /* mark this for later */
10068 /* Look for the boundary between the VMS and UNIX filespecs */
10069 cp
= rindex (fname
, ']'); /* Look for end of dirspec. */
10070 if (cp
== 0) cp
= rindex (fname
, '>'); /* ... Ditto */
10071 if (cp
== 0) cp
= rindex (fname
, ':'); /* Look for end of devspec. */
10075 cp
= index (fname
, '/'); /* Look for the "/" */
10079 * Check if we have a vax-c style '#include filename'
10080 * and add the missing .h
10083 if (index(fname
,'.') == 0)
10084 strcat(fname
, ".h");
10086 if (index(cp
,'.') == 0)
10090 cp2
= Local
; /* initialize */
10092 /* We are trying to do a number of things here. First of all, we are
10093 trying to hammer the filenames into a standard format, such that later
10094 processing can handle them.
10096 If the file name contains something like [dir.], then it recognizes this
10097 as a root, and strips the ".]". Later processing will add whatever is
10098 needed to get things working properly.
10100 If no device is specified, then the first directory name is taken to be
10101 a device name (or a rooted logical). */
10103 /* See if we found that 1st slash */
10104 if (cp
== 0) return; /* Nothing to do!!! */
10105 if (*cp
!= '/') return; /* Nothing to do!!! */
10106 /* Point to the UNIX filename part (which needs to be fixed!) */
10108 /* If the directory spec is not rooted, we can just copy
10109 the UNIX filename part and we are done */
10110 if (((cp
- fname
) > 1) && ((cp
[-1] == ']') || (cp
[-1] == '>'))) {
10111 if (cp
[-2] != '.') {
10113 * The VMS part ends in a `]', and the preceding character is not a `.'.
10114 * We strip the `]', and then splice the two parts of the name in the
10115 * usual way. Given the default locations for include files in cccp.c,
10116 * we will only use this code if the user specifies alternate locations
10117 * with the /include (-I) switch on the command line. */
10118 cp
-= 1; /* Strip "]" */
10119 cp1
--; /* backspace */
10122 * The VMS part has a ".]" at the end, and this will not do. Later
10123 * processing will add a second directory spec, and this would be a syntax
10124 * error. Thus we strip the ".]", and thus merge the directory specs.
10125 * We also backspace cp1, so that it points to a '/'. This inhibits the
10126 * generation of the 000000 root directory spec (which does not belong here
10129 cp
-= 2; /* Strip ".]" */
10130 cp1
--; }; /* backspace */
10133 /* We drop in here if there is no VMS style directory specification yet.
10134 * If there is no device specification either, we make the first dir a
10135 * device and try that. If we do not do this, then we will be essentially
10136 * searching the users default directory (as if they did a #include "asdf.h").
10138 * Then all we need to do is to push a '[' into the output string. Later
10139 * processing will fill this in, and close the bracket.
10141 if (cp
[-1] != ':') *cp2
++ = ':'; /* dev not in spec. take first dir */
10142 *cp2
++ = '['; /* Open the directory specification */
10145 /* at this point we assume that we have the device spec, and (at least
10146 the opening "[" for a directory specification. We may have directories
10147 specified already */
10149 /* If there are no other slashes then the filename will be
10150 in the "root" directory. Otherwise, we need to add
10151 directory specifications. */
10152 if (index (cp1
, '/') == 0) {
10153 /* Just add "000000]" as the directory string */
10154 strcpy (cp2
, "000000]");
10155 cp2
+= strlen (cp2
);
10156 check_filename_before_returning
= 1; /* we might need to fool with this later */
10158 /* As long as there are still subdirectories to add, do them. */
10159 while (index (cp1
, '/') != 0) {
10160 /* If this token is "." we can ignore it */
10161 if ((cp1
[0] == '.') && (cp1
[1] == '/')) {
10165 /* Add a subdirectory spec. Do not duplicate "." */
10166 if (cp2
[-1] != '.' && cp2
[-1] != '[' && cp2
[-1] != '<')
10168 /* If this is ".." then the spec becomes "-" */
10169 if ((cp1
[0] == '.') && (cp1
[1] == '.') && (cp
[2] == '/')) {
10170 /* Add "-" and skip the ".." */
10175 /* Copy the subdirectory */
10176 while (*cp1
!= '/') *cp2
++= *cp1
++;
10177 cp1
++; /* Skip the "/" */
10179 /* Close the directory specification */
10180 if (cp2
[-1] == '.') /* no trailing periods */
10184 /* Now add the filename */
10185 while (*cp1
) *cp2
++ = *cp1
++;
10187 /* Now append it to the original VMS spec. */
10188 strcpy (cp
, Local
);
10190 /* If we put a [000000] in the filename, try to open it first. If this fails,
10191 remove the [000000], and return that name. This provides flexibility
10192 to the user in that they can use both rooted and non-rooted logical names
10193 to point to the location of the file. */
10195 if (check_filename_before_returning
&& no_prefix_seen
) {
10196 f
= open (fname
, O_RDONLY
, 0666);
10198 /* The file name is OK as it is, so return it as is. */
10202 /* The filename did not work. Try to remove the [000000] from the name,
10204 cp
= index (fname
, '[');
10205 cp2
= index (fname
, ']') + 1;
10206 strcpy (cp
, cp2
); /* this gets rid of it */
10214 /* These are the read/write replacement routines for
10215 VAX-11 "C". They make read/write behave enough
10216 like their UNIX counterparts that CCCP will work */
10219 read (fd
, buf
, size
)
10224 #undef read /* Get back the REAL read routine */
10226 register int total
= 0;
10228 /* Read until the buffer is exhausted */
10230 /* Limit each read to 32KB */
10231 i
= (size
> (32*1024)) ? (32*1024) : size
;
10232 i
= read (fd
, buf
, i
);
10234 if (i
== 0) return (total
);
10237 /* Account for this read */
10246 write (fd
, buf
, size
)
10251 #undef write /* Get back the REAL write routine */
10255 /* Limit individual writes to 32Kb */
10258 j
= (i
> (32*1024)) ? (32*1024) : i
;
10259 if (write (fd
, buf
, j
) < 0) return (-1);
10260 /* Account for the data written */
10267 /* The following wrapper functions supply additional arguments to the VMS
10268 I/O routines to optimize performance with file handling. The arguments
10270 "mbc=16" - Set multi-block count to 16 (use a 8192 byte buffer).
10271 "deq=64" - When extending the file, extend it in chunks of 32Kbytes.
10272 "fop=tef"- Truncate unused portions of file when closing file.
10273 "shr=nil"- Disallow file sharing while file is open.
10277 freopen (fname
, type
, oldfile
)
10282 #undef freopen /* Get back the REAL fopen routine */
10283 if (strcmp (type
, "w") == 0)
10284 return freopen (fname
, type
, oldfile
, "mbc=16", "deq=64", "fop=tef", "shr=nil");
10285 return freopen (fname
, type
, oldfile
, "mbc=16");
10289 fopen (fname
, type
)
10293 #undef fopen /* Get back the REAL fopen routine */
10294 /* The gcc-vms-1.42 distribution's header files prototype fopen with two
10295 fixed arguments, which matches ANSI's specification but not VAXCRTL's
10296 pre-ANSI implementation. This hack circumvents the mismatch problem. */
10297 FILE *(*vmslib_fopen
)() = (FILE *(*)()) fopen
;
10300 return (*vmslib_fopen
) (fname
, type
, "mbc=32",
10301 "deq=64", "fop=tef", "shr=nil");
10303 return (*vmslib_fopen
) (fname
, type
, "mbc=32");
10307 open (fname
, flags
, prot
)
10312 #undef open /* Get back the REAL open routine */
10313 return open (fname
, flags
, prot
, "mbc=16", "deq=64", "fop=tef");
10316 /* Avoid run-time library bug, where copying M out of N+M characters with
10317 N >= 65535 results in VAXCRTL's strncat falling into an infinite loop.
10318 gcc-cpp exercises this particular bug. [Fixed in V5.5-2's VAXCRTL.] */
10321 strncat (dst
, src
, cnt
)
10326 register char *d
= dst
, *s
= (char *) src
;
10327 register int n
= cnt
; /* convert to _signed_ type */
10329 while (*d
) d
++; /* advance to end */
10331 if (!(*d
++ = *s
++)) break;
10332 if (n
< 0) *d
= '\0';
10336 /* more VMS hackery */
10340 extern unsigned long sys$
parse(), sys$
search();
10342 /* Work around another library bug. If a file is located via a searchlist,
10343 and if the device it's on is not the same device as the one specified
10344 in the first element of that searchlist, then both stat() and fstat()
10345 will fail to return info about it. `errno' will be set to EVMSERR, and
10346 `vaxc$errno' will be set to SS$_NORMAL due yet another bug in stat()!
10347 We can get around this by fully parsing the filename and then passing
10348 that absolute name to stat().
10350 Without this fix, we can end up failing to find header files, which is
10351 bad enough, but then compounding the problem by reporting the reason for
10352 failure as "normal successful completion." */
10354 #undef fstat /* get back to library version */
10357 VMS_fstat (fd
, statbuf
)
10359 struct stat
*statbuf
;
10361 int result
= fstat (fd
, statbuf
);
10366 char nambuf
[NAM$C_MAXRSS
+1];
10368 if ((fp
= fdopen (fd
, "r")) != 0 && fgetname (fp
, nambuf
) != 0)
10369 result
= VMS_stat (nambuf
, statbuf
);
10370 /* No fclose(fp) here; that would close(fd) as well. */
10377 VMS_stat (name
, statbuf
)
10379 struct stat
*statbuf
;
10381 int result
= stat (name
, statbuf
);
10387 char exp_nam
[NAM$C_MAXRSS
+1], /* expanded name buffer for sys$parse */
10388 res_nam
[NAM$C_MAXRSS
+1]; /* resultant name buffer for sys$search */
10391 fab
.fab$l_fna
= (char *) name
;
10392 fab
.fab$b_fns
= (unsigned char) strlen (name
);
10393 fab
.fab$l_nam
= (void *) &nam
;
10395 nam
.nam$l_esa
= exp_nam
, nam
.nam$b_ess
= sizeof exp_nam
- 1;
10396 nam
.nam$l_rsa
= res_nam
, nam
.nam$b_rss
= sizeof res_nam
- 1;
10397 nam
.nam$b_nop
= NAM$M_PWD
| NAM$M_NOCONCEAL
;
10398 if (sys$
parse (&fab
) & 1)
10400 if (sys$
search (&fab
) & 1)
10402 res_nam
[nam
.nam$b_rsl
] = '\0';
10403 result
= stat (res_nam
, statbuf
);
10405 /* Clean up searchlist context cached by the system. */
10406 nam
.nam$b_nop
= NAM$M_SYNCHK
;
10407 fab
.fab$l_fna
= 0, fab
.fab$b_fns
= 0;
10408 (void) sys$
parse (&fab
);