1 /* C Compatible Compiler Preprocessor (CCCP)
2 Copyright (C) 1986, 87, 89, 92-98, 1999 Free Software Foundation, Inc.
3 Written by Paul Rubin, June 1986
4 Adapted to ANSI C, Richard Stallman, Jan 1987
6 This program is free software; you can redistribute it and/or modify it
7 under the terms of the GNU General Public License as published by the
8 Free Software Foundation; either version 2, or (at your option) any
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with this program; if not, write to the Free Software
18 Foundation, 59 Temple Place - Suite 330,
19 Boston, MA 02111-1307, USA. */
26 #ifdef HAVE_SYS_RESOURCE_H
27 # include <sys/resource.h>
30 typedef unsigned char U_CHAR;
36 #ifdef MULTIBYTE_CHARS
39 #endif /* MULTIBYTE_CHARS */
41 #ifndef GET_ENV_PATH_LIST
42 #define GET_ENV_PATH_LIST(VAR,NAME) do { (VAR) = getenv (NAME); } while (0)
45 #ifndef STANDARD_INCLUDE_DIR
46 # define STANDARD_INCLUDE_DIR "/usr/include"
49 /* By default, colon separates directories in a path. */
50 #ifndef PATH_SEPARATOR
51 # define PATH_SEPARATOR ':'
54 /* By default, a slash separates directory names. */
56 # define DIR_SEPARATOR '/'
59 /* By default, the suffix for object files is ".o". */
61 # define HAVE_OBJECT_SUFFIX
63 # define OBJECT_SUFFIX ".o"
66 /* VMS-specific definitions */
71 #define open(fname,mode,prot) VMS_open (fname,mode,prot)
72 #define fopen(fname,mode) VMS_fopen (fname,mode)
73 #define freopen(fname,mode,ofile) VMS_freopen (fname,mode,ofile)
74 #define fstat(fd,stbuf) VMS_fstat (fd,stbuf)
75 #define fwrite(ptr,size,nitems,stream) VMS_fwrite (ptr,size,nitems,stream)
76 static int VMS_fstat (), VMS_stat ();
77 static int VMS_open ();
78 static FILE *VMS_fopen ();
79 static FILE *VMS_freopen ();
80 static size_t VMS_fwrite ();
81 static void hack_vms_include_specification ();
82 #define INO_T_EQ(a, b) (!bcmp((char *) &(a), (char *) &(b), sizeof (a)))
83 #define INO_T_HASH(a) 0
84 #define INCLUDE_LEN_FUDGE 12 /* leave room for VMS syntax conversion */
87 /* Windows does not natively support inodes, and neither does MSDOS. */
88 #if (defined (_WIN32) && ! defined (__CYGWIN__) && ! defined (_UWIN)) \
89 || defined (__MSDOS__)
90 #define INO_T_EQ(a, b) 0
94 #define INO_T_EQ(a, b) ((a) == (b))
98 #define INO_T_HASH(a) (a)
101 #ifndef INCLUDE_LEN_FUDGE
102 #define INCLUDE_LEN_FUDGE 0
105 /* External declarations. */
107 extern char *version_string;
108 HOST_WIDEST_INT parse_escape PROTO((char **, HOST_WIDEST_INT));
109 HOST_WIDEST_INT parse_c_expression PROTO((char *, int));
111 /* Name under which this program was invoked. */
113 static char *progname;
115 /* Nonzero means use extra default include directories for C++. */
117 static int cplusplus;
119 /* Nonzero means handle cplusplus style comments */
121 static int cplusplus_comments;
123 /* Nonzero means handle #import, for objective C. */
127 /* Nonzero means this is an assembly file, and allow
128 unknown directives, which could be comments. */
132 /* Current maximum length of directory names in the search path
133 for include files. (Altered as we get more of them.) */
135 static int max_include_len;
137 /* Nonzero means turn NOTREACHED into #pragma NOTREACHED etc */
139 static int for_lint = 0;
141 /* Nonzero means copy comments into the output file. */
143 static int put_out_comments = 0;
145 /* Nonzero means don't process the ANSI trigraph sequences. */
147 static int no_trigraphs = 0;
149 /* Nonzero means print the names of included files rather than
150 the preprocessed output. 1 means just the #include "...",
151 2 means #include <...> as well. */
153 static int print_deps = 0;
155 /* Nonzero if missing .h files in -M output are assumed to be generated
156 files and not errors. */
158 static int print_deps_missing_files = 0;
160 /* Nonzero means print names of header files (-H). */
162 static int print_include_names = 0;
164 /* Nonzero means don't output line number information. */
166 static int no_line_directives;
168 /* Nonzero means output the text in failing conditionals,
169 inside #failed ... #endfailed. */
171 static int output_conditionals;
173 /* dump_only means inhibit output of the preprocessed text
174 and instead output the definitions of all user-defined
175 macros in a form suitable for use as input to cccp.
176 dump_names means pass #define and the macro name through to output.
177 dump_definitions means pass the whole definition (plus #define) through
180 static enum {dump_none, dump_only, dump_names, dump_definitions}
181 dump_macros = dump_none;
183 /* Nonzero means pass all #define and #undef directives which we actually
184 process through to the output stream. This feature is used primarily
185 to allow cc1 to record the #defines and #undefs for the sake of
186 debuggers which understand about preprocessor macros, but it may
187 also be useful with -E to figure out how symbols are defined, and
188 where they are defined. */
189 static int debug_output = 0;
191 /* Nonzero means pass #include lines through to the output,
192 even if they are ifdefed out. */
193 static int dump_includes;
195 /* Nonzero indicates special processing used by the pcp program. The
196 special effects of this mode are:
198 Inhibit all macro expansion, except those inside #if directives.
200 Process #define directives normally, and output their contents
203 Output preconditions to pcp_outfile indicating all the relevant
204 preconditions for use of this file in a later cpp run.
206 static FILE *pcp_outfile;
208 /* Nonzero means we are inside an IF during a -pcp run. In this mode
209 macro expansion is done, and preconditions are output for all macro
210 uses requiring them. */
211 static int pcp_inside_if;
213 /* Nonzero means never to include precompiled files.
214 This is 1 since there's no way now to make precompiled files,
215 so it's not worth testing for them. */
216 static int no_precomp = 1;
218 /* Nonzero means give all the error messages the ANSI standard requires. */
222 /* Nonzero means try to make failure to fit ANSI C an error. */
224 static int pedantic_errors;
226 /* Nonzero means don't print warning messages. -w. */
228 static int inhibit_warnings = 0;
230 /* Nonzero means warn if slash-star appears in a slash-star comment,
231 or if newline-backslash appears in a slash-slash comment. */
233 static int warn_comments;
235 /* Nonzero means warn if a macro argument is (or would be)
236 stringified with -traditional. */
238 static int warn_stringify;
240 /* Nonzero means warn if there are any trigraphs. */
242 static int warn_trigraphs;
244 /* Nonzero means warn if undefined identifiers are evaluated in an #if. */
246 static int warn_undef;
248 /* Nonzero means warn if we find white space where it doesn't belong. */
250 static int warn_white_space;
252 /* Nonzero means warn if #import is used. */
254 static int warn_import = 1;
256 /* Nonzero means turn warnings into errors. */
258 static int warnings_are_errors;
260 /* Nonzero means try to imitate old fashioned non-ANSI preprocessor. */
264 /* Nonzero for the 1989 C Standard, including corrigenda and amendments. */
268 /* Nonzero for the 199x C Standard. */
272 /* Nonzero causes output not to be done,
273 but directives such as #define that have side effects
276 static int no_output;
278 /* Nonzero means we should look for header.gcc files that remap file names. */
281 /* Nonzero means this file was included with a -imacros or -include
282 command line and should not be recorded as an include file. */
284 static int no_record_file;
286 /* Nonzero means that we have finished processing the command line options.
287 This flag is used to decide whether or not to issue certain errors
290 static int done_initializing = 0;
292 /* Line where a newline was first seen in a string constant. */
294 static int multiline_string_line = 0;
296 /* I/O buffer structure.
297 The `fname' field is nonzero for source files and #include files
298 and for the dummy text used for -D and -U.
299 It is zero for rescanning results of macro expansion
300 and for expanding macro arguments. */
301 #define INPUT_STACK_MAX 400
302 static struct file_buf {
304 /* Filename specified with #line directive. */
306 /* The length of nominal_fname, which may contain embedded NULs. */
307 size_t nominal_fname_len;
308 /* Include file description. */
309 struct include_file *inc;
310 /* Record where in the search path this file was found.
311 For #include_next. */
312 struct file_name_list *dir;
317 /* Macro that this level is the expansion of.
318 Included so that we can reenable the macro
319 at the end of this level. */
320 struct hashnode *macro;
321 /* Value of if_stack at start of this file.
322 Used to prohibit unmatched #endif (etc) in an include file. */
323 struct if_stack *if_stack;
324 /* Object to be freed at end of input at this level. */
326 /* True if this is a system header file; see is_system_include. */
327 char system_header_p;
328 } instack[INPUT_STACK_MAX];
330 static int last_error_tick; /* Incremented each time we print it. */
331 static int input_file_stack_tick; /* Incremented when the status changes. */
333 /* Current nesting level of input sources.
334 `instack[indepth]' is the level currently being read. */
335 static int indepth = -1;
336 #define CHECK_DEPTH(code) \
337 if (indepth >= (INPUT_STACK_MAX - 1)) \
339 error_with_line (line_for_error (instack[indepth].lineno), \
340 "macro or `#include' recursion too deep"); \
344 /* Current depth in #include directives that use <...>. */
345 static int system_include_depth = 0;
347 typedef struct file_buf FILE_BUF;
349 /* The output buffer. Its LENGTH field is the amount of room allocated
350 for the buffer, not the number of chars actually present. To get
351 that, subtract outbuf.buf from outbuf.bufp. */
353 #define OUTBUF_SIZE 10 /* initial size of output buffer */
354 static FILE_BUF outbuf;
356 /* Grow output buffer OBUF points at
357 so it can hold at least NEEDED more chars. */
359 #define check_expand(OBUF, NEEDED) \
360 (((OBUF)->length - ((OBUF)->bufp - (OBUF)->buf) <= (NEEDED)) \
361 ? grow_outbuf ((OBUF), (NEEDED)) : 0)
363 struct file_name_list
365 struct file_name_list *next;
366 /* If the following is 1, it is a C-language system include
368 int c_system_include_path;
369 /* Mapping of file names for this directory. */
370 struct file_name_map *name_map;
371 /* Non-zero if name_map is valid. */
373 /* The include directory status. */
375 /* The include prefix: "" denotes the working directory,
376 otherwise fname must end in '/'.
377 The actual size is dynamically allocated. */
381 /* #include "file" looks in source file dir, then stack. */
382 /* #include <file> just looks in the stack. */
383 /* -I directories are added to the end, then the defaults are added. */
385 static struct default_include {
386 char *fname; /* The name of the directory. */
387 char *component; /* The component containing the directory */
388 int cplusplus; /* Only look here if we're compiling C++. */
389 int cxx_aware; /* Includes in this directory don't need to
390 be wrapped in extern "C" when compiling
392 int included; /* Set if the directory is acceptable. */
393 } include_defaults_array[]
394 #ifdef INCLUDE_DEFAULTS
398 /* Pick up GNU C++ specific include files. */
399 { GPLUSPLUS_INCLUDE_DIR, "G++", 1, 1, 0 },
401 /* This is the dir for fixincludes. Put it just before
402 the files that we fix. */
403 { GCC_INCLUDE_DIR, "GCC", 0, 0, 0 },
404 /* For cross-compilation, this dir name is generated
405 automatically in Makefile.in. */
406 { CROSS_INCLUDE_DIR, "GCC", 0, 0, 0 },
407 #ifdef TOOL_INCLUDE_DIR
408 /* This is another place that the target system's headers might be. */
409 { TOOL_INCLUDE_DIR, "BINUTILS", 0, 0, 0 },
411 #else /* not CROSS_COMPILE */
412 #ifdef LOCAL_INCLUDE_DIR
413 /* This should be /usr/local/include and should come before
414 the fixincludes-fixed header files. */
415 { LOCAL_INCLUDE_DIR, 0, 0, 1, 0 },
417 #ifdef TOOL_INCLUDE_DIR
418 /* This is here ahead of GCC_INCLUDE_DIR because assert.h goes here.
419 Likewise, behind LOCAL_INCLUDE_DIR, where glibc puts its assert.h. */
420 { TOOL_INCLUDE_DIR, "BINUTILS", 0, 0, 0 },
422 /* This is the dir for fixincludes. Put it just before
423 the files that we fix. */
424 { GCC_INCLUDE_DIR, "GCC", 0, 0, 0 },
425 /* Some systems have an extra dir of include files. */
426 #ifdef SYSTEM_INCLUDE_DIR
427 { SYSTEM_INCLUDE_DIR, 0, 0, 0, 0 },
429 #ifndef STANDARD_INCLUDE_COMPONENT
430 #define STANDARD_INCLUDE_COMPONENT 0
432 { STANDARD_INCLUDE_DIR, STANDARD_INCLUDE_COMPONENT, 0, 0, 0 },
433 #endif /* not CROSS_COMPILE */
436 #endif /* no INCLUDE_DEFAULTS */
438 /* The code looks at the defaults through this pointer, rather than through
439 the constant structure above. This pointer gets changed if an environment
440 variable specifies other defaults. */
441 static struct default_include *include_defaults = include_defaults_array;
443 static struct file_name_list *include = 0; /* First dir to search */
444 /* First dir to search for <file> */
445 /* This is the first element to use for #include <...>.
446 If it is 0, use the entire chain for such includes. */
447 static struct file_name_list *first_bracket_include = 0;
448 /* This is the first element in the chain that corresponds to
449 a directory of system header files. */
450 static struct file_name_list *first_system_include = 0;
451 static struct file_name_list *last_include = 0; /* Last in chain */
453 /* Chain of include directories to put at the end of the other chain. */
454 static struct file_name_list *after_include = 0;
455 static struct file_name_list *last_after_include = 0; /* Last in chain */
457 /* Chain to put at the start of the system include files. */
458 static struct file_name_list *before_system = 0;
459 static struct file_name_list *last_before_system = 0; /* Last in chain */
461 /* Directory prefix that should replace `/usr' in the standard
462 include file directories. */
463 static char *include_prefix;
465 /* Maintain and search list of included files. */
467 struct include_file {
468 struct include_file *next; /* for include_hashtab */
469 struct include_file *next_ino; /* for include_ino_hashtab */
471 /* If the following is the empty string, it means #pragma once
472 was seen in this include file, or #import was applied to the file.
473 Otherwise, if it is nonzero, it is a macro name.
474 Don't include the file again if that macro is defined. */
475 U_CHAR *control_macro;
476 /* Nonzero if the dependency on this include file has been output. */
481 /* Hash tables of files already included with #include or #import.
482 include_hashtab is by full name; include_ino_hashtab is by inode number. */
484 #define INCLUDE_HASHSIZE 61
485 static struct include_file *include_hashtab[INCLUDE_HASHSIZE];
486 static struct include_file *include_ino_hashtab[INCLUDE_HASHSIZE];
488 /* Global list of strings read in from precompiled files. This list
489 is kept in the order the strings are read in, with new strings being
490 added at the end through stringlist_tailp. We use this list to output
491 the strings at the end of the run.
493 static STRINGDEF *stringlist;
494 static STRINGDEF **stringlist_tailp = &stringlist;
497 /* Structure returned by create_definition */
498 typedef struct macrodef MACRODEF;
501 struct definition *defn;
506 enum sharp_token_type {
507 NO_SHARP_TOKEN = 0, /* token not present */
509 SHARP_TOKEN = '#', /* token spelled with # only */
510 WHITE_SHARP_TOKEN, /* token spelled with # and white space */
512 PERCENT_COLON_TOKEN = '%', /* token spelled with %: only */
513 WHITE_PERCENT_COLON_TOKEN /* token spelled with %: and white space */
516 /* Structure allocated for every #define. For a simple replacement
519 nargs = -1, the `pattern' list is null, and the expansion is just
520 the replacement text. Nargs = 0 means a functionlike macro with no args,
522 #define getchar() getc (stdin) .
523 When there are args, the expansion is the replacement text with the
524 args squashed out, and the reflist is a list describing how to
525 build the output from the input: e.g., "3 chars, then the 1st arg,
526 then 9 chars, then the 3rd arg, then 0 chars, then the 2nd arg".
527 The chars here come from the expansion. Whatever is left of the
528 expansion after the last arg-occurrence is copied after that arg.
529 Note that the reflist can be arbitrarily long---
530 its length depends on the number of times the arguments appear in
531 the replacement text, not how many args there are. Example:
532 #define f(x) x+x+x+x+x+x+x would have replacement text "++++++" and
534 { (0, 1), (1, 1), (1, 1), ..., (1, 1), NULL }
535 where (x, y) means (nchars, argno). */
537 typedef struct definition DEFINITION;
540 int length; /* length of expansion string */
541 int predefined; /* True if the macro was builtin or */
542 /* came from the command line */
544 int line; /* Line number of definition */
545 char *file; /* File of definition */
546 size_t file_len; /* Length of file (which can contain NULs) */
547 char rest_args; /* Nonzero if last arg. absorbs the rest */
549 struct reflist *next;
551 enum sharp_token_type stringify; /* set if a # operator before arg */
552 enum sharp_token_type raw_before; /* set if a ## operator before arg */
553 enum sharp_token_type raw_after; /* set if a ## operator after arg */
555 char rest_args; /* Nonzero if this arg. absorbs the rest */
556 int nchars; /* Number of literal chars to copy before
557 this arg occurrence. */
558 int argno; /* Number of arg to substitute (origin-0) */
561 /* Names of macro args, concatenated in reverse order
562 with comma-space between them.
563 The only use of this is that we warn on redefinition
564 if this differs between the old and new definitions. */
569 /* different kinds of things that can appear in the value field
570 of a hash node. Actually, this may be useless now. */
578 * special extension string that can be added to the last macro argument to
579 * allow it to absorb the "rest" of the arguments when expanded. Ex:
580 * #define wow(a, b...) process (b, a, b)
581 * { wow (1, 2, 3); } -> { process (2, 3, 1, 2, 3); }
582 * { wow (one, two); } -> { process (two, one, two); }
583 * if this "rest_arg" is used with the concat token '##' and if it is not
584 * supplied then the token attached to with ## will not be outputted. Ex:
585 * #define wow (a, b...) process (b ## , a, ## b)
586 * { wow (1, 2); } -> { process (2, 1, 2); }
587 * { wow (one); } -> { process (one); {
589 static char rest_extension[] = "...";
590 #define REST_EXTENSION_LENGTH (sizeof (rest_extension) - 1)
592 /* This is the implicit parameter name when using variable number of
593 parameters for macros using the ISO C 9x extension. */
594 static char va_args_name[] = "__VA_ARGS__";
595 #define VA_ARGS_NAME_LENGTH (sizeof (va_args_name) - 1)
597 /* The structure of a node in the hash table. The hash table
598 has entries for all tokens defined by #define directives (type T_MACRO),
599 plus some special tokens like __LINE__ (these each have their own
600 type, and the appropriate code is run when that type of node is seen.
601 It does not contain control words like "#define", which are recognized
602 by a separate piece of code. */
604 /* different flavors of hash nodes --- also used in keyword table */
606 T_DEFINE = 1, /* the `#define' keyword */
607 T_INCLUDE, /* the `#include' keyword */
608 T_INCLUDE_NEXT, /* the `#include_next' keyword */
609 T_IMPORT, /* the `#import' keyword */
610 T_IFDEF, /* the `#ifdef' keyword */
611 T_IFNDEF, /* the `#ifndef' keyword */
612 T_IF, /* the `#if' keyword */
613 T_ELSE, /* `#else' */
614 T_PRAGMA, /* `#pragma' */
615 T_ELIF, /* `#elif' */
616 T_UNDEF, /* `#undef' */
617 T_LINE, /* `#line' */
618 T_ERROR, /* `#error' */
619 T_WARNING, /* `#warning' */
620 T_ENDIF, /* `#endif' */
621 T_SCCS, /* `#sccs', used on system V. */
622 T_IDENT, /* `#ident', used on system V. */
623 T_ASSERT, /* `#assert', taken from system V. */
624 T_UNASSERT, /* `#unassert', taken from system V. */
625 T_SPECLINE, /* special symbol `__LINE__' */
626 T_DATE, /* `__DATE__' */
627 T_FILE, /* `__FILE__' */
628 T_BASE_FILE, /* `__BASE_FILE__' */
629 T_INCLUDE_LEVEL, /* `__INCLUDE_LEVEL__' */
630 T_VERSION, /* `__VERSION__' */
631 T_SIZE_TYPE, /* `__SIZE_TYPE__' */
632 T_PTRDIFF_TYPE, /* `__PTRDIFF_TYPE__' */
633 T_WCHAR_TYPE, /* `__WCHAR_TYPE__' */
634 T_USER_LABEL_PREFIX_TYPE, /* `__USER_LABEL_PREFIX__' */
635 T_REGISTER_PREFIX_TYPE, /* `__REGISTER_PREFIX__' */
636 T_IMMEDIATE_PREFIX_TYPE, /* `__IMMEDIATE_PREFIX__' */
637 T_TIME, /* `__TIME__' */
638 T_CONST, /* Constant value, used by `__STDC__' */
639 T_MACRO, /* macro defined by `#define' */
640 T_DISABLED, /* macro temporarily turned off for rescan */
641 T_SPEC_DEFINED, /* special `defined' macro for use in #if statements */
642 T_PCSTRING, /* precompiled string (hashval is KEYDEF *) */
643 T_POISON, /* defined with `#pragma poison' */
644 T_UNUSED /* Used for something not defined. */
648 struct hashnode *next; /* double links for easy deletion */
649 struct hashnode *prev;
650 struct hashnode **bucket_hdr; /* also, a back pointer to this node's hash
651 chain is kept, in case the node is the head
652 of the chain and gets deleted. */
653 enum node_type type; /* type of special token */
654 int length; /* length of token, for quick comparison */
655 U_CHAR *name; /* the actual name */
656 union hashval value; /* pointer to expansion, or whatever */
659 typedef struct hashnode HASHNODE;
661 /* Some definitions for the hash table. The hash function MUST be
662 computed as shown in hashf () below. That is because the rescan
663 loop computes the hash value `on the fly' for most tokens,
664 in order to avoid the overhead of a lot of procedure calls to
665 the hashf () function. Hashf () only exists for the sake of
666 politeness, for use when speed isn't so important. */
668 #define HASHSIZE 1403
669 static HASHNODE *hashtab[HASHSIZE];
670 #define HASHSTEP(old, c) ((old << 2) + c)
671 #define MAKE_POS(v) (v & 0x7fffffff) /* make number positive */
674 /* We let tm.h override the types used here, to handle trivial differences
675 such as the choice of unsigned int or long unsigned int for size_t.
676 When machines start needing nontrivial differences in the size type,
677 it would be best to do something here to figure out automatically
678 from other information what type to use. */
680 /* The string value for __SIZE_TYPE__. */
683 #define SIZE_TYPE "long unsigned int"
686 /* The string value for __PTRDIFF_TYPE__. */
689 #define PTRDIFF_TYPE "long int"
692 /* The string value for __WCHAR_TYPE__. */
695 #define WCHAR_TYPE "int"
697 char * wchar_type = WCHAR_TYPE;
700 /* The string value for __USER_LABEL_PREFIX__ */
702 #ifndef USER_LABEL_PREFIX
703 #define USER_LABEL_PREFIX ""
705 char * user_label_prefix = USER_LABEL_PREFIX;
706 #undef USER_LABEL_PREFIX
708 /* The string value for __REGISTER_PREFIX__ */
710 #ifndef REGISTER_PREFIX
711 #define REGISTER_PREFIX ""
714 /* The string value for __IMMEDIATE_PREFIX__ */
716 #ifndef IMMEDIATE_PREFIX
717 #define IMMEDIATE_PREFIX ""
720 /* In the definition of a #assert name, this structure forms
721 a list of the individual values asserted.
722 Each value is itself a list of "tokens".
723 These are strings that are compared by name. */
725 struct tokenlist_list {
726 struct tokenlist_list *next;
727 struct arglist *tokens;
730 struct assertion_hashnode {
731 struct assertion_hashnode *next; /* double links for easy deletion */
732 struct assertion_hashnode *prev;
733 /* also, a back pointer to this node's hash
734 chain is kept, in case the node is the head
735 of the chain and gets deleted. */
736 struct assertion_hashnode **bucket_hdr;
737 int length; /* length of token, for quick comparison */
738 U_CHAR *name; /* the actual name */
739 /* List of token-sequences. */
740 struct tokenlist_list *value;
743 typedef struct assertion_hashnode ASSERTION_HASHNODE;
745 /* Some definitions for the hash table. The hash function MUST be
746 computed as shown in hashf below. That is because the rescan
747 loop computes the hash value `on the fly' for most tokens,
748 in order to avoid the overhead of a lot of procedure calls to
749 the hashf function. hashf only exists for the sake of
750 politeness, for use when speed isn't so important. */
752 #define ASSERTION_HASHSIZE 37
753 static ASSERTION_HASHNODE *assertion_hashtab[ASSERTION_HASHSIZE];
755 /* Nonzero means inhibit macroexpansion of what seem to be
756 assertion tests, in rescan. For #if. */
757 static int assertions_flag;
759 /* `struct directive' defines one #-directive, including how to handle it. */
761 #define DO_PROTO PROTO((U_CHAR *, U_CHAR *, FILE_BUF *, struct directive *))
764 int length; /* Length of name */
765 int (*func) DO_PROTO; /* Function to handle directive */
766 char *name; /* Name of directive */
767 enum node_type type; /* Code which describes which directive. */
770 #define IS_INCLUDE_DIRECTIVE_TYPE(t) \
771 ((int) T_INCLUDE <= (int) (t) && (int) (t) <= (int) T_IMPORT)
773 /* These functions are declared to return int instead of void since they
774 are going to be placed in the table and some old compilers have trouble with
775 pointers to functions returning void. */
777 static int do_assert DO_PROTO;
778 static int do_define DO_PROTO;
779 static int do_elif DO_PROTO;
780 static int do_else DO_PROTO;
781 static int do_endif DO_PROTO;
782 static int do_error DO_PROTO;
783 static int do_ident DO_PROTO;
784 static int do_if DO_PROTO;
785 static int do_include DO_PROTO;
786 static int do_line DO_PROTO;
787 static int do_pragma DO_PROTO;
788 #ifdef SCCS_DIRECTIVE
789 static int do_sccs DO_PROTO;
791 static int do_unassert DO_PROTO;
792 static int do_undef DO_PROTO;
793 static int do_xifdef DO_PROTO;
795 /* Here is the actual list of #-directives, most-often-used first. */
797 static struct directive directive_table[] = {
798 { 6, do_define, "define", T_DEFINE},
799 { 2, do_if, "if", T_IF},
800 { 5, do_xifdef, "ifdef", T_IFDEF},
801 { 6, do_xifdef, "ifndef", T_IFNDEF},
802 { 5, do_endif, "endif", T_ENDIF},
803 { 4, do_else, "else", T_ELSE},
804 { 4, do_elif, "elif", T_ELIF},
805 { 4, do_line, "line", T_LINE},
806 { 7, do_include, "include", T_INCLUDE},
807 { 12, do_include, "include_next", T_INCLUDE_NEXT},
808 { 6, do_include, "import", T_IMPORT},
809 { 5, do_undef, "undef", T_UNDEF},
810 { 5, do_error, "error", T_ERROR},
811 { 7, do_error, "warning", T_WARNING},
812 #ifdef SCCS_DIRECTIVE
813 { 4, do_sccs, "sccs", T_SCCS},
815 { 6, do_pragma, "pragma", T_PRAGMA},
816 { 5, do_ident, "ident", T_IDENT},
817 { 6, do_assert, "assert", T_ASSERT},
818 { 8, do_unassert, "unassert", T_UNASSERT},
819 { -1, 0, "", T_UNUSED},
822 /* When a directive handler is called,
823 this points to the # (or the : of the %:) that started the directive. */
824 U_CHAR *directive_start;
826 /* table to tell if char can be part of a C identifier. */
827 U_CHAR is_idchar[256];
828 /* table to tell if char can be first char of a c identifier. */
829 U_CHAR is_idstart[256];
830 /* table to tell if c is horizontal space. */
831 static U_CHAR is_hor_space[256];
832 /* table to tell if c is horizontal or vertical space. */
833 U_CHAR is_space[256];
835 #define SKIP_WHITE_SPACE(p) do { while (is_hor_space[*p]) p++; } while (0)
836 #define SKIP_ALL_WHITE_SPACE(p) do { while (is_space[*p]) p++; } while (0)
838 static int errors = 0; /* Error counter for exit code */
840 /* Name of output file, for error messages. */
841 static char *out_fname;
843 /* Nonzero to ignore \ in string constants. Use to treat #line 1 "A:\file.h
844 as a non-form feed. If you want it to be a form feed, you must use
846 static int ignore_escape_flag = 1;
848 /* Stack of conditionals currently in progress
849 (including both successful and failing conditionals). */
852 struct if_stack *next; /* for chaining to the next stack frame */
853 char *fname; /* copied from input when frame is made */
854 size_t fname_len; /* similarly */
855 int lineno; /* similarly */
856 int if_succeeded; /* true if a leg of this if-group
857 has been passed through rescan */
858 U_CHAR *control_macro; /* For #ifndef at start of file,
859 this is the macro name tested. */
860 enum node_type type; /* type of last directive seen in this group */
862 typedef struct if_stack IF_STACK_FRAME;
863 static IF_STACK_FRAME *if_stack = NULL;
865 /* Buffer of -M output. */
866 static char *deps_buffer;
868 /* Number of bytes allocated in above. */
869 static int deps_allocated_size;
871 /* Number of bytes used. */
872 static int deps_size;
874 /* Number of bytes since the last newline. */
875 static int deps_column;
877 /* Nonzero means -I- has been seen,
878 so don't look for #include "foo" the source-file directory. */
879 static int ignore_srcdir;
881 static int safe_read PROTO((int, char *, int));
882 static void safe_write PROTO((int, char *, int));
884 int main PROTO((int, char **));
886 static void path_include PROTO((char *));
888 static U_CHAR *index0 PROTO((U_CHAR *, int, size_t));
890 static void trigraph_pcp PROTO((FILE_BUF *));
891 static void check_white_space PROTO((FILE_BUF *));
893 static void newline_fix PROTO((U_CHAR *));
894 static void name_newline_fix PROTO((U_CHAR *));
896 static char *get_lintcmd PROTO((U_CHAR *, U_CHAR *, U_CHAR **, int *, int *));
898 static void rescan PROTO((FILE_BUF *, int));
900 static FILE_BUF expand_to_temp_buffer PROTO((U_CHAR *, U_CHAR *, int, int));
902 static int handle_directive PROTO((FILE_BUF *, FILE_BUF *));
904 static struct tm *timestamp PROTO((void));
905 static void special_symbol PROTO((HASHNODE *, FILE_BUF *));
907 static int is_system_include PROTO((char *));
908 static char *base_name PROTO((char *));
909 static int absolute_filename PROTO((char *));
910 static size_t simplify_filename PROTO((char *));
912 static char *read_filename_string PROTO((int, FILE *));
913 static struct file_name_map *read_name_map PROTO((char *));
914 static int open_include_file PROTO((char *, struct file_name_list *, U_CHAR *, struct include_file **));
915 static char *remap_include_file PROTO((char *, struct file_name_list *));
916 static int lookup_ino_include PROTO((struct include_file *));
918 static void finclude PROTO((int, struct include_file *, FILE_BUF *, int, struct file_name_list *));
919 static void record_control_macro PROTO((struct include_file *, U_CHAR *));
921 static char *check_precompiled PROTO((int, struct stat *, char *, char **));
922 static int check_preconditions PROTO((char *));
923 static void pcfinclude PROTO((U_CHAR *, U_CHAR *, FILE_BUF *));
924 static void pcstring_used PROTO((HASHNODE *));
925 static void write_output PROTO((void));
926 static void pass_thru_directive PROTO((U_CHAR *, U_CHAR *, FILE_BUF *, struct directive *));
928 static MACRODEF create_definition PROTO((U_CHAR *, U_CHAR *, FILE_BUF *));
930 static int check_macro_name PROTO((U_CHAR *, int));
931 static int compare_defs PROTO((DEFINITION *, DEFINITION *));
932 static int comp_def_part PROTO((int, U_CHAR *, int, U_CHAR *, int, int));
934 static DEFINITION *collect_expansion PROTO((U_CHAR *, U_CHAR *, int, struct arglist *));
936 int check_assertion PROTO((U_CHAR *, int, int, struct arglist *));
937 static int compare_token_lists PROTO((struct arglist *, struct arglist *));
939 static struct arglist *read_token_list PROTO((U_CHAR **, U_CHAR *, int *));
940 static void free_token_list PROTO((struct arglist *));
942 static ASSERTION_HASHNODE *assertion_install PROTO((U_CHAR *, int, int));
943 static ASSERTION_HASHNODE *assertion_lookup PROTO((U_CHAR *, int, int));
944 static void delete_assertion PROTO((ASSERTION_HASHNODE *));
946 static void do_once PROTO((void));
948 static HOST_WIDEST_INT eval_if_expression PROTO((U_CHAR *, int));
949 static void conditional_skip PROTO((FILE_BUF *, int, enum node_type, U_CHAR *, FILE_BUF *));
950 static void skip_if_group PROTO((FILE_BUF *, int, FILE_BUF *));
951 static void validate_else PROTO((U_CHAR *, U_CHAR *));
953 static U_CHAR *skip_to_end_of_comment PROTO((FILE_BUF *, int *, int));
954 static U_CHAR *skip_quoted_string PROTO((U_CHAR *, U_CHAR *, int, int *, int *, int *));
955 static char *quote_string PROTO((char *, char *, size_t));
956 static U_CHAR *skip_paren_group PROTO((FILE_BUF *));
958 /* Last arg to output_line_directive. */
959 enum file_change_code {same_file, enter_file, leave_file};
960 static void output_line_directive PROTO((FILE_BUF *, FILE_BUF *, int, enum file_change_code));
962 static void macroexpand PROTO((HASHNODE *, FILE_BUF *));
965 static int macarg PROTO((struct argdata *, int));
967 static U_CHAR *macarg1 PROTO((U_CHAR *, U_CHAR *, struct hashnode *, int *, int *, int *, int));
969 static int discard_comments PROTO((U_CHAR *, int, int));
971 static void change_newlines PROTO((struct argdata *));
973 static void notice PVPROTO((const char *, ...)) ATTRIBUTE_PRINTF_1;
974 static void vnotice PROTO((const char *, va_list));
975 void error PVPROTO((const char *, ...)) ATTRIBUTE_PRINTF_1;
976 void verror PROTO((const char *, va_list));
977 static void error_from_errno PROTO((char *));
978 void warning PVPROTO((const char *, ...)) ATTRIBUTE_PRINTF_1;
979 static void vwarning PROTO((const char *, va_list));
980 static void error_with_line PVPROTO((int, const char *, ...)) ATTRIBUTE_PRINTF_2;
981 static void verror_with_line PROTO((int, const char *, va_list));
982 static void vwarning_with_line PROTO((int, const char *, va_list));
983 static void warning_with_line PVPROTO((int, const char *, ...)) ATTRIBUTE_PRINTF_2;
984 void pedwarn PVPROTO((const char *, ...)) ATTRIBUTE_PRINTF_1;
985 void pedwarn_with_line PVPROTO((int, const char *, ...)) ATTRIBUTE_PRINTF_2;
986 static void pedwarn_with_file_and_line PVPROTO((const char *, size_t, int, const char *, ...)) ATTRIBUTE_PRINTF_4;
987 static void pedwarn_strange_white_space PROTO((int));
989 static void print_containing_files PROTO((void));
991 static int line_for_error PROTO((int));
992 static int grow_outbuf PROTO((FILE_BUF *, int));
994 static HASHNODE *install PROTO((U_CHAR *, int, enum node_type, char *, int));
995 HASHNODE *lookup PROTO((U_CHAR *, int, int));
996 static void delete_macro PROTO((HASHNODE *));
997 static int hashf PROTO((U_CHAR *, int, int));
999 static void dump_single_macro PROTO((HASHNODE *, FILE *));
1000 static void dump_all_macros PROTO((void));
1001 static void dump_defn_1 PROTO((U_CHAR *, int, int, FILE *));
1002 static void dump_arg_n PROTO((DEFINITION *, int, FILE *));
1004 static void initialize_char_syntax PROTO((void));
1005 static void initialize_builtins PROTO((FILE_BUF *, FILE_BUF *));
1007 static void make_definition PROTO((char *));
1008 static void make_undef PROTO((char *, FILE_BUF *));
1010 static void make_assertion PROTO((const char *, const char *));
1012 static struct file_name_list *new_include_prefix PROTO((struct file_name_list *, const char *, const char *, const char *));
1013 static void append_include_chain PROTO((struct file_name_list *, struct file_name_list *));
1015 static int quote_string_for_make PROTO((char *, const char *));
1016 static void deps_output PROTO((const char *, int));
1018 void fatal PVPROTO((const char *, ...)) ATTRIBUTE_PRINTF_1 ATTRIBUTE_NORETURN;
1019 void fancy_abort PROTO((void)) ATTRIBUTE_NORETURN;
1020 static void perror_with_name PROTO((char *));
1021 static void pfatal_with_name PROTO((char *)) ATTRIBUTE_NORETURN;
1022 static void pipe_closed PROTO((int)) ATTRIBUTE_NORETURN;
1024 static void memory_full PROTO((void)) ATTRIBUTE_NORETURN;
1025 static void print_help PROTO((void));
1027 /* Read LEN bytes at PTR from descriptor DESC, for file FILENAME,
1028 retrying if necessary. If MAX_READ_LEN is defined, read at most
1029 that bytes at a time. Return a negative value if an error occurs,
1030 otherwise return the actual number of bytes read,
1031 which must be LEN unless end-of-file was reached. */
1034 safe_read (desc, ptr, len)
1039 int left, rcount, nchars;
1045 if (rcount > MAX_READ_LEN)
1046 rcount = MAX_READ_LEN;
1048 nchars = read (desc, ptr, rcount);
1065 /* Write LEN bytes at PTR to descriptor DESC,
1066 retrying if necessary, and treating any real error as fatal.
1067 If MAX_WRITE_LEN is defined, write at most that many bytes at a time. */
1070 safe_write (desc, ptr, len)
1075 int wcount, written;
1079 #ifdef MAX_WRITE_LEN
1080 if (wcount > MAX_WRITE_LEN)
1081 wcount = MAX_WRITE_LEN;
1083 written = write (desc, ptr, wcount);
1090 pfatal_with_name (out_fname);
1101 printf ("Usage: %s [switches] input output\n", progname);
1102 printf ("Switches:\n");
1103 printf (" -include <file> Include the contents of <file> before other files\n");
1104 printf (" -imacros <file> Accept definition of macros in <file>\n");
1105 printf (" -iprefix <path> Specify <path> as a prefix for next two options\n");
1106 printf (" -iwithprefix <dir> Add <dir> to the end of the system include paths\n");
1107 printf (" -iwithprefixbefore <dir> Add <dir> to the end of the main include paths\n");
1108 printf (" -isystem <dir> Add <dir> to the start of the system include paths\n");
1109 printf (" -idirafter <dir> Add <dir> to the end of the system include paths\n");
1110 printf (" -I <dir> Add <dir> to the end of the main include paths\n");
1111 printf (" -nostdinc Do not search the system include directories\n");
1112 printf (" -nostdinc++ Do not search the system include directories for C++\n");
1113 printf (" -o <file> Put output into <file>\n");
1114 printf (" -pedantic Issue all warnings demanded by strict ANSI C\n");
1115 printf (" -traditional Follow K&R pre-processor behaviour\n");
1116 printf (" -trigraphs Support ANSI C trigraphs\n");
1117 printf (" -lang-c Assume that the input sources are in C\n");
1118 printf (" -lang-c89 Assume that the input is C89; depricated\n");
1119 printf (" -lang-c++ Assume that the input sources are in C++\n");
1120 printf (" -lang-objc Assume that the input sources are in ObjectiveC\n");
1121 printf (" -lang-objc++ Assume that the input sources are in ObjectiveC++\n");
1122 printf (" -lang-asm Assume that the input sources are in assembler\n");
1123 printf (" -lang-chill Assume that the input sources are in Chill\n");
1124 printf (" -std=<std name> Specify the conformance standard; one of:\n");
1125 printf (" gnu89, gnu9x, c89, c9x, iso9899:1990,\n");
1126 printf (" iso9899:199409, iso9899:199x\n");
1127 printf (" -+ Allow parsing of C++ style features\n");
1128 printf (" -w Inhibit warning messages\n");
1129 printf (" -Wtrigraphs Warn if trigraphs are encountered\n");
1130 printf (" -Wno-trigraphs Do not warn about trigraphs\n");
1131 printf (" -Wcomment{s} Warn if one comment starts inside another\n");
1132 printf (" -Wno-comment{s} Do not warn about comments\n");
1133 printf (" -Wtraditional Warn if a macro argument is/would be turned into\n");
1134 printf (" a string if -traditional is specified\n");
1135 printf (" -Wno-traditional Do not warn about stringification\n");
1136 printf (" -Wundef Warn if an undefined macro is used by #if\n");
1137 printf (" -Wno-undef Do not warn about testing undefined macros\n");
1138 printf (" -Wimport Warn about the use of the #import directive\n");
1139 printf (" -Wno-import Do not warn about the use of #import\n");
1140 printf (" -Werror Treat all warnings as errors\n");
1141 printf (" -Wno-error Do not treat warnings as errors\n");
1142 printf (" -Wall Enable all preprocessor warnings\n");
1143 printf (" -M Generate make dependencies\n");
1144 printf (" -MM As -M, but ignore system header files\n");
1145 printf (" -MD As -M, but put output in a .d file\n");
1146 printf (" -MMD As -MD, but ignore system header files\n");
1147 printf (" -MG Treat missing header file as generated files\n");
1148 printf (" -g Include #define and #undef directives in the output\n");
1149 printf (" -D<macro> Define a <macro> with string '1' as its value\n");
1150 printf (" -D<macro>=<val> Define a <macro> with <val> as its value\n");
1151 printf (" -A<question> (<answer>) Assert the <answer> to <question>\n");
1152 printf (" -U<macro> Undefine <macro> \n");
1153 printf (" -u or -undef Do not predefine any macros\n");
1154 printf (" -v Display the version number\n");
1155 printf (" -H Print the name of header files as they are used\n");
1156 printf (" -C Do not discard comments\n");
1157 printf (" -dM Display a list of macro definitions active at end\n");
1158 printf (" -dD Preserve macro definitions in output\n");
1159 printf (" -dN As -dD except that only the names are preserved\n");
1160 printf (" -dI Include #include directives in the output\n");
1161 printf (" -ifoutput Describe skipped code blocks in output \n");
1162 printf (" -P Do not generate #line directives\n");
1163 printf (" -$ Do not include '$' in identifiers\n");
1164 printf (" -remap Remap file names when including files.\n");
1165 printf (" -h or --help Display this information\n");
1182 char **pend_assertions;
1183 char **pend_includes;
1185 /* Record the option used with each element of pend_assertions.
1186 This is preparation for supporting more than one option for making
1188 char **pend_assertion_options;
1189 int no_standard_includes = 0;
1190 int no_standard_cplusplus_includes = 0;
1191 int missing_newline = 0;
1193 /* Non-0 means don't output the preprocessed program. */
1194 int inhibit_output = 0;
1195 /* Non-0 means -v, so print the full set of include dirs. */
1198 /* File name which deps are being written to.
1199 This is 0 if deps are being written to stdout. */
1200 char *deps_file = 0;
1201 /* Fopen file mode to open deps_file with. */
1202 char *deps_mode = "a";
1203 /* Stream on which to print the dependency information. */
1204 FILE *deps_stream = 0;
1205 /* Target-name to write with the dependency information. */
1206 char *deps_target = 0;
1208 #if defined (RLIMIT_STACK) && defined (HAVE_GETRLIMIT) && defined (HAVE_SETRLIMIT)
1209 /* Get rid of any avoidable limit on stack size. */
1213 /* Set the stack limit huge so that alloca (particularly stringtab
1214 in dbxread.c) does not fail. */
1215 getrlimit (RLIMIT_STACK, &rlim);
1216 rlim.rlim_cur = rlim.rlim_max;
1217 setrlimit (RLIMIT_STACK, &rlim);
1222 signal (SIGPIPE, pipe_closed);
1225 #ifdef HAVE_LC_MESSAGES
1226 setlocale (LC_MESSAGES, "");
1228 (void) bindtextdomain (PACKAGE, localedir);
1229 (void) textdomain (PACKAGE);
1231 progname = base_name (argv[0]);
1235 /* Remove extension from PROGNAME. */
1237 char *s = progname = xstrdup (progname);
1239 if ((p = rindex (s, ';')) != 0) *p = '\0'; /* strip version number */
1240 if ((p = rindex (s, '.')) != 0 /* strip type iff ".exe" */
1241 && (p[1] == 'e' || p[1] == 'E')
1242 && (p[2] == 'x' || p[2] == 'X')
1243 && (p[3] == 'e' || p[3] == 'E')
1249 /* Do not invoke xmalloc before this point, since locale and
1250 progname need to be set first, in case a diagnostic is issued. */
1252 pend_files = (char **) xmalloc (argc * sizeof (char *));
1253 pend_defs = (char **) xmalloc (argc * sizeof (char *));
1254 pend_undefs = (char **) xmalloc (argc * sizeof (char *));
1255 pend_assertions = (char **) xmalloc (argc * sizeof (char *));
1256 pend_includes = (char **) xmalloc (argc * sizeof (char *));
1257 pend_assertion_options = (char **) xmalloc (argc * sizeof (char *));
1262 /* Initialize is_idchar. */
1263 initialize_char_syntax ();
1265 no_line_directives = 0;
1267 dump_macros = dump_none;
1270 cplusplus_comments = 1;
1272 bzero ((char *) pend_files, argc * sizeof (char *));
1273 bzero ((char *) pend_defs, argc * sizeof (char *));
1274 bzero ((char *) pend_undefs, argc * sizeof (char *));
1275 bzero ((char *) pend_assertions, argc * sizeof (char *));
1276 bzero ((char *) pend_includes, argc * sizeof (char *));
1278 #ifdef MULTIBYTE_CHARS
1279 /* Change to the native locale for multibyte conversions. */
1280 setlocale (LC_CTYPE, "");
1281 literal_codeset = getenv ("LANG");
1284 /* Process switches and find input file name. */
1286 for (i = 1; i < argc; i++) {
1287 if (argv[i][0] != '-') {
1288 if (out_fname != NULL)
1291 fatal ("Too many arguments");
1293 else if (in_fname != NULL)
1294 out_fname = argv[i];
1298 switch (argv[i][1]) {
1301 if (!strcmp (argv[i], "-include")) {
1303 fatal ("Filename missing after `-include' option");
1306 simplify_filename (pend_includes[i] = argv[i]);
1309 if (!strcmp (argv[i], "-imacros")) {
1311 fatal ("Filename missing after `-imacros' option");
1314 simplify_filename (pend_files[i] = argv[i]);
1317 if (!strcmp (argv[i], "-iprefix")) {
1319 fatal ("Filename missing after `-iprefix' option");
1321 include_prefix = argv[++i];
1323 if (!strcmp (argv[i], "-ifoutput")) {
1324 output_conditionals = 1;
1326 if (!strcmp (argv[i], "-isystem")) {
1327 struct file_name_list *dirtmp;
1329 if (! (dirtmp = new_include_prefix (NULL_PTR, NULL_PTR,
1332 dirtmp->c_system_include_path = 1;
1334 if (before_system == 0)
1335 before_system = dirtmp;
1337 last_before_system->next = dirtmp;
1338 last_before_system = dirtmp; /* Tail follows the last one */
1340 /* Add directory to end of path for includes,
1341 with the default prefix at the front of its name. */
1342 if (!strcmp (argv[i], "-iwithprefix")) {
1343 struct file_name_list *dirtmp;
1346 if (include_prefix != 0)
1347 prefix = include_prefix;
1349 prefix = xstrdup (GCC_INCLUDE_DIR);
1350 /* Remove the `include' from /usr/local/lib/gcc.../include. */
1351 if (!strcmp (prefix + strlen (prefix) - 8, "/include"))
1352 prefix[strlen (prefix) - 7] = 0;
1355 if (! (dirtmp = new_include_prefix (NULL_PTR, NULL_PTR,
1356 prefix, argv[++i])))
1359 if (after_include == 0)
1360 after_include = dirtmp;
1362 last_after_include->next = dirtmp;
1363 last_after_include = dirtmp; /* Tail follows the last one */
1365 /* Add directory to main path for includes,
1366 with the default prefix at the front of its name. */
1367 if (!strcmp (argv[i], "-iwithprefixbefore")) {
1368 struct file_name_list *dirtmp;
1371 if (include_prefix != 0)
1372 prefix = include_prefix;
1374 prefix = xstrdup (GCC_INCLUDE_DIR);
1375 /* Remove the `include' from /usr/local/lib/gcc.../include. */
1376 if (!strcmp (prefix + strlen (prefix) - 8, "/include"))
1377 prefix[strlen (prefix) - 7] = 0;
1380 dirtmp = new_include_prefix (NULL_PTR, NULL_PTR, prefix, argv[++i]);
1381 append_include_chain (dirtmp, dirtmp);
1383 /* Add directory to end of path for includes. */
1384 if (!strcmp (argv[i], "-idirafter")) {
1385 struct file_name_list *dirtmp;
1387 if (! (dirtmp = new_include_prefix (NULL_PTR, NULL_PTR,
1391 if (after_include == 0)
1392 after_include = dirtmp;
1394 last_after_include->next = dirtmp;
1395 last_after_include = dirtmp; /* Tail follows the last one */
1400 if (out_fname != NULL)
1401 fatal ("Output filename specified twice");
1403 fatal ("Filename missing after -o option");
1404 out_fname = argv[++i];
1405 if (!strcmp (out_fname, "-"))
1410 if (!strcmp (argv[i], "-pedantic"))
1412 else if (!strcmp (argv[i], "-pedantic-errors")) {
1414 pedantic_errors = 1;
1415 } else if (!strcmp (argv[i], "-pcp")) {
1418 fatal ("Filename missing after -pcp option");
1419 pcp_fname = argv[++i];
1421 = ((pcp_fname[0] != '-' || pcp_fname[1] != '\0')
1422 ? fopen (pcp_fname, "w")
1424 if (pcp_outfile == 0)
1425 pfatal_with_name (pcp_fname);
1431 if (!strcmp (argv[i], "-traditional")) {
1433 cplusplus_comments = 0;
1434 } else if (!strcmp (argv[i], "-trigraphs")) {
1440 if (! strcmp (argv[i], "-lang-c"))
1441 cplusplus = 0, cplusplus_comments = 1, c89 = 0, c9x = 1, objc = 0;
1442 else if (! strcmp (argv[i], "-lang-c89"))
1443 cplusplus = 0, cplusplus_comments = 0, c89 = 1, c9x = 0, objc = 0;
1444 else if (! strcmp (argv[i], "-lang-c++"))
1445 cplusplus = 1, cplusplus_comments = 1, c89 = 0, c9x = 0, objc = 0;
1446 else if (! strcmp (argv[i], "-lang-objc"))
1447 cplusplus = 0, cplusplus_comments = 1, c89 = 0, c9x = 0, objc = 1;
1448 else if (! strcmp (argv[i], "-lang-objc++"))
1449 cplusplus = 1, cplusplus_comments = 1, c89 = 0, c9x = 0, objc = 1;
1450 else if (! strcmp (argv[i], "-lang-asm"))
1452 else if (! strcmp (argv[i], "-lint"))
1457 cplusplus = 1, cplusplus_comments = 1;
1461 if (!strcmp (argv[i], "-std=iso9899:1990")
1462 || !strcmp (argv[i], "-std=iso9899:199409")
1463 || !strcmp (argv[i], "-std=c89")
1464 || !strcmp (argv[i], "-std=gnu89"))
1465 cplusplus = 0, cplusplus_comments = 0, c89 = 1, c9x = 0, objc = 0;
1466 else if (!strcmp (argv[i], "-std=iso9899:199x")
1467 || !strcmp (argv[i], "-std=c9x")
1468 || !strcmp (argv[i], "-std=gnu9x"))
1469 cplusplus = 0, cplusplus_comments = 1, c89 = 0, c9x = 1, objc = 0;
1473 inhibit_warnings = 1;
1477 if (!strcmp (argv[i], "-Wtrigraphs"))
1479 else if (!strcmp (argv[i], "-Wno-trigraphs"))
1481 else if (!strcmp (argv[i], "-Wcomment"))
1483 else if (!strcmp (argv[i], "-Wno-comment"))
1485 else if (!strcmp (argv[i], "-Wcomments"))
1487 else if (!strcmp (argv[i], "-Wno-comments"))
1489 else if (!strcmp (argv[i], "-Wtraditional"))
1491 else if (!strcmp (argv[i], "-Wno-traditional"))
1493 else if (!strcmp (argv[i], "-Wwhite-space"))
1494 warn_white_space = 1;
1495 else if (!strcmp (argv[i], "-Wno-white-space"))
1496 warn_white_space = 0;
1497 else if (!strcmp (argv[i], "-Wundef"))
1499 else if (!strcmp (argv[i], "-Wno-undef"))
1501 else if (!strcmp (argv[i], "-Wimport"))
1503 else if (!strcmp (argv[i], "-Wno-import"))
1505 else if (!strcmp (argv[i], "-Werror"))
1506 warnings_are_errors = 1;
1507 else if (!strcmp (argv[i], "-Wno-error"))
1508 warnings_are_errors = 0;
1509 else if (!strcmp (argv[i], "-Wall"))
1513 warn_white_space = 1;
1518 if (!strcmp (argv[i], "-fleading-underscore"))
1519 user_label_prefix = "_";
1520 else if (!strcmp (argv[i], "-fno-leading-underscore"))
1521 user_label_prefix = "";
1525 /* The style of the choices here is a bit mixed.
1526 The chosen scheme is a hybrid of keeping all options in one string
1527 and specifying each option in a separate argument:
1528 -M|-MM|-MD file|-MMD file [-MG]. An alternative is:
1529 -M|-MM|-MD file|-MMD file|-MG|-MMG; or more concisely:
1530 -M[M][G][D file]. This is awkward to handle in specs, and is not
1532 /* ??? -MG must be specified in addition to one of -M or -MM.
1533 This can be relaxed in the future without breaking anything.
1534 The converse isn't true. */
1536 /* -MG isn't valid with -MD or -MMD. This is checked for later. */
1537 if (!strcmp (argv[i], "-MG"))
1539 print_deps_missing_files = 1;
1542 if (!strcmp (argv[i], "-M"))
1544 else if (!strcmp (argv[i], "-MM"))
1546 else if (!strcmp (argv[i], "-MD"))
1548 else if (!strcmp (argv[i], "-MMD"))
1550 /* For -MD and -MMD options, write deps on file named by next arg. */
1551 if (!strcmp (argv[i], "-MD")
1552 || !strcmp (argv[i], "-MMD")) {
1554 fatal ("Filename missing after %s option", argv[i]);
1556 deps_file = argv[i];
1559 /* For -M and -MM, write deps on standard output
1560 and suppress the usual output. */
1561 deps_stream = stdout;
1568 char *p = argv[i] + 2;
1570 while ((c = *p++)) {
1571 /* Arg to -d specifies what parts of macros to dump */
1574 dump_macros = dump_only;
1578 dump_macros = dump_names;
1581 dump_macros = dump_definitions;
1592 if (argv[i][2] == '3')
1597 if (strcmp (argv[i], "--help") != 0)
1604 notice ("GNU CPP version %s", version_string);
1605 #ifdef TARGET_VERSION
1608 fprintf (stderr, "\n");
1613 print_include_names = 1;
1617 if (argv[i][2] != 0)
1618 pend_defs[i] = argv[i] + 2;
1619 else if (i + 1 == argc)
1620 fatal ("Macro name missing after -D option");
1622 i++, pend_defs[i] = argv[i];
1629 if (argv[i][2] != 0)
1631 else if (i + 1 == argc)
1632 fatal ("Assertion missing after -A option");
1636 if (!strcmp (p, "-")) {
1637 /* -A- eliminates all predefined macros and assertions.
1638 Let's include also any that were specified earlier
1639 on the command line. That way we can get rid of any
1640 that were passed automatically in from GCC. */
1642 for (j = 0; j < i; j++)
1643 pend_defs[j] = pend_assertions[j] = 0;
1645 pend_assertions[i] = p;
1646 pend_assertion_options[i] = "-A";
1651 case 'U': /* JF #undef something */
1652 if (argv[i][2] != 0)
1653 pend_undefs[i] = argv[i] + 2;
1654 else if (i + 1 == argc)
1655 fatal ("Macro name missing after -U option");
1657 pend_undefs[i] = argv[i+1], i++;
1661 put_out_comments = 1;
1664 case 'E': /* -E comes from cc -E; ignore it. */
1668 no_line_directives = 1;
1671 case '$': /* Don't include $ in identifiers. */
1672 is_idchar['$'] = is_idstart['$'] = 0;
1675 case 'I': /* Add directory to path for includes. */
1677 struct file_name_list *dirtmp;
1678 char *dir = argv[i][2] ? argv[i] + 2 : argv[++i];
1680 if (! ignore_srcdir && !strcmp (dir, "-")) {
1682 /* Don't use any preceding -I directories for #include <...>. */
1683 first_bracket_include = 0;
1686 dirtmp = new_include_prefix (last_include, NULL_PTR, "", dir);
1687 append_include_chain (dirtmp, dirtmp);
1693 if (!strcmp (argv[i], "-nostdinc"))
1694 /* -nostdinc causes no default include directories.
1695 You must specify all include-file directories with -I. */
1696 no_standard_includes = 1;
1697 else if (!strcmp (argv[i], "-nostdinc++"))
1698 /* -nostdinc++ causes no default C++-specific include directories. */
1699 no_standard_cplusplus_includes = 1;
1700 else if (!strcmp (argv[i], "-noprecomp"))
1705 if (!strcmp (argv[i], "-remap"))
1709 case '\0': /* JF handle '-' as file name meaning stdin or stdout */
1710 if (in_fname == NULL) {
1713 } else if (out_fname == NULL) {
1716 } /* else fall through into error */
1719 fatal ("Invalid option `%s'", argv[i]);
1724 /* Add dirs from CPATH after dirs from -I. */
1725 /* There seems to be confusion about what CPATH should do,
1726 so for the moment it is not documented. */
1727 /* Some people say that CPATH should replace the standard include dirs,
1728 but that seems pointless: it comes before them, so it overrides them
1730 GET_ENV_PATH_LIST (cp, "CPATH");
1731 if (cp && ! no_standard_includes)
1734 /* Initialize output buffer */
1736 outbuf.buf = (U_CHAR *) xmalloc (OUTBUF_SIZE);
1737 outbuf.bufp = outbuf.buf;
1738 outbuf.length = OUTBUF_SIZE;
1740 /* Do partial setup of input buffer for the sake of generating
1741 early #line directives (when -g is in effect). */
1743 fp = &instack[++indepth];
1744 if (in_fname == NULL)
1746 fp->nominal_fname = fp->fname = in_fname;
1747 fp->nominal_fname_len = strlen (in_fname);
1750 /* In C++, wchar_t is a distinct basic type, and we can expect
1751 __wchar_t to be defined by cc1plus. */
1753 wchar_type = "__wchar_t";
1755 /* Install __LINE__, etc. Must follow initialize_char_syntax
1756 and option processing. */
1757 initialize_builtins (fp, &outbuf);
1759 /* Now handle the command line options. */
1761 /* Do -U's, -D's and -A's in the order they were seen. */
1762 for (i = 1; i < argc; i++) {
1763 if (pend_undefs[i]) {
1765 output_line_directive (fp, &outbuf, 0, same_file);
1766 make_undef (pend_undefs[i], &outbuf);
1770 output_line_directive (fp, &outbuf, 0, same_file);
1771 make_definition (pend_defs[i]);
1773 if (pend_assertions[i])
1774 make_assertion (pend_assertion_options[i], pend_assertions[i]);
1777 done_initializing = 1;
1779 { /* Read the appropriate environment variable and if it exists
1780 replace include_defaults with the listed path. */
1782 switch ((objc << 1) + cplusplus)
1785 GET_ENV_PATH_LIST (epath, "C_INCLUDE_PATH");
1788 GET_ENV_PATH_LIST (epath, "CPLUS_INCLUDE_PATH");
1791 GET_ENV_PATH_LIST (epath, "OBJC_INCLUDE_PATH");
1794 GET_ENV_PATH_LIST (epath, "OBJCPLUS_INCLUDE_PATH");
1797 /* If the environment var for this language is set,
1798 add to the default list of include directories. */
1801 char *startp, *endp;
1803 for (num_dirs = 1, startp = epath; *startp; startp++)
1804 if (*startp == PATH_SEPARATOR)
1807 = (struct default_include *) xmalloc ((num_dirs
1808 * sizeof (struct default_include))
1809 + sizeof (include_defaults_array));
1810 startp = endp = epath;
1814 if (c == PATH_SEPARATOR || !c) {
1816 include_defaults[num_dirs].fname
1817 = startp == endp ? "." : xstrdup (startp);
1819 include_defaults[num_dirs].component = 0;
1820 include_defaults[num_dirs].cplusplus = cplusplus;
1821 include_defaults[num_dirs].cxx_aware = 1;
1828 /* Put the usual defaults back in at the end. */
1829 bcopy ((char *) include_defaults_array,
1830 (char *) &include_defaults[num_dirs],
1831 sizeof (include_defaults_array));
1835 append_include_chain (before_system, last_before_system);
1836 first_system_include = before_system;
1838 /* Unless -fnostdinc,
1839 tack on the standard include file dirs to the specified list */
1840 if (!no_standard_includes) {
1841 struct default_include *p = include_defaults;
1842 char *specd_prefix = include_prefix;
1843 char *default_prefix = xstrdup (GCC_INCLUDE_DIR);
1844 int default_len = 0;
1845 /* Remove the `include' from /usr/local/lib/gcc.../include. */
1846 if (!strcmp (default_prefix + strlen (default_prefix) - 8, "/include")) {
1847 default_len = strlen (default_prefix) - 7;
1848 default_prefix[default_len] = 0;
1850 /* Search "translated" versions of GNU directories.
1851 These have /usr/local/lib/gcc... replaced by specd_prefix. */
1852 if (specd_prefix != 0 && default_len != 0)
1853 for (p = include_defaults; p->fname; p++) {
1854 /* Some standard dirs are only for C++. */
1855 if (!p->cplusplus || (cplusplus && !no_standard_cplusplus_includes)) {
1856 /* Does this dir start with the prefix? */
1857 if (!strncmp (p->fname, default_prefix, default_len)) {
1858 /* Yes; change prefix and add to search list. */
1859 struct file_name_list *new
1860 = new_include_prefix (NULL_PTR, NULL_PTR, specd_prefix,
1861 p->fname + default_len);
1863 new->c_system_include_path = !p->cxx_aware;
1864 append_include_chain (new, new);
1865 if (first_system_include == 0)
1866 first_system_include = new;
1872 /* Search ordinary names for GNU include directories. */
1873 for (p = include_defaults; p->fname; p++) {
1874 /* Some standard dirs are only for C++. */
1875 if (!p->cplusplus || (cplusplus && !no_standard_cplusplus_includes)) {
1876 struct file_name_list *new
1877 = new_include_prefix (NULL_PTR, p->component, "", p->fname);
1879 new->c_system_include_path = !p->cxx_aware;
1880 append_include_chain (new, new);
1881 if (first_system_include == 0)
1882 first_system_include = new;
1889 /* Tack the after_include chain at the end of the include chain. */
1890 append_include_chain (after_include, last_after_include);
1891 if (first_system_include == 0)
1892 first_system_include = after_include;
1894 /* With -v, print the list of dirs to search. */
1896 struct file_name_list *p;
1897 notice ("#include \"...\" search starts here:\n");
1898 for (p = include; p; p = p->next) {
1899 if (p == first_bracket_include)
1900 notice ("#include <...> search starts here:\n");
1902 fprintf (stderr, " .\n");
1903 else if (!strcmp (p->fname, "/") || !strcmp (p->fname, "//"))
1904 fprintf (stderr, " %s\n", p->fname);
1906 /* Omit trailing '/'. */
1907 fprintf (stderr, " %.*s\n", (int) strlen (p->fname) - 1, p->fname);
1909 notice ("End of search list.\n");
1911 struct default_include * d;
1912 notice ("The following default directories have been omitted from the search path:\n");
1913 for (d = include_defaults; d->fname; d++)
1915 fprintf (stderr, " %s\n", d->fname);
1916 notice ("End of omitted list.\n");
1920 /* -MG doesn't select the form of output and must be specified with one of
1921 -M or -MM. -MG doesn't make sense with -MD or -MMD since they don't
1922 inhibit compilation. */
1923 if (print_deps_missing_files && (print_deps == 0 || !inhibit_output))
1924 fatal ("-MG must be specified with one of -M or -MM");
1926 /* Either of two environment variables can specify output of deps.
1927 Its value is either "OUTPUT_FILE" or "OUTPUT_FILE DEPS_TARGET",
1928 where OUTPUT_FILE is the file to write deps info to
1929 and DEPS_TARGET is the target to mention in the deps. */
1932 && (getenv ("SUNPRO_DEPENDENCIES") != 0
1933 || getenv ("DEPENDENCIES_OUTPUT") != 0)) {
1934 char *spec = getenv ("DEPENDENCIES_OUTPUT");
1939 spec = getenv ("SUNPRO_DEPENDENCIES");
1945 /* Find the space before the DEPS_TARGET, if there is one. */
1946 s = index (spec, ' ');
1948 deps_target = s + 1;
1949 output_file = xmalloc (s - spec + 1);
1950 bcopy (spec, output_file, s - spec);
1951 output_file[s - spec] = 0;
1957 deps_file = output_file;
1961 /* For -M, print the expected object file name
1962 as the target of this Make-rule. */
1964 deps_allocated_size = 200;
1965 deps_buffer = xmalloc (deps_allocated_size);
1971 deps_output (deps_target, ':');
1972 } else if (*in_fname == 0) {
1973 deps_output ("-", ':');
1978 q = base_name (in_fname);
1980 /* Copy remainder to mungable area. */
1981 p = (char *) alloca (strlen(q) + 8);
1984 /* Output P, but remove known suffixes. */
1988 && p[len - 2] == '.'
1989 && index("cCsSm", p[len - 1]))
1992 && p[len - 3] == '.'
1993 && p[len - 2] == 'c'
1994 && p[len - 1] == 'c')
1997 && p[len - 4] == '.'
1998 && p[len - 3] == 'c'
1999 && p[len - 2] == 'x'
2000 && p[len - 1] == 'x')
2003 && p[len - 4] == '.'
2004 && p[len - 3] == 'c'
2005 && p[len - 2] == 'p'
2006 && p[len - 1] == 'p')
2009 /* Supply our own suffix. */
2010 strcpy (q, OBJECT_SUFFIX);
2012 deps_output (p, ':');
2015 deps_output (in_fname, ' ');
2018 /* Scan the -imacros files before the main input.
2019 Much like #including them, but with no_output set
2020 so that only their macro definitions matter. */
2022 no_output++; no_record_file++;
2023 for (i = 1; i < argc; i++)
2024 if (pend_files[i]) {
2025 struct include_file *inc;
2026 int fd = open_include_file (pend_files[i], NULL_PTR, NULL_PTR, &inc);
2028 perror_with_name (pend_files[i]);
2029 return FATAL_EXIT_CODE;
2031 finclude (fd, inc, &outbuf, 0, NULL_PTR);
2033 no_output--; no_record_file--;
2035 /* Copy the entire contents of the main input file into
2036 the stacked input buffer previously allocated for it. */
2038 /* JF check for stdin */
2039 if (in_fname == NULL || *in_fname == 0) {
2042 } else if ((f = open (in_fname, O_RDONLY, 0666)) < 0)
2045 if (fstat (f, &st) != 0)
2046 pfatal_with_name (in_fname);
2047 fp->nominal_fname = fp->fname = in_fname;
2048 fp->nominal_fname_len = strlen (in_fname);
2050 fp->system_header_p = 0;
2051 /* JF all this is mine about reading pipes and ttys */
2052 if (! S_ISREG (st.st_mode)) {
2053 /* Read input from a file that is not a normal disk file.
2054 We cannot preallocate a buffer with the correct size,
2055 so we must read in the file a piece at the time and make it bigger. */
2060 if (S_ISDIR (st.st_mode))
2061 fatal ("Input file `%s' is a directory", in_fname);
2065 fp->buf = (U_CHAR *) xmalloc (bsize + 2);
2067 cnt = safe_read (f, (char *) fp->buf + size, bsize - size);
2068 if (cnt < 0) goto perror; /* error! */
2070 if (size != bsize) break; /* End of file */
2072 fp->buf = (U_CHAR *) xrealloc (fp->buf, bsize + 2);
2076 /* Read a file whose size we can determine in advance.
2077 For the sake of VMS, st.st_size is just an upper bound. */
2078 size_t s = (size_t) st.st_size;
2079 if (s != st.st_size || s + 2 < s)
2081 fp->buf = (U_CHAR *) xmalloc (s + 2);
2082 fp->length = safe_read (f, (char *) fp->buf, s);
2083 if (fp->length < 0) goto perror;
2086 fp->if_stack = if_stack;
2088 /* Make sure data ends with a newline. And put a null after it. */
2090 if ((fp->length > 0 && fp->buf[fp->length - 1] != '\n')
2091 /* Backslash-newline at end is not good enough. */
2092 || (fp->length > 1 && fp->buf[fp->length - 2] == '\\')) {
2093 fp->buf[fp->length++] = '\n';
2094 missing_newline = 1;
2096 fp->buf[fp->length] = '\0';
2098 /* Unless inhibited, convert trigraphs in the input. */
2103 if (warn_white_space)
2104 check_white_space (fp);
2106 /* Now that we know the input file is valid, open the output. */
2108 if (!out_fname || !strcmp (out_fname, ""))
2109 out_fname = "stdout";
2110 else if (! freopen (out_fname, "w", stdout))
2111 pfatal_with_name (out_fname);
2113 output_line_directive (fp, &outbuf, 0, same_file);
2115 /* Scan the -include files before the main input. */
2118 for (i = 1; i < argc; i++)
2119 if (pend_includes[i]) {
2120 struct include_file *inc;
2121 int fd = open_include_file (pend_includes[i], NULL_PTR, NULL_PTR, &inc);
2123 perror_with_name (pend_includes[i]);
2124 return FATAL_EXIT_CODE;
2126 finclude (fd, inc, &outbuf, 0, NULL_PTR);
2130 /* Scan the input, processing macros and directives. */
2132 rescan (&outbuf, 0);
2134 if (missing_newline)
2137 if (pedantic && missing_newline)
2138 pedwarn ("file does not end in newline");
2140 /* Now we have processed the entire input
2141 Write whichever kind of output has been requested. */
2143 if (dump_macros == dump_only)
2145 else if (! inhibit_output) {
2150 /* Don't actually write the deps file if compilation has failed. */
2152 if (deps_file && ! (deps_stream = fopen (deps_file, deps_mode)))
2153 pfatal_with_name (deps_file);
2154 fputs (deps_buffer, deps_stream);
2155 putc ('\n', deps_stream);
2157 if (ferror (deps_stream) || fclose (deps_stream) != 0)
2158 fatal ("I/O error on output");
2163 if (pcp_outfile && pcp_outfile != stdout
2164 && (ferror (pcp_outfile) || fclose (pcp_outfile) != 0))
2165 fatal ("I/O error on `-pcp' output");
2167 if (ferror (stdout) || fclose (stdout) != 0)
2168 fatal ("I/O error on output");
2171 exit (FATAL_EXIT_CODE);
2172 exit (SUCCESS_EXIT_CODE);
2175 pfatal_with_name (in_fname);
2179 /* Given a colon-separated list of file names PATH,
2180 add all the names to the search path for include files. */
2194 struct file_name_list *dirtmp;
2196 /* Find the end of this name. */
2197 while ((c = *q++) != PATH_SEPARATOR && c)
2201 dirtmp = new_include_prefix (last_include, NULL_PTR,
2202 "", p == q ? "." : p);
2204 append_include_chain (dirtmp, dirtmp);
2206 /* Advance past this name. */
2213 /* Return the address of the first character in S that equals C.
2214 S is an array of length N, possibly containing '\0's, and followed by '\0'.
2215 Return 0 if there is no such character. Assume that C itself is not '\0'.
2216 If we knew we could use memchr, we could just invoke memchr (S, C, N),
2217 but unfortunately memchr isn't autoconfigured yet. */
2225 char *p = (char *) s;
2227 char *q = index (p, c);
2229 return (U_CHAR *) q;
2231 size_t l = strlen (p);
2241 /* Pre-C-Preprocessor to translate ANSI trigraph idiocy in BUF
2242 before main CCCP processing. Name `pcp' is also in honor of the
2243 drugs the trigraph designers must have been on.
2245 Using an extra pass through the buffer takes a little extra time,
2246 but is infinitely less hairy than trying to handle trigraphs inside
2247 strings, etc. everywhere, and also makes sure that trigraphs are
2248 only translated in the top level of processing. */
2254 register U_CHAR c, *fptr, *bptr, *sptr, *lptr;
2257 fptr = bptr = sptr = buf->buf;
2258 lptr = fptr + buf->length;
2259 while ((sptr = index0 (sptr, '?', (size_t) (lptr - sptr))) != NULL) {
2296 len = sptr - fptr - 2;
2298 /* BSD doc says bcopy () works right for overlapping strings. In ANSI
2299 C, this will be memmove (). */
2300 if (bptr != fptr && len > 0)
2301 bcopy ((char *) fptr, (char *) bptr, len);
2307 len = buf->length - (fptr - buf->buf);
2308 if (bptr != fptr && len > 0)
2309 bcopy ((char *) fptr, (char *) bptr, len);
2310 buf->length -= fptr - bptr;
2311 buf->buf[buf->length] = '\0';
2312 if (warn_trigraphs && fptr != bptr)
2313 warning_with_line (0, "%lu trigraph(s) encountered",
2314 (unsigned long) (fptr - bptr) / 2);
2317 /* Warn about white space between backslash and end of line. */
2320 check_white_space (buf)
2323 register U_CHAR *sptr = buf->buf;
2324 register U_CHAR *lptr = sptr + buf->length;
2325 register U_CHAR *nptr;
2328 nptr = sptr = buf->buf;
2329 lptr = sptr + buf->length;
2331 (nptr = index0 (nptr, '\n', (size_t) (lptr - nptr))) != NULL;
2333 register U_CHAR *p = nptr;
2335 for (p = nptr; sptr < p; p--) {
2336 if (! is_hor_space[p[-1]]) {
2337 if (p[-1] == '\\' && p != nptr)
2338 warning_with_line (line,
2339 "`\\' followed by white space at end of line");
2346 /* Move all backslash-newline pairs out of embarrassing places.
2347 Exchange all such pairs following BP
2348 with any potentially-embarrassing characters that follow them.
2349 Potentially-embarrassing characters are / and *
2350 (because a backslash-newline inside a comment delimiter
2351 would cause it not to be recognized).
2352 We assume that *BP == '\\'. */
2358 register U_CHAR *p = bp;
2360 /* First count the backslash-newline pairs here. */
2365 } while (*p == '\\');
2367 /* What follows the backslash-newlines is not embarrassing. */
2369 if (*p != '/' && *p != '*')
2370 /* What follows the backslash-newlines is not embarrassing. */
2373 /* Copy all potentially embarrassing characters
2374 that follow the backslash-newline pairs
2375 down to where the pairs originally started. */
2378 while (*p == '*' || *p == '/');
2380 /* Now write the same number of pairs after the embarrassing chars. */
2387 /* Like newline_fix but for use within a directive-name.
2388 Move any backslash-newlines up past any following symbol constituents. */
2391 name_newline_fix (bp)
2394 register U_CHAR *p = bp;
2396 /* First count the backslash-newline pairs here. */
2401 } while (*p == '\\');
2403 /* What follows the backslash-newlines is not embarrassing. */
2406 /* What follows the backslash-newlines is not embarrassing. */
2409 /* Copy all potentially embarrassing characters
2410 that follow the backslash-newline pairs
2411 down to where the pairs originally started. */
2414 while (is_idchar[*p]);
2416 /* Now write the same number of pairs after the embarrassing chars. */
2423 /* Look for lint commands in comments.
2425 When we come in here, ibp points into a comment. Limit is as one expects.
2426 scan within the comment -- it should start, after lwsp, with a lint command.
2427 If so that command is returned as a (constant) string.
2429 Upon return, any arg will be pointed to with argstart and will be
2430 arglen long. Note that we don't parse that arg since it will just
2431 be printed out again. */
2434 get_lintcmd (ibp, limit, argstart, arglen, cmdlen)
2435 register U_CHAR *ibp;
2436 register U_CHAR *limit;
2437 U_CHAR **argstart; /* point to command arg */
2438 int *arglen, *cmdlen; /* how long they are */
2440 HOST_WIDEST_INT linsize;
2441 register U_CHAR *numptr; /* temp for arg parsing */
2445 SKIP_WHITE_SPACE (ibp);
2447 if (ibp >= limit) return NULL;
2449 linsize = limit - ibp;
2451 /* Oh, I wish C had lexical functions... hell, I'll just open-code the set */
2452 if ((linsize >= 10) && !bcmp (ibp, "NOTREACHED", 10)) {
2454 return "NOTREACHED";
2456 if ((linsize >= 8) && !bcmp (ibp, "ARGSUSED", 8)) {
2460 if ((linsize >= 11) && !bcmp (ibp, "LINTLIBRARY", 11)) {
2462 return "LINTLIBRARY";
2464 if ((linsize >= 7) && !bcmp (ibp, "VARARGS", 7)) {
2466 ibp += 7; linsize -= 7;
2467 if ((linsize == 0) || ! ISDIGIT (*ibp)) return "VARARGS";
2469 /* OK, read a number */
2470 for (numptr = *argstart = ibp; (numptr < limit) && ISDIGIT (*numptr);
2472 *arglen = numptr - *argstart;
2479 * The main loop of the program.
2481 * Read characters from the input stack, transferring them to the
2484 * Macros are expanded and push levels on the input stack.
2485 * At the end of such a level it is popped off and we keep reading.
2486 * At the end of any other kind of level, we return.
2487 * #-directives are handled, except within macros.
2489 * If OUTPUT_MARKS is nonzero, keep Newline markers found in the input
2490 * and insert them when appropriate. This is set while scanning macro
2491 * arguments before substitution. It is zero when scanning for final output.
2492 * There are two types of Newline markers:
2493 * * Newline - follows a macro name that was not expanded
2494 * because it appeared inside an expansion of the same macro.
2495 * This marker prevents future expansion of that identifier.
2496 * When the input is rescanned into the final output, these are deleted.
2497 * These are also deleted by ## concatenation.
2498 * * Newline Space (or Newline and any other whitespace character)
2499 * stands for a place that tokens must be separated or whitespace
2500 * is otherwise desirable, but where the ANSI standard specifies there
2501 * is no whitespace. This marker turns into a Space (or whichever other
2502 * whitespace char appears in the marker) in the final output,
2503 * but it turns into nothing in an argument that is stringified with #.
2504 * Such stringified arguments are the only place where the ANSI standard
2505 * specifies with precision that whitespace may not appear.
2507 * During this function, IP->bufp is kept cached in IBP for speed of access.
2508 * Likewise, OP->bufp is kept in OBP. Before calling a subroutine
2509 * IBP, IP and OBP must be copied back to memory. IP and IBP are
2510 * copied back with the RECACHE macro. OBP must be copied back from OP->bufp
2511 * explicitly, and before RECACHE, since RECACHE uses OBP.
2515 rescan (op, output_marks)
2519 /* Character being scanned in main loop. */
2522 /* Length of pending accumulated identifier. */
2523 register int ident_length = 0;
2525 /* Hash code of pending accumulated identifier. */
2526 register int hash = 0;
2528 /* Current input level (&instack[indepth]). */
2531 /* Pointer for scanning input. */
2532 register U_CHAR *ibp;
2534 /* Pointer to end of input. End of scan is controlled by LIMIT. */
2535 register U_CHAR *limit;
2537 /* Pointer for storing output. */
2538 register U_CHAR *obp;
2540 /* REDO_CHAR is nonzero if we are processing an identifier
2541 after backing up over the terminating character.
2542 Sometimes we process an identifier without backing up over
2543 the terminating character, if the terminating character
2544 is not special. Backing up is done so that the terminating character
2545 will be dispatched on again once the identifier is dealt with. */
2548 /* 1 if within an identifier inside of which a concatenation
2549 marker (Newline -) has been seen. */
2550 int concatenated = 0;
2552 /* While scanning a comment or a string constant,
2553 this records the line it started on, for error messages. */
2556 /* Record position of last `real' newline. */
2557 U_CHAR *beg_of_line;
2559 /* Pop the innermost input stack level, assuming it is a macro expansion. */
2562 do { ip->macro->type = T_MACRO; \
2563 if (ip->free_ptr) free (ip->free_ptr); \
2564 --indepth; } while (0)
2566 /* Reload `rescan's local variables that describe the current
2567 level of the input stack. */
2570 do { ip = &instack[indepth]; \
2572 limit = ip->buf + ip->length; \
2574 check_expand (op, limit - ibp); \
2576 obp = op->bufp; } while (0)
2578 if (no_output && instack[indepth].fname != 0)
2579 skip_if_group (&instack[indepth], 1, NULL);
2586 /* Our caller must always put a null after the end of
2587 the input at each input stack level. */
2597 if (*ibp == '\n' && !ip->macro) {
2598 /* At the top level, always merge lines ending with backslash-newline,
2599 even in middle of identifier. But do not merge lines in a macro,
2600 since backslash might be followed by a newline-space marker. */
2603 --obp; /* remove backslash from obuf */
2606 /* If ANSI, backslash is just another character outside a string. */
2609 /* Otherwise, backslash suppresses specialness of following char,
2610 so copy it here to prevent the switch from seeing it.
2611 But first get any pending identifier processed. */
2612 if (ident_length > 0)
2619 if (ident_length || ip->macro || traditional)
2621 while (*ibp == '\\' && ibp[1] == '\n') {
2627 /* Treat this %: digraph as if it were #. */
2631 if (assertions_flag) {
2634 /* Copy #foo (bar lose) without macro expansion. */
2635 obp[-1] = '#'; /* In case it was '%'. */
2636 SKIP_WHITE_SPACE (ibp);
2637 while (is_idchar[*ibp])
2639 SKIP_WHITE_SPACE (ibp);
2642 skip_paren_group (ip);
2643 bcopy ((char *) ibp, (char *) obp, ip->bufp - ibp);
2644 obp += ip->bufp - ibp;
2650 /* If this is expanding a macro definition, don't recognize
2651 preprocessing directives. */
2654 /* If this is expand_into_temp_buffer,
2655 don't recognize them either. Warn about them
2656 only after an actual newline at this level,
2657 not at the beginning of the input level. */
2659 if (ip->buf != beg_of_line)
2660 warning ("preprocessing directive not recognized within macro arg");
2667 /* # keyword: a # must be first nonblank char on the line */
2668 if (beg_of_line == 0)
2673 /* Scan from start of line, skipping whitespace, comments
2674 and backslash-newlines, and see if we reach this #.
2675 If not, this # is not special. */
2677 /* If -traditional, require # to be at beginning of line. */
2680 if (is_hor_space[*bp])
2682 else if (*bp == '\\' && bp[1] == '\n')
2684 else if (*bp == '/' && bp[1] == '*') {
2698 #ifdef MULTIBYTE_CHARS
2700 length = local_mblen (bp, limit - bp);
2708 /* There is no point in trying to deal with C++ // comments here,
2709 because if there is one, then this # must be part of the
2710 comment and we would never reach here. */
2716 while (bp[1] == '\\' && bp[2] == '\n')
2720 /* %: appears at start of line; skip past the ':' too. */
2729 /* This # can start a directive. */
2731 --obp; /* Don't copy the '#' */
2735 if (! handle_directive (ip, op)) {
2739 /* Not a known directive: treat it as ordinary text.
2740 IP, OP, IBP, etc. have not been changed. */
2741 if (no_output && instack[indepth].fname) {
2742 /* If not generating expanded output,
2743 what we do with ordinary text is skip it.
2744 Discard everything until next # directive. */
2745 skip_if_group (&instack[indepth], 1, 0);
2750 *obp++ = '#'; /* Copy # (even if it was originally %:). */
2751 /* Don't expand an identifier that could be a macro directive.
2752 (Section 3.8.3 of the ANSI C standard) */
2753 SKIP_WHITE_SPACE (ibp);
2754 if (is_idstart[*ibp])
2757 while (is_idchar[*ibp])
2765 /* A # directive has been successfully processed. */
2766 /* If not generating expanded output, ignore everything until
2767 next # directive. */
2768 if (no_output && instack[indepth].fname)
2769 skip_if_group (&instack[indepth], 1, 0);
2775 case '\"': /* skip quoted string */
2777 /* A single quoted string is treated like a double -- some
2778 programs (e.g., troff) are perverse this way */
2780 /* Handle any pending identifier;
2781 but the L in L'...' or L"..." is not an identifier. */
2783 if (! (ident_length == 1 && hash == HASHSTEP (0, 'L')))
2785 ident_length = hash = 0;
2788 start_line = ip->lineno;
2790 /* Skip ahead to a matching quote. */
2794 if (ip->macro != 0) {
2795 /* try harder: this string crosses a macro expansion boundary.
2796 This can happen naturally if -traditional.
2797 Otherwise, only -D can make a macro with an unmatched quote. */
2803 error_with_line (line_for_error (start_line),
2804 "unterminated string or character constant");
2805 if (multiline_string_line) {
2806 error_with_line (multiline_string_line,
2807 "possible real start of unterminated constant");
2808 multiline_string_line = 0;
2816 if (warn_white_space && ip->fname && is_hor_space[ibp[-2]])
2817 warning ("white space at end of line in string");
2820 /* Traditionally, end of line ends a string constant with no error.
2821 So exit the loop and record the new line. */
2827 error_with_line (line_for_error (start_line),
2828 "unterminated character constant");
2831 if (multiline_string_line == 0) {
2833 pedwarn_with_line (line_for_error (start_line),
2834 "string constant runs past end of line");
2835 multiline_string_line = ip->lineno - 1;
2841 /* Backslash newline is replaced by nothing at all, but
2842 keep the line counts correct. But if we are reading
2843 from a macro, keep the backslash newline, since backslash
2844 newlines have already been processed. */
2853 /* ANSI stupidly requires that in \\ the second \
2854 is *not* prevented from combining with a newline. */
2856 while (*ibp == '\\' && ibp[1] == '\n') {
2872 #ifdef MULTIBYTE_CHARS
2877 length = local_mblen (ibp, limit - ibp);
2881 bcopy (ibp, obp, length);
2901 && !(cplusplus_comments && *ibp == '/'))
2907 /* C++ style comment... */
2908 start_line = ip->lineno;
2910 /* Comments are equivalent to spaces. */
2911 if (! put_out_comments)
2915 U_CHAR *before_bp = ibp;
2917 while (++ibp < limit) {
2920 if (put_out_comments) {
2921 bcopy ((char *) before_bp, (char *) obp, ibp - before_bp);
2922 obp += ibp - before_bp;
2928 if (ibp + 1 < limit && ibp[1] == '\n')
2931 warning ("multiline `//' comment");
2933 /* Copy the newline into the output buffer, in order to
2934 avoid the pain of a #line every time a multiline comment
2936 if (!put_out_comments)
2944 #ifdef MULTIBYTE_CHARS
2946 length = local_mblen (ibp, limit - ibp);
2948 ibp += (length - 1);
2956 /* Ordinary C comment. Skip it, optionally copying it to output. */
2958 start_line = ip->lineno;
2960 ++ibp; /* Skip the star. */
2962 /* If this cpp is for lint, we peek inside the comments: */
2966 char *lintcmd = get_lintcmd (ibp, limit, &argbp, &arglen, &cmdlen);
2968 if (lintcmd != NULL) {
2970 check_expand (op, cmdlen + arglen + 14);
2972 /* I believe it is always safe to emit this newline: */
2974 bcopy ("#pragma lint ", (char *) obp, 13);
2976 bcopy (lintcmd, (char *) obp, cmdlen);
2981 bcopy (argbp, (char *) obp, arglen);
2985 /* OK, now bring us back to the state we were in before we entered
2986 this branch. We need #line because the #pragma's newline always
2987 messes up the line count. */
2989 output_line_directive (ip, op, 0, same_file);
2990 check_expand (op, limit - ibp + 2);
2996 /* Comments are equivalent to spaces.
2997 Note that we already output the slash; we might not want it.
2998 For -traditional, a comment is equivalent to nothing. */
2999 if (! put_out_comments) {
3009 U_CHAR *before_bp = ibp;
3014 if (ibp[-2] == '/' && warn_comments)
3015 warning ("`/*' within comment");
3024 /* Copy the newline into the output buffer, in order to
3025 avoid the pain of a #line every time a multiline comment
3027 if (!put_out_comments)
3034 error_with_line (line_for_error (start_line),
3035 "unterminated comment");
3039 #ifdef MULTIBYTE_CHARS
3043 length = local_mblen (ibp, limit - ibp);
3045 ibp += (length - 1);
3054 if (put_out_comments) {
3055 bcopy ((char *) before_bp, (char *) obp, ibp - before_bp);
3056 obp += ibp - before_bp;
3062 if (! is_idchar['$'])
3065 pedwarn ("`$' in identifier");
3068 case '0': case '1': case '2': case '3': case '4':
3069 case '5': case '6': case '7': case '8': case '9':
3070 /* If digit is not part of identifier, it starts a number,
3071 which means that following letters are not an identifier.
3072 "0x5" does not refer to an identifier "x5".
3073 So copy all alphanumerics that follow without accumulating
3074 as an identifier. Periods also, for sake of "3.e7". */
3076 if (ident_length == 0) {
3079 while (ibp[0] == '\\' && ibp[1] == '\n') {
3085 if (!is_idchar[c] && c != '.') {
3090 /* A sign can be part of a preprocessing number
3091 if it follows an `e' or `p'. */
3092 if (c == 'e' || c == 'E' || c == 'p' || c == 'P') {
3094 while (ibp[0] == '\\' && ibp[1] == '\n') {
3099 if (*ibp == '+' || *ibp == '-') {
3101 /* But traditional C does not let the token go past the sign,
3102 and C89 does not allow `p'. */
3103 if (traditional || (c89 && (c == 'p' || c == 'P')))
3113 case 'a': case 'b': case 'c': case 'd': case 'e': case 'f':
3114 case 'g': case 'h': case 'i': case 'j': case 'k': case 'l':
3115 case 'm': case 'n': case 'o': case 'p': case 'q': case 'r':
3116 case 's': case 't': case 'u': case 'v': case 'w': case 'x':
3118 case 'A': case 'B': case 'C': case 'D': case 'E': case 'F':
3119 case 'G': case 'H': case 'I': case 'J': case 'K': case 'L':
3120 case 'M': case 'N': case 'O': case 'P': case 'Q': case 'R':
3121 case 'S': case 'T': case 'U': case 'V': case 'W': case 'X':
3125 /* Compute step of hash function, to avoid a proc call on every token */
3126 hash = HASHSTEP (hash, c);
3130 if (ip->fname == 0 && *ibp == '-') {
3131 /* Newline - inhibits expansion of preceding token.
3132 If expanding a macro arg, we keep the newline -.
3133 In final output, it is deleted.
3134 We recognize Newline - in macro bodies and macro args. */
3135 if (! concatenated) {
3140 if (!output_marks) {
3143 /* If expanding a macro arg, keep the newline -. */
3149 /* If reprocessing a macro expansion, newline is a special marker. */
3150 else if (ip->macro != 0) {
3151 /* Newline White is a "funny space" to separate tokens that are
3152 supposed to be separate but without space between.
3153 Here White means any whitespace character.
3154 Newline - marks a recursive macro use that is not
3155 supposed to be expandable. */
3157 if (is_space[*ibp]) {
3158 /* Newline Space does not prevent expansion of preceding token
3159 so expand the preceding token and then come back. */
3160 if (ident_length > 0)
3163 /* If generating final output, newline space makes a space. */
3164 if (!output_marks) {
3166 /* And Newline Newline makes a newline, so count it. */
3167 if (obp[-1] == '\n')
3170 /* If expanding a macro arg, keep the newline space.
3171 If the arg gets stringified, newline space makes nothing. */
3174 } else abort (); /* Newline followed by something random? */
3178 /* If there is a pending identifier, handle it and come back here. */
3179 if (ident_length > 0)
3184 /* Update the line counts and output a #line if necessary. */
3187 if (ip->lineno != op->lineno) {
3189 output_line_directive (ip, op, 1, same_file);
3190 check_expand (op, limit - ibp);
3195 /* Come here either after (1) a null character that is part of the input
3196 or (2) at the end of the input, because there is a null there. */
3199 /* Our input really contains a null character. */
3203 /* At end of a macro-expansion level, pop it and read next level. */
3204 if (ip->macro != 0) {
3207 /* If traditional, and we have an identifier that ends here,
3208 process it now, so we get the right error for recursion. */
3209 if (traditional && ident_length
3210 && ! is_idchar[*instack[indepth - 1].bufp]) {
3219 /* If we don't have a pending identifier,
3220 return at end of input. */
3221 if (ident_length == 0) {
3229 /* If we do have a pending identifier, just consider this null
3230 a special character and arrange to dispatch on it again.
3231 The second time, IDENT_LENGTH will be zero so we will return. */
3237 /* Handle the case of a character such as /, ', " or null
3238 seen following an identifier. Back over it so that
3239 after the identifier is processed the special char
3240 will be dispatched on again. */
3250 if (ident_length > 0) {
3251 register HASHNODE *hp;
3253 /* We have just seen an identifier end. If it's a macro, expand it.
3255 IDENT_LENGTH is the length of the identifier
3256 and HASH is its hash code.
3258 The identifier has already been copied to the output,
3259 so if it is a macro we must remove it.
3261 If REDO_CHAR is 0, the char that terminated the identifier
3262 has been skipped in the output and the input.
3263 OBP-IDENT_LENGTH-1 points to the identifier.
3264 If the identifier is a macro, we must back over the terminator.
3266 If REDO_CHAR is 1, the terminating char has already been
3267 backed over. OBP-IDENT_LENGTH points to the identifier. */
3269 if (!pcp_outfile || pcp_inside_if) {
3270 for (hp = hashtab[MAKE_POS (hash) % HASHSIZE]; hp != NULL;
3273 if (hp->length == ident_length) {
3274 int obufp_before_macroname;
3275 int op_lineno_before_macroname;
3276 register int i = ident_length;
3277 register U_CHAR *p = hp->name;
3278 register U_CHAR *q = obp - i;
3284 do { /* All this to avoid a strncmp () */
3289 /* We found a use of a macro name.
3290 see if the context shows it is a macro call. */
3292 /* Back up over terminating character if not already done. */
3298 /* Save this as a displacement from the beginning of the output
3299 buffer. We can not save this as a position in the output
3300 buffer, because it may get realloc'ed by RECACHE. */
3301 obufp_before_macroname = (obp - op->buf) - ident_length;
3302 op_lineno_before_macroname = op->lineno;
3304 if (hp->type == T_PCSTRING) {
3305 pcstring_used (hp); /* Mark the definition of this key
3306 as needed, ensuring that it
3308 break; /* Exit loop, since the key cannot have a
3309 definition any longer. */
3312 /* Record whether the macro is disabled. */
3313 disabled = hp->type == T_DISABLED;
3315 /* This looks like a macro ref, but if the macro was disabled,
3316 just copy its name and put in a marker if requested. */
3320 /* This error check caught useful cases such as
3321 #define foo(x,y) bar (x (y,0), y)
3324 error ("recursive use of macro `%s'", hp->name);
3328 check_expand (op, limit - ibp + 2);
3335 /* If macro wants an arglist, verify that a '(' follows.
3336 first skip all whitespace, copying it to the output
3337 after the macro name. Then, if there is no '(',
3338 decide this is not a macro call and leave things that way. */
3339 if ((hp->type == T_MACRO || hp->type == T_DISABLED)
3340 && hp->value.defn->nargs >= 0)
3342 U_CHAR *old_ibp = ibp;
3343 U_CHAR *old_obp = obp;
3344 int old_iln = ip->lineno;
3345 int old_oln = op->lineno;
3348 /* Scan forward over whitespace, copying it to the output. */
3349 if (ibp == limit && ip->macro != 0) {
3354 old_iln = ip->lineno;
3355 old_oln = op->lineno;
3357 else if (is_space[*ibp]) {
3359 if (ibp[-1] == '\n') {
3360 if (ip->macro == 0) {
3361 /* Newline in a file. Count it. */
3364 } else if (!output_marks) {
3365 /* A newline mark, and we don't want marks
3366 in the output. If it is newline-hyphen,
3367 discard it entirely. Otherwise, it is
3368 newline-whitechar, so keep the whitechar. */
3378 /* A newline mark; copy both chars to the output. */
3385 else if (*ibp == '/') {
3386 /* If a comment, copy it unchanged or discard it. */
3388 newline_fix (ibp + 1);
3389 if (ibp[1] == '*') {
3390 if (put_out_comments) {
3393 } else if (! traditional) {
3396 for (ibp += 2; ibp < limit; ibp++) {
3397 /* We need not worry about newline-marks,
3398 since they are never found in comments. */
3399 if (ibp[0] == '*') {
3401 newline_fix (ibp + 1);
3402 if (ibp[1] == '/') {
3404 if (put_out_comments) {
3411 else if (*ibp == '\n') {
3412 /* Newline in a file. Count it. */
3418 #ifdef MULTIBYTE_CHARS
3420 length = local_mblen (ibp, limit - ibp);
3423 if (put_out_comments)
3425 bcopy (ibp, obp, length - 1);
3428 ibp += (length - 1);
3432 if (put_out_comments)
3435 } else if (ibp[1] == '/' && cplusplus_comments) {
3436 if (put_out_comments) {
3439 } else if (! traditional) {
3442 for (ibp += 2; ; ibp++)
3446 if (*ibp == '\\' && ibp[1] == '\n')
3448 if (put_out_comments)
3453 #ifdef MULTIBYTE_CHARS
3455 length = local_mblen (ibp, limit - ibp);
3458 if (put_out_comments)
3460 bcopy (ibp, obp, length - 1);
3463 ibp += (length - 1);
3467 if (put_out_comments)
3473 else if (ibp[0] == '\\' && ibp[1] == '\n') {
3480 /* It isn't a macro call.
3481 Put back the space that we just skipped. */
3484 ip->lineno = old_iln;
3485 op->lineno = old_oln;
3486 /* Exit the for loop. */
3491 /* This is now known to be a macro call.
3492 Discard the macro name from the output,
3493 along with any following whitespace just copied,
3494 but preserve newlines if not outputting marks since this
3495 is more likely to do the right thing with line numbers. */
3496 obp = op->buf + obufp_before_macroname;
3498 op->lineno = op_lineno_before_macroname;
3500 int newlines = op->lineno - op_lineno_before_macroname;
3501 while (0 < newlines--)
3505 /* Prevent accidental token-pasting with a character
3506 before the macro call. */
3507 if (!traditional && obp != op->buf) {
3509 case '!': case '%': case '&': case '*':
3510 case '+': case '-': case '.': case '/':
3511 case ':': case '<': case '=': case '>':
3513 /* If we are expanding a macro arg, make a newline marker
3514 to separate the tokens. If we are making real output,
3515 a plain space will do. */
3522 /* Expand the macro, reading arguments as needed,
3523 and push the expansion on the input stack. */
3526 macroexpand (hp, op);
3528 /* Reexamine input stack, since macroexpand has pushed
3529 a new level on it. */
3536 } /* End hash-table-search loop */
3538 ident_length = hash = 0; /* Stop collecting identifier */
3541 } /* End if (ident_length > 0) */
3543 } /* End per-char loop */
3545 /* Come here to return -- but first give an error message
3546 if there was an unterminated successful conditional. */
3548 if (if_stack != ip->if_stack)
3552 switch (if_stack->type)
3573 error_with_line (line_for_error (if_stack->lineno),
3574 "unterminated `#%s' conditional", str);
3576 if_stack = ip->if_stack;
3580 * Rescan a string into a temporary buffer and return the result
3581 * as a FILE_BUF. Note this function returns a struct, not a pointer.
3583 * OUTPUT_MARKS nonzero means keep Newline markers found in the input
3584 * and insert such markers when appropriate. See `rescan' for details.
3585 * OUTPUT_MARKS is 1 for macroexpanding a macro argument separately
3586 * before substitution; it is 0 for other uses.
3589 expand_to_temp_buffer (buf, limit, output_marks, assertions)
3590 U_CHAR *buf, *limit;
3591 int output_marks, assertions;
3593 register FILE_BUF *ip;
3595 int length = limit - buf;
3597 int odepth = indepth;
3598 int save_assertions_flag = assertions_flag;
3600 assertions_flag = assertions;
3605 /* Set up the input on the input stack. */
3607 buf1 = (U_CHAR *) alloca (length + 1);
3609 register U_CHAR *p1 = buf;
3610 register U_CHAR *p2 = buf1;
3617 /* Set up to receive the output. */
3619 obuf.length = length * 2 + 100; /* Usually enough. Why be stingy? */
3620 obuf.bufp = obuf.buf = (U_CHAR *) xmalloc (obuf.length);
3621 obuf.nominal_fname = 0;
3628 obuf.system_header_p = 0;
3630 CHECK_DEPTH ({return obuf;});
3634 ip = &instack[indepth];
3636 ip->nominal_fname = 0;
3637 ip->nominal_fname_len = 0;
3639 ip->system_header_p = 0;
3642 ip->length = length;
3643 ip->buf = ip->bufp = buf1;
3644 ip->if_stack = if_stack;
3646 ip->lineno = obuf.lineno = 1;
3648 /* Scan the input, create the output. */
3649 rescan (&obuf, output_marks);
3651 /* Pop input stack to original state. */
3654 if (indepth != odepth)
3657 assertions_flag = save_assertions_flag;
3662 * Process a # directive. Expects IP->bufp to point after the '#', as in
3663 * `#define foo bar'. Passes to the directive handler
3664 * (do_define, do_include, etc.): the addresses of the 1st and
3665 * last chars of the directive (starting immediately after the #
3666 * keyword), plus op and the keyword table pointer. If the directive
3667 * contains comments it is copied into a temporary buffer sans comments
3668 * and the temporary buffer is passed to the directive handler instead.
3669 * Likewise for backslash-newlines.
3671 * Returns nonzero if this was a known # directive.
3672 * Otherwise, returns zero, without advancing the input pointer.
3676 handle_directive (ip, op)
3679 register U_CHAR *bp, *cp;
3680 register struct directive *kt;
3681 register int ident_length;
3684 /* Nonzero means we must copy the entire directive
3685 to get rid of comments or backslash-newlines. */
3686 int copy_directive = 0;
3688 U_CHAR *ident, *after_ident;
3692 /* Record where the directive started. do_xifdef needs this. */
3693 directive_start = bp - 1;
3695 ignore_escape_flag = 1;
3697 /* Skip whitespace and \-newline. */
3699 if (is_hor_space[*bp]) {
3700 if (*bp != ' ' && *bp != '\t' && pedantic)
3701 pedwarn_strange_white_space (*bp);
3703 } else if (*bp == '/') {
3705 newline_fix (bp + 1);
3706 if (! (bp[1] == '*' || (cplusplus_comments && bp[1] == '/')))
3709 skip_to_end_of_comment (ip, &ip->lineno, 0);
3711 } else if (*bp == '\\' && bp[1] == '\n') {
3712 bp += 2; ip->lineno++;
3716 /* Now find end of directive name.
3717 If we encounter a backslash-newline, exchange it with any following
3718 symbol-constituents so that we end up with a contiguous name. */
3726 name_newline_fix (cp);
3732 ident_length = cp - bp;
3736 /* A line of just `#' becomes blank. */
3738 if (ident_length == 0 && *after_ident == '\n') {
3739 ip->bufp = after_ident;
3743 if (ident_length == 0 || !is_idstart[*ident]) {
3745 while (is_idchar[*p]) {
3746 if (*p < '0' || *p > '9')
3750 /* Handle # followed by a line number. */
3751 if (p != ident && !is_idchar[*p]) {
3752 static struct directive line_directive_table[] = {
3753 { 4, do_line, "line", T_LINE},
3756 pedwarn ("`#' followed by integer");
3757 after_ident = ident;
3758 kt = line_directive_table;
3759 ignore_escape_flag = 0;
3763 /* Avoid error for `###' and similar cases unless -pedantic. */
3765 while (*p == '#' || is_hor_space[*p]) p++;
3767 if (pedantic && !lang_asm)
3768 warning ("invalid preprocessing directive");
3774 error ("invalid preprocessing directive name");
3780 * Decode the keyword and call the appropriate expansion
3781 * routine, after moving the input pointer up to the next line.
3783 for (kt = directive_table; kt->length > 0; kt++) {
3784 if (kt->length == ident_length && !bcmp (kt->name, ident, ident_length)) {
3785 register U_CHAR *buf;
3786 register U_CHAR *limit;
3789 int *already_output;
3791 /* Nonzero means do not delete comments within the directive.
3792 #define needs this when -traditional. */
3797 limit = ip->buf + ip->length;
3800 keep_comments = traditional && kt->type == T_DEFINE;
3801 /* #import is defined only in Objective C, or when on the NeXT. */
3802 if (kt->type == T_IMPORT
3803 && !(objc || lookup ((U_CHAR *) "__NeXT__", -1, -1)))
3806 /* Find the end of this directive (first newline not backslashed
3807 and not in a string or comment).
3808 Set COPY_DIRECTIVE if the directive must be copied
3809 (it contains a backslash-newline or a comment). */
3811 buf = bp = after_ident;
3812 while (bp < limit) {
3813 register U_CHAR c = *bp++;
3820 } else if (traditional && bp < limit)
3825 /* "..." is special for #include. */
3826 if (IS_INCLUDE_DIRECTIVE_TYPE (kt->type)) {
3827 while (bp < limit && *bp != '\n') {
3832 if (*bp == '\\' && bp[1] == '\n') {
3843 bp = skip_quoted_string (bp - 1, limit, ip->lineno, &ip->lineno, ©_directive, &unterminated);
3844 /* Don't bother calling the directive if we already got an error
3845 message due to unterminated string. Skip everything and pretend
3846 we called the directive. */
3849 /* Traditional preprocessing permits unterminated strings. */
3858 /* <...> is special for #include. */
3860 if (! IS_INCLUDE_DIRECTIVE_TYPE (kt->type))
3862 while (bp < limit && *bp != '>' && *bp != '\n') {
3863 if (*bp == '\\' && bp[1] == '\n') {
3876 || (cplusplus_comments && *bp == '/')) {
3877 U_CHAR *obp = bp - 1;
3879 skip_to_end_of_comment (ip, &ip->lineno, 0);
3881 /* No need to copy the directive because of a comment at the end;
3882 just don't include the comment in the directive. */
3883 if (!put_out_comments) {
3885 for (p = bp; *p == ' ' || *p == '\t'; p++)
3892 /* Don't remove the comments if -traditional. */
3893 if (! keep_comments)
3902 pedwarn_strange_white_space (c);
3906 --bp; /* Point to the newline */
3914 resume_p = ip->bufp;
3915 /* BP is the end of the directive.
3916 RESUME_P is the next interesting data after the directive.
3917 A comment may come between. */
3919 /* If a directive should be copied through, and -C was given,
3920 pass it through before removing comments. */
3921 if (!no_output && put_out_comments
3922 && ((kt->type == T_DEFINE || kt->type == T_UNDEF)
3923 ? dump_macros == dump_definitions
3924 : IS_INCLUDE_DIRECTIVE_TYPE (kt->type) ? dump_includes
3925 : kt->type == T_PRAGMA)) {
3928 /* Output directive name. */
3929 check_expand (op, kt->length + 2);
3930 /* Make sure # is at the start of a line */
3931 if (op->bufp > op->buf && op->bufp[-1] != '\n') {
3936 bcopy (kt->name, op->bufp, kt->length);
3937 op->bufp += kt->length;
3939 /* Output arguments. */
3941 check_expand (op, len);
3942 bcopy (buf, (char *) op->bufp, len);
3944 /* Take account of any (escaped) newlines just output. */
3946 if (buf[len] == '\n')
3949 already_output = &junk;
3950 } /* Don't we need a newline or #line? */
3952 if (copy_directive) {
3953 register U_CHAR *xp = buf;
3954 /* Need to copy entire directive into temp buffer before dispatching */
3956 /* room for directive plus some slop */
3957 cp = (U_CHAR *) alloca (2 * (bp - buf) + 5);
3960 /* Copy to the new buffer, deleting comments
3961 and backslash-newlines (and whitespace surrounding the latter
3962 if outside of char and string constants). */
3965 register U_CHAR c = *xp++;
3970 abort (); /* A bare newline should never part of the line. */
3973 /* <...> is special for #include. */
3975 if (! IS_INCLUDE_DIRECTIVE_TYPE (kt->type))
3977 while (xp < bp && c != '>') {
3979 if (c == '\\' && xp < bp && *xp == '\n')
3990 if (cp != buf && is_hor_space[cp[-1]]) {
3991 while (cp - 1 != buf && is_hor_space[cp[-2]])
3993 SKIP_WHITE_SPACE (xp);
3994 } else if (is_hor_space[*xp]) {
3996 SKIP_WHITE_SPACE (xp);
3998 } else if (traditional && xp < bp) {
4006 int backslash_newlines_p;
4008 register U_CHAR *bp1
4009 = skip_quoted_string (xp - 1, bp, ip->lineno,
4010 NULL_PTR, &backslash_newlines_p,
4012 if (backslash_newlines_p)
4015 /* With something like:
4020 we should still remove the backslash-newline
4021 pair as part of phase two. */
4022 if (xp[0] == '\\' && xp[1] == '\n')
4028 /* This is the same as the loop above, but taking
4029 advantage of the fact that we know there are no
4030 backslash-newline pairs. */
4038 || (cplusplus_comments && *xp == '/')) {
4040 /* If we already copied the directive through,
4041 already_output != 0 prevents outputting comment now. */
4042 skip_to_end_of_comment (ip, already_output, 0);
4044 while (xp != ip->bufp)
4046 /* Delete or replace the slash. */
4047 else if (traditional)
4056 /* Null-terminate the copy. */
4062 ip->bufp = resume_p;
4064 /* Some directives should be written out for cc1 to process,
4065 just as if they were not defined. And sometimes we're copying
4066 directives through. */
4068 if (!no_output && already_output == 0
4069 && ((kt->type == T_DEFINE || kt->type == T_UNDEF)
4070 ? (int) dump_names <= (int) dump_macros
4071 : IS_INCLUDE_DIRECTIVE_TYPE (kt->type) ? dump_includes
4072 : kt->type == T_PRAGMA)) {
4075 /* Output directive name. */
4076 check_expand (op, kt->length + 1);
4078 bcopy (kt->name, (char *) op->bufp, kt->length);
4079 op->bufp += kt->length;
4081 if (kt->type == T_DEFINE && dump_macros == dump_names) {
4082 /* Output `#define name' only. */
4085 SKIP_WHITE_SPACE (xp);
4087 while (is_idchar[*xp]) xp++;
4089 check_expand (op, len + 1);
4091 bcopy (yp, (char *) op->bufp, len);
4093 /* Output entire directive. */
4095 check_expand (op, len);
4096 bcopy (buf, (char *) op->bufp, len);
4101 /* Call the appropriate directive handler. buf now points to
4102 either the appropriate place in the input buffer, or to
4103 the temp buffer if it was necessary to make one. cp
4104 points to the first char after the contents of the (possibly
4105 copied) directive, in either case. */
4106 (*kt->func) (buf, cp, op, kt);
4107 check_expand (op, ip->length - (ip->bufp - ip->buf));
4113 /* It is deliberate that we don't warn about undefined directives.
4114 That is the responsibility of cc1. */
4121 static struct tm tmbuf;
4122 if (! tmbuf.tm_mday) {
4123 time_t t = time ((time_t *) 0);
4124 struct tm *tm = localtime (&t);
4128 /* Use 0000-01-01 00:00:00 if local time is not available. */
4129 tmbuf.tm_year = -1900;
4136 static char *monthnames[] = {"Jan", "Feb", "Mar", "Apr", "May", "Jun",
4137 "Jul", "Aug", "Sep", "Oct", "Nov", "Dec",
4141 * expand things like __FILE__. Place the expansion into the output
4142 * buffer *without* rescanning.
4146 special_symbol (hp, op)
4153 FILE_BUF *ip = NULL;
4156 int paren = 0; /* For special `defined' keyword */
4158 if (pcp_outfile && pcp_inside_if
4159 && hp->type != T_SPEC_DEFINED && hp->type != T_CONST)
4160 error ("Predefined macro `%s' used inside `#if' during precompilation",
4163 for (i = indepth; i >= 0; i--)
4164 if (instack[i].fname != NULL) {
4169 error ("cccp error: not in any file?!");
4170 return; /* the show must go on */
4177 FILE_BUF *p = hp->type == T_FILE ? ip : &instack[0];
4178 char *string = p->nominal_fname;
4182 size_t string_len = p->nominal_fname_len;
4183 buf = (char *) alloca (3 + 4 * string_len);
4184 quote_string (buf, string, string_len);
4192 case T_INCLUDE_LEVEL:
4194 for (i = indepth; i >= 0; i--)
4195 if (instack[i].fname != NULL)
4198 buf = (char *) alloca (8); /* Eight bytes ought to be more than enough */
4199 sprintf (buf, "%d", true_indepth - 1);
4203 buf = (char *) alloca (3 + strlen (version_string));
4204 sprintf (buf, "\"%s\"", version_string);
4207 #ifndef NO_BUILTIN_SIZE_TYPE
4213 #ifndef NO_BUILTIN_PTRDIFF_TYPE
4214 case T_PTRDIFF_TYPE:
4223 case T_USER_LABEL_PREFIX_TYPE:
4224 buf = user_label_prefix;
4227 case T_REGISTER_PREFIX_TYPE:
4228 buf = REGISTER_PREFIX;
4231 case T_IMMEDIATE_PREFIX_TYPE:
4232 buf = IMMEDIATE_PREFIX;
4236 buf = hp->value.cpval;
4237 #ifdef STDC_0_IN_SYSTEM_HEADERS
4238 if (ip->system_header_p
4239 && hp->length == 8 && bcmp (hp->name, "__STDC__", 8) == 0
4240 && !lookup ((U_CHAR *) "__STRICT_ANSI__", -1, -1))
4243 if (pcp_inside_if && pcp_outfile)
4244 /* Output a precondition for this macro use */
4245 fprintf (pcp_outfile, "#define %s %s\n", hp->name, buf);
4249 buf = (char *) alloca (10);
4250 sprintf (buf, "%d", ip->lineno);
4255 buf = (char *) alloca (20);
4256 timebuf = timestamp ();
4257 if (hp->type == T_DATE)
4258 sprintf (buf, "\"%s %2d %4d\"", monthnames[timebuf->tm_mon],
4259 timebuf->tm_mday, timebuf->tm_year + 1900);
4261 sprintf (buf, "\"%02d:%02d:%02d\"", timebuf->tm_hour, timebuf->tm_min,
4265 case T_SPEC_DEFINED:
4266 buf = " 0 "; /* Assume symbol is not defined */
4267 ip = &instack[indepth];
4268 SKIP_WHITE_SPACE (ip->bufp);
4269 if (*ip->bufp == '(') {
4271 ip->bufp++; /* Skip over the paren */
4272 SKIP_WHITE_SPACE (ip->bufp);
4275 if (!is_idstart[*ip->bufp])
4277 if (ip->bufp[0] == 'L' && (ip->bufp[1] == '\'' || ip->bufp[1] == '"'))
4279 if ((hp = lookup (ip->bufp, -1, -1))) {
4280 if (pcp_outfile && pcp_inside_if
4281 && (hp->type == T_CONST
4282 || (hp->type == T_MACRO && hp->value.defn->predefined)))
4283 /* Output a precondition for this macro use. */
4284 fprintf (pcp_outfile, "#define %s\n", hp->name);
4285 if (hp->type == T_POISON) {
4286 error("attempt to use poisoned `%s'.", hp->name);
4293 if (pcp_outfile && pcp_inside_if) {
4294 /* Output a precondition for this macro use */
4295 U_CHAR *cp = ip->bufp;
4296 fprintf (pcp_outfile, "#undef ");
4297 while (is_idchar[*cp]) /* Ick! */
4298 fputc (*cp++, pcp_outfile);
4299 putc ('\n', pcp_outfile);
4301 while (is_idchar[*ip->bufp])
4303 SKIP_WHITE_SPACE (ip->bufp);
4305 if (*ip->bufp != ')')
4312 error("attempt to use poisoned `%s'.", hp->name);
4313 buf = " 0 "; /* Consider poisoned symbol to not be defined */
4318 error ("`defined' without an identifier");
4322 error ("cccp error: invalid special hash type"); /* time for gdb */
4326 check_expand (op, len);
4327 bcopy (buf, (char *) op->bufp, len);
4334 /* Routines to handle #directives */
4336 /* Handle #include and #import.
4337 This function expects to see "fname" or <fname> on the input. */
4340 do_include (buf, limit, op, keyword)
4341 U_CHAR *buf, *limit;
4343 struct directive *keyword;
4345 U_CHAR *importing = keyword->type == T_IMPORT ? (U_CHAR *) "" : (U_CHAR *) 0;
4346 int skip_dirs = (keyword->type == T_INCLUDE_NEXT);
4347 static int import_warning = 0;
4348 char *fname; /* Dynamically allocated fname buffer */
4351 char *fbeg, *fend; /* Beginning and end of fname */
4354 struct file_name_list *search_start = include; /* Chain of dirs to search */
4355 struct file_name_list *dsp; /* First in chain, if #include "..." */
4356 struct file_name_list *searchptr = 0;
4359 int f = -3; /* file number */
4360 struct include_file *inc = 0;
4362 int retried = 0; /* Have already tried macro
4363 expanding the include line*/
4364 int angle_brackets = 0; /* 0 for "...", 1 for <...> */
4366 int vaxc_include = 0; /* 1 for token without punctuation */
4373 if (pedantic && !instack[indepth].system_header_p)
4376 pedwarn ("ANSI C does not allow `#import'");
4378 pedwarn ("ANSI C does not allow `#include_next'");
4381 if (importing && warn_import && !inhibit_warnings
4382 && !instack[indepth].system_header_p && !import_warning) {
4384 warning ("using `#import' is not recommended");
4385 notice ("The fact that a certain header file need not be processed more than once\n\
4386 should be indicated in the header file, not where it is used.\n\
4387 The best way to do this is with a conditional of this form:\n\
4389 #ifndef _FOO_H_INCLUDED\n\
4390 #define _FOO_H_INCLUDED\n\
4391 ... <real contents of file> ...\n\
4392 #endif /* Not _FOO_H_INCLUDED */\n\
4394 Then users can use `#include' any number of times.\n\
4395 GNU C automatically avoids processing the file more than once\n\
4396 when it is equipped with such a conditional.\n");
4402 SKIP_WHITE_SPACE (fin);
4403 /* Discard trailing whitespace so we can easily see
4404 if we have parsed all the significant chars we were given. */
4405 while (limit != fin && is_hor_space[limit[-1]]) limit--;
4406 fbeg = fend = (char *) alloca (limit - fin);
4412 /* Copy the operand text, concatenating the strings. */
4417 goto invalid_include_file_name;
4425 /* If not at the end, there had better be another string. */
4426 /* Skip just horiz space, and don't go past limit. */
4427 while (fin != limit && is_hor_space[*fin]) fin++;
4428 if (fin != limit && *fin == '\"')
4435 /* We have "filename". Figure out directory this source
4436 file is coming from and put it on the front of the list. */
4438 /* If -I- was specified, don't search current dir, only spec'd ones. */
4439 if (ignore_srcdir) break;
4441 for (fp = &instack[indepth]; fp >= instack; fp--)
4446 if ((nam = fp->nominal_fname) != NULL) {
4447 /* Found a named file. Figure out dir of the file,
4448 and put it in front of the search list. */
4449 dsp = ((struct file_name_list *)
4450 alloca (sizeof (struct file_name_list)
4451 + fp->nominal_fname_len));
4452 strcpy (dsp->fname, nam);
4453 simplify_filename (dsp->fname);
4454 nam = base_name (dsp->fname);
4457 /* for hack_vms_include_specification(), a local
4458 dir specification must start with "./" on VMS. */
4459 if (nam == dsp->fname)
4466 /* But for efficiency's sake, do not insert the dir
4467 if it matches the search list's first dir. */
4468 dsp->next = search_start;
4469 if (!search_start || strcmp (dsp->fname, search_start->fname)) {
4471 n = nam - dsp->fname;
4472 if (n + INCLUDE_LEN_FUDGE > max_include_len)
4473 max_include_len = n + INCLUDE_LEN_FUDGE;
4475 dsp[0].got_name_map = 0;
4483 while (fin != limit && *fin != '>')
4485 if (*fin == '>' && fin + 1 == limit) {
4487 /* If -I-, start with the first -I dir after the -I-. */
4488 search_start = first_bracket_include;
4496 * Support '#include xyz' like VAX-C to allow for easy use of all the
4497 * decwindow include files. It defaults to '#include <xyz.h>' (so the
4498 * code from case '<' is repeated here) and generates a warning.
4499 * (Note: macro expansion of `xyz' takes precedence.)
4501 /* Note: The argument of ISALPHA() can be evaluated twice, so do
4502 the pre-decrement outside of the macro. */
4503 if (retried && (--fin, ISALPHA(*(U_CHAR *) (fin)))) {
4504 while (fin != limit && (!ISSPACE(*fin)))
4506 warning ("VAX-C-style include specification found, use '#include <filename.h>' !");
4510 /* If -I-, start with the first -I dir after the -I-. */
4511 search_start = first_bracket_include;
4519 /* Expand buffer and then remove any newline markers.
4520 We can't just tell expand_to_temp_buffer to omit the markers,
4521 since it would put extra spaces in include file names. */
4524 int errors_before_expansion = errors;
4525 trybuf = expand_to_temp_buffer (buf, limit, 1, 0);
4526 if (errors != errors_before_expansion) {
4528 goto invalid_include_file_name;
4531 buf = (U_CHAR *) alloca (trybuf.bufp - trybuf.buf + 1);
4533 while (src != trybuf.bufp) {
4534 switch ((*limit++ = *src++)) {
4543 U_CHAR *src1 = skip_quoted_string (src - 1, trybuf.bufp, 0,
4544 NULL_PTR, NULL_PTR, NULL_PTR);
4557 invalid_include_file_name:
4558 error ("`#%s' expects \"FILENAME\" or <FILENAME>", keyword->name);
4562 /* For #include_next, skip in the search path
4563 past the dir in which the containing file was found. */
4566 for (fp = &instack[indepth]; fp >= instack; fp--)
4567 if (fp->fname != NULL) {
4568 /* fp->dir is null if the containing file was specified
4569 with an absolute file name. In that case, don't skip anything. */
4571 search_start = fp->dir->next;
4577 flen = simplify_filename (fbeg);
4581 error ("empty file name in `#%s'", keyword->name);
4585 /* Allocate this permanently, because it gets stored in the definitions
4587 fname = xmalloc (max_include_len + flen + 1);
4588 /* + 1 above for terminating null. */
4590 system_include_depth += angle_brackets;
4592 /* If specified file name is absolute, just open it. */
4594 if (absolute_filename (fbeg)) {
4595 strcpy (fname, fbeg);
4596 f = open_include_file (fname, NULL_PTR, importing, &inc);
4600 struct bypass_dir *next;
4602 struct file_name_list *searchptr;
4603 } **bypass_slot = 0;
4605 /* Search directory path, trying to open the file.
4606 Copy each filename tried into FNAME. */
4608 for (searchptr = search_start; searchptr; searchptr = searchptr->next) {
4610 if (searchptr == first_bracket_include) {
4611 /* Go to bypass directory if we know we've seen this file before. */
4612 static struct bypass_dir *bypass_hashtab[INCLUDE_HASHSIZE];
4613 struct bypass_dir *p;
4614 bypass_slot = &bypass_hashtab[hashf ((U_CHAR *) fbeg, flen,
4616 for (p = *bypass_slot; p; p = p->next)
4617 if (!strcmp (fbeg, p->fname)) {
4618 searchptr = p->searchptr;
4625 /* Change this 1/2 Unix 1/2 VMS file specification into a
4626 full VMS file specification */
4627 if (searchptr->fname[0])
4629 strcpy (fname, searchptr->fname);
4630 if (fname[strlen (fname) - 1] == ':')
4633 slashp = strchr (fbeg, '/');
4635 /* start at root-dir of logical device if no path given. */
4637 strcat (fname, "[000000]");
4639 strcat (fname, fbeg);
4641 /* Fix up the filename */
4642 hack_vms_include_specification (fname, vaxc_include);
4646 /* This is a normal VMS filespec, so use it unchanged. */
4647 strcpy (fname, fbeg);
4648 /* if it's '#include filename', add the missing .h */
4649 if (vaxc_include && index(fname,'.')==NULL)
4650 strcat (fname, ".h");
4653 strcpy (fname, searchptr->fname);
4654 strcat (fname, fbeg);
4656 f = open_include_file (fname, searchptr, importing, &inc);
4658 if (bypass_slot && searchptr != first_bracket_include) {
4659 /* This is the first time we found this include file,
4660 and we found it after first_bracket_include.
4661 Record its location so that we can bypass to here next time. */
4662 struct bypass_dir *p
4663 = (struct bypass_dir *) xmalloc (sizeof (struct bypass_dir));
4664 p->next = *bypass_slot;
4665 p->fname = fname + strlen (searchptr->fname);
4666 p->searchptr = searchptr;
4672 /* Our VMS hacks can produce invalid filespecs, so don't worry
4673 about errors other than EACCES. */
4674 if (errno == EACCES)
4677 if (errno != ENOENT && errno != ENOTDIR)
4687 /* The file was already included. */
4689 /* If generating dependencies and -MG was specified, we assume missing
4690 files are leaf files, living in the same directory as the source file
4691 or other similar place; these missing files may be generated from
4692 other files and may not exist yet (eg: y.tab.h). */
4693 } else if (print_deps_missing_files
4694 && (system_include_depth != 0) < print_deps)
4696 /* If it was requested as a system header file,
4697 then assume it belongs in the first place to look for such. */
4701 char *p = (char *) alloca (strlen (search_start->fname)
4702 + strlen (fbeg) + 1);
4703 strcpy (p, search_start->fname);
4705 deps_output (p, ' ');
4710 /* Otherwise, omit the directory, as if the file existed
4711 in the directory with the source. */
4712 deps_output (fbeg, ' ');
4715 /* If -M was specified, and this header file won't be added to the
4716 dependency list, then don't count this as an error, because we can
4717 still produce correct output. Otherwise, we can't produce correct
4718 output, because there may be dependencies we need inside the missing
4719 file, and we don't know what directory this missing file exists in. */
4720 else if (0 < print_deps && print_deps <= (system_include_depth != 0))
4721 warning ("No include path in which to find %s", fbeg);
4723 error_from_errno (fbeg);
4725 error ("No include path in which to find %s", fbeg);
4729 /* Actually process the file. */
4731 pcftry = (char *) alloca (strlen (fname) + 30);
4738 sprintf (pcftry, "%s%d", fname, pcfnum++);
4740 pcf = open (pcftry, O_RDONLY, 0666);
4745 if (fstat (pcf, &s) != 0)
4746 pfatal_with_name (pcftry);
4747 if (! INO_T_EQ (inc->st.st_ino, s.st_ino)
4748 || inc->st.st_dev != s.st_dev)
4750 pcfbuf = check_precompiled (pcf, &s, fname, &pcfbuflimit);
4751 /* Don't need it any more. */
4756 /* Don't need it at all. */
4761 } while (pcf != -1 && !pcfbuf);
4764 /* Actually process the file */
4766 pcfname = xstrdup (pcftry);
4767 pcfinclude ((U_CHAR *) pcfbuf, (U_CHAR *) fname, op);
4770 finclude (f, inc, op, is_system_include (fname), searchptr);
4773 system_include_depth -= angle_brackets;
4778 /* Return nonzero if the given FILENAME is an absolute pathname which
4779 designates a file within one of the known "system" include file
4780 directories. We assume here that if the given FILENAME looks like
4781 it is the name of a file which resides either directly in a "system"
4782 include file directory, or within any subdirectory thereof, then the
4783 given file must be a "system" include file. This function tells us
4784 if we should suppress pedantic errors/warnings for the given FILENAME.
4786 The value is 2 if the file is a C-language system header file
4787 for which C++ should (on most systems) assume `extern "C"'. */
4790 is_system_include (filename)
4791 register char *filename;
4793 struct file_name_list *searchptr;
4795 for (searchptr = first_system_include; searchptr;
4796 searchptr = searchptr->next)
4797 if (! strncmp (searchptr->fname, filename, strlen (searchptr->fname)))
4798 return searchptr->c_system_include_path + 1;
4802 /* Yield the non-directory suffix of a file name. */
4810 #if defined (__MSDOS__) || defined (_WIN32)
4811 if (ISALPHA (s[0]) && s[1] == ':') s += 2;
4814 if ((p = rindex (s, ':'))) s = p + 1; /* Skip device. */
4815 if ((p = rindex (s, ']'))) s = p + 1; /* Skip directory. */
4816 if ((p = rindex (s, '>'))) s = p + 1; /* Skip alternate (int'n'l) dir. */
4820 if ((p = rindex (s, '/'))) s = p + 1;
4821 #ifdef DIR_SEPARATOR
4822 if ((p = rindex (s, DIR_SEPARATOR))) s = p + 1;
4827 /* Yield nonzero if FILENAME is absolute (i.e. not relative). */
4830 absolute_filename (filename)
4833 #if defined (__MSDOS__) \
4834 || (defined (_WIN32) && !defined (__CYGWIN__) && !defined (_UWIN))
4835 if (ISALPHA (filename[0]) && filename[1] == ':') filename += 2;
4837 #if defined (__CYGWIN__)
4838 /* At present, any path that begins with a drive spec is absolute. */
4839 if (ISALPHA (filename[0]) && filename[1] == ':') return 1;
4842 if (index (filename, ':') != 0) return 1;
4844 if (filename[0] == '/') return 1;
4845 #ifdef DIR_SEPARATOR
4846 if (filename[0] == DIR_SEPARATOR) return 1;
4851 /* Returns whether or not a given character is a directory separator.
4852 Used by simplify_filename. */
4855 is_dir_separator(ch)
4858 return (ch == DIR_SEPARATOR)
4859 #if defined (DIR_SEPARATOR_2)
4860 || (ch == DIR_SEPARATOR_2)
4865 /* Remove unnecessary characters from FILENAME in place,
4866 to avoid unnecessary filename aliasing.
4867 Return the length of the resulting string.
4869 Do only the simplifications allowed by Posix.
4870 It is OK to miss simplifications on non-Posix hosts,
4871 since this merely leads to suboptimal results. */
4874 simplify_filename (filename)
4877 register char *from = filename;
4878 register char *to = filename;
4881 /* Remove redundant initial /s. */
4882 if (is_dir_separator (*from))
4884 *to++ = DIR_SEPARATOR;
4885 if (is_dir_separator (*++from))
4887 if (is_dir_separator (*++from))
4889 /* 3 or more initial /s are equivalent to 1 /. */
4890 while (is_dir_separator (*++from))
4895 /* On some hosts // differs from /; Posix allows this. */
4896 *to++ = DIR_SEPARATOR;
4906 if (from[0] == '.' && from[1] == '/')
4911 /* Copy this component and trailing DIR_SEPARATOR, if any. */
4912 while (!is_dir_separator (*to++ = *from++))
4916 /* Trim . component at end of nonempty name. */
4917 to -= filename <= to - 3 && to[-3] == DIR_SEPARATOR && to[-2] == '.';
4919 /* Trim unnecessary trailing /s. */
4920 while (to0 < --to && to[-1] == DIR_SEPARATOR)
4924 return to - filename;
4927 #if defined(DIR_SEPARATOR_2)
4928 /* Simplify to one directory separator. */
4929 to[-1] = DIR_SEPARATOR;
4933 /* Skip /s after a /. */
4934 while (is_dir_separator (*from))
4939 /* The file_name_map structure holds a mapping of file names for a
4940 particular directory. This mapping is read from the file named
4941 FILE_NAME_MAP_FILE in that directory. Such a file can be used to
4942 map filenames on a file system with severe filename restrictions,
4943 such as DOS. The format of the file name map file is just a series
4944 of lines with two tokens on each line. The first token is the name
4945 to map, and the second token is the actual name to use. */
4947 struct file_name_map
4949 struct file_name_map *map_next;
4954 #define FILE_NAME_MAP_FILE "header.gcc"
4956 /* Read a space delimited string of unlimited length from a stdio
4960 read_filename_string (ch, f)
4968 set = alloc = xmalloc (len + 1);
4972 while ((ch = getc (f)) != EOF && ! is_space[ch])
4974 if (set - alloc == len)
4977 alloc = xrealloc (alloc, len + 1);
4978 set = alloc + len / 2;
4988 /* Read the file name map file for DIRNAME.
4989 If DIRNAME is empty, read the map file for the working directory;
4990 otherwise DIRNAME must end in '/'. */
4992 static struct file_name_map *
4993 read_name_map (dirname)
4996 /* This structure holds a linked list of file name maps, one per
4998 struct file_name_map_list
5000 struct file_name_map_list *map_list_next;
5001 char *map_list_name;
5002 struct file_name_map *map_list_map;
5004 static struct file_name_map_list *map_list;
5005 register struct file_name_map_list *map_list_ptr;
5010 for (map_list_ptr = map_list; map_list_ptr;
5011 map_list_ptr = map_list_ptr->map_list_next)
5012 if (! strcmp (map_list_ptr->map_list_name, dirname))
5013 return map_list_ptr->map_list_map;
5015 map_list_ptr = ((struct file_name_map_list *)
5016 xmalloc (sizeof (struct file_name_map_list)));
5017 map_list_ptr->map_list_name = xstrdup (dirname);
5018 map_list_ptr->map_list_map = NULL;
5020 dirlen = strlen (dirname);
5021 name = (char *) alloca (dirlen + strlen (FILE_NAME_MAP_FILE) + 1);
5022 strcpy (name, dirname);
5023 strcat (name, FILE_NAME_MAP_FILE);
5024 f = fopen (name, "r");
5026 map_list_ptr->map_list_map = NULL;
5031 while ((ch = getc (f)) != EOF)
5034 struct file_name_map *ptr;
5039 from = read_filename_string (ch, f);
5040 while ((ch = getc (f)) != EOF && is_hor_space[ch])
5042 to = read_filename_string (ch, f);
5044 simplify_filename (from);
5045 tolen = simplify_filename (to);
5047 ptr = ((struct file_name_map *)
5048 xmalloc (sizeof (struct file_name_map)));
5049 ptr->map_from = from;
5051 /* Make the real filename absolute. */
5052 if (absolute_filename (to))
5056 ptr->map_to = xmalloc (dirlen + tolen + 1);
5057 strcpy (ptr->map_to, dirname);
5058 strcat (ptr->map_to, to);
5062 ptr->map_next = map_list_ptr->map_list_map;
5063 map_list_ptr->map_list_map = ptr;
5065 while ((ch = getc (f)) != '\n')
5072 map_list_ptr->map_list_next = map_list;
5073 map_list = map_list_ptr;
5075 return map_list_ptr->map_list_map;
5078 /* Try to open include file FILENAME. SEARCHPTR is the directory
5079 being tried from the include file search path.
5080 IMPORTING is "" if we are importing, null otherwise.
5081 Return -2 if found, either a matching name or a matching inode.
5082 Otherwise, open the file and return a file descriptor if successful
5083 or -1 if unsuccessful.
5084 Unless unsuccessful, put a descriptor of the included file into *PINC.
5085 This function maps filenames on file systems based on information read by
5089 open_include_file (filename, searchptr, importing, pinc)
5091 struct file_name_list *searchptr;
5093 struct include_file **pinc;
5095 char *fname = remap ? remap_include_file (filename, searchptr) : filename;
5098 /* Look up FNAME in include_hashtab. */
5099 struct include_file **phead = &include_hashtab[hashf ((U_CHAR *) fname,
5102 struct include_file *inc, *head = *phead;
5103 for (inc = head; inc; inc = inc->next)
5104 if (!strcmp (fname, inc->fname))
5108 || ! inc->control_macro
5109 || (inc->control_macro[0] && ! lookup (inc->control_macro, -1, -1))) {
5111 fd = open (fname, O_RDONLY, 0);
5116 /* if #include <dir/file> fails, try again with hacked spec. */
5117 if (!hack_vms_include_specification (fname, 0))
5119 fd = open (fname, O_RDONLY, 0);
5126 /* FNAME was not in include_hashtab; insert a new entry. */
5127 inc = (struct include_file *) xmalloc (sizeof (struct include_file));
5130 inc->control_macro = 0;
5131 inc->deps_output = 0;
5132 if (fstat (fd, &inc->st) != 0)
5133 pfatal_with_name (fname);
5136 /* Look for another file with the same inode and device. */
5137 if (lookup_ino_include (inc)
5138 && inc->control_macro
5139 && (!inc->control_macro[0] || lookup (inc->control_macro, -1, -1))) {
5145 /* For -M, add this file to the dependencies. */
5146 if (! inc->deps_output && (system_include_depth != 0) < print_deps) {
5147 inc->deps_output = 1;
5148 deps_output (fname, ' ');
5151 /* Handle -H option. */
5152 if (print_include_names)
5153 fprintf (stderr, "%*s%s\n", indepth, "", fname);
5157 inc->control_macro = importing;
5163 /* Return the remapped name of the include file FILENAME.
5164 SEARCHPTR is the directory being tried from the include file path. */
5167 remap_include_file (filename, searchptr)
5169 struct file_name_list *searchptr;
5171 register struct file_name_map *map;
5172 register char *from;
5176 if (! searchptr->got_name_map)
5178 searchptr->name_map = read_name_map (searchptr->fname);
5179 searchptr->got_name_map = 1;
5182 /* Check the mapping for the directory we are using. */
5183 from = filename + strlen (searchptr->fname);
5184 for (map = searchptr->name_map; map; map = map->map_next)
5185 if (! strcmp (map->map_from, from))
5189 from = base_name (filename);
5191 if (from != filename || !searchptr)
5193 /* Try to find a mapping file for the particular directory we are
5194 looking in. Thus #include <sys/types.h> will look up sys/types.h
5195 in /usr/include/header.gcc and look up types.h in
5196 /usr/include/sys/header.gcc. */
5198 char *dir = (char *) alloca (from - filename + 1);
5199 bcopy (filename, dir, from - filename);
5200 dir[from - filename] = '\0';
5202 for (map = read_name_map (dir); map; map = map->map_next)
5203 if (! strcmp (map->map_from, from))
5210 /* Insert INC into the include file table, hashed by device and inode number.
5211 If a file with different name but same dev+ino was already in the table,
5212 return 1 and set INC's control macro to the already-known macro. */
5215 lookup_ino_include (inc)
5216 struct include_file *inc;
5218 int hash = ((unsigned) (inc->st.st_dev + INO_T_HASH (inc->st.st_ino))
5219 % INCLUDE_HASHSIZE);
5220 struct include_file *i = include_ino_hashtab[hash];
5222 include_ino_hashtab[hash] = inc;
5224 for (; i; i = i->next_ino)
5225 if (INO_T_EQ (inc->st.st_ino, i->st.st_ino)
5226 && inc->st.st_dev == i->st.st_dev) {
5227 inc->control_macro = i->control_macro;
5234 /* Process file descriptor F, which corresponds to include file INC,
5236 SYSTEM_HEADER_P is 1 if this file resides in any one of the known
5237 "system" include directories (as decided by the `is_system_include'
5239 DIRPTR is the link in the dir path through which this file was found,
5240 or 0 if the file name was absolute. */
5243 finclude (f, inc, op, system_header_p, dirptr)
5245 struct include_file *inc;
5247 int system_header_p;
5248 struct file_name_list *dirptr;
5250 char *fname = inc->fname;
5252 FILE_BUF *fp; /* For input stack frame */
5253 int missing_newline = 0;
5255 CHECK_DEPTH (return;);
5257 fp = &instack[indepth + 1];
5258 bzero ((char *) fp, sizeof (FILE_BUF));
5259 fp->nominal_fname = fp->fname = fname;
5260 fp->nominal_fname_len = strlen (fname);
5264 fp->if_stack = if_stack;
5265 fp->system_header_p = system_header_p;
5268 if (S_ISREG (inc->st.st_mode)) {
5269 size_t s = (size_t) inc->st.st_size;
5270 if (s != inc->st.st_size || s + 2 < s)
5272 fp->buf = (U_CHAR *) xmalloc (s + 2);
5275 /* Read the file contents, knowing that s is an upper bound
5276 on the number of bytes we can read. */
5277 fp->length = safe_read (f, (char *) fp->buf, s);
5278 if (fp->length < 0) goto nope;
5280 else if (S_ISDIR (inc->st.st_mode)) {
5281 error ("directory `%s' specified in #include", fname);
5285 /* Cannot count its file size before reading.
5286 First read the entire file into heap and
5287 copy them into buffer on stack. */
5292 fp->buf = (U_CHAR *) xmalloc (bsize + 2);
5295 i = safe_read (f, (char *) fp->buf + st_size, bsize - st_size);
5297 goto nope; /* error! */
5299 if (st_size != bsize)
5300 break; /* End of file */
5302 fp->buf = (U_CHAR *) xrealloc (fp->buf, bsize + 2);
5305 fp->length = st_size;
5308 if ((fp->length > 0 && fp->buf[fp->length - 1] != '\n')
5309 /* Backslash-newline at end is not good enough. */
5310 || (fp->length > 1 && fp->buf[fp->length - 2] == '\\')) {
5311 fp->buf[fp->length++] = '\n';
5312 missing_newline = 1;
5314 fp->buf[fp->length] = '\0';
5316 /* Close descriptor now, so nesting does not use lots of descriptors. */
5319 /* Must do this before calling trigraph_pcp, so that the correct file name
5320 will be printed in warning messages. */
5323 input_file_stack_tick++;
5328 if (warn_white_space)
5329 check_white_space (fp);
5331 output_line_directive (fp, op, 0, enter_file);
5334 if (missing_newline)
5337 if (pedantic && missing_newline)
5338 pedwarn ("file does not end in newline");
5341 input_file_stack_tick++;
5342 output_line_directive (&instack[indepth], op, 0, leave_file);
5348 perror_with_name (fname);
5353 /* Record that inclusion of the include file INC
5354 should be controlled by the macro named MACRO_NAME.
5355 This means that trying to include the file again
5356 will do something if that macro is defined. */
5359 record_control_macro (inc, macro_name)
5360 struct include_file *inc;
5363 if (!inc->control_macro || inc->control_macro[0])
5364 inc->control_macro = macro_name;
5367 /* Load the specified precompiled header into core, and verify its
5368 preconditions. PCF indicates the file descriptor to read, which must
5369 be a regular file. *ST is its file status.
5370 FNAME indicates the file name of the original header.
5371 *LIMIT will be set to an address one past the end of the file.
5372 If the preconditions of the file are not satisfied, the buffer is
5373 freed and we return 0. If the preconditions are satisfied, return
5374 the address of the buffer following the preconditions. The buffer, in
5375 this case, should never be freed because various pieces of it will
5376 be referred to until all precompiled strings are output at the end of
5380 check_precompiled (pcf, st, fname, limit)
5383 char *fname ATTRIBUTE_UNUSED;
5393 if (S_ISREG (st->st_mode))
5395 size_t s = (size_t) st->st_size;
5396 if (s != st->st_size || s + 2 < s)
5398 buf = xmalloc (s + 2);
5399 length = safe_read (pcf, buf, s);
5406 if (length > 0 && buf[length-1] != '\n')
5407 buf[length++] = '\n';
5410 *limit = buf + length;
5412 /* File is in core. Check the preconditions. */
5413 if (!check_preconditions (buf))
5415 for (cp = buf; *cp; cp++)
5418 fprintf (stderr, "Using preinclude %s\n", fname);
5424 fprintf (stderr, "Cannot use preinclude %s\n", fname);
5430 /* PREC (null terminated) points to the preconditions of a
5431 precompiled header. These are a series of #define and #undef
5432 lines which must match the current contents of the hash
5436 check_preconditions (prec)
5443 lineend = index (prec, '\n');
5445 if (*prec++ != '#') {
5446 error ("Bad format encountered while reading precompiled file");
5449 if (!strncmp (prec, "define", 6)) {
5453 mdef = create_definition ((U_CHAR *) prec, (U_CHAR *) lineend, NULL_PTR);
5458 if ((hp = lookup (mdef.symnam, mdef.symlen, -1)) == NULL
5459 || (hp->type != T_MACRO && hp->type != T_CONST)
5460 || (hp->type == T_MACRO
5461 && !compare_defs (mdef.defn, hp->value.defn)
5462 && (mdef.defn->length != 2
5463 || mdef.defn->expansion[0] != '\n'
5464 || mdef.defn->expansion[1] != ' ')))
5466 } else if (!strncmp (prec, "undef", 5)) {
5471 while (is_hor_space[(U_CHAR) *prec])
5474 while (is_idchar[(U_CHAR) *prec])
5478 if (lookup ((U_CHAR *) name, len, -1))
5481 error ("Bad format encountered while reading precompiled file");
5486 /* They all passed successfully */
5490 /* Process the main body of a precompiled file. BUF points to the
5491 string section of the file, following the preconditions. LIMIT is one
5492 character past the end. NAME is the name of the file being read
5493 in. OP is the main output buffer. */
5496 pcfinclude (buf, name, op)
5504 /* First in the file comes 4 bytes indicating the number of strings, */
5505 /* in network byte order. (MSB first). */
5507 nstrings = (nstrings << 8) | *cp++;
5508 nstrings = (nstrings << 8) | *cp++;
5509 nstrings = (nstrings << 8) | *cp++;
5511 /* Looping over each string... */
5512 while (nstrings--) {
5513 U_CHAR *string_start;
5514 U_CHAR *endofthiskey;
5518 /* Each string starts with a STRINGDEF structure (str), followed */
5519 /* by the text of the string (string_start) */
5521 /* First skip to a longword boundary */
5522 /* ??? Why a 4-byte boundary? On all machines? */
5523 /* NOTE: This works correctly even if size_t
5524 is narrower than a pointer.
5525 Do not try risky measures here to get another type to use!
5526 Do not include stddef.h--it will fail! */
5527 if ((size_t) cp & 3)
5528 cp += 4 - ((size_t) cp & 3);
5530 /* Now get the string. */
5531 str = (STRINGDEF *) (PTR) cp;
5532 string_start = cp += sizeof (STRINGDEF);
5534 for (; *cp; cp++) /* skip the string */
5537 /* We need to macro expand the string here to ensure that the
5538 proper definition environment is in place. If it were only
5539 expanded when we find out it is needed, macros necessary for
5540 its proper expansion might have had their definitions changed. */
5541 tmpbuf = expand_to_temp_buffer (string_start, cp++, 0, 0);
5542 /* Lineno is already set in the precompiled file */
5543 str->contents = tmpbuf.buf;
5544 str->len = tmpbuf.bufp - tmpbuf.buf;
5546 str->filename = name;
5547 str->output_mark = outbuf.bufp - outbuf.buf;
5550 *stringlist_tailp = str;
5551 stringlist_tailp = &str->chain;
5553 /* Next comes a fourbyte number indicating the number of keys
5556 nkeys = (nkeys << 8) | *cp++;
5557 nkeys = (nkeys << 8) | *cp++;
5558 nkeys = (nkeys << 8) | *cp++;
5560 /* If this number is -1, then the string is mandatory. */
5564 /* Otherwise, for each key, */
5565 for (; nkeys--; free (tmpbuf.buf), cp = endofthiskey + 1) {
5566 KEYDEF *kp = (KEYDEF *) (PTR) cp;
5570 /* It starts with a KEYDEF structure */
5571 cp += sizeof (KEYDEF);
5573 /* Find the end of the key. At the end of this for loop we
5574 advance CP to the start of the next key using this variable. */
5575 endofthiskey = cp + strlen ((char *) cp);
5578 /* Expand the key, and enter it into the hash table. */
5579 tmpbuf = expand_to_temp_buffer (cp, endofthiskey, 0, 0);
5582 while (is_hor_space[*bp])
5584 if (!is_idstart[*bp] || bp == tmpbuf.bufp) {
5589 hp = lookup (bp, -1, -1);
5592 install (bp, -1, T_PCSTRING, (char *) kp, -1);
5594 else if (hp->type == T_PCSTRING) {
5595 kp->chain = hp->value.keydef;
5596 hp->value.keydef = kp;
5602 /* This output_line_directive serves to switch us back to the current
5603 input file in case some of these strings get output (which will
5604 result in line directives for the header file being output). */
5605 output_line_directive (&instack[indepth], op, 0, enter_file);
5608 /* Called from rescan when it hits a key for strings. Mark them all
5609 used and clean up. */
5617 for (kp = hp->value.keydef; kp; kp = kp->chain)
5618 kp->str->writeflag = 1;
5622 /* Write the output, interspersing precompiled strings in their
5623 appropriate places. */
5628 STRINGDEF *next_string;
5629 U_CHAR *cur_buf_loc;
5630 int line_directive_len = 80;
5631 char *line_directive = xmalloc (line_directive_len);
5634 /* In each run through the loop, either cur_buf_loc ==
5635 next_string_loc, in which case we print a series of strings, or
5636 it is less than next_string_loc, in which case we write some of
5638 cur_buf_loc = outbuf.buf;
5639 next_string = stringlist;
5641 while (cur_buf_loc < outbuf.bufp || next_string) {
5643 && cur_buf_loc - outbuf.buf == next_string->output_mark) {
5644 if (next_string->writeflag) {
5645 len = 4 * strlen ((char *) next_string->filename) + 32;
5646 while (len > line_directive_len)
5647 line_directive = xrealloc (line_directive,
5648 line_directive_len *= 2);
5649 sprintf (line_directive, "\n# %d ", next_string->lineno);
5650 strcpy (quote_string (line_directive + strlen (line_directive),
5651 (char *) next_string->filename,
5652 strlen ((char *) next_string->filename)),
5654 safe_write (fileno (stdout), line_directive, strlen (line_directive));
5655 safe_write (fileno (stdout),
5656 (char *) next_string->contents, next_string->len);
5658 next_string = next_string->chain;
5662 ? (next_string->output_mark
5663 - (cur_buf_loc - outbuf.buf))
5664 : outbuf.bufp - cur_buf_loc);
5666 safe_write (fileno (stdout), (char *) cur_buf_loc, len);
5670 free (line_directive);
5673 /* Pass a directive through to the output file.
5674 BUF points to the contents of the directive, as a contiguous string.
5675 LIMIT points to the first character past the end of the directive.
5676 KEYWORD is the keyword-table entry for the directive. */
5679 pass_thru_directive (buf, limit, op, keyword)
5680 U_CHAR *buf, *limit;
5682 struct directive *keyword;
5684 register int keyword_length = keyword->length;
5686 check_expand (op, 1 + keyword_length + (limit - buf));
5688 bcopy (keyword->name, (char *) op->bufp, keyword_length);
5689 op->bufp += keyword_length;
5690 if (limit != buf && buf[0] != ' ')
5692 bcopy ((char *) buf, (char *) op->bufp, limit - buf);
5693 op->bufp += (limit - buf);
5696 /* Count the line we have just made in the output,
5697 to get in sync properly. */
5702 /* The arglist structure is built by do_define to tell
5703 collect_definition where the argument names begin. That
5704 is, for a define like "#define f(x,y,z) foo+x-bar*y", the arglist
5705 would contain pointers to the strings x, y, and z.
5706 Collect_definition would then build a DEFINITION node,
5707 with reflist nodes pointing to the places x, y, and z had
5708 appeared. So the arglist is just convenience data passed
5709 between these two routines. It is not kept around after
5710 the current #define has been processed and entered into the
5714 struct arglist *next;
5721 /* Create a DEFINITION node from a #define directive. Arguments are
5722 as for do_define. */
5725 create_definition (buf, limit, op)
5726 U_CHAR *buf, *limit;
5729 U_CHAR *bp; /* temp ptr into input buffer */
5730 U_CHAR *symname; /* remember where symbol name starts */
5731 int sym_length; /* and how long it is */
5732 int line = instack[indepth].lineno;
5733 char *file = instack[indepth].nominal_fname;
5734 size_t file_len = instack[indepth].nominal_fname_len;
5738 int arglengths = 0; /* Accumulate lengths of arg names
5739 plus number of args. */
5744 while (is_hor_space[*bp])
5747 symname = bp; /* remember where it starts */
5748 sym_length = check_macro_name (bp, 0);
5751 /* Lossage will occur if identifiers or control keywords are broken
5752 across lines using backslash. This is not the right place to take
5756 struct arglist *arg_ptrs = NULL;
5759 bp++; /* skip '(' */
5760 SKIP_WHITE_SPACE (bp);
5762 /* Loop over macro argument names. */
5763 while (*bp != ')') {
5764 struct arglist *temp;
5766 temp = (struct arglist *) alloca (sizeof (struct arglist));
5768 temp->next = arg_ptrs;
5769 temp->argno = argno++;
5770 temp->rest_args = 0;
5774 pedwarn ("another parameter follows `%s'",
5777 if (!is_idstart[*bp])
5779 if (c9x && limit - bp > (long) REST_EXTENSION_LENGTH
5780 && bcmp (rest_extension, bp, REST_EXTENSION_LENGTH) == 0)
5782 /* This is the ISO C 9x way to write macros with variable
5783 number of arguments. */
5785 temp->rest_args = 1;
5788 pedwarn ("invalid character in macro parameter name");
5791 /* Find the end of the arg name. */
5792 while (is_idchar[*bp]) {
5794 /* do we have a "special" rest-args extension here? */
5795 if (limit - bp > (long) REST_EXTENSION_LENGTH
5796 && bcmp (rest_extension, bp, REST_EXTENSION_LENGTH) == 0) {
5797 if (pedantic && !instack[indepth].system_header_p)
5798 pedwarn ("ANSI C does not allow macro with variable arguments");
5800 temp->rest_args = 1;
5804 if (bp == temp->name && rest_args == 1)
5806 /* This is the ISO C 9x style. */
5807 temp->name = (U_CHAR *) va_args_name;
5808 temp->length = VA_ARGS_NAME_LENGTH;
5811 temp->length = bp - temp->name;
5813 bp += REST_EXTENSION_LENGTH;
5814 arglengths += temp->length + 2;
5815 SKIP_WHITE_SPACE (bp);
5816 if (temp->length == 0 || (*bp != ',' && *bp != ')')) {
5817 error ("badly punctuated parameter list in `#define'");
5822 SKIP_WHITE_SPACE (bp);
5823 /* A comma at this point can only be followed by an identifier. */
5824 if (!is_idstart[*bp]
5825 && !(c9x && limit - bp > (long) REST_EXTENSION_LENGTH
5826 && bcmp (rest_extension, bp, REST_EXTENSION_LENGTH) == 0)) {
5827 error ("badly punctuated parameter list in `#define'");
5832 error ("unterminated parameter list in `#define'");
5836 struct arglist *otemp;
5838 for (otemp = temp->next; otemp != NULL; otemp = otemp->next)
5839 if (temp->length == otemp->length
5840 && bcmp (temp->name, otemp->name, temp->length) == 0)
5842 error ("duplicate argument name `%.*s' in `#define'",
5843 temp->length, temp->name);
5846 if (rest_args == 0 && temp->length == VA_ARGS_NAME_LENGTH
5847 && bcmp (temp->name, va_args_name, VA_ARGS_NAME_LENGTH) == 0)
5850 reserved name `%s' used as argument name in `#define'", va_args_name);
5856 ++bp; /* skip paren */
5857 SKIP_WHITE_SPACE (bp);
5858 /* now everything from bp before limit is the definition. */
5859 defn = collect_expansion (bp, limit, argno, arg_ptrs);
5860 defn->rest_args = rest_args;
5862 /* Now set defn->args.argnames to the result of concatenating
5863 the argument names in reverse order
5864 with comma-space between them. */
5865 defn->args.argnames = (U_CHAR *) xmalloc (arglengths + 1);
5867 struct arglist *temp;
5869 for (temp = arg_ptrs; temp; temp = temp->next) {
5870 bcopy (temp->name, &defn->args.argnames[i], temp->length);
5872 if (temp->next != 0) {
5873 defn->args.argnames[i++] = ',';
5874 defn->args.argnames[i++] = ' ';
5877 defn->args.argnames[i] = 0;
5880 /* Simple expansion or empty definition. */
5884 if (is_hor_space[*bp]) {
5886 SKIP_WHITE_SPACE (bp);
5887 } else if (sym_length) {
5889 case '!': case '"': case '#': case '%': case '&': case '\'':
5890 case ')': case '*': case '+': case ',': case '-': case '.':
5891 case '/': case ':': case ';': case '<': case '=': case '>':
5892 case '?': case '[': case '\\': case ']': case '^': case '{':
5893 case '|': case '}': case '~':
5894 warning ("missing white space after `#define %.*s'",
5895 sym_length, symname);
5899 pedwarn ("missing white space after `#define %.*s'",
5900 sym_length, symname);
5905 /* Now everything from bp before limit is the definition. */
5906 defn = collect_expansion (bp, limit, -1, NULL_PTR);
5907 defn->args.argnames = (U_CHAR *) "";
5912 defn->file_len = file_len;
5914 /* OP is null if this is a predefinition */
5915 defn->predefined = !op;
5917 mdef.symnam = symname;
5918 mdef.symlen = sym_length;
5927 /* Process a #define directive.
5928 BUF points to the contents of the #define directive, as a contiguous string.
5929 LIMIT points to the first character past the end of the definition.
5930 KEYWORD is the keyword-table entry for #define. */
5933 do_define (buf, limit, op, keyword)
5934 U_CHAR *buf, *limit;
5936 struct directive *keyword;
5940 enum node_type newtype = keyword->type == T_DEFINE ? T_MACRO : T_POISON;
5942 /* If this is a precompiler run (with -pcp) pass thru #define directives. */
5943 if (pcp_outfile && op)
5944 pass_thru_directive (buf, limit, op, keyword);
5946 mdef = create_definition (buf, limit, op);
5950 hashcode = hashf (mdef.symnam, mdef.symlen, HASHSIZE);
5954 if ((hp = lookup (mdef.symnam, mdef.symlen, hashcode)) != NULL) {
5956 /* Redefining a precompiled key is ok. */
5957 if (hp->type == T_PCSTRING)
5959 /* Redefining a poisoned identifier is even worse than `not ok'. */
5960 else if (hp->type == T_POISON)
5962 /* Poisoning anything else is not ok.
5963 The poison should always come first. */
5964 else if (newtype == T_POISON)
5966 /* Redefining a macro is ok if the definitions are the same. */
5967 else if (hp->type == T_MACRO)
5968 ok = ! compare_defs (mdef.defn, hp->value.defn);
5969 /* Redefining a constant is ok with -D. */
5970 else if (hp->type == T_CONST)
5971 ok = ! done_initializing;
5973 /* Print the warning or error if it's not ok. */
5976 /* If we are passing through #define and #undef directives, do
5977 that for this re-definition now. */
5978 if (debug_output && op)
5979 pass_thru_directive (buf, limit, op, keyword);
5981 if (hp->type == T_POISON)
5982 error ("redefining poisoned `%.*s'", mdef.symlen, mdef.symnam);
5984 pedwarn ("`%.*s' redefined", mdef.symlen, mdef.symnam);
5985 if (hp->type == T_MACRO)
5986 pedwarn_with_file_and_line (hp->value.defn->file,
5987 hp->value.defn->file_len,
5988 hp->value.defn->line,
5989 "this is the location of the previous definition");
5991 if (hp->type != T_POISON)
5993 /* Replace the old definition. */
5995 hp->value.defn = mdef.defn;
5998 /* If we are passing through #define and #undef directives, do
5999 that for this new definition now. */
6000 if (debug_output && op)
6001 pass_thru_directive (buf, limit, op, keyword);
6002 install (mdef.symnam, mdef.symlen, newtype,
6003 (char *) mdef.defn, hashcode);
6014 /* Check a purported macro name SYMNAME, and yield its length.
6015 ASSERTION is nonzero if this is really for an assertion name. */
6018 check_macro_name (symname, assertion)
6025 for (p = symname; is_idchar[*p]; p++)
6027 sym_length = p - symname;
6029 || (sym_length == 1 && *symname == 'L' && (*p == '\'' || *p == '"')))
6030 error (assertion ? "invalid assertion name" : "invalid macro name");
6031 else if (!is_idstart[*symname]
6032 || (sym_length == 7 && ! bcmp (symname, "defined", 7)))
6034 ? "invalid assertion name `%.*s'"
6035 : "invalid macro name `%.*s'"),
6036 sym_length, symname);
6040 /* Return zero if two DEFINITIONs are isomorphic. */
6043 compare_defs (d1, d2)
6044 DEFINITION *d1, *d2;
6046 register struct reflist *a1, *a2;
6047 register U_CHAR *p1 = d1->expansion;
6048 register U_CHAR *p2 = d2->expansion;
6051 if (d1->nargs != d2->nargs)
6054 && strcmp ((char *)d1->args.argnames, (char *)d2->args.argnames))
6056 for (a1 = d1->pattern, a2 = d2->pattern; a1 && a2;
6057 a1 = a1->next, a2 = a2->next) {
6058 if (!((a1->nchars == a2->nchars && ! bcmp (p1, p2, a1->nchars))
6059 || ! comp_def_part (first, p1, a1->nchars, p2, a2->nchars, 0))
6060 || a1->argno != a2->argno
6061 || a1->stringify != a2->stringify
6062 || a1->raw_before != a2->raw_before
6063 || a1->raw_after != a2->raw_after)
6071 if (comp_def_part (first, p1, d1->length - (p1 - d1->expansion),
6072 p2, d2->length - (p2 - d2->expansion), 1))
6077 /* Return 1 if two parts of two macro definitions are effectively different.
6078 One of the parts starts at BEG1 and has LEN1 chars;
6079 the other has LEN2 chars at BEG2.
6080 Any sequence of whitespace matches any other sequence of whitespace.
6081 FIRST means these parts are the first of a macro definition;
6082 so ignore leading whitespace entirely.
6083 LAST means these parts are the last of a macro definition;
6084 so ignore trailing whitespace entirely. */
6087 comp_def_part (first, beg1, len1, beg2, len2, last)
6089 U_CHAR *beg1, *beg2;
6093 register U_CHAR *end1 = beg1 + len1;
6094 register U_CHAR *end2 = beg2 + len2;
6096 while (beg1 != end1 && is_space[*beg1]) beg1++;
6097 while (beg2 != end2 && is_space[*beg2]) beg2++;
6100 while (beg1 != end1 && is_space[end1[-1]]) end1--;
6101 while (beg2 != end2 && is_space[end2[-1]]) end2--;
6103 while (beg1 != end1 && beg2 != end2) {
6104 if (is_space[*beg1] && is_space[*beg2]) {
6105 while (beg1 != end1 && is_space[*beg1]) beg1++;
6106 while (beg2 != end2 && is_space[*beg2]) beg2++;
6107 } else if (*beg1 == *beg2) {
6111 return (beg1 != end1) || (beg2 != end2);
6114 /* Read a replacement list for a macro with parameters.
6115 Build the DEFINITION structure.
6116 Reads characters of text starting at BUF until END.
6117 ARGLIST specifies the formal parameters to look for
6118 in the text of the definition; NARGS is the number of args
6119 in that list, or -1 for a macro name that wants no argument list.
6120 MACRONAME is the macro name itself (so we can avoid recursive expansion)
6121 and NAMELEN is its length in characters.
6123 Note that comments, backslash-newlines, and leading white space
6124 have already been deleted from the argument. */
6126 /* If there is no trailing whitespace, a Newline Space is added at the end
6127 to prevent concatenation that would be contrary to the standard. */
6130 collect_expansion (buf, end, nargs, arglist)
6133 struct arglist *arglist;
6136 register U_CHAR *p, *limit, *lastp, *exp_p;
6137 struct reflist *endpat = NULL;
6138 /* Pointer to first nonspace after last ## seen. */
6140 /* Pointer to first nonspace after last single-# seen. */
6141 U_CHAR *stringify = 0;
6142 /* How those tokens were spelled. */
6143 enum sharp_token_type concat_sharp_token_type = NO_SHARP_TOKEN;
6144 enum sharp_token_type stringify_sharp_token_type = NO_SHARP_TOKEN;
6146 int expected_delimiter = '\0';
6148 /* Scan thru the replacement list, ignoring comments and quoted
6149 strings, picking up on the macro calls. It does a linear search
6150 thru the arg list on every potential symbol. Profiling might say
6151 that something smarter should happen. */
6156 /* Find the beginning of the trailing whitespace. */
6159 while (p < limit && is_space[limit[-1]]) limit--;
6161 /* Allocate space for the text in the macro definition.
6162 Each input char may or may not need 1 byte,
6163 so this is an upper bound.
6164 The extra 3 are for invented trailing newline-marker and final null. */
6165 maxsize = (sizeof (DEFINITION)
6167 defn = (DEFINITION *) xcalloc (1, maxsize);
6169 defn->nargs = nargs;
6170 exp_p = defn->expansion = (U_CHAR *) defn + sizeof (DEFINITION);
6175 : p[0] == '%' && p[1] == ':' && p[2] == '%' && p[3] == ':') {
6176 error ("`##' at start of macro definition");
6177 p += p[0] == '#' ? 2 : 4;
6180 /* Process the main body of the definition. */
6182 int skipped_arg = 0;
6183 register U_CHAR c = *p++;
6191 if (expected_delimiter != '\0') {
6192 if (c == expected_delimiter)
6193 expected_delimiter = '\0';
6195 expected_delimiter = c;
6199 if (expected_delimiter) {
6200 /* In a string, backslash goes through
6201 and makes next char ordinary. */
6207 if (!expected_delimiter && *p == ':') {
6208 /* %: is not a digraph if preceded by an odd number of '<'s. */
6210 while (buf < p0 && p0[-1] == '<')
6213 /* Treat %:%: as ## and %: as #. */
6214 if (p[1] == '%' && p[2] == ':') {
6216 goto sharp_sharp_token;
6227 /* # is ordinary inside a string. */
6228 if (expected_delimiter)
6232 /* ##: concatenate preceding and following tokens. */
6233 /* Take out the first #, discard preceding whitespace. */
6235 while (exp_p > lastp && is_hor_space[exp_p[-1]])
6237 /* Skip the second #. */
6239 concat_sharp_token_type = c;
6240 if (is_hor_space[*p]) {
6241 concat_sharp_token_type = c + 1;
6243 SKIP_WHITE_SPACE (p);
6247 error ("`##' at end of macro definition");
6248 } else if (nargs >= 0) {
6249 /* Single #: stringify following argument ref.
6250 Don't leave the # in the expansion. */
6253 stringify_sharp_token_type = c;
6254 if (is_hor_space[*p]) {
6255 stringify_sharp_token_type = c + 1;
6257 SKIP_WHITE_SPACE (p);
6259 if (! is_idstart[*p] || nargs == 0
6260 || (*p == 'L' && (p[1] == '\'' || p[1] == '"')))
6261 error ("`#' operator is not followed by a macro argument name");
6268 /* In -traditional mode, recognize arguments inside strings and
6269 character constants, and ignore special properties of #.
6270 Arguments inside strings are considered "stringified", but no
6271 extra quote marks are supplied. */
6275 if (expected_delimiter != '\0') {
6276 if (c == expected_delimiter)
6277 expected_delimiter = '\0';
6279 expected_delimiter = c;
6283 /* Backslash quotes delimiters and itself, but not macro args. */
6284 if (expected_delimiter != 0 && p < limit
6285 && (*p == expected_delimiter || *p == '\\')) {
6292 if (expected_delimiter != '\0') /* No comments inside strings. */
6295 /* If we find a comment that wasn't removed by handle_directive,
6296 this must be -traditional. So replace the comment with
6299 while (++p < limit) {
6300 if (p[0] == '*' && p[1] == '/') {
6306 /* Mark this as a concatenation-point, as if it had been ##. */
6314 #ifdef MULTIBYTE_CHARS
6315 /* Handle multibyte characters inside string and character literals. */
6316 if (expected_delimiter != '\0')
6320 length = local_mblen (p, limit - p);
6324 bcopy (p, exp_p, length);
6333 /* Handle the start of a symbol. */
6334 if (is_idchar[c] && nargs > 0) {
6335 U_CHAR *id_beg = p - 1;
6339 while (p != limit && is_idchar[*p]) p++;
6340 id_len = p - id_beg;
6343 && ! (id_len == 1 && c == 'L' && (*p == '\'' || *p == '"'))) {
6344 register struct arglist *arg;
6346 for (arg = arglist; arg != NULL; arg = arg->next) {
6347 struct reflist *tpat;
6349 if (arg->name[0] == c
6350 && arg->length == id_len
6351 && bcmp (arg->name, id_beg, id_len) == 0) {
6352 enum sharp_token_type tpat_stringify;
6353 if (expected_delimiter) {
6354 if (warn_stringify) {
6356 warning ("macro argument `%.*s' is stringified.",
6359 warning ("macro arg `%.*s' would be stringified with -traditional.",
6363 /* If ANSI, don't actually substitute inside a string. */
6366 tpat_stringify = SHARP_TOKEN;
6369 = (stringify == id_beg
6370 ? stringify_sharp_token_type : NO_SHARP_TOKEN);
6372 /* make a pat node for this arg and append it to the end of
6374 tpat = (struct reflist *) xmalloc (sizeof (struct reflist));
6377 = concat == id_beg ? concat_sharp_token_type : NO_SHARP_TOKEN;
6378 tpat->raw_after = NO_SHARP_TOKEN;
6379 tpat->rest_args = arg->rest_args;
6380 tpat->stringify = tpat_stringify;
6383 defn->pattern = tpat;
6385 endpat->next = tpat;
6388 tpat->argno = arg->argno;
6389 tpat->nchars = exp_p - lastp;
6391 register U_CHAR *p1 = p;
6392 SKIP_WHITE_SPACE (p1);
6395 : p1[0]=='%' && p1[1]==':' && p1[2]=='%' && p1[3]==':')
6396 tpat->raw_after = p1[0] + (p != p1);
6398 lastp = exp_p; /* place to start copying from next time */
6405 /* If this was not a macro arg, copy it into the expansion. */
6406 if (! skipped_arg) {
6407 register U_CHAR *lim1 = p;
6411 if (stringify == id_beg)
6412 error ("`#' operator should be followed by a macro argument name");
6417 if (!traditional && expected_delimiter == 0) {
6418 /* If ANSI, put in a newline-space marker to prevent token pasting.
6419 But not if "inside a string" (which in ANSI mode happens only for
6427 defn->length = exp_p - defn->expansion;
6429 /* Crash now if we overrun the allocated size. */
6430 if (defn->length + 1 > maxsize)
6434 /* This isn't worth the time it takes. */
6435 /* give back excess storage */
6436 defn->expansion = (U_CHAR *) xrealloc (defn->expansion, defn->length + 1);
6443 do_assert (buf, limit, op, keyword)
6444 U_CHAR *buf, *limit;
6445 FILE_BUF *op ATTRIBUTE_UNUSED;
6446 struct directive *keyword ATTRIBUTE_UNUSED;
6448 U_CHAR *bp; /* temp ptr into input buffer */
6449 U_CHAR *symname; /* remember where symbol name starts */
6450 int sym_length; /* and how long it is */
6451 struct arglist *tokens = NULL;
6453 if (pedantic && done_initializing && !instack[indepth].system_header_p)
6454 pedwarn ("ANSI C does not allow `#assert'");
6458 while (is_hor_space[*bp])
6461 symname = bp; /* remember where it starts */
6462 sym_length = check_macro_name (bp, 1);
6464 /* #define doesn't do this, but we should. */
6465 SKIP_WHITE_SPACE (bp);
6467 /* Lossage will occur if identifiers or control tokens are broken
6468 across lines using backslash. This is not the right place to take
6472 error ("missing token-sequence in `#assert'");
6479 bp++; /* skip '(' */
6480 SKIP_WHITE_SPACE (bp);
6482 tokens = read_token_list (&bp, limit, &error_flag);
6486 error ("empty token-sequence in `#assert'");
6490 ++bp; /* skip paren */
6491 SKIP_WHITE_SPACE (bp);
6494 /* If this name isn't already an assertion name, make it one.
6495 Error if it was already in use in some other way. */
6498 ASSERTION_HASHNODE *hp;
6499 int hashcode = hashf (symname, sym_length, ASSERTION_HASHSIZE);
6500 struct tokenlist_list *value
6501 = (struct tokenlist_list *) xmalloc (sizeof (struct tokenlist_list));
6503 hp = assertion_lookup (symname, sym_length, hashcode);
6505 if (sym_length == 7 && ! bcmp (symname, "defined", 7))
6506 error ("`defined' redefined as assertion");
6507 hp = assertion_install (symname, sym_length, hashcode);
6510 /* Add the spec'd token-sequence to the list of such. */
6511 value->tokens = tokens;
6512 value->next = hp->value;
6520 do_unassert (buf, limit, op, keyword)
6521 U_CHAR *buf, *limit;
6522 FILE_BUF *op ATTRIBUTE_UNUSED;
6523 struct directive *keyword ATTRIBUTE_UNUSED;
6525 U_CHAR *bp; /* temp ptr into input buffer */
6526 U_CHAR *symname; /* remember where symbol name starts */
6527 int sym_length; /* and how long it is */
6529 struct arglist *tokens = NULL;
6530 int tokens_specified = 0;
6532 if (pedantic && done_initializing && !instack[indepth].system_header_p)
6533 pedwarn ("ANSI C does not allow `#unassert'");
6537 while (is_hor_space[*bp])
6540 symname = bp; /* remember where it starts */
6541 sym_length = check_macro_name (bp, 1);
6543 /* #define doesn't do this, but we should. */
6544 SKIP_WHITE_SPACE (bp);
6546 /* Lossage will occur if identifiers or control tokens are broken
6547 across lines using backslash. This is not the right place to take
6553 bp++; /* skip '(' */
6554 SKIP_WHITE_SPACE (bp);
6556 tokens = read_token_list (&bp, limit, &error_flag);
6560 error ("empty token list in `#unassert'");
6564 tokens_specified = 1;
6566 ++bp; /* skip paren */
6567 SKIP_WHITE_SPACE (bp);
6571 ASSERTION_HASHNODE *hp;
6572 int hashcode = hashf (symname, sym_length, ASSERTION_HASHSIZE);
6573 struct tokenlist_list *tail, *prev;
6575 hp = assertion_lookup (symname, sym_length, hashcode);
6579 /* If no token list was specified, then eliminate this assertion
6581 if (! tokens_specified) {
6582 struct tokenlist_list *next;
6583 for (tail = hp->value; tail; tail = next) {
6585 free_token_list (tail->tokens);
6588 delete_assertion (hp);
6590 /* If a list of tokens was given, then delete any matching list. */
6595 struct tokenlist_list *next = tail->next;
6596 if (compare_token_lists (tail->tokens, tokens)) {
6600 hp->value = tail->next;
6601 free_token_list (tail->tokens);
6614 /* Test whether there is an assertion named NAME
6615 and optionally whether it has an asserted token list TOKENS.
6616 NAME is not null terminated; its length is SYM_LENGTH.
6617 If TOKENS_SPECIFIED is 0, then don't check for any token list. */
6620 check_assertion (name, sym_length, tokens_specified, tokens)
6623 int tokens_specified;
6624 struct arglist *tokens;
6626 ASSERTION_HASHNODE *hp;
6627 int hashcode = hashf (name, sym_length, ASSERTION_HASHSIZE);
6629 if (pedantic && !instack[indepth].system_header_p)
6630 pedwarn ("ANSI C does not allow testing assertions");
6632 hp = assertion_lookup (name, sym_length, hashcode);
6634 /* It is not an assertion; just return false. */
6637 /* If no token list was specified, then value is 1. */
6638 if (! tokens_specified)
6642 struct tokenlist_list *tail;
6646 /* If a list of tokens was given,
6647 then succeed if the assertion records a matching list. */
6650 if (compare_token_lists (tail->tokens, tokens))
6655 /* Fail if the assertion has no matching list. */
6660 /* Compare two lists of tokens for equality including order of tokens. */
6663 compare_token_lists (l1, l2)
6664 struct arglist *l1, *l2;
6667 if (l1->length != l2->length)
6669 if (bcmp (l1->name, l2->name, l1->length))
6675 /* Succeed if both lists end at the same time. */
6679 /* Read a space-separated list of tokens ending in a close parenthesis.
6680 Return a list of strings, in the order they were written.
6681 (In case of error, return 0 and store -1 in *ERROR_FLAG.)
6682 Parse the text starting at *BPP, and update *BPP.
6683 Don't parse beyond LIMIT. */
6685 static struct arglist *
6686 read_token_list (bpp, limit, error_flag)
6691 struct arglist *token_ptrs = 0;
6697 /* Loop over the assertion value tokens. */
6699 struct arglist *temp;
6703 /* Find the end of the token. */
6707 } else if (*bp == ')') {
6712 } else if (*bp == '"' || *bp == '\'')
6713 bp = skip_quoted_string (bp, limit, 0, NULL_PTR, NULL_PTR, &eofp);
6715 while (! is_hor_space[*bp] && *bp != '(' && *bp != ')'
6716 && *bp != '"' && *bp != '\'' && bp != limit)
6719 temp = (struct arglist *) xmalloc (sizeof (struct arglist));
6720 temp->name = (U_CHAR *) xmalloc (bp - beg + 1);
6721 bcopy ((char *) beg, (char *) temp->name, bp - beg);
6722 temp->name[bp - beg] = 0;
6723 temp->next = token_ptrs;
6725 temp->length = bp - beg;
6727 SKIP_WHITE_SPACE (bp);
6730 error ("unterminated token sequence in `#assert' or `#unassert'");
6737 /* We accumulated the names in reverse order.
6738 Now reverse them to get the proper order. */
6740 register struct arglist *prev = 0, *this, *next;
6741 for (this = token_ptrs; this; this = next) {
6751 free_token_list (tokens)
6752 struct arglist *tokens;
6755 struct arglist *next = tokens->next;
6756 free (tokens->name);
6762 /* Install a name in the assertion hash table.
6764 If LEN is >= 0, it is the length of the name.
6765 Otherwise, compute the length by scanning the entire name.
6767 If HASH is >= 0, it is the precomputed hash code.
6768 Otherwise, compute the hash code. */
6770 static ASSERTION_HASHNODE *
6771 assertion_install (name, len, hash)
6776 register ASSERTION_HASHNODE *hp;
6777 register int i, bucket;
6778 register U_CHAR *p, *q;
6780 i = sizeof (ASSERTION_HASHNODE) + len + 1;
6781 hp = (ASSERTION_HASHNODE *) xmalloc (i);
6783 hp->bucket_hdr = &assertion_hashtab[bucket];
6784 hp->next = assertion_hashtab[bucket];
6785 assertion_hashtab[bucket] = hp;
6787 if (hp->next != NULL)
6788 hp->next->prev = hp;
6791 hp->name = ((U_CHAR *) hp) + sizeof (ASSERTION_HASHNODE);
6794 for (i = 0; i < len; i++)
6800 /* Find the most recent hash node for name "name" (ending with first
6801 non-identifier char) installed by install
6803 If LEN is >= 0, it is the length of the name.
6804 Otherwise, compute the length by scanning the entire name.
6806 If HASH is >= 0, it is the precomputed hash code.
6807 Otherwise, compute the hash code. */
6809 static ASSERTION_HASHNODE *
6810 assertion_lookup (name, len, hash)
6815 register ASSERTION_HASHNODE *bucket;
6817 bucket = assertion_hashtab[hash];
6819 if (bucket->length == len && bcmp (bucket->name, name, len) == 0)
6821 bucket = bucket->next;
6827 delete_assertion (hp)
6828 ASSERTION_HASHNODE *hp;
6831 if (hp->prev != NULL)
6832 hp->prev->next = hp->next;
6833 if (hp->next != NULL)
6834 hp->next->prev = hp->prev;
6836 /* Make sure that the bucket chain header that the deleted guy was
6837 on points to the right thing afterwards. */
6838 if (hp == *hp->bucket_hdr)
6839 *hp->bucket_hdr = hp->next;
6845 * interpret #line directive. Remembers previously seen fnames
6846 * in its very own hash table.
6848 #define FNAME_HASHSIZE 37
6851 do_line (buf, limit, op, keyword)
6852 U_CHAR *buf, *limit;
6854 struct directive *keyword ATTRIBUTE_UNUSED;
6856 register U_CHAR *bp;
6857 FILE_BUF *ip = &instack[indepth];
6860 enum file_change_code file_change = same_file;
6862 /* Expand any macros. */
6863 tem = expand_to_temp_buffer (buf, limit, 0, 0);
6865 /* Point to macroexpanded line, which is null-terminated now. */
6868 SKIP_WHITE_SPACE (bp);
6870 if (!ISDIGIT (*bp)) {
6871 error ("invalid format `#line' directive");
6875 /* The Newline at the end of this line remains to be processed.
6876 To put the next line at the specified line number,
6877 we must store a line number now that is one less. */
6878 new_lineno = atoi ((char *) bp) - 1;
6880 /* NEW_LINENO is one less than the actual line number here. */
6881 if (pedantic && new_lineno < 0)
6882 pedwarn ("line number out of range in `#line' directive");
6884 /* skip over the line number. */
6885 while (ISDIGIT (*bp))
6888 #if 0 /* #line 10"foo.c" is supposed to be allowed. */
6889 if (*bp && !is_space[*bp]) {
6890 error ("invalid format `#line' directive");
6895 SKIP_WHITE_SPACE (bp);
6898 static HASHNODE *fname_table[FNAME_HASHSIZE];
6899 HASHNODE *hp, **hash_bucket;
6905 /* Turn the file name, which is a character string literal,
6906 into a null-terminated string. Do this in place. */
6909 switch ((*p++ = *bp++)) {
6911 if (! ignore_escape_flag)
6913 char *bpc = (char *) bp;
6914 HOST_WIDEST_INT c = parse_escape (&bpc, (HOST_WIDEST_INT) (U_CHAR) (-1));
6915 bp = (U_CHAR *) bpc;
6928 fname_length = p - fname;
6930 SKIP_WHITE_SPACE (bp);
6933 pedwarn ("garbage at end of `#line' directive");
6935 file_change = enter_file;
6936 else if (*bp == '2')
6937 file_change = leave_file;
6938 else if (*bp == '3')
6939 ip->system_header_p = 1;
6940 else if (*bp == '4')
6941 ip->system_header_p = 2;
6943 error ("invalid format `#line' directive");
6948 SKIP_WHITE_SPACE (bp);
6950 ip->system_header_p = 1;
6952 SKIP_WHITE_SPACE (bp);
6955 ip->system_header_p = 2;
6957 SKIP_WHITE_SPACE (bp);
6960 error ("invalid format `#line' directive");
6965 hash_bucket = &fname_table[hashf (fname, fname_length, FNAME_HASHSIZE)];
6966 for (hp = *hash_bucket; hp != NULL; hp = hp->next)
6967 if (hp->length == fname_length &&
6968 bcmp (hp->value.cpval, fname, fname_length) == 0) {
6969 ip->nominal_fname = hp->value.cpval;
6970 ip->nominal_fname_len = fname_length;
6974 /* Didn't find it; cons up a new one. */
6975 hp = (HASHNODE *) xcalloc (1, sizeof (HASHNODE) + fname_length + 1);
6976 hp->next = *hash_bucket;
6979 ip->nominal_fname = hp->value.cpval = ((char *) hp) + sizeof (HASHNODE);
6980 ip->nominal_fname_len = hp->length = fname_length;
6981 bcopy (fname, hp->value.cpval, fname_length + 1);
6984 error ("invalid format `#line' directive");
6988 ip->lineno = new_lineno;
6989 output_line_directive (ip, op, 0, file_change);
6990 check_expand (op, ip->length - (ip->bufp - ip->buf));
6994 /* Remove the definition of a symbol from the symbol table.
6995 according to un*x /lib/cpp, it is not an error to undef
6996 something that has no definitions, so it isn't one here either. */
6999 do_undef (buf, limit, op, keyword)
7000 U_CHAR *buf, *limit;
7002 struct directive *keyword;
7006 U_CHAR *orig_buf = buf;
7008 /* If this is a precompiler run (with -pcp) pass thru #undef directives. */
7009 if (pcp_outfile && op)
7010 pass_thru_directive (buf, limit, op, keyword);
7012 SKIP_WHITE_SPACE (buf);
7013 sym_length = check_macro_name (buf, 0);
7015 while ((hp = lookup (buf, sym_length, -1)) != NULL) {
7016 /* If we are generating additional info for debugging (with -g) we
7017 need to pass through all effective #undef directives. */
7018 if (debug_output && op)
7019 pass_thru_directive (orig_buf, limit, op, keyword);
7020 if (hp->type == T_POISON)
7021 error ("cannot undefine poisoned `%s'", hp->name);
7023 if (hp->type != T_MACRO)
7024 warning ("undefining `%s'", hp->name);
7031 SKIP_WHITE_SPACE (buf);
7033 pedwarn ("garbage after `#undef' directive");
7039 /* Report an error detected by the program we are processing.
7040 Use the text of the line in the error message. */
7043 do_error (buf, limit, op, keyword)
7044 U_CHAR *buf, *limit;
7045 FILE_BUF *op ATTRIBUTE_UNUSED;
7046 struct directive *keyword;
7048 int length = limit - buf;
7049 U_CHAR *copy = (U_CHAR *) alloca (length + 1);
7050 bcopy ((char *) buf, (char *) copy, length);
7052 SKIP_WHITE_SPACE (copy);
7054 switch (keyword->type) {
7056 error ("#error %s", copy);
7060 if (pedantic && !instack[indepth].system_header_p)
7061 pedwarn ("ANSI C does not allow `#warning'");
7062 warning ("#warning %s", copy);
7071 /* Remember the name of the current file being read from so that we can
7072 avoid ever including it again. */
7079 for (i = indepth; i >= 0; i--)
7080 if (instack[i].inc) {
7081 record_control_macro (instack[i].inc, (U_CHAR *) "");
7086 /* Report program identification. */
7089 do_ident (buf, limit, op, keyword)
7090 U_CHAR *buf, *limit;
7092 struct directive *keyword ATTRIBUTE_UNUSED;
7097 /* Allow #ident in system headers, since that's not user's fault. */
7098 if (pedantic && !instack[indepth].system_header_p)
7099 pedwarn ("ANSI C does not allow `#ident'");
7101 trybuf = expand_to_temp_buffer (buf, limit, 0, 0);
7103 len = trybuf.bufp - buf;
7105 /* Output expanded directive. */
7106 check_expand (op, 7 + len);
7107 bcopy ("#ident ", (char *) op->bufp, 7);
7109 bcopy ((char *) buf, (char *) op->bufp, len);
7116 /* #pragma and its argument line have already been copied to the output file.
7117 Just check for some recognized pragmas that need validation here. */
7120 do_pragma (buf, limit, op, keyword)
7121 U_CHAR *buf, *limit;
7123 struct directive *keyword;
7125 SKIP_WHITE_SPACE (buf);
7126 if (!strncmp ((char *) buf, "once", 4)) {
7127 /* Allow #pragma once in system headers, since that's not the user's
7129 if (!instack[indepth].system_header_p)
7130 warning ("`#pragma once' is obsolete");
7134 if (!strncmp (buf, "poison", 6)) {
7135 /* Poison these symbols so that all subsequent usage produces an
7137 U_CHAR *p = buf + 6;
7139 SKIP_WHITE_SPACE (p);
7144 while (end < limit && is_idchar[*end])
7146 if (end < limit && !is_space[*end])
7148 error ("invalid #pragma poison");
7151 do_define(p, end, op, keyword);
7153 SKIP_WHITE_SPACE (p);
7157 if (!strncmp ((char *) buf, "implementation", 14)) {
7158 /* Be quiet about `#pragma implementation' for a file only if it hasn't
7159 been included yet. */
7162 U_CHAR *p = buf + 14, *fname;
7163 SKIP_WHITE_SPACE (p);
7168 p = skip_quoted_string (p, limit, 0, NULL_PTR, NULL_PTR, NULL_PTR);
7172 for (h = 0; h < INCLUDE_HASHSIZE; h++) {
7173 struct include_file *inc;
7174 for (inc = include_hashtab[h]; inc; inc = inc->next) {
7175 if (!strcmp (base_name (inc->fname), (char *) fname)) {
7176 warning ("`#pragma implementation' for \"%s\" appears after its #include",fname);
7186 /* This was a fun hack, but #pragma seems to start to be useful.
7187 By failing to recognize it, we pass it through unchanged to cc1. */
7189 /* The behavior of the #pragma directive is implementation defined.
7190 this implementation defines it as follows. */
7196 if (open ("/dev/tty", O_RDONLY, 0666) != 0)
7199 if (open ("/dev/tty", O_WRONLY, 0666) != 1)
7201 execl ("/usr/games/hack", "#pragma", 0);
7202 execl ("/usr/games/rogue", "#pragma", 0);
7203 execl ("/usr/new/emacs", "-f", "hanoi", "9", "-kill", 0);
7204 execl ("/usr/local/emacs", "-f", "hanoi", "9", "-kill", 0);
7206 fatal ("You are in a maze of twisty compiler features, all different");
7210 #ifdef SCCS_DIRECTIVE
7212 /* Just ignore #sccs, on systems where we define it at all. */
7215 do_sccs (buf, limit, op, keyword)
7216 U_CHAR *buf ATTRIBUTE_UNUSED, *limit ATTRIBUTE_UNUSED;
7217 FILE_BUF *op ATTRIBUTE_UNUSED;
7218 struct directive *keyword ATTRIBUTE_UNUSED;
7221 pedwarn ("ANSI C does not allow `#sccs'");
7225 #endif /* defined (SCCS_DIRECTIVE) */
7227 /* Handle #if directive by
7228 1) inserting special `defined' keyword into the hash table
7229 that gets turned into 0 or 1 by special_symbol (thus,
7230 if the luser has a symbol called `defined' already, it won't
7231 work inside the #if directive)
7232 2) rescan the input into a temporary output buffer
7233 3) pass the output buffer to the yacc parser and collect a value
7234 4) clean up the mess left from steps 1 and 2.
7235 5) call conditional_skip to skip til the next #endif (etc.),
7236 or not, depending on the value from step 3. */
7239 do_if (buf, limit, op, keyword)
7240 U_CHAR *buf, *limit;
7242 struct directive *keyword ATTRIBUTE_UNUSED;
7244 HOST_WIDEST_INT value;
7245 FILE_BUF *ip = &instack[indepth];
7247 value = eval_if_expression (buf, limit - buf);
7248 conditional_skip (ip, value == 0, T_IF, NULL_PTR, op);
7252 /* Handle a #elif directive by not changing if_stack either.
7253 see the comment above do_else. */
7256 do_elif (buf, limit, op, keyword)
7257 U_CHAR *buf, *limit;
7259 struct directive *keyword ATTRIBUTE_UNUSED;
7261 HOST_WIDEST_INT value;
7262 FILE_BUF *ip = &instack[indepth];
7264 if (if_stack == instack[indepth].if_stack) {
7265 error ("`#elif' not within a conditional");
7268 if (if_stack->type != T_IF && if_stack->type != T_ELIF) {
7269 error ("`#elif' after `#else'");
7270 fprintf (stderr, " (matches line %d", if_stack->lineno);
7271 if (! (if_stack->fname_len == ip->nominal_fname_len
7272 && !bcmp (if_stack->fname, ip->nominal_fname,
7273 if_stack->fname_len))) {
7274 fprintf (stderr, ", file ");
7275 fwrite (if_stack->fname, sizeof if_stack->fname[0],
7276 if_stack->fname_len, stderr);
7278 fprintf (stderr, ")\n");
7280 if_stack->type = T_ELIF;
7283 if (if_stack->if_succeeded)
7284 skip_if_group (ip, 0, op);
7286 value = eval_if_expression (buf, limit - buf);
7288 skip_if_group (ip, 0, op);
7290 ++if_stack->if_succeeded; /* continue processing input */
7291 output_line_directive (ip, op, 1, same_file);
7297 /* Evaluate a #if expression in BUF, of length LENGTH, then parse the
7298 result as a C expression and return the value as an int. */
7300 static HOST_WIDEST_INT
7301 eval_if_expression (buf, length)
7306 HASHNODE *save_defined;
7307 HOST_WIDEST_INT value;
7309 save_defined = install ((U_CHAR *) "defined", -1, T_SPEC_DEFINED,
7312 temp_obuf = expand_to_temp_buffer (buf, buf + length, 0, 1);
7314 delete_macro (save_defined); /* clean up special symbol */
7316 *temp_obuf.bufp = '\n';
7317 value = parse_c_expression ((char *) temp_obuf.buf,
7318 warn_undef && !instack[indepth].system_header_p);
7320 free (temp_obuf.buf);
7325 /* routine to handle ifdef/ifndef. Try to look up the symbol, then do
7326 or don't skip to the #endif/#else/#elif depending on what directive
7327 is actually being processed. */
7330 do_xifdef (buf, limit, op, keyword)
7331 U_CHAR *buf, *limit;
7333 struct directive *keyword;
7336 FILE_BUF *ip = &instack[indepth];
7338 int start_of_file = 0;
7339 U_CHAR *control_macro = 0;
7341 /* Detect a #ifndef at start of file (not counting comments). */
7342 if (ip->fname != 0 && keyword->type == T_IFNDEF) {
7343 U_CHAR *p = ip->buf;
7344 while (p != directive_start) {
7348 /* Make no special provision for backslash-newline here; this is
7349 slower if backslash-newlines are present, but it's correct,
7350 and it's not worth it to tune for the rare backslash-newline. */
7352 && (*p == '*' || (cplusplus_comments && *p == '/'))) {
7353 /* Skip this comment. */
7355 U_CHAR *save_bufp = ip->bufp;
7357 p = skip_to_end_of_comment (ip, &junk, 1);
7358 ip->bufp = save_bufp;
7363 /* If we get here, this conditional is the beginning of the file. */
7368 /* Discard leading and trailing whitespace. */
7369 SKIP_WHITE_SPACE (buf);
7370 while (limit != buf && is_hor_space[limit[-1]]) limit--;
7372 /* Find the end of the identifier at the beginning. */
7373 for (end = buf; is_idchar[*end]; end++);
7376 skip = (keyword->type == T_IFDEF);
7378 pedwarn (end == limit ? "`#%s' with no argument"
7379 : "`#%s' argument starts with punctuation",
7384 if (! traditional) {
7385 if (ISDIGIT (buf[0]))
7386 pedwarn ("`#%s' argument starts with a digit", keyword->name);
7387 else if (end != limit)
7388 pedwarn ("garbage at end of `#%s' argument", keyword->name);
7391 hp = lookup (buf, end-buf, -1);
7394 /* Output a precondition for this macro. */
7396 && (hp->type == T_CONST
7397 || (hp->type == T_MACRO && hp->value.defn->predefined)))
7398 fprintf (pcp_outfile, "#define %s\n", hp->name);
7401 fprintf (pcp_outfile, "#undef ");
7402 while (is_idchar[*cp]) /* Ick! */
7403 fputc (*cp++, pcp_outfile);
7404 putc ('\n', pcp_outfile);
7408 if ((hp != NULL) && (hp->type == T_POISON)) {
7409 error("attempt to use poisoned `%s'.", hp->name);
7412 skip = (hp == NULL) ^ (keyword->type == T_IFNDEF);
7413 if (start_of_file && !skip) {
7414 control_macro = (U_CHAR *) xmalloc (end - buf + 1);
7415 bcopy ((char *) buf, (char *) control_macro, end - buf);
7416 control_macro[end - buf] = 0;
7420 conditional_skip (ip, skip, T_IF, control_macro, op);
7424 /* Push TYPE on stack; then, if SKIP is nonzero, skip ahead.
7425 If this is a #ifndef starting at the beginning of a file,
7426 CONTROL_MACRO is the macro name tested by the #ifndef.
7427 Otherwise, CONTROL_MACRO is 0. */
7430 conditional_skip (ip, skip, type, control_macro, op)
7433 enum node_type type;
7434 U_CHAR *control_macro;
7437 IF_STACK_FRAME *temp;
7439 temp = (IF_STACK_FRAME *) xcalloc (1, sizeof (IF_STACK_FRAME));
7440 temp->fname = ip->nominal_fname;
7441 temp->fname_len = ip->nominal_fname_len;
7442 temp->lineno = ip->lineno;
7443 temp->next = if_stack;
7444 temp->control_macro = control_macro;
7447 if_stack->type = type;
7450 skip_if_group (ip, 0, op);
7453 ++if_stack->if_succeeded;
7454 output_line_directive (ip, &outbuf, 1, same_file);
7458 /* Skip to #endif, #else, or #elif. adjust line numbers, etc.
7459 Leaves input ptr at the sharp sign found.
7460 If ANY is nonzero, return at next directive of any sort. */
7463 skip_if_group (ip, any, op)
7468 register U_CHAR *bp = ip->bufp, *cp;
7469 register U_CHAR *endb = ip->buf + ip->length;
7470 struct directive *kt;
7471 IF_STACK_FRAME *save_if_stack = if_stack; /* don't pop past here */
7472 U_CHAR *beg_of_line = bp;
7473 register int ident_length;
7474 U_CHAR *ident, *after_ident;
7475 /* Save info about where the group starts. */
7476 U_CHAR *beg_of_group = bp;
7477 int beg_lineno = ip->lineno;
7478 int skipping_include_directive = 0;
7480 if (output_conditionals && op != 0) {
7481 char *ptr = "#failed\n";
7482 int len = strlen (ptr);
7484 if (op->bufp > op->buf && op->bufp[-1] != '\n')
7489 check_expand (op, len);
7490 bcopy (ptr, (char *) op->bufp, len);
7493 output_line_directive (ip, op, 1, 0);
7498 case '/': /* possible comment */
7502 || (cplusplus_comments && *bp == '/')) {
7504 bp = skip_to_end_of_comment (ip, &ip->lineno, 0);
7508 if (skipping_include_directive) {
7509 while (bp < endb && *bp != '>' && *bp != '\n') {
7510 if (*bp == '\\' && bp[1] == '\n') {
7519 if (skipping_include_directive) {
7520 while (bp < endb && *bp != '\n') {
7525 if (*bp == '\\' && bp[1] == '\n') {
7535 bp = skip_quoted_string (bp - 1, endb, ip->lineno, &ip->lineno,
7536 NULL_PTR, NULL_PTR);
7539 /* Char after backslash loses its special meaning in some cases. */
7543 } else if (traditional && bp < endb)
7549 skipping_include_directive = 0;
7552 if (beg_of_line == 0 || traditional)
7555 while (bp[0] == '\\' && bp[1] == '\n')
7561 /* # keyword: a # must be first nonblank char on the line */
7562 if (beg_of_line == 0)
7566 /* Scan from start of line, skipping whitespace, comments
7567 and backslash-newlines, and see if we reach this #.
7568 If not, this # is not special. */
7570 /* If -traditional, require # to be at beginning of line. */
7573 if (is_hor_space[*bp])
7575 else if (*bp == '\\' && bp[1] == '\n')
7577 else if (*bp == '/' && bp[1] == '*') {
7591 #ifdef MULTIBYTE_CHARS
7593 length = local_mblen (bp, endb - bp);
7601 /* There is no point in trying to deal with C++ // comments here,
7602 because if there is one, then this # must be part of the
7603 comment and we would never reach here. */
7607 if (bp != ip->bufp) {
7608 bp = ip->bufp + 1; /* Reset bp to after the #. */
7612 bp = ip->bufp + 1; /* Point after the '#' */
7613 if (ip->bufp[0] == '%') {
7614 /* Skip past the ':' again. */
7615 while (*bp == '\\') {
7622 /* Skip whitespace and \-newline. */
7624 if (is_hor_space[*bp])
7626 else if (*bp == '\\' && bp[1] == '\n')
7628 else if (*bp == '/') {
7630 newline_fix (bp + 1);
7632 for (bp += 2; ; bp++) {
7635 else if (*bp == '*') {
7636 if (bp[-1] == '/' && warn_comments)
7637 warning ("`/*' within comment");
7639 newline_fix (bp + 1);
7645 #ifdef MULTIBYTE_CHARS
7647 length = local_mblen (bp, endb - bp);
7654 } else if (bp[1] == '/' && cplusplus_comments) {
7655 for (bp += 2; ; bp++) {
7658 if (*bp == '\\' && bp[1] == '\n')
7661 warning ("multiline `//' comment");
7667 #ifdef MULTIBYTE_CHARS
7669 length = local_mblen (bp, endb - bp);
7683 /* Now find end of directive name.
7684 If we encounter a backslash-newline, exchange it with any following
7685 symbol-constituents so that we end up with a contiguous name. */
7692 name_newline_fix (bp);
7698 ident_length = bp - cp;
7702 /* A line of just `#' becomes blank. */
7704 if (ident_length == 0 && *after_ident == '\n') {
7708 if (ident_length == 0 || !is_idstart[*ident]) {
7710 while (is_idchar[*p]) {
7711 if (*p < '0' || *p > '9')
7715 /* Handle # followed by a line number. */
7716 if (p != ident && !is_idchar[*p]) {
7718 pedwarn ("`#' followed by integer");
7722 /* Avoid error for `###' and similar cases unless -pedantic. */
7724 while (*p == '#' || is_hor_space[*p]) p++;
7726 if (pedantic && !lang_asm)
7727 pedwarn ("invalid preprocessing directive");
7732 if (!lang_asm && pedantic)
7733 pedwarn ("invalid preprocessing directive name");
7737 for (kt = directive_table; kt->length >= 0; kt++) {
7738 IF_STACK_FRAME *temp;
7739 if (ident_length == kt->length
7740 && bcmp (cp, kt->name, kt->length) == 0) {
7741 /* If we are asked to return on next directive, do so now. */
7749 temp = (IF_STACK_FRAME *) xcalloc (1, sizeof (IF_STACK_FRAME));
7750 temp->next = if_stack;
7752 temp->lineno = ip->lineno;
7753 temp->fname = ip->nominal_fname;
7754 temp->fname_len = ip->nominal_fname_len;
7755 temp->type = kt->type;
7759 if (pedantic && if_stack != save_if_stack)
7760 validate_else (bp, endb);
7762 if (if_stack == instack[indepth].if_stack) {
7763 error ("`#%s' not within a conditional", kt->name);
7766 else if (if_stack == save_if_stack)
7767 goto done; /* found what we came for */
7769 if (kt->type != T_ENDIF) {
7770 if (if_stack->type == T_ELSE)
7771 error ("`#else' or `#elif' after `#else'");
7772 if_stack->type = kt->type;
7777 if_stack = if_stack->next;
7782 case T_INCLUDE_NEXT:
7784 skipping_include_directive = 1;
7793 /* Don't let erroneous code go by. */
7794 if (kt->length < 0 && !lang_asm && pedantic)
7795 pedwarn ("invalid preprocessing directive name");
7800 /* after this returns, rescan will exit because ip->bufp
7801 now points to the end of the buffer.
7802 rescan is responsible for the error message also. */
7805 if (output_conditionals && op != 0) {
7806 char *ptr = "#endfailed\n";
7807 int len = strlen (ptr);
7809 if (op->bufp > op->buf && op->bufp[-1] != '\n')
7814 check_expand (op, beg_of_line - beg_of_group);
7815 bcopy ((char *) beg_of_group, (char *) op->bufp,
7816 beg_of_line - beg_of_group);
7817 op->bufp += beg_of_line - beg_of_group;
7818 op->lineno += ip->lineno - beg_lineno;
7819 check_expand (op, len);
7820 bcopy (ptr, (char *) op->bufp, len);
7826 /* Handle a #else directive. Do this by just continuing processing
7827 without changing if_stack ; this is so that the error message
7828 for missing #endif's etc. will point to the original #if. It
7829 is possible that something different would be better. */
7832 do_else (buf, limit, op, keyword)
7833 U_CHAR *buf, *limit;
7835 struct directive *keyword ATTRIBUTE_UNUSED;
7837 FILE_BUF *ip = &instack[indepth];
7840 SKIP_WHITE_SPACE (buf);
7842 pedwarn ("text following `#else' violates ANSI standard");
7845 if (if_stack == instack[indepth].if_stack) {
7846 error ("`#else' not within a conditional");
7849 /* #ifndef can't have its special treatment for containing the whole file
7850 if it has a #else clause. */
7851 if_stack->control_macro = 0;
7853 if (if_stack->type != T_IF && if_stack->type != T_ELIF) {
7854 error ("`#else' after `#else'");
7855 fprintf (stderr, " (matches line %d", if_stack->lineno);
7856 if (! (if_stack->fname_len == ip->nominal_fname_len
7857 && !bcmp (if_stack->fname, ip->nominal_fname,
7858 if_stack->fname_len))) {
7859 fprintf (stderr, ", file ");
7860 fwrite (if_stack->fname, sizeof if_stack->fname[0],
7861 if_stack->fname_len, stderr);
7863 fprintf (stderr, ")\n");
7865 if_stack->type = T_ELSE;
7868 if (if_stack->if_succeeded)
7869 skip_if_group (ip, 0, op);
7871 ++if_stack->if_succeeded; /* continue processing input */
7872 output_line_directive (ip, op, 1, same_file);
7877 /* Unstack after #endif directive. */
7880 do_endif (buf, limit, op, keyword)
7881 U_CHAR *buf, *limit;
7883 struct directive *keyword ATTRIBUTE_UNUSED;
7886 SKIP_WHITE_SPACE (buf);
7888 pedwarn ("text following `#endif' violates ANSI standard");
7891 if (if_stack == instack[indepth].if_stack)
7892 error ("unbalanced `#endif'");
7894 IF_STACK_FRAME *temp = if_stack;
7895 if_stack = if_stack->next;
7896 if (temp->control_macro != 0) {
7897 /* This #endif matched a #ifndef at the start of the file.
7898 See if it is at the end of the file. */
7899 FILE_BUF *ip = &instack[indepth];
7900 U_CHAR *p = ip->bufp;
7901 U_CHAR *ep = ip->buf + ip->length;
7907 && (*p == '*' || (cplusplus_comments && *p == '/'))) {
7908 /* Skip this comment. */
7910 U_CHAR *save_bufp = ip->bufp;
7912 p = skip_to_end_of_comment (ip, &junk, 1);
7913 ip->bufp = save_bufp;
7918 /* If we get here, this #endif ends a #ifndef
7919 that contains all of the file (aside from whitespace).
7920 Arrange not to include the file again
7921 if the macro that was tested is defined.
7923 Do not do this for the top-level file in a -include or any
7924 file in a -imacros. */
7926 && ! (indepth == 1 && no_record_file)
7927 && ! (no_record_file && no_output))
7928 record_control_macro (ip->inc, temp->control_macro);
7932 output_line_directive (&instack[indepth], op, 1, same_file);
7937 /* When an #else or #endif is found while skipping failed conditional,
7938 if -pedantic was specified, this is called to warn about text after
7939 the directive name. P points to the first char after the directive
7943 validate_else (p, limit)
7945 register U_CHAR *limit;
7947 /* Advance P over whitespace and comments. */
7949 while (*p == '\\' && p[1] == '\n')
7951 if (is_hor_space[*p])
7953 else if (*p == '/') {
7954 while (p[1] == '\\' && p[2] == '\n')
7957 /* Don't bother warning about unterminated comments
7958 since that will happen later. Just be sure to exit. */
7959 for (p += 2; ; p++) {
7963 while (p[1] == '\\' && p[2] == '\n')
7972 #ifdef MULTIBYTE_CHARS
7974 length = local_mblen (p, limit - p);
7981 else if (cplusplus_comments && p[1] == '/')
7987 pedwarn ("text following `#else' or `#endif' violates ANSI standard");
7990 /* Skip a comment, assuming the input ptr immediately follows the
7991 initial slash-star. Bump *LINE_COUNTER for each newline.
7992 (The canonical line counter is &ip->lineno.)
7993 Don't use this routine (or the next one) if bumping the line
7994 counter is not sufficient to deal with newlines in the string.
7996 If NOWARN is nonzero, don't warn about slash-star inside a comment.
7997 This feature is useful when processing a comment that is going to
7998 be processed or was processed at another point in the preprocessor,
7999 to avoid a duplicate warning. Likewise for unterminated comment
8003 skip_to_end_of_comment (ip, line_counter, nowarn)
8004 register FILE_BUF *ip;
8005 int *line_counter; /* place to remember newlines, or NULL */
8008 register U_CHAR *limit = ip->buf + ip->length;
8009 register U_CHAR *bp = ip->bufp;
8010 FILE_BUF *op = put_out_comments && !line_counter ? &outbuf : (FILE_BUF *) 0;
8011 int start_line = line_counter ? *line_counter : 0;
8013 /* JF this line_counter stuff is a crock to make sure the
8014 comment is only put out once, no matter how many times
8015 the comment is skipped. It almost works */
8018 *op->bufp++ = bp[-1];
8020 if (cplusplus_comments && bp[-1] == '/') {
8021 for (; bp < limit; bp++) {
8024 if (*bp == '\\' && bp + 1 < limit && bp[1] == '\n')
8026 if (!nowarn && warn_comments)
8027 warning ("multiline `//' comment");
8039 #ifdef MULTIBYTE_CHARS
8041 length = local_mblen (bp, limit - bp);
8046 bcopy (bp, op->bufp, length - 1);
8047 op->bufp += (length - 1);
8059 while (bp < limit) {
8064 /* If this is the end of the file, we have an unterminated comment.
8065 Don't swallow the newline. We are guaranteed that there will be a
8066 trailing newline and various pieces assume it's there. */
8073 if (line_counter != NULL)
8079 if (bp[-2] == '/' && !nowarn && warn_comments)
8080 warning ("`/*' within comment");
8090 #ifdef MULTIBYTE_CHARS
8095 length = local_mblen (bp, limit - bp);
8101 bcopy (bp, op->bufp, length);
8111 error_with_line (line_for_error (start_line), "unterminated comment");
8116 /* Skip over a quoted string. BP points to the opening quote.
8117 Returns a pointer after the closing quote. Don't go past LIMIT.
8118 START_LINE is the line number of the starting point (but it need
8119 not be valid if the starting point is inside a macro expansion).
8121 The input stack state is not changed.
8123 If COUNT_NEWLINES is nonzero, it points to an int to increment
8124 for each newline passed; also, warn about any white space
8125 just before line end.
8127 If BACKSLASH_NEWLINES_P is nonzero, store 1 thru it
8128 if we pass a backslash-newline.
8130 If EOFP is nonzero, set *EOFP to 1 if the string is unterminated. */
8133 skip_quoted_string (bp, limit, start_line, count_newlines, backslash_newlines_p, eofp)
8134 register U_CHAR *bp;
8135 register U_CHAR *limit;
8137 int *count_newlines;
8138 int *backslash_newlines_p;
8141 register U_CHAR c, match;
8146 error_with_line (line_for_error (start_line),
8147 "unterminated string or character constant");
8148 error_with_line (multiline_string_line,
8149 "possible real start of unterminated constant");
8150 multiline_string_line = 0;
8157 while (*bp == '\\' && bp[1] == '\n') {
8158 if (backslash_newlines_p)
8159 *backslash_newlines_p = 1;
8165 if (backslash_newlines_p)
8166 *backslash_newlines_p = 1;
8171 } else if (c == '\n') {
8173 /* Unterminated strings and character constants are 'valid'. */
8174 bp--; /* Don't consume the newline. */
8179 if (match == '\'') {
8180 error_with_line (line_for_error (start_line),
8181 "unterminated character constant");
8187 /* If not traditional, then allow newlines inside strings. */
8188 if (count_newlines) {
8189 if (warn_white_space && is_hor_space[bp[-2]])
8190 warning ("white space at end of line in string");
8193 if (multiline_string_line == 0) {
8195 pedwarn_with_line (line_for_error (start_line),
8196 "string constant runs past end of line");
8197 multiline_string_line = start_line;
8199 } else if (c == match)
8201 #ifdef MULTIBYTE_CHARS
8205 length = local_mblen (bp, limit - bp);
8215 /* Place into DST a quoted string representing the string SRC.
8216 SRCLEN is the length of SRC; SRC may contain null bytes.
8217 Return the address of DST's terminating null. */
8220 quote_string (dst, src, srclen)
8225 char *srclim = src + srclen;
8228 while (src != srclim)
8229 switch ((c = *src++))
8236 sprintf (dst, "\\%03o", c);
8253 /* Skip across a group of balanced parens, starting from IP->bufp.
8254 IP->bufp is updated. Use this with IP->bufp pointing at an open-paren.
8256 This does not handle newlines, because it's used for the arg of #if,
8257 where there aren't any newlines. Also, backslash-newline can't appear. */
8260 skip_paren_group (ip)
8261 register FILE_BUF *ip;
8263 U_CHAR *limit = ip->buf + ip->length;
8264 U_CHAR *p = ip->bufp;
8266 int lines_dummy = 0;
8268 while (p != limit) {
8278 return ip->bufp = p;
8284 p = skip_to_end_of_comment (ip, &lines_dummy, 0);
8292 p = skip_quoted_string (p - 1, limit, 0, NULL_PTR, NULL_PTR, &eofp);
8294 return ip->bufp = p;
8304 /* Write out a #line directive, for instance, after an #include file.
8305 If CONDITIONAL is nonzero, we can omit the #line if it would
8306 appear to be a no-op, and we can output a few newlines instead
8307 if we want to increase the line number by a small amount.
8308 FILE_CHANGE says whether we are entering a file, leaving, or neither. */
8311 output_line_directive (ip, op, conditional, file_change)
8314 enum file_change_code file_change;
8317 char *line_directive_buf, *line_end;
8319 if (no_line_directives
8320 || ip->fname == NULL
8322 op->lineno = ip->lineno;
8327 if (ip->lineno == op->lineno)
8330 /* If the inherited line number is a little too small,
8331 output some newlines instead of a #line directive. */
8332 if (ip->lineno > op->lineno && ip->lineno < op->lineno + 8) {
8333 check_expand (op, 10);
8334 while (ip->lineno > op->lineno) {
8342 /* Output a positive line number if possible. */
8343 while (ip->lineno <= 0 && ip->bufp - ip->buf < ip->length
8344 && *ip->bufp == '\n') {
8349 line_directive_buf = (char *) alloca (4 * ip->nominal_fname_len + 100);
8350 sprintf (line_directive_buf, "# %d ", ip->lineno);
8351 line_end = quote_string (line_directive_buf + strlen (line_directive_buf),
8352 ip->nominal_fname, ip->nominal_fname_len);
8353 if (file_change != same_file) {
8355 *line_end++ = file_change == enter_file ? '1' : '2';
8357 /* Tell cc1 if following text comes from a system header file. */
8358 if (ip->system_header_p) {
8362 #ifndef NO_IMPLICIT_EXTERN_C
8363 /* Tell cc1plus if following text should be treated as C. */
8364 if (ip->system_header_p == 2 && cplusplus) {
8370 len = line_end - line_directive_buf;
8371 check_expand (op, len + 1);
8372 if (op->bufp > op->buf && op->bufp[-1] != '\n')
8374 bcopy ((char *) line_directive_buf, (char *) op->bufp, len);
8376 op->lineno = ip->lineno;
8379 /* This structure represents one parsed argument in a macro call.
8380 `raw' points to the argument text as written (`raw_length' is its length).
8381 `expanded' points to the argument's macro-expansion
8382 (its length is `expand_length', and its allocated size is `expand_size').
8383 `stringified_length_bound' is an upper bound on the length
8384 the argument would have if stringified.
8385 `use_count' is the number of times this macro arg is substituted
8386 into the macro. If the actual use count exceeds 10,
8387 the value stored is 10.
8388 `free1' and `free2', if nonzero, point to blocks to be freed
8389 when the macro argument data is no longer needed. */
8392 U_CHAR *raw, *expanded;
8393 int raw_length, expand_length, expand_size;
8394 int stringified_length_bound;
8395 U_CHAR *free1, *free2;
8400 /* Expand a macro call.
8401 HP points to the symbol that is the macro being called.
8402 Put the result of expansion onto the input stack
8403 so that subsequent input by our caller will use it.
8405 If macro wants arguments, caller has already verified that
8406 an argument list follows; arguments come from the input stack. */
8409 macroexpand (hp, op)
8414 DEFINITION *defn = hp->value.defn;
8415 register U_CHAR *xbuf;
8417 int start_line = instack[indepth].lineno;
8418 int rest_args, rest_zero;
8420 CHECK_DEPTH (return;);
8422 /* it might not actually be a macro. */
8423 if (hp->type != T_MACRO) {
8424 special_symbol (hp, op);
8428 /* This macro is being used inside a #if, which means it must be */
8429 /* recorded as a precondition. */
8430 if (pcp_inside_if && pcp_outfile && defn->predefined)
8431 dump_single_macro (hp, pcp_outfile);
8433 nargs = defn->nargs;
8437 struct argdata *args;
8438 int parse_error = 0;
8440 args = (struct argdata *) alloca ((nargs + 1) * sizeof (struct argdata));
8442 for (i = 0; i < nargs; i++) {
8443 args[i].raw = (U_CHAR *) "";
8444 args[i].expanded = 0;
8445 args[i].raw_length = args[i].expand_length = args[i].expand_size
8446 = args[i].stringified_length_bound = 0;
8447 args[i].free1 = args[i].free2 = 0;
8448 args[i].use_count = 0;
8451 /* Parse all the macro args that are supplied. I counts them.
8452 The first NARGS args are stored in ARGS.
8453 The rest are discarded.
8454 If rest_args is set then we assume macarg absorbed the rest of the args.
8459 /* Discard the open-parenthesis or comma before the next arg. */
8460 ++instack[indepth].bufp;
8463 if (i < nargs || (nargs == 0 && i == 0)) {
8464 /* If we are working on last arg which absorbs rest of args... */
8465 if (i == nargs - 1 && defn->rest_args)
8467 parse_error = macarg (&args[i], rest_args);
8470 parse_error = macarg (NULL_PTR, 0);
8472 error_with_line (line_for_error (start_line),
8473 "unterminated macro call");
8477 } while (*instack[indepth].bufp != ')');
8479 /* If we got one arg but it was just whitespace, call that 0 args. */
8481 register U_CHAR *bp = args[0].raw;
8482 register U_CHAR *lim = bp + args[0].raw_length;
8483 /* cpp.texi says for foo ( ) we provide one argument.
8484 However, if foo wants just 0 arguments, treat this as 0. */
8486 while (bp != lim && is_space[*bp]) bp++;
8491 /* Don't output an error message if we have already output one for
8492 a parse error above. */
8494 if (nargs == 0 && i > 0) {
8496 error ("arguments given to macro `%s'", hp->name);
8497 } else if (i < nargs) {
8498 /* traditional C allows foo() if foo wants one argument. */
8499 if (nargs == 1 && i == 0 && traditional)
8501 /* the rest args token is allowed to absorb 0 tokens */
8502 else if (i == nargs - 1 && defn->rest_args)
8504 else if (parse_error)
8507 error ("macro `%s' used without args", hp->name);
8509 error ("macro `%s' used with just one arg", hp->name);
8511 error ("macro `%s' used with only %d args", hp->name, i);
8512 } else if (i > nargs) {
8514 error ("macro `%s' used with too many (%d) args", hp->name, i);
8517 /* Swallow the closeparen. */
8518 ++instack[indepth].bufp;
8520 /* If macro wants zero args, we parsed the arglist for checking only.
8521 Read directly from the macro definition. */
8523 xbuf = defn->expansion;
8524 xbuf_len = defn->length;
8526 register U_CHAR *exp = defn->expansion;
8527 register int offset; /* offset in expansion,
8528 copied a piece at a time */
8529 register int totlen; /* total amount of exp buffer filled so far */
8531 register struct reflist *ap, *last_ap;
8533 /* Macro really takes args. Compute the expansion of this call. */
8535 /* Compute length in characters of the macro's expansion.
8536 Also count number of times each arg is used. */
8537 xbuf_len = defn->length;
8538 for (ap = defn->pattern; ap != NULL; ap = ap->next) {
8540 xbuf_len += args[ap->argno].stringified_length_bound;
8541 else if (ap->raw_before != 0 || ap->raw_after != 0 || traditional)
8542 /* Add 4 for two newline-space markers to prevent
8543 token concatenation. */
8544 xbuf_len += args[ap->argno].raw_length + 4;
8546 /* We have an ordinary (expanded) occurrence of the arg.
8547 So compute its expansion, if we have not already. */
8548 if (args[ap->argno].expanded == 0) {
8550 obuf = expand_to_temp_buffer (args[ap->argno].raw,
8551 args[ap->argno].raw + args[ap->argno].raw_length,
8554 args[ap->argno].expanded = obuf.buf;
8555 args[ap->argno].expand_length = obuf.bufp - obuf.buf;
8556 args[ap->argno].expand_size = obuf.length;
8557 args[ap->argno].free2 = obuf.buf;
8559 xbuf_len += args[ap->argno].expand_length;
8561 /* If the arg appears more than once, its later occurrences
8562 may have newline turned into backslash-'n', which is a
8563 factor of 2 expansion. */
8564 xbuf_len += 2 * args[ap->argno].expand_length;
8566 /* Add 4 for two newline-space markers to prevent
8567 token concatenation. */
8570 if (args[ap->argno].use_count < 10)
8571 args[ap->argno].use_count++;
8574 xbuf = (U_CHAR *) xmalloc (xbuf_len + 1);
8576 /* Generate in XBUF the complete expansion
8577 with arguments substituted in.
8578 TOTLEN is the total size generated so far.
8579 OFFSET is the index in the definition
8580 of where we are copying from. */
8581 offset = totlen = 0;
8582 for (last_ap = NULL, ap = defn->pattern; ap != NULL;
8583 last_ap = ap, ap = ap->next) {
8584 register struct argdata *arg = &args[ap->argno];
8585 int count_before = totlen;
8587 /* Add chars to XBUF. */
8588 for (i = 0; i < ap->nchars; i++, offset++)
8589 xbuf[totlen++] = exp[offset];
8591 /* If followed by an empty rest arg with concatenation,
8592 delete the last run of nonwhite chars. */
8593 if (rest_zero && totlen > count_before
8594 && ((ap->rest_args && ap->raw_before != 0)
8595 || (last_ap != NULL && last_ap->rest_args
8596 && last_ap->raw_after != 0))) {
8597 /* Delete final whitespace. */
8598 while (totlen > count_before && is_space[xbuf[totlen - 1]]) {
8602 /* Delete the nonwhites before them. */
8603 while (totlen > count_before && ! is_space[xbuf[totlen - 1]]) {
8608 if (ap->stringify != 0) {
8609 int arglen = arg->raw_length;
8615 && (c = arg->raw[i], is_space[c]))
8618 && (c = arg->raw[arglen - 1], is_space[c]))
8621 xbuf[totlen++] = '\"'; /* insert beginning quote */
8622 for (; i < arglen; i++) {
8626 /* Generate nothing for backslash-newline in a string. */
8627 if (c == '\\' && arg->raw[i + 1] == '\n') {
8633 generate nothing for a stringified argument. */
8639 /* Internal sequences of whitespace are replaced by one space
8640 except within a string or char token. */
8643 while (is_space[(c = arg->raw[i])])
8644 /* Newline markers can occur within a whitespace sequence;
8645 consider them part of the sequence. */
8646 i += (c == '\n') + 1;
8657 else if (in_string) {
8662 #ifdef MULTIBYTE_CHARS
8664 length = local_mblen (arg->raw + i, arglen - i);
8667 bcopy (arg->raw + i, xbuf + totlen, length);
8674 } else if (c == '\"' || c == '\'')
8678 /* Escape double-quote, and backslashes in strings.
8679 Newlines in strings are best escaped as \n, since
8680 otherwise backslash-backslash-newline-newline is
8681 mishandled. The C Standard doesn't allow newlines in
8682 strings, so we can escape newlines as we please. */
8686 || (c == '\n' ? (c = 'n', 1) : 0))))
8687 xbuf[totlen++] = '\\';
8688 /* We used to output e.g. \008 for control characters here,
8689 but this doesn't conform to the C Standard.
8690 Just output the characters as-is. */
8694 xbuf[totlen++] = '\"'; /* insert ending quote */
8695 } else if (ap->raw_before != 0 || ap->raw_after != 0 || traditional) {
8696 U_CHAR *p1 = arg->raw;
8697 U_CHAR *l1 = p1 + arg->raw_length;
8698 if (ap->raw_before != 0) {
8699 while (p1 != l1 && is_space[*p1]) p1++;
8700 while (p1 != l1 && is_idchar[*p1])
8701 xbuf[totlen++] = *p1++;
8702 /* Delete any no-reexpansion marker that follows
8703 an identifier at the beginning of the argument
8704 if the argument is concatenated with what precedes it. */
8705 if (p1[0] == '\n' && p1[1] == '-')
8707 } else if (!traditional) {
8708 /* Ordinary expanded use of the argument.
8709 Put in newline-space markers to prevent token pasting. */
8710 xbuf[totlen++] = '\n';
8711 xbuf[totlen++] = ' ';
8713 if (ap->raw_after != 0) {
8714 /* Arg is concatenated after: delete trailing whitespace,
8715 whitespace markers, and no-reexpansion markers. */
8717 if (is_space[l1[-1]]) l1--;
8718 else if (l1[-1] == '-') {
8719 U_CHAR *p2 = l1 - 1;
8720 /* If a `-' is preceded by an odd number of newlines then it
8721 and the last newline are a no-reexpansion marker. */
8722 while (p2 != p1 && p2[-1] == '\n') p2--;
8723 if ((l1 - 1 - p2) & 1) {
8732 bcopy ((char *) p1, (char *) (xbuf + totlen), l1 - p1);
8734 if (!traditional && ap->raw_after == 0) {
8735 /* Ordinary expanded use of the argument.
8736 Put in newline-space markers to prevent token pasting. */
8737 xbuf[totlen++] = '\n';
8738 xbuf[totlen++] = ' ';
8741 /* Ordinary expanded use of the argument.
8742 Put in newline-space markers to prevent token pasting. */
8744 xbuf[totlen++] = '\n';
8745 xbuf[totlen++] = ' ';
8747 bcopy ((char *) arg->expanded, (char *) (xbuf + totlen),
8748 arg->expand_length);
8749 totlen += arg->expand_length;
8751 xbuf[totlen++] = '\n';
8752 xbuf[totlen++] = ' ';
8754 /* If a macro argument with newlines is used multiple times,
8755 then only expand the newlines once. This avoids creating output
8756 lines which don't correspond to any input line, which confuses
8758 if (arg->use_count > 1 && arg->newlines > 0) {
8759 /* Don't bother doing change_newlines for subsequent
8762 change_newlines (arg);
8766 if (totlen > xbuf_len)
8770 /* If there is anything left of the definition after handling
8771 the arg list, copy that in too. */
8773 for (i = offset; i < defn->length; i++) {
8774 /* if we've reached the end of the macro */
8777 if (! (rest_zero && last_ap != NULL && last_ap->rest_args
8778 && last_ap->raw_after != 0))
8779 xbuf[totlen++] = exp[i];
8785 for (i = 0; i < nargs; i++) {
8786 if (args[i].free1 != 0)
8787 free (args[i].free1);
8788 if (args[i].free2 != 0)
8789 free (args[i].free2);
8793 xbuf = defn->expansion;
8794 xbuf_len = defn->length;
8797 /* Now put the expansion on the input stack
8798 so our caller will commence reading from it. */
8800 register FILE_BUF *ip2;
8802 ip2 = &instack[++indepth];
8805 ip2->nominal_fname = 0;
8806 ip2->nominal_fname_len = 0;
8808 /* This may not be exactly correct, but will give much better error
8809 messages for nested macro calls than using a line number of zero. */
8810 ip2->lineno = start_line;
8812 ip2->length = xbuf_len;
8814 ip2->free_ptr = (nargs > 0) ? xbuf : 0;
8816 ip2->if_stack = if_stack;
8817 ip2->system_header_p = 0;
8819 /* Recursive macro use sometimes works traditionally.
8820 #define foo(x,y) bar (x (y,0), y)
8824 hp->type = T_DISABLED;
8828 /* Parse a macro argument and store the info on it into *ARGPTR.
8829 REST_ARGS is passed to macarg1 to make it absorb the rest of the args.
8830 Return nonzero to indicate a syntax error. */
8833 macarg (argptr, rest_args)
8834 register struct argdata *argptr;
8837 FILE_BUF *ip = &instack[indepth];
8839 int lineno0 = ip->lineno;
8843 /* Try to parse as much of the argument as exists at this
8844 input stack level. */
8845 U_CHAR *bp = macarg1 (ip->bufp, ip->buf + ip->length, ip->macro,
8846 &paren, &ip->lineno, &comments, rest_args);
8848 /* If we find the end of the argument at this level,
8849 set up *ARGPTR to point at it in the input stack. */
8850 if (!(ip->fname != 0 && (ip->lineno != lineno0 || comments != 0))
8851 && bp != ip->buf + ip->length) {
8853 argptr->raw = ip->bufp;
8854 argptr->raw_length = bp - ip->bufp;
8855 argptr->newlines = ip->lineno - lineno0;
8859 /* This input stack level ends before the macro argument does.
8860 We must pop levels and keep parsing.
8861 Therefore, we must allocate a temporary buffer and copy
8862 the macro argument into it. */
8863 int bufsize = bp - ip->bufp;
8864 int extra = ip->lineno - lineno0;
8865 U_CHAR *buffer = (U_CHAR *) xmalloc (bufsize + extra + 1);
8866 int final_start = 0;
8868 bcopy ((char *) ip->bufp, (char *) buffer, bufsize);
8871 while (bp == ip->buf + ip->length) {
8872 if (instack[indepth].macro == 0) {
8876 ip->macro->type = T_MACRO;
8878 free (ip->free_ptr);
8879 ip = &instack[--indepth];
8880 lineno0 = ip->lineno;
8882 bp = macarg1 (ip->bufp, ip->buf + ip->length, ip->macro, &paren,
8883 &ip->lineno, &comments, rest_args);
8884 final_start = bufsize;
8885 bufsize += bp - ip->bufp;
8886 extra += ip->lineno - lineno0;
8887 buffer = (U_CHAR *) xrealloc (buffer, bufsize + extra + 1);
8888 bcopy ((char *) ip->bufp, (char *) (buffer + bufsize - (bp - ip->bufp)),
8893 /* Now, if arg is actually wanted, record its raw form,
8894 discarding comments and duplicating newlines in whatever
8895 part of it did not come from a macro expansion.
8896 EXTRA space has been preallocated for duplicating the newlines.
8897 FINAL_START is the index of the start of that part. */
8899 argptr->raw = buffer;
8900 argptr->raw_length = bufsize;
8901 argptr->free1 = buffer;
8902 argptr->newlines = ip->lineno - lineno0;
8903 if ((argptr->newlines || comments) && ip->fname != 0)
8906 discard_comments (argptr->raw + final_start,
8907 argptr->raw_length - final_start,
8909 argptr->raw[argptr->raw_length] = 0;
8910 if (argptr->raw_length > bufsize + extra)
8915 /* If we are not discarding this argument,
8916 macroexpand it and compute its length as stringified.
8917 All this info goes into *ARGPTR. */
8920 register U_CHAR *buf, *lim;
8921 register int totlen;
8924 lim = buf + argptr->raw_length;
8926 while (buf != lim && is_space[*buf])
8928 while (buf != lim && is_space[lim[-1]])
8930 totlen = traditional ? 0 : 2; /* Count opening and closing quote. */
8931 while (buf != lim) {
8932 register U_CHAR c = *buf++;
8934 /* Internal sequences of whitespace are replaced by one space
8935 in most cases, but not always. So count all the whitespace
8936 in case we need to keep it all. */
8939 SKIP_ALL_WHITE_SPACE (buf);
8942 if (c == '\"' || c == '\\' || c == '\n') /* escape these chars */
8945 argptr->stringified_length_bound = totlen;
8950 /* Scan text from START (inclusive) up to LIMIT (exclusive),
8951 taken from the expansion of MACRO,
8952 counting parens in *DEPTHPTR,
8953 and return if reach LIMIT
8954 or before a `)' that would make *DEPTHPTR negative
8955 or before a comma when *DEPTHPTR is zero.
8956 Single and double quotes are matched and termination
8957 is inhibited within them. Comments also inhibit it.
8958 Value returned is pointer to stopping place.
8960 Increment *NEWLINES each time a newline is passed.
8961 REST_ARGS notifies macarg1 that it should absorb the rest of the args.
8962 Set *COMMENTS to 1 if a comment is seen. */
8965 macarg1 (start, limit, macro, depthptr, newlines, comments, rest_args)
8967 register U_CHAR *limit;
8968 struct hashnode *macro;
8969 int *depthptr, *newlines, *comments;
8972 register U_CHAR *bp = start;
8974 while (bp < limit) {
8980 if (--(*depthptr) < 0)
8984 /* Traditionally, backslash makes following char not special. */
8985 if (traditional && bp + 1 < limit && bp[1] != '\n')
8995 newline_fix (bp + 1);
8998 for (bp += 2; bp < limit; bp++) {
9001 else if (*bp == '*') {
9002 if (bp[-1] == '/' && warn_comments)
9003 warning ("`/*' within comment");
9005 newline_fix (bp + 1);
9013 #ifdef MULTIBYTE_CHARS
9015 length = local_mblen (bp, limit - bp);
9021 } else if (bp[1] == '/' && cplusplus_comments) {
9023 for (bp += 2; bp < limit; bp++) {
9028 if (*bp == '\\' && bp + 1 < limit && bp[1] == '\n')
9032 warning ("multiline `//' comment");
9037 #ifdef MULTIBYTE_CHARS
9039 length = local_mblen (bp, limit - bp);
9051 for (quotec = *bp++; bp < limit && *bp != quotec; bp++) {
9056 while (*bp == '\\' && bp[1] == '\n') {
9060 } else if (*bp == '\n') {
9061 if (warn_white_space && is_hor_space[bp[-1]] && ! macro)
9062 warning ("white space at end of line in string");
9069 #ifdef MULTIBYTE_CHARS
9071 length = local_mblen (bp, limit - bp);
9080 /* if we've returned to lowest level and we aren't absorbing all args */
9081 if ((*depthptr) == 0 && rest_args == 0)
9091 /* Discard comments and duplicate newlines
9092 in the string of length LENGTH at START,
9093 except inside of string constants.
9094 The string is copied into itself with its beginning staying fixed.
9096 NEWLINES is the number of newlines that must be duplicated.
9097 We assume that that much extra space is available past the end
9101 discard_comments (start, length, newlines)
9106 register U_CHAR *ibp;
9107 register U_CHAR *obp;
9108 register U_CHAR *limit;
9111 /* If we have newlines to duplicate, copy everything
9112 that many characters up. Then, in the second part,
9113 we will have room to insert the newlines
9115 NEWLINES may actually be too large, because it counts
9116 newlines in string constants, and we don't duplicate those.
9117 But that does no harm. */
9119 ibp = start + length;
9120 obp = ibp + newlines;
9122 while (limit != ibp)
9126 ibp = start + newlines;
9127 limit = start + length + newlines;
9130 while (ibp < limit) {
9131 *obp++ = c = *ibp++;
9134 /* Duplicate the newline. */
9148 /* Delete any comment. */
9149 if (cplusplus_comments && ibp[0] == '/') {
9150 /* Comments are equivalent to spaces. */
9157 if (*ibp == '\\' && ibp + 1 < limit && ibp[1] == '\n')
9161 #ifdef MULTIBYTE_CHARS
9162 int length = local_mblen (ibp, limit - ibp);
9164 ibp += (length - 1);
9171 if (ibp[0] != '*' || ibp + 1 >= limit)
9173 /* Comments are equivalent to spaces.
9174 For -traditional, a comment is equivalent to nothing. */
9179 while (++ibp < limit) {
9180 if (ibp[0] == '*') {
9182 newline_fix (ibp + 1);
9183 if (ibp[1] == '/') {
9190 #ifdef MULTIBYTE_CHARS
9191 int length = local_mblen (ibp, limit - ibp);
9193 ibp += (length - 1);
9201 /* Notice and skip strings, so that we don't
9202 think that comments start inside them,
9203 and so we don't duplicate newlines in them. */
9206 while (ibp < limit) {
9207 *obp++ = c = *ibp++;
9215 else if (c == '\\') {
9216 if (ibp < limit && *ibp == '\n') {
9220 while (*ibp == '\\' && ibp[1] == '\n')
9228 #ifdef MULTIBYTE_CHARS
9231 length = local_mblen (ibp, limit - ibp);
9235 bcopy (ibp, obp, length);
9252 /* Turn newlines to spaces in the macro argument ARG.
9253 Remove backslash-newline from string constants,
9254 and turn other newlines in string constants to backslash-'n'. */
9257 change_newlines (arg)
9258 struct argdata *arg;
9260 U_CHAR *start = arg->expanded;
9261 int length = arg->expand_length;
9262 register U_CHAR *ibp;
9263 register U_CHAR *obp;
9264 register U_CHAR *limit;
9268 limit = start + length;
9271 while (ibp < limit) {
9272 *obp++ = c = *ibp++;
9275 /* If this is a NEWLINE NEWLINE, then this is a real newline in the
9276 string. Skip past the newline and its duplicate.
9277 Put a space in the output. */
9288 /* Notice and skip strings, so that we don't delete newlines in them. */
9291 while (ibp < limit) {
9292 *obp++ = c = *ibp++;
9295 else if (c == '\\' && ibp < limit && *ibp == '\n')
9304 #ifdef MULTIBYTE_CHARS
9307 length = local_mblen (ibp, limit - ibp);
9311 bcopy (ibp, obp, length);
9325 arg->expand_length = obp - arg->expanded;
9327 if (start != arg->expanded)
9331 /* notice - output message to stderr */
9334 notice VPROTO ((const char * msgid, ...))
9336 #ifndef ANSI_PROTOTYPES
9341 VA_START (args, msgid);
9343 #ifndef ANSI_PROTOTYPES
9344 msgid = va_arg (args, const char *);
9347 vnotice (msgid, args);
9352 vnotice (msgid, args)
9356 vfprintf (stderr, _(msgid), args);
9359 /* error - print error message and increment count of errors. */
9362 error VPROTO ((const char * msgid, ...))
9364 #ifndef ANSI_PROTOTYPES
9369 VA_START (args, msgid);
9371 #ifndef ANSI_PROTOTYPES
9372 msgid = va_arg (args, const char *);
9375 verror (msgid, args);
9380 verror (msgid, args)
9385 FILE_BUF *ip = NULL;
9387 print_containing_files ();
9389 for (i = indepth; i >= 0; i--)
9390 if (instack[i].fname != NULL) {
9396 fwrite (ip->nominal_fname, sizeof ip->nominal_fname[0],
9397 ip->nominal_fname_len, stderr);
9398 fprintf (stderr, ":%d: ", ip->lineno);
9400 vnotice (msgid, args);
9401 fprintf (stderr, "\n");
9405 /* Error including a message from `errno'. */
9408 error_from_errno (name)
9413 FILE_BUF *ip = NULL;
9415 print_containing_files ();
9417 for (i = indepth; i >= 0; i--)
9418 if (instack[i].fname != NULL) {
9424 fwrite (ip->nominal_fname, sizeof ip->nominal_fname[0],
9425 ip->nominal_fname_len, stderr);
9426 fprintf (stderr, ":%d: ", ip->lineno);
9429 fprintf (stderr, "%s: %s\n", name, xstrerror (e));
9434 /* Print error message but don't count it. */
9437 warning VPROTO ((const char * msgid, ...))
9439 #ifndef ANSI_PROTOTYPES
9444 VA_START (args, msgid);
9446 #ifndef ANSI_PROTOTYPES
9447 msgid = va_arg (args, const char *);
9450 vwarning (msgid, args);
9455 vwarning (msgid, args)
9460 FILE_BUF *ip = NULL;
9462 if (inhibit_warnings)
9465 if (warnings_are_errors)
9468 print_containing_files ();
9470 for (i = indepth; i >= 0; i--)
9471 if (instack[i].fname != NULL) {
9477 fwrite (ip->nominal_fname, sizeof ip->nominal_fname[0],
9478 ip->nominal_fname_len, stderr);
9479 fprintf (stderr, ":%d: ", ip->lineno);
9481 notice ("warning: ");
9482 vnotice (msgid, args);
9483 fprintf (stderr, "\n");
9487 error_with_line VPROTO ((int line, const char * msgid, ...))
9489 #ifndef ANSI_PROTOTYPES
9495 VA_START (args, msgid);
9497 #ifndef ANSI_PROTOTYPES
9498 line = va_arg (args, int);
9499 msgid = va_arg (args, const char *);
9502 verror_with_line (line, msgid, args);
9508 verror_with_line (line, msgid, args)
9514 FILE_BUF *ip = NULL;
9516 print_containing_files ();
9518 for (i = indepth; i >= 0; i--)
9519 if (instack[i].fname != NULL) {
9525 fwrite (ip->nominal_fname, sizeof ip->nominal_fname[0],
9526 ip->nominal_fname_len, stderr);
9527 fprintf (stderr, ":%d: ", line);
9529 vnotice (msgid, args);
9530 fprintf (stderr, "\n");
9535 warning_with_line VPROTO ((int line, const char * msgid, ...))
9537 #ifndef ANSI_PROTOTYPES
9543 VA_START (args, msgid);
9545 #ifndef ANSI_PROTOTYPES
9546 line = va_arg (args, int);
9547 msgid = va_arg (args, const char *);
9550 vwarning_with_line (line, msgid, args);
9555 vwarning_with_line (line, msgid, args)
9561 FILE_BUF *ip = NULL;
9563 if (inhibit_warnings)
9566 if (warnings_are_errors)
9569 print_containing_files ();
9571 for (i = indepth; i >= 0; i--)
9572 if (instack[i].fname != NULL) {
9578 fwrite (ip->nominal_fname, sizeof ip->nominal_fname[0],
9579 ip->nominal_fname_len, stderr);
9580 fprintf (stderr, line ? ":%d: " : ": ", line);
9582 notice ("warning: ");
9583 vnotice (msgid, args);
9584 fprintf (stderr, "\n");
9587 /* Print an error message and maybe count it. */
9590 pedwarn VPROTO ((const char * msgid, ...))
9592 #ifndef ANSI_PROTOTYPES
9597 VA_START (args, msgid);
9599 #ifndef ANSI_PROTOTYPES
9600 msgid = va_arg (args, const char *);
9603 if (pedantic_errors)
9604 verror (msgid, args);
9606 vwarning (msgid, args);
9611 pedwarn_with_line VPROTO ((int line, const char * msgid, ...))
9613 #ifndef ANSI_PROTOTYPES
9619 VA_START (args, msgid);
9621 #ifndef ANSI_PROTOTYPES
9622 line = va_arg (args, int);
9623 msgid = va_arg (args, const char *);
9626 if (pedantic_errors)
9627 verror_with_line (line, msgid, args);
9629 vwarning_with_line (line, msgid, args);
9633 /* Report a warning (or an error if pedantic_errors)
9634 giving specified file name and line number, not current. */
9637 pedwarn_with_file_and_line VPROTO ((const char *file, size_t file_len, int line,
9638 const char * msgid, ...))
9640 #ifndef ANSI_PROTOTYPES
9648 if (!pedantic_errors && inhibit_warnings)
9651 VA_START (args, msgid);
9653 #ifndef ANSI_PROTOTYPES
9654 file = va_arg (args, const char *);
9655 file_len = va_arg (args, size_t);
9656 line = va_arg (args, int);
9657 msgid = va_arg (args, const char *);
9661 fwrite (file, sizeof file[0], file_len, stderr);
9662 fprintf (stderr, ":%d: ", line);
9664 if (pedantic_errors)
9666 if (!pedantic_errors)
9667 notice ("warning: ");
9668 vnotice (msgid, args);
9670 fprintf (stderr, "\n");
9674 pedwarn_strange_white_space (ch)
9679 case '\f': pedwarn ("formfeed in preprocessing directive"); break;
9680 case '\r': pedwarn ("carriage return in preprocessing directive"); break;
9681 case '\v': pedwarn ("vertical tab in preprocessing directive"); break;
9686 /* Print the file names and line numbers of the #include
9687 directives which led to the current file. */
9690 print_containing_files ()
9692 FILE_BUF *ip = NULL;
9696 /* If stack of files hasn't changed since we last printed
9697 this info, don't repeat it. */
9698 if (last_error_tick == input_file_stack_tick)
9701 for (i = indepth; i >= 0; i--)
9702 if (instack[i].fname != NULL) {
9707 /* Give up if we don't find a source file. */
9711 /* Find the other, outer source files. */
9712 for (i--; i >= 0; i--)
9713 if (instack[i].fname != NULL) {
9717 notice ( "In file included from ");
9719 notice (",\n from ");
9722 fwrite (ip->nominal_fname, sizeof ip->nominal_fname[0],
9723 ip->nominal_fname_len, stderr);
9724 fprintf (stderr, ":%d", ip->lineno);
9727 fprintf (stderr, ":\n");
9729 /* Record we have printed the status as of this time. */
9730 last_error_tick = input_file_stack_tick;
9733 /* Return the line at which an error occurred.
9734 The error is not necessarily associated with the current spot
9735 in the input stack, so LINE says where. LINE will have been
9736 copied from ip->lineno for the current input level.
9737 If the current level is for a file, we return LINE.
9738 But if the current level is not for a file, LINE is meaningless.
9739 In that case, we return the lineno of the innermost file. */
9742 line_for_error (line)
9748 for (i = indepth; i >= 0; ) {
9749 if (instack[i].fname != 0)
9754 line1 = instack[i].lineno;
9762 * If OBUF doesn't have NEEDED bytes after OPTR, make it bigger.
9764 * As things stand, nothing is ever placed in the output buffer to be
9765 * removed again except when it's KNOWN to be part of an identifier,
9766 * so flushing and moving down everything left, instead of expanding,
9770 /* You might think void was cleaner for the return type,
9771 but that would get type mismatch in check_expand in strict ANSI. */
9774 grow_outbuf (obuf, needed)
9775 register FILE_BUF *obuf;
9776 register int needed;
9781 if (obuf->length - (obuf->bufp - obuf->buf) > needed)
9784 /* Make it at least twice as big as it is now. */
9786 /* Make it have at least 150% of the free space we will need. */
9787 minsize = (3 * needed) / 2 + (obuf->bufp - obuf->buf);
9788 if (minsize > obuf->length)
9789 obuf->length = minsize;
9791 p = (U_CHAR *) xrealloc (obuf->buf, obuf->length);
9793 obuf->bufp = p + (obuf->bufp - obuf->buf);
9799 /* Symbol table for macro names and special symbols */
9802 * install a name in the main hash table, even if it is already there.
9803 * name stops with first non alphanumeric, except leading '#'.
9804 * caller must check against redefinition if that is desired.
9805 * delete_macro () removes things installed by install () in fifo order.
9806 * this is important because of the `defined' special symbol used
9807 * in #if, and also if pushdef/popdef directives are ever implemented.
9809 * If LEN is >= 0, it is the length of the name.
9810 * Otherwise, compute the length by scanning the entire name.
9812 * If HASH is >= 0, it is the precomputed hash code.
9813 * Otherwise, compute the hash code.
9817 install (name, len, type, value, hash)
9820 enum node_type type;
9824 register HASHNODE *hp;
9825 register int i, bucket;
9826 register U_CHAR *p, *q;
9830 while (is_idchar[*p])
9836 hash = hashf (name, len, HASHSIZE);
9838 i = sizeof (HASHNODE) + len + 1;
9839 hp = (HASHNODE *) xmalloc (i);
9841 hp->bucket_hdr = &hashtab[bucket];
9842 hp->next = hashtab[bucket];
9843 hashtab[bucket] = hp;
9845 if (hp->next != NULL)
9846 hp->next->prev = hp;
9849 hp->value.cpval = value;
9850 hp->name = ((U_CHAR *) hp) + sizeof (HASHNODE);
9853 for (i = 0; i < len; i++)
9860 * find the most recent hash node for name "name" (ending with first
9861 * non-identifier char) installed by install
9863 * If LEN is >= 0, it is the length of the name.
9864 * Otherwise, compute the length by scanning the entire name.
9866 * If HASH is >= 0, it is the precomputed hash code.
9867 * Otherwise, compute the hash code.
9871 lookup (name, len, hash)
9876 register U_CHAR *bp;
9877 register HASHNODE *bucket;
9880 for (bp = name; is_idchar[*bp]; bp++) ;
9885 hash = hashf (name, len, HASHSIZE);
9887 bucket = hashtab[hash];
9889 if (bucket->length == len && bcmp (bucket->name, name, len) == 0)
9891 bucket = bucket->next;
9897 * Delete a hash node. Some weirdness to free junk from macros.
9898 * More such weirdness will have to be added if you define more hash
9899 * types that need it.
9902 /* Note that the DEFINITION of a macro is removed from the hash table
9903 but its storage is not freed. This would be a storage leak
9904 except that it is not reasonable to keep undefining and redefining
9905 large numbers of macros many times.
9906 In any case, this is necessary, because a macro can be #undef'd
9907 in the middle of reading the arguments to a call to it.
9908 If #undef freed the DEFINITION, that would crash. */
9915 if (hp->prev != NULL)
9916 hp->prev->next = hp->next;
9917 if (hp->next != NULL)
9918 hp->next->prev = hp->prev;
9920 /* Make sure that the bucket chain header that the deleted guy was
9921 on points to the right thing afterwards. */
9922 if (hp == *hp->bucket_hdr)
9923 *hp->bucket_hdr = hp->next;
9926 if (hp->type == T_MACRO) {
9927 DEFINITION *d = hp->value.defn;
9928 struct reflist *ap, *nextap;
9930 for (ap = d->pattern; ap != NULL; ap = nextap) {
9941 * return hash function on name. must be compatible with the one
9942 * computed a step at a time, elsewhere
9946 hashf (name, len, hashsize)
9947 register U_CHAR *name;
9954 r = HASHSTEP (r, *name++);
9956 return MAKE_POS (r) % hashsize;
9960 /* Dump the definition of a single macro HP to OF. */
9963 dump_single_macro (hp, of)
9964 register HASHNODE *hp;
9967 register DEFINITION *defn = hp->value.defn;
9973 /* Print the definition of the macro HP. */
9975 fprintf (of, "#define %s", hp->name);
9977 if (defn->nargs >= 0) {
9981 for (i = 0; i < defn->nargs; i++) {
9982 dump_arg_n (defn, i, of);
9983 if (i + 1 < defn->nargs)
9993 for (ap = defn->pattern; ap != NULL; ap = ap->next) {
9994 dump_defn_1 (defn->expansion, offset, ap->nchars, of);
9995 offset += ap->nchars;
9997 if (ap->nchars != 0)
9999 if (ap->stringify) {
10000 switch (ap->stringify) {
10001 case SHARP_TOKEN: fprintf (of, "#"); break;
10002 case WHITE_SHARP_TOKEN: fprintf (of, "# "); break;
10003 case PERCENT_COLON_TOKEN: fprintf (of, "%%:"); break;
10004 case WHITE_PERCENT_COLON_TOKEN: fprintf (of, "%%: "); break;
10008 if (ap->raw_before != 0) {
10010 switch (ap->raw_before) {
10011 case WHITE_SHARP_TOKEN:
10012 case WHITE_PERCENT_COLON_TOKEN:
10019 switch (ap->raw_before) {
10020 case SHARP_TOKEN: fprintf (of, "##"); break;
10021 case WHITE_SHARP_TOKEN: fprintf (of, "## "); break;
10022 case PERCENT_COLON_TOKEN: fprintf (of, "%%:%%:"); break;
10023 case WHITE_PERCENT_COLON_TOKEN: fprintf (of, "%%:%%: "); break;
10030 dump_arg_n (defn, ap->argno, of);
10031 if (!traditional && ap->raw_after != 0) {
10032 switch (ap->raw_after) {
10033 case SHARP_TOKEN: fprintf (of, "##"); break;
10034 case WHITE_SHARP_TOKEN: fprintf (of, " ##"); break;
10035 case PERCENT_COLON_TOKEN: fprintf (of, "%%:%%:"); break;
10036 case WHITE_PERCENT_COLON_TOKEN: fprintf (of, " %%:%%:"); break;
10042 dump_defn_1 (defn->expansion, offset, defn->length - offset, of);
10043 fprintf (of, "\n");
10046 /* Dump all macro definitions as #defines to stdout. */
10053 for (bucket = 0; bucket < HASHSIZE; bucket++) {
10054 register HASHNODE *hp;
10056 for (hp = hashtab[bucket]; hp; hp= hp->next) {
10057 if (hp->type == T_MACRO)
10058 dump_single_macro (hp, stdout);
10063 /* Output to OF a substring of a macro definition.
10064 BASE is the beginning of the definition.
10065 Output characters START thru LENGTH.
10066 Unless traditional, discard newlines outside of strings, thus
10067 converting funny-space markers to ordinary spaces. */
10070 dump_defn_1 (base, start, length, of)
10076 U_CHAR *p = base + start;
10077 U_CHAR *limit = base + start + length;
10080 fwrite (p, sizeof (*p), length, of);
10082 while (p < limit) {
10083 if (*p == '\"' || *p =='\'') {
10084 U_CHAR *p1 = skip_quoted_string (p, limit, 0, NULL_PTR,
10085 NULL_PTR, NULL_PTR);
10086 fwrite (p, sizeof (*p), p1 - p, of);
10097 /* Print the name of argument number ARGNUM of macro definition DEFN
10099 Recall that DEFN->args.argnames contains all the arg names
10100 concatenated in reverse order with comma-space in between. */
10103 dump_arg_n (defn, argnum, of)
10108 register U_CHAR *p = defn->args.argnames;
10109 while (argnum + 1 < defn->nargs) {
10110 p = (U_CHAR *) index ((char *) p, ' ') + 1;
10114 while (*p && *p != ',') {
10120 /* Initialize syntactic classifications of characters. */
10123 initialize_char_syntax ()
10128 * Set up is_idchar and is_idstart tables. These should be
10129 * faster than saying (is_alpha (c) || c == '_'), etc.
10130 * Set up these things before calling any routines tthat
10133 for (i = 'a'; i <= 'z'; i++) {
10134 is_idchar[TOUPPER(i)] = 1;
10136 is_idstart[TOUPPER(i)] = 1;
10139 for (i = '0'; i <= '9'; i++)
10141 is_idchar['_'] = 1;
10142 is_idstart['_'] = 1;
10143 is_idchar['$'] = 1;
10144 is_idstart['$'] = 1;
10146 /* horizontal space table */
10147 is_hor_space[' '] = 1;
10148 is_hor_space['\t'] = 1;
10149 is_hor_space['\v'] = 1;
10150 is_hor_space['\f'] = 1;
10151 is_hor_space['\r'] = 1;
10154 is_space['\t'] = 1;
10155 is_space['\v'] = 1;
10156 is_space['\f'] = 1;
10157 is_space['\n'] = 1;
10158 is_space['\r'] = 1;
10161 /* Initialize the built-in macros. */
10164 initialize_builtins (inp, outp)
10168 install ((U_CHAR *) "__LINE__", -1, T_SPECLINE, NULL_PTR, -1);
10169 install ((U_CHAR *) "__DATE__", -1, T_DATE, NULL_PTR, -1);
10170 install ((U_CHAR *) "__FILE__", -1, T_FILE, NULL_PTR, -1);
10171 install ((U_CHAR *) "__BASE_FILE__", -1, T_BASE_FILE, NULL_PTR, -1);
10172 install ((U_CHAR *) "__INCLUDE_LEVEL__", -1, T_INCLUDE_LEVEL, NULL_PTR, -1);
10173 install ((U_CHAR *) "__VERSION__", -1, T_VERSION, NULL_PTR, -1);
10174 #ifndef NO_BUILTIN_SIZE_TYPE
10175 install ((U_CHAR *) "__SIZE_TYPE__", -1, T_SIZE_TYPE, NULL_PTR, -1);
10177 #ifndef NO_BUILTIN_PTRDIFF_TYPE
10178 install ((U_CHAR *) "__PTRDIFF_TYPE__ ", -1, T_PTRDIFF_TYPE, NULL_PTR, -1);
10180 install ((U_CHAR *) "__WCHAR_TYPE__", -1, T_WCHAR_TYPE, NULL_PTR, -1);
10181 install ((U_CHAR *) "__USER_LABEL_PREFIX__", -1, T_USER_LABEL_PREFIX_TYPE,
10183 install ((U_CHAR *) "__REGISTER_PREFIX__", -1, T_REGISTER_PREFIX_TYPE,
10185 install ((U_CHAR *) "__IMMEDIATE_PREFIX__", -1, T_IMMEDIATE_PREFIX_TYPE,
10187 install ((U_CHAR *) "__TIME__", -1, T_TIME, NULL_PTR, -1);
10188 if (!traditional) {
10189 install ((U_CHAR *) "__STDC__", -1, T_CONST, "1", -1);
10190 install ((U_CHAR *) "__STDC_VERSION__", -1, T_CONST, "199409L", -1);
10192 /* This is supplied using a -D by the compiler driver
10193 so that it is present only when truly compiling with GNU C. */
10194 /* install ((U_CHAR *) "__GNUC__", -1, T_CONST, "2", -1); */
10195 install ((U_CHAR *) "__HAVE_BUILTIN_SETJMP__", -1, T_CONST, "1", -1);
10199 char directive[2048];
10200 U_CHAR *udirective = (U_CHAR *) directive;
10201 register struct directive *dp = &directive_table[0];
10202 struct tm *timebuf = timestamp ();
10204 sprintf (directive, " __BASE_FILE__ \"%s\"\n",
10205 instack[0].nominal_fname);
10206 output_line_directive (inp, outp, 0, same_file);
10207 pass_thru_directive (udirective, &udirective[strlen (directive)],
10210 sprintf (directive, " __VERSION__ \"%s\"\n", version_string);
10211 output_line_directive (inp, outp, 0, same_file);
10212 pass_thru_directive (udirective, &udirective[strlen (directive)],
10215 #ifndef NO_BUILTIN_SIZE_TYPE
10216 sprintf (directive, " __SIZE_TYPE__ %s\n", SIZE_TYPE);
10217 output_line_directive (inp, outp, 0, same_file);
10218 pass_thru_directive (udirective, &udirective[strlen (directive)],
10222 #ifndef NO_BUILTIN_PTRDIFF_TYPE
10223 sprintf (directive, " __PTRDIFF_TYPE__ %s\n", PTRDIFF_TYPE);
10224 output_line_directive (inp, outp, 0, same_file);
10225 pass_thru_directive (udirective, &udirective[strlen (directive)],
10229 sprintf (directive, " __WCHAR_TYPE__ %s\n", wchar_type);
10230 output_line_directive (inp, outp, 0, same_file);
10231 pass_thru_directive (udirective, &udirective[strlen (directive)],
10234 sprintf (directive, " __DATE__ \"%s %2d %4d\"\n",
10235 monthnames[timebuf->tm_mon],
10236 timebuf->tm_mday, timebuf->tm_year + 1900);
10237 output_line_directive (inp, outp, 0, same_file);
10238 pass_thru_directive (udirective, &udirective[strlen (directive)],
10241 sprintf (directive, " __TIME__ \"%02d:%02d:%02d\"\n",
10242 timebuf->tm_hour, timebuf->tm_min, timebuf->tm_sec);
10243 output_line_directive (inp, outp, 0, same_file);
10244 pass_thru_directive (udirective, &udirective[strlen (directive)],
10249 sprintf (directive, " __STDC__ 1");
10250 output_line_directive (inp, outp, 0, same_file);
10251 pass_thru_directive (udirective, &udirective[strlen (directive)],
10256 sprintf (directive, " __OBJC__ 1");
10257 output_line_directive (inp, outp, 0, same_file);
10258 pass_thru_directive (udirective, &udirective[strlen (directive)],
10265 * process a given definition string, for initialization
10266 * If STR is just an identifier, define it with value 1.
10267 * If STR has anything after the identifier, then it should
10268 * be identifier=definition.
10272 make_definition (str)
10276 struct directive *kt;
10279 p = buf = (U_CHAR *) str;
10280 if (!is_idstart[*p]) {
10281 error ("malformed option `-D %s'", str);
10284 while (is_idchar[*++p])
10287 while (is_idchar[*++p] || *p == ',' || is_hor_space[*p])
10290 p = (U_CHAR *) str; /* Error */
10293 buf = (U_CHAR *) alloca (p - buf + 4);
10294 strcpy ((char *)buf, str);
10295 strcat ((char *)buf, " 1");
10296 } else if (*p != '=') {
10297 error ("malformed option `-D %s'", str);
10301 /* Copy the entire option so we can modify it. */
10302 buf = (U_CHAR *) alloca (2 * strlen (str) + 1);
10303 strncpy ((char *) buf, str, p - (U_CHAR *) str);
10304 /* Change the = to a space. */
10305 buf[p - (U_CHAR *) str] = ' ';
10306 /* Scan for any backslash-newline and remove it. */
10308 q = &buf[p - (U_CHAR *) str];
10310 if (*p == '\"' || *p == '\'') {
10311 int unterminated = 0;
10312 U_CHAR *p1 = skip_quoted_string (p, p + strlen ((char *) p), 0,
10313 NULL_PTR, NULL_PTR, &unterminated);
10317 if (*p == '\\' && p[1] == '\n')
10319 else if (*p == '\n')
10328 } else if (*p == '\\' && p[1] == '\n')
10330 /* Change newline chars into newline-markers. */
10331 else if (*p == '\n')
10343 ip = &instack[++indepth];
10344 ip->nominal_fname = ip->fname = "*Initialization*";
10345 ip->nominal_fname_len = strlen (ip->nominal_fname);
10347 ip->buf = ip->bufp = buf;
10348 ip->length = strlen ((char *) buf);
10352 ip->if_stack = if_stack;
10353 ip->system_header_p = 0;
10355 for (kt = directive_table; kt->type != T_DEFINE; kt++)
10358 /* Pass NULL instead of OP, since this is a "predefined" macro. */
10359 do_define (buf, buf + strlen ((char *) buf), NULL_PTR, kt);
10363 /* JF, this does the work for the -U option */
10366 make_undef (str, op)
10371 struct directive *kt;
10373 ip = &instack[++indepth];
10374 ip->nominal_fname = ip->fname = "*undef*";
10375 ip->nominal_fname_len = strlen (ip->nominal_fname);
10377 ip->buf = ip->bufp = (U_CHAR *) str;
10378 ip->length = strlen (str);
10382 ip->if_stack = if_stack;
10383 ip->system_header_p = 0;
10385 for (kt = directive_table; kt->type != T_UNDEF; kt++)
10388 do_undef ((U_CHAR *) str, (U_CHAR *) str + strlen (str), op, kt);
10392 /* Process the string STR as if it appeared as the body of a #assert.
10393 OPTION is the option name for which STR was the argument. */
10396 make_assertion (option, str)
10397 const char *option;
10401 struct directive *kt;
10402 U_CHAR *buf, *p, *q;
10404 /* Copy the entire option so we can modify it. */
10405 buf = (U_CHAR *) alloca (strlen (str) + 1);
10406 strcpy ((char *) buf, str);
10407 /* Scan for any backslash-newline and remove it. */
10410 if (*p == '\\' && p[1] == '\n')
10418 if (!is_idstart[*p]) {
10419 error ("malformed option `%s %s'", option, str);
10422 while (is_idchar[*++p])
10424 SKIP_WHITE_SPACE (p);
10425 if (! (*p == 0 || *p == '(')) {
10426 error ("malformed option `%s %s'", option, str);
10430 ip = &instack[++indepth];
10431 ip->nominal_fname = ip->fname = "*Initialization*";
10432 ip->nominal_fname_len = strlen (ip->nominal_fname);
10434 ip->buf = ip->bufp = buf;
10435 ip->length = strlen ((char *) buf);
10439 ip->if_stack = if_stack;
10440 ip->system_header_p = 0;
10442 for (kt = directive_table; kt->type != T_ASSERT; kt++)
10445 /* Pass NULL as output ptr to do_define since we KNOW it never does
10447 do_assert (buf, buf + strlen ((char *) buf) , NULL_PTR, kt);
10451 /* The previous include prefix, if any, is PREV_FILE_NAME.
10452 Translate any pathnames with COMPONENT.
10453 Allocate a new include prefix whose name is the
10454 simplified concatenation of PREFIX and NAME,
10455 with a trailing / added if needed.
10456 But return 0 if the include prefix should be ignored,
10457 e.g. because it is a duplicate of PREV_FILE_NAME. */
10459 static struct file_name_list *
10460 new_include_prefix (prev_file_name, component, prefix, name)
10461 struct file_name_list *prev_file_name;
10462 const char *component;
10463 const char *prefix;
10467 fatal ("Directory name missing after command line option");
10470 /* Ignore the empty string. */
10473 prefix = update_path (prefix, component);
10474 name = update_path (name, component);
10477 struct file_name_list *dir
10478 = ((struct file_name_list *)
10479 xmalloc (sizeof (struct file_name_list)
10480 + strlen (prefix) + strlen (name) + 2));
10482 strcpy (dir->fname, prefix);
10483 strcat (dir->fname, name);
10484 len = simplify_filename (dir->fname);
10486 /* Convert directory name to a prefix. */
10487 if (len && dir->fname[len - 1] != DIR_SEPARATOR) {
10488 if (len == 1 && dir->fname[len - 1] == '.')
10492 /* must be '/', hack_vms_include_specification triggers on it. */
10493 dir->fname[len++] = '/';
10495 dir->fname[len++] = DIR_SEPARATOR;
10497 dir->fname[len] = 0;
10500 /* Ignore a directory whose name matches the previous one. */
10501 if (prev_file_name && !strcmp (prev_file_name->fname, dir->fname)) {
10502 /* But treat `-Idir -I- -Idir' as `-I- -Idir'. */
10503 if (!first_bracket_include)
10504 first_bracket_include = prev_file_name;
10510 /* VMS can't stat dir prefixes, so skip these optimizations in VMS. */
10512 /* Add a trailing "." if there is a filename. This increases the number
10513 of systems that can stat directories. We remove it below. */
10516 dir->fname[len] = '.';
10517 dir->fname[len + 1] = 0;
10520 /* Ignore a nonexistent directory. */
10521 if (stat (len ? dir->fname : ".", &dir->st) != 0) {
10522 if (errno != ENOENT && errno != ENOTDIR)
10523 error_from_errno (dir->fname);
10529 dir->fname[len] = 0;
10531 /* Ignore a directory whose identity matches the previous one. */
10533 && INO_T_EQ (prev_file_name->st.st_ino, dir->st.st_ino)
10534 && prev_file_name->st.st_dev == dir->st.st_dev) {
10535 /* But treat `-Idir -I- -Idir' as `-I- -Idir'. */
10536 if (!first_bracket_include)
10537 first_bracket_include = prev_file_name;
10544 dir->c_system_include_path = 0;
10545 dir->got_name_map = 0;
10551 /* Append a chain of `struct file_name_list's
10552 to the end of the main include chain.
10553 FIRST is the beginning of the chain to append, and LAST is the end. */
10556 append_include_chain (first, last)
10557 struct file_name_list *first, *last;
10559 struct file_name_list *dir;
10561 if (!first || !last)
10567 last_include->next = first;
10569 if (first_bracket_include == 0)
10570 first_bracket_include = first;
10572 for (dir = first; ; dir = dir->next) {
10573 int len = strlen (dir->fname) + INCLUDE_LEN_FUDGE;
10574 if (len > max_include_len)
10575 max_include_len = len;
10581 last_include = last;
10584 /* Place into DST a representation of the file named SRC that is suitable
10585 for `make'. Do not null-terminate DST. Return its length. */
10587 quote_string_for_make (dst, src)
10591 const char *p = src;
10602 /* GNU make uses a weird quoting scheme for white space.
10603 A space or tab preceded by 2N+1 backslashes represents
10604 N backslashes followed by space; a space or tab
10605 preceded by 2N backslashes represents N backslashes at
10606 the end of a file name; and backslashes in other
10607 contexts should not be doubled. */
10609 for (q = p - 1; src < q && q[-1] == '\\'; q--)
10621 goto ordinary_char;
10627 /* Fall through. This can mishandle things like "$(" but
10628 there's no easy fix. */
10631 /* This can mishandle characters in the string "\0\n%*?[\\~";
10632 exactly which chars are mishandled depends on the `make' version.
10633 We know of no portable solution for this;
10634 even GNU make 3.76.1 doesn't solve the problem entirely.
10635 (Also, '\0' is mishandled due to our calling conventions.) */
10645 /* Add output to `deps_buffer' for the -M switch.
10646 STRING points to the text to be output.
10647 SPACER is ':' for targets, ' ' for dependencies. */
10650 deps_output (string, spacer)
10651 const char *string;
10654 int size = quote_string_for_make ((char *) 0, string);
10659 #ifndef MAX_OUTPUT_COLUMNS
10660 #define MAX_OUTPUT_COLUMNS 72
10662 if (MAX_OUTPUT_COLUMNS - 1 /*spacer*/ - 2 /*` \'*/ < deps_column + size
10663 && 1 < deps_column) {
10664 bcopy (" \\\n ", &deps_buffer[deps_size], 4);
10671 if (deps_size + 2 * size + 8 > deps_allocated_size) {
10672 deps_allocated_size = (deps_size + 2 * size + 50) * 2;
10673 deps_buffer = xrealloc (deps_buffer, deps_allocated_size);
10675 if (spacer == ' ') {
10676 deps_buffer[deps_size++] = ' ';
10679 quote_string_for_make (&deps_buffer[deps_size], string);
10681 deps_column += size;
10682 if (spacer == ':') {
10683 deps_buffer[deps_size++] = ':';
10686 deps_buffer[deps_size] = 0;
10690 fatal VPROTO ((const char * msgid, ...))
10692 #ifndef ANSI_PROTOTYPES
10693 const char * msgid;
10697 fprintf (stderr, "%s: ", progname);
10698 VA_START (args, msgid);
10700 #ifndef ANSI_PROTOTYPES
10701 msgid = va_arg (args, const char *);
10703 vnotice (msgid, args);
10705 fprintf (stderr, "\n");
10706 exit (FATAL_EXIT_CODE);
10709 /* More 'friendly' abort that prints the line and file.
10710 config.h can #define abort fancy_abort if you like that sort of thing. */
10715 fatal ("Internal gcc abort.");
10719 perror_with_name (name)
10722 fprintf (stderr, "%s: %s: %s\n", progname, name, xstrerror (errno));
10727 pfatal_with_name (name)
10730 perror_with_name (name);
10734 exit (FATAL_EXIT_CODE);
10738 /* Handler for SIGPIPE. */
10741 pipe_closed (signo)
10742 /* If this is missing, some compilers complain. */
10743 int signo ATTRIBUTE_UNUSED;
10745 fatal ("output pipe has been closed");
10751 fatal ("Memory exhausted.");
10756 /* Under VMS we need to fix up the "include" specification filename.
10758 Rules for possible conversions
10760 fullname tried paths
10763 ./dir/name [.dir]name
10765 /name [000000]name, name
10766 dir/name dir:[000000]name, dir:name, dir/name
10767 dir1/dir2/name dir1:[dir2]name, dir1:[000000.dir2]name
10768 path:/name path:[000000]name, path:name
10769 path:/dir/name path:[000000.dir]name, path:[dir]name
10770 path:dir/name path:[dir]name
10771 [path]:[dir]name [path.dir]name
10772 path/[dir]name [path.dir]name
10774 The path:/name input is constructed when expanding <> includes.
10776 return 1 if name was changed, 0 else. */
10779 hack_vms_include_specification (fullname, vaxc_include)
10783 register char *basename, *unixname, *local_ptr, *first_slash;
10784 int f, check_filename_before_returning, must_revert;
10787 check_filename_before_returning = 0;
10789 /* See if we can find a 1st slash. If not, there's no path information. */
10790 first_slash = index (fullname, '/');
10791 if (first_slash == 0)
10792 return 0; /* Nothing to do!!! */
10794 /* construct device spec if none given. */
10796 if (index (fullname, ':') == 0)
10799 /* If fullname has a slash, take it as device spec. */
10801 if (first_slash == fullname)
10803 first_slash = index (fullname+1, '/'); /* 2nd slash ? */
10805 *first_slash = ':'; /* make device spec */
10806 for (basename = fullname; *basename != 0; basename++)
10807 *basename = *(basename+1); /* remove leading slash */
10809 else if ((first_slash[-1] != '.') /* keep ':/', './' */
10810 && (first_slash[-1] != ':')
10811 && (first_slash[-1] != ']')) /* or a vms path */
10813 *first_slash = ':';
10815 else if ((first_slash[1] == '[') /* skip './' in './[dir' */
10816 && (first_slash[-1] == '.'))
10820 /* Get part after first ':' (basename[-1] == ':')
10821 or last '/' (basename[-1] == '/'). */
10823 basename = base_name (fullname);
10826 * Check if we have a vax-c style '#include filename'
10827 * and add the missing .h
10830 if (vaxc_include && !index (basename,'.'))
10831 strcat (basename, ".h");
10833 local_ptr = Local; /* initialize */
10835 /* We are trying to do a number of things here. First of all, we are
10836 trying to hammer the filenames into a standard format, such that later
10837 processing can handle them.
10839 If the file name contains something like [dir.], then it recognizes this
10840 as a root, and strips the ".]". Later processing will add whatever is
10841 needed to get things working properly.
10843 If no device is specified, then the first directory name is taken to be
10844 a device name (or a rooted logical). */
10846 /* Point to the UNIX filename part (which needs to be fixed!)
10847 but skip vms path information.
10848 [basename != fullname since first_slash != 0]. */
10850 if ((basename[-1] == ':') /* vms path spec. */
10851 || (basename[-1] == ']')
10852 || (basename[-1] == '>'))
10853 unixname = basename;
10855 unixname = fullname;
10857 if (*unixname == '/')
10860 /* If the directory spec is not rooted, we can just copy
10861 the UNIX filename part and we are done. */
10863 if (((basename - fullname) > 1)
10864 && ( (basename[-1] == ']')
10865 || (basename[-1] == '>')))
10867 if (basename[-2] != '.')
10870 /* The VMS part ends in a `]', and the preceding character is not a `.'.
10871 -> PATH]:/name (basename = '/name', unixname = 'name')
10872 We strip the `]', and then splice the two parts of the name in the
10873 usual way. Given the default locations for include files in cccp.c,
10874 we will only use this code if the user specifies alternate locations
10875 with the /include (-I) switch on the command line. */
10877 basename -= 1; /* Strip "]" */
10878 unixname--; /* backspace */
10883 /* The VMS part has a ".]" at the end, and this will not do. Later
10884 processing will add a second directory spec, and this would be a syntax
10885 error. Thus we strip the ".]", and thus merge the directory specs.
10886 We also backspace unixname, so that it points to a '/'. This inhibits the
10887 generation of the 000000 root directory spec (which does not belong here
10890 basename -= 2; /* Strip ".]" */
10891 unixname--; /* backspace */
10899 /* We drop in here if there is no VMS style directory specification yet.
10900 If there is no device specification either, we make the first dir a
10901 device and try that. If we do not do this, then we will be essentially
10902 searching the users default directory (as if they did a #include "asdf.h").
10904 Then all we need to do is to push a '[' into the output string. Later
10905 processing will fill this in, and close the bracket. */
10907 if ((unixname != fullname) /* vms path spec found. */
10908 && (basename[-1] != ':'))
10909 *local_ptr++ = ':'; /* dev not in spec. take first dir */
10911 *local_ptr++ = '['; /* Open the directory specification */
10914 if (unixname == fullname) /* no vms dir spec. */
10917 if ((first_slash != 0) /* unix dir spec. */
10918 && (*unixname != '/') /* not beginning with '/' */
10919 && (*unixname != '.')) /* or './' or '../' */
10920 *local_ptr++ = '.'; /* dir is local ! */
10923 /* at this point we assume that we have the device spec, and (at least
10924 the opening "[" for a directory specification. We may have directories
10927 If there are no other slashes then the filename will be
10928 in the "root" directory. Otherwise, we need to add
10929 directory specifications. */
10931 if (index (unixname, '/') == 0)
10933 /* if no directories specified yet and none are following. */
10934 if (local_ptr[-1] == '[')
10936 /* Just add "000000]" as the directory string */
10937 strcpy (local_ptr, "000000]");
10938 local_ptr += strlen (local_ptr);
10939 check_filename_before_returning = 1; /* we might need to fool with this later */
10945 /* As long as there are still subdirectories to add, do them. */
10946 while (index (unixname, '/') != 0)
10948 /* If this token is "." we can ignore it
10949 if it's not at the beginning of a path. */
10950 if ((unixname[0] == '.') && (unixname[1] == '/'))
10952 /* remove it at beginning of path. */
10953 if ( ((unixname == fullname) /* no device spec */
10954 && (fullname+2 != basename)) /* starts with ./ */
10956 || ((basename[-1] == ':') /* device spec */
10957 && (unixname-1 == basename))) /* and ./ afterwards */
10958 *local_ptr++ = '.'; /* make '[.' start of path. */
10963 /* Add a subdirectory spec. Do not duplicate "." */
10964 if ( local_ptr[-1] != '.'
10965 && local_ptr[-1] != '['
10966 && local_ptr[-1] != '<')
10967 *local_ptr++ = '.';
10969 /* If this is ".." then the spec becomes "-" */
10970 if ( (unixname[0] == '.')
10971 && (unixname[1] == '.')
10972 && (unixname[2] == '/'))
10974 /* Add "-" and skip the ".." */
10975 if ((local_ptr[-1] == '.')
10976 && (local_ptr[-2] == '['))
10977 local_ptr--; /* prevent [.- */
10978 *local_ptr++ = '-';
10983 /* Copy the subdirectory */
10984 while (*unixname != '/')
10985 *local_ptr++= *unixname++;
10987 unixname++; /* Skip the "/" */
10990 /* Close the directory specification */
10991 if (local_ptr[-1] == '.') /* no trailing periods */
10994 if (local_ptr[-1] == '[') /* no dir needed */
10997 *local_ptr++ = ']';
11000 /* Now add the filename. */
11003 *local_ptr++ = *unixname++;
11006 /* Now append it to the original VMS spec. */
11008 strcpy ((must_revert==1)?fullname:basename, Local);
11010 /* If we put a [000000] in the filename, try to open it first. If this fails,
11011 remove the [000000], and return that name. This provides flexibility
11012 to the user in that they can use both rooted and non-rooted logical names
11013 to point to the location of the file. */
11015 if (check_filename_before_returning)
11017 f = open (fullname, O_RDONLY, 0666);
11020 /* The file name is OK as it is, so return it as is. */
11025 /* The filename did not work. Try to remove the [000000] from the name,
11028 basename = index (fullname, '[');
11029 local_ptr = index (fullname, ']') + 1;
11030 strcpy (basename, local_ptr); /* this gets rid of it */
11040 /* The following wrapper functions supply additional arguments to the VMS
11041 I/O routines to optimize performance with file handling. The arguments
11043 "mbc=16" - Set multi-block count to 16 (use a 8192 byte buffer).
11044 "deq=64" - When extending the file, extend it in chunks of 32Kbytes.
11045 "fop=tef"- Truncate unused portions of file when closing file.
11046 "shr=nil"- Disallow file sharing while file is open. */
11049 VMS_freopen (fname, type, oldfile)
11054 #undef freopen /* Get back the real freopen routine. */
11055 if (strcmp (type, "w") == 0)
11056 return freopen (fname, type, oldfile,
11057 "mbc=16", "deq=64", "fop=tef", "shr=nil");
11058 return freopen (fname, type, oldfile, "mbc=16");
11062 VMS_fopen (fname, type)
11066 #undef fopen /* Get back the real fopen routine. */
11067 /* The gcc-vms-1.42 distribution's header files prototype fopen with two
11068 fixed arguments, which matches ANSI's specification but not VAXCRTL's
11069 pre-ANSI implementation. This hack circumvents the mismatch problem. */
11070 FILE *(*vmslib_fopen)() = (FILE *(*)()) fopen;
11073 return (*vmslib_fopen) (fname, type, "mbc=32",
11074 "deq=64", "fop=tef", "shr=nil");
11076 return (*vmslib_fopen) (fname, type, "mbc=32");
11080 VMS_open (fname, flags, prot)
11085 #undef open /* Get back the real open routine. */
11086 return open (fname, flags, prot, "mbc=16", "deq=64", "fop=tef");
11089 /* more VMS hackery */
11093 extern unsigned long SYS$PARSE(), SYS$SEARCH();
11095 /* Work around another library bug. If a file is located via a searchlist,
11096 and if the device it's on is not the same device as the one specified
11097 in the first element of that searchlist, then both stat() and fstat()
11098 will fail to return info about it. `errno' will be set to EVMSERR, and
11099 `vaxc$errno' will be set to SS$_NORMAL due yet another bug in stat()!
11100 We can get around this by fully parsing the filename and then passing
11101 that absolute name to stat().
11103 Without this fix, we can end up failing to find header files, which is
11104 bad enough, but then compounding the problem by reporting the reason for
11105 failure as "normal successful completion." */
11107 #undef fstat /* Get back to the library version. */
11110 VMS_fstat (fd, statbuf)
11112 struct stat *statbuf;
11114 int result = fstat (fd, statbuf);
11119 char nambuf[NAM$C_MAXRSS+1];
11121 if ((fp = fdopen (fd, "r")) != 0 && fgetname (fp, nambuf) != 0)
11122 result = VMS_stat (nambuf, statbuf);
11123 /* No fclose(fp) here; that would close(fd) as well. */
11130 VMS_stat (name, statbuf)
11132 struct stat *statbuf;
11134 int result = stat (name, statbuf);
11140 char exp_nam[NAM$C_MAXRSS+1], /* expanded name buffer for SYS$PARSE */
11141 res_nam[NAM$C_MAXRSS+1]; /* resultant name buffer for SYS$SEARCH */
11144 fab.fab$l_fna = (char *) name;
11145 fab.fab$b_fns = (unsigned char) strlen (name);
11146 fab.fab$l_nam = (void *) &nam;
11148 nam.nam$l_esa = exp_nam, nam.nam$b_ess = sizeof exp_nam - 1;
11149 nam.nam$l_rsa = res_nam, nam.nam$b_rss = sizeof res_nam - 1;
11150 nam.nam$b_nop = NAM$M_PWD | NAM$M_NOCONCEAL;
11151 if (SYS$PARSE (&fab) & 1)
11153 if (SYS$SEARCH (&fab) & 1)
11155 res_nam[nam.nam$b_rsl] = '\0';
11156 result = stat (res_nam, statbuf);
11158 /* Clean up searchlist context cached by the system. */
11159 nam.nam$b_nop = NAM$M_SYNCHK;
11160 fab.fab$l_fna = 0, fab.fab$b_fns = 0;
11161 (void) SYS$PARSE (&fab);
11169 VMS_fwrite (ptr, size, nitems, stream)
11175 /* VMS fwrite has undesirable results
11176 if STREAM happens to be a record oriented file.
11177 Work around this problem by writing each character individually. */
11178 char const *p = ptr;
11179 size_t bytes = size * nitems;
11180 char *lim = p + bytes;
11183 if (putc (*p++, stream) == EOF)
OSDN Git Service
