1 /* C Compatible Compiler Preprocessor (CCCP)
2 Copyright (C) 1986, 1987, 1989, 1992 Free Software Foundation, Inc.
3 Written by Paul Rubin, June 1986
4 Adapted to ANSI C, Richard Stallman, Jan 1987
6 This program is free software; you can redistribute it and/or modify it
7 under the terms of the GNU General Public License as published by the
8 Free Software Foundation; either version 2, or (at your option) any
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with this program; if not, write to the Free Software
18 Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
20 In other words, you are welcome to use, share and improve this program.
21 You are forbidden to forbid anyone else to use, share and improve
22 what you give them. Help stamp out software-hoarding! */
24 typedef unsigned char U_CHAR
;
28 #include "../src/config.h"
36 /* The macro EMACS is defined when cpp is distributed as part of Emacs,
37 for the sake of machines with limited C compilers. */
40 #endif /* not EMACS */
42 #ifndef STANDARD_INCLUDE_DIR
43 #define STANDARD_INCLUDE_DIR "/usr/include"
46 #ifndef LOCAL_INCLUDE_DIR
47 #define LOCAL_INCLUDE_DIR "/usr/local/include"
50 #if 0 /* We can't get ptrdiff_t, so I arranged not to need PTR_INT_TYPE. */
52 #define PTR_INT_TYPE ptrdiff_t
54 #define PTR_INT_TYPE long
64 /* By default, colon separates directories in a path. */
65 #ifndef PATH_SEPARATOR
66 #define PATH_SEPARATOR ':'
69 /* In case config.h defines these. */
74 #include <sys/types.h>
82 #include <sys/time.h> /* for __DATE__ and __TIME__ */
83 #include <sys/resource.h>
90 /* This defines "errno" properly for VMS, and gives us EACCES. */
93 /* VMS-specific definitions */
96 #include <perror.h> /* This defines sys_errlist/sys_nerr properly */
98 #define O_RDONLY 0 /* Open arg for Read/Only */
99 #define O_WRONLY 1 /* Open arg for Write/Only */
100 #define read(fd,buf,size) VMS_read (fd,buf,size)
101 #define write(fd,buf,size) VMS_write (fd,buf,size)
102 #define open(fname,mode,prot) VMS_open (fname,mode,prot)
103 #define fopen(fname,mode) VMS_fopen (fname,mode)
104 #define freopen(fname,mode,ofile) VMS_freopen (fname,mode,ofile)
105 #define strncat(dst,src,cnt) VMS_strncat (dst,src,cnt)
106 static char * VMS_strncat ();
107 static int VMS_read ();
108 static int VMS_write ();
109 static int VMS_open ();
110 static FILE * VMS_fopen ();
111 static FILE * VMS_freopen ();
112 static void hack_vms_include_specification ();
113 typedef struct { unsigned :16, :16, :16; } vms_ino_t
;
114 #define ino_t vms_ino_t
115 #define INCLUDE_LEN_FUDGE 10 /* leave room for VMS syntax conversion */
117 #define BSTRING /* VMS/GCC supplies the bstring routines */
118 #endif /* __GNUC__ */
121 extern char *index ();
122 extern char *rindex ();
130 #define MIN(X,Y) ((X) < (Y) ? (X) : (Y))
131 #define MAX(X,Y) ((X) > (Y) ? (X) : (Y))
133 /* Find the largest host integer type and set its size and type. */
135 #ifndef HOST_BITS_PER_WIDE_INT
137 #if HOST_BITS_PER_LONG > HOST_BITS_PER_INT
138 #define HOST_BITS_PER_WIDE_INT HOST_BITS_PER_LONG
139 #define HOST_WIDE_INT long
141 #define HOST_BITS_PER_WIDE_INT HOST_BITS_PER_INT
142 #define HOST_WIDE_INT int
148 #define S_ISREG(m) (((m) & S_IFMT) == S_IFREG)
152 #define S_ISDIR(m) (((m) & S_IFMT) == S_IFDIR)
155 /* Define a generic NULL if one hasn't already been defined. */
162 #if defined (USE_PROTOTYPES) ? USE_PROTOTYPES : defined (__STDC__)
163 #define GENERIC_PTR void *
165 #define GENERIC_PTR char *
170 #define NULL_PTR ((GENERIC_PTR)0)
173 #ifndef INCLUDE_LEN_FUDGE
174 #define INCLUDE_LEN_FUDGE 0
177 /* Forward declarations. */
183 /* External declarations. */
185 extern char *getenv ();
186 extern FILE *fdopen ();
187 extern char *version_string
;
188 extern struct tm
*localtime ();
190 extern char *sys_errlist
[];
196 /* Forward declarations. */
203 #if defined(USG) || defined(VMS)
211 /* These functions are declared to return int instead of void since they
212 are going to be placed in a table and some old compilers have trouble with
213 pointers to functions returning void. */
215 static int do_define ();
216 static int do_line ();
217 static int do_include ();
218 static int do_undef ();
219 static int do_error ();
220 static int do_pragma ();
221 static int do_ident ();
223 static int do_xifdef ();
224 static int do_else ();
225 static int do_elif ();
226 static int do_endif ();
227 static int do_sccs ();
228 static int do_once ();
229 static int do_assert ();
230 static int do_unassert ();
231 static int do_warning ();
233 static void add_import ();
234 static void append_include_chain ();
235 static void deps_output ();
236 static void make_undef ();
237 static void make_definition ();
238 static void make_assertion ();
239 static void path_include ();
240 static void initialize_builtins ();
241 static void initialize_char_syntax ();
242 static void dump_arg_n ();
243 static void dump_defn_1 ();
244 static void delete_macro ();
245 static void trigraph_pcp ();
246 static void rescan ();
247 static void finclude ();
248 static void validate_else ();
249 static int comp_def_part ();
250 static void error_from_errno ();
251 static void error_with_line ();
253 void pedwarn_with_line ();
254 static void pedwarn_with_file_and_line ();
255 static void fatal ();
257 static void pfatal_with_name ();
258 static void perror_with_name ();
259 static void pipe_closed ();
260 static void print_containing_files ();
261 static int lookup_import ();
262 static int redundant_include_p ();
263 static is_system_include ();
264 static int check_preconditions ();
265 static void pcfinclude ();
266 static void pcstring_used ();
267 static void write_output ();
268 static int check_macro_name ();
269 static int compare_defs ();
270 static int compare_token_lists ();
271 static int eval_if_expression ();
272 static int discard_comments ();
273 static int change_newlines ();
274 static int line_for_error ();
276 static int file_size_and_mode ();
278 static struct arglist
*read_token_list ();
279 static void free_token_list ();
281 static struct hashnode
*install ();
282 struct hashnode
*lookup ();
284 static struct assertion_hashnode
*assertion_install ();
285 static struct assertion_hashnode
*assertion_lookup ();
287 static char *xrealloc ();
288 static char *xcalloc ();
289 static char *savestring ();
291 static void delete_assertion ();
292 static void macroexpand ();
293 static void dump_all_macros ();
294 static void conditional_skip ();
295 static void skip_if_group ();
296 static void output_line_command ();
298 /* Last arg to output_line_command. */
299 enum file_change_code
{same_file
, enter_file
, leave_file
};
301 static int grow_outbuf ();
302 static int handle_directive ();
303 static void memory_full ();
305 static U_CHAR
*macarg1 ();
306 static char *macarg ();
308 static U_CHAR
*skip_to_end_of_comment ();
309 static U_CHAR
*skip_quoted_string ();
310 static U_CHAR
*skip_paren_group ();
312 static char *check_precompiled ();
313 /* static struct macrodef create_definition (); [moved below] */
314 static void dump_single_macro ();
316 #ifndef FAILURE_EXIT_CODE
317 #define FAILURE_EXIT_CODE 33 /* gnu cc command understands this */
320 #ifndef SUCCESS_EXIT_CODE
321 #define SUCCESS_EXIT_CODE 0 /* 0 means success on Unix. */
324 /* Name under which this program was invoked. */
326 static char *progname
;
328 /* Nonzero means use extra default include directories for C++. */
330 static int cplusplus
;
332 /* Nonzero means handle cplusplus style comments */
334 static int cplusplus_comments
;
336 /* Nonzero means handle #import, for objective C. */
340 /* Nonzero means this is an assembly file, and allow
341 unknown directives, which could be comments. */
345 /* Current maximum length of directory names in the search path
346 for include files. (Altered as we get more of them.) */
348 static int max_include_len
;
350 /* Nonzero means turn NOTREACHED into #pragma NOTREACHED etc */
354 /* Nonzero means copy comments into the output file. */
356 static int put_out_comments
= 0;
358 /* Nonzero means don't process the ANSI trigraph sequences. */
360 static int no_trigraphs
= 0;
362 /* Nonzero means print the names of included files rather than
363 the preprocessed output. 1 means just the #include "...",
364 2 means #include <...> as well. */
366 static int print_deps
= 0;
368 /* Nonzero means print names of header files (-H). */
370 static int print_include_names
= 0;
372 /* Nonzero means don't output line number information. */
374 static int no_line_commands
;
376 /* dump_only means inhibit output of the preprocessed text
377 and instead output the definitions of all user-defined
378 macros in a form suitable for use as input to cccp.
379 dump_names means pass #define and the macro name through to output.
380 dump_definitions means pass the whole definition (plus #define) through
383 static enum {dump_none
, dump_only
, dump_names
, dump_definitions
}
384 dump_macros
= dump_none
;
386 /* Nonzero means pass all #define and #undef directives which we actually
387 process through to the output stream. This feature is used primarily
388 to allow cc1 to record the #defines and #undefs for the sake of
389 debuggers which understand about preprocessor macros, but it may
390 also be useful with -E to figure out how symbols are defined, and
391 where they are defined. */
392 static int debug_output
= 0;
394 /* Nonzero indicates special processing used by the pcp program. The
395 special effects of this mode are:
397 Inhibit all macro expansion, except those inside #if directives.
399 Process #define directives normally, and output their contents
402 Output preconditions to pcp_outfile indicating all the relevant
403 preconditions for use of this file in a later cpp run.
405 static FILE *pcp_outfile
;
407 /* Nonzero means we are inside an IF during a -pcp run. In this mode
408 macro expansion is done, and preconditions are output for all macro
409 uses requiring them. */
410 static int pcp_inside_if
;
412 /* Nonzero means never to include precompiled files.
413 This is 1 since there's no way now to make precompiled files,
414 so it's not worth testing for them. */
415 static int no_precomp
= 1;
417 /* Nonzero means give all the error messages the ANSI standard requires. */
421 /* Nonzero means try to make failure to fit ANSI C an error. */
423 static int pedantic_errors
;
425 /* Nonzero means don't print warning messages. -w. */
427 static int inhibit_warnings
= 0;
429 /* Nonzero means warn if slash-star appears in a comment. */
431 static int warn_comments
;
433 /* Nonzero means warn if a macro argument is (or would be)
434 stringified with -traditional. */
436 static int warn_stringify
;
438 /* Nonzero means warn if there are any trigraphs. */
440 static int warn_trigraphs
;
442 /* Nonzero means warn if #import is used. */
444 static int warn_import
= 1;
446 /* Nonzero means turn warnings into errors. */
448 static int warnings_are_errors
;
450 /* Nonzero means try to imitate old fashioned non-ANSI preprocessor. */
454 /* Nonzero causes output not to be done,
455 but directives such as #define that have side effects
458 static int no_output
;
460 /* Nonzero means that we have finished processing the command line options.
461 This flag is used to decide whether or not to issue certain errors
464 static int done_initializing
= 0;
466 /* Line where a newline was first seen in a string constant. */
468 static int multiline_string_line
= 0;
470 /* I/O buffer structure.
471 The `fname' field is nonzero for source files and #include files
472 and for the dummy text used for -D and -U.
473 It is zero for rescanning results of macro expansion
474 and for expanding macro arguments. */
475 #define INPUT_STACK_MAX 200
476 static struct file_buf
{
478 /* Filename specified with #line command. */
480 /* Record where in the search path this file was found.
481 For #include_next. */
482 struct file_name_list
*dir
;
487 /* Macro that this level is the expansion of.
488 Included so that we can reenable the macro
489 at the end of this level. */
490 struct hashnode
*macro
;
491 /* Value of if_stack at start of this file.
492 Used to prohibit unmatched #endif (etc) in an include file. */
493 struct if_stack
*if_stack
;
494 /* Object to be freed at end of input at this level. */
496 /* True if this is a header file included using <FILENAME>. */
497 char system_header_p
;
498 } instack
[INPUT_STACK_MAX
];
500 static int last_error_tick
; /* Incremented each time we print it. */
501 static int input_file_stack_tick
; /* Incremented when the status changes. */
503 /* Current nesting level of input sources.
504 `instack[indepth]' is the level currently being read. */
505 static int indepth
= -1;
506 #define CHECK_DEPTH(code) \
507 if (indepth >= (INPUT_STACK_MAX - 1)) \
509 error_with_line (line_for_error (instack[indepth].lineno), \
510 "macro or `#include' recursion too deep"); \
514 /* Current depth in #include directives that use <...>. */
515 static int system_include_depth
= 0;
517 typedef struct file_buf FILE_BUF
;
519 /* The output buffer. Its LENGTH field is the amount of room allocated
520 for the buffer, not the number of chars actually present. To get
521 that, subtract outbuf.buf from outbuf.bufp. */
523 #define OUTBUF_SIZE 10 /* initial size of output buffer */
524 static FILE_BUF outbuf
;
526 /* Grow output buffer OBUF points at
527 so it can hold at least NEEDED more chars. */
529 #define check_expand(OBUF, NEEDED) \
530 (((OBUF)->length - ((OBUF)->bufp - (OBUF)->buf) <= (NEEDED)) \
531 ? grow_outbuf ((OBUF), (NEEDED)) : 0)
533 struct file_name_list
535 struct file_name_list
*next
;
537 /* If the following is nonzero, it is a macro name.
538 Don't include the file again if that macro is defined. */
539 U_CHAR
*control_macro
;
542 /* #include "file" looks in source file dir, then stack. */
543 /* #include <file> just looks in the stack. */
544 /* -I directories are added to the end, then the defaults are added. */
545 static struct default_include
{ char *fname
; int cplusplus
; } include_defaults_array
[]
546 #ifdef INCLUDE_DEFAULTS
550 /* Pick up GNU C++ specific include files. */
551 { GPLUSPLUS_INCLUDE_DIR
, 1},
553 /* This is the dir for fixincludes. Put it just before
554 the files that we fix. */
555 { GCC_INCLUDE_DIR
, 0},
556 /* For cross-compilation, this dir name is generated
557 automatically in Makefile.in. */
558 { CROSS_INCLUDE_DIR
, 0 },
559 /* This is another place that the target system's headers might be. */
560 { TOOL_INCLUDE_DIR
, 0},
561 #else /* not CROSS_COMPILE */
562 /* This should be /use/local/include and should come before
563 the fixincludes-fixed header files. */
564 { LOCAL_INCLUDE_DIR
, 0},
565 /* This is here ahead of GCC_INCLUDE_DIR because assert.h goes here.
566 Likewise, behind LOCAL_INCLUDE_DIR, where glibc puts its assert.h. */
567 { TOOL_INCLUDE_DIR
, 0},
568 /* This is the dir for fixincludes. Put it just before
569 the files that we fix. */
570 { GCC_INCLUDE_DIR
, 0},
571 /* Some systems have an extra dir of include files. */
572 #ifdef SYSTEM_INCLUDE_DIR
573 { SYSTEM_INCLUDE_DIR
, 0},
575 { STANDARD_INCLUDE_DIR
, 0},
576 #endif /* not CROSS_COMPILE */
579 #endif /* no INCLUDE_DEFAULTS */
581 /* The code looks at the defaults through this pointer, rather than through
582 the constant structure above. This pointer gets changed if an environment
583 variable specifies other defaults. */
584 static struct default_include
*include_defaults
= include_defaults_array
;
586 static struct file_name_list
*include
= 0; /* First dir to search */
587 /* First dir to search for <file> */
588 /* This is the first element to use for #include <...>.
589 If it is 0, use the entire chain for such includes. */
590 static struct file_name_list
*first_bracket_include
= 0;
591 /* This is the first element in the chain that corresponds to
592 a directory of system header files. */
593 static struct file_name_list
*first_system_include
= 0;
594 static struct file_name_list
*last_include
= 0; /* Last in chain */
596 /* Chain of include directories to put at the end of the other chain. */
597 static struct file_name_list
*after_include
= 0;
598 static struct file_name_list
*last_after_include
= 0; /* Last in chain */
600 /* List of included files that contained #pragma once. */
601 static struct file_name_list
*dont_repeat_files
= 0;
603 /* List of other included files.
604 If ->control_macro if nonzero, the file had a #ifndef
605 around the entire contents, and ->control_macro gives the macro name. */
606 static struct file_name_list
*all_include_files
= 0;
608 /* Directory prefix that should replace `/usr' in the standard
609 include file directories. */
610 static char *include_prefix
;
612 /* Global list of strings read in from precompiled files. This list
613 is kept in the order the strings are read in, with new strings being
614 added at the end through stringlist_tailp. We use this list to output
615 the strings at the end of the run.
617 static STRINGDEF
*stringlist
;
618 static STRINGDEF
**stringlist_tailp
= &stringlist
;
621 /* Structure returned by create_definition */
622 typedef struct macrodef MACRODEF
;
625 struct definition
*defn
;
630 static struct macrodef
create_definition ();
633 /* Structure allocated for every #define. For a simple replacement
636 nargs = -1, the `pattern' list is null, and the expansion is just
637 the replacement text. Nargs = 0 means a functionlike macro with no args,
639 #define getchar() getc (stdin) .
640 When there are args, the expansion is the replacement text with the
641 args squashed out, and the reflist is a list describing how to
642 build the output from the input: e.g., "3 chars, then the 1st arg,
643 then 9 chars, then the 3rd arg, then 0 chars, then the 2nd arg".
644 The chars here come from the expansion. Whatever is left of the
645 expansion after the last arg-occurrence is copied after that arg.
646 Note that the reflist can be arbitrarily long---
647 its length depends on the number of times the arguments appear in
648 the replacement text, not how many args there are. Example:
649 #define f(x) x+x+x+x+x+x+x would have replacement text "++++++" and
651 { (0, 1), (1, 1), (1, 1), ..., (1, 1), NULL }
652 where (x, y) means (nchars, argno). */
654 typedef struct definition DEFINITION
;
657 int length
; /* length of expansion string */
658 int predefined
; /* True if the macro was builtin or */
659 /* came from the command line */
661 int line
; /* Line number of definition */
662 char *file
; /* File of definition */
663 char rest_args
; /* Nonzero if last arg. absorbs the rest */
665 struct reflist
*next
;
666 char stringify
; /* nonzero if this arg was preceded by a
668 char raw_before
; /* Nonzero if a ## operator before arg. */
669 char raw_after
; /* Nonzero if a ## operator after arg. */
670 char rest_args
; /* Nonzero if this arg. absorbs the rest */
671 int nchars
; /* Number of literal chars to copy before
672 this arg occurrence. */
673 int argno
; /* Number of arg to substitute (origin-0) */
676 /* Names of macro args, concatenated in reverse order
677 with comma-space between them.
678 The only use of this is that we warn on redefinition
679 if this differs between the old and new definitions. */
684 /* different kinds of things that can appear in the value field
685 of a hash node. Actually, this may be useless now. */
694 * special extension string that can be added to the last macro argument to
695 * allow it to absorb the "rest" of the arguments when expanded. Ex:
696 * #define wow(a, b...) process (b, a, b)
697 * { wow (1, 2, 3); } -> { process (2, 3, 1, 2, 3); }
698 * { wow (one, two); } -> { process (two, one, two); }
699 * if this "rest_arg" is used with the concat token '##' and if it is not
700 * supplied then the token attached to with ## will not be outputted. Ex:
701 * #define wow (a, b...) process (b ## , a, ## b)
702 * { wow (1, 2); } -> { process (2, 1, 2); }
703 * { wow (one); } -> { process (one); {
705 static char rest_extension
[] = "...";
706 #define REST_EXTENSION_LENGTH (sizeof (rest_extension) - 1)
708 /* The structure of a node in the hash table. The hash table
709 has entries for all tokens defined by #define commands (type T_MACRO),
710 plus some special tokens like __LINE__ (these each have their own
711 type, and the appropriate code is run when that type of node is seen.
712 It does not contain control words like "#define", which are recognized
713 by a separate piece of code. */
715 /* different flavors of hash nodes --- also used in keyword table */
717 T_DEFINE
= 1, /* the `#define' keyword */
718 T_INCLUDE
, /* the `#include' keyword */
719 T_INCLUDE_NEXT
, /* the `#include_next' keyword */
720 T_IMPORT
, /* the `#import' keyword */
721 T_IFDEF
, /* the `#ifdef' keyword */
722 T_IFNDEF
, /* the `#ifndef' keyword */
723 T_IF
, /* the `#if' keyword */
724 T_ELSE
, /* `#else' */
725 T_PRAGMA
, /* `#pragma' */
726 T_ELIF
, /* `#elif' */
727 T_UNDEF
, /* `#undef' */
728 T_LINE
, /* `#line' */
729 T_ERROR
, /* `#error' */
730 T_WARNING
, /* `#warning' */
731 T_ENDIF
, /* `#endif' */
732 T_SCCS
, /* `#sccs', used on system V. */
733 T_IDENT
, /* `#ident', used on system V. */
734 T_ASSERT
, /* `#assert', taken from system V. */
735 T_UNASSERT
, /* `#unassert', taken from system V. */
736 T_SPECLINE
, /* special symbol `__LINE__' */
737 T_DATE
, /* `__DATE__' */
738 T_FILE
, /* `__FILE__' */
739 T_BASE_FILE
, /* `__BASE_FILE__' */
740 T_INCLUDE_LEVEL
, /* `__INCLUDE_LEVEL__' */
741 T_VERSION
, /* `__VERSION__' */
742 T_SIZE_TYPE
, /* `__SIZE_TYPE__' */
743 T_PTRDIFF_TYPE
, /* `__PTRDIFF_TYPE__' */
744 T_WCHAR_TYPE
, /* `__WCHAR_TYPE__' */
745 T_USER_LABEL_PREFIX_TYPE
, /* `__USER_LABEL_PREFIX__' */
746 T_REGISTER_PREFIX_TYPE
, /* `__REGISTER_PREFIX__' */
747 T_TIME
, /* `__TIME__' */
748 T_CONST
, /* Constant value, used by `__STDC__' */
749 T_MACRO
, /* macro defined by `#define' */
750 T_DISABLED
, /* macro temporarily turned off for rescan */
751 T_SPEC_DEFINED
, /* special `defined' macro for use in #if statements */
752 T_PCSTRING
, /* precompiled string (hashval is KEYDEF *) */
753 T_UNUSED
/* Used for something not defined. */
757 struct hashnode
*next
; /* double links for easy deletion */
758 struct hashnode
*prev
;
759 struct hashnode
**bucket_hdr
; /* also, a back pointer to this node's hash
760 chain is kept, in case the node is the head
761 of the chain and gets deleted. */
762 enum node_type type
; /* type of special token */
763 int length
; /* length of token, for quick comparison */
764 U_CHAR
*name
; /* the actual name */
765 union hashval value
; /* pointer to expansion, or whatever */
768 typedef struct hashnode HASHNODE
;
770 /* Some definitions for the hash table. The hash function MUST be
771 computed as shown in hashf () below. That is because the rescan
772 loop computes the hash value `on the fly' for most tokens,
773 in order to avoid the overhead of a lot of procedure calls to
774 the hashf () function. Hashf () only exists for the sake of
775 politeness, for use when speed isn't so important. */
777 #define HASHSIZE 1403
778 static HASHNODE
*hashtab
[HASHSIZE
];
779 #define HASHSTEP(old, c) ((old << 2) + c)
780 #define MAKE_POS(v) (v & 0x7fffffff) /* make number positive */
782 /* Symbols to predefine. */
784 #ifdef CPP_PREDEFINES
785 static char *predefs
= CPP_PREDEFINES
;
787 static char *predefs
= "";
790 /* We let tm.h override the types used here, to handle trivial differences
791 such as the choice of unsigned int or long unsigned int for size_t.
792 When machines start needing nontrivial differences in the size type,
793 it would be best to do something here to figure out automatically
794 from other information what type to use. */
796 /* The string value for __size_type__. */
799 #define SIZE_TYPE "long unsigned int"
802 /* The string value for __ptrdiff_type__. */
805 #define PTRDIFF_TYPE "long int"
808 /* The string value for __wchar_type__. */
811 #define WCHAR_TYPE "int"
814 /* The string value for __USER_LABEL_PREFIX__ */
816 #ifndef USER_LABEL_PREFIX
817 #define USER_LABEL_PREFIX ""
820 /* The string value for __REGISTER_PREFIX__ */
822 #ifndef REGISTER_PREFIX
823 #define REGISTER_PREFIX ""
826 /* In the definition of a #assert name, this structure forms
827 a list of the individual values asserted.
828 Each value is itself a list of "tokens".
829 These are strings that are compared by name. */
831 struct tokenlist_list
{
832 struct tokenlist_list
*next
;
833 struct arglist
*tokens
;
836 struct assertion_hashnode
{
837 struct assertion_hashnode
*next
; /* double links for easy deletion */
838 struct assertion_hashnode
*prev
;
839 /* also, a back pointer to this node's hash
840 chain is kept, in case the node is the head
841 of the chain and gets deleted. */
842 struct assertion_hashnode
**bucket_hdr
;
843 int length
; /* length of token, for quick comparison */
844 U_CHAR
*name
; /* the actual name */
845 /* List of token-sequences. */
846 struct tokenlist_list
*value
;
849 typedef struct assertion_hashnode ASSERTION_HASHNODE
;
851 /* Some definitions for the hash table. The hash function MUST be
852 computed as shown in hashf below. That is because the rescan
853 loop computes the hash value `on the fly' for most tokens,
854 in order to avoid the overhead of a lot of procedure calls to
855 the hashf function. hashf only exists for the sake of
856 politeness, for use when speed isn't so important. */
858 #define ASSERTION_HASHSIZE 37
859 static ASSERTION_HASHNODE
*assertion_hashtab
[ASSERTION_HASHSIZE
];
861 /* Nonzero means inhibit macroexpansion of what seem to be
862 assertion tests, in rescan. For #if. */
863 static int assertions_flag
;
865 /* `struct directive' defines one #-directive, including how to handle it. */
868 int length
; /* Length of name */
869 int (*func
)(); /* Function to handle directive */
870 char *name
; /* Name of directive */
871 enum node_type type
; /* Code which describes which directive. */
872 char angle_brackets
; /* Nonzero => <...> is special. */
873 char traditional_comments
; /* Nonzero: keep comments if -traditional. */
874 char pass_thru
; /* Copy preprocessed directive to output file. */
877 /* Here is the actual list of #-directives, most-often-used first. */
879 static struct directive directive_table
[] = {
880 { 6, do_define
, "define", T_DEFINE
, 0, 1},
881 { 2, do_if
, "if", T_IF
},
882 { 5, do_xifdef
, "ifdef", T_IFDEF
},
883 { 6, do_xifdef
, "ifndef", T_IFNDEF
},
884 { 5, do_endif
, "endif", T_ENDIF
},
885 { 4, do_else
, "else", T_ELSE
},
886 { 4, do_elif
, "elif", T_ELIF
},
887 { 4, do_line
, "line", T_LINE
},
888 { 7, do_include
, "include", T_INCLUDE
, 1},
889 { 12, do_include
, "include_next", T_INCLUDE_NEXT
, 1},
890 { 6, do_include
, "import", T_IMPORT
, 1},
891 { 5, do_undef
, "undef", T_UNDEF
},
892 { 5, do_error
, "error", T_ERROR
},
893 { 7, do_warning
, "warning", T_WARNING
},
894 #ifdef SCCS_DIRECTIVE
895 { 4, do_sccs
, "sccs", T_SCCS
},
897 { 6, do_pragma
, "pragma", T_PRAGMA
, 0, 0, 1},
898 { 5, do_ident
, "ident", T_IDENT
, 0, 0, 1},
899 { 6, do_assert
, "assert", T_ASSERT
},
900 { 8, do_unassert
, "unassert", T_UNASSERT
},
901 { -1, 0, "", T_UNUSED
},
904 /* When a directive handler is called,
905 this points to the # that started the directive. */
906 U_CHAR
*directive_start
;
908 /* table to tell if char can be part of a C identifier. */
909 U_CHAR is_idchar
[256];
910 /* table to tell if char can be first char of a c identifier. */
911 U_CHAR is_idstart
[256];
912 /* table to tell if c is horizontal space. */
913 U_CHAR is_hor_space
[256];
914 /* table to tell if c is horizontal or vertical space. */
915 static U_CHAR is_space
[256];
917 #define SKIP_WHITE_SPACE(p) do { while (is_hor_space[*p]) p++; } while (0)
918 #define SKIP_ALL_WHITE_SPACE(p) do { while (is_space[*p]) p++; } while (0)
920 static int errors
= 0; /* Error counter for exit code */
922 /* Name of output file, for error messages. */
923 static char *out_fname
;
925 /* Zero means dollar signs are punctuation.
926 -$ stores 0; -traditional may store 1. Default is 1 for VMS, 0 otherwise.
927 This must be 0 for correct processing of this ANSI C program:
929 #define lose(b) foo (b)
932 static int dollars_in_ident
;
933 #ifndef DOLLARS_IN_IDENTIFIERS
934 #define DOLLARS_IN_IDENTIFIERS 1
937 static FILE_BUF
expand_to_temp_buffer ();
939 static DEFINITION
*collect_expansion ();
941 /* Stack of conditionals currently in progress
942 (including both successful and failing conditionals). */
945 struct if_stack
*next
; /* for chaining to the next stack frame */
946 char *fname
; /* copied from input when frame is made */
947 int lineno
; /* similarly */
948 int if_succeeded
; /* true if a leg of this if-group
949 has been passed through rescan */
950 U_CHAR
*control_macro
; /* For #ifndef at start of file,
951 this is the macro name tested. */
952 enum node_type type
; /* type of last directive seen in this group */
954 typedef struct if_stack IF_STACK_FRAME
;
955 static IF_STACK_FRAME
*if_stack
= NULL
;
957 /* Buffer of -M output. */
958 static char *deps_buffer
;
960 /* Number of bytes allocated in above. */
961 static int deps_allocated_size
;
963 /* Number of bytes used. */
964 static int deps_size
;
966 /* Number of bytes since the last newline. */
967 static int deps_column
;
969 /* Nonzero means -I- has been seen,
970 so don't look for #include "foo" the source-file directory. */
971 static int ignore_srcdir
;
984 char **pend_files
= (char **) xmalloc (argc
* sizeof (char *));
985 char **pend_defs
= (char **) xmalloc (argc
* sizeof (char *));
986 char **pend_undefs
= (char **) xmalloc (argc
* sizeof (char *));
987 char **pend_assertions
= (char **) xmalloc (argc
* sizeof (char *));
988 char **pend_includes
= (char **) xmalloc (argc
* sizeof (char *));
990 /* Record the option used with each element of pend_assertions.
991 This is preparation for supporting more than one option for making
993 char **pend_assertion_options
= (char **) xmalloc (argc
* sizeof (char *));
994 int inhibit_predefs
= 0;
995 int no_standard_includes
= 0;
996 int no_standard_cplusplus_includes
= 0;
997 int missing_newline
= 0;
999 /* Non-0 means don't output the preprocessed program. */
1000 int inhibit_output
= 0;
1002 /* File name which deps are being written to.
1003 This is 0 if deps are being written to stdout. */
1004 char *deps_file
= 0;
1005 /* Fopen file mode to open deps_file with. */
1006 char *deps_mode
= "a";
1007 /* Stream on which to print the dependency information. */
1008 FILE *deps_stream
= 0;
1009 /* Target-name to write with the dependency information. */
1010 char *deps_target
= 0;
1013 /* Get rid of any avoidable limit on stack size. */
1017 /* Set the stack limit huge so that alloca (particularly stringtab
1018 * in dbxread.c) does not fail. */
1019 getrlimit (RLIMIT_STACK
, &rlim
);
1020 rlim
.rlim_cur
= rlim
.rlim_max
;
1021 setrlimit (RLIMIT_STACK
, &rlim
);
1023 #endif /* RLIMIT_STACK defined */
1025 signal (SIGPIPE
, pipe_closed
);
1027 p
= argv
[0] + strlen (argv
[0]);
1028 while (p
!= argv
[0] && p
[-1] != '/') --p
;
1033 /* Remove directories from PROGNAME. */
1036 progname
= savestring (argv
[0]);
1038 if (!(s
= rindex (progname
, ']')))
1039 s
= rindex (progname
, ':');
1041 strcpy (progname
, s
+1);
1042 if (s
= rindex (progname
, '.'))
1050 /* Initialize is_idchar to allow $. */
1051 dollars_in_ident
= 1;
1052 initialize_char_syntax ();
1053 dollars_in_ident
= DOLLARS_IN_IDENTIFIERS
> 0;
1055 no_line_commands
= 0;
1057 dump_macros
= dump_none
;
1060 cplusplus_comments
= 0;
1062 bzero (pend_files
, argc
* sizeof (char *));
1063 bzero (pend_defs
, argc
* sizeof (char *));
1064 bzero (pend_undefs
, argc
* sizeof (char *));
1065 bzero (pend_assertions
, argc
* sizeof (char *));
1066 bzero (pend_includes
, argc
* sizeof (char *));
1068 /* Process switches and find input file name. */
1070 for (i
= 1; i
< argc
; i
++) {
1071 if (argv
[i
][0] != '-') {
1072 if (out_fname
!= NULL
)
1073 fatal ("Usage: %s [switches] input output", argv
[0]);
1074 else if (in_fname
!= NULL
)
1075 out_fname
= argv
[i
];
1079 switch (argv
[i
][1]) {
1082 if (!strcmp (argv
[i
], "-include")) {
1084 fatal ("Filename missing after `-include' option");
1086 pend_includes
[i
] = argv
[i
+1], i
++;
1088 if (!strcmp (argv
[i
], "-imacros")) {
1090 fatal ("Filename missing after `-imacros' option");
1092 pend_files
[i
] = argv
[i
+1], i
++;
1094 if (!strcmp (argv
[i
], "-iprefix")) {
1096 fatal ("Filename missing after `-iprefix' option");
1098 include_prefix
= argv
[++i
];
1100 /* Add directory to end of path for includes,
1101 with the default prefix at the front of its name. */
1102 if (!strcmp (argv
[i
], "-iwithprefix")) {
1103 struct file_name_list
*dirtmp
;
1105 dirtmp
= (struct file_name_list
*)
1106 xmalloc (sizeof (struct file_name_list
));
1107 dirtmp
->next
= 0; /* New one goes on the end */
1108 dirtmp
->control_macro
= 0;
1110 fatal ("Directory name missing after `-iwithprefix' option");
1112 dirtmp
->fname
= (char *) xmalloc (strlen (argv
[i
+1])
1113 + strlen (include_prefix
) + 1);
1114 strcpy (dirtmp
->fname
, include_prefix
);
1115 strcat (dirtmp
->fname
, argv
[++i
]);
1117 if (after_include
== 0)
1118 after_include
= dirtmp
;
1120 last_after_include
->next
= dirtmp
;
1121 last_after_include
= dirtmp
; /* Tail follows the last one */
1123 /* Add directory to end of path for includes. */
1124 if (!strcmp (argv
[i
], "-idirafter")) {
1125 struct file_name_list
*dirtmp
;
1127 dirtmp
= (struct file_name_list
*)
1128 xmalloc (sizeof (struct file_name_list
));
1129 dirtmp
->next
= 0; /* New one goes on the end */
1130 dirtmp
->control_macro
= 0;
1132 fatal ("Directory name missing after `-idirafter' option");
1134 dirtmp
->fname
= argv
[++i
];
1136 if (after_include
== 0)
1137 after_include
= dirtmp
;
1139 last_after_include
->next
= dirtmp
;
1140 last_after_include
= dirtmp
; /* Tail follows the last one */
1145 if (out_fname
!= NULL
)
1146 fatal ("Output filename specified twice");
1148 fatal ("Filename missing after -o option");
1149 out_fname
= argv
[++i
];
1150 if (!strcmp (out_fname
, "-"))
1155 if (!strcmp (argv
[i
], "-pedantic"))
1157 else if (!strcmp (argv
[i
], "-pedantic-errors")) {
1159 pedantic_errors
= 1;
1160 } else if (!strcmp (argv
[i
], "-pcp")) {
1161 char *pcp_fname
= argv
[++i
];
1163 ((pcp_fname
[0] != '-' || pcp_fname
[1] != '\0')
1164 ? fopen (pcp_fname
, "w")
1165 : fdopen (dup (fileno (stdout
)), "w"));
1166 if (pcp_outfile
== 0)
1167 pfatal_with_name (pcp_fname
);
1173 if (!strcmp (argv
[i
], "-traditional")) {
1175 if (dollars_in_ident
> 0)
1176 dollars_in_ident
= 1;
1177 } else if (!strcmp (argv
[i
], "-trigraphs")) {
1183 if (! strcmp (argv
[i
], "-lang-c"))
1184 cplusplus
= 0, cplusplus_comments
= 0, objc
= 0;
1185 if (! strcmp (argv
[i
], "-lang-c++"))
1186 cplusplus
= 1, cplusplus_comments
= 1, objc
= 0;
1187 if (! strcmp (argv
[i
], "-lang-objc"))
1188 objc
= 1, cplusplus
= 0, cplusplus_comments
= 1;
1189 if (! strcmp (argv
[i
], "-lang-objc++"))
1190 objc
= 1, cplusplus
= 1, cplusplus_comments
= 1;
1191 if (! strcmp (argv
[i
], "-lang-asm"))
1193 if (! strcmp (argv
[i
], "-lint"))
1198 cplusplus
= 1, cplusplus_comments
= 1;
1202 inhibit_warnings
= 1;
1206 if (!strcmp (argv
[i
], "-Wtrigraphs"))
1208 else if (!strcmp (argv
[i
], "-Wno-trigraphs"))
1210 else if (!strcmp (argv
[i
], "-Wcomment"))
1212 else if (!strcmp (argv
[i
], "-Wno-comment"))
1214 else if (!strcmp (argv
[i
], "-Wcomments"))
1216 else if (!strcmp (argv
[i
], "-Wno-comments"))
1218 else if (!strcmp (argv
[i
], "-Wtraditional"))
1220 else if (!strcmp (argv
[i
], "-Wno-traditional"))
1222 else if (!strcmp (argv
[i
], "-Wimport"))
1224 else if (!strcmp (argv
[i
], "-Wno-import"))
1226 else if (!strcmp (argv
[i
], "-Werror"))
1227 warnings_are_errors
= 1;
1228 else if (!strcmp (argv
[i
], "-Wno-error"))
1229 warnings_are_errors
= 0;
1230 else if (!strcmp (argv
[i
], "-Wall"))
1238 if (!strcmp (argv
[i
], "-M"))
1240 else if (!strcmp (argv
[i
], "-MM"))
1242 else if (!strcmp (argv
[i
], "-MD"))
1244 else if (!strcmp (argv
[i
], "-MMD"))
1246 /* For -MD and -MMD options, write deps on file named by next arg. */
1247 if (!strcmp (argv
[i
], "-MD")
1248 || !strcmp (argv
[i
], "-MMD")) {
1250 deps_file
= argv
[i
];
1253 /* For -M and -MM, write deps on standard output
1254 and suppress the usual output. */
1255 deps_stream
= stdout
;
1262 char *p
= argv
[i
] + 2;
1265 /* Arg to -d specifies what parts of macros to dump */
1268 dump_macros
= dump_only
;
1272 dump_macros
= dump_names
;
1275 dump_macros
= dump_definitions
;
1283 if (argv
[i
][2] == '3')
1288 fprintf (stderr
, "GNU CPP version %s", version_string
);
1289 #ifdef TARGET_VERSION
1292 fprintf (stderr
, "\n");
1296 print_include_names
= 1;
1303 if (argv
[i
][2] != 0)
1305 else if (i
+ 1 == argc
)
1306 fatal ("Macro name missing after -D option");
1318 if (argv
[i
][2] != 0)
1320 else if (i
+ 1 == argc
)
1321 fatal ("Assertion missing after -A option");
1325 if (!strcmp (p
, "-")) {
1326 /* -A- eliminates all predefined macros and assertions.
1327 Let's include also any that were specified earlier
1328 on the command line. That way we can get rid of any
1329 that were passed automatically in from GCC. */
1331 inhibit_predefs
= 1;
1332 for (j
= 0; j
< i
; j
++)
1333 pend_defs
[j
] = pend_assertions
[j
] = 0;
1335 pend_assertions
[i
] = p
;
1336 pend_assertion_options
[i
] = "-A";
1341 case 'U': /* JF #undef something */
1342 if (argv
[i
][2] != 0)
1343 pend_undefs
[i
] = argv
[i
] + 2;
1344 else if (i
+ 1 == argc
)
1345 fatal ("Macro name missing after -U option");
1347 pend_undefs
[i
] = argv
[i
+1], i
++;
1351 put_out_comments
= 1;
1354 case 'E': /* -E comes from cc -E; ignore it. */
1358 no_line_commands
= 1;
1361 case '$': /* Don't include $ in identifiers. */
1362 dollars_in_ident
= 0;
1365 case 'I': /* Add directory to path for includes. */
1367 struct file_name_list
*dirtmp
;
1369 if (! ignore_srcdir
&& !strcmp (argv
[i
] + 2, "-")) {
1371 /* Don't use any preceding -I directories for #include <...>. */
1372 first_bracket_include
= 0;
1375 dirtmp
= (struct file_name_list
*)
1376 xmalloc (sizeof (struct file_name_list
));
1377 dirtmp
->next
= 0; /* New one goes on the end */
1378 dirtmp
->control_macro
= 0;
1379 if (argv
[i
][2] != 0)
1380 dirtmp
->fname
= argv
[i
] + 2;
1381 else if (i
+ 1 == argc
)
1382 fatal ("Directory name missing after -I option");
1384 dirtmp
->fname
= argv
[++i
];
1385 append_include_chain (dirtmp
, dirtmp
);
1391 if (!strcmp (argv
[i
], "-nostdinc"))
1392 /* -nostdinc causes no default include directories.
1393 You must specify all include-file directories with -I. */
1394 no_standard_includes
= 1;
1395 else if (!strcmp (argv
[i
], "-nostdinc++"))
1396 /* -nostdinc++ causes no default C++-specific include directories. */
1397 no_standard_cplusplus_includes
= 1;
1398 else if (!strcmp (argv
[i
], "-noprecomp"))
1403 /* Sun compiler passes undocumented switch "-undef".
1404 Let's assume it means to inhibit the predefined symbols. */
1405 inhibit_predefs
= 1;
1408 case '\0': /* JF handle '-' as file name meaning stdin or stdout */
1409 if (in_fname
== NULL
) {
1412 } else if (out_fname
== NULL
) {
1415 } /* else fall through into error */
1418 fatal ("Invalid option `%s'", argv
[i
]);
1423 /* Add dirs from CPATH after dirs from -I. */
1424 /* There seems to be confusion about what CPATH should do,
1425 so for the moment it is not documented. */
1426 /* Some people say that CPATH should replace the standard include dirs,
1427 but that seems pointless: it comes before them, so it overrides them
1429 p
= (char *) getenv ("CPATH");
1430 if (p
!= 0 && ! no_standard_includes
)
1433 /* Now that dollars_in_ident is known, initialize is_idchar. */
1434 initialize_char_syntax ();
1436 /* Initialize output buffer */
1438 outbuf
.buf
= (U_CHAR
*) xmalloc (OUTBUF_SIZE
);
1439 outbuf
.bufp
= outbuf
.buf
;
1440 outbuf
.length
= OUTBUF_SIZE
;
1442 /* Do partial setup of input buffer for the sake of generating
1443 early #line directives (when -g is in effect). */
1445 fp
= &instack
[++indepth
];
1446 if (in_fname
== NULL
)
1448 fp
->nominal_fname
= fp
->fname
= in_fname
;
1451 /* Install __LINE__, etc. Must follow initialize_char_syntax
1452 and option processing. */
1453 initialize_builtins (fp
, &outbuf
);
1455 /* Do standard #defines and assertions
1456 that identify system and machine type. */
1458 if (!inhibit_predefs
) {
1459 char *p
= (char *) alloca (strlen (predefs
) + 1);
1460 strcpy (p
, predefs
);
1463 while (*p
== ' ' || *p
== '\t')
1465 /* Handle -D options. */
1466 if (p
[0] == '-' && p
[1] == 'D') {
1468 while (*p
&& *p
!= ' ' && *p
!= '\t')
1473 output_line_command (fp
, &outbuf
, 0, same_file
);
1474 make_definition (q
, &outbuf
);
1475 while (*p
== ' ' || *p
== '\t')
1477 } else if (p
[0] == '-' && p
[1] == 'A') {
1478 /* Handle -A options (assertions). */
1487 past_name
= assertion
;
1488 /* Locate end of name. */
1489 while (*past_name
&& *past_name
!= ' '
1490 && *past_name
!= '\t' && *past_name
!= '(')
1492 /* Locate `(' at start of value. */
1494 while (*value
&& (*value
== ' ' || *value
== '\t'))
1496 if (*value
++ != '(')
1498 while (*value
&& (*value
== ' ' || *value
== '\t'))
1501 /* Locate end of value. */
1502 while (*past_value
&& *past_value
!= ' '
1503 && *past_value
!= '\t' && *past_value
!= ')')
1505 termination
= past_value
;
1506 while (*termination
&& (*termination
== ' ' || *termination
== '\t'))
1508 if (*termination
++ != ')')
1510 if (*termination
&& *termination
!= ' ' && *termination
!= '\t')
1512 /* Temporarily null-terminate the value. */
1513 save_char
= *termination
;
1514 *termination
= '\0';
1515 /* Install the assertion. */
1516 make_assertion ("-A", assertion
);
1517 *termination
= (char) save_char
;
1519 while (*p
== ' ' || *p
== '\t')
1527 /* Now handle the command line options. */
1529 /* Do -U's, -D's and -A's in the order they were seen. */
1530 for (i
= 1; i
< argc
; i
++) {
1531 if (pend_undefs
[i
]) {
1533 output_line_command (fp
, &outbuf
, 0, same_file
);
1534 make_undef (pend_undefs
[i
], &outbuf
);
1538 output_line_command (fp
, &outbuf
, 0, same_file
);
1539 make_definition (pend_defs
[i
], &outbuf
);
1541 if (pend_assertions
[i
])
1542 make_assertion (pend_assertion_options
[i
], pend_assertions
[i
]);
1545 done_initializing
= 1;
1547 { /* read the appropriate environment variable and if it exists
1548 replace include_defaults with the listed path. */
1550 switch ((objc
<< 1) + cplusplus
)
1553 epath
= getenv ("C_INCLUDE_PATH");
1556 epath
= getenv ("CPLUS_INCLUDE_PATH");
1559 epath
= getenv ("OBJC_INCLUDE_PATH");
1562 epath
= getenv ("OBJCPLUS_INCLUDE_PATH");
1565 /* If the environment var for this language is set,
1566 add to the default list of include directories. */
1568 char *nstore
= (char *) alloca (strlen (epath
) + 2);
1570 char *startp
, *endp
;
1572 for (num_dirs
= 1, startp
= epath
; *startp
; startp
++)
1573 if (*startp
== PATH_SEPARATOR
)
1576 = (struct default_include
*) xmalloc ((num_dirs
1577 * sizeof (struct default_include
))
1578 + sizeof (include_defaults_array
));
1579 startp
= endp
= epath
;
1582 /* Handle cases like c:/usr/lib:d:/gcc/lib */
1583 if ((*endp
== PATH_SEPARATOR
1584 #if 0 /* Obsolete, now that we use semicolons as the path separator. */
1586 && (endp
-startp
!= 1 || !isalpha (*startp
))
1591 strncpy (nstore
, startp
, endp
-startp
);
1593 strcpy (nstore
, ".");
1595 nstore
[endp
-startp
] = '\0';
1597 include_defaults
[num_dirs
].fname
= savestring (nstore
);
1598 include_defaults
[num_dirs
].cplusplus
= cplusplus
;
1602 endp
= startp
= endp
+ 1;
1606 /* Put the usual defaults back in at the end. */
1607 bcopy (include_defaults_array
, &include_defaults
[num_dirs
],
1608 sizeof (include_defaults_array
));
1612 first_system_include
= 0;
1613 /* Unless -fnostdinc,
1614 tack on the standard include file dirs to the specified list */
1615 if (!no_standard_includes
) {
1616 struct default_include
*p
= include_defaults
;
1617 char *specd_prefix
= include_prefix
;
1618 char *default_prefix
= savestring (GCC_INCLUDE_DIR
);
1619 int default_len
= 0;
1620 /* Remove the `include' from /usr/local/lib/gcc.../include. */
1621 if (!strcmp (default_prefix
+ strlen (default_prefix
) - 8, "/include")) {
1622 default_len
= strlen (default_prefix
) - 7;
1623 default_prefix
[default_len
] = 0;
1625 /* Search "translated" versions of GNU directories.
1626 These have /usr/local/lib/gcc... replaced by specd_prefix. */
1627 if (specd_prefix
!= 0 && default_len
!= 0)
1628 for (p
= include_defaults
; p
->fname
; p
++) {
1629 /* Some standard dirs are only for C++. */
1630 if (!p
->cplusplus
|| (cplusplus
&& !no_standard_cplusplus_includes
)) {
1631 /* Does this dir start with the prefix? */
1632 if (!strncmp (p
->fname
, default_prefix
, default_len
)) {
1633 /* Yes; change prefix and add to search list. */
1634 struct file_name_list
*new
1635 = (struct file_name_list
*) xmalloc (sizeof (struct file_name_list
));
1636 int this_len
= strlen (specd_prefix
) + strlen (p
->fname
) - default_len
;
1637 char *str
= (char *) xmalloc (this_len
+ 1);
1638 strcpy (str
, specd_prefix
);
1639 strcat (str
, p
->fname
+ default_len
);
1641 new->control_macro
= 0;
1642 append_include_chain (new, new);
1643 if (first_system_include
== 0)
1644 first_system_include
= new;
1648 /* Search ordinary names for GNU include directories. */
1649 for (p
= include_defaults
; p
->fname
; p
++) {
1650 /* Some standard dirs are only for C++. */
1651 if (!p
->cplusplus
|| (cplusplus
&& !no_standard_cplusplus_includes
)) {
1652 struct file_name_list
*new
1653 = (struct file_name_list
*) xmalloc (sizeof (struct file_name_list
));
1654 new->control_macro
= 0;
1655 new->fname
= p
->fname
;
1656 append_include_chain (new, new);
1657 if (first_system_include
== 0)
1658 first_system_include
= new;
1663 /* Tack the after_include chain at the end of the include chain. */
1664 append_include_chain (after_include
, last_after_include
);
1665 if (first_system_include
== 0)
1666 first_system_include
= after_include
;
1668 /* Scan the -imacros files before the main input.
1669 Much like #including them, but with no_output set
1670 so that only their macro definitions matter. */
1673 for (i
= 1; i
< argc
; i
++)
1674 if (pend_files
[i
]) {
1675 int fd
= open (pend_files
[i
], O_RDONLY
, 0666);
1677 perror_with_name (pend_files
[i
]);
1678 return FAILURE_EXIT_CODE
;
1680 finclude (fd
, pend_files
[i
], &outbuf
, 0, NULL_PTR
);
1684 /* Copy the entire contents of the main input file into
1685 the stacked input buffer previously allocated for it. */
1687 /* JF check for stdin */
1688 if (in_fname
== NULL
|| *in_fname
== 0) {
1691 } else if ((f
= open (in_fname
, O_RDONLY
, 0666)) < 0)
1694 /* Either of two environment variables can specify output of deps.
1695 Its value is either "OUTPUT_FILE" or "OUTPUT_FILE DEPS_TARGET",
1696 where OUTPUT_FILE is the file to write deps info to
1697 and DEPS_TARGET is the target to mention in the deps. */
1700 && (getenv ("SUNPRO_DEPENDENCIES") != 0
1701 || getenv ("DEPENDENCIES_OUTPUT") != 0)) {
1702 char *spec
= getenv ("DEPENDENCIES_OUTPUT");
1707 spec
= getenv ("SUNPRO_DEPENDENCIES");
1714 /* Find the space before the DEPS_TARGET, if there is one. */
1715 /* This should use index. (mrs) */
1716 while (*s
!= 0 && *s
!= ' ') s
++;
1718 deps_target
= s
+ 1;
1719 output_file
= (char *) xmalloc (s
- spec
+ 1);
1720 bcopy (spec
, output_file
, s
- spec
);
1721 output_file
[s
- spec
] = 0;
1728 deps_file
= output_file
;
1732 /* For -M, print the expected object file name
1733 as the target of this Make-rule. */
1735 deps_allocated_size
= 200;
1736 deps_buffer
= (char *) xmalloc (deps_allocated_size
);
1742 deps_output (deps_target
, 0);
1743 deps_output (":", 0);
1744 } else if (*in_fname
== 0)
1745 deps_output ("-: ", 0);
1750 /* Discard all directory prefixes from P. */
1756 /* Output P, but remove known suffixes. */
1758 if (p
[len
- 2] == '.' && p
[len
- 1] == 'c')
1759 deps_output (p
, len
- 2);
1760 else if (p
[len
- 2] == '.' && p
[len
- 1] == 'C')
1761 deps_output (p
, len
- 2);
1762 else if (p
[len
- 3] == '.'
1763 && p
[len
- 2] == 'c'
1764 && p
[len
- 1] == 'c')
1765 deps_output (p
, len
- 3);
1766 else if (p
[len
- 4] == '.'
1767 && p
[len
- 3] == 'c'
1768 && p
[len
- 2] == 'x'
1769 && p
[len
- 1] == 'x')
1770 deps_output (p
, len
- 4);
1771 else if (p
[len
- 2] == '.' && p
[len
- 1] == 's')
1772 deps_output (p
, len
- 2);
1773 else if (p
[len
- 2] == '.' && p
[len
- 1] == 'S')
1774 deps_output (p
, len
- 2);
1775 else if (p
[len
- 2] == '.' && p
[len
- 1] == 'm')
1776 deps_output (p
, len
- 2);
1779 /* Supply our own suffix. */
1781 deps_output (".o : ", 0);
1783 deps_output (".obj : ", 0);
1785 deps_output (in_fname
, 0);
1786 deps_output (" ", 0);
1790 file_size_and_mode (f
, &st_mode
, &st_size
);
1791 fp
->nominal_fname
= fp
->fname
= in_fname
;
1793 fp
->system_header_p
= 0;
1794 /* JF all this is mine about reading pipes and ttys */
1795 if (! S_ISREG (st_mode
)) {
1796 /* Read input from a file that is not a normal disk file.
1797 We cannot preallocate a buffer with the correct size,
1798 so we must read in the file a piece at the time and make it bigger. */
1806 fp
->buf
= (U_CHAR
*) xmalloc (bsize
+ 2);
1809 cnt
= read (f
, bufp
, bsize
- size
);
1810 if (cnt
< 0) goto perror
; /* error! */
1811 if (cnt
== 0) break; /* End of file */
1814 if (bsize
== size
) { /* Buffer is full! */
1816 fp
->buf
= (U_CHAR
*) xrealloc (fp
->buf
, bsize
+ 2);
1817 bufp
= fp
->buf
+ size
; /* May have moved */
1822 /* Read a file whose size we can determine in advance.
1823 For the sake of VMS, st_size is just an upper bound. */
1826 fp
->buf
= (U_CHAR
*) xmalloc (st_size
+ 2);
1828 while (st_size
> 0) {
1829 i
= read (f
, fp
->buf
+ fp
->length
, st_size
);
1839 fp
->if_stack
= if_stack
;
1841 /* Make sure data ends with a newline. And put a null after it. */
1843 if ((fp
->length
> 0 && fp
->buf
[fp
->length
- 1] != '\n')
1844 /* Backslash-newline at end is not good enough. */
1845 || (fp
->length
> 1 && fp
->buf
[fp
->length
- 2] == '\\')) {
1846 fp
->buf
[fp
->length
++] = '\n';
1847 missing_newline
= 1;
1849 fp
->buf
[fp
->length
] = '\0';
1851 /* Unless inhibited, convert trigraphs in the input. */
1856 /* Now that we know the input file is valid, open the output. */
1858 if (!out_fname
|| !strcmp (out_fname
, ""))
1859 out_fname
= "stdout";
1860 else if (! freopen (out_fname
, "w", stdout
))
1861 pfatal_with_name (out_fname
);
1863 output_line_command (fp
, &outbuf
, 0, same_file
);
1865 /* Scan the -include files before the main input. */
1867 for (i
= 1; i
< argc
; i
++)
1868 if (pend_includes
[i
]) {
1869 int fd
= open (pend_includes
[i
], O_RDONLY
, 0666);
1871 perror_with_name (pend_includes
[i
]);
1872 return FAILURE_EXIT_CODE
;
1874 finclude (fd
, pend_includes
[i
], &outbuf
, 0, NULL_PTR
);
1877 /* Scan the input, processing macros and directives. */
1879 rescan (&outbuf
, 0);
1881 if (missing_newline
)
1884 if (pedantic
&& missing_newline
)
1885 pedwarn ("file does not end in newline");
1887 /* Now we have processed the entire input
1888 Write whichever kind of output has been requested. */
1890 if (dump_macros
== dump_only
)
1892 else if (! inhibit_output
) {
1897 /* Don't actually write the deps file if compilation has failed. */
1899 if (deps_file
&& ! (deps_stream
= fopen (deps_file
, deps_mode
)))
1900 pfatal_with_name (deps_file
);
1901 fputs (deps_buffer
, deps_stream
);
1902 putc ('\n', deps_stream
);
1904 if (ferror (deps_stream
) || fclose (deps_stream
) != 0)
1905 fatal ("I/O error on output");
1910 if (pcp_outfile
&& pcp_outfile
!= stdout
1911 && (ferror (pcp_outfile
) || fclose (pcp_outfile
) != 0))
1912 fatal ("I/O error on `-pcp' output");
1914 if (ferror (stdout
) || fclose (stdout
) != 0)
1915 fatal ("I/O error on output");
1918 exit (FAILURE_EXIT_CODE
);
1919 exit (SUCCESS_EXIT_CODE
);
1922 pfatal_with_name (in_fname
);
1926 /* Given a colon-separated list of file names PATH,
1927 add all the names to the search path for include files. */
1941 struct file_name_list
*dirtmp
;
1943 /* Find the end of this name. */
1944 while (*q
!= 0 && *q
!= PATH_SEPARATOR
) q
++;
1946 /* An empty name in the path stands for the current directory. */
1947 name
= (char *) xmalloc (2);
1951 /* Otherwise use the directory that is named. */
1952 name
= (char *) xmalloc (q
- p
+ 1);
1953 bcopy (p
, name
, q
- p
);
1957 dirtmp
= (struct file_name_list
*)
1958 xmalloc (sizeof (struct file_name_list
));
1959 dirtmp
->next
= 0; /* New one goes on the end */
1960 dirtmp
->control_macro
= 0;
1961 dirtmp
->fname
= name
;
1962 append_include_chain (dirtmp
, dirtmp
);
1964 /* Advance past this name. */
1968 /* Skip the colon. */
1973 /* Pre-C-Preprocessor to translate ANSI trigraph idiocy in BUF
1974 before main CCCP processing. Name `pcp' is also in honor of the
1975 drugs the trigraph designers must have been on.
1977 Using an extra pass through the buffer takes a little extra time,
1978 but is infinitely less hairy than trying to handle trigraphs inside
1979 strings, etc. everywhere, and also makes sure that trigraphs are
1980 only translated in the top level of processing. */
1986 register U_CHAR c
, *fptr
, *bptr
, *sptr
;
1989 fptr
= bptr
= sptr
= buf
->buf
;
1990 while ((sptr
= (U_CHAR
*) index (sptr
, '?')) != NULL
) {
2027 len
= sptr
- fptr
- 2;
2028 if (bptr
!= fptr
&& len
> 0)
2029 bcopy (fptr
, bptr
, len
); /* BSD doc says bcopy () works right
2030 for overlapping strings. In ANSI
2031 C, this will be memmove (). */
2036 len
= buf
->length
- (fptr
- buf
->buf
);
2037 if (bptr
!= fptr
&& len
> 0)
2038 bcopy (fptr
, bptr
, len
);
2039 buf
->length
-= fptr
- bptr
;
2040 buf
->buf
[buf
->length
] = '\0';
2041 if (warn_trigraphs
&& fptr
!= bptr
)
2042 warning ("%d trigraph(s) encountered", (fptr
- bptr
) / 2);
2045 /* Move all backslash-newline pairs out of embarrassing places.
2046 Exchange all such pairs following BP
2047 with any potentially-embarrassing characters that follow them.
2048 Potentially-embarrassing characters are / and *
2049 (because a backslash-newline inside a comment delimiter
2050 would cause it not to be recognized). */
2056 register U_CHAR
*p
= bp
;
2057 register int count
= 0;
2059 /* First count the backslash-newline pairs here. */
2065 else if (p
[1] == '\r' && p
[2] == '\n')
2073 /* What follows the backslash-newlines is not embarrassing. */
2075 if (count
== 0 || (*p
!= '/' && *p
!= '*'))
2078 /* Copy all potentially embarrassing characters
2079 that follow the backslash-newline pairs
2080 down to where the pairs originally started. */
2082 while (*p
== '*' || *p
== '/')
2085 /* Now write the same number of pairs after the embarrassing chars. */
2086 while (count
-- > 0) {
2092 /* Like newline_fix but for use within a directive-name.
2093 Move any backslash-newlines up past any following symbol constituents. */
2096 name_newline_fix (bp
)
2099 register U_CHAR
*p
= bp
;
2100 register int count
= 0;
2102 /* First count the backslash-newline pairs here. */
2107 else if (p
[1] == '\r' && p
[2] == '\n')
2115 /* What follows the backslash-newlines is not embarrassing. */
2117 if (count
== 0 || !is_idchar
[*p
])
2120 /* Copy all potentially embarrassing characters
2121 that follow the backslash-newline pairs
2122 down to where the pairs originally started. */
2124 while (is_idchar
[*p
])
2127 /* Now write the same number of pairs after the embarrassing chars. */
2128 while (count
-- > 0) {
2134 /* Look for lint commands in comments.
2136 When we come in here, ibp points into a comment. Limit is as one expects.
2137 scan within the comment -- it should start, after lwsp, with a lint command.
2138 If so that command is returned as a (constant) string.
2140 Upon return, any arg will be pointed to with argstart and will be
2141 arglen long. Note that we don't parse that arg since it will just
2142 be printed out again.
2146 get_lintcmd (ibp
, limit
, argstart
, arglen
, cmdlen
)
2147 register U_CHAR
*ibp
;
2148 register U_CHAR
*limit
;
2149 U_CHAR
**argstart
; /* point to command arg */
2150 int *arglen
, *cmdlen
; /* how long they are */
2153 register U_CHAR
*numptr
; /* temp for arg parsing */
2157 SKIP_WHITE_SPACE (ibp
);
2159 if (ibp
>= limit
) return NULL
;
2161 linsize
= limit
- ibp
;
2163 /* Oh, I wish C had lexical functions... hell, I'll just open-code the set */
2164 if ((linsize
>= 10) && !strncmp (ibp
, "NOTREACHED", 10)) {
2166 return "NOTREACHED";
2168 if ((linsize
>= 8) && !strncmp (ibp
, "ARGSUSED", 8)) {
2172 if ((linsize
>= 11) && !strncmp (ibp
, "LINTLIBRARY", 11)) {
2174 return "LINTLIBRARY";
2176 if ((linsize
>= 7) && !strncmp (ibp
, "VARARGS", 7)) {
2178 ibp
+= 7; linsize
-= 7;
2179 if ((linsize
== 0) || ! isdigit (*ibp
)) return "VARARGS";
2181 /* OK, read a number */
2182 for (numptr
= *argstart
= ibp
; (numptr
< limit
) && isdigit (*numptr
);
2184 *arglen
= numptr
- *argstart
;
2191 * The main loop of the program.
2193 * Read characters from the input stack, transferring them to the
2196 * Macros are expanded and push levels on the input stack.
2197 * At the end of such a level it is popped off and we keep reading.
2198 * At the end of any other kind of level, we return.
2199 * #-directives are handled, except within macros.
2201 * If OUTPUT_MARKS is nonzero, keep Newline markers found in the input
2202 * and insert them when appropriate. This is set while scanning macro
2203 * arguments before substitution. It is zero when scanning for final output.
2204 * There are three types of Newline markers:
2205 * * Newline - follows a macro name that was not expanded
2206 * because it appeared inside an expansion of the same macro.
2207 * This marker prevents future expansion of that identifier.
2208 * When the input is rescanned into the final output, these are deleted.
2209 * These are also deleted by ## concatenation.
2210 * * Newline Space (or Newline and any other whitespace character)
2211 * stands for a place that tokens must be separated or whitespace
2212 * is otherwise desirable, but where the ANSI standard specifies there
2213 * is no whitespace. This marker turns into a Space (or whichever other
2214 * whitespace char appears in the marker) in the final output,
2215 * but it turns into nothing in an argument that is stringified with #.
2216 * Such stringified arguments are the only place where the ANSI standard
2217 * specifies with precision that whitespace may not appear.
2219 * During this function, IP->bufp is kept cached in IBP for speed of access.
2220 * Likewise, OP->bufp is kept in OBP. Before calling a subroutine
2221 * IBP, IP and OBP must be copied back to memory. IP and IBP are
2222 * copied back with the RECACHE macro. OBP must be copied back from OP->bufp
2223 * explicitly, and before RECACHE, since RECACHE uses OBP.
2227 rescan (op
, output_marks
)
2231 /* Character being scanned in main loop. */
2234 /* Length of pending accumulated identifier. */
2235 register int ident_length
= 0;
2237 /* Hash code of pending accumulated identifier. */
2238 register int hash
= 0;
2240 /* Current input level (&instack[indepth]). */
2243 /* Pointer for scanning input. */
2244 register U_CHAR
*ibp
;
2246 /* Pointer to end of input. End of scan is controlled by LIMIT. */
2247 register U_CHAR
*limit
;
2249 /* Pointer for storing output. */
2250 register U_CHAR
*obp
;
2252 /* REDO_CHAR is nonzero if we are processing an identifier
2253 after backing up over the terminating character.
2254 Sometimes we process an identifier without backing up over
2255 the terminating character, if the terminating character
2256 is not special. Backing up is done so that the terminating character
2257 will be dispatched on again once the identifier is dealt with. */
2260 /* 1 if within an identifier inside of which a concatenation
2261 marker (Newline -) has been seen. */
2262 int concatenated
= 0;
2264 /* While scanning a comment or a string constant,
2265 this records the line it started on, for error messages. */
2268 /* Record position of last `real' newline. */
2269 U_CHAR
*beg_of_line
;
2271 /* Pop the innermost input stack level, assuming it is a macro expansion. */
2274 do { ip->macro->type = T_MACRO; \
2275 if (ip->free_ptr) free (ip->free_ptr); \
2276 --indepth; } while (0)
2278 /* Reload `rescan's local variables that describe the current
2279 level of the input stack. */
2282 do { ip = &instack[indepth]; \
2284 limit = ip->buf + ip->length; \
2286 check_expand (op, limit - ibp); \
2288 obp = op->bufp; } while (0)
2290 if (no_output
&& instack
[indepth
].fname
!= 0)
2291 skip_if_group (&instack
[indepth
], 1);
2298 /* Our caller must always put a null after the end of
2299 the input at each input stack level. */
2312 /* Always merge lines ending with backslash-newline,
2313 even in middle of identifier. */
2316 --obp
; /* remove backslash from obuf */
2319 /* Otherwise, backslash suppresses specialness of following char,
2320 so copy it here to prevent the switch from seeing it.
2321 But first get any pending identifier processed. */
2322 if (ident_length
> 0)
2328 if (assertions_flag
) {
2329 /* Copy #foo (bar lose) without macro expansion. */
2330 SKIP_WHITE_SPACE (ibp
);
2331 while (is_idchar
[*ibp
])
2333 SKIP_WHITE_SPACE (ibp
);
2336 skip_paren_group (ip
);
2337 bcopy (ibp
, obp
, ip
->bufp
- ibp
);
2338 obp
+= ip
->bufp
- ibp
;
2343 /* If this is expanding a macro definition, don't recognize
2344 preprocessor directives. */
2347 /* If this is expand_into_temp_buffer, recognize them
2348 only after an actual newline at this level,
2349 not at the beginning of the input level. */
2350 if (ip
->fname
== 0 && beg_of_line
== ip
->buf
)
2356 /* # keyword: a # must be first nonblank char on the line */
2357 if (beg_of_line
== 0)
2362 /* Scan from start of line, skipping whitespace, comments
2363 and backslash-newlines, and see if we reach this #.
2364 If not, this # is not special. */
2366 /* If -traditional, require # to be at beginning of line. */
2369 if (is_hor_space
[*bp
])
2371 else if (*bp
== '\\' && bp
[1] == '\n')
2373 else if (*bp
== '/' && bp
[1] == '*') {
2375 while (!(*bp
== '*' && bp
[1] == '/'))
2379 else if (cplusplus_comments
&& *bp
== '/' && bp
[1] == '/') {
2381 while (*bp
++ != '\n') ;
2389 /* This # can start a directive. */
2391 --obp
; /* Don't copy the '#' */
2395 if (! handle_directive (ip
, op
)) {
2399 /* Not a known directive: treat it as ordinary text.
2400 IP, OP, IBP, etc. have not been changed. */
2401 if (no_output
&& instack
[indepth
].fname
) {
2402 /* If not generating expanded output,
2403 what we do with ordinary text is skip it.
2404 Discard everything until next # directive. */
2405 skip_if_group (&instack
[indepth
], 1);
2410 ++obp
; /* Copy the '#' after all */
2416 /* A # directive has been successfully processed. */
2417 /* If not generating expanded output, ignore everything until
2418 next # directive. */
2419 if (no_output
&& instack
[indepth
].fname
)
2420 skip_if_group (&instack
[indepth
], 1);
2426 case '\"': /* skip quoted string */
2428 /* A single quoted string is treated like a double -- some
2429 programs (e.g., troff) are perverse this way */
2434 start_line
= ip
->lineno
;
2436 /* Skip ahead to a matching quote. */
2440 if (ip
->macro
!= 0) {
2441 /* try harder: this string crosses a macro expansion boundary.
2442 This can happen naturally if -traditional.
2443 Otherwise, only -D can make a macro with an unmatched quote. */
2449 error_with_line (line_for_error (start_line
),
2450 "unterminated string or character constant");
2451 error_with_line (multiline_string_line
,
2452 "possible real start of unterminated constant");
2453 multiline_string_line
= 0;
2462 /* Traditionally, end of line ends a string constant with no error.
2463 So exit the loop and record the new line. */
2469 error_with_line (line_for_error (start_line
),
2470 "unterminated character constant");
2473 if (pedantic
&& multiline_string_line
== 0) {
2474 pedwarn_with_line (line_for_error (start_line
),
2475 "string constant runs past end of line");
2477 if (multiline_string_line
== 0)
2478 multiline_string_line
= ip
->lineno
- 1;
2485 /* Backslash newline is replaced by nothing at all,
2486 but keep the line counts correct. */
2491 /* ANSI stupidly requires that in \\ the second \
2492 is *not* prevented from combining with a newline. */
2493 while (*ibp
== '\\' && ibp
[1] == '\n') {
2512 if (*ibp
== '\\' && ibp
[1] == '\n')
2516 && !(cplusplus_comments
&& *ibp
== '/'))
2524 /* C++ style comment... */
2525 start_line
= ip
->lineno
;
2527 --ibp
; /* Back over the slash */
2530 /* Comments are equivalent to spaces. */
2531 if (! put_out_comments
)
2534 /* must fake up a comment here */
2539 U_CHAR
*before_bp
= ibp
+2;
2541 while (ibp
< limit
) {
2542 if (*ibp
++ == '\n') {
2544 if (put_out_comments
) {
2545 bcopy (before_bp
, obp
, ibp
- before_bp
);
2546 obp
+= ibp
- before_bp
;
2555 /* Ordinary C comment. Skip it, optionally copying it to output. */
2557 start_line
= ip
->lineno
;
2559 ++ibp
; /* Skip the star. */
2561 /* If this cpp is for lint, we peek inside the comments: */
2565 char *lintcmd
= get_lintcmd (ibp
, limit
, &argbp
, &arglen
, &cmdlen
);
2567 if (lintcmd
!= NULL
) {
2568 /* I believe it is always safe to emit this newline: */
2570 bcopy ("#pragma lint ", obp
, 13);
2572 bcopy (lintcmd
, obp
, cmdlen
);
2577 bcopy (argbp
, obp
, arglen
);
2581 /* OK, now bring us back to the state we were in before we entered
2582 this branch. We need #line b/c the newline for the pragma
2583 could fuck things up. */
2584 output_line_command (ip
, op
, 0, same_file
);
2585 *(obp
++) = ' '; /* just in case, if comments are copied thru */
2590 /* Comments are equivalent to spaces.
2591 Note that we already output the slash; we might not want it.
2592 For -traditional, a comment is equivalent to nothing. */
2593 if (! put_out_comments
) {
2603 U_CHAR
*before_bp
= ibp
;
2605 while (ibp
< limit
) {
2608 if (warn_comments
&& ibp
< limit
&& *ibp
== '*')
2609 warning ("`/*' within comment");
2612 if (*ibp
== '\\' && ibp
[1] == '\n')
2614 if (ibp
>= limit
|| *ibp
== '/')
2619 /* Copy the newline into the output buffer, in order to
2620 avoid the pain of a #line every time a multiline comment
2622 if (!put_out_comments
)
2630 error_with_line (line_for_error (start_line
),
2631 "unterminated comment");
2634 if (put_out_comments
) {
2635 bcopy (before_bp
, obp
, ibp
- before_bp
);
2636 obp
+= ibp
- before_bp
;
2643 if (!dollars_in_ident
)
2647 case '0': case '1': case '2': case '3': case '4':
2648 case '5': case '6': case '7': case '8': case '9':
2649 /* If digit is not part of identifier, it starts a number,
2650 which means that following letters are not an identifier.
2651 "0x5" does not refer to an identifier "x5".
2652 So copy all alphanumerics that follow without accumulating
2653 as an identifier. Periods also, for sake of "3.e7". */
2655 if (ident_length
== 0) {
2656 while (ibp
< limit
) {
2657 while (ibp
< limit
&& ibp
[0] == '\\' && ibp
[1] == '\n') {
2662 /* ".." terminates a preprocessing number. This is useless for C
2663 code but useful for preprocessing other things. */
2664 if (!isalnum (c
) && (c
!= '.' || *ibp
== '.') && c
!= '_') {
2669 /* A sign can be part of a preprocessing number
2670 if it follows an e. */
2671 if (c
== 'e' || c
== 'E') {
2672 while (ibp
< limit
&& ibp
[0] == '\\' && ibp
[1] == '\n') {
2676 if (ibp
< limit
&& (*ibp
== '+' || *ibp
== '-')) {
2678 /* But traditional C does not let the token go past the sign. */
2689 case 'a': case 'b': case 'c': case 'd': case 'e': case 'f':
2690 case 'g': case 'h': case 'i': case 'j': case 'k': case 'l':
2691 case 'm': case 'n': case 'o': case 'p': case 'q': case 'r':
2692 case 's': case 't': case 'u': case 'v': case 'w': case 'x':
2694 case 'A': case 'B': case 'C': case 'D': case 'E': case 'F':
2695 case 'G': case 'H': case 'I': case 'J': case 'K': case 'L':
2696 case 'M': case 'N': case 'O': case 'P': case 'Q': case 'R':
2697 case 'S': case 'T': case 'U': case 'V': case 'W': case 'X':
2701 /* Compute step of hash function, to avoid a proc call on every token */
2702 hash
= HASHSTEP (hash
, c
);
2706 if (ip
->fname
== 0 && *ibp
== '-') {
2707 /* Newline - inhibits expansion of preceding token.
2708 If expanding a macro arg, we keep the newline -.
2709 In final output, it is deleted.
2710 We recognize Newline - in macro bodies and macro args. */
2711 if (! concatenated
) {
2716 if (!output_marks
) {
2719 /* If expanding a macro arg, keep the newline -. */
2725 /* If reprocessing a macro expansion, newline is a special marker. */
2726 else if (ip
->macro
!= 0) {
2727 /* Newline White is a "funny space" to separate tokens that are
2728 supposed to be separate but without space between.
2729 Here White means any whitespace character.
2730 Newline - marks a recursive macro use that is not
2731 supposed to be expandable. */
2733 if (is_space
[*ibp
]) {
2734 /* Newline Space does not prevent expansion of preceding token
2735 so expand the preceding token and then come back. */
2736 if (ident_length
> 0)
2739 /* If generating final output, newline space makes a space. */
2740 if (!output_marks
) {
2742 /* And Newline Newline makes a newline, so count it. */
2743 if (obp
[-1] == '\n')
2746 /* If expanding a macro arg, keep the newline space.
2747 If the arg gets stringified, newline space makes nothing. */
2750 } else abort (); /* Newline followed by something random? */
2754 /* If there is a pending identifier, handle it and come back here. */
2755 if (ident_length
> 0)
2760 /* Update the line counts and output a #line if necessary. */
2763 if (ip
->lineno
!= op
->lineno
) {
2765 output_line_command (ip
, op
, 1, same_file
);
2766 check_expand (op
, ip
->length
- (ip
->bufp
- ip
->buf
));
2771 /* Come here either after (1) a null character that is part of the input
2772 or (2) at the end of the input, because there is a null there. */
2775 /* Our input really contains a null character. */
2778 /* At end of a macro-expansion level, pop it and read next level. */
2779 if (ip
->macro
!= 0) {
2782 /* If traditional, and we have an identifier that ends here,
2783 process it now, so we get the right error for recursion. */
2784 if (traditional
&& ident_length
2785 && ! is_idchar
[*instack
[indepth
- 1].bufp
]) {
2794 /* If we don't have a pending identifier,
2795 return at end of input. */
2796 if (ident_length
== 0) {
2804 /* If we do have a pending identifier, just consider this null
2805 a special character and arrange to dispatch on it again.
2806 The second time, IDENT_LENGTH will be zero so we will return. */
2812 /* Handle the case of a character such as /, ', " or null
2813 seen following an identifier. Back over it so that
2814 after the identifier is processed the special char
2815 will be dispatched on again. */
2825 if (ident_length
> 0) {
2826 register HASHNODE
*hp
;
2828 /* We have just seen an identifier end. If it's a macro, expand it.
2830 IDENT_LENGTH is the length of the identifier
2831 and HASH is its hash code.
2833 The identifier has already been copied to the output,
2834 so if it is a macro we must remove it.
2836 If REDO_CHAR is 0, the char that terminated the identifier
2837 has been skipped in the output and the input.
2838 OBP-IDENT_LENGTH-1 points to the identifier.
2839 If the identifier is a macro, we must back over the terminator.
2841 If REDO_CHAR is 1, the terminating char has already been
2842 backed over. OBP-IDENT_LENGTH points to the identifier. */
2844 if (!pcp_outfile
|| pcp_inside_if
) {
2846 for (hp
= hashtab
[MAKE_POS (hash
) % HASHSIZE
]; hp
!= NULL
;
2849 if (hp
->length
== ident_length
) {
2850 int obufp_before_macroname
;
2851 int op_lineno_before_macroname
;
2852 register int i
= ident_length
;
2853 register U_CHAR
*p
= hp
->name
;
2854 register U_CHAR
*q
= obp
- i
;
2860 do { /* All this to avoid a strncmp () */
2865 /* We found a use of a macro name.
2866 see if the context shows it is a macro call. */
2868 /* Back up over terminating character if not already done. */
2874 /* Save this as a displacement from the beginning of the output
2875 buffer. We can not save this as a position in the output
2876 buffer, because it may get realloc'ed by RECACHE. */
2877 obufp_before_macroname
= (obp
- op
->buf
) - ident_length
;
2878 op_lineno_before_macroname
= op
->lineno
;
2880 if (hp
->type
== T_PCSTRING
) {
2881 pcstring_used (hp
); /* Mark the definition of this key
2882 as needed, ensuring that it
2884 break; /* Exit loop, since the key cannot have a
2885 definition any longer. */
2888 /* Record whether the macro is disabled. */
2889 disabled
= hp
->type
== T_DISABLED
;
2891 /* This looks like a macro ref, but if the macro was disabled,
2892 just copy its name and put in a marker if requested. */
2896 /* This error check caught useful cases such as
2897 #define foo(x,y) bar (x (y,0), y)
2900 error ("recursive use of macro `%s'", hp
->name
);
2904 check_expand (op
, limit
- ibp
+ 2);
2911 /* If macro wants an arglist, verify that a '(' follows.
2912 first skip all whitespace, copying it to the output
2913 after the macro name. Then, if there is no '(',
2914 decide this is not a macro call and leave things that way. */
2915 if ((hp
->type
== T_MACRO
|| hp
->type
== T_DISABLED
)
2916 && hp
->value
.defn
->nargs
>= 0)
2918 U_CHAR
*old_ibp
= ibp
;
2919 U_CHAR
*old_obp
= obp
;
2920 int old_iln
= ip
->lineno
;
2921 int old_oln
= op
->lineno
;
2924 /* Scan forward over whitespace, copying it to the output. */
2925 if (ibp
== limit
&& ip
->macro
!= 0) {
2930 old_iln
= ip
->lineno
;
2931 old_oln
= op
->lineno
;
2933 /* A comment: copy it unchanged or discard it. */
2934 else if (*ibp
== '/' && ibp
+1 != limit
&& ibp
[1] == '*') {
2935 if (put_out_comments
) {
2938 } else if (! traditional
) {
2942 while (ibp
+ 1 != limit
2943 && !(ibp
[0] == '*' && ibp
[1] == '/')) {
2944 /* We need not worry about newline-marks,
2945 since they are never found in comments. */
2947 /* Newline in a file. Count it. */
2951 if (put_out_comments
)
2957 if (put_out_comments
) {
2962 else if (is_space
[*ibp
]) {
2964 if (ibp
[-1] == '\n') {
2965 if (ip
->macro
== 0) {
2966 /* Newline in a file. Count it. */
2969 } else if (!output_marks
) {
2970 /* A newline mark, and we don't want marks
2971 in the output. If it is newline-hyphen,
2972 discard it entirely. Otherwise, it is
2973 newline-whitechar, so keep the whitechar. */
2983 /* A newline mark; copy both chars to the output. */
2991 /* It isn't a macro call.
2992 Put back the space that we just skipped. */
2995 ip
->lineno
= old_iln
;
2996 op
->lineno
= old_oln
;
2997 /* Exit the for loop. */
3002 /* This is now known to be a macro call.
3003 Discard the macro name from the output,
3004 along with any following whitespace just copied. */
3005 obp
= op
->buf
+ obufp_before_macroname
;
3006 op
->lineno
= op_lineno_before_macroname
;
3008 /* Prevent accidental token-pasting with a character
3009 before the macro call. */
3010 if (!traditional
&& obp
!= op
->buf
3011 && (obp
[-1] == '-' || obp
[1] == '+' || obp
[1] == '&'
3012 || obp
[-1] == '|' || obp
[1] == '<' || obp
[1] == '>')) {
3013 /* If we are expanding a macro arg, make a newline marker
3014 to separate the tokens. If we are making real output,
3015 a plain space will do. */
3021 /* Expand the macro, reading arguments as needed,
3022 and push the expansion on the input stack. */
3025 macroexpand (hp
, op
);
3027 /* Reexamine input stack, since macroexpand has pushed
3028 a new level on it. */
3035 } /* End hash-table-search loop */
3037 ident_length
= hash
= 0; /* Stop collecting identifier */
3040 } /* End if (ident_length > 0) */
3042 } /* End per-char loop */
3044 /* Come here to return -- but first give an error message
3045 if there was an unterminated successful conditional. */
3047 if (if_stack
!= ip
->if_stack
) {
3049 switch (if_stack
->type
) {
3066 error_with_line (line_for_error (if_stack
->lineno
),
3067 "unterminated `#%s' conditional", str
);
3069 if_stack
= ip
->if_stack
;
3073 * Rescan a string into a temporary buffer and return the result
3074 * as a FILE_BUF. Note this function returns a struct, not a pointer.
3076 * OUTPUT_MARKS nonzero means keep Newline markers found in the input
3077 * and insert such markers when appropriate. See `rescan' for details.
3078 * OUTPUT_MARKS is 1 for macroexpanding a macro argument separately
3079 * before substitution; it is 0 for other uses.
3082 expand_to_temp_buffer (buf
, limit
, output_marks
, assertions
)
3083 U_CHAR
*buf
, *limit
;
3084 int output_marks
, assertions
;
3086 register FILE_BUF
*ip
;
3088 int length
= limit
- buf
;
3090 int odepth
= indepth
;
3091 int save_assertions_flag
= assertions_flag
;
3093 assertions_flag
= assertions
;
3098 /* Set up the input on the input stack. */
3100 buf1
= (U_CHAR
*) alloca (length
+ 1);
3102 register U_CHAR
*p1
= buf
;
3103 register U_CHAR
*p2
= buf1
;
3110 /* Set up to receive the output. */
3112 obuf
.length
= length
* 2 + 100; /* Usually enough. Why be stingy? */
3113 obuf
.bufp
= obuf
.buf
= (U_CHAR
*) xmalloc (obuf
.length
);
3118 CHECK_DEPTH ({return obuf
;});
3122 ip
= &instack
[indepth
];
3124 ip
->nominal_fname
= 0;
3125 ip
->system_header_p
= 0;
3128 ip
->length
= length
;
3129 ip
->buf
= ip
->bufp
= buf1
;
3130 ip
->if_stack
= if_stack
;
3132 ip
->lineno
= obuf
.lineno
= 1;
3134 /* Scan the input, create the output. */
3135 rescan (&obuf
, output_marks
);
3137 /* Pop input stack to original state. */
3140 if (indepth
!= odepth
)
3143 /* Record the output. */
3144 obuf
.length
= obuf
.bufp
- obuf
.buf
;
3146 assertions_flag
= save_assertions_flag
;
3151 * Process a # directive. Expects IP->bufp to point after the '#', as in
3152 * `#define foo bar'. Passes to the command handler
3153 * (do_define, do_include, etc.): the addresses of the 1st and
3154 * last chars of the command (starting immediately after the #
3155 * keyword), plus op and the keyword table pointer. If the command
3156 * contains comments it is copied into a temporary buffer sans comments
3157 * and the temporary buffer is passed to the command handler instead.
3158 * Likewise for backslash-newlines.
3160 * Returns nonzero if this was a known # directive.
3161 * Otherwise, returns zero, without advancing the input pointer.
3165 handle_directive (ip
, op
)
3168 register U_CHAR
*bp
, *cp
;
3169 register struct directive
*kt
;
3170 register int ident_length
;
3173 /* Nonzero means we must copy the entire command
3174 to get rid of comments or backslash-newlines. */
3175 int copy_command
= 0;
3177 U_CHAR
*ident
, *after_ident
;
3181 /* Record where the directive started. do_xifdef needs this. */
3182 directive_start
= bp
- 1;
3184 /* Skip whitespace and \-newline. */
3186 if (is_hor_space
[*bp
]) {
3187 if ((*bp
== '\f' || *bp
== '\v') && pedantic
)
3188 pedwarn ("%s in preprocessing directive",
3189 *bp
== '\f' ? "formfeed" : "vertical tab");
3191 } else if (*bp
== '/' && bp
[1] == '*') {
3193 skip_to_end_of_comment (ip
, &ip
->lineno
, 0);
3195 } else if (*bp
== '\\' && bp
[1] == '\n') {
3196 bp
+= 2; ip
->lineno
++;
3200 /* Now find end of directive name.
3201 If we encounter a backslash-newline, exchange it with any following
3202 symbol-constituents so that we end up with a contiguous name. */
3209 if (*cp
== '\\' && cp
[1] == '\n')
3210 name_newline_fix (cp
);
3216 ident_length
= cp
- bp
;
3220 /* A line of just `#' becomes blank. */
3222 if (ident_length
== 0 && *after_ident
== '\n') {
3223 ip
->bufp
= after_ident
;
3227 if (ident_length
== 0 || !is_idstart
[*ident
]) {
3229 while (is_idchar
[*p
]) {
3230 if (*p
< '0' || *p
> '9')
3234 /* Handle # followed by a line number. */
3235 if (p
!= ident
&& !is_idchar
[*p
]) {
3236 static struct directive line_directive_table
[] = {
3237 { 4, do_line
, "line", T_LINE
},
3240 pedwarn ("`#' followed by integer");
3241 after_ident
= ident
;
3242 kt
= line_directive_table
;
3246 /* Avoid error for `###' and similar cases unless -pedantic. */
3248 while (*p
== '#' || is_hor_space
[*p
]) p
++;
3250 if (pedantic
&& !lang_asm
)
3251 warning ("invalid preprocessor directive");
3257 error ("invalid preprocessor directive name");
3263 * Decode the keyword and call the appropriate expansion
3264 * routine, after moving the input pointer up to the next line.
3266 for (kt
= directive_table
; kt
->length
> 0; kt
++) {
3267 if (kt
->length
== ident_length
&& !strncmp (kt
->name
, ident
, ident_length
)) {
3268 register U_CHAR
*buf
;
3269 register U_CHAR
*limit
;
3272 int *already_output
;
3274 /* Nonzero means do not delete comments within the directive.
3275 #define needs this when -traditional. */
3280 limit
= ip
->buf
+ ip
->length
;
3283 keep_comments
= traditional
&& kt
->traditional_comments
;
3284 /* #import is defined only in Objective C, or when on the NeXT. */
3285 if (kt
->type
== T_IMPORT
&& !(objc
|| lookup ("__NeXT__", -1, -1)))
3288 /* Find the end of this command (first newline not backslashed
3289 and not in a string or comment).
3290 Set COPY_COMMAND if the command must be copied
3291 (it contains a backslash-newline or a comment). */
3293 buf
= bp
= after_ident
;
3294 while (bp
< limit
) {
3295 register U_CHAR c
= *bp
++;
3309 bp
= skip_quoted_string (bp
- 1, limit
, ip
->lineno
, &ip
->lineno
, ©_command
, &unterminated
);
3310 /* Don't bother calling the directive if we already got an error
3311 message due to unterminated string. Skip everything and pretend
3312 we called the directive. */
3315 /* Traditional preprocessing permits unterminated strings. */
3324 /* <...> is special for #include. */
3326 if (!kt
->angle_brackets
)
3328 while (*bp
&& *bp
!= '>') bp
++;
3332 if (*bp
== '\\' && bp
[1] == '\n')
3335 || (cplusplus_comments
&& *bp
== '/')) {
3336 U_CHAR
*obp
= bp
- 1;
3338 skip_to_end_of_comment (ip
, &ip
->lineno
, 0);
3340 /* No need to copy the command because of a comment at the end;
3341 just don't include the comment in the directive. */
3342 if (bp
== limit
|| *bp
== '\n') {
3346 /* Don't remove the comments if -traditional. */
3347 if (! keep_comments
)
3355 pedwarn ("%s in preprocessing directive",
3356 c
== '\f' ? "formfeed" : "vertical tab");
3360 --bp
; /* Point to the newline */
3368 resume_p
= ip
->bufp
;
3369 /* BP is the end of the directive.
3370 RESUME_P is the next interesting data after the directive.
3371 A comment may come between. */
3373 /* If a directive should be copied through, and -E was given,
3374 pass it through before removing comments. */
3375 if (!no_output
&& kt
->pass_thru
&& put_out_comments
) {
3378 /* Output directive name. */
3379 check_expand (op
, kt
->length
+ 2);
3380 /* Make sure # is at the start of a line */
3381 if (op
->bufp
> op
->buf
&& op
->bufp
[-1] != '\n') {
3386 bcopy (kt
->name
, op
->bufp
, kt
->length
);
3387 op
->bufp
+= kt
->length
;
3389 /* Output arguments. */
3391 check_expand (op
, len
);
3392 bcopy (buf
, op
->bufp
, len
);
3394 /* Take account of any (escaped) newlines just output. */
3396 if (buf
[len
] == '\n')
3399 already_output
= &junk
;
3400 } /* Don't we need a newline or #line? */
3403 register U_CHAR
*xp
= buf
;
3404 /* Need to copy entire command into temp buffer before dispatching */
3406 cp
= (U_CHAR
*) alloca (bp
- buf
+ 5); /* room for cmd plus
3410 /* Copy to the new buffer, deleting comments
3411 and backslash-newlines (and whitespace surrounding the latter). */
3414 register U_CHAR c
= *xp
++;
3419 abort (); /* A bare newline should never part of the line. */
3422 /* <...> is special for #include. */
3424 if (!kt
->angle_brackets
)
3426 while (xp
< bp
&& c
!= '>') {
3428 if (c
== '\\' && xp
< bp
&& *xp
== '\n')
3439 if (cp
!= buf
&& is_space
[cp
[-1]]) {
3440 while (cp
!= buf
&& is_space
[cp
[-1]]) cp
--;
3442 SKIP_WHITE_SPACE (xp
);
3443 } else if (is_space
[*xp
]) {
3445 SKIP_WHITE_SPACE (xp
);
3455 register U_CHAR
*bp1
3456 = skip_quoted_string (xp
- 1, bp
, ip
->lineno
,
3457 NULL_PTR
, NULL_PTR
, NULL_PTR
);
3471 || (cplusplus_comments
&& *xp
== '/')) {
3473 /* If we already copied the command through,
3474 already_output != 0 prevents outputting comment now. */
3475 skip_to_end_of_comment (ip
, already_output
, 0);
3477 while (xp
!= ip
->bufp
)
3479 /* Delete or replace the slash. */
3480 else if (traditional
)
3489 /* Null-terminate the copy. */
3495 ip
->bufp
= resume_p
;
3497 /* Some directives should be written out for cc1 to process,
3498 just as if they were not defined. And sometimes we're copying
3499 definitions through. */
3501 if (!no_output
&& already_output
== 0
3503 || (kt
->type
== T_DEFINE
3504 && (dump_macros
== dump_names
3505 || dump_macros
== dump_definitions
)))) {
3508 /* Output directive name. */
3509 check_expand (op
, kt
->length
+ 1);
3511 bcopy (kt
->name
, op
->bufp
, kt
->length
);
3512 op
->bufp
+= kt
->length
;
3514 if (kt
->pass_thru
|| dump_macros
== dump_definitions
) {
3515 /* Output arguments. */
3517 check_expand (op
, len
);
3518 bcopy (buf
, op
->bufp
, len
);
3520 } else if (kt
->type
== T_DEFINE
&& dump_macros
== dump_names
) {
3523 SKIP_WHITE_SPACE (xp
);
3525 while (is_idchar
[*xp
]) xp
++;
3527 check_expand (op
, len
+ 1);
3529 bcopy (yp
, op
->bufp
, len
);
3532 } /* Don't we need a newline or #line? */
3534 /* Call the appropriate command handler. buf now points to
3535 either the appropriate place in the input buffer, or to
3536 the temp buffer if it was necessary to make one. cp
3537 points to the first char after the contents of the (possibly
3538 copied) command, in either case. */
3539 (*kt
->func
) (buf
, cp
, op
, kt
);
3540 check_expand (op
, ip
->length
- (ip
->bufp
- ip
->buf
));
3546 /* It is deliberate that we don't warn about undefined directives.
3547 That is the responsibility of cc1. */
3554 static struct tm
*timebuf
;
3556 time_t t
= time (0);
3557 timebuf
= localtime (&t
);
3562 static char *monthnames
[] = {"Jan", "Feb", "Mar", "Apr", "May", "Jun",
3563 "Jul", "Aug", "Sep", "Oct", "Nov", "Dec",
3567 * expand things like __FILE__. Place the expansion into the output
3568 * buffer *without* rescanning.
3572 special_symbol (hp
, op
)
3579 FILE_BUF
*ip
= NULL
;
3582 int paren
= 0; /* For special `defined' keyword */
3584 if (pcp_outfile
&& pcp_inside_if
3585 && hp
->type
!= T_SPEC_DEFINED
&& hp
->type
!= T_CONST
)
3586 error ("Predefined macro `%s' used inside `#if' during precompilation",
3589 for (i
= indepth
; i
>= 0; i
--)
3590 if (instack
[i
].fname
!= NULL
) {
3595 error ("cccp error: not in any file?!");
3596 return; /* the show must go on */
3604 if (hp
->type
== T_FILE
)
3605 string
= ip
->nominal_fname
;
3607 string
= instack
[0].nominal_fname
;
3611 buf
= (char *) alloca (3 + strlen (string
));
3612 sprintf (buf
, "\"%s\"", string
);
3620 case T_INCLUDE_LEVEL
:
3622 for (i
= indepth
; i
>= 0; i
--)
3623 if (instack
[i
].fname
!= NULL
)
3626 buf
= (char *) alloca (8); /* Eight bytes ought to be more than enough */
3627 sprintf (buf
, "%d", true_indepth
- 1);
3631 buf
= (char *) alloca (3 + strlen (version_string
));
3632 sprintf (buf
, "\"%s\"", version_string
);
3636 buf
= (char *) alloca (3 + strlen (SIZE_TYPE
));
3637 sprintf (buf
, "%s", SIZE_TYPE
);
3640 case T_PTRDIFF_TYPE
:
3641 buf
= (char *) alloca (3 + strlen (PTRDIFF_TYPE
));
3642 sprintf (buf
, "%s", PTRDIFF_TYPE
);
3646 buf
= (char *) alloca (3 + strlen (WCHAR_TYPE
));
3647 sprintf (buf
, "%s", WCHAR_TYPE
);
3650 case T_USER_LABEL_PREFIX_TYPE
:
3651 buf
= (char *) alloca (3 + strlen (USER_LABEL_PREFIX
));
3652 sprintf (buf
, "%s", USER_LABEL_PREFIX
);
3655 case T_REGISTER_PREFIX_TYPE
:
3656 buf
= (char *) alloca (3 + strlen (REGISTER_PREFIX
));
3657 sprintf (buf
, "%s", REGISTER_PREFIX
);
3661 buf
= (char *) alloca (4 * sizeof (int));
3662 sprintf (buf
, "%d", hp
->value
.ival
);
3663 if (pcp_inside_if
&& pcp_outfile
)
3664 /* Output a precondition for this macro use */
3665 fprintf (pcp_outfile
, "#define %s %d\n", hp
->name
, hp
->value
.ival
);
3669 buf
= (char *) alloca (10);
3670 sprintf (buf
, "%d", ip
->lineno
);
3675 buf
= (char *) alloca (20);
3676 timebuf
= timestamp ();
3677 if (hp
->type
== T_DATE
)
3678 sprintf (buf
, "\"%s %2d %4d\"", monthnames
[timebuf
->tm_mon
],
3679 timebuf
->tm_mday
, timebuf
->tm_year
+ 1900);
3681 sprintf (buf
, "\"%02d:%02d:%02d\"", timebuf
->tm_hour
, timebuf
->tm_min
,
3685 case T_SPEC_DEFINED
:
3686 buf
= " 0 "; /* Assume symbol is not defined */
3687 ip
= &instack
[indepth
];
3688 SKIP_WHITE_SPACE (ip
->bufp
);
3689 if (*ip
->bufp
== '(') {
3691 ip
->bufp
++; /* Skip over the paren */
3692 SKIP_WHITE_SPACE (ip
->bufp
);
3695 if (!is_idstart
[*ip
->bufp
])
3697 if (hp
= lookup (ip
->bufp
, -1, -1)) {
3698 if (pcp_outfile
&& pcp_inside_if
3699 && hp
->value
.defn
->predefined
)
3700 /* Output a precondition for this macro use. */
3701 fprintf (pcp_outfile
, "#define %s\n", hp
->name
);
3705 if (pcp_outfile
&& pcp_inside_if
) {
3706 /* Output a precondition for this macro use */
3707 U_CHAR
*cp
= ip
->bufp
;
3708 fprintf (pcp_outfile
, "#undef ");
3709 while (is_idchar
[*cp
]) /* Ick! */
3710 fputc (*cp
++, pcp_outfile
);
3711 putc ('\n', pcp_outfile
);
3713 while (is_idchar
[*ip
->bufp
])
3715 SKIP_WHITE_SPACE (ip
->bufp
);
3717 if (*ip
->bufp
!= ')')
3725 error ("`defined' without an identifier");
3729 error ("cccp error: invalid special hash type"); /* time for gdb */
3733 check_expand (op
, len
);
3734 bcopy (buf
, op
->bufp
, len
);
3741 /* Routines to handle #directives */
3743 /* Handle #include and #import.
3744 This function expects to see "fname" or <fname> on the input. */
3747 do_include (buf
, limit
, op
, keyword
)
3748 U_CHAR
*buf
, *limit
;
3750 struct directive
*keyword
;
3752 int importing
= (keyword
->type
== T_IMPORT
);
3753 int skip_dirs
= (keyword
->type
== T_INCLUDE_NEXT
);
3754 static int import_warning
= 0;
3755 char *fname
; /* Dynamically allocated fname buffer */
3758 U_CHAR
*fbeg
, *fend
; /* Beginning and end of fname */
3760 struct file_name_list
*search_start
= include
; /* Chain of dirs to search */
3761 struct file_name_list dsp
[1]; /* First in chain, if #include "..." */
3762 struct file_name_list
*searchptr
= 0;
3765 int f
; /* file number */
3767 int retried
= 0; /* Have already tried macro
3768 expanding the include line*/
3769 FILE_BUF trybuf
; /* It got expanded into here */
3770 int angle_brackets
= 0; /* 0 for "...", 1 for <...> */
3775 f
= -1; /* JF we iz paranoid! */
3777 if (importing
&& warn_import
&& !inhibit_warnings
3778 && !instack
[indepth
].system_header_p
&& !import_warning
) {
3780 warning ("using `#import' is not recommended");
3781 fprintf (stderr
, "The fact that a certain header file need not be processed more than once\n");
3782 fprintf (stderr
, "should be indicated in the header file, not where it is used.\n");
3783 fprintf (stderr
, "The best way to do this is with a conditional of this form:\n\n");
3784 fprintf (stderr
, " #ifndef _FOO_H_INCLUDED\n");
3785 fprintf (stderr
, " #define _FOO_H_INCLUDED\n");
3786 fprintf (stderr
, " ... <real contents of file> ...\n");
3787 fprintf (stderr
, " #endif /* Not _FOO_H_INCLUDED */\n\n");
3788 fprintf (stderr
, "Then users can use `#include' any number of times.\n");
3789 fprintf (stderr
, "GNU C automatically avoids processing the file more than once\n");
3790 fprintf (stderr
, "when it is equipped with such a conditional.\n");
3796 SKIP_WHITE_SPACE (fbeg
);
3797 /* Discard trailing whitespace so we can easily see
3798 if we have parsed all the significant chars we were given. */
3799 while (limit
!= fbeg
&& is_hor_space
[limit
[-1]]) limit
--;
3805 /* Copy the operand text, concatenating the strings. */
3808 fbeg
= (U_CHAR
*) alloca (limit
- fbeg
+ 1);
3810 while (fin
!= limit
) {
3811 while (fin
!= limit
&& *fin
!= '\"')
3816 /* If not at the end, there had better be another string. */
3817 /* Skip just horiz space, and don't go past limit. */
3818 while (fin
!= limit
&& is_hor_space
[*fin
]) fin
++;
3819 if (fin
!= limit
&& *fin
== '\"')
3827 /* We have "filename". Figure out directory this source
3828 file is coming from and put it on the front of the list. */
3830 /* If -I- was specified, don't search current dir, only spec'd ones. */
3831 if (ignore_srcdir
) break;
3833 for (fp
= &instack
[indepth
]; fp
>= instack
; fp
--)
3838 if ((nam
= fp
->nominal_fname
) != NULL
) {
3839 /* Found a named file. Figure out dir of the file,
3840 and put it in front of the search list. */
3841 dsp
[0].next
= search_start
;
3844 ep
= rindex (nam
, '/');
3846 ep
= rindex (nam
, ']');
3847 if (ep
== NULL
) ep
= rindex (nam
, '>');
3848 if (ep
== NULL
) ep
= rindex (nam
, ':');
3849 if (ep
!= NULL
) ep
++;
3853 dsp
[0].fname
= (char *) alloca (n
+ 1);
3854 strncpy (dsp
[0].fname
, nam
, n
);
3855 dsp
[0].fname
[n
] = '\0';
3856 if (n
+ INCLUDE_LEN_FUDGE
> max_include_len
)
3857 max_include_len
= n
+ INCLUDE_LEN_FUDGE
;
3859 dsp
[0].fname
= 0; /* Current directory */
3869 while (fend
!= limit
&& *fend
!= '>') fend
++;
3870 if (*fend
== '>' && fend
+ 1 == limit
) {
3872 /* If -I-, start with the first -I dir after the -I-. */
3873 if (first_bracket_include
)
3874 search_start
= first_bracket_include
;
3882 error ("`#%s' expects \"FILENAME\" or <FILENAME>", keyword
->name
);
3885 trybuf
= expand_to_temp_buffer (buf
, limit
, 0, 0);
3886 buf
= (U_CHAR
*) alloca (trybuf
.bufp
- trybuf
.buf
+ 1);
3887 bcopy (trybuf
.buf
, buf
, trybuf
.bufp
- trybuf
.buf
);
3888 limit
= buf
+ (trybuf
.bufp
- trybuf
.buf
);
3895 /* For #include_next, skip in the search path
3896 past the dir in which the containing file was found. */
3899 for (fp
= &instack
[indepth
]; fp
>= instack
; fp
--)
3900 if (fp
->fname
!= NULL
) {
3901 /* fp->dir is null if the containing file was specified
3902 with an absolute file name. In that case, don't skip anything. */
3904 search_start
= fp
->dir
->next
;
3913 error ("empty file name in `#%s'", keyword
->name
);
3917 /* Allocate this permanently, because it gets stored in the definitions
3919 fname
= (char *) xmalloc (max_include_len
+ flen
+ 2);
3920 /* + 2 above for slash and terminating null. */
3922 /* If specified file name is absolute, just open it. */
3925 strncpy (fname
, fbeg
, flen
);
3927 if (redundant_include_p (fname
))
3930 f
= lookup_import (fname
);
3932 f
= open (fname
, O_RDONLY
, 0666);
3934 return 0; /* Already included this file */
3936 /* Search directory path, trying to open the file.
3937 Copy each filename tried into FNAME. */
3939 for (searchptr
= search_start
; searchptr
; searchptr
= searchptr
->next
) {
3940 if (searchptr
->fname
) {
3941 /* The empty string in a search path is ignored.
3942 This makes it possible to turn off entirely
3943 a standard piece of the list. */
3944 if (searchptr
->fname
[0] == 0)
3946 strcpy (fname
, searchptr
->fname
);
3947 strcat (fname
, "/");
3948 fname
[strlen (fname
) + flen
] = 0;
3952 strncat (fname
, fbeg
, flen
);
3954 /* Change this 1/2 Unix 1/2 VMS file specification into a
3955 full VMS file specification */
3956 if (searchptr
->fname
&& (searchptr
->fname
[0] != 0)) {
3957 /* Fix up the filename */
3958 hack_vms_include_specification (fname
);
3960 /* This is a normal VMS filespec, so use it unchanged. */
3961 strncpy (fname
, fbeg
, flen
);
3966 f
= lookup_import (fname
);
3968 f
= open (fname
, O_RDONLY
, 0666);
3970 return 0; /* Already included this file */
3972 else if (f
== -1 && errno
== EACCES
)
3973 warning ("Header file %s exists, but is not readable", fname
);
3975 if (redundant_include_p (fname
)) {
3985 /* A file that was not found. */
3987 strncpy (fname
, fbeg
, flen
);
3989 /* If -M was specified, and this header file won't be added to the
3990 dependency list, then don't count this as an error, because we can
3991 still produce correct output. Otherwise, we can't produce correct
3992 output, because there may be dependencies we need inside the missing
3993 file, and we don't know what directory this missing file exists in. */
3995 && (print_deps
<= (angle_brackets
|| (system_include_depth
> 0))))
3996 warning ("No include path in which to find %s", fname
);
3997 else if (search_start
)
3998 error_from_errno (fname
);
4000 error ("No include path in which to find %s", fname
);
4004 /* Check to see if this include file is a once-only include file.
4007 struct file_name_list
* ptr
;
4009 for (ptr
= dont_repeat_files
; ptr
; ptr
= ptr
->next
) {
4010 if (!strcmp (ptr
->fname
, fname
)) {
4012 return 0; /* This file was once'd. */
4016 for (ptr
= all_include_files
; ptr
; ptr
= ptr
->next
) {
4017 if (!strcmp (ptr
->fname
, fname
))
4018 break; /* This file was included before. */
4022 /* This is the first time for this file. */
4023 /* Add it to list of files included. */
4025 ptr
= (struct file_name_list
*) xmalloc (sizeof (struct file_name_list
));
4026 ptr
->control_macro
= 0;
4027 ptr
->next
= all_include_files
;
4028 all_include_files
= ptr
;
4029 ptr
->fname
= savestring (fname
);
4031 /* For -M, add this file to the dependencies. */
4032 if (print_deps
> (angle_brackets
|| (system_include_depth
> 0))) {
4033 deps_output ("", 0);
4034 deps_output (fname
, 0);
4035 deps_output (" ", 0);
4039 /* Handle -H option. */
4040 if (print_include_names
)
4041 fprintf (stderr
, "%s\n", fname
);
4044 system_include_depth
++;
4046 /* Actually process the file. */
4047 add_import (f
, fname
); /* Record file on "seen" list for #import. */
4049 pcftry
= (char *) alloca (strlen (fname
) + 30);
4057 sprintf (pcftry
, "%s%d", fname
, pcfnum
++);
4059 pcf
= open (pcftry
, O_RDONLY
, 0666);
4065 if (bcmp (&stat_f
.st_ino
, &s
.st_ino
, sizeof (s
.st_ino
))
4066 || stat_f
.st_dev
!= s
.st_dev
)
4068 pcfbuf
= check_precompiled (pcf
, fname
, &pcfbuflimit
);
4069 /* Don't need it any more. */
4074 /* Don't need it at all. */
4079 } while (pcf
!= -1 && !pcfbuf
);
4081 /* Actually process the file */
4083 pcfname
= xmalloc (strlen (pcftry
) + 1);
4084 strcpy (pcfname
, pcftry
);
4085 pcfinclude (pcfbuf
, pcfbuflimit
, fname
, op
);
4088 finclude (f
, fname
, op
, is_system_include (fname
), searchptr
);
4091 system_include_depth
--;
4096 /* Return nonzero if there is no need to include file NAME
4097 because it has already been included and it contains a conditional
4098 to make a repeated include do nothing. */
4101 redundant_include_p (name
)
4104 struct file_name_list
*l
= all_include_files
;
4105 for (; l
; l
= l
->next
)
4106 if (! strcmp (name
, l
->fname
)
4108 && lookup (l
->control_macro
, -1, -1))
4113 /* Return nonzero if the given FILENAME is an absolute pathname which
4114 designates a file within one of the known "system" include file
4115 directories. We assume here that if the given FILENAME looks like
4116 it is the name of a file which resides either directly in a "system"
4117 include file directory, or within any subdirectory thereof, then the
4118 given file must be a "system" include file. This function tells us
4119 if we should suppress pedantic errors/warnings for the given FILENAME. */
4122 is_system_include (filename
)
4123 register char *filename
;
4125 struct file_name_list
*searchptr
;
4127 for (searchptr
= first_system_include
; searchptr
;
4128 searchptr
= searchptr
->next
)
4129 if (searchptr
->fname
) {
4130 register char *sys_dir
= searchptr
->fname
;
4131 register unsigned length
= strlen (sys_dir
);
4133 if (! strncmp (sys_dir
, filename
, length
) && filename
[length
] == '/')
4139 /* Process the contents of include file FNAME, already open on descriptor F,
4141 SYSTEM_HEADER_P is 1 if this file resides in any one of the known
4142 "system" include directories (as decided by the `is_system_include'
4144 DIRPTR is the link in the dir path through which this file was found,
4145 or 0 if the file name was absolute. */
4148 finclude (f
, fname
, op
, system_header_p
, dirptr
)
4152 int system_header_p
;
4153 struct file_name_list
*dirptr
;
4158 FILE_BUF
*fp
; /* For input stack frame */
4159 int missing_newline
= 0;
4161 CHECK_DEPTH (return;);
4163 if (file_size_and_mode (f
, &st_mode
, &st_size
) < 0)
4165 perror_with_name (fname
);
4170 fp
= &instack
[indepth
+ 1];
4171 bzero (fp
, sizeof (FILE_BUF
));
4172 fp
->nominal_fname
= fp
->fname
= fname
;
4175 fp
->if_stack
= if_stack
;
4176 fp
->system_header_p
= system_header_p
;
4179 if (S_ISREG (st_mode
)) {
4180 fp
->buf
= (U_CHAR
*) xmalloc (st_size
+ 2);
4183 /* Read the file contents, knowing that st_size is an upper bound
4184 on the number of bytes we can read. */
4185 while (st_size
> 0) {
4186 i
= read (f
, fp
->buf
+ fp
->length
, st_size
);
4195 else if (S_ISDIR (st_mode
)) {
4196 error ("directory `%s' specified in #include", fname
);
4200 /* Cannot count its file size before reading.
4201 First read the entire file into heap and
4202 copy them into buffer on stack. */
4209 basep
= (U_CHAR
*) xmalloc (bsize
+ 2);
4210 fp
->buf
= basep
; /* So it will get freed, on error. */
4214 i
= read (f
, bufp
, bsize
- st_size
);
4216 goto nope
; /* error! */
4218 break; /* End of file */
4221 if (bsize
== st_size
) { /* Buffer is full! */
4223 basep
= (U_CHAR
*) xrealloc (basep
, bsize
+ 2);
4225 bufp
= basep
+ st_size
; /* May have moved */
4229 fp
->length
= st_size
;
4232 if ((fp
->length
> 0 && fp
->buf
[fp
->length
- 1] != '\n')
4233 /* Backslash-newline at end is not good enough. */
4234 || (fp
->length
> 1 && fp
->buf
[fp
->length
- 2] == '\\')) {
4235 fp
->buf
[fp
->length
++] = '\n';
4236 missing_newline
= 1;
4238 fp
->buf
[fp
->length
] = '\0';
4240 /* Close descriptor now, so nesting does not use lots of descriptors. */
4243 /* Must do this before calling trigraph_pcp, so that the correct file name
4244 will be printed in warning messages. */
4247 input_file_stack_tick
++;
4252 output_line_command (fp
, op
, 0, enter_file
);
4255 if (missing_newline
)
4258 if (pedantic
&& missing_newline
)
4259 pedwarn ("file does not end in newline");
4262 input_file_stack_tick
++;
4263 output_line_command (&instack
[indepth
], op
, 0, leave_file
);
4269 perror_with_name (fname
);
4274 /* Record that inclusion of the file named FILE
4275 should be controlled by the macro named MACRO_NAME.
4276 This means that trying to include the file again
4277 will do something if that macro is defined. */
4280 record_control_macro (file
, macro_name
)
4284 struct file_name_list
*new;
4286 for (new = all_include_files
; new; new = new->next
) {
4287 if (!strcmp (new->fname
, file
)) {
4288 new->control_macro
= macro_name
;
4293 /* If the file is not in all_include_files, something's wrong. */
4297 /* Maintain and search list of included files, for #import. */
4299 #define IMPORT_HASH_SIZE 31
4301 struct import_file
{
4305 struct import_file
*next
;
4308 /* Hash table of files already included with #include or #import. */
4310 static struct import_file
*import_hash_table
[IMPORT_HASH_SIZE
];
4312 /* Hash a file name for import_hash_table. */
4320 while (*f
) val
+= *f
++;
4321 return (val
%IMPORT_HASH_SIZE
);
4324 /* Search for file FILENAME in import_hash_table.
4325 Return -2 if found, either a matching name or a matching inode.
4326 Otherwise, open the file and return a file descriptor if successful
4327 or -1 if unsuccessful. */
4330 lookup_import (filename
)
4333 struct import_file
*i
;
4339 hashval
= import_hash (filename
);
4341 /* Attempt to find file in list of already included files */
4342 i
= import_hash_table
[hashval
];
4345 if (!strcmp (filename
, i
->name
))
4346 return -2; /* return found */
4349 /* Open it and try a match on inode/dev */
4350 fd
= open (filename
, O_RDONLY
, 0666);
4354 for (h
= 0; h
< IMPORT_HASH_SIZE
; h
++) {
4355 i
= import_hash_table
[h
];
4357 /* Compare the inode and the device.
4358 Supposedly on some systems the inode is not a scalar. */
4359 if (!bcmp (&i
->inode
, &sb
.st_ino
, sizeof (sb
.st_ino
))
4360 && i
->dev
== sb
.st_dev
) {
4362 return -2; /* return found */
4367 return fd
; /* Not found, return open file */
4370 /* Add the file FNAME, open on descriptor FD, to import_hash_table. */
4373 add_import (fd
, fname
)
4377 struct import_file
*i
;
4381 hashval
= import_hash (fname
);
4383 i
= (struct import_file
*)xmalloc (sizeof (struct import_file
));
4384 i
->name
= (char *)xmalloc (strlen (fname
)+1);
4385 strcpy (i
->name
, fname
);
4386 bcopy (&sb
.st_ino
, &i
->inode
, sizeof (sb
.st_ino
));
4388 i
->next
= import_hash_table
[hashval
];
4389 import_hash_table
[hashval
] = i
;
4392 /* Load the specified precompiled header into core, and verify its
4393 preconditions. PCF indicates the file descriptor to read, which must
4394 be a regular file. FNAME indicates the file name of the original
4395 header. *LIMIT will be set to an address one past the end of the file.
4396 If the preconditions of the file are not satisfied, the buffer is
4397 freed and we return 0. If the preconditions are satisfied, return
4398 the address of the buffer following the preconditions. The buffer, in
4399 this case, should never be freed because various pieces of it will
4400 be referred to until all precompiled strings are output at the end of
4404 check_precompiled (pcf
, fname
, limit
)
4420 if (file_size_and_mode (pcf
, &st_mode
, &st_size
) < 0)
4423 if (S_ISREG (st_mode
))
4425 buf
= xmalloc (st_size
+ 2);
4428 i
= read (pcf
, buf
+ length
, st_size
);
4440 if (length
> 0 && buf
[length
-1] != '\n')
4441 buf
[length
++] = '\n';
4444 *limit
= buf
+ length
;
4446 /* File is in core. Check the preconditions. */
4447 if (!check_preconditions (buf
))
4449 for (cp
= buf
; *cp
; cp
++)
4452 fprintf (stderr
, "Using preinclude %s\n", fname
);
4458 fprintf (stderr
, "Cannot use preinclude %s\n", fname
);
4464 /* PREC (null terminated) points to the preconditions of a
4465 precompiled header. These are a series of #define and #undef
4466 lines which must match the current contents of the hash
4469 check_preconditions (prec
)
4476 lineend
= (char *) index (prec
, '\n');
4478 if (*prec
++ != '#') {
4479 error ("Bad format encountered while reading precompiled file");
4482 if (!strncmp (prec
, "define", 6)) {
4486 mdef
= create_definition (prec
, lineend
, NULL_PTR
);
4491 if ((hp
= lookup (mdef
.symnam
, mdef
.symlen
, -1)) == NULL
4492 || (hp
->type
!= T_MACRO
&& hp
->type
!= T_CONST
)
4493 || (hp
->type
== T_MACRO
4494 && !compare_defs (mdef
.defn
, hp
->value
.defn
)
4495 && (mdef
.defn
->length
!= 2
4496 || mdef
.defn
->expansion
[0] != '\n'
4497 || mdef
.defn
->expansion
[1] != ' ')))
4499 } else if (!strncmp (prec
, "undef", 5)) {
4504 while (is_hor_space
[(U_CHAR
) *prec
])
4507 while (is_idchar
[(U_CHAR
) *prec
])
4511 if (lookup (name
, len
, -1))
4514 error ("Bad format encountered while reading precompiled file");
4519 /* They all passed successfully */
4523 /* Process the main body of a precompiled file. BUF points to the
4524 string section of the file, following the preconditions. LIMIT is one
4525 character past the end. NAME is the name of the file being read
4526 in. OP is the main output buffer */
4528 pcfinclude (buf
, limit
, name
, op
)
4529 U_CHAR
*buf
, *limit
, *name
;
4536 /* First in the file comes 4 bytes indicating the number of strings, */
4537 /* in network byte order. (MSB first). */
4539 nstrings
= (nstrings
<< 8) | *cp
++;
4540 nstrings
= (nstrings
<< 8) | *cp
++;
4541 nstrings
= (nstrings
<< 8) | *cp
++;
4543 /* Looping over each string... */
4544 while (nstrings
--) {
4545 U_CHAR
*string_start
;
4546 U_CHAR
*endofthiskey
;
4550 /* Each string starts with a STRINGDEF structure (str), followed */
4551 /* by the text of the string (string_start) */
4553 /* First skip to a longword boundary */
4554 /* ??? Why a 4-byte boundary? On all machines? */
4555 /* NOTE: This works correctly even if HOST_WIDE_INT
4556 is narrower than a pointer.
4557 Do not try risky measures here to get another type to use!
4558 Do not include gstddef.h or stddef.h--either one will fail! */
4559 if ((HOST_WIDE_INT
) cp
& 3)
4560 cp
+= 4 - ((HOST_WIDE_INT
) cp
& 3);
4562 /* Now get the string. */
4563 str
= (STRINGDEF
*) cp
;
4564 string_start
= cp
+= sizeof (STRINGDEF
);
4566 for (; *cp
; cp
++) /* skip the string */
4569 /* We need to macro expand the string here to ensure that the
4570 proper definition environment is in place. If it were only
4571 expanded when we find out it is needed, macros necessary for
4572 its proper expansion might have had their definitions changed. */
4573 tmpbuf
= expand_to_temp_buffer (string_start
, cp
++, 0, 0);
4574 /* Lineno is already set in the precompiled file */
4575 str
->contents
= tmpbuf
.buf
;
4576 str
->len
= tmpbuf
.length
;
4578 str
->filename
= name
;
4579 str
->output_mark
= outbuf
.bufp
- outbuf
.buf
;
4582 *stringlist_tailp
= str
;
4583 stringlist_tailp
= &str
->chain
;
4585 /* Next comes a fourbyte number indicating the number of keys */
4586 /* for this string. */
4588 nkeys
= (nkeys
<< 8) | *cp
++;
4589 nkeys
= (nkeys
<< 8) | *cp
++;
4590 nkeys
= (nkeys
<< 8) | *cp
++;
4592 /* If this number is -1, then the string is mandatory. */
4596 /* Otherwise, for each key, */
4597 for (; nkeys
--; free (tmpbuf
.buf
), cp
= endofthiskey
+ 1) {
4598 KEYDEF
*kp
= (KEYDEF
*) cp
;
4601 /* It starts with a KEYDEF structure */
4602 cp
+= sizeof (KEYDEF
);
4604 /* Find the end of the key. At the end of this for loop we
4605 advance CP to the start of the next key using this variable. */
4606 endofthiskey
= cp
+ strlen (cp
);
4609 /* Expand the key, and enter it into the hash table. */
4610 tmpbuf
= expand_to_temp_buffer (cp
, endofthiskey
, 0, 0);
4611 tmpbuf
.bufp
= tmpbuf
.buf
;
4613 while (is_hor_space
[*tmpbuf
.bufp
])
4615 if (!is_idstart
[*tmpbuf
.bufp
]
4616 || tmpbuf
.bufp
== tmpbuf
.buf
+ tmpbuf
.length
) {
4621 hp
= lookup (tmpbuf
.bufp
, -1, -1);
4624 install (tmpbuf
.bufp
, -1, T_PCSTRING
, 0, (char *) kp
, -1);
4626 else if (hp
->type
== T_PCSTRING
) {
4627 kp
->chain
= hp
->value
.keydef
;
4628 hp
->value
.keydef
= kp
;
4634 /* This output_line_command serves to switch us back to the current
4635 input file in case some of these strings get output (which will
4636 result in line commands for the header file being output). */
4637 output_line_command (&instack
[indepth
], op
, 0, enter_file
);
4640 /* Called from rescan when it hits a key for strings. Mark them all */
4641 /* used and clean up. */
4648 for (kp
= hp
->value
.keydef
; kp
; kp
= kp
->chain
)
4649 kp
->str
->writeflag
= 1;
4653 /* Write the output, interspersing precompiled strings in their */
4654 /* appropriate places. */
4658 STRINGDEF
*next_string
;
4659 U_CHAR
*cur_buf_loc
;
4660 int line_command_len
= 80;
4661 char *line_command
= xmalloc (line_command_len
);
4664 /* In each run through the loop, either cur_buf_loc == */
4665 /* next_string_loc, in which case we print a series of strings, or */
4666 /* it is less than next_string_loc, in which case we write some of */
4668 cur_buf_loc
= outbuf
.buf
;
4669 next_string
= stringlist
;
4671 while (cur_buf_loc
< outbuf
.bufp
|| next_string
) {
4673 && cur_buf_loc
- outbuf
.buf
== next_string
->output_mark
) {
4674 if (next_string
->writeflag
) {
4675 len
= strlen (next_string
->filename
);
4676 if (len
> line_command_len
)
4677 line_command
= xrealloc (line_command
,
4678 line_command_len
*= 2);
4679 sprintf (line_command
, "\n# %d \"%s\"\n",
4680 next_string
->lineno
, next_string
->filename
);
4681 if (write (fileno (stdout
), line_command
, strlen (line_command
)) < 0)
4682 pfatal_with_name (out_fname
);
4683 if (write (fileno (stdout
), next_string
->contents
, next_string
->len
) < 0)
4684 pfatal_with_name (out_fname
);
4686 next_string
= next_string
->chain
;
4690 ? (next_string
->output_mark
4691 - (cur_buf_loc
- outbuf
.buf
))
4692 : outbuf
.bufp
- cur_buf_loc
);
4694 if (write (fileno (stdout
), cur_buf_loc
, len
) < len
)
4695 pfatal_with_name (out_fname
);
4699 free (line_command
);
4702 /* Pass a directive through to the output file.
4703 BUF points to the contents of the directive, as a contiguous string.
4704 LIMIT points to the first character past the end of the directive.
4705 KEYWORD is the keyword-table entry for the directive. */
4708 pass_thru_directive (buf
, limit
, op
, keyword
)
4709 U_CHAR
*buf
, *limit
;
4711 struct directive
*keyword
;
4713 register unsigned keyword_length
= keyword
->length
;
4715 check_expand (op
, 1 + keyword_length
+ (limit
- buf
));
4717 bcopy (keyword
->name
, op
->bufp
, keyword_length
);
4718 op
->bufp
+= keyword_length
;
4719 if (limit
!= buf
&& buf
[0] != ' ')
4721 bcopy (buf
, op
->bufp
, limit
- buf
);
4722 op
->bufp
+= (limit
- buf
);
4725 /* Count the line we have just made in the output,
4726 to get in sync properly. */
4731 /* The arglist structure is built by do_define to tell
4732 collect_definition where the argument names begin. That
4733 is, for a define like "#define f(x,y,z) foo+x-bar*y", the arglist
4734 would contain pointers to the strings x, y, and z.
4735 Collect_definition would then build a DEFINITION node,
4736 with reflist nodes pointing to the places x, y, and z had
4737 appeared. So the arglist is just convenience data passed
4738 between these two routines. It is not kept around after
4739 the current #define has been processed and entered into the
4743 struct arglist
*next
;
4750 /* Create a DEFINITION node from a #define directive. Arguments are
4751 as for do_define. */
4753 create_definition (buf
, limit
, op
)
4754 U_CHAR
*buf
, *limit
;
4757 U_CHAR
*bp
; /* temp ptr into input buffer */
4758 U_CHAR
*symname
; /* remember where symbol name starts */
4759 int sym_length
; /* and how long it is */
4760 int line
= instack
[indepth
].lineno
;
4761 char *file
= instack
[indepth
].nominal_fname
;
4765 int arglengths
= 0; /* Accumulate lengths of arg names
4766 plus number of args. */
4771 while (is_hor_space
[*bp
])
4774 symname
= bp
; /* remember where it starts */
4775 sym_length
= check_macro_name (bp
, "macro");
4778 /* Lossage will occur if identifiers or control keywords are broken
4779 across lines using backslash. This is not the right place to take
4783 struct arglist
*arg_ptrs
= NULL
;
4786 bp
++; /* skip '(' */
4787 SKIP_WHITE_SPACE (bp
);
4789 /* Loop over macro argument names. */
4790 while (*bp
!= ')') {
4791 struct arglist
*temp
;
4793 temp
= (struct arglist
*) alloca (sizeof (struct arglist
));
4795 temp
->next
= arg_ptrs
;
4796 temp
->argno
= argno
++;
4797 temp
->rest_args
= 0;
4801 pedwarn ("another parameter follows `%s'",
4804 if (!is_idstart
[*bp
])
4805 pedwarn ("invalid character in macro parameter name");
4807 /* Find the end of the arg name. */
4808 while (is_idchar
[*bp
]) {
4810 /* do we have a "special" rest-args extension here? */
4811 if (limit
- bp
> REST_EXTENSION_LENGTH
&&
4812 strncmp (rest_extension
, bp
, REST_EXTENSION_LENGTH
) == 0) {
4814 temp
->rest_args
= 1;
4818 temp
->length
= bp
- temp
->name
;
4820 bp
+= REST_EXTENSION_LENGTH
;
4821 arglengths
+= temp
->length
+ 2;
4822 SKIP_WHITE_SPACE (bp
);
4823 if (temp
->length
== 0 || (*bp
!= ',' && *bp
!= ')')) {
4824 error ("badly punctuated parameter list in `#define'");
4829 SKIP_WHITE_SPACE (bp
);
4832 error ("unterminated parameter list in `#define'");
4836 struct arglist
*otemp
;
4838 for (otemp
= temp
->next
; otemp
!= NULL
; otemp
= otemp
->next
)
4839 if (temp
->length
== otemp
->length
&&
4840 strncmp (temp
->name
, otemp
->name
, temp
->length
) == 0) {
4843 name
= (U_CHAR
*) alloca (temp
->length
+ 1);
4844 (void) strncpy (name
, temp
->name
, temp
->length
);
4845 name
[temp
->length
] = '\0';
4846 error ("duplicate argument name `%s' in `#define'", name
);
4852 ++bp
; /* skip paren */
4853 /* Skip exactly one space or tab if any. */
4854 if (bp
< limit
&& (*bp
== ' ' || *bp
== '\t')) ++bp
;
4855 /* now everything from bp before limit is the definition. */
4856 defn
= collect_expansion (bp
, limit
, argno
, arg_ptrs
);
4857 defn
->rest_args
= rest_args
;
4859 /* Now set defn->args.argnames to the result of concatenating
4860 the argument names in reverse order
4861 with comma-space between them. */
4862 defn
->args
.argnames
= (U_CHAR
*) xmalloc (arglengths
+ 1);
4864 struct arglist
*temp
;
4866 for (temp
= arg_ptrs
; temp
; temp
= temp
->next
) {
4867 bcopy (temp
->name
, &defn
->args
.argnames
[i
], temp
->length
);
4869 if (temp
->next
!= 0) {
4870 defn
->args
.argnames
[i
++] = ',';
4871 defn
->args
.argnames
[i
++] = ' ';
4874 defn
->args
.argnames
[i
] = 0;
4877 /* simple expansion or empty definition; gobble it */
4878 if (is_hor_space
[*bp
])
4879 ++bp
; /* skip exactly one blank/tab char */
4880 /* now everything from bp before limit is the definition. */
4881 defn
= collect_expansion (bp
, limit
, -1, NULL_PTR
);
4882 defn
->args
.argnames
= (U_CHAR
*) "";
4888 /* OP is null if this is a predefinition */
4889 defn
->predefined
= !op
;
4891 mdef
.symnam
= symname
;
4892 mdef
.symlen
= sym_length
;
4901 /* Process a #define command.
4902 BUF points to the contents of the #define command, as a contiguous string.
4903 LIMIT points to the first character past the end of the definition.
4904 KEYWORD is the keyword-table entry for #define. */
4907 do_define (buf
, limit
, op
, keyword
)
4908 U_CHAR
*buf
, *limit
;
4910 struct directive
*keyword
;
4915 /* If this is a precompiler run (with -pcp) pass thru #define commands. */
4916 if (pcp_outfile
&& op
)
4917 pass_thru_directive (buf
, limit
, op
, keyword
);
4919 mdef
= create_definition (buf
, limit
, op
);
4923 hashcode
= hashf (mdef
.symnam
, mdef
.symlen
, HASHSIZE
);
4927 if ((hp
= lookup (mdef
.symnam
, mdef
.symlen
, hashcode
)) != NULL
) {
4929 /* Redefining a precompiled key is ok. */
4930 if (hp
->type
== T_PCSTRING
)
4932 /* Redefining a macro is ok if the definitions are the same. */
4933 else if (hp
->type
== T_MACRO
)
4934 ok
= ! compare_defs (mdef
.defn
, hp
->value
.defn
);
4935 /* Redefining a constant is ok with -D. */
4936 else if (hp
->type
== T_CONST
)
4937 ok
= ! done_initializing
;
4938 /* Print the warning if it's not ok. */
4940 U_CHAR
*msg
; /* what pain... */
4942 /* If we are passing through #define and #undef directives, do
4943 that for this re-definition now. */
4944 if (debug_output
&& op
)
4945 pass_thru_directive (buf
, limit
, op
, keyword
);
4947 msg
= (U_CHAR
*) alloca (mdef
.symlen
+ 22);
4949 bcopy (mdef
.symnam
, msg
+ 1, mdef
.symlen
);
4950 strcpy ((char *) (msg
+ mdef
.symlen
+ 1), "' redefined");
4952 if (hp
->type
== T_MACRO
)
4953 pedwarn_with_file_and_line (hp
->value
.defn
->file
, hp
->value
.defn
->line
,
4954 "this is the location of the previous definition");
4956 /* Replace the old definition. */
4958 hp
->value
.defn
= mdef
.defn
;
4960 /* If we are passing through #define and #undef directives, do
4961 that for this new definition now. */
4962 if (debug_output
&& op
)
4963 pass_thru_directive (buf
, limit
, op
, keyword
);
4964 install (mdef
.symnam
, mdef
.symlen
, T_MACRO
, 0,
4965 (char *) mdef
.defn
, hashcode
);
4976 /* Check a purported macro name SYMNAME, and yield its length.
4977 USAGE is the kind of name this is intended for. */
4980 check_macro_name (symname
, usage
)
4987 for (p
= symname
; is_idchar
[*p
]; p
++)
4989 sym_length
= p
- symname
;
4990 if (sym_length
== 0)
4991 error ("invalid %s name", usage
);
4992 else if (!is_idstart
[*symname
]) {
4993 U_CHAR
*msg
; /* what pain... */
4994 msg
= (U_CHAR
*) alloca (sym_length
+ 1);
4995 bcopy (symname
, msg
, sym_length
);
4996 msg
[sym_length
] = 0;
4997 error ("invalid %s name `%s'", usage
, msg
);
4999 if (! strncmp (symname
, "defined", 7) && sym_length
== 7)
5000 error ("invalid %s name `defined'", usage
);
5006 * return zero if two DEFINITIONs are isomorphic
5009 compare_defs (d1
, d2
)
5010 DEFINITION
*d1
, *d2
;
5012 register struct reflist
*a1
, *a2
;
5013 register U_CHAR
*p1
= d1
->expansion
;
5014 register U_CHAR
*p2
= d2
->expansion
;
5017 if (d1
->nargs
!= d2
->nargs
)
5019 if (strcmp ((char *)d1
->args
.argnames
, (char *)d2
->args
.argnames
))
5021 for (a1
= d1
->pattern
, a2
= d2
->pattern
; a1
&& a2
;
5022 a1
= a1
->next
, a2
= a2
->next
) {
5023 if (!((a1
->nchars
== a2
->nchars
&& ! strncmp (p1
, p2
, a1
->nchars
))
5024 || ! comp_def_part (first
, p1
, a1
->nchars
, p2
, a2
->nchars
, 0))
5025 || a1
->argno
!= a2
->argno
5026 || a1
->stringify
!= a2
->stringify
5027 || a1
->raw_before
!= a2
->raw_before
5028 || a1
->raw_after
!= a2
->raw_after
)
5036 if (comp_def_part (first
, p1
, d1
->length
- (p1
- d1
->expansion
),
5037 p2
, d2
->length
- (p2
- d2
->expansion
), 1))
5042 /* Return 1 if two parts of two macro definitions are effectively different.
5043 One of the parts starts at BEG1 and has LEN1 chars;
5044 the other has LEN2 chars at BEG2.
5045 Any sequence of whitespace matches any other sequence of whitespace.
5046 FIRST means these parts are the first of a macro definition;
5047 so ignore leading whitespace entirely.
5048 LAST means these parts are the last of a macro definition;
5049 so ignore trailing whitespace entirely. */
5052 comp_def_part (first
, beg1
, len1
, beg2
, len2
, last
)
5054 U_CHAR
*beg1
, *beg2
;
5058 register U_CHAR
*end1
= beg1
+ len1
;
5059 register U_CHAR
*end2
= beg2
+ len2
;
5061 while (beg1
!= end1
&& is_space
[*beg1
]) beg1
++;
5062 while (beg2
!= end2
&& is_space
[*beg2
]) beg2
++;
5065 while (beg1
!= end1
&& is_space
[end1
[-1]]) end1
--;
5066 while (beg2
!= end2
&& is_space
[end2
[-1]]) end2
--;
5068 while (beg1
!= end1
&& beg2
!= end2
) {
5069 if (is_space
[*beg1
] && is_space
[*beg2
]) {
5070 while (beg1
!= end1
&& is_space
[*beg1
]) beg1
++;
5071 while (beg2
!= end2
&& is_space
[*beg2
]) beg2
++;
5072 } else if (*beg1
== *beg2
) {
5076 return (beg1
!= end1
) || (beg2
!= end2
);
5079 /* Read a replacement list for a macro with parameters.
5080 Build the DEFINITION structure.
5081 Reads characters of text starting at BUF until END.
5082 ARGLIST specifies the formal parameters to look for
5083 in the text of the definition; NARGS is the number of args
5084 in that list, or -1 for a macro name that wants no argument list.
5085 MACRONAME is the macro name itself (so we can avoid recursive expansion)
5086 and NAMELEN is its length in characters.
5088 Note that comments and backslash-newlines have already been deleted
5089 from the argument. */
5091 /* Leading and trailing Space, Tab, etc. are converted to markers
5092 Newline Space, Newline Tab, etc.
5093 Newline Space makes a space in the final output
5094 but is discarded if stringified. (Newline Tab is similar but
5095 makes a Tab instead.)
5097 If there is no trailing whitespace, a Newline Space is added at the end
5098 to prevent concatenation that would be contrary to the standard. */
5101 collect_expansion (buf
, end
, nargs
, arglist
)
5104 struct arglist
*arglist
;
5107 register U_CHAR
*p
, *limit
, *lastp
, *exp_p
;
5108 struct reflist
*endpat
= NULL
;
5109 /* Pointer to first nonspace after last ## seen. */
5111 /* Pointer to first nonspace after last single-# seen. */
5112 U_CHAR
*stringify
= 0;
5114 int expected_delimiter
= '\0';
5116 /* Scan thru the replacement list, ignoring comments and quoted
5117 strings, picking up on the macro calls. It does a linear search
5118 thru the arg list on every potential symbol. Profiling might say
5119 that something smarter should happen. */
5124 /* Find the beginning of the trailing whitespace. */
5125 /* Find end of leading whitespace. */
5128 while (p
< limit
&& is_space
[limit
[-1]]) limit
--;
5129 while (p
< limit
&& is_space
[*p
]) p
++;
5131 /* Allocate space for the text in the macro definition.
5132 Leading and trailing whitespace chars need 2 bytes each.
5133 Each other input char may or may not need 1 byte,
5134 so this is an upper bound.
5135 The extra 2 are for invented trailing newline-marker and final null. */
5136 maxsize
= (sizeof (DEFINITION
)
5137 + 2 * (end
- limit
) + 2 * (p
- buf
)
5139 defn
= (DEFINITION
*) xcalloc (1, maxsize
);
5141 defn
->nargs
= nargs
;
5142 exp_p
= defn
->expansion
= (U_CHAR
*) defn
+ sizeof (DEFINITION
);
5147 /* Convert leading whitespace to Newline-markers. */
5148 while (p
< limit
&& is_space
[*p
]) {
5153 if (limit
- p
>= 2 && p
[0] == '#' && p
[1] == '#') {
5154 error ("`##' at start of macro definition");
5158 /* Process the main body of the definition. */
5160 int skipped_arg
= 0;
5161 register U_CHAR c
= *p
++;
5169 if (expected_delimiter
!= '\0') {
5170 if (c
== expected_delimiter
)
5171 expected_delimiter
= '\0';
5173 expected_delimiter
= c
;
5176 /* Special hack: if a \# is written in the #define
5177 include a # in the definition. This is useless for C code
5178 but useful for preprocessing other things. */
5181 /* \# quotes a # even outside of strings. */
5182 if (p
< limit
&& *p
== '#' && !expected_delimiter
) {
5185 } else if (p
< limit
&& expected_delimiter
) {
5186 /* In a string, backslash goes through
5187 and makes next char ordinary. */
5193 /* # is ordinary inside a string. */
5194 if (expected_delimiter
)
5196 if (p
< limit
&& *p
== '#') {
5197 /* ##: concatenate preceding and following tokens. */
5198 /* Take out the first #, discard preceding whitespace. */
5200 while (exp_p
> lastp
&& is_hor_space
[exp_p
[-1]])
5202 /* Skip the second #. */
5204 /* Discard following whitespace. */
5205 SKIP_WHITE_SPACE (p
);
5208 error ("`##' at end of macro definition");
5209 } else if (nargs
>= 0) {
5210 /* Single #: stringify following argument ref.
5211 Don't leave the # in the expansion. */
5213 SKIP_WHITE_SPACE (p
);
5214 if (p
== limit
|| ! is_idstart
[*p
])
5215 error ("`#' operator is not followed by a macro argument name");
5222 /* In -traditional mode, recognize arguments inside strings and
5223 and character constants, and ignore special properties of #.
5224 Arguments inside strings are considered "stringified", but no
5225 extra quote marks are supplied. */
5229 if (expected_delimiter
!= '\0') {
5230 if (c
== expected_delimiter
)
5231 expected_delimiter
= '\0';
5233 expected_delimiter
= c
;
5237 /* Backslash quotes delimiters and itself, but not macro args. */
5238 if (expected_delimiter
!= 0 && p
< limit
5239 && (*p
== expected_delimiter
|| *p
== '\\')) {
5246 if (expected_delimiter
!= '\0') /* No comments inside strings. */
5249 /* If we find a comment that wasn't removed by handle_directive,
5250 this must be -traditional. So replace the comment with
5254 while (p
< limit
&& !(p
[-2] == '*' && p
[-1] == '/'))
5257 /* Mark this as a concatenation-point, as if it had been ##. */
5265 /* Handle the start of a symbol. */
5266 if (is_idchar
[c
] && nargs
> 0) {
5267 U_CHAR
*id_beg
= p
- 1;
5271 while (p
!= limit
&& is_idchar
[*p
]) p
++;
5272 id_len
= p
- id_beg
;
5274 if (is_idstart
[c
]) {
5275 register struct arglist
*arg
;
5277 for (arg
= arglist
; arg
!= NULL
; arg
= arg
->next
) {
5278 struct reflist
*tpat
;
5280 if (arg
->name
[0] == c
5281 && arg
->length
== id_len
5282 && strncmp (arg
->name
, id_beg
, id_len
) == 0) {
5283 if (expected_delimiter
&& warn_stringify
) {
5285 warning ("macro argument `%.*s' is stringified.",
5288 warning ("macro arg `%.*s' would be stringified with -traditional.",
5292 /* If ANSI, don't actually substitute inside a string. */
5293 if (!traditional
&& expected_delimiter
)
5295 /* make a pat node for this arg and append it to the end of
5297 tpat
= (struct reflist
*) xmalloc (sizeof (struct reflist
));
5299 tpat
->raw_before
= concat
== id_beg
;
5300 tpat
->raw_after
= 0;
5301 tpat
->rest_args
= arg
->rest_args
;
5302 tpat
->stringify
= (traditional
? expected_delimiter
!= '\0'
5303 : stringify
== id_beg
);
5306 defn
->pattern
= tpat
;
5308 endpat
->next
= tpat
;
5311 tpat
->argno
= arg
->argno
;
5312 tpat
->nchars
= exp_p
- lastp
;
5314 register U_CHAR
*p1
= p
;
5315 SKIP_WHITE_SPACE (p1
);
5316 if (p1
+ 2 <= limit
&& p1
[0] == '#' && p1
[1] == '#')
5317 tpat
->raw_after
= 1;
5319 lastp
= exp_p
; /* place to start copying from next time */
5326 /* If this was not a macro arg, copy it into the expansion. */
5327 if (! skipped_arg
) {
5328 register U_CHAR
*lim1
= p
;
5332 if (stringify
== id_beg
)
5333 error ("`#' operator should be followed by a macro argument name");
5339 /* Convert trailing whitespace to Newline-markers. */
5340 while (limit
< end
&& is_space
[*limit
]) {
5342 *exp_p
++ = *limit
++;
5344 } else if (!traditional
&& expected_delimiter
== 0) {
5345 /* There is no trailing whitespace, so invent some in ANSI mode.
5346 But not if "inside a string" (which in ANSI mode
5347 happens only for -D option). */
5354 defn
->length
= exp_p
- defn
->expansion
;
5356 /* Crash now if we overrun the allocated size. */
5357 if (defn
->length
+ 1 > maxsize
)
5361 /* This isn't worth the time it takes. */
5362 /* give back excess storage */
5363 defn
->expansion
= (U_CHAR
*) xrealloc (defn
->expansion
, defn
->length
+ 1);
5370 do_assert (buf
, limit
, op
, keyword
)
5371 U_CHAR
*buf
, *limit
;
5373 struct directive
*keyword
;
5375 U_CHAR
*bp
; /* temp ptr into input buffer */
5376 U_CHAR
*symname
; /* remember where symbol name starts */
5377 int sym_length
; /* and how long it is */
5378 struct arglist
*tokens
= NULL
;
5380 if (pedantic
&& done_initializing
&& !instack
[indepth
].system_header_p
)
5381 pedwarn ("ANSI C does not allow `#assert'");
5385 while (is_hor_space
[*bp
])
5388 symname
= bp
; /* remember where it starts */
5389 sym_length
= check_macro_name (bp
, "assertion");
5391 /* #define doesn't do this, but we should. */
5392 SKIP_WHITE_SPACE (bp
);
5394 /* Lossage will occur if identifiers or control tokens are broken
5395 across lines using backslash. This is not the right place to take
5399 error ("missing token-sequence in `#assert'");
5406 bp
++; /* skip '(' */
5407 SKIP_WHITE_SPACE (bp
);
5409 tokens
= read_token_list (&bp
, limit
, &error_flag
);
5413 error ("empty token-sequence in `#assert'");
5417 ++bp
; /* skip paren */
5418 SKIP_WHITE_SPACE (bp
);
5421 /* If this name isn't already an assertion name, make it one.
5422 Error if it was already in use in some other way. */
5425 ASSERTION_HASHNODE
*hp
;
5426 int hashcode
= hashf (symname
, sym_length
, ASSERTION_HASHSIZE
);
5427 struct tokenlist_list
*value
5428 = (struct tokenlist_list
*) xmalloc (sizeof (struct tokenlist_list
));
5430 hp
= assertion_lookup (symname
, sym_length
, hashcode
);
5432 if (sym_length
== 7 && ! strncmp (symname
, "defined", sym_length
))
5433 error ("`defined' redefined as assertion");
5434 hp
= assertion_install (symname
, sym_length
, hashcode
);
5437 /* Add the spec'd token-sequence to the list of such. */
5438 value
->tokens
= tokens
;
5439 value
->next
= hp
->value
;
5447 do_unassert (buf
, limit
, op
, keyword
)
5448 U_CHAR
*buf
, *limit
;
5450 struct directive
*keyword
;
5452 U_CHAR
*bp
; /* temp ptr into input buffer */
5453 U_CHAR
*symname
; /* remember where symbol name starts */
5454 int sym_length
; /* and how long it is */
5456 struct arglist
*tokens
= NULL
;
5457 int tokens_specified
= 0;
5459 if (pedantic
&& done_initializing
&& !instack
[indepth
].system_header_p
)
5460 pedwarn ("ANSI C does not allow `#unassert'");
5464 while (is_hor_space
[*bp
])
5467 symname
= bp
; /* remember where it starts */
5468 sym_length
= check_macro_name (bp
, "assertion");
5470 /* #define doesn't do this, but we should. */
5471 SKIP_WHITE_SPACE (bp
);
5473 /* Lossage will occur if identifiers or control tokens are broken
5474 across lines using backslash. This is not the right place to take
5480 bp
++; /* skip '(' */
5481 SKIP_WHITE_SPACE (bp
);
5483 tokens
= read_token_list (&bp
, limit
, &error_flag
);
5487 error ("empty token list in `#unassert'");
5491 tokens_specified
= 1;
5493 ++bp
; /* skip paren */
5494 SKIP_WHITE_SPACE (bp
);
5498 ASSERTION_HASHNODE
*hp
;
5499 int hashcode
= hashf (symname
, sym_length
, ASSERTION_HASHSIZE
);
5500 struct tokenlist_list
*tail
, *prev
;
5502 hp
= assertion_lookup (symname
, sym_length
, hashcode
);
5506 /* If no token list was specified, then eliminate this assertion
5508 if (! tokens_specified
) {
5509 struct tokenlist_list
*next
;
5510 for (tail
= hp
->value
; tail
; tail
= next
) {
5512 free_token_list (tail
->tokens
);
5515 delete_assertion (hp
);
5517 /* If a list of tokens was given, then delete any matching list. */
5522 struct tokenlist_list
*next
= tail
->next
;
5523 if (compare_token_lists (tail
->tokens
, tokens
)) {
5527 hp
->value
= tail
->next
;
5528 free_token_list (tail
->tokens
);
5541 /* Test whether there is an assertion named NAME
5542 and optionally whether it has an asserted token list TOKENS.
5543 NAME is not null terminated; its length is SYM_LENGTH.
5544 If TOKENS_SPECIFIED is 0, then don't check for any token list. */
5547 check_assertion (name
, sym_length
, tokens_specified
, tokens
)
5550 int tokens_specified
;
5551 struct arglist
*tokens
;
5553 ASSERTION_HASHNODE
*hp
;
5554 int hashcode
= hashf (name
, sym_length
, ASSERTION_HASHSIZE
);
5556 if (pedantic
&& !instack
[indepth
].system_header_p
)
5557 pedwarn ("ANSI C does not allow testing assertions");
5559 hp
= assertion_lookup (name
, sym_length
, hashcode
);
5561 /* It is not an assertion; just return false. */
5564 /* If no token list was specified, then value is 1. */
5565 if (! tokens_specified
)
5569 struct tokenlist_list
*tail
;
5573 /* If a list of tokens was given,
5574 then succeed if the assertion records a matching list. */
5577 if (compare_token_lists (tail
->tokens
, tokens
))
5582 /* Fail if the assertion has no matching list. */
5587 /* Compare two lists of tokens for equality including order of tokens. */
5590 compare_token_lists (l1
, l2
)
5591 struct arglist
*l1
, *l2
;
5594 if (l1
->length
!= l2
->length
)
5596 if (strncmp (l1
->name
, l2
->name
, l1
->length
))
5602 /* Succeed if both lists end at the same time. */
5606 /* Read a space-separated list of tokens ending in a close parenthesis.
5607 Return a list of strings, in the order they were written.
5608 (In case of error, return 0 and store -1 in *ERROR_FLAG.)
5609 Parse the text starting at *BPP, and update *BPP.
5610 Don't parse beyond LIMIT. */
5612 static struct arglist
*
5613 read_token_list (bpp
, limit
, error_flag
)
5618 struct arglist
*token_ptrs
= 0;
5624 /* Loop over the assertion value tokens. */
5626 struct arglist
*temp
;
5630 /* Find the end of the token. */
5634 } else if (*bp
== ')') {
5639 } else if (*bp
== '"' || *bp
== '\'')
5640 bp
= skip_quoted_string (bp
, limit
, 0, NULL_PTR
, NULL_PTR
, &eofp
);
5642 while (! is_hor_space
[*bp
] && *bp
!= '(' && *bp
!= ')'
5643 && *bp
!= '"' && *bp
!= '\'' && bp
!= limit
)
5646 temp
= (struct arglist
*) xmalloc (sizeof (struct arglist
));
5647 temp
->name
= (U_CHAR
*) xmalloc (bp
- beg
+ 1);
5648 bcopy (beg
, temp
->name
, bp
- beg
);
5649 temp
->name
[bp
- beg
] = 0;
5650 temp
->next
= token_ptrs
;
5652 temp
->length
= bp
- beg
;
5654 SKIP_WHITE_SPACE (bp
);
5657 error ("unterminated token sequence in `#assert' or `#unassert'");
5664 /* We accumulated the names in reverse order.
5665 Now reverse them to get the proper order. */
5667 register struct arglist
*prev
= 0, *this, *next
;
5668 for (this = token_ptrs
; this; this = next
) {
5678 free_token_list (tokens
)
5679 struct arglist
*tokens
;
5682 struct arglist
*next
= tokens
->next
;
5683 free (tokens
->name
);
5690 * Install a name in the assertion hash table.
5692 * If LEN is >= 0, it is the length of the name.
5693 * Otherwise, compute the length by scanning the entire name.
5695 * If HASH is >= 0, it is the precomputed hash code.
5696 * Otherwise, compute the hash code.
5698 static ASSERTION_HASHNODE
*
5699 assertion_install (name
, len
, hash
)
5704 register ASSERTION_HASHNODE
*hp
;
5705 register int i
, bucket
;
5706 register U_CHAR
*p
, *q
;
5708 i
= sizeof (ASSERTION_HASHNODE
) + len
+ 1;
5709 hp
= (ASSERTION_HASHNODE
*) xmalloc (i
);
5711 hp
->bucket_hdr
= &assertion_hashtab
[bucket
];
5712 hp
->next
= assertion_hashtab
[bucket
];
5713 assertion_hashtab
[bucket
] = hp
;
5715 if (hp
->next
!= NULL
)
5716 hp
->next
->prev
= hp
;
5719 hp
->name
= ((U_CHAR
*) hp
) + sizeof (ASSERTION_HASHNODE
);
5722 for (i
= 0; i
< len
; i
++)
5729 * find the most recent hash node for name name (ending with first
5730 * non-identifier char) installed by install
5732 * If LEN is >= 0, it is the length of the name.
5733 * Otherwise, compute the length by scanning the entire name.
5735 * If HASH is >= 0, it is the precomputed hash code.
5736 * Otherwise, compute the hash code.
5738 static ASSERTION_HASHNODE
*
5739 assertion_lookup (name
, len
, hash
)
5744 register U_CHAR
*bp
;
5745 register ASSERTION_HASHNODE
*bucket
;
5747 bucket
= assertion_hashtab
[hash
];
5749 if (bucket
->length
== len
&& strncmp (bucket
->name
, name
, len
) == 0)
5751 bucket
= bucket
->next
;
5757 delete_assertion (hp
)
5758 ASSERTION_HASHNODE
*hp
;
5761 if (hp
->prev
!= NULL
)
5762 hp
->prev
->next
= hp
->next
;
5763 if (hp
->next
!= NULL
)
5764 hp
->next
->prev
= hp
->prev
;
5766 /* make sure that the bucket chain header that
5767 the deleted guy was on points to the right thing afterwards. */
5768 if (hp
== *hp
->bucket_hdr
)
5769 *hp
->bucket_hdr
= hp
->next
;
5775 * interpret #line command. Remembers previously seen fnames
5776 * in its very own hash table.
5778 #define FNAME_HASHSIZE 37
5781 do_line (buf
, limit
, op
, keyword
)
5782 U_CHAR
*buf
, *limit
;
5784 struct directive
*keyword
;
5786 register U_CHAR
*bp
;
5787 FILE_BUF
*ip
= &instack
[indepth
];
5790 enum file_change_code file_change
= same_file
;
5792 /* Expand any macros. */
5793 tem
= expand_to_temp_buffer (buf
, limit
, 0, 0);
5795 /* Point to macroexpanded line, which is null-terminated now. */
5797 SKIP_WHITE_SPACE (bp
);
5799 if (!isdigit (*bp
)) {
5800 error ("invalid format `#line' command");
5804 /* The Newline at the end of this line remains to be processed.
5805 To put the next line at the specified line number,
5806 we must store a line number now that is one less. */
5807 new_lineno
= atoi (bp
) - 1;
5809 /* NEW_LINENO is one less than the actual line number here. */
5810 if (pedantic
&& new_lineno
< 0)
5811 pedwarn ("line number out of range in `#line' command");
5813 /* skip over the line number. */
5814 while (isdigit (*bp
))
5817 #if 0 /* #line 10"foo.c" is supposed to be allowed. */
5818 if (*bp
&& !is_space
[*bp
]) {
5819 error ("invalid format `#line' command");
5824 SKIP_WHITE_SPACE (bp
);
5827 static HASHNODE
*fname_table
[FNAME_HASHSIZE
];
5828 HASHNODE
*hp
, **hash_bucket
;
5834 while (*bp
&& *bp
!= '\"')
5837 error ("invalid format `#line' command");
5841 fname_length
= bp
- fname
;
5844 SKIP_WHITE_SPACE (bp
);
5847 pedwarn ("garbage at end of `#line' command");
5849 file_change
= enter_file
;
5850 else if (*bp
== '2')
5851 file_change
= leave_file
;
5852 else if (*bp
== '3')
5853 ip
->system_header_p
= 1;
5855 error ("invalid format `#line' command");
5860 SKIP_WHITE_SPACE (bp
);
5862 ip
->system_header_p
= 1;
5864 SKIP_WHITE_SPACE (bp
);
5867 error ("invalid format `#line' command");
5873 &fname_table
[hashf (fname
, fname_length
, FNAME_HASHSIZE
)];
5874 for (hp
= *hash_bucket
; hp
!= NULL
; hp
= hp
->next
)
5875 if (hp
->length
== fname_length
&&
5876 strncmp (hp
->value
.cpval
, fname
, fname_length
) == 0) {
5877 ip
->nominal_fname
= hp
->value
.cpval
;
5881 /* Didn't find it; cons up a new one. */
5882 hp
= (HASHNODE
*) xcalloc (1, sizeof (HASHNODE
) + fname_length
+ 1);
5883 hp
->next
= *hash_bucket
;
5886 hp
->length
= fname_length
;
5887 ip
->nominal_fname
= hp
->value
.cpval
= ((char *) hp
) + sizeof (HASHNODE
);
5888 bcopy (fname
, hp
->value
.cpval
, fname_length
);
5891 error ("invalid format `#line' command");
5895 ip
->lineno
= new_lineno
;
5896 output_line_command (ip
, op
, 0, file_change
);
5897 check_expand (op
, ip
->length
- (ip
->bufp
- ip
->buf
));
5902 * remove the definition of a symbol from the symbol table.
5903 * according to un*x /lib/cpp, it is not an error to undef
5904 * something that has no definitions, so it isn't one here either.
5908 do_undef (buf
, limit
, op
, keyword
)
5909 U_CHAR
*buf
, *limit
;
5911 struct directive
*keyword
;
5915 U_CHAR
*orig_buf
= buf
;
5917 /* If this is a precompiler run (with -pcp) pass thru #undef commands. */
5918 if (pcp_outfile
&& op
)
5919 pass_thru_directive (buf
, limit
, op
, keyword
);
5921 SKIP_WHITE_SPACE (buf
);
5922 sym_length
= check_macro_name (buf
, "macro");
5924 while ((hp
= lookup (buf
, sym_length
, -1)) != NULL
) {
5925 /* If we are generating additional info for debugging (with -g) we
5926 need to pass through all effective #undef commands. */
5927 if (debug_output
&& op
)
5928 pass_thru_directive (orig_buf
, limit
, op
, keyword
);
5929 if (hp
->type
!= T_MACRO
)
5930 warning ("undefining `%s'", hp
->name
);
5936 SKIP_WHITE_SPACE (buf
);
5938 pedwarn ("garbage after `#undef' directive");
5944 * Report a fatal error detected by the program we are processing.
5945 * Use the text of the line in the error message, then terminate.
5946 * (We use error because it prints the filename & line#.)
5950 do_error (buf
, limit
, op
, keyword
)
5951 U_CHAR
*buf
, *limit
;
5953 struct directive
*keyword
;
5955 int length
= limit
- buf
;
5956 U_CHAR
*copy
= (U_CHAR
*) xmalloc (length
+ 1);
5957 bcopy (buf
, copy
, length
);
5959 SKIP_WHITE_SPACE (copy
);
5960 error ("#error %s", copy
);
5961 exit (FAILURE_EXIT_CODE
);
5967 * Report a warning detected by the program we are processing.
5968 * Use the text of the line in the warning message, then continue.
5969 * (We use error because it prints the filename & line#.)
5973 do_warning (buf
, limit
, op
, keyword
)
5974 U_CHAR
*buf
, *limit
;
5976 struct directive
*keyword
;
5978 int length
= limit
- buf
;
5979 U_CHAR
*copy
= (U_CHAR
*) xmalloc (length
+ 1);
5980 bcopy (buf
, copy
, length
);
5982 SKIP_WHITE_SPACE (copy
);
5983 warning ("#warning %s", copy
);
5987 /* Remember the name of the current file being read from so that we can
5988 avoid ever including it again. */
5994 FILE_BUF
*ip
= NULL
;
5996 for (i
= indepth
; i
>= 0; i
--)
5997 if (instack
[i
].fname
!= NULL
) {
6003 struct file_name_list
*new;
6005 new = (struct file_name_list
*) xmalloc (sizeof (struct file_name_list
));
6006 new->next
= dont_repeat_files
;
6007 dont_repeat_files
= new;
6008 new->fname
= savestring (ip
->fname
);
6009 new->control_macro
= 0;
6014 /* #ident has already been copied to the output file, so just ignore it. */
6017 do_ident (buf
, limit
)
6018 U_CHAR
*buf
, *limit
;
6020 /* Allow #ident in system headers, since that's not user's fault. */
6021 if (pedantic
&& !instack
[indepth
].system_header_p
)
6022 pedwarn ("ANSI C does not allow `#ident'");
6026 /* #pragma and its argument line have already been copied to the output file.
6027 Just check for some recognized pragmas that need validation here. */
6030 do_pragma (buf
, limit
)
6031 U_CHAR
*buf
, *limit
;
6033 while (*buf
== ' ' || *buf
== '\t')
6035 if (!strncmp (buf
, "once", 4)) {
6036 /* Allow #pragma once in system headers, since that's not the user's
6038 if (!instack
[indepth
].system_header_p
)
6039 warning ("`#pragma once' is obsolete");
6043 if (!strncmp (buf
, "implementation", 14)) {
6044 /* Be quiet about `#pragma implementation' for a file only if it hasn't
6045 been included yet. */
6046 struct file_name_list
*ptr
;
6047 U_CHAR
*p
= buf
+ 14, *fname
, *inc_fname
;
6048 SKIP_WHITE_SPACE (p
);
6049 if (*p
== '\n' || *p
!= '\"')
6053 if (p
= (U_CHAR
*) index (fname
, '\"'))
6056 for (ptr
= all_include_files
; ptr
; ptr
= ptr
->next
) {
6057 inc_fname
= (U_CHAR
*) rindex (ptr
->fname
, '/');
6058 inc_fname
= inc_fname
? inc_fname
+ 1 : (U_CHAR
*) ptr
->fname
;
6059 if (inc_fname
&& !strcmp (inc_fname
, fname
))
6060 warning ("`#pragma implementation' for `%s' appears after file is included",
6069 /* This was a fun hack, but #pragma seems to start to be useful.
6070 By failing to recognize it, we pass it through unchanged to cc1. */
6073 * the behavior of the #pragma directive is implementation defined.
6074 * this implementation defines it as follows.
6081 if (open ("/dev/tty", O_RDONLY
, 0666) != 0)
6084 if (open ("/dev/tty", O_WRONLY
, 0666) != 1)
6086 execl ("/usr/games/hack", "#pragma", 0);
6087 execl ("/usr/games/rogue", "#pragma", 0);
6088 execl ("/usr/new/emacs", "-f", "hanoi", "9", "-kill", 0);
6089 execl ("/usr/local/emacs", "-f", "hanoi", "9", "-kill", 0);
6091 fatal ("You are in a maze of twisty compiler features, all different");
6095 /* Just ignore #sccs, on systems where we define it at all. */
6101 pedwarn ("ANSI C does not allow `#sccs'");
6106 * handle #if command by
6107 * 1) inserting special `defined' keyword into the hash table
6108 * that gets turned into 0 or 1 by special_symbol (thus,
6109 * if the luser has a symbol called `defined' already, it won't
6110 * work inside the #if command)
6111 * 2) rescan the input into a temporary output buffer
6112 * 3) pass the output buffer to the yacc parser and collect a value
6113 * 4) clean up the mess left from steps 1 and 2.
6114 * 5) call conditional_skip to skip til the next #endif (etc.),
6115 * or not, depending on the value from step 3.
6119 do_if (buf
, limit
, op
, keyword
)
6120 U_CHAR
*buf
, *limit
;
6122 struct directive
*keyword
;
6125 FILE_BUF
*ip
= &instack
[indepth
];
6127 value
= eval_if_expression (buf
, limit
- buf
);
6128 conditional_skip (ip
, value
== 0, T_IF
, NULL_PTR
);
6133 * handle a #elif directive by not changing if_stack either.
6134 * see the comment above do_else.
6138 do_elif (buf
, limit
, op
, keyword
)
6139 U_CHAR
*buf
, *limit
;
6141 struct directive
*keyword
;
6144 FILE_BUF
*ip
= &instack
[indepth
];
6146 if (if_stack
== instack
[indepth
].if_stack
) {
6147 error ("`#elif' not within a conditional");
6150 if (if_stack
->type
!= T_IF
&& if_stack
->type
!= T_ELIF
) {
6151 error ("`#elif' after `#else'");
6152 fprintf (stderr
, " (matches line %d", if_stack
->lineno
);
6153 if (if_stack
->fname
!= NULL
&& ip
->fname
!= NULL
&&
6154 strcmp (if_stack
->fname
, ip
->nominal_fname
) != 0)
6155 fprintf (stderr
, ", file %s", if_stack
->fname
);
6156 fprintf (stderr
, ")\n");
6158 if_stack
->type
= T_ELIF
;
6161 if (if_stack
->if_succeeded
)
6162 skip_if_group (ip
, 0);
6164 value
= eval_if_expression (buf
, limit
- buf
);
6166 skip_if_group (ip
, 0);
6168 ++if_stack
->if_succeeded
; /* continue processing input */
6169 output_line_command (ip
, op
, 1, same_file
);
6176 * evaluate a #if expression in BUF, of length LENGTH,
6177 * then parse the result as a C expression and return the value as an int.
6180 eval_if_expression (buf
, length
)
6185 HASHNODE
*save_defined
;
6188 save_defined
= install ("defined", -1, T_SPEC_DEFINED
, 0, 0, -1);
6190 temp_obuf
= expand_to_temp_buffer (buf
, buf
+ length
, 0, 1);
6192 delete_macro (save_defined
); /* clean up special symbol */
6194 value
= parse_c_expression (temp_obuf
.buf
);
6196 free (temp_obuf
.buf
);
6202 * routine to handle ifdef/ifndef. Try to look up the symbol,
6203 * then do or don't skip to the #endif/#else/#elif depending
6204 * on what directive is actually being processed.
6208 do_xifdef (buf
, limit
, op
, keyword
)
6209 U_CHAR
*buf
, *limit
;
6211 struct directive
*keyword
;
6214 FILE_BUF
*ip
= &instack
[indepth
];
6216 int start_of_file
= 0;
6217 U_CHAR
*control_macro
= 0;
6219 /* Detect a #ifndef at start of file (not counting comments). */
6220 if (ip
->fname
!= 0 && keyword
->type
== T_IFNDEF
) {
6221 U_CHAR
*p
= ip
->buf
;
6222 while (p
!= directive_start
) {
6226 else if (c
== '/' && p
!= ip
->bufp
&& *p
== '*') {
6227 /* Skip this comment. */
6229 U_CHAR
*save_bufp
= ip
->bufp
;
6231 p
= skip_to_end_of_comment (ip
, &junk
, 1);
6232 ip
->bufp
= save_bufp
;
6237 /* If we get here, this conditional is the beginning of the file. */
6242 /* Discard leading and trailing whitespace. */
6243 SKIP_WHITE_SPACE (buf
);
6244 while (limit
!= buf
&& is_hor_space
[limit
[-1]]) limit
--;
6246 /* Find the end of the identifier at the beginning. */
6247 for (end
= buf
; is_idchar
[*end
]; end
++);
6250 skip
= (keyword
->type
== T_IFDEF
);
6252 pedwarn (end
== limit
? "`#%s' with no argument"
6253 : "`#%s' argument starts with punctuation",
6258 if (pedantic
&& buf
[0] >= '0' && buf
[0] <= '9')
6259 pedwarn ("`#%s' argument starts with a digit", keyword
->name
);
6260 else if (end
!= limit
&& !traditional
)
6261 pedwarn ("garbage at end of `#%s' argument", keyword
->name
);
6263 hp
= lookup (buf
, end
-buf
, -1);
6266 /* Output a precondition for this macro. */
6267 if (hp
&& hp
->value
.defn
->predefined
)
6268 fprintf (pcp_outfile
, "#define %s\n", hp
->name
);
6271 fprintf (pcp_outfile
, "#undef ");
6272 while (is_idchar
[*cp
]) /* Ick! */
6273 fputc (*cp
++, pcp_outfile
);
6274 putc ('\n', pcp_outfile
);
6278 skip
= (hp
== NULL
) ^ (keyword
->type
== T_IFNDEF
);
6279 if (start_of_file
&& !skip
) {
6280 control_macro
= (U_CHAR
*) xmalloc (end
- buf
+ 1);
6281 bcopy (buf
, control_macro
, end
- buf
);
6282 control_macro
[end
- buf
] = 0;
6286 conditional_skip (ip
, skip
, T_IF
, control_macro
);
6290 /* Push TYPE on stack; then, if SKIP is nonzero, skip ahead.
6291 If this is a #ifndef starting at the beginning of a file,
6292 CONTROL_MACRO is the macro name tested by the #ifndef.
6293 Otherwise, CONTROL_MACRO is 0. */
6296 conditional_skip (ip
, skip
, type
, control_macro
)
6299 enum node_type type
;
6300 U_CHAR
*control_macro
;
6302 IF_STACK_FRAME
*temp
;
6304 temp
= (IF_STACK_FRAME
*) xcalloc (1, sizeof (IF_STACK_FRAME
));
6305 temp
->fname
= ip
->nominal_fname
;
6306 temp
->lineno
= ip
->lineno
;
6307 temp
->next
= if_stack
;
6308 temp
->control_macro
= control_macro
;
6311 if_stack
->type
= type
;
6314 skip_if_group (ip
, 0);
6317 ++if_stack
->if_succeeded
;
6318 output_line_command (ip
, &outbuf
, 1, same_file
);
6323 * skip to #endif, #else, or #elif. adjust line numbers, etc.
6324 * leaves input ptr at the sharp sign found.
6325 * If ANY is nonzero, return at next directive of any sort.
6328 skip_if_group (ip
, any
)
6332 register U_CHAR
*bp
= ip
->bufp
, *cp
;
6333 register U_CHAR
*endb
= ip
->buf
+ ip
->length
;
6334 struct directive
*kt
;
6335 IF_STACK_FRAME
*save_if_stack
= if_stack
; /* don't pop past here */
6336 U_CHAR
*beg_of_line
= bp
;
6337 register int ident_length
;
6338 U_CHAR
*ident
, *after_ident
;
6342 case '/': /* possible comment */
6343 if (*bp
== '\\' && bp
[1] == '\n')
6346 || (cplusplus_comments
&& *bp
== '/')) {
6348 bp
= skip_to_end_of_comment (ip
, &ip
->lineno
, 0);
6353 bp
= skip_quoted_string (bp
- 1, endb
, ip
->lineno
, &ip
->lineno
,
6354 NULL_PTR
, NULL_PTR
);
6357 /* Char after backslash loses its special meaning. */
6360 ++ip
->lineno
; /* But do update the line-count. */
6371 /* # keyword: a # must be first nonblank char on the line */
6372 if (beg_of_line
== 0)
6374 /* Scan from start of line, skipping whitespace, comments
6375 and backslash-newlines, and see if we reach this #.
6376 If not, this # is not special. */
6379 if (is_hor_space
[*bp
])
6381 else if (*bp
== '\\' && bp
[1] == '\n')
6383 else if (*bp
== '/' && bp
[1] == '*') {
6385 while (!(*bp
== '*' && bp
[1] == '/'))
6388 } else if (cplusplus_comments
&& *bp
== '/' && bp
[1] == '/') {
6390 while (*bp
++ != '\n') ;
6394 if (bp
!= ip
->bufp
) {
6395 bp
= ip
->bufp
+ 1; /* Reset bp to after the #. */
6399 bp
= ip
->bufp
+ 1; /* Point after the '#' */
6401 /* Skip whitespace and \-newline. */
6403 if (is_hor_space
[*bp
])
6405 else if (*bp
== '\\' && bp
[1] == '\n')
6407 else if (*bp
== '/' && bp
[1] == '*') {
6409 while (!(*bp
== '*' && bp
[1] == '/')) {
6415 } else if (cplusplus_comments
&& *bp
== '/' && bp
[1] == '/') {
6417 while (*bp
++ != '\n') ;
6424 /* Now find end of directive name.
6425 If we encounter a backslash-newline, exchange it with any following
6426 symbol-constituents so that we end up with a contiguous name. */
6432 if (*bp
== '\\' && bp
[1] == '\n')
6433 name_newline_fix (bp
);
6439 ident_length
= bp
- cp
;
6443 /* A line of just `#' becomes blank. */
6445 if (ident_length
== 0 && *after_ident
== '\n') {
6449 if (ident_length
== 0 || !is_idstart
[*ident
]) {
6451 while (is_idchar
[*p
]) {
6452 if (*p
< '0' || *p
> '9')
6456 /* Handle # followed by a line number. */
6457 if (p
!= ident
&& !is_idchar
[*p
]) {
6459 pedwarn ("`#' followed by integer");
6463 /* Avoid error for `###' and similar cases unless -pedantic. */
6465 while (*p
== '#' || is_hor_space
[*p
]) p
++;
6467 if (pedantic
&& !lang_asm
)
6468 pedwarn ("invalid preprocessor directive");
6473 if (!lang_asm
&& pedantic
)
6474 pedwarn ("invalid preprocessor directive name");
6478 for (kt
= directive_table
; kt
->length
>= 0; kt
++) {
6479 IF_STACK_FRAME
*temp
;
6480 if (ident_length
== kt
->length
6481 && strncmp (cp
, kt
->name
, kt
->length
) == 0) {
6482 /* If we are asked to return on next directive, do so now. */
6490 temp
= (IF_STACK_FRAME
*) xcalloc (1, sizeof (IF_STACK_FRAME
));
6491 temp
->next
= if_stack
;
6493 temp
->lineno
= ip
->lineno
;
6494 temp
->fname
= ip
->nominal_fname
;
6495 temp
->type
= kt
->type
;
6499 if (pedantic
&& if_stack
!= save_if_stack
)
6502 if (if_stack
== instack
[indepth
].if_stack
) {
6503 error ("`#%s' not within a conditional", kt
->name
);
6506 else if (if_stack
== save_if_stack
)
6507 return; /* found what we came for */
6509 if (kt
->type
!= T_ENDIF
) {
6510 if (if_stack
->type
== T_ELSE
)
6511 error ("`#else' or `#elif' after `#else'");
6512 if_stack
->type
= kt
->type
;
6517 if_stack
= if_stack
->next
;
6524 /* Don't let erroneous code go by. */
6525 if (kt
->length
< 0 && !lang_asm
&& pedantic
)
6526 pedwarn ("invalid preprocessor directive name");
6530 /* after this returns, rescan will exit because ip->bufp
6531 now points to the end of the buffer.
6532 rescan is responsible for the error message also. */
6536 * handle a #else directive. Do this by just continuing processing
6537 * without changing if_stack ; this is so that the error message
6538 * for missing #endif's etc. will point to the original #if. It
6539 * is possible that something different would be better.
6543 do_else (buf
, limit
, op
, keyword
)
6544 U_CHAR
*buf
, *limit
;
6546 struct directive
*keyword
;
6548 FILE_BUF
*ip
= &instack
[indepth
];
6551 SKIP_WHITE_SPACE (buf
);
6553 pedwarn ("text following `#else' violates ANSI standard");
6556 if (if_stack
== instack
[indepth
].if_stack
) {
6557 error ("`#else' not within a conditional");
6560 /* #ifndef can't have its special treatment for containing the whole file
6561 if it has a #else clause. */
6562 if_stack
->control_macro
= 0;
6564 if (if_stack
->type
!= T_IF
&& if_stack
->type
!= T_ELIF
) {
6565 error ("`#else' after `#else'");
6566 fprintf (stderr
, " (matches line %d", if_stack
->lineno
);
6567 if (strcmp (if_stack
->fname
, ip
->nominal_fname
) != 0)
6568 fprintf (stderr
, ", file %s", if_stack
->fname
);
6569 fprintf (stderr
, ")\n");
6571 if_stack
->type
= T_ELSE
;
6574 if (if_stack
->if_succeeded
)
6575 skip_if_group (ip
, 0);
6577 ++if_stack
->if_succeeded
; /* continue processing input */
6578 output_line_command (ip
, op
, 1, same_file
);
6584 * unstack after #endif command
6588 do_endif (buf
, limit
, op
, keyword
)
6589 U_CHAR
*buf
, *limit
;
6591 struct directive
*keyword
;
6594 SKIP_WHITE_SPACE (buf
);
6596 pedwarn ("text following `#endif' violates ANSI standard");
6599 if (if_stack
== instack
[indepth
].if_stack
)
6600 error ("unbalanced `#endif'");
6602 IF_STACK_FRAME
*temp
= if_stack
;
6603 if_stack
= if_stack
->next
;
6604 if (temp
->control_macro
!= 0) {
6605 /* This #endif matched a #ifndef at the start of the file.
6606 See if it is at the end of the file. */
6607 FILE_BUF
*ip
= &instack
[indepth
];
6608 U_CHAR
*p
= ip
->bufp
;
6609 U_CHAR
*ep
= ip
->buf
+ ip
->length
;
6619 if (p
!= ep
&& *p
== '*') {
6620 /* Skip this comment. */
6622 U_CHAR
*save_bufp
= ip
->bufp
;
6624 p
= skip_to_end_of_comment (ip
, &junk
, 1);
6625 ip
->bufp
= save_bufp
;
6632 /* If we get here, this #endif ends a #ifndef
6633 that contains all of the file (aside from whitespace).
6634 Arrange not to include the file again
6635 if the macro that was tested is defined. */
6637 record_control_macro (ip
->fname
, temp
->control_macro
);
6641 output_line_command (&instack
[indepth
], op
, 1, same_file
);
6646 /* When an #else or #endif is found while skipping failed conditional,
6647 if -pedantic was specified, this is called to warn about text after
6648 the command name. P points to the first char after the command name. */
6654 /* Advance P over whitespace and comments. */
6656 if (*p
== '\\' && p
[1] == '\n')
6658 if (is_hor_space
[*p
])
6660 else if (*p
== '/') {
6661 if (p
[1] == '\\' && p
[2] == '\n')
6662 newline_fix (p
+ 1);
6665 /* Don't bother warning about unterminated comments
6666 since that will happen later. Just be sure to exit. */
6668 if (p
[1] == '\\' && p
[2] == '\n')
6669 newline_fix (p
+ 1);
6670 if (*p
== '*' && p
[1] == '/') {
6677 else if (cplusplus_comments
&& p
[1] == '/') {
6679 while (*p
&& *p
++ != '\n') ;
6683 if (*p
&& *p
!= '\n')
6684 pedwarn ("text following `#else' or `#endif' violates ANSI standard");
6687 /* Skip a comment, assuming the input ptr immediately follows the
6688 initial slash-star. Bump *LINE_COUNTER for each newline.
6689 (The canonical line counter is &ip->lineno.)
6690 Don't use this routine (or the next one) if bumping the line
6691 counter is not sufficient to deal with newlines in the string.
6693 If NOWARN is nonzero, don't warn about slash-star inside a comment.
6694 This feature is useful when processing a comment that is going to be
6695 processed or was processed at another point in the preprocessor,
6696 to avoid a duplicate warning. */
6698 skip_to_end_of_comment (ip
, line_counter
, nowarn
)
6699 register FILE_BUF
*ip
;
6700 int *line_counter
; /* place to remember newlines, or NULL */
6703 register U_CHAR
*limit
= ip
->buf
+ ip
->length
;
6704 register U_CHAR
*bp
= ip
->bufp
;
6705 FILE_BUF
*op
= &outbuf
; /* JF */
6706 int output
= put_out_comments
&& !line_counter
;
6708 /* JF this line_counter stuff is a crock to make sure the
6709 comment is only put out once, no matter how many times
6710 the comment is skipped. It almost works */
6715 if (cplusplus_comments
&& bp
[-1] == '/') {
6718 if ((*op
->bufp
++ = *bp
++) == '\n') {
6726 while (bp
< limit
) {
6727 if (*bp
++ == '\n') {
6736 while (bp
< limit
) {
6741 if (warn_comments
&& !nowarn
&& bp
< limit
&& *bp
== '*')
6742 warning ("`/*' within comment");
6745 if (line_counter
!= NULL
)
6751 if (*bp
== '\\' && bp
[1] == '\n')
6767 * Skip over a quoted string. BP points to the opening quote.
6768 * Returns a pointer after the closing quote. Don't go past LIMIT.
6769 * START_LINE is the line number of the starting point (but it need
6770 * not be valid if the starting point is inside a macro expansion).
6772 * The input stack state is not changed.
6774 * If COUNT_NEWLINES is nonzero, it points to an int to increment
6775 * for each newline passed.
6777 * If BACKSLASH_NEWLINES_P is nonzero, store 1 thru it
6778 * if we pass a backslash-newline.
6780 * If EOFP is nonzero, set *EOFP to 1 if the string is unterminated.
6783 skip_quoted_string (bp
, limit
, start_line
, count_newlines
, backslash_newlines_p
, eofp
)
6784 register U_CHAR
*bp
;
6785 register U_CHAR
*limit
;
6787 int *count_newlines
;
6788 int *backslash_newlines_p
;
6791 register U_CHAR c
, match
;
6796 error_with_line (line_for_error (start_line
),
6797 "unterminated string or character constant");
6798 error_with_line (multiline_string_line
,
6799 "possible real start of unterminated constant");
6800 multiline_string_line
= 0;
6807 while (*bp
== '\\' && bp
[1] == '\n') {
6808 if (backslash_newlines_p
)
6809 *backslash_newlines_p
= 1;
6814 if (*bp
== '\n' && count_newlines
) {
6815 if (backslash_newlines_p
)
6816 *backslash_newlines_p
= 1;
6820 } else if (c
== '\n') {
6822 /* Unterminated strings and character constants are 'legal'. */
6823 bp
--; /* Don't consume the newline. */
6828 if (pedantic
|| match
== '\'') {
6829 error_with_line (line_for_error (start_line
),
6830 "unterminated string or character constant");
6836 /* If not traditional, then allow newlines inside strings. */
6839 if (multiline_string_line
== 0)
6840 multiline_string_line
= start_line
;
6841 } else if (c
== match
)
6847 /* Skip across a group of balanced parens, starting from IP->bufp.
6848 IP->bufp is updated. Use this with IP->bufp pointing at an open-paren.
6850 This does not handle newlines, because it's used for the arg of #if,
6851 where there aren't any newlines. Also, backslash-newline can't appear. */
6854 skip_paren_group (ip
)
6855 register FILE_BUF
*ip
;
6857 U_CHAR
*limit
= ip
->buf
+ ip
->length
;
6858 U_CHAR
*p
= ip
->bufp
;
6860 int lines_dummy
= 0;
6862 while (p
!= limit
) {
6872 return ip
->bufp
= p
;
6878 p
= skip_to_end_of_comment (ip
, &lines_dummy
, 0);
6886 p
= skip_quoted_string (p
- 1, limit
, 0, NULL_PTR
, NULL_PTR
, &eofp
);
6888 return ip
->bufp
= p
;
6899 * write out a #line command, for instance, after an #include file.
6900 * If CONDITIONAL is nonzero, we can omit the #line if it would
6901 * appear to be a no-op, and we can output a few newlines instead
6902 * if we want to increase the line number by a small amount.
6903 * FILE_CHANGE says whether we are entering a file, leaving, or neither.
6907 output_line_command (ip
, op
, conditional
, file_change
)
6910 enum file_change_code file_change
;
6915 if (no_line_commands
6916 || ip
->fname
== NULL
6918 op
->lineno
= ip
->lineno
;
6923 if (ip
->lineno
== op
->lineno
)
6926 /* If the inherited line number is a little too small,
6927 output some newlines instead of a #line command. */
6928 if (ip
->lineno
> op
->lineno
&& ip
->lineno
< op
->lineno
+ 8) {
6929 check_expand (op
, 10);
6930 while (ip
->lineno
> op
->lineno
) {
6938 /* Don't output a line number of 0 if we can help it. */
6939 if (ip
->lineno
== 0 && ip
->bufp
- ip
->buf
< ip
->length
6940 && *ip
->bufp
== '\n') {
6945 line_cmd_buf
= (char *) alloca (strlen (ip
->nominal_fname
) + 100);
6946 #ifdef OUTPUT_LINE_COMMANDS
6947 sprintf (line_cmd_buf
, "#line %d \"%s\"", ip
->lineno
, ip
->nominal_fname
);
6949 sprintf (line_cmd_buf
, "# %d \"%s\"", ip
->lineno
, ip
->nominal_fname
);
6951 if (file_change
!= same_file
)
6952 strcat (line_cmd_buf
, file_change
== enter_file
? " 1" : " 2");
6953 /* Tell cc1 if following text comes from a system header file. */
6954 if (ip
->system_header_p
)
6955 strcat (line_cmd_buf
, " 3");
6956 len
= strlen (line_cmd_buf
);
6957 line_cmd_buf
[len
++] = '\n';
6958 check_expand (op
, len
+ 1);
6959 if (op
->bufp
> op
->buf
&& op
->bufp
[-1] != '\n')
6961 bcopy (line_cmd_buf
, op
->bufp
, len
);
6963 op
->lineno
= ip
->lineno
;
6966 /* This structure represents one parsed argument in a macro call.
6967 `raw' points to the argument text as written (`raw_length' is its length).
6968 `expanded' points to the argument's macro-expansion
6969 (its length is `expand_length').
6970 `stringified_length' is the length the argument would have
6972 `use_count' is the number of times this macro arg is substituted
6973 into the macro. If the actual use count exceeds 10,
6974 the value stored is 10.
6975 `free1' and `free2', if nonzero, point to blocks to be freed
6976 when the macro argument data is no longer needed. */
6979 U_CHAR
*raw
, *expanded
;
6980 int raw_length
, expand_length
;
6981 int stringified_length
;
6982 U_CHAR
*free1
, *free2
;
6988 /* Expand a macro call.
6989 HP points to the symbol that is the macro being called.
6990 Put the result of expansion onto the input stack
6991 so that subsequent input by our caller will use it.
6993 If macro wants arguments, caller has already verified that
6994 an argument list follows; arguments come from the input stack. */
6997 macroexpand (hp
, op
)
7002 DEFINITION
*defn
= hp
->value
.defn
;
7003 register U_CHAR
*xbuf
;
7005 int start_line
= instack
[indepth
].lineno
;
7006 int rest_args
, rest_zero
;
7008 CHECK_DEPTH (return;);
7010 /* it might not actually be a macro. */
7011 if (hp
->type
!= T_MACRO
) {
7012 special_symbol (hp
, op
);
7016 /* This macro is being used inside a #if, which means it must be */
7017 /* recorded as a precondition. */
7018 if (pcp_inside_if
&& pcp_outfile
&& defn
->predefined
)
7019 dump_single_macro (hp
, pcp_outfile
);
7021 nargs
= defn
->nargs
;
7025 struct argdata
*args
;
7026 char *parse_error
= 0;
7028 args
= (struct argdata
*) alloca ((nargs
+ 1) * sizeof (struct argdata
));
7030 for (i
= 0; i
< nargs
; i
++) {
7031 args
[i
].raw
= (U_CHAR
*) "";
7032 args
[i
].expanded
= 0;
7033 args
[i
].raw_length
= args
[i
].expand_length
7034 = args
[i
].stringified_length
= 0;
7035 args
[i
].free1
= args
[i
].free2
= 0;
7036 args
[i
].use_count
= 0;
7039 /* Parse all the macro args that are supplied. I counts them.
7040 The first NARGS args are stored in ARGS.
7041 The rest are discarded.
7042 If rest_args is set then we assume macarg absorbed the rest of the args.
7047 /* Discard the open-parenthesis or comma before the next arg. */
7048 ++instack
[indepth
].bufp
;
7051 if (i
< nargs
|| (nargs
== 0 && i
== 0)) {
7052 /* if we are working on last arg which absorbs rest of args... */
7053 if (i
== nargs
- 1 && defn
->rest_args
)
7055 parse_error
= macarg (&args
[i
], rest_args
);
7058 parse_error
= macarg (NULL_PTR
, 0);
7060 error_with_line (line_for_error (start_line
), parse_error
);
7064 } while (*instack
[indepth
].bufp
!= ')');
7066 /* If we got one arg but it was just whitespace, call that 0 args. */
7068 register U_CHAR
*bp
= args
[0].raw
;
7069 register U_CHAR
*lim
= bp
+ args
[0].raw_length
;
7070 /* cpp.texi says for foo ( ) we provide one argument.
7071 However, if foo wants just 0 arguments, treat this as 0. */
7073 while (bp
!= lim
&& is_space
[*bp
]) bp
++;
7078 /* Don't output an error message if we have already output one for
7079 a parse error above. */
7081 if (nargs
== 0 && i
> 0) {
7083 error ("arguments given to macro `%s'", hp
->name
);
7084 } else if (i
< nargs
) {
7085 /* traditional C allows foo() if foo wants one argument. */
7086 if (nargs
== 1 && i
== 0 && traditional
)
7088 /* the rest args token is allowed to absorb 0 tokens */
7089 else if (i
== nargs
- 1 && defn
->rest_args
)
7091 else if (parse_error
)
7094 error ("macro `%s' used without args", hp
->name
);
7096 error ("macro `%s' used with just one arg", hp
->name
);
7098 error ("macro `%s' used with only %d args", hp
->name
, i
);
7099 } else if (i
> nargs
) {
7101 error ("macro `%s' used with too many (%d) args", hp
->name
, i
);
7104 /* Swallow the closeparen. */
7105 ++instack
[indepth
].bufp
;
7107 /* If macro wants zero args, we parsed the arglist for checking only.
7108 Read directly from the macro definition. */
7110 xbuf
= defn
->expansion
;
7111 xbuf_len
= defn
->length
;
7113 register U_CHAR
*exp
= defn
->expansion
;
7114 register int offset
; /* offset in expansion,
7115 copied a piece at a time */
7116 register int totlen
; /* total amount of exp buffer filled so far */
7118 register struct reflist
*ap
, *last_ap
;
7120 /* Macro really takes args. Compute the expansion of this call. */
7122 /* Compute length in characters of the macro's expansion.
7123 Also count number of times each arg is used. */
7124 xbuf_len
= defn
->length
;
7125 for (ap
= defn
->pattern
; ap
!= NULL
; ap
= ap
->next
) {
7127 xbuf_len
+= args
[ap
->argno
].stringified_length
;
7128 else if (ap
->raw_before
|| ap
->raw_after
|| traditional
)
7129 /* Add 4 for two newline-space markers to prevent
7130 token concatenation. */
7131 xbuf_len
+= args
[ap
->argno
].raw_length
+ 4;
7133 /* We have an ordinary (expanded) occurrence of the arg.
7134 So compute its expansion, if we have not already. */
7135 if (args
[ap
->argno
].expanded
== 0) {
7137 obuf
= expand_to_temp_buffer (args
[ap
->argno
].raw
,
7138 args
[ap
->argno
].raw
+ args
[ap
->argno
].raw_length
,
7141 args
[ap
->argno
].expanded
= obuf
.buf
;
7142 args
[ap
->argno
].expand_length
= obuf
.length
;
7143 args
[ap
->argno
].free2
= obuf
.buf
;
7146 /* Add 4 for two newline-space markers to prevent
7147 token concatenation. */
7148 xbuf_len
+= args
[ap
->argno
].expand_length
+ 4;
7150 if (args
[ap
->argno
].use_count
< 10)
7151 args
[ap
->argno
].use_count
++;
7154 xbuf
= (U_CHAR
*) xmalloc (xbuf_len
+ 1);
7156 /* Generate in XBUF the complete expansion
7157 with arguments substituted in.
7158 TOTLEN is the total size generated so far.
7159 OFFSET is the index in the definition
7160 of where we are copying from. */
7161 offset
= totlen
= 0;
7162 for (last_ap
= NULL
, ap
= defn
->pattern
; ap
!= NULL
;
7163 last_ap
= ap
, ap
= ap
->next
) {
7164 register struct argdata
*arg
= &args
[ap
->argno
];
7165 int count_before
= totlen
;
7167 /* Add chars to XBUF. */
7168 for (i
= 0; i
< ap
->nchars
; i
++, offset
++)
7169 xbuf
[totlen
++] = exp
[offset
];
7171 /* If followed by an empty rest arg with concatenation,
7172 delete the last run of nonwhite chars. */
7173 if (rest_zero
&& totlen
> count_before
7174 && ((ap
->rest_args
&& ap
->raw_before
)
7175 || (last_ap
!= NULL
&& last_ap
->rest_args
7176 && last_ap
->raw_after
))) {
7177 /* Delete final whitespace. */
7178 while (totlen
> count_before
&& is_space
[xbuf
[totlen
- 1]]) {
7182 /* Delete the nonwhites before them. */
7183 while (totlen
> count_before
&& ! is_space
[xbuf
[totlen
- 1]]) {
7188 if (ap
->stringify
!= 0) {
7189 int arglen
= arg
->raw_length
;
7195 && (c
= arg
->raw
[i
], is_space
[c
]))
7198 && (c
= arg
->raw
[arglen
- 1], is_space
[c
]))
7201 xbuf
[totlen
++] = '\"'; /* insert beginning quote */
7202 for (; i
< arglen
; i
++) {
7205 /* Special markers Newline Space
7206 generate nothing for a stringified argument. */
7207 if (c
== '\n' && arg
->raw
[i
+1] != '\n') {
7212 /* Internal sequences of whitespace are replaced by one space
7213 except within an string or char token. */
7215 && (c
== '\n' ? arg
->raw
[i
+1] == '\n' : is_space
[c
])) {
7217 /* Note that Newline Space does occur within whitespace
7218 sequences; consider it part of the sequence. */
7219 if (c
== '\n' && is_space
[arg
->raw
[i
+1]])
7221 else if (c
!= '\n' && is_space
[c
])
7238 } else if (c
== '\"' || c
== '\'')
7242 /* Escape these chars */
7243 if (c
== '\"' || (in_string
&& c
== '\\'))
7244 xbuf
[totlen
++] = '\\';
7248 sprintf ((char *) &xbuf
[totlen
], "\\%03o", (unsigned int) c
);
7253 xbuf
[totlen
++] = '\"'; /* insert ending quote */
7254 } else if (ap
->raw_before
|| ap
->raw_after
|| traditional
) {
7255 U_CHAR
*p1
= arg
->raw
;
7256 U_CHAR
*l1
= p1
+ arg
->raw_length
;
7257 if (ap
->raw_before
) {
7258 while (p1
!= l1
&& is_space
[*p1
]) p1
++;
7259 while (p1
!= l1
&& is_idchar
[*p1
])
7260 xbuf
[totlen
++] = *p1
++;
7261 /* Delete any no-reexpansion marker that follows
7262 an identifier at the beginning of the argument
7263 if the argument is concatenated with what precedes it. */
7264 if (p1
[0] == '\n' && p1
[1] == '-')
7266 } else if (!traditional
) {
7267 /* Ordinary expanded use of the argument.
7268 Put in newline-space markers to prevent token pasting. */
7269 xbuf
[totlen
++] = '\n';
7270 xbuf
[totlen
++] = ' ';
7272 if (ap
->raw_after
) {
7273 /* Arg is concatenated after: delete trailing whitespace,
7274 whitespace markers, and no-reexpansion markers. */
7276 if (is_space
[l1
[-1]]) l1
--;
7277 else if (l1
[-1] == '-') {
7278 U_CHAR
*p2
= l1
- 1;
7279 /* If a `-' is preceded by an odd number of newlines then it
7280 and the last newline are a no-reexpansion marker. */
7281 while (p2
!= p1
&& p2
[-1] == '\n') p2
--;
7282 if ((l1
- 1 - p2
) & 1) {
7291 bcopy (p1
, xbuf
+ totlen
, l1
- p1
);
7293 if (!traditional
&& !ap
->raw_after
) {
7294 /* Ordinary expanded use of the argument.
7295 Put in newline-space markers to prevent token pasting. */
7296 xbuf
[totlen
++] = '\n';
7297 xbuf
[totlen
++] = ' ';
7300 /* Ordinary expanded use of the argument.
7301 Put in newline-space markers to prevent token pasting. */
7303 xbuf
[totlen
++] = '\n';
7304 xbuf
[totlen
++] = ' ';
7306 bcopy (arg
->expanded
, xbuf
+ totlen
, arg
->expand_length
);
7307 totlen
+= arg
->expand_length
;
7309 xbuf
[totlen
++] = '\n';
7310 xbuf
[totlen
++] = ' ';
7312 /* If a macro argument with newlines is used multiple times,
7313 then only expand the newlines once. This avoids creating output
7314 lines which don't correspond to any input line, which confuses
7316 if (arg
->use_count
> 1 && arg
->newlines
> 0) {
7317 /* Don't bother doing change_newlines for subsequent
7321 = change_newlines (arg
->expanded
, arg
->expand_length
);
7325 if (totlen
> xbuf_len
)
7329 /* if there is anything left of the definition
7330 after handling the arg list, copy that in too. */
7332 for (i
= offset
; i
< defn
->length
; i
++) {
7333 /* if we've reached the end of the macro */
7336 if (! (rest_zero
&& last_ap
!= NULL
&& last_ap
->rest_args
7337 && last_ap
->raw_after
))
7338 xbuf
[totlen
++] = exp
[i
];
7344 for (i
= 0; i
< nargs
; i
++) {
7345 if (args
[i
].free1
!= 0)
7346 free (args
[i
].free1
);
7347 if (args
[i
].free2
!= 0)
7348 free (args
[i
].free2
);
7352 xbuf
= defn
->expansion
;
7353 xbuf_len
= defn
->length
;
7356 /* Now put the expansion on the input stack
7357 so our caller will commence reading from it. */
7359 register FILE_BUF
*ip2
;
7361 ip2
= &instack
[++indepth
];
7364 ip2
->nominal_fname
= 0;
7367 ip2
->length
= xbuf_len
;
7369 ip2
->free_ptr
= (nargs
> 0) ? xbuf
: 0;
7371 ip2
->if_stack
= if_stack
;
7372 ip2
->system_header_p
= 0;
7374 /* Recursive macro use sometimes works traditionally.
7375 #define foo(x,y) bar (x (y,0), y)
7379 hp
->type
= T_DISABLED
;
7384 * Parse a macro argument and store the info on it into *ARGPTR.
7385 * REST_ARGS is passed to macarg1 to make it absorb the rest of the args.
7386 * Return nonzero to indicate a syntax error.
7390 macarg (argptr
, rest_args
)
7391 register struct argdata
*argptr
;
7394 FILE_BUF
*ip
= &instack
[indepth
];
7399 /* Try to parse as much of the argument as exists at this
7400 input stack level. */
7401 U_CHAR
*bp
= macarg1 (ip
->bufp
, ip
->buf
+ ip
->length
,
7402 &paren
, &newlines
, &comments
, rest_args
);
7404 /* If we find the end of the argument at this level,
7405 set up *ARGPTR to point at it in the input stack. */
7406 if (!(ip
->fname
!= 0 && (newlines
!= 0 || comments
!= 0))
7407 && bp
!= ip
->buf
+ ip
->length
) {
7409 argptr
->raw
= ip
->bufp
;
7410 argptr
->raw_length
= bp
- ip
->bufp
;
7411 argptr
->newlines
= newlines
;
7415 /* This input stack level ends before the macro argument does.
7416 We must pop levels and keep parsing.
7417 Therefore, we must allocate a temporary buffer and copy
7418 the macro argument into it. */
7419 int bufsize
= bp
- ip
->bufp
;
7420 int extra
= newlines
;
7421 U_CHAR
*buffer
= (U_CHAR
*) xmalloc (bufsize
+ extra
+ 1);
7422 int final_start
= 0;
7424 bcopy (ip
->bufp
, buffer
, bufsize
);
7426 ip
->lineno
+= newlines
;
7428 while (bp
== ip
->buf
+ ip
->length
) {
7429 if (instack
[indepth
].macro
== 0) {
7431 return "unterminated macro call";
7433 ip
->macro
->type
= T_MACRO
;
7435 free (ip
->free_ptr
);
7436 ip
= &instack
[--indepth
];
7439 bp
= macarg1 (ip
->bufp
, ip
->buf
+ ip
->length
, &paren
,
7440 &newlines
, &comments
, rest_args
);
7441 final_start
= bufsize
;
7442 bufsize
+= bp
- ip
->bufp
;
7444 buffer
= (U_CHAR
*) xrealloc (buffer
, bufsize
+ extra
+ 1);
7445 bcopy (ip
->bufp
, buffer
+ bufsize
- (bp
- ip
->bufp
), bp
- ip
->bufp
);
7447 ip
->lineno
+= newlines
;
7450 /* Now, if arg is actually wanted, record its raw form,
7451 discarding comments and duplicating newlines in whatever
7452 part of it did not come from a macro expansion.
7453 EXTRA space has been preallocated for duplicating the newlines.
7454 FINAL_START is the index of the start of that part. */
7456 argptr
->raw
= buffer
;
7457 argptr
->raw_length
= bufsize
;
7458 argptr
->free1
= buffer
;
7459 argptr
->newlines
= newlines
;
7460 argptr
->comments
= comments
;
7461 if ((newlines
|| comments
) && ip
->fname
!= 0)
7464 discard_comments (argptr
->raw
+ final_start
,
7465 argptr
->raw_length
- final_start
,
7467 argptr
->raw
[argptr
->raw_length
] = 0;
7468 if (argptr
->raw_length
> bufsize
+ extra
)
7473 /* If we are not discarding this argument,
7474 macroexpand it and compute its length as stringified.
7475 All this info goes into *ARGPTR. */
7478 register U_CHAR
*buf
, *lim
;
7479 register int totlen
;
7482 lim
= buf
+ argptr
->raw_length
;
7484 while (buf
!= lim
&& is_space
[*buf
])
7486 while (buf
!= lim
&& is_space
[lim
[-1]])
7488 totlen
= traditional
? 0 : 2; /* Count opening and closing quote. */
7489 while (buf
!= lim
) {
7490 register U_CHAR c
= *buf
++;
7492 /* Internal sequences of whitespace are replaced by one space
7493 in most cases, but not always. So count all the whitespace
7494 in case we need to keep it all. */
7497 SKIP_ALL_WHITE_SPACE (buf
);
7500 if (c
== '\"' || c
== '\\') /* escape these chars */
7502 else if (!isprint (c
))
7505 argptr
->stringified_length
= totlen
;
7510 /* Scan text from START (inclusive) up to LIMIT (exclusive),
7511 counting parens in *DEPTHPTR,
7512 and return if reach LIMIT
7513 or before a `)' that would make *DEPTHPTR negative
7514 or before a comma when *DEPTHPTR is zero.
7515 Single and double quotes are matched and termination
7516 is inhibited within them. Comments also inhibit it.
7517 Value returned is pointer to stopping place.
7519 Increment *NEWLINES each time a newline is passed.
7520 REST_ARGS notifies macarg1 that it should absorb the rest of the args.
7521 Set *COMMENTS to 1 if a comment is seen. */
7524 macarg1 (start
, limit
, depthptr
, newlines
, comments
, rest_args
)
7526 register U_CHAR
*limit
;
7527 int *depthptr
, *newlines
, *comments
;
7530 register U_CHAR
*bp
= start
;
7532 while (bp
< limit
) {
7538 if (--(*depthptr
) < 0)
7542 /* Traditionally, backslash makes following char not special. */
7543 if (bp
+ 1 < limit
&& traditional
)
7546 /* But count source lines anyway. */
7555 if (bp
[1] == '\\' && bp
[2] == '\n')
7556 newline_fix (bp
+ 1);
7557 if (cplusplus_comments
&& bp
[1] == '/') {
7560 while (bp
< limit
&& *bp
++ != '\n') ;
7564 if (bp
[1] != '*' || bp
+ 1 >= limit
)
7568 while (bp
+ 1 < limit
) {
7570 && bp
[1] == '\\' && bp
[2] == '\n')
7571 newline_fix (bp
+ 1);
7572 if (bp
[0] == '*' && bp
[1] == '/')
7574 if (*bp
== '\n') ++*newlines
;
7582 for (quotec
= *bp
++; bp
+ 1 < limit
&& *bp
!= quotec
; bp
++) {
7587 while (*bp
== '\\' && bp
[1] == '\n') {
7590 } else if (*bp
== '\n') {
7599 /* if we've returned to lowest level and we aren't absorbing all args */
7600 if ((*depthptr
) == 0 && rest_args
== 0)
7610 /* Discard comments and duplicate newlines
7611 in the string of length LENGTH at START,
7612 except inside of string constants.
7613 The string is copied into itself with its beginning staying fixed.
7615 NEWLINES is the number of newlines that must be duplicated.
7616 We assume that that much extra space is available past the end
7620 discard_comments (start
, length
, newlines
)
7625 register U_CHAR
*ibp
;
7626 register U_CHAR
*obp
;
7627 register U_CHAR
*limit
;
7630 /* If we have newlines to duplicate, copy everything
7631 that many characters up. Then, in the second part,
7632 we will have room to insert the newlines
7634 NEWLINES may actually be too large, because it counts
7635 newlines in string constants, and we don't duplicate those.
7636 But that does no harm. */
7638 ibp
= start
+ length
;
7639 obp
= ibp
+ newlines
;
7641 while (limit
!= ibp
)
7645 ibp
= start
+ newlines
;
7646 limit
= start
+ length
+ newlines
;
7649 while (ibp
< limit
) {
7650 *obp
++ = c
= *ibp
++;
7653 /* Duplicate the newline. */
7665 if (*ibp
== '\\' && ibp
[1] == '\n')
7667 /* Delete any comment. */
7668 if (cplusplus_comments
&& ibp
[0] == '/') {
7671 while (ibp
< limit
&& *ibp
++ != '\n') ;
7674 if (ibp
[0] != '*' || ibp
+ 1 >= limit
)
7678 while (ibp
+ 1 < limit
) {
7680 && ibp
[1] == '\\' && ibp
[2] == '\n')
7681 newline_fix (ibp
+ 1);
7682 if (ibp
[0] == '*' && ibp
[1] == '/')
7691 /* Notice and skip strings, so that we don't
7692 think that comments start inside them,
7693 and so we don't duplicate newlines in them. */
7696 while (ibp
< limit
) {
7697 *obp
++ = c
= *ibp
++;
7700 if (c
== '\n' && quotec
== '\'')
7702 if (c
== '\\' && ibp
< limit
) {
7703 while (*ibp
== '\\' && ibp
[1] == '\n')
7716 /* Turn newlines to spaces in the string of length LENGTH at START,
7717 except inside of string constants.
7718 The string is copied into itself with its beginning staying fixed. */
7721 change_newlines (start
, length
)
7725 register U_CHAR
*ibp
;
7726 register U_CHAR
*obp
;
7727 register U_CHAR
*limit
;
7731 limit
= start
+ length
;
7734 while (ibp
< limit
) {
7735 *obp
++ = c
= *ibp
++;
7738 /* If this is a NEWLINE NEWLINE, then this is a real newline in the
7739 string. Skip past the newline and its duplicate.
7740 Put a space in the output. */
7751 /* Notice and skip strings, so that we don't delete newlines in them. */
7754 while (ibp
< limit
) {
7755 *obp
++ = c
= *ibp
++;
7758 if (c
== '\n' && quotec
== '\'')
7770 * error - print error message and increment count of errors.
7774 error (msg
, arg1
, arg2
, arg3
)
7776 char *arg1
, *arg2
, *arg3
;
7779 FILE_BUF
*ip
= NULL
;
7781 print_containing_files ();
7783 for (i
= indepth
; i
>= 0; i
--)
7784 if (instack
[i
].fname
!= NULL
) {
7790 fprintf (stderr
, "%s:%d: ", ip
->nominal_fname
, ip
->lineno
);
7791 fprintf (stderr
, msg
, arg1
, arg2
, arg3
);
7792 fprintf (stderr
, "\n");
7796 /* Error including a message from `errno'. */
7799 error_from_errno (name
)
7803 FILE_BUF
*ip
= NULL
;
7805 print_containing_files ();
7807 for (i
= indepth
; i
>= 0; i
--)
7808 if (instack
[i
].fname
!= NULL
) {
7814 fprintf (stderr
, "%s:%d: ", ip
->nominal_fname
, ip
->lineno
);
7816 if (errno
< sys_nerr
)
7817 fprintf (stderr
, "%s: %s\n", name
, sys_errlist
[errno
]);
7819 fprintf (stderr
, "%s: undocumented I/O error\n", name
);
7824 /* Print error message but don't count it. */
7827 warning (msg
, arg1
, arg2
, arg3
)
7829 char *arg1
, *arg2
, *arg3
;
7832 FILE_BUF
*ip
= NULL
;
7834 if (inhibit_warnings
)
7837 if (warnings_are_errors
)
7840 print_containing_files ();
7842 for (i
= indepth
; i
>= 0; i
--)
7843 if (instack
[i
].fname
!= NULL
) {
7849 fprintf (stderr
, "%s:%d: ", ip
->nominal_fname
, ip
->lineno
);
7850 fprintf (stderr
, "warning: ");
7851 fprintf (stderr
, msg
, arg1
, arg2
, arg3
);
7852 fprintf (stderr
, "\n");
7856 error_with_line (line
, msg
, arg1
, arg2
, arg3
)
7859 char *arg1
, *arg2
, *arg3
;
7862 FILE_BUF
*ip
= NULL
;
7864 print_containing_files ();
7866 for (i
= indepth
; i
>= 0; i
--)
7867 if (instack
[i
].fname
!= NULL
) {
7873 fprintf (stderr
, "%s:%d: ", ip
->nominal_fname
, line
);
7874 fprintf (stderr
, msg
, arg1
, arg2
, arg3
);
7875 fprintf (stderr
, "\n");
7880 warning_with_line (line
, msg
, arg1
, arg2
, arg3
)
7883 char *arg1
, *arg2
, *arg3
;
7886 FILE_BUF
*ip
= NULL
;
7888 if (inhibit_warnings
)
7891 if (warnings_are_errors
)
7894 print_containing_files ();
7896 for (i
= indepth
; i
>= 0; i
--)
7897 if (instack
[i
].fname
!= NULL
) {
7903 fprintf (stderr
, "%s:%d: ", ip
->nominal_fname
, line
);
7904 fprintf (stderr
, "warning: ");
7905 fprintf (stderr
, msg
, arg1
, arg2
, arg3
);
7906 fprintf (stderr
, "\n");
7909 /* print an error message and maybe count it. */
7912 pedwarn (msg
, arg1
, arg2
, arg3
)
7914 char *arg1
, *arg2
, *arg3
;
7916 if (pedantic_errors
)
7917 error (msg
, arg1
, arg2
, arg3
);
7919 warning (msg
, arg1
, arg2
, arg3
);
7923 pedwarn_with_line (line
, msg
, arg1
, arg2
, arg3
)
7926 char *arg1
, *arg2
, *arg3
;
7928 if (pedantic_errors
)
7929 error_with_line (line
, msg
, arg1
, arg2
, arg3
);
7931 warning_with_line (line
, msg
, arg1
, arg2
, arg3
);
7934 /* Report a warning (or an error if pedantic_errors)
7935 giving specified file name and line number, not current. */
7938 pedwarn_with_file_and_line (file
, line
, msg
, arg1
, arg2
, arg3
)
7942 char *arg1
, *arg2
, *arg3
;
7945 if (!pedantic_errors
&& inhibit_warnings
)
7948 fprintf (stderr
, "%s:%d: ", file
, line
);
7949 if (pedantic_errors
)
7951 if (!pedantic_errors
)
7952 fprintf (stderr
, "warning: ");
7953 fprintf (stderr
, msg
, arg1
, arg2
, arg3
);
7954 fprintf (stderr
, "\n");
7957 /* Print the file names and line numbers of the #include
7958 commands which led to the current file. */
7961 print_containing_files ()
7963 FILE_BUF
*ip
= NULL
;
7967 /* If stack of files hasn't changed since we last printed
7968 this info, don't repeat it. */
7969 if (last_error_tick
== input_file_stack_tick
)
7972 for (i
= indepth
; i
>= 0; i
--)
7973 if (instack
[i
].fname
!= NULL
) {
7978 /* Give up if we don't find a source file. */
7982 /* Find the other, outer source files. */
7983 for (i
--; i
>= 0; i
--)
7984 if (instack
[i
].fname
!= NULL
) {
7988 fprintf (stderr
, "In file included");
7990 fprintf (stderr
, ",");
7993 fprintf (stderr
, " from %s:%d", ip
->nominal_fname
, ip
->lineno
);
7996 fprintf (stderr
, ":\n");
7998 /* Record we have printed the status as of this time. */
7999 last_error_tick
= input_file_stack_tick
;
8002 /* Return the line at which an error occurred.
8003 The error is not necessarily associated with the current spot
8004 in the input stack, so LINE says where. LINE will have been
8005 copied from ip->lineno for the current input level.
8006 If the current level is for a file, we return LINE.
8007 But if the current level is not for a file, LINE is meaningless.
8008 In that case, we return the lineno of the innermost file. */
8011 line_for_error (line
)
8017 for (i
= indepth
; i
>= 0; ) {
8018 if (instack
[i
].fname
!= 0)
8023 line1
= instack
[i
].lineno
;
8031 * If OBUF doesn't have NEEDED bytes after OPTR, make it bigger.
8033 * As things stand, nothing is ever placed in the output buffer to be
8034 * removed again except when it's KNOWN to be part of an identifier,
8035 * so flushing and moving down everything left, instead of expanding,
8039 /* You might think void was cleaner for the return type,
8040 but that would get type mismatch in check_expand in strict ANSI. */
8042 grow_outbuf (obuf
, needed
)
8043 register FILE_BUF
*obuf
;
8044 register int needed
;
8049 if (obuf
->length
- (obuf
->bufp
- obuf
->buf
) > needed
)
8052 /* Make it at least twice as big as it is now. */
8054 /* Make it have at least 150% of the free space we will need. */
8055 minsize
= (3 * needed
) / 2 + (obuf
->bufp
- obuf
->buf
);
8056 if (minsize
> obuf
->length
)
8057 obuf
->length
= minsize
;
8059 if ((p
= (U_CHAR
*) xrealloc (obuf
->buf
, obuf
->length
)) == NULL
)
8062 obuf
->bufp
= p
+ (obuf
->bufp
- obuf
->buf
);
8068 /* Symbol table for macro names and special symbols */
8071 * install a name in the main hash table, even if it is already there.
8072 * name stops with first non alphanumeric, except leading '#'.
8073 * caller must check against redefinition if that is desired.
8074 * delete_macro () removes things installed by install () in fifo order.
8075 * this is important because of the `defined' special symbol used
8076 * in #if, and also if pushdef/popdef directives are ever implemented.
8078 * If LEN is >= 0, it is the length of the name.
8079 * Otherwise, compute the length by scanning the entire name.
8081 * If HASH is >= 0, it is the precomputed hash code.
8082 * Otherwise, compute the hash code.
8085 install (name
, len
, type
, ivalue
, value
, hash
)
8088 enum node_type type
;
8093 register HASHNODE
*hp
;
8094 register int i
, bucket
;
8095 register U_CHAR
*p
, *q
;
8099 while (is_idchar
[*p
])
8105 hash
= hashf (name
, len
, HASHSIZE
);
8107 i
= sizeof (HASHNODE
) + len
+ 1;
8108 hp
= (HASHNODE
*) xmalloc (i
);
8110 hp
->bucket_hdr
= &hashtab
[bucket
];
8111 hp
->next
= hashtab
[bucket
];
8112 hashtab
[bucket
] = hp
;
8114 if (hp
->next
!= NULL
)
8115 hp
->next
->prev
= hp
;
8118 if (hp
->type
== T_CONST
)
8119 hp
->value
.ival
= ivalue
;
8121 hp
->value
.cpval
= value
;
8122 hp
->name
= ((U_CHAR
*) hp
) + sizeof (HASHNODE
);
8125 for (i
= 0; i
< len
; i
++)
8132 * find the most recent hash node for name name (ending with first
8133 * non-identifier char) installed by install
8135 * If LEN is >= 0, it is the length of the name.
8136 * Otherwise, compute the length by scanning the entire name.
8138 * If HASH is >= 0, it is the precomputed hash code.
8139 * Otherwise, compute the hash code.
8142 lookup (name
, len
, hash
)
8147 register U_CHAR
*bp
;
8148 register HASHNODE
*bucket
;
8151 for (bp
= name
; is_idchar
[*bp
]; bp
++) ;
8156 hash
= hashf (name
, len
, HASHSIZE
);
8158 bucket
= hashtab
[hash
];
8160 if (bucket
->length
== len
&& strncmp (bucket
->name
, name
, len
) == 0)
8162 bucket
= bucket
->next
;
8168 * Delete a hash node. Some weirdness to free junk from macros.
8169 * More such weirdness will have to be added if you define more hash
8170 * types that need it.
8173 /* Note that the DEFINITION of a macro is removed from the hash table
8174 but its storage is not freed. This would be a storage leak
8175 except that it is not reasonable to keep undefining and redefining
8176 large numbers of macros many times.
8177 In any case, this is necessary, because a macro can be #undef'd
8178 in the middle of reading the arguments to a call to it.
8179 If #undef freed the DEFINITION, that would crash. */
8186 if (hp
->prev
!= NULL
)
8187 hp
->prev
->next
= hp
->next
;
8188 if (hp
->next
!= NULL
)
8189 hp
->next
->prev
= hp
->prev
;
8191 /* make sure that the bucket chain header that
8192 the deleted guy was on points to the right thing afterwards. */
8193 if (hp
== *hp
->bucket_hdr
)
8194 *hp
->bucket_hdr
= hp
->next
;
8197 if (hp
->type
== T_MACRO
) {
8198 DEFINITION
*d
= hp
->value
.defn
;
8199 struct reflist
*ap
, *nextap
;
8201 for (ap
= d
->pattern
; ap
!= NULL
; ap
= nextap
) {
8212 * return hash function on name. must be compatible with the one
8213 * computed a step at a time, elsewhere
8216 hashf (name
, len
, hashsize
)
8217 register U_CHAR
*name
;
8224 r
= HASHSTEP (r
, *name
++);
8226 return MAKE_POS (r
) % hashsize
;
8230 /* Dump the definition of a single macro HP to OF. */
8232 dump_single_macro (hp
, of
)
8233 register HASHNODE
*hp
;
8236 register DEFINITION
*defn
= hp
->value
.defn
;
8242 /* Print the definition of the macro HP. */
8244 fprintf (of
, "#define %s", hp
->name
);
8246 if (defn
->nargs
>= 0) {
8250 for (i
= 0; i
< defn
->nargs
; i
++) {
8251 dump_arg_n (defn
, i
, of
);
8252 if (i
+ 1 < defn
->nargs
)
8262 for (ap
= defn
->pattern
; ap
!= NULL
; ap
= ap
->next
) {
8263 dump_defn_1 (defn
->expansion
, offset
, ap
->nchars
, of
);
8264 if (ap
->nchars
!= 0)
8266 offset
+= ap
->nchars
;
8269 if (ap
->raw_before
&& !concat
)
8270 fprintf (of
, " ## ");
8272 dump_arg_n (defn
, ap
->argno
, of
);
8273 if (ap
->raw_after
) {
8274 fprintf (of
, " ## ");
8278 dump_defn_1 (defn
->expansion
, offset
, defn
->length
- offset
, of
);
8282 /* Dump all macro definitions as #defines to stdout. */
8289 for (bucket
= 0; bucket
< HASHSIZE
; bucket
++) {
8290 register HASHNODE
*hp
;
8292 for (hp
= hashtab
[bucket
]; hp
; hp
= hp
->next
) {
8293 if (hp
->type
== T_MACRO
)
8294 dump_single_macro (hp
, stdout
);
8299 /* Output to OF a substring of a macro definition.
8300 BASE is the beginning of the definition.
8301 Output characters START thru LENGTH.
8302 Discard newlines outside of strings, thus
8303 converting funny-space markers to ordinary spaces. */
8306 dump_defn_1 (base
, start
, length
, of
)
8312 U_CHAR
*p
= base
+ start
;
8313 U_CHAR
*limit
= base
+ start
+ length
;
8318 else if (*p
== '\"' || *p
=='\'') {
8319 U_CHAR
*p1
= skip_quoted_string (p
, limit
, 0, NULL_PTR
,
8320 NULL_PTR
, NULL_PTR
);
8321 fwrite (p
, p1
- p
, 1, of
);
8328 /* Print the name of argument number ARGNUM of macro definition DEFN
8330 Recall that DEFN->args.argnames contains all the arg names
8331 concatenated in reverse order with comma-space in between. */
8334 dump_arg_n (defn
, argnum
, of
)
8339 register U_CHAR
*p
= defn
->args
.argnames
;
8340 while (argnum
+ 1 < defn
->nargs
) {
8341 p
= (U_CHAR
*) index (p
, ' ') + 1;
8345 while (*p
&& *p
!= ',') {
8351 /* Initialize syntactic classifications of characters. */
8354 initialize_char_syntax ()
8359 * Set up is_idchar and is_idstart tables. These should be
8360 * faster than saying (is_alpha (c) || c == '_'), etc.
8361 * Set up these things before calling any routines tthat
8364 for (i
= 'a'; i
<= 'z'; i
++) {
8365 is_idchar
[i
- 'a' + 'A'] = 1;
8367 is_idstart
[i
- 'a' + 'A'] = 1;
8370 for (i
= '0'; i
<= '9'; i
++)
8373 is_idstart
['_'] = 1;
8374 is_idchar
['$'] = dollars_in_ident
;
8375 is_idstart
['$'] = dollars_in_ident
;
8377 /* horizontal space table */
8378 is_hor_space
[' '] = 1;
8379 is_hor_space
['\t'] = 1;
8380 is_hor_space
['\v'] = 1;
8381 is_hor_space
['\f'] = 1;
8382 is_hor_space
['\r'] = 1;
8392 /* Initialize the built-in macros. */
8395 initialize_builtins (inp
, outp
)
8399 install ("__LINE__", -1, T_SPECLINE
, 0, 0, -1);
8400 install ("__DATE__", -1, T_DATE
, 0, 0, -1);
8401 install ("__FILE__", -1, T_FILE
, 0, 0, -1);
8402 install ("__BASE_FILE__", -1, T_BASE_FILE
, 0, 0, -1);
8403 install ("__INCLUDE_LEVEL__", -1, T_INCLUDE_LEVEL
, 0, 0, -1);
8404 install ("__VERSION__", -1, T_VERSION
, 0, 0, -1);
8405 #ifndef NO_BUILTIN_SIZE_TYPE
8406 install ("__SIZE_TYPE__", -1, T_SIZE_TYPE
, 0, 0, -1);
8408 #ifndef NO_BUILTIN_PTRDIFF_TYPE
8409 install ("__PTRDIFF_TYPE__ ", -1, T_PTRDIFF_TYPE
, 0, 0, -1);
8411 install ("__WCHAR_TYPE__", -1, T_WCHAR_TYPE
, 0, 0, -1);
8412 install ("__USER_LABEL_PREFIX__", -1, T_USER_LABEL_PREFIX_TYPE
, 0, 0, -1);
8413 install ("__REGISTER_PREFIX__", -1, T_REGISTER_PREFIX_TYPE
, 0, 0, -1);
8414 install ("__TIME__", -1, T_TIME
, 0, 0, -1);
8416 install ("__STDC__", -1, T_CONST
, STDC_VALUE
, 0, -1);
8418 install ("__OBJC__", -1, T_CONST
, 1, 0, -1);
8419 /* This is supplied using a -D by the compiler driver
8420 so that it is present only when truly compiling with GNU C. */
8421 /* install ("__GNUC__", -1, T_CONST, 2, 0, -1); */
8425 char directive
[2048];
8426 register struct directive
*dp
= &directive_table
[0];
8427 struct tm
*timebuf
= timestamp ();
8429 sprintf (directive
, " __BASE_FILE__ \"%s\"\n",
8430 instack
[0].nominal_fname
);
8431 output_line_command (inp
, outp
, 0, same_file
);
8432 pass_thru_directive (directive
, &directive
[strlen (directive
)], outp
, dp
);
8434 sprintf (directive
, " __VERSION__ \"%s\"\n", version_string
);
8435 output_line_command (inp
, outp
, 0, same_file
);
8436 pass_thru_directive (directive
, &directive
[strlen (directive
)], outp
, dp
);
8438 sprintf (directive
, " __SIZE_TYPE__ %s\n", SIZE_TYPE
);
8439 output_line_command (inp
, outp
, 0, same_file
);
8440 pass_thru_directive (directive
, &directive
[strlen (directive
)], outp
, dp
);
8442 sprintf (directive
, " __PTRDIFF_TYPE__ %s\n", PTRDIFF_TYPE
);
8443 output_line_command (inp
, outp
, 0, same_file
);
8444 pass_thru_directive (directive
, &directive
[strlen (directive
)], outp
, dp
);
8446 sprintf (directive
, " __WCHAR_TYPE__ %s\n", WCHAR_TYPE
);
8447 output_line_command (inp
, outp
, 0, same_file
);
8448 pass_thru_directive (directive
, &directive
[strlen (directive
)], outp
, dp
);
8450 sprintf (directive
, " __DATE__ \"%s %2d %4d\"\n",
8451 monthnames
[timebuf
->tm_mon
],
8452 timebuf
->tm_mday
, timebuf
->tm_year
+ 1900);
8453 output_line_command (inp
, outp
, 0, same_file
);
8454 pass_thru_directive (directive
, &directive
[strlen (directive
)], outp
, dp
);
8456 sprintf (directive
, " __TIME__ \"%02d:%02d:%02d\"\n",
8457 timebuf
->tm_hour
, timebuf
->tm_min
, timebuf
->tm_sec
);
8458 output_line_command (inp
, outp
, 0, same_file
);
8459 pass_thru_directive (directive
, &directive
[strlen (directive
)], outp
, dp
);
8463 sprintf (directive
, " __STDC__ 1");
8464 output_line_command (inp
, outp
, 0, same_file
);
8465 pass_thru_directive (directive
, &directive
[strlen (directive
)],
8470 sprintf (directive
, " __OBJC__ 1");
8471 output_line_command (inp
, outp
, 0, same_file
);
8472 pass_thru_directive (directive
, &directive
[strlen (directive
)],
8479 * process a given definition string, for initialization
8480 * If STR is just an identifier, define it with value 1.
8481 * If STR has anything after the identifier, then it should
8482 * be identifier=definition.
8486 make_definition (str
, op
)
8491 struct directive
*kt
;
8496 if (!is_idstart
[*p
]) {
8497 error ("malformed option `-D %s'", str
);
8500 while (is_idchar
[*++p
])
8503 buf
= (U_CHAR
*) alloca (p
- buf
+ 4);
8504 strcpy ((char *)buf
, str
);
8505 strcat ((char *)buf
, " 1");
8506 } else if (*p
!= '=') {
8507 error ("malformed option `-D %s'", str
);
8511 /* Copy the entire option so we can modify it. */
8512 buf
= (U_CHAR
*) alloca (2 * strlen (str
) + 1);
8513 strncpy (buf
, str
, p
- str
);
8514 /* Change the = to a space. */
8516 /* Scan for any backslash-newline and remove it. */
8520 if (*p
== '\\' && p
[1] == '\n')
8522 /* Change newline chars into newline-markers. */
8523 else if (*p
== '\n')
8535 ip
= &instack
[++indepth
];
8536 ip
->nominal_fname
= ip
->fname
= "*Initialization*";
8538 ip
->buf
= ip
->bufp
= buf
;
8539 ip
->length
= strlen (buf
);
8543 ip
->if_stack
= if_stack
;
8544 ip
->system_header_p
= 0;
8546 for (kt
= directive_table
; kt
->type
!= T_DEFINE
; kt
++)
8549 /* Pass NULL instead of OP, since this is a "predefined" macro. */
8550 do_define (buf
, buf
+ strlen (buf
), NULL
, kt
);
8554 /* JF, this does the work for the -U option */
8557 make_undef (str
, op
)
8562 struct directive
*kt
;
8564 ip
= &instack
[++indepth
];
8565 ip
->nominal_fname
= ip
->fname
= "*undef*";
8567 ip
->buf
= ip
->bufp
= str
;
8568 ip
->length
= strlen (str
);
8572 ip
->if_stack
= if_stack
;
8573 ip
->system_header_p
= 0;
8575 for (kt
= directive_table
; kt
->type
!= T_UNDEF
; kt
++)
8578 do_undef (str
, str
+ strlen (str
), op
, kt
);
8582 /* Process the string STR as if it appeared as the body of a #assert.
8583 OPTION is the option name for which STR was the argument. */
8586 make_assertion (option
, str
)
8591 struct directive
*kt
;
8592 U_CHAR
*buf
, *p
, *q
;
8594 /* Copy the entire option so we can modify it. */
8595 buf
= (U_CHAR
*) alloca (strlen (str
) + 1);
8596 strcpy ((char *) buf
, str
);
8597 /* Scan for any backslash-newline and remove it. */
8600 if (*p
== '\\' && p
[1] == '\n')
8608 if (!is_idstart
[*p
]) {
8609 error ("malformed option `%s %s'", option
, str
);
8612 while (is_idchar
[*++p
])
8614 while (*p
== ' ' || *p
== '\t') p
++;
8615 if (! (*p
== 0 || *p
== '(')) {
8616 error ("malformed option `%s %s'", option
, str
);
8620 ip
= &instack
[++indepth
];
8621 ip
->nominal_fname
= ip
->fname
= "*Initialization*";
8623 ip
->buf
= ip
->bufp
= buf
;
8624 ip
->length
= strlen (buf
);
8628 ip
->if_stack
= if_stack
;
8629 ip
->system_header_p
= 0;
8631 for (kt
= directive_table
; kt
->type
!= T_ASSERT
; kt
++)
8634 /* pass NULL as output ptr to do_define since we KNOW it never
8635 does any output.... */
8636 do_assert (buf
, buf
+ strlen (buf
) , NULL_PTR
, kt
);
8640 /* Append a chain of `struct file_name_list's
8641 to the end of the main include chain.
8642 FIRST is the beginning of the chain to append, and LAST is the end. */
8645 append_include_chain (first
, last
)
8646 struct file_name_list
*first
, *last
;
8648 struct file_name_list
*dir
;
8650 if (!first
|| !last
)
8656 last_include
->next
= first
;
8658 if (first_bracket_include
== 0)
8659 first_bracket_include
= first
;
8661 for (dir
= first
; ; dir
= dir
->next
) {
8662 int len
= strlen (dir
->fname
) + INCLUDE_LEN_FUDGE
;
8663 if (len
> max_include_len
)
8664 max_include_len
= len
;
8670 last_include
= last
;
8673 /* Add output to `deps_buffer' for the -M switch.
8674 STRING points to the text to be output.
8675 SIZE is the number of bytes, or 0 meaning output until a null.
8676 Outputting the empty string breaks the line if it is long enough. */
8679 deps_output (string
, size
)
8684 size
= strlen (string
);
8686 #ifndef MAX_OUTPUT_COLUMNS
8687 #define MAX_OUTPUT_COLUMNS 75
8689 if (size
== 0 && deps_column
!= 0
8690 && size
+ deps_column
> MAX_OUTPUT_COLUMNS
) {
8691 deps_output ("\\\n ", 0);
8695 if (deps_size
+ size
+ 1 > deps_allocated_size
) {
8696 deps_allocated_size
= deps_size
+ size
+ 50;
8697 deps_allocated_size
*= 2;
8698 deps_buffer
= (char *) xrealloc (deps_buffer
, deps_allocated_size
);
8700 bcopy (string
, &deps_buffer
[deps_size
], size
);
8702 deps_column
+= size
;
8703 deps_buffer
[deps_size
] = 0;
8706 #if defined(USG) || defined(VMS)
8712 register unsigned length
;
8714 while (length
-- > 0)
8719 bcopy (b1
, b2
, length
)
8722 register unsigned length
;
8724 while (length
-- > 0)
8729 bcmp (b1
, b2
, length
) /* This could be a macro! */
8732 register unsigned length
;
8734 while (length
-- > 0)
8740 #endif /* not BSTRING */
8741 #endif /* USG or VMS */
8748 fprintf (stderr
, "%s: ", progname
);
8749 fprintf (stderr
, str
, arg
);
8750 fprintf (stderr
, "\n");
8751 exit (FAILURE_EXIT_CODE
);
8754 /* More 'friendly' abort that prints the line and file.
8755 config.h can #define abort fancy_abort if you like that sort of thing. */
8760 fatal ("Internal gcc abort.");
8764 perror_with_name (name
)
8767 fprintf (stderr
, "%s: ", progname
);
8768 if (errno
< sys_nerr
)
8769 fprintf (stderr
, "%s: %s\n", name
, sys_errlist
[errno
]);
8771 fprintf (stderr
, "%s: undocumented I/O error\n", name
);
8776 pfatal_with_name (name
)
8779 perror_with_name (name
);
8783 exit (FAILURE_EXIT_CODE
);
8787 /* Handler for SIGPIPE. */
8791 /* If this is missing, some compilers complain. */
8794 fatal ("output pipe has been closed");
8800 fatal ("Memory exhausted.");
8808 register char *ptr
= (char *) malloc (size
);
8809 if (ptr
!= 0) return (ptr
);
8816 xrealloc (old
, size
)
8820 register char *ptr
= (char *) realloc (old
, size
);
8821 if (ptr
!= 0) return (ptr
);
8828 xcalloc (number
, size
)
8829 unsigned number
, size
;
8831 register unsigned total
= number
* size
;
8832 register char *ptr
= (char *) malloc (total
);
8837 /* It's not too long, so loop, zeroing by longs.
8838 It must be safe because malloc values are always well aligned. */
8839 register long *zp
= (long *) ptr
;
8840 register long *zl
= (long *) (ptr
+ total
- 4);
8841 register int i
= total
- 4;
8860 unsigned size
= strlen (input
);
8861 char *output
= xmalloc (size
+ 1);
8862 strcpy (output
, input
);
8866 /* Get the file-mode and data size of the file open on FD
8867 and store them in *MODE_POINTER and *SIZE_POINTER. */
8870 file_size_and_mode (fd
, mode_pointer
, size_pointer
)
8873 long int *size_pointer
;
8877 if (fstat (fd
, &sbuf
) < 0) return (-1);
8878 if (mode_pointer
) *mode_pointer
= sbuf
.st_mode
;
8879 if (size_pointer
) *size_pointer
= sbuf
.st_size
;
8885 /* Under VMS we need to fix up the "include" specification
8886 filename so that everything following the 1st slash is
8887 changed into its correct VMS file specification. */
8890 hack_vms_include_specification (fname
)
8893 register char *cp
, *cp1
, *cp2
;
8894 int f
, check_filename_before_returning
, no_prefix_seen
;
8897 check_filename_before_returning
= 0;
8900 /* Ignore leading "./"s */
8901 while (fname
[0] == '.' && fname
[1] == '/') {
8902 strcpy (fname
, fname
+2);
8903 no_prefix_seen
= 1; /* mark this for later */
8905 /* Look for the boundary between the VMS and UNIX filespecs */
8906 cp
= rindex (fname
, ']'); /* Look for end of dirspec. */
8907 if (cp
== 0) cp
= rindex (fname
, '>'); /* ... Ditto */
8908 if (cp
== 0) cp
= rindex (fname
, ':'); /* Look for end of devspec. */
8912 cp
= index (fname
, '/'); /* Look for the "/" */
8915 cp2
= Local
; /* initialize */
8917 /* We are trying to do a number of things here. First of all, we are
8918 trying to hammer the filenames into a standard format, such that later
8919 processing can handle them.
8921 If the file name contains something like [dir.], then it recognizes this
8922 as a root, and strips the ".]". Later processing will add whatever is
8923 needed to get things working properly.
8925 If no device is specified, then the first directory name is taken to be
8926 a device name (or a rooted logical). */
8928 /* See if we found that 1st slash */
8929 if (cp
== 0) return; /* Nothing to do!!! */
8930 if (*cp
!= '/') return; /* Nothing to do!!! */
8931 /* Point to the UNIX filename part (which needs to be fixed!) */
8933 /* If the directory spec is not rooted, we can just copy
8934 the UNIX filename part and we are done */
8935 if (((cp
- fname
) > 1) && ((cp
[-1] == ']') || (cp
[-1] == '>'))) {
8936 if (cp
[-2] != '.') {
8938 * The VMS part ends in a `]', and the preceding character is not a `.'.
8939 * We strip the `]', and then splice the two parts of the name in the
8940 * usual way. Given the default locations for include files in cccp.c,
8941 * we will only use this code if the user specifies alternate locations
8942 * with the /include (-I) switch on the command line. */
8943 cp
-= 1; /* Strip "]" */
8944 cp1
--; /* backspace */
8947 * The VMS part has a ".]" at the end, and this will not do. Later
8948 * processing will add a second directory spec, and this would be a syntax
8949 * error. Thus we strip the ".]", and thus merge the directory specs.
8950 * We also backspace cp1, so that it points to a '/'. This inhibits the
8951 * generation of the 000000 root directory spec (which does not belong here
8954 cp
-= 2; /* Strip ".]" */
8955 cp1
--; }; /* backspace */
8958 /* We drop in here if there is no VMS style directory specification yet.
8959 * If there is no device specification either, we make the first dir a
8960 * device and try that. If we do not do this, then we will be essentially
8961 * searching the users default directory (as if they did a #include "asdf.h").
8963 * Then all we need to do is to push a '[' into the output string. Later
8964 * processing will fill this in, and close the bracket.
8966 if (cp
[-1] != ':') *cp2
++ = ':'; /* dev not in spec. take first dir */
8967 *cp2
++ = '['; /* Open the directory specification */
8970 /* at this point we assume that we have the device spec, and (at least
8971 the opening "[" for a directory specification. We may have directories
8972 specified already */
8974 /* If there are no other slashes then the filename will be
8975 in the "root" directory. Otherwise, we need to add
8976 directory specifications. */
8977 if (index (cp1
, '/') == 0) {
8978 /* Just add "000000]" as the directory string */
8979 strcpy (cp2
, "000000]");
8980 cp2
+= strlen (cp2
);
8981 check_filename_before_returning
= 1; /* we might need to fool with this later */
8983 /* As long as there are still subdirectories to add, do them. */
8984 while (index (cp1
, '/') != 0) {
8985 /* If this token is "." we can ignore it */
8986 if ((cp1
[0] == '.') && (cp1
[1] == '/')) {
8990 /* Add a subdirectory spec. Do not duplicate "." */
8991 if (cp2
[-1] != '.' && cp2
[-1] != '[' && cp2
[-1] != '<')
8993 /* If this is ".." then the spec becomes "-" */
8994 if ((cp1
[0] == '.') && (cp1
[1] == '.') && (cp
[2] == '/')) {
8995 /* Add "-" and skip the ".." */
9000 /* Copy the subdirectory */
9001 while (*cp1
!= '/') *cp2
++= *cp1
++;
9002 cp1
++; /* Skip the "/" */
9004 /* Close the directory specification */
9005 if (cp2
[-1] == '.') /* no trailing periods */
9009 /* Now add the filename */
9010 while (*cp1
) *cp2
++ = *cp1
++;
9012 /* Now append it to the original VMS spec. */
9015 /* If we put a [000000] in the filename, try to open it first. If this fails,
9016 remove the [000000], and return that name. This provides flexibility
9017 to the user in that they can use both rooted and non-rooted logical names
9018 to point to the location of the file. */
9020 if (check_filename_before_returning
&& no_prefix_seen
) {
9021 f
= open (fname
, O_RDONLY
, 0666);
9023 /* The file name is OK as it is, so return it as is. */
9027 /* The filename did not work. Try to remove the [000000] from the name,
9029 cp
= index (fname
, '[');
9030 cp2
= index (fname
, ']') + 1;
9031 strcpy (cp
, cp2
); /* this gets rid of it */
9039 /* These are the read/write replacement routines for
9040 VAX-11 "C". They make read/write behave enough
9041 like their UNIX counterparts that CCCP will work */
9044 read (fd
, buf
, size
)
9049 #undef read /* Get back the REAL read routine */
9051 register int total
= 0;
9053 /* Read until the buffer is exhausted */
9055 /* Limit each read to 32KB */
9056 i
= (size
> (32*1024)) ? (32*1024) : size
;
9057 i
= read (fd
, buf
, i
);
9059 if (i
== 0) return (total
);
9062 /* Account for this read */
9071 write (fd
, buf
, size
)
9076 #undef write /* Get back the REAL write routine */
9080 /* Limit individual writes to 32Kb */
9083 j
= (i
> (32*1024)) ? (32*1024) : i
;
9084 if (write (fd
, buf
, j
) < 0) return (-1);
9085 /* Account for the data written */
9092 /* The following wrapper functions supply additional arguments to the VMS
9093 I/O routines to optimize performance with file handling. The arguments
9095 "mbc=16" - Set multi-block count to 16 (use a 8192 byte buffer).
9096 "deq=64" - When extending the file, extend it in chunks of 32Kbytes.
9097 "fop=tef"- Truncate unused portions of file when closing file.
9098 "shr=nil"- Disallow file sharing while file is open.
9102 freopen (fname
, type
, oldfile
)
9107 #undef freopen /* Get back the REAL fopen routine */
9108 if (strcmp (type
, "w") == 0)
9109 return freopen (fname
, type
, oldfile
, "mbc=16", "deq=64", "fop=tef", "shr=nil");
9110 return freopen (fname
, type
, oldfile
, "mbc=16");
9118 #undef fopen /* Get back the REAL fopen routine */
9119 if (strcmp (type
, "w") == 0)
9120 return fopen (fname
, type
, "mbc=16", "deq=64", "fop=tef", "shr=nil");
9121 return fopen (fname
, type
, "mbc=16");
9125 open (fname
, flags
, prot
)
9130 #undef open /* Get back the REAL open routine */
9131 return open (fname
, flags
, prot
, "mbc=16", "deq=64", "fop=tef");
9134 /* Avoid run-time library bug, where copying M out of N+M characters with
9135 N >= 65535 results in VAXCRTL's strncat falling into an infinite loop.
9136 gcc-cpp exercises this particular bug. */
9139 strncat (dst
, src
, cnt
)
9144 register char *d
= dst
, *s
= (char *) src
;
9145 register int n
= cnt
; /* convert to _signed_ type */
9147 while (*d
) d
++; /* advance to end */
9149 if (!(*d
++ = *s
++)) break;
9150 if (n
< 0) *d
= '\0';