1 /* C Compatible Compiler Preprocessor (CCCP)
2 Copyright (C) 1986, 1987, 1989, 2000 Free Software Foundation, Inc.
3 Written by Paul Rubin, June 1986
4 Adapted to ANSI C, Richard Stallman, Jan 1987
5 Dusted off, polished, and adapted for use as traditional
6 preprocessor only, Zack Weinberg, Jul 2000
8 This program is free software; you can redistribute it and/or modify it
9 under the terms of the GNU General Public License as published by the
10 Free Software Foundation; either version 2, or (at your option) any
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
25 #include "cppdefault.h"
28 typedef unsigned char U_CHAR;
30 /* Name under which this program was invoked. */
32 static const char *progname;
34 /* Current maximum length of directory names in the search path
35 for include files. (Altered as we get more of them.) */
37 size_t max_include_len;
39 /* Nonzero means copy comments into the output file. */
41 int put_out_comments = 0;
43 /* Nonzero means print the names of included files rather than
44 the preprocessed output. 1 means just the #include "...",
45 2 means #include <...> as well. */
49 /* Nonzero means don't output line number information. */
53 /* Nonzero means inhibit output of the preprocessed text
54 and instead output the definitions of all user-defined macros
55 in a form suitable for use as input to cccp. */
59 /* Nonzero means don't print warning messages. -w. */
61 int inhibit_warnings = 0;
63 /* Nonzero means warn if slash-star appears in a comment. */
67 /* Nonzero causes output not to be done,
68 but directives such as #define that have side effects
73 /* Value of __USER_LABEL_PREFIX__. Target-dependent, also controlled
74 by -f(no-)leading-underscore. */
75 static const char *user_label_prefix;
77 /* I/O buffer structure.
78 The `fname' field is nonzero for source files and #include files
79 and for the dummy text used for -D and -U.
80 It is zero for rescanning results of macro expansion
81 and for expanding macro arguments. */
82 #define INPUT_STACK_MAX 200
89 /* Macro that this level is the expansion of.
90 Included so that we can reenable the macro
91 at the end of this level. */
92 struct hashnode *macro;
93 /* Value of if_stack at start of this file.
94 Used to prohibit unmatched #endif (etc) in an include file. */
95 struct if_stack *if_stack;
96 /* Object to be freed at end of input at this level. */
98 } instack[INPUT_STACK_MAX];
100 typedef struct file_buf FILE_BUF;
102 /* Current nesting level of input sources.
103 `instack[indepth]' is the level currently being read. */
105 #define CHECK_DEPTH(code) \
106 if (indepth >= (INPUT_STACK_MAX - 1)) \
108 error_with_line (line_for_error (instack[indepth].lineno), \
109 "macro or #include recursion too deep"); \
113 /* Current depth in #include directives that use <...>. */
114 int system_include_depth = 0;
116 /* The output buffer. Its LENGTH field is the amount of room allocated
117 for the buffer, not the number of chars actually present. To get
118 that, subtract outbuf.buf from outbuf.bufp. */
120 #define OUTBUF_SIZE 10 /* initial size of output buffer */
123 /* Grow output buffer OBUF points at
124 so it can hold at least NEEDED more chars. */
126 #define check_expand(OBUF, NEEDED) do { \
127 if ((OBUF)->length - ((OBUF)->bufp - (OBUF)->buf) <= (NEEDED)) \
128 grow_outbuf ((OBUF), (NEEDED)); \
131 struct file_name_list
133 struct file_name_list *next;
137 struct file_name_list *include = 0; /* First dir to search */
138 /* First dir to search for <file> */
139 struct file_name_list *first_bracket_include = 0;
140 struct file_name_list *last_include = 0; /* Last in chain */
142 /* List of included files that contained #once. */
143 struct file_name_list *dont_repeat_files = 0;
145 /* List of other included files. */
146 struct file_name_list *all_include_files = 0;
148 /* Structure allocated for every #define. For a simple replacement
151 nargs = -1, the `pattern' list is null, and the expansion is just
152 the replacement text. Nargs = 0 means a functionlike macro with no args,
154 #define getchar() getc (stdin) .
155 When there are args, the expansion is the replacement text with the
156 args squashed out, and the reflist is a list describing how to
157 build the output from the input: e.g., "3 chars, then the 1st arg,
158 then 9 chars, then the 3rd arg, then 0 chars, then the 2nd arg".
159 The chars here come from the expansion. Whatever is left of the
160 expansion after the last arg-occurrence is copied after that arg.
161 Note that the reflist can be arbitrarily long---
162 its length depends on the number of times the arguments appear in
163 the replacement text, not how many args there are. Example:
164 #define f(x) x+x+x+x+x+x+x would have replacement text "++++++" and
166 { (0, 1), (1, 1), (1, 1), ..., (1, 1), NULL }
167 where (x, y) means (nchars, argno). */
169 typedef struct definition DEFINITION;
172 int length; /* length of expansion string */
175 struct reflist *next;
176 char stringify; /* nonzero if this arg was preceded by a
178 char raw_before; /* Nonzero if a ## operator before arg. */
179 char raw_after; /* Nonzero if a ## operator after arg. */
180 int nchars; /* Number of literal chars to copy before
181 this arg occurrence. */
182 int argno; /* Number of arg to substitute (origin-0) */
184 /* Names of macro args, concatenated in reverse order
185 with comma-space between them.
186 The only use of this is that we warn on redefinition
187 if this differs between the old and new definitions. */
188 const U_CHAR *argnames;
191 /* Chained list of answers to an assertion. */
195 const unsigned char *answer;
199 /* different kinds of things that can appear in the value field
200 of a hash node. Actually, this may be useless now. */
204 struct answer *answers;
207 /* The structure of a node in the hash table. The hash table
208 has entries for all tokens defined by #define commands (type T_MACRO),
209 plus some special tokens like __LINE__ (these each have their own
210 type, and the appropriate code is run when that type of node is seen.
211 It does not contain control words like "#define", which are recognized
212 by a separate piece of code. */
214 /* different flavors of hash nodes --- also used in keyword table */
216 T_DEFINE = 1, /* `#define' */
217 T_INCLUDE, /* `#include' */
218 T_IFDEF, /* `#ifdef' */
219 T_IFNDEF, /* `#ifndef' */
221 T_ELSE, /* `#else' */
222 T_ELIF, /* `#elif' */
223 T_UNDEF, /* `#undef' */
224 T_LINE, /* `#line' */
225 T_ENDIF, /* `#endif' */
226 T_ERROR, /* `#error' */
227 T_WARNING, /* `#warning' */
228 T_ASSERT, /* `#assert' */
229 T_UNASSERT, /* `#unassert' */
230 T_SPECLINE, /* special symbol `__LINE__' */
231 T_DATE, /* `__DATE__' */
232 T_FILE, /* `__FILE__' */
233 T_BASE_FILE, /* `__BASE_FILE__' */
234 T_INCLUDE_LEVEL, /* `__INCLUDE_LEVEL__' */
235 T_VERSION, /* `__VERSION__' */
236 T_TIME, /* `__TIME__' */
237 T_CONST, /* Constant value, used by `__STDC__' */
238 T_MACRO, /* macro defined by `#define' */
239 T_SPEC_DEFINED, /* special `defined' macro for use in #if statements */
240 T_UNUSED /* Used for something not defined. */
244 struct hashnode *next; /* double links for easy deletion */
245 struct hashnode *prev;
246 struct hashnode **bucket_hdr; /* also, a back pointer to this node's hash
247 chain is kept, in case the node is the head
248 of the chain and gets deleted. */
249 enum node_type type; /* type of special token */
250 int length; /* length of token, for quick comparison */
251 U_CHAR *name; /* the actual name */
252 union hashval value; /* pointer to expansion, or whatever */
255 typedef struct hashnode HASHNODE;
257 static HASHNODE *parse_assertion PARAMS ((const unsigned char *,
258 const unsigned char *,
259 struct answer **, int));
260 static struct answer **find_answer PARAMS ((HASHNODE *,
261 const struct answer *));
262 static int parse_answer PARAMS ((const unsigned char *, const unsigned char *,
263 struct answer **, int));
264 static unsigned char *canonicalize_text PARAMS ((const unsigned char *,
265 const unsigned char *,
266 const unsigned char **));
268 /* Some definitions for the hash table. The hash function MUST be
269 computed as shown in hashf () below. That is because the rescan
270 loop computes the hash value `on the fly' for most tokens,
271 in order to avoid the overhead of a lot of procedure calls to
272 the hashf () function. Hashf () only exists for the sake of
273 politeness, for use when speed isn't so important. */
275 #define HASHSIZE 1403
276 HASHNODE *hashtab[HASHSIZE];
277 #define HASHSTEP(old, c) ((old << 2) + c)
278 #define MAKE_POS(v) (v & 0x7fffffff) /* make number positive */
280 /* `struct directive' defines one #-directive, including how to handle it. */
283 int length; /* Length of name */
284 void (*func) PARAMS ((U_CHAR *, U_CHAR *, FILE_BUF *));
285 /* Function to handle directive */
286 const char *name; /* Name of directive */
287 enum node_type type; /* Code which describes which directive. */
290 /* Last arg to output_line_command. */
291 enum file_change_code {same_file, enter_file, leave_file};
293 /* This structure represents one parsed argument in a macro call.
294 `raw' points to the argument text as written (`raw_length' is its length).
295 `expanded' points to the argument's macro-expansion
296 (its length is `expand_length').
297 `stringified_length' is the length the argument would have
299 `free1' and `free2', if nonzero, point to blocks to be freed
300 when the macro argument data is no longer needed. */
303 U_CHAR *raw, *expanded;
304 int raw_length, expand_length;
305 int stringified_length;
306 U_CHAR *free1, *free2;
311 /* The arglist structure is built by do_define to tell
312 collect_definition where the argument names begin. That
313 is, for a define like "#define f(x,y,z) foo+x-bar*y", the arglist
314 would contain pointers to the strings x, y, and z.
315 Collect_definition would then build a DEFINITION node,
316 with reflist nodes pointing to the places x, y, and z had
317 appeared. So the arglist is just convenience data passed
318 between these two routines. It is not kept around after
319 the current #define has been processed and entered into the
323 struct arglist *next;
329 /* Function prototypes. */
331 static void do_define PARAMS ((U_CHAR *, U_CHAR *, FILE_BUF *));
332 static void do_error PARAMS ((U_CHAR *, U_CHAR *, FILE_BUF *));
333 static void do_warning PARAMS ((U_CHAR *, U_CHAR *, FILE_BUF *));
334 static void do_line PARAMS ((U_CHAR *, U_CHAR *, FILE_BUF *));
335 static void do_include PARAMS ((U_CHAR *, U_CHAR *, FILE_BUF *));
336 static void do_undef PARAMS ((U_CHAR *, U_CHAR *, FILE_BUF *));
337 static void do_if PARAMS ((U_CHAR *, U_CHAR *, FILE_BUF *));
338 static void do_ifdef PARAMS ((U_CHAR *, U_CHAR *, FILE_BUF *));
339 static void do_ifndef PARAMS ((U_CHAR *, U_CHAR *, FILE_BUF *));
340 static void do_else PARAMS ((U_CHAR *, U_CHAR *, FILE_BUF *));
341 static void do_elif PARAMS ((U_CHAR *, U_CHAR *, FILE_BUF *));
342 static void do_endif PARAMS ((U_CHAR *, U_CHAR *, FILE_BUF *));
343 static void do_assert PARAMS ((U_CHAR *, U_CHAR *, FILE_BUF *));
344 static void do_unassert PARAMS ((U_CHAR *, U_CHAR *, FILE_BUF *));
345 static void do_xifdef PARAMS ((U_CHAR *, U_CHAR *, enum node_type));
347 static struct hashnode *install PARAMS ((const U_CHAR *, int, enum node_type, int));
348 static int hashf PARAMS ((const U_CHAR *, int, int));
349 static int compare_defs PARAMS ((DEFINITION *, DEFINITION *));
350 static int comp_def_part PARAMS ((int, const U_CHAR *, int,
351 const U_CHAR *, int, int));
352 static void delete_macro PARAMS ((HASHNODE *));
354 /* First arg to v_message. */
355 enum msgtype { WARNING = 0, ERROR, FATAL };
356 static void v_message PARAMS ((enum msgtype mtype, int line,
357 const char *msgid, va_list ap))
358 ATTRIBUTE_PRINTF (3, 0);
360 static int line_for_error PARAMS ((int));
362 /* We know perfectly well which file this is, so we don't need to
365 #if (GCC_VERSION >= 2007)
366 #define abort() fancy_abort(__LINE__, __FUNCTION__)
368 #define abort() fancy_abort(__LINE__, 0);
371 static void macroexpand PARAMS ((HASHNODE *, FILE_BUF *));
372 static void special_symbol PARAMS ((HASHNODE *, FILE_BUF *));
373 static void dump_all_macros PARAMS ((void));
374 static void dump_defn_1 PARAMS ((const U_CHAR *, int, int));
375 static void dump_arg_n PARAMS ((DEFINITION *, int));
376 static void conditional_skip PARAMS ((FILE_BUF *, int, enum node_type));
377 static void skip_if_group PARAMS ((FILE_BUF *, int));
378 static void output_line_command PARAMS ((FILE_BUF *, FILE_BUF *,
379 int, enum file_change_code));
381 static int eval_if_expression PARAMS ((const U_CHAR *, int));
383 static void initialize_builtins PARAMS ((void));
384 static void run_directive PARAMS ((const char *, size_t,
386 static void make_definition PARAMS ((const char *));
387 static void make_undef PARAMS ((const char *));
388 static void make_assertion PARAMS ((const char *));
390 static void grow_outbuf PARAMS ((FILE_BUF *, int));
391 static int handle_directive PARAMS ((FILE_BUF *, FILE_BUF *));
392 static void finclude PARAMS ((int, const char *, FILE_BUF *));
393 static void deps_output PARAMS ((const char *, int));
394 static void rescan PARAMS ((FILE_BUF *, int));
395 static void newline_fix PARAMS ((U_CHAR *));
396 static void name_newline_fix PARAMS ((U_CHAR *));
397 static U_CHAR *macarg1 PARAMS ((U_CHAR *, const U_CHAR *, int *,
399 static const char *macarg PARAMS ((struct argdata *));
400 static int discard_comments PARAMS ((U_CHAR *, int, int));
401 static int file_size_and_mode PARAMS ((int, int *, long *));
403 static U_CHAR *skip_to_end_of_comment PARAMS ((FILE_BUF *, int *));
404 static U_CHAR *skip_quoted_string PARAMS ((const U_CHAR *, const U_CHAR *,
405 int, int *, int *, int *));
407 int main PARAMS ((int, char **));
409 /* Convenience. Write U"string" to get an unsigned string constant. */
410 #define U (const unsigned char *)
412 /* Here is the actual list of #-directives, most-often-used first. */
414 struct directive directive_table[] = {
415 { 6, do_define, "define", T_DEFINE },
416 { 7, do_include, "include", T_INCLUDE },
417 { 5, do_endif, "endif", T_ENDIF },
418 { 5, do_ifdef, "ifdef", T_IFDEF },
419 { 2, do_if, "if", T_IF, },
420 { 4, do_else, "else", T_ELSE },
421 { 6, do_ifndef, "ifndef", T_IFNDEF },
422 { 5, do_undef, "undef", T_UNDEF },
423 { 4, do_line, "line", T_LINE },
424 { 4, do_elif, "elif", T_ELIF },
425 { 5, do_error, "error", T_ERROR },
426 { 7, do_warning, "warning", T_WARNING },
427 { 6, do_assert, "assert", T_ASSERT },
428 { 8, do_unassert,"unassert",T_UNASSERT},
429 { -1, 0, "", T_UNUSED},
432 #define SKIP_WHITE_SPACE(p) do { while (is_nvspace(*p)) p++; } while (0)
433 #define SKIP_ALL_WHITE_SPACE(p) do { while (is_space(*p)) p++; } while (0)
435 int errors = 0; /* Error counter for exit code */
437 static FILE_BUF expand_to_temp_buffer PARAMS ((const U_CHAR *, const U_CHAR *, int));
438 static DEFINITION *collect_expansion PARAMS ((U_CHAR *, U_CHAR *, int,
441 /* Stack of conditionals currently in progress
442 (including both successful and failing conditionals). */
445 struct if_stack *next; /* for chaining to the next stack frame */
446 const char *fname; /* copied from input when frame is made */
447 int lineno; /* similarly */
448 int if_succeeded; /* true if a leg of this if-group
449 has been passed through rescan */
450 enum node_type type; /* type of last directive seen in this group */
452 typedef struct if_stack IF_STACK_FRAME;
453 IF_STACK_FRAME *if_stack = NULL;
455 /* Buffer of -M output. */
459 /* Number of bytes allocated in above. */
460 int deps_allocated_size;
462 /* Number of bytes used. */
465 /* Number of bytes since the last newline. */
468 /* Nonzero means -I- has been seen,
469 so don't look for #include "foo" the source-file directory. */
472 /* Pending directives. */
473 enum pending_dir_t {PD_NONE = 0, PD_DEFINE, PD_UNDEF, PD_ASSERTION, PD_FILE};
475 typedef struct pending_dir pending_dir;
479 enum pending_dir_t type;
489 const char *in_fname, *out_fname;
492 pending_dir *pend = (pending_dir *) xcalloc (argc, sizeof (pending_dir));
493 int no_standard_includes = 0;
495 /* Non-0 means don't output the preprocessed program. */
496 int inhibit_output = 0;
498 /* Stream on which to print the dependency information. */
499 FILE *deps_stream = 0;
500 /* Target-name to write with the dependency information. */
501 char *deps_target = 0;
504 /* Get rid of any avoidable limit on stack size. */
508 /* Set the stack limit huge so that alloca (particularly stringtab
509 * in dbxread.c) does not fail. */
510 getrlimit (RLIMIT_STACK, &rlim);
511 rlim.rlim_cur = rlim.rlim_max;
512 setrlimit (RLIMIT_STACK, &rlim);
514 #endif /* RLIMIT_STACK defined */
521 no_line_commands = 0;
525 max_include_len = cpp_GCC_INCLUDE_DIR_len + 7; /* ??? */
527 /* Process switches and find input file name. */
529 for (i = 1; i < argc; i++) {
530 if (argv[i][0] != '-') {
531 if (out_fname != NULL)
532 fatal ("Usage: %s [switches] input output", argv[0]);
533 else if (in_fname != NULL)
544 break; /* Ignore for compatibility with ISO/extended cpp. */
547 if (!strcmp (argv[i], "-lang-c++")
548 || !strcmp (argv[i], "-lang-objc++"))
549 fatal ("-traditional is not supported in C++");
550 else if (!strcmp (argv[i], "-lang-c89"))
551 fatal ("-traditional and -ansi are mutually exclusive");
552 else if (!strcmp (argv[i], "-lang-objc"))
553 pend[i].type = PD_DEFINE, pend[i].arg = "__OBJC__";
554 else if (!strcmp (argv[i], "-lang-asm"))
555 pend[i].type = PD_DEFINE, pend[i].arg = "__ASSEMBLER__";
556 else if (!strcmp (argv[i], "-lang-fortran"))
557 pend[i].type = PD_DEFINE, pend[i].arg = "_LANGUAGE_FORTRAN";
558 /* All other possibilities ignored. */
562 if (!strcmp (argv[i], "-include"))
565 fatal ("Filename missing after -i option");
567 pend[i].type = PD_FILE, pend[i].arg = argv[i + 1], i++;
569 else if (!strcmp (argv[i], "-iprefix"))
570 i++; /* Ignore for compatibility */
571 else if (!strcmp (argv[i], "-isystem")
572 || !strcmp (argv[i], "-iwithprefix")
573 || !strcmp (argv[i], "-iwithprefixbefore")
574 || !strcmp (argv[i], "-idirafter"))
575 goto add_include; /* best we can do */
580 if (out_fname != NULL)
581 fatal ("Output filename specified twice");
583 fatal ("Filename missing after -o option");
584 out_fname = argv[++i];
585 if (!strcmp (out_fname, "-"))
590 inhibit_warnings = 1;
594 if (!strcmp (argv[i], "-Wcomments"))
596 else if (!strcmp (argv[i], "-Wcomment"))
598 else if (!strcmp (argv[i], "-Wall")) {
604 if (!strcmp (argv[i], "-fleading-underscore"))
605 user_label_prefix = "_";
606 else if (!strcmp (argv[i], "-fno-leading-underscore"))
607 user_label_prefix = "";
611 if (!strcmp (argv[i], "-M"))
613 else if (!strcmp (argv[i], "-MM"))
624 fprintf (stderr, "GNU traditional CPP version %s\n", version_string);
635 else if (i + 1 == argc)
636 fatal ("Macro name missing after -%c option", c);
641 pend[i].type = PD_DEFINE;
643 pend[i].type = PD_UNDEF;
645 pend[i].type = PD_ASSERTION;
651 put_out_comments = 1;
655 if (!strcmp (argv[i], "-pedantic"))
656 fatal ("-pedantic and -traditional are mutually exclusive");
660 if (!strcmp (argv[i], "-trigraphs"))
661 fatal ("-trigraphs and -traditional are mutually exclusive");
665 no_line_commands = 1;
668 case 'I': /* Add directory to path for includes. */
671 struct file_name_list *dirtmp;
673 if (! ignore_srcdir && !strcmp (argv[i] + 2, "-"))
676 dirtmp = (struct file_name_list *)
677 xmalloc (sizeof (struct file_name_list));
678 dirtmp->next = 0; /* New one goes on the end */
682 last_include->next = dirtmp;
683 last_include = dirtmp; /* Tail follows the last one */
684 if (argv[i][1] == 'I' && argv[i][2] != 0)
685 dirtmp->fname = argv[i] + 2;
686 else if (i + 1 == argc)
687 fatal ("Directory name missing after -I option");
689 dirtmp->fname = argv[++i];
690 if (strlen (dirtmp->fname) > max_include_len)
691 max_include_len = strlen (dirtmp->fname);
692 if (ignore_srcdir && first_bracket_include == 0)
693 first_bracket_include = dirtmp;
699 /* -nostdinc causes no default include directories.
700 You must specify all include-file directories with -I. */
701 no_standard_includes = 1;
704 case '\0': /* JF handle '-' as file name meaning stdin or stdout */
705 if (in_fname == NULL) {
708 } else if (out_fname == NULL) {
711 } /* else fall through into error */
714 fatal ("Invalid option `%s'", argv[i]);
719 if (user_label_prefix == 0)
720 user_label_prefix = USER_LABEL_PREFIX;
722 /* Install __LINE__, etc. Must follow option processing. */
723 initialize_builtins ();
725 /* Do defines specified with -D and undefines specified with -U. */
726 for (i = 1; i < argc; i++)
727 if (pend[i].type == PD_DEFINE)
728 make_definition (pend[i].arg);
729 else if (pend[i].type == PD_UNDEF)
730 make_undef (pend[i].arg);
731 else if (pend[i].type == PD_ASSERTION)
732 make_assertion (pend[i].arg);
734 /* Unless -fnostdinc,
735 tack on the standard include file dirs to the specified list */
736 if (!no_standard_includes) {
737 const struct default_include *di;
738 struct file_name_list *old_last_include = last_include;
739 struct file_name_list *dirtmp;
740 for (di = cpp_include_defaults; di->fname; di++) {
743 dirtmp = (struct file_name_list *)
744 xmalloc (sizeof (struct file_name_list));
745 dirtmp->next = 0; /* New one goes on the end */
749 last_include->next = dirtmp;
750 last_include = dirtmp; /* Tail follows the last one */
751 dirtmp->fname = di->fname;
752 if (strlen (dirtmp->fname) > max_include_len)
753 max_include_len = strlen (dirtmp->fname);
756 if (ignore_srcdir && first_bracket_include == 0)
757 first_bracket_include = old_last_include->next;
760 /* Initialize output buffer */
762 outbuf.buf = (U_CHAR *) xmalloc (OUTBUF_SIZE);
763 outbuf.bufp = outbuf.buf;
764 outbuf.length = OUTBUF_SIZE;
766 /* Scan the -i files before the main input.
767 Much like #including them, but with no_output set
768 so that only their macro definitions matter. */
771 for (i = 1; i < argc; i++)
772 if (pend[i].type == PD_FILE)
774 int fd = open (pend[i].arg, O_RDONLY, 0666);
777 perror_with_name (pend[i].arg);
778 return FATAL_EXIT_CODE;
780 finclude (fd, pend[i].arg, &outbuf);
784 /* Pending directives no longer needed. */
787 /* Create an input stack level for the main input file
788 and copy the entire contents of the file into it. */
790 fp = &instack[++indepth];
792 /* JF check for stdin */
793 if (in_fname == NULL || *in_fname == 0) {
796 } else if ((f = open (in_fname, O_RDONLY, 0666)) < 0)
799 /* Either of two environment variables can specify output of deps.
800 Its value is either "OUTPUT_FILE" or "OUTPUT_FILE DEPS_TARGET",
801 where OUTPUT_FILE is the file to write deps info to
802 and DEPS_TARGET is the target to mention in the deps. */
805 && (getenv ("SUNPRO_DEPENDENCIES") != 0
806 || getenv ("DEPENDENCIES_OUTPUT") != 0))
808 char *spec = getenv ("DEPENDENCIES_OUTPUT");
814 spec = getenv ("SUNPRO_DEPENDENCIES");
820 /* Find the space before the DEPS_TARGET, if there is one. */
821 s = strchr (spec, ' ');
825 output_file = (char *) xmalloc (s - spec + 1);
826 memcpy (output_file, spec, s - spec);
827 output_file[s - spec] = 0;
835 deps_stream = fopen (output_file, "a");
836 if (deps_stream == 0)
837 pfatal_with_name (output_file);
839 /* If the -M option was used, output the deps to standard output. */
841 deps_stream = stdout;
843 /* For -M, print the expected object file name
844 as the target of this Make-rule. */
846 deps_allocated_size = 200;
847 deps_buffer = (char *) xmalloc (deps_allocated_size);
853 deps_output (deps_target, 0);
854 deps_output (":", 0);
855 } else if (*in_fname == 0)
856 deps_output ("-: ", 0);
859 const char *p = in_fname;
861 /* Discard all directory prefixes from P. */
867 /* Output P, but remove known suffixes. */
869 if (p[len - 2] == '.'
870 && (p[len - 1] == 'c' || p[len - 1] == 'C' || p[len - 1] == 'S'))
871 deps_output (p, len - 2);
872 else if (p[len - 3] == '.'
874 && p[len - 1] == 'c')
875 deps_output (p, len - 3);
878 /* Supply our own suffix. */
879 deps_output (".o : ", 0);
880 deps_output (in_fname, 0);
881 deps_output (" ", 0);
885 if (file_size_and_mode (f, &st_mode, &st_size))
887 fp->fname = in_fname;
889 /* JF all this is mine about reading pipes and ttys */
890 if (!S_ISREG (st_mode)) {
891 /* Read input from a file that is not a normal disk file.
892 We cannot preallocate a buffer with the correct size,
893 so we must read in the file a piece at the time and make it bigger. */
901 fp->buf = (U_CHAR *) xmalloc (bsize + 2);
904 cnt = read (f, bufp, bsize - size);
905 if (cnt < 0) goto sys_error; /* error! */
906 if (cnt == 0) break; /* End of file */
909 if (bsize == size) { /* Buffer is full! */
911 fp->buf = (U_CHAR *) xrealloc (fp->buf, bsize + 2);
912 bufp = fp->buf + size; /* May have moved */
917 /* Read a file whose size we can determine in advance.
918 For the sake of VMS, st_size is just an upper bound. */
921 fp->buf = (U_CHAR *) xmalloc (st_size + 2);
923 while (st_size > 0) {
924 i = read (f, fp->buf + fp->length, st_size);
934 fp->if_stack = if_stack;
936 /* Make sure data ends with a newline. And put a null after it. */
938 if (fp->length > 0 && fp->buf[fp->length-1] != '\n')
939 fp->buf[fp->length++] = '\n';
940 fp->buf[fp->length] = '\0';
942 /* Now that we know the input file is valid, open the output. */
944 if (!out_fname || !strcmp (out_fname, ""))
945 out_fname = "stdout";
946 else if (! freopen (out_fname, "w", stdout))
947 pfatal_with_name (out_fname);
949 output_line_command (fp, &outbuf, 0, same_file);
951 /* Scan the input, processing macros and directives. */
955 /* Now we have processed the entire input
956 Write whichever kind of output has been requested. */
961 else if (! inhibit_output && deps_stream != stdout) {
962 if (write (fileno (stdout), outbuf.buf, outbuf.bufp - outbuf.buf) < 0)
963 fatal ("I/O error on output");
967 fputs (deps_buffer, deps_stream);
968 putc ('\n', deps_stream);
969 if (deps_stream != stdout) {
970 fclose (deps_stream);
971 if (ferror (deps_stream))
972 fatal ("I/O error on output");
977 fatal ("I/O error on output");
980 exit (FATAL_EXIT_CODE);
981 exit (SUCCESS_EXIT_CODE);
984 pfatal_with_name (in_fname);
987 /* Move all backslash-newline pairs out of embarrassing places.
988 Exchange all such pairs following BP
989 with any potentially-embarrasing characters that follow them.
990 Potentially-embarrassing characters are / and *
991 (because a backslash-newline inside a comment delimiter
992 would cause it not to be recognized). */
997 register U_CHAR *p = bp;
998 register int count = 0;
1000 /* First count the backslash-newline pairs here. */
1002 while (*p++ == '\\' && *p++ == '\n')
1007 /* Exit if what follows the backslash-newlines is not embarrassing. */
1009 if (count == 0 || (*p != '/' && *p != '*'))
1012 /* Copy all potentially embarrassing characters
1013 that follow the backslash-newline pairs
1014 down to where the pairs originally started. */
1016 while (*p == '*' || *p == '/')
1019 /* Now write the same number of pairs after the embarrassing chars. */
1020 while (count-- > 0) {
1026 /* Like newline_fix but for use within a directive-name.
1027 Move any backslash-newlines up past any following symbol constituents. */
1029 name_newline_fix (bp)
1032 register U_CHAR *p = bp;
1033 register int count = 0;
1035 /* First count the backslash-newline pairs here. */
1037 while (*p++ == '\\' && *p++ == '\n')
1042 /* What follows the backslash-newlines is not embarrassing. */
1044 if (count == 0 || !is_idchar (*p))
1047 /* Copy all potentially embarrassing characters
1048 that follow the backslash-newline pairs
1049 down to where the pairs originally started. */
1051 while (is_idchar (*p))
1054 /* Now write the same number of pairs after the embarrassing chars. */
1055 while (count-- > 0) {
1062 * The main loop of the program.
1064 * Read characters from the input stack, transferring them to the
1067 * Macros are expanded and push levels on the input stack.
1068 * At the end of such a level it is popped off and we keep reading.
1069 * At the end of any other kind of level, we return.
1070 * #-directives are handled, except within macros.
1072 * If OUTPUT_MARKS is nonzero, keep Newline markers found in the input
1073 * and insert them when appropriate. This is set while scanning macro
1074 * arguments before substitution. It is zero when scanning for final output.
1075 * There are three types of Newline markers:
1076 * * Newline - follows a macro name that was not expanded
1077 * because it appeared inside an expansion of the same macro.
1078 * This marker prevents future expansion of that identifier.
1079 * When the input is rescanned into the final output, these are deleted.
1080 * These are also deleted by ## concatenation.
1081 * * Newline Space (or Newline and any other whitespace character)
1082 * stands for a place that tokens must be separated or whitespace
1083 * is otherwise desirable, but where the ANSI standard specifies there
1084 * is no whitespace. This marker turns into a Space (or whichever other
1085 * whitespace char appears in the marker) in the final output,
1086 * but it turns into nothing in an argument that is stringified with #.
1087 * Such stringified arguments are the only place where the ANSI standard
1088 * specifies with precision that whitespace may not appear.
1090 * During this function, IP->bufp is kept cached in IBP for speed of access.
1091 * Likewise, OP->bufp is kept in OBP. Before calling a subroutine
1092 * IBP, IP and OBP must be copied back to memory. IP and IBP are
1093 * copied back with the RECACHE macro. OBP must be copied back from OP->bufp
1094 * explicitly, and before RECACHE, since RECACHE uses OBP.
1098 rescan (op, output_marks)
1102 /* Character being scanned in main loop. */
1105 /* Length of pending accumulated identifier. */
1106 register int ident_length = 0;
1108 /* Hash code of pending accumulated identifier. */
1109 register int hash = 0;
1111 /* Current input level (&instack[indepth]). */
1114 /* Pointer for scanning input. */
1115 register U_CHAR *ibp;
1117 /* Pointer to end of input. End of scan is controlled by LIMIT. */
1118 register U_CHAR *limit;
1120 /* Pointer for storing output. */
1121 register U_CHAR *obp;
1123 /* REDO_CHAR is nonzero if we are processing an identifier
1124 after backing up over the terminating character.
1125 Sometimes we process an identifier without backing up over
1126 the terminating character, if the terminating character
1127 is not special. Backing up is done so that the terminating character
1128 will be dispatched on again once the identifier is dealt with. */
1131 /* 1 if within an identifier inside of which a concatenation
1132 marker (Newline -) has been seen. */
1133 int concatenated = 0;
1135 /* While scanning a comment or a string constant,
1136 this records the line it started on, for error messages. */
1139 /* Record position of last `real' newline. */
1140 U_CHAR *beg_of_line;
1142 /* Pop the innermost input stack level, assuming it is a macro expansion. */
1145 do { ip->macro->type = T_MACRO; \
1146 if (ip->free_ptr) free (ip->free_ptr); \
1147 --indepth; } while (0)
1149 /* Reload `rescan's local variables that describe the current
1150 level of the input stack. */
1153 do { ip = &instack[indepth]; \
1155 limit = ip->buf + ip->length; \
1157 check_expand (op, limit - ibp); \
1159 obp = op->bufp; } while (0)
1161 if (no_output && instack[indepth].fname != 0)
1162 skip_if_group (&instack[indepth], 1);
1168 /* Our caller must always put a null after the end of
1169 the input at each input stack level. */
1182 /* Always merge lines ending with backslash-newline,
1183 even in middle of identifier. */
1186 --obp; /* remove backslash from obuf */
1189 /* Otherwise, backslash suppresses specialness of following char,
1190 so copy it here to prevent the switch from seeing it.
1191 But first get any pending identifier processed. */
1192 if (ident_length > 0)
1198 /* If this is expanding a macro definition, don't recognize
1199 preprocessor directives. */
1205 /* # keyword: a # must be the first char on the line */
1206 if (beg_of_line == 0)
1208 if (beg_of_line + 1 != ibp)
1211 /* This # can start a directive. */
1213 --obp; /* Don't copy the '#' */
1217 if (! handle_directive (ip, op)) {
1221 /* Not a known directive: treat it as ordinary text.
1222 IP, OP, IBP, etc. have not been changed. */
1223 if (no_output && instack[indepth].fname) {
1224 /* If not generating expanded output,
1225 what we do with ordinary text is skip it.
1226 Discard everything until next # directive. */
1227 skip_if_group (&instack[indepth], 1);
1232 ++obp; /* Copy the '#' after all */
1238 /* A # directive has been successfully processed. */
1239 /* If not generating expanded output, ignore everything until
1240 next # directive. */
1241 if (no_output && instack[indepth].fname)
1242 skip_if_group (&instack[indepth], 1);
1248 case '\"': /* skip quoted string */
1250 /* A single quoted string is treated like a double -- some
1251 programs (e.g., troff) are perverse this way */
1256 start_line = ip->lineno;
1258 /* Skip ahead to a matching quote. */
1262 if (ip->macro != 0) {
1263 /* try harder: this string crosses a macro expansion boundary */
1275 /* Traditionally, end of line ends a string constant with no error.
1276 So exit the loop and record the new line. */
1284 /* Backslash newline is replaced by nothing at all,
1285 but keep the line counts correct. */
1290 /* ANSI stupidly requires that in \\ the second \
1291 is *not* prevented from combining with a newline. */
1292 while (*ibp == '\\' && ibp[1] == '\n') {
1311 if (*ibp == '\\' && ibp[1] == '\n')
1313 /* Don't look for comments inside a macro definition. */
1316 /* A comment constitutes white space, so it can terminate an identifier.
1317 Process the identifier, if any. */
1324 /* We have a comment. Skip it, optionally copying it to output. */
1326 start_line = ip->lineno;
1328 ++ibp; /* Skip the star. */
1330 /* In K+R C, a comment is equivalent to nothing. Note that we
1331 already output the slash; we might not want it. */
1332 if (! put_out_comments)
1338 U_CHAR *before_bp = ibp;
1340 while (ibp < limit) {
1343 if (warn_comments && ibp < limit && *ibp == '*')
1344 warning("`/*' within comment");
1347 if (*ibp == '\\' && ibp[1] == '\n')
1349 if (ibp >= limit || *ibp == '/')
1354 /* Copy the newline into the output buffer, in order to
1355 avoid the pain of a #line every time a multiline comment
1357 if (!put_out_comments)
1365 error_with_line (line_for_error (start_line),
1366 "unterminated comment");
1369 if (put_out_comments) {
1370 memcpy (obp, before_bp, ibp - before_bp);
1371 obp += ibp - before_bp;
1377 case '0': case '1': case '2': case '3': case '4':
1378 case '5': case '6': case '7': case '8': case '9':
1379 /* If digit is not part of identifier, it starts a number,
1380 which means that following letters are not an identifier.
1381 "0x5" does not refer to an identifier "x5".
1382 So copy all alphanumerics that follow without accumulating
1383 as an identifier. Periods also, for sake of "3.e7". */
1385 if (ident_length == 0) {
1386 while (ibp < limit) {
1387 while (ibp < limit && ibp[0] == '\\' && ibp[1] == '\n') {
1392 if (!ISALNUM (c) && c != '.' && c != '_') {
1397 /* A sign can be part of a preprocessing number
1398 if it follows an e. */
1399 if (c == 'e' || c == 'E') {
1400 while (ibp < limit && ibp[0] == '\\' && ibp[1] == '\n') {
1404 if (ibp < limit && (*ibp == '+' || *ibp == '-')) {
1406 /* Traditional C does not let the token go past the sign. */
1416 case 'a': case 'b': case 'c': case 'd': case 'e': case 'f':
1417 case 'g': case 'h': case 'i': case 'j': case 'k': case 'l':
1418 case 'm': case 'n': case 'o': case 'p': case 'q': case 'r':
1419 case 's': case 't': case 'u': case 'v': case 'w': case 'x':
1421 case 'A': case 'B': case 'C': case 'D': case 'E': case 'F':
1422 case 'G': case 'H': case 'I': case 'J': case 'K': case 'L':
1423 case 'M': case 'N': case 'O': case 'P': case 'Q': case 'R':
1424 case 'S': case 'T': case 'U': case 'V': case 'W': case 'X':
1427 /* Compute step of hash function, to avoid a proc call on every token */
1428 hash = HASHSTEP (hash, c);
1432 /* If reprocessing a macro expansion, newline is a special marker. */
1433 if (ip->macro != 0) {
1434 /* Newline White is a "funny space" to separate tokens that are
1435 supposed to be separate but without space between.
1436 Here White means any horizontal whitespace character.
1437 Newline - marks a recursive macro use that is not
1438 supposed to be expandable. */
1441 /* Newline - inhibits expansion of preceding token.
1442 If expanding a macro arg, we keep the newline -.
1443 In final output, it is deleted. */
1444 if (! concatenated) {
1449 if (!output_marks) {
1452 /* If expanding a macro arg, keep the newline -. */
1455 } else if (is_space (*ibp)) {
1456 /* Newline Space does not prevent expansion of preceding token
1457 so expand the preceding token and then come back. */
1458 if (ident_length > 0)
1461 /* If generating final output, newline space makes a space. */
1462 if (!output_marks) {
1464 /* And Newline Newline makes a newline, so count it. */
1465 if (obp[-1] == '\n')
1468 /* If expanding a macro arg, keep the newline space.
1469 If the arg gets stringified, newline space makes nothing. */
1472 } else abort (); /* Newline followed by something random? */
1476 /* If there is a pending identifier, handle it and come back here. */
1477 if (ident_length > 0)
1482 /* Update the line counts and output a #line if necessary. */
1485 if (ip->lineno != op->lineno) {
1487 output_line_command (ip, op, 1, same_file);
1488 check_expand (op, ip->length - (ip->bufp - ip->buf));
1493 /* Come here either after (1) a null character that is part of the input
1494 or (2) at the end of the input, because there is a null there. */
1497 /* Our input really contains a null character. */
1500 /* At end of a macro-expansion level, pop it and read next level. */
1501 if (ip->macro != 0) {
1504 /* If we have an identifier that ends here, process it now, so
1505 we get the right error for recursion. */
1506 if (ident_length && ! is_idchar (*instack[indepth - 1].bufp)) {
1515 /* If we don't have a pending identifier,
1516 return at end of input. */
1517 if (ident_length == 0) {
1525 /* If we do have a pending identifier, just consider this null
1526 a special character and arrange to dispatch on it again.
1527 The second time, IDENT_LENGTH will be zero so we will return. */
1533 /* Handle the case of a character such as /, ', " or null
1534 seen following an identifier. Back over it so that
1535 after the identifier is processed the special char
1536 will be dispatched on again. */
1546 if (ident_length > 0) {
1547 register HASHNODE *hp;
1549 /* We have just seen an identifier end. If it's a macro, expand it.
1551 IDENT_LENGTH is the length of the identifier
1552 and HASH is its hash code.
1554 The identifier has already been copied to the output,
1555 so if it is a macro we must remove it.
1557 If REDO_CHAR is 0, the char that terminated the identifier
1558 has been skipped in the output and the input.
1559 OBP-IDENT_LENGTH-1 points to the identifier.
1560 If the identifier is a macro, we must back over the terminator.
1562 If REDO_CHAR is 1, the terminating char has already been
1563 backed over. OBP-IDENT_LENGTH points to the identifier. */
1565 for (hp = hashtab[MAKE_POS (hash) % HASHSIZE]; hp != NULL;
1568 if (hp->length == ident_length) {
1569 U_CHAR *obufp_before_macroname;
1570 int op_lineno_before_macroname;
1571 register int i = ident_length;
1572 register U_CHAR *p = hp->name;
1573 register U_CHAR *q = obp - i;
1578 do { /* All this to avoid a strncmp () */
1583 /* We found a use of a macro name.
1584 see if the context shows it is a macro call. */
1586 /* Back up over terminating character if not already done. */
1592 obufp_before_macroname = obp - ident_length;
1593 op_lineno_before_macroname = op->lineno;
1595 /* If macro wants an arglist, verify that a '(' follows.
1596 first skip all whitespace, copying it to the output
1597 after the macro name. Then, if there is no '(',
1598 decide this is not a macro call and leave things that way. */
1599 if (hp->type == T_MACRO && hp->value.defn->nargs >= 0)
1602 /* Scan forward over whitespace, copying it to the output. */
1603 if (ibp == limit && ip->macro != 0) {
1607 /* A comment: copy it unchanged or discard it. */
1608 else if (*ibp == '/' && ibp+1 != limit && ibp[1] == '*') {
1609 if (put_out_comments) {
1614 while (ibp + 1 != limit
1615 && !(ibp[0] == '*' && ibp[1] == '/')) {
1616 /* We need not worry about newline-marks,
1617 since they are never found in comments. */
1619 /* Newline in a file. Count it. */
1623 if (put_out_comments)
1629 if (put_out_comments) {
1634 else if (is_space (*ibp)) {
1636 if (ibp[-1] == '\n') {
1637 if (ip->macro == 0) {
1638 /* Newline in a file. Count it. */
1641 } else if (!output_marks) {
1642 /* A newline mark, and we don't want marks
1643 in the output. If it is newline-hyphen,
1644 discard it entirely. Otherwise, it is
1645 newline-whitechar, so keep the whitechar. */
1655 /* A newline mark; copy both chars to the output. */
1666 /* This is now known to be a macro call.
1667 Discard the macro name from the output,
1668 along with any following whitespace just copied. */
1669 obp = obufp_before_macroname;
1670 op->lineno = op_lineno_before_macroname;
1672 /* Expand the macro, reading arguments as needed,
1673 and push the expansion on the input stack. */
1676 macroexpand (hp, op);
1678 /* Reexamine input stack, since macroexpand has pushed
1679 a new level on it. */
1686 } /* End hash-table-search loop */
1687 ident_length = hash = 0; /* Stop collecting identifier */
1690 } /* End if (ident_length > 0) */
1692 } /* End per-char loop */
1694 /* Come here to return -- but first give an error message
1695 if there was an unterminated successful conditional. */
1697 if (if_stack != ip->if_stack) {
1699 switch (if_stack->type) {
1718 error_with_line (line_for_error (if_stack->lineno),
1719 "unterminated #%s conditional", str);
1721 if_stack = ip->if_stack;
1725 * Rescan a string into a temporary buffer and return the result
1726 * as a FILE_BUF. Note this function returns a struct, not a pointer.
1728 * OUTPUT_MARKS nonzero means keep Newline markers found in the input
1729 * and insert such markers when appropriate. See `rescan' for details.
1730 * OUTPUT_MARKS is 1 for macroexpanding a macro argument separately
1731 * before substitution; it is 0 for other uses.
1734 expand_to_temp_buffer (buf, limit, output_marks)
1735 const U_CHAR *buf, *limit;
1738 register FILE_BUF *ip;
1740 int length = limit - buf;
1742 int odepth = indepth;
1747 /* Set up the input on the input stack. */
1749 buf1 = (U_CHAR *) alloca (length + 1);
1751 register const U_CHAR *p1 = buf;
1752 register U_CHAR *p2 = buf1;
1759 /* Set up to receive the output. */
1761 obuf.length = length * 2 + 100; /* Usually enough. Why be stingy? */
1762 obuf.bufp = obuf.buf = (U_CHAR *) xmalloc (obuf.length);
1767 CHECK_DEPTH ({return obuf;});
1771 ip = &instack[indepth];
1775 ip->length = length;
1776 ip->buf = ip->bufp = buf1;
1777 ip->if_stack = if_stack;
1779 ip->lineno = obuf.lineno = 1;
1781 /* Scan the input, create the output. */
1783 rescan (&obuf, output_marks);
1785 /* Pop input stack to original state. */
1788 if (indepth != odepth)
1791 /* Record the output. */
1792 obuf.length = obuf.bufp - obuf.buf;
1798 * Process a # directive. Expects IP->bufp to point to the '#', as in
1799 * `#define foo bar'. Passes to the command handler
1800 * (do_define, do_include, etc.): the addresses of the 1st and
1801 * last chars of the command (starting immediately after the #
1802 * keyword), plus op and the keyword table pointer. If the command
1803 * contains comments it is copied into a temporary buffer sans comments
1804 * and the temporary buffer is passed to the command handler instead.
1805 * Likewise for backslash-newlines.
1807 * Returns nonzero if this was a known # directive.
1808 * Otherwise, returns zero, without advancing the input pointer.
1812 handle_directive (ip, op)
1815 register U_CHAR *bp, *cp;
1816 register struct directive *kt;
1817 register int ident_length;
1820 /* Nonzero means we must copy the entire command
1821 to get rid of comments or backslash-newlines. */
1822 int copy_command = 0;
1824 U_CHAR *ident, *after_ident;
1827 /* Skip whitespace and \-newline. */
1829 if (is_nvspace (*bp))
1831 else if (*bp == '/' && (newline_fix (bp + 1), bp[1]) == '*') {
1833 skip_to_end_of_comment (ip, &ip->lineno);
1835 } else if (*bp == '\\' && bp[1] == '\n') {
1836 bp += 2; ip->lineno++;
1840 /* Now find end of directive name.
1841 If we encounter a backslash-newline, exchange it with any following
1842 symbol-constituents so that we end up with a contiguous name. */
1846 if (is_idchar (*cp))
1849 if (*cp == '\\' && cp[1] == '\n')
1850 name_newline_fix (cp);
1851 if (is_idchar (*cp))
1856 ident_length = cp - bp;
1860 /* A line of just `#' becomes blank. */
1862 if (ident_length == 0 && *after_ident == '\n') {
1863 ip->bufp = after_ident;
1868 * Decode the keyword and call the appropriate expansion
1869 * routine, after moving the input pointer up to the next line.
1871 for (kt = directive_table; kt->length > 0; kt++) {
1872 if (kt->length == ident_length
1873 && !strncmp (kt->name, (const char *)ident, ident_length)) {
1874 register U_CHAR *buf;
1875 register U_CHAR *limit = ip->buf + ip->length;
1876 int unterminated = 0;
1878 /* Nonzero means do not delete comments within the directive.
1879 #define needs this to detect traditional token paste. */
1880 int keep_comments = kt->type == T_DEFINE;
1882 /* Find the end of this command (first newline not backslashed
1883 and not in a string or comment).
1884 Set COPY_COMMAND if the command must be copied
1885 (it contains a backslash-newline or a comment). */
1887 buf = bp = after_ident;
1888 while (bp < limit) {
1889 register U_CHAR c = *bp++;
1903 bp = skip_quoted_string (bp - 1, limit, ip->lineno, &ip->lineno, ©_command, &unterminated);
1905 /* Traditional preprocessing permits unterminated strings. */
1911 /* <...> is special for #include. */
1913 if (kt->type != T_INCLUDE)
1915 while (*bp && *bp != '>') bp++;
1919 if (*bp == '\\' && bp[1] == '\n')
1922 U_CHAR *obp = bp - 1;
1924 skip_to_end_of_comment (ip, &ip->lineno);
1926 /* No need to copy the command because of a comment at the end;
1927 just don't include the comment in the directive. */
1928 if (bp == limit || *bp == '\n') {
1932 /* Don't remove the comments if this is #define. */
1933 if (! keep_comments)
1939 --bp; /* Point to the newline */
1947 resume_p = ip->bufp;
1948 /* BP is the end of the directive.
1949 RESUME_P is the next interesting data after the directive.
1950 A comment may come between. */
1953 register U_CHAR *xp = buf;
1954 /* Need to copy entire command into temp buffer before dispatching */
1956 cp = (U_CHAR *) alloca (bp - buf + 5); /* room for cmd plus
1960 /* Copy to the new buffer, deleting comments
1961 and backslash-newlines (and whitespace surrounding the latter). */
1964 register U_CHAR c = *xp++;
1971 /* <...> is special for #include. */
1973 if (kt->type != T_INCLUDE)
1975 while (xp < bp && c != '>') {
1977 if (c == '\\' && xp < bp && *xp == '\n')
1988 if (cp != buf && is_space (cp[-1])) {
1989 while (cp != buf && is_space(cp[-1])) cp--;
1991 SKIP_WHITE_SPACE (xp);
1992 } else if (is_space (*xp)) {
1994 SKIP_WHITE_SPACE (xp);
2004 register const U_CHAR *bp1
2005 = skip_quoted_string (xp - 1, limit, ip->lineno, 0, 0, 0);
2014 skip_to_end_of_comment (ip, 0);
2016 while (xp != ip->bufp)
2018 /* Delete the slash. */
2026 /* Null-terminate the copy. */
2033 ip->bufp = resume_p;
2035 /* Call the appropriate command handler. buf now points to
2036 either the appropriate place in the input buffer, or to
2037 the temp buffer if it was necessary to make one. cp
2038 points to the first char after the contents of the (possibly
2039 copied) command, in either case. */
2040 (*kt->func) (buf, cp, op);
2041 check_expand (op, ip->length - (ip->bufp - ip->buf));
2050 static const char *const
2051 monthnames[] = {"Jan", "Feb", "Mar", "Apr", "May", "Jun",
2052 "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"};
2055 * expand things like __FILE__. Place the expansion into the output
2056 * buffer *without* rescanning.
2059 special_symbol (hp, op)
2067 FILE_BUF *ip = NULL;
2068 static struct tm *timebuf = NULL;
2070 int paren = 0; /* For special `defined' keyword */
2072 for (i = indepth; i >= 0; i--)
2073 if (instack[i].fname != NULL) {
2078 fatal ("not in any file?!");
2085 if (hp->type == T_FILE)
2088 string = instack[0].fname;
2092 char *tmp = (char *) alloca (3 + strlen (string));
2093 sprintf (tmp, "\"%s\"", string);
2102 case T_INCLUDE_LEVEL:
2104 char *tmp = (char *) alloca (8); /* Eigth bytes ought to be more than enough */
2106 for (i = indepth; i >= 0; i--)
2107 if (instack[i].fname != NULL)
2110 sprintf (tmp, "%d", true_indepth - 1);
2117 char *tmp = (char *) alloca (3 + strlen (version_string));
2118 sprintf (tmp, "\"%s\"", version_string);
2124 buf = hp->value.cpval;
2129 char *tmp = (char *) alloca (10);
2130 sprintf (tmp, "%d", ip->lineno);
2138 char *tmp = (char *) alloca (20);
2140 if (timebuf == NULL) {
2142 timebuf = localtime (&t);
2144 if (hp->type == T_DATE)
2145 sprintf (tmp, "\"%s %2d %4d\"", monthnames[timebuf->tm_mon],
2146 timebuf->tm_mday, timebuf->tm_year + 1900);
2148 sprintf (tmp, "\"%02d:%02d:%02d\"", timebuf->tm_hour, timebuf->tm_min,
2154 case T_SPEC_DEFINED:
2155 buf = " 0 "; /* Assume symbol is not defined */
2156 ip = &instack[indepth];
2157 SKIP_WHITE_SPACE (ip->bufp);
2158 if (*ip->bufp == '(') {
2160 ip->bufp++; /* Skip over the paren */
2161 SKIP_WHITE_SPACE (ip->bufp);
2164 if (!is_idstart (*ip->bufp))
2167 HASHNODE *hp = lookup (ip->bufp, -1, -1);
2169 if (hp && hp->type != T_UNUSED && hp->type != T_SPEC_DEFINED)
2172 while (is_idchar (*ip->bufp))
2174 SKIP_WHITE_SPACE (ip->bufp);
2176 if (*ip->bufp != ')')
2184 error ("`defined' must be followed by ident or (ident)");
2188 error ("cccp error: invalid special hash type"); /* time for gdb */
2192 check_expand (op, len);
2193 memcpy (op->bufp, buf, len);
2198 /* Routines to handle #directives */
2201 * Process include file by reading it in and calling rescan.
2202 * Expects to see "fname" or <fname> on the input.
2205 do_include (buf, limit, op)
2206 U_CHAR *buf, *limit;
2209 char *fname; /* Dynamically allocated fname buffer */
2210 U_CHAR *fbeg, *fend; /* Beginning and end of fname */
2212 struct file_name_list *stackp = include; /* Chain of dirs to search */
2213 struct file_name_list dsp[1]; /* First in chain, if #include "..." */
2216 int f; /* file number */
2218 int retried = 0; /* Have already tried macro
2219 expanding the include line*/
2220 FILE_BUF trybuf; /* It got expanded into here */
2221 int system_header_p = 0; /* 0 for "...", 1 for <...> */
2223 f= -1; /* JF we iz paranoid! */
2228 SKIP_WHITE_SPACE (fbeg);
2229 /* Discard trailing whitespace so we can easily see
2230 if we have parsed all the significant chars we were given. */
2231 while (limit != fbeg && is_nvspace (limit[-1])) limit--;
2236 while (fend != limit && *fend != '\"')
2238 if (*fend == '\"' && fend + 1 == limit) {
2241 /* We have "filename". Figure out directory this source
2242 file is coming from and put it on the front of the list. */
2244 /* If -I- was specified, don't search current dir, only spec'd ones. */
2245 if (ignore_srcdir) break;
2247 for (fp = &instack[indepth]; fp >= instack; fp--)
2250 const char *ep, *nam;
2252 if ((nam = fp->fname) != NULL) {
2253 /* Found a named file. Figure out dir of the file,
2254 and put it in front of the search list. */
2255 dsp[0].next = stackp;
2257 ep = strrchr (nam, '/');
2261 f = (char *) alloca (n + 1);
2262 strncpy (f, nam, n);
2265 if (n > max_include_len) max_include_len = n;
2267 dsp[0].fname = 0; /* Current directory */
2278 while (fend != limit && *fend != '>') fend++;
2279 if (*fend == '>' && fend + 1 == limit) {
2280 system_header_p = 1;
2281 /* If -I-, start with the first -I dir after the -I-. */
2282 if (first_bracket_include)
2283 stackp = first_bracket_include;
2291 error ("#include expects \"fname\" or <fname>");
2294 trybuf = expand_to_temp_buffer (buf, limit, 0);
2295 buf = (U_CHAR *) alloca (trybuf.bufp - trybuf.buf + 1);
2296 memcpy (buf, trybuf.buf, trybuf.bufp - trybuf.buf);
2297 limit = buf + (trybuf.bufp - trybuf.buf);
2305 fname = (char *) alloca (max_include_len + flen + 2);
2306 /* + 2 above for slash and terminating null. */
2308 /* If specified file name is absolute, just open it. */
2311 strncpy (fname, (const char *)fbeg, flen);
2313 f = open (fname, O_RDONLY, 0666);
2315 /* Search directory path, trying to open the file.
2316 Copy each filename tried into FNAME. */
2318 for (; stackp; stackp = stackp->next) {
2319 if (stackp->fname) {
2320 strcpy (fname, stackp->fname);
2321 strcat (fname, "/");
2322 fname[strlen (fname) + flen] = 0;
2326 strncat (fname, (const char *)fbeg, flen);
2327 if ((f = open (fname, O_RDONLY, 0666)) >= 0)
2333 strncpy (fname, (const char *)fbeg, flen);
2335 error_from_errno (fname);
2337 /* For -M, add this file to the dependencies. */
2338 if (print_deps > (system_header_p || (system_include_depth > 0))) {
2339 if (system_header_p)
2340 warning ("nonexistent file <%.*s> omitted from dependency output",
2344 deps_output ((const char *)fbeg, flen);
2345 deps_output (" ", 0);
2350 /* Check to see if this include file is a once-only include file.
2353 struct file_name_list* ptr;
2355 for (ptr = dont_repeat_files; ptr; ptr = ptr->next) {
2356 if (!strcmp (ptr->fname, fname)) {
2358 return; /* This file was once'd. */
2362 for (ptr = all_include_files; ptr; ptr = ptr->next) {
2363 if (!strcmp (ptr->fname, fname))
2364 break; /* This file was included before. */
2368 /* This is the first time for this file. */
2369 /* Add it to list of files included. */
2371 ptr = (struct file_name_list *) xmalloc (sizeof (struct file_name_list));
2372 ptr->next = all_include_files;
2373 all_include_files = ptr;
2374 ptr->fname = xstrdup (fname);
2376 /* For -M, add this file to the dependencies. */
2377 if (print_deps > (system_header_p || (system_include_depth > 0))) {
2378 deps_output (fname, strlen (fname));
2379 deps_output (" ", 0);
2383 if (system_header_p)
2384 system_include_depth++;
2386 /* Actually process the file. */
2387 finclude (f, fname, op);
2389 if (system_header_p)
2390 system_include_depth--;
2396 /* Process the contents of include file FNAME, already open on descriptor F,
2397 with output to OP. */
2400 finclude (f, fname, op)
2408 FILE_BUF *fp; /* For input stack frame */
2410 CHECK_DEPTH (return;);
2412 if (file_size_and_mode (f, &st_mode, &st_size))
2415 fp = &instack[indepth + 1];
2416 memset (fp, 0, sizeof (FILE_BUF));
2420 fp->if_stack = if_stack;
2422 if (S_ISREG (st_mode)) {
2423 fp->buf = (U_CHAR *) xmalloc (st_size + 2);
2426 /* Read the file contents, knowing that st_size is an upper bound
2427 on the number of bytes we can read. */
2428 while (st_size > 0) {
2429 i = read (f, fp->buf + fp->length, st_size);
2439 /* Cannot count its file size before reading. */
2446 basep = (U_CHAR *) xmalloc (bsize + 2);
2450 i = read (f, bufp, bsize - st_size);
2452 goto nope; /* error! */
2454 break; /* End of file */
2457 if (bsize == st_size) { /* Buffer is full! */
2459 basep = (U_CHAR *) xrealloc (basep, bsize + 2);
2460 bufp = basep + st_size; /* May have moved */
2465 fp->length = st_size;
2469 /* Make sure data ends with a newline. And put a null after it. */
2471 if (fp->length > 0 && fp->buf[fp->length-1] != '\n')
2472 fp->buf[fp->length++] = '\n';
2473 fp->buf[fp->length] = '\0';
2476 output_line_command (fp, op, 0, enter_file);
2479 instack[indepth].lineno++;
2480 instack[indepth].bufp++; /* Skip the new line. */
2481 output_line_command (&instack[indepth], op, 0, leave_file);
2486 perror_with_name (fname);
2491 /* Process a #define command.
2492 BUF points to the contents of the #define command, as a continguous string.
2493 LIMIT points to the first character past the end of the definition.
2494 KEYWORD is the keyword-table entry for #define. */
2497 do_define (buf, limit, op)
2498 U_CHAR *buf, *limit;
2499 FILE_BUF *op ATTRIBUTE_UNUSED;
2501 U_CHAR *bp; /* temp ptr into input buffer */
2502 U_CHAR *symname; /* remember where symbol name starts */
2503 int sym_length; /* and how long it is */
2506 int arglengths = 0; /* Accumulate lengths of arg names
2507 plus number of args. */
2512 while (is_nvspace (*bp))
2515 symname = bp; /* remember where it starts */
2516 while (is_idchar (*bp) && bp < limit) {
2519 sym_length = bp - symname;
2520 if (sym_length == 0)
2522 error ("invalid macro name");
2525 else if (!is_idstart (*symname)) {
2526 U_CHAR *msg; /* what pain... */
2527 msg = (U_CHAR *) alloca (sym_length + 1);
2528 memcpy (msg, symname, sym_length);
2529 msg[sym_length] = 0;
2530 error ("invalid macro name `%s'", msg);
2533 if (! strncmp ((const char *)symname, "defined", 7) && sym_length == 7)
2535 error ("\"defined\" cannot be used as a macro name");
2540 /* lossage will occur if identifiers or control keywords are broken
2541 across lines using backslash. This is not the right place to take
2545 struct arglist *arg_ptrs = NULL;
2548 bp++; /* skip '(' */
2549 SKIP_WHITE_SPACE (bp);
2551 /* Loop over macro argument names. */
2552 while (*bp != ')') {
2553 struct arglist *temp;
2555 temp = (struct arglist *) alloca (sizeof (struct arglist));
2557 temp->next = arg_ptrs;
2558 temp->argno = argno++;
2561 if (!is_idstart (*bp))
2562 warning ("parameter name starts with a digit in #define");
2564 /* Find the end of the arg name. */
2565 while (is_idchar (*bp)) {
2568 temp->length = bp - temp->name;
2569 arglengths += temp->length + 2;
2570 SKIP_WHITE_SPACE (bp);
2571 if (temp->length == 0 || (*bp != ',' && *bp != ')')) {
2572 error ("badly punctuated parameter list in #define");
2577 SKIP_WHITE_SPACE (bp);
2580 error ("unterminated parameter list in #define");
2585 ++bp; /* skip paren */
2586 while (is_nvspace (*bp)) /* and leading whitespace */
2588 /* now everything from bp before limit is the definition. */
2589 defn = collect_expansion (bp, limit, argno, arg_ptrs);
2591 /* Now set defn->argnames to the result of concatenating
2592 the argument names in reverse order
2593 with comma-space between them. */
2595 struct arglist *temp;
2597 U_CHAR *tmp = (U_CHAR *) xmalloc (arglengths + 1);
2599 for (temp = arg_ptrs; temp; temp = temp->next) {
2600 memcpy (&tmp[i], temp->name, temp->length);
2602 if (temp->next != 0) {
2608 defn->argnames = tmp;
2612 /* simple expansion or empty definition; skip leading whitespace */
2613 while (is_nvspace (*bp))
2615 /* now everything from bp before limit is the definition. */
2616 defn = collect_expansion (bp, limit, -1, 0);
2617 defn->argnames = (const U_CHAR *) "";
2620 hashcode = hashf (symname, sym_length, HASHSIZE);
2624 if ((hp = lookup (symname, sym_length, hashcode)) == NULL)
2625 hp = install (symname, sym_length, T_MACRO, hashcode);
2627 if (hp->type != T_MACRO || compare_defs (defn, hp->value.defn))
2628 warning ("\"%.*s\" redefined", sym_length, symname);
2630 /* Replace the old definition. */
2634 hp->value.defn = defn;
2639 * return zero if two DEFINITIONs are isomorphic
2642 compare_defs (d1, d2)
2643 DEFINITION *d1, *d2;
2645 register struct reflist *a1, *a2;
2646 register U_CHAR *p1 = d1->expansion;
2647 register U_CHAR *p2 = d2->expansion;
2650 if (d1->nargs != d2->nargs)
2652 if (strcmp ((const char *)d1->argnames, (const char *)d2->argnames))
2654 for (a1 = d1->pattern, a2 = d2->pattern; a1 && a2;
2655 a1 = a1->next, a2 = a2->next) {
2656 if (!((a1->nchars == a2->nchars
2657 && ! strncmp ((const char *)p1, (const char *)p2, a1->nchars))
2658 || ! comp_def_part (first, p1, a1->nchars, p2, a2->nchars, 0))
2659 || a1->argno != a2->argno
2660 || a1->stringify != a2->stringify
2661 || a1->raw_before != a2->raw_before
2662 || a1->raw_after != a2->raw_after)
2670 if (comp_def_part (first, p1, d1->length - (p1 - d1->expansion),
2671 p2, d2->length - (p2 - d2->expansion), 1))
2676 /* Return 1 if two parts of two macro definitions are effectively different.
2677 One of the parts starts at BEG1 and has LEN1 chars;
2678 the other has LEN2 chars at BEG2.
2679 Any sequence of whitespace matches any other sequence of whitespace.
2680 FIRST means these parts are the first of a macro definition;
2681 so ignore leading whitespace entirely.
2682 LAST means these parts are the last of a macro definition;
2683 so ignore trailing whitespace entirely. */
2685 comp_def_part (first, beg1, len1, beg2, len2, last)
2687 const U_CHAR *beg1, *beg2;
2691 register const U_CHAR *end1 = beg1 + len1;
2692 register const U_CHAR *end2 = beg2 + len2;
2694 while (beg1 != end1 && is_space (*beg1)) beg1++;
2695 while (beg2 != end2 && is_space (*beg2)) beg2++;
2698 while (beg1 != end1 && is_space (end1[-1])) end1--;
2699 while (beg2 != end2 && is_space (end2[-1])) end2--;
2701 while (beg1 != end1 && beg2 != end2) {
2702 if (is_space (*beg1) && is_space (*beg2)) {
2703 while (beg1 != end1 && is_space (*beg1)) beg1++;
2704 while (beg2 != end2 && is_space (*beg2)) beg2++;
2705 } else if (*beg1 == *beg2) {
2709 return (beg1 != end1) || (beg2 != end2);
2712 /* Read a replacement list for a macro with parameters.
2713 Build the DEFINITION structure.
2714 Reads characters of text starting at BUF until LIMIT.
2715 ARGLIST specifies the formal parameters to look for
2716 in the text of the definition; NARGS is the number of args
2717 in that list, or -1 for a macro name that wants no argument list.
2718 MACRONAME is the macro name itself (so we can avoid recursive expansion)
2719 and NAMELEN is its length in characters.
2721 Note that comments and backslash-newlines have already been deleted
2722 from the argument. */
2724 /* Leading and trailing Space, Tab, etc. are converted to markers
2725 Newline Space, Newline Tab, etc.
2726 Newline Space makes a space in the final output
2727 but is discarded if stringified. (Newline Tab is similar but
2728 makes a Tab instead.)
2730 If there is no trailing whitespace, a Newline Space is added at the end
2731 to prevent concatenation that would be contrary to the standard. */
2734 collect_expansion (buf, end, nargs, arglist)
2737 struct arglist *arglist;
2740 register U_CHAR *p, *limit, *lastp, *exp_p;
2741 struct reflist *endpat = NULL;
2742 /* Pointer to first nonspace after last ## seen. */
2744 /* Pointer to first nonspace after last single-# seen. */
2745 U_CHAR *stringify = 0;
2747 int expected_delimiter = '\0';
2749 /* Scan thru the replacement list, ignoring comments and quoted
2750 strings, picking up on the macro calls. It does a linear search
2751 thru the arg list on every potential symbol. Profiling might say
2752 that something smarter should happen. */
2757 /* Find the beginning of the trailing whitespace. */
2758 /* Find end of leading whitespace. */
2761 while (p < limit && is_space (limit[-1])) limit--;
2762 while (p < limit && is_space (*p)) p++;
2764 /* Allocate space for the text in the macro definition.
2765 Leading and trailing whitespace chars need 2 bytes each.
2766 Each other input char may or may not need 1 byte,
2767 so this is an upper bound.
2768 The extra 2 are for invented trailing newline-marker and final null. */
2769 maxsize = (sizeof (DEFINITION)
2770 + 2 * (end - limit) + 2 * (p - buf)
2772 defn = (DEFINITION *) xcalloc (1, maxsize);
2774 defn->nargs = nargs;
2775 exp_p = defn->expansion = (U_CHAR *) defn + sizeof (DEFINITION);
2780 /* Convert leading whitespace to Newline-markers. */
2781 while (p < limit && is_space (*p)) {
2786 /* Process the main body of the definition. */
2788 int skipped_arg = 0;
2789 register U_CHAR c = *p++;
2793 /* In -traditional mode, recognize arguments inside strings and
2794 and character constants, and ignore special properties of #.
2795 Arguments inside strings are considered "stringified", but no
2796 extra quote marks are supplied. */
2800 if (expected_delimiter != '\0') {
2801 if (c == expected_delimiter)
2802 expected_delimiter = '\0';
2804 expected_delimiter = c;
2808 /* Backslash quotes delimiters and itself, but not macro args. */
2809 if (expected_delimiter != 0 && p < limit
2810 && (*p == expected_delimiter || *p == '\\')) {
2817 if (expected_delimiter != '\0') /* No comments inside strings. */
2820 /* If we find a comment that wasn't removed by handle_directive,
2821 this must be -traditional. So replace the comment with
2825 while (p < limit && !(p[-2] == '*' && p[-1] == '/'))
2831 if (is_idchar (c) && nargs > 0) {
2832 U_CHAR *id_beg = p - 1;
2836 while (p != limit && is_idchar (*p)) p++;
2837 id_len = p - id_beg;
2839 if (is_idstart (c)) {
2840 register struct arglist *arg;
2842 for (arg = arglist; arg != NULL; arg = arg->next) {
2843 struct reflist *tpat;
2845 if (arg->name[0] == c
2846 && arg->length == id_len
2847 && strncmp ((const char *)arg->name,
2848 (const char *)id_beg, id_len) == 0) {
2849 /* make a pat node for this arg and append it to the end of
2851 tpat = (struct reflist *) xmalloc (sizeof (struct reflist));
2853 tpat->raw_before = concat == id_beg;
2854 tpat->raw_after = 0;
2855 tpat->stringify = expected_delimiter != '\0';
2858 defn->pattern = tpat;
2860 endpat->next = tpat;
2863 tpat->argno = arg->argno;
2864 tpat->nchars = exp_p - lastp;
2866 register U_CHAR *p1 = p;
2867 SKIP_WHITE_SPACE (p1);
2868 if (p1 + 2 <= limit && p1[0] == '#' && p1[1] == '#')
2869 tpat->raw_after = 1;
2871 lastp = exp_p; /* place to start copying from next time */
2878 /* If this was not a macro arg, copy it into the expansion. */
2879 if (! skipped_arg) {
2880 register U_CHAR *lim1 = p;
2884 if (stringify == id_beg)
2885 error ("# operator should be followed by a macro argument name");
2891 /* Convert trailing whitespace to Newline-markers. */
2892 while (limit < end && is_space (*limit)) {
2894 *exp_p++ = *limit++;
2899 defn->length = exp_p - defn->expansion;
2901 /* Crash now if we overrun the allocated size. */
2902 if (defn->length + 1 > maxsize)
2909 * interpret #line command. Remembers previously seen fnames
2910 * in its very own hash table.
2912 #define FNAME_HASHSIZE 37
2914 do_line (buf, limit, op)
2915 U_CHAR *buf, *limit;
2918 register U_CHAR *bp;
2919 FILE_BUF *ip = &instack[indepth];
2922 enum file_change_code file_change = same_file;
2924 /* Expand any macros. */
2925 tem = expand_to_temp_buffer (buf, limit, 0);
2927 /* Point to macroexpanded line, which is null-terminated now. */
2929 SKIP_WHITE_SPACE (bp);
2931 if (!ISDIGIT (*bp)) {
2932 error ("invalid format #line command");
2936 /* The Newline at the end of this line remains to be processed.
2937 To put the next line at the specified line number,
2938 we must store a line number now that is one less. */
2939 new_lineno = atoi ((const char *)bp);
2941 /* skip over the line number. */
2942 while (ISDIGIT (*bp))
2945 SKIP_WHITE_SPACE (bp);
2948 static HASHNODE *fname_table[FNAME_HASHSIZE];
2949 HASHNODE *hp, **hash_bucket;
2955 while (*bp && *bp != '\"')
2958 error ("invalid format #line command");
2962 fname_length = bp - fname;
2965 SKIP_WHITE_SPACE (bp);
2968 file_change = enter_file;
2969 else if (*bp == '2')
2970 file_change = leave_file;
2972 error ("invalid format #line command");
2977 SKIP_WHITE_SPACE (bp);
2979 error ("invalid format #line command");
2985 &fname_table[hashf (fname, fname_length, FNAME_HASHSIZE)];
2986 for (hp = *hash_bucket; hp != NULL; hp = hp->next)
2987 if (hp->length == fname_length &&
2988 strncmp (hp->value.cpval, (const char *)fname, fname_length) == 0) {
2989 ip->fname = hp->value.cpval;
2994 /* Didn't find it; cons up a new one. */
2995 hp = (HASHNODE *) xcalloc (1, sizeof (HASHNODE) + fname_length + 1);
2996 hp->next = *hash_bucket;
2999 hp->length = fname_length;
3000 ip->fname = hp->value.cpval = q = ((char *) hp) + sizeof (HASHNODE);
3001 memcpy (q, fname, fname_length);
3004 error ("invalid format #line command");
3008 ip->lineno = new_lineno;
3009 output_line_command (ip, op, 0, file_change);
3010 ip->bufp++; /* Skip the new line. */
3011 check_expand (op, ip->length - (ip->bufp - ip->buf));
3015 * remove all definitions of symbol from symbol table.
3016 * according to un*x /lib/cpp, it is not an error to undef
3017 * something that has no definitions, so it isn't one here either.
3020 do_undef (buf, limit, op)
3022 U_CHAR *limit ATTRIBUTE_UNUSED;
3023 FILE_BUF *op ATTRIBUTE_UNUSED;
3027 SKIP_WHITE_SPACE (buf);
3029 if (! strncmp ((const char *)buf, "defined", 7) && ! is_idchar (buf[7]))
3030 warning ("undefining `defined'");
3032 while ((hp = lookup (buf, -1, -1)) != NULL) {
3033 if (hp->type != T_MACRO)
3034 warning ("undefining `%s'", hp->name);
3039 /* Read the tokens of the answer into the macro pool. Only commit the
3040 memory if we intend it as permanent storage, i.e. the #assert case.
3041 Returns 0 on success. */
3044 parse_answer (buf, limit, answerp, type)
3045 const unsigned char *buf, *limit;
3046 struct answer **answerp;
3049 const unsigned char *start;
3051 /* Skip leading whitespace. */
3052 if (buf < limit && *buf == ' ')
3055 /* Parentheses are optional here. */
3056 if (buf == limit && type == T_UNASSERT)
3059 if (buf == limit || *buf++ != '(')
3064 error ("missing '(' after predicate");
3068 /* Drop whitespace at start. */
3069 while (buf < limit && *buf == ' ')
3073 while (buf < limit && *buf != ')')
3078 error ("missing ')' to complete answer");
3084 error ("predicate's answer is empty");
3088 if ((type == T_ASSERT || type == T_UNASSERT) && buf + 1 != limit)
3090 error ("extra text at end of directive");
3094 /* Lose trailing whitespace. */
3098 *answerp = (struct answer *) xmalloc (sizeof (struct answer));
3099 (*answerp)->answer = start;
3100 (*answerp)->len = buf - start;
3105 /* Parses an assertion, returning a pointer to the hash node of the
3106 predicate, or 0 on error. If an answer was supplied, it is placed
3107 in ANSWERP, otherwise it is set to 0. */
3109 parse_assertion (buf, limit, answerp, type)
3110 const unsigned char *buf, *limit;
3111 struct answer **answerp;
3114 HASHNODE *result = 0;
3115 const unsigned char *climit;
3116 unsigned char *bp, *symname = canonicalize_text (buf, limit, &climit);
3120 if (bp < climit && is_idstart (*bp))
3124 while (bp < climit && is_idchar (*bp));
3131 if (symname == climit)
3132 error ("assertion without predicate");
3134 error ("predicate must be an identifier");
3136 /* Unfortunately, because of the way we handle #if, we don't avoid
3137 macro expansion in answers. This is not easy to fix. */
3138 else if (parse_answer (bp, climit, answerp, type) == 0)
3140 unsigned char *sym = alloca (len + 1);
3143 /* Prefix '#' to get it out of macro namespace. */
3145 memcpy (sym + 1, symname, len);
3147 hashcode = hashf (sym, len + 1, HASHSIZE);
3148 result = lookup (sym, len + 1, hashcode);
3150 result = install (sym, len + 1, T_UNUSED, hashcode);
3156 /* Test an assertion within a preprocessor conditional. Returns zero
3157 on error or failure, one on success. */
3159 test_assertion (pbuf)
3160 unsigned char **pbuf; /* NUL-terminated. */
3162 unsigned char *buf = *pbuf;
3163 unsigned char *limit = buf + strlen ((char *) buf);
3164 struct answer *answer;
3168 node = parse_assertion (buf, limit, &answer, T_IF);
3171 result = (node->type == T_ASSERT &&
3172 (answer == 0 || *find_answer (node, answer) != 0));
3174 /* Yuk. We update pbuf to point after the assertion test.
3175 First, move past the identifier. */
3176 if (is_space (*buf))
3178 while (is_idchar (*buf))
3180 /* If we have an answer, we need to move past the parentheses. */
3182 while (*buf++ != ')')
3190 /* Handle a #error directive. */
3192 do_error (buf, limit, op)
3195 FILE_BUF *op ATTRIBUTE_UNUSED;
3197 error ("#error%.*s", (int) (limit - buf), buf);
3200 /* Handle a #warning directive. */
3202 do_warning (buf, limit, op)
3205 FILE_BUF *op ATTRIBUTE_UNUSED;
3207 warning ("#warning%.*s", (int) (limit - buf), buf);
3210 /* Handle a #assert directive. */
3212 do_assert (buf, limit, op)
3215 FILE_BUF *op ATTRIBUTE_UNUSED;
3217 struct answer *new_answer;
3220 node = parse_assertion (buf, limit, &new_answer, T_ASSERT);
3223 /* Place the new answer in the answer list. First check there
3224 is not a duplicate. */
3225 new_answer->next = 0;
3226 if (node->type == T_ASSERT)
3228 if (*find_answer (node, new_answer))
3231 warning ("\"%s\" re-asserted", node->name + 1);
3234 new_answer->next = node->value.answers;
3236 node->type = T_ASSERT;
3237 node->value.answers = new_answer;
3241 /* Function body to be provided later. */
3243 do_unassert (buf, limit, op)
3246 FILE_BUF *op ATTRIBUTE_UNUSED;
3249 struct answer *answer;
3251 node = parse_assertion (buf, limit, &answer, T_UNASSERT);
3252 /* It isn't an error to #unassert something that isn't asserted. */
3255 if (node->type == T_ASSERT)
3259 struct answer **p = find_answer (node, answer), *temp;
3261 /* Remove the answer from the list. */
3266 /* Did we free the last answer? */
3267 if (node->value.answers == 0)
3268 delete_macro (node);
3271 delete_macro (node);
3278 /* Returns a pointer to the pointer to the answer in the answer chain,
3279 or a pointer to NULL if the answer is not in the chain. */
3280 static struct answer **
3281 find_answer (node, candidate)
3283 const struct answer *candidate;
3285 struct answer **result;
3287 for (result = &node->value.answers; *result; result = &(*result)->next)
3289 struct answer *answer = *result;
3291 if (answer->len == candidate->len
3292 && !memcmp (answer->answer, candidate->answer, answer->len))
3299 /* Return a malloced buffer with leading and trailing whitespace
3300 removed, and all instances of internal whitespace reduced to a
3302 static unsigned char *
3303 canonicalize_text (buf, limit, climit)
3304 const unsigned char *buf, *limit, **climit;
3306 unsigned int len = limit - buf;
3307 unsigned char *result = (unsigned char *) xmalloc (len), *dest;
3309 for (dest = result; buf < limit;)
3311 if (! is_space (*buf))
3315 while (++buf < limit && is_space (*buf))
3317 if (dest != result && buf != limit)
3327 * handle #if command by
3328 * 1) inserting special `defined' keyword into the hash table
3329 * that gets turned into 0 or 1 by special_symbol (thus,
3330 * if the luser has a symbol called `defined' already, it won't
3331 * work inside the #if command)
3332 * 2) rescan the input into a temporary output buffer
3333 * 3) pass the output buffer to the yacc parser and collect a value
3334 * 4) clean up the mess left from steps 1 and 2.
3335 * 5) call conditional_skip to skip til the next #endif (etc.),
3336 * or not, depending on the value from step 3.
3339 do_if (buf, limit, op)
3340 U_CHAR *buf, *limit;
3341 FILE_BUF *op ATTRIBUTE_UNUSED;
3344 FILE_BUF *ip = &instack[indepth];
3346 value = eval_if_expression (buf, limit - buf);
3347 conditional_skip (ip, value == 0, T_IF);
3351 * handle a #elif directive by not changing if_stack either.
3352 * see the comment above do_else.
3355 do_elif (buf, limit, op)
3356 U_CHAR *buf, *limit;
3360 FILE_BUF *ip = &instack[indepth];
3362 if (if_stack == instack[indepth].if_stack) {
3363 error ("#elif not within a conditional");
3366 if (if_stack->type != T_IF && if_stack->type != T_ELIF) {
3367 error ("#elif after #else");
3368 fprintf (stderr, " (matches line %d", if_stack->lineno);
3369 if (if_stack->fname != NULL && ip->fname != NULL &&
3370 strcmp (if_stack->fname, ip->fname) != 0)
3371 fprintf (stderr, ", file %s", if_stack->fname);
3372 fprintf (stderr, ")\n");
3374 if_stack->type = T_ELIF;
3377 if (if_stack->if_succeeded)
3378 skip_if_group (ip, 0);
3380 value = eval_if_expression (buf, limit - buf);
3382 skip_if_group (ip, 0);
3384 ++if_stack->if_succeeded; /* continue processing input */
3385 output_line_command (ip, op, 1, same_file);
3391 * evaluate a #if expression in BUF, of length LENGTH,
3392 * then parse the result as a C expression and return the value as an int.
3395 eval_if_expression (buf, length)
3400 HASHNODE *save_defined;
3403 save_defined = install (U"defined", -1, T_SPEC_DEFINED, -1);
3404 temp_obuf = expand_to_temp_buffer (buf, buf + length, 0);
3405 delete_macro (save_defined); /* clean up special symbol */
3407 value = parse_c_expression ((const char *)temp_obuf.buf);
3409 free (temp_obuf.buf);
3415 * routine to handle ifdef/ifndef. Try to look up the symbol,
3416 * then do or don't skip to the #endif/#else/#elif depending
3417 * on what directive is actually being processed.
3420 do_xifdef (buf, limit, type)
3421 U_CHAR *buf, *limit;
3422 enum node_type type;
3425 FILE_BUF *ip = &instack[indepth];
3428 /* Discard leading and trailing whitespace. */
3429 SKIP_WHITE_SPACE (buf);
3430 while (limit != buf && is_nvspace (limit[-1])) limit--;
3432 /* Find the end of the identifier at the beginning. */
3433 for (end = buf; is_idchar (*end); end++);
3436 skip = (type == T_IFDEF);
3438 skip = (lookup (buf, end-buf, -1) == NULL) ^ (type == T_IFNDEF);
3440 conditional_skip (ip, skip, T_IF);
3444 do_ifdef (buf, limit, op)
3445 U_CHAR *buf, *limit;
3446 FILE_BUF *op ATTRIBUTE_UNUSED;
3448 do_xifdef (buf, limit, T_IFDEF);
3452 do_ifndef (buf, limit, op)
3453 U_CHAR *buf, *limit;
3454 FILE_BUF *op ATTRIBUTE_UNUSED;
3456 do_xifdef (buf, limit, T_IFNDEF);
3460 * push TYPE on stack; then, if SKIP is nonzero, skip ahead.
3463 conditional_skip (ip, skip, type)
3466 enum node_type type;
3468 IF_STACK_FRAME *temp;
3470 temp = (IF_STACK_FRAME *) xcalloc (1, sizeof (IF_STACK_FRAME));
3471 temp->fname = ip->fname;
3472 temp->lineno = ip->lineno;
3473 temp->next = if_stack;
3476 if_stack->type = type;
3479 skip_if_group (ip, 0);
3482 ++if_stack->if_succeeded;
3483 output_line_command (ip, &outbuf, 1, same_file);
3488 * skip to #endif, #else, or #elif. adjust line numbers, etc.
3489 * leaves input ptr at the sharp sign found.
3490 * If ANY is nonzero, return at next directive of any sort.
3493 skip_if_group (ip, any)
3497 register U_CHAR *bp = ip->bufp, *cp;
3498 register U_CHAR *endb = ip->buf + ip->length;
3499 struct directive *kt;
3500 IF_STACK_FRAME *save_if_stack = if_stack; /* don't pop past here */
3501 U_CHAR *beg_of_line = bp;
3505 case '/': /* possible comment */
3506 if (*bp == '\\' && bp[1] == '\n')
3510 bp = skip_to_end_of_comment (ip, &ip->lineno);
3515 bp = skip_quoted_string (bp - 1, endb, ip->lineno, &ip->lineno, 0, 0);
3518 /* Char after backslash loses its special meaning. */
3521 ++ip->lineno; /* But do update the line-count. */
3532 /* # keyword: a # must be first nonblank char on the line */
3533 if (beg_of_line == 0)
3535 /* Scan from start of line, skipping whitespace, comments
3536 and backslash-newlines, and see if we reach this #.
3537 If not, this # is not special. */
3540 if (is_nvspace (*bp))
3542 else if (*bp == '\\' && bp[1] == '\n')
3544 else if (*bp == '/' && bp[1] == '*') {
3546 while (!(*bp == '*' && bp[1] == '/')) {
3555 if (bp != ip->bufp) {
3556 bp = ip->bufp + 1; /* Reset bp to after the #. */
3560 bp = ip->bufp + 1; /* Point after '#'. */
3562 /* Skip whitespace and \-newline. */
3564 if (is_nvspace (*bp))
3566 else if (*bp == '\\' && bp[1] == '\n')
3568 else if (*bp == '/' && bp[1] == '*') {
3570 while (!(*bp == '*' && bp[1] == '/'))
3579 /* Now find end of directive name.
3580 If we encounter a backslash-newline, exchange it with any following
3581 symbol-constituents so that we end up with a contiguous name. */
3584 if (is_idchar (*bp))
3587 if (*bp == '\\' && bp[1] == '\n')
3588 name_newline_fix (bp);
3589 if (is_idchar (*bp))
3595 for (kt = directive_table; kt->length >= 0; kt++) {
3596 IF_STACK_FRAME *temp;
3597 if (strncmp ((const char *)cp, kt->name, kt->length) == 0
3598 && !is_idchar (cp[kt->length])) {
3600 /* If we are asked to return on next directive,
3609 temp = (IF_STACK_FRAME *) xcalloc (1, sizeof (IF_STACK_FRAME));
3610 temp->next = if_stack;
3612 temp->lineno = ip->lineno;
3613 temp->fname = ip->fname;
3614 temp->type = kt->type;
3619 if (if_stack == instack[indepth].if_stack) {
3620 error ("#%s not within a conditional", kt->name);
3623 else if (if_stack == save_if_stack)
3624 return; /* found what we came for */
3626 if (kt->type != T_ENDIF) {
3627 if (if_stack->type == T_ELSE)
3628 error ("#else or #elif after #else");
3629 if_stack->type = kt->type;
3634 if_stack = if_stack->next;
3639 /* Anything else is ignored. */
3648 /* after this returns, rescan will exit because ip->bufp
3649 now points to the end of the buffer.
3650 rescan is responsible for the error message also. */
3654 * handle a #else directive. Do this by just continuing processing
3655 * without changing if_stack ; this is so that the error message
3656 * for missing #endif's etc. will point to the original #if. It
3657 * is possible that something different would be better.
3660 do_else (buf, limit, op)
3661 U_CHAR *buf ATTRIBUTE_UNUSED;
3662 U_CHAR *limit ATTRIBUTE_UNUSED;
3665 FILE_BUF *ip = &instack[indepth];
3667 if (if_stack == instack[indepth].if_stack) {
3668 error ("#else not within a conditional");
3671 if (if_stack->type != T_IF && if_stack->type != T_ELIF) {
3672 error ("#else after #else");
3673 fprintf (stderr, " (matches line %d", if_stack->lineno);
3674 if (strcmp (if_stack->fname, ip->fname) != 0)
3675 fprintf (stderr, ", file %s", if_stack->fname);
3676 fprintf (stderr, ")\n");
3678 if_stack->type = T_ELSE;
3681 if (if_stack->if_succeeded)
3682 skip_if_group (ip, 0);
3684 ++if_stack->if_succeeded; /* continue processing input */
3685 output_line_command (ip, op, 1, same_file);
3690 * unstack after #endif command
3693 do_endif (buf, limit, op)
3694 U_CHAR *buf ATTRIBUTE_UNUSED;
3695 U_CHAR *limit ATTRIBUTE_UNUSED;
3698 if (if_stack == instack[indepth].if_stack)
3699 error ("unbalanced #endif");
3701 IF_STACK_FRAME *temp = if_stack;
3702 if_stack = if_stack->next;
3704 output_line_command (&instack[indepth], op, 1, same_file);
3709 * Skip a comment, assuming the input ptr immediately follows the
3710 * initial slash-star. Bump line counter as necessary.
3711 * (The canonical line counter is &ip->lineno).
3712 * Don't use this routine (or the next one) if bumping the line
3713 * counter is not sufficient to deal with newlines in the string.
3716 skip_to_end_of_comment (ip, line_counter)
3717 register FILE_BUF *ip;
3718 int *line_counter; /* place to remember newlines, or NULL */
3720 register U_CHAR *limit = ip->buf + ip->length;
3721 register U_CHAR *bp = ip->bufp;
3722 FILE_BUF *op = &outbuf; /* JF */
3723 int output = put_out_comments && !line_counter;
3725 /* JF this line_counter stuff is a crock to make sure the
3726 comment is only put out once, no matter how many times
3727 the comment is skipped. It almost works */
3732 while (bp < limit) {
3737 if (warn_comments && bp < limit && *bp == '*')
3738 warning("`/*' within comment");
3741 if (line_counter != NULL)
3747 if (*bp == '\\' && bp[1] == '\n')
3763 * Skip over a quoted string. BP points to the opening quote.
3764 * Returns a pointer after the closing quote. Don't go past LIMIT.
3765 * START_LINE is the line number of the starting point (but it need
3766 * not be valid if the starting point is inside a macro expansion).
3768 * The input stack state is not changed.
3770 * If COUNT_NEWLINES is nonzero, it points to an int to increment
3771 * for each newline passed.
3773 * If BACKSLASH_NEWLINES_P is nonzero, store 1 thru it
3774 * if we pass a backslash-newline.
3776 * If EOFP is nonzero, set *EOFP to 1 if the string is unterminated.
3779 skip_quoted_string (bp, limit, start_line, count_newlines, backslash_newlines_p, eofp)
3780 register const U_CHAR *bp;
3781 register const U_CHAR *limit;
3783 int *count_newlines;
3784 int *backslash_newlines_p;
3787 register U_CHAR c, match;
3792 error_with_line (line_for_error (start_line),
3793 "unterminated string or character constant");
3800 while (*bp == '\\' && bp[1] == '\n') {
3801 if (backslash_newlines_p)
3802 *backslash_newlines_p = 1;
3807 if (*bp == '\n' && count_newlines) {
3808 if (backslash_newlines_p)
3809 *backslash_newlines_p = 1;
3813 } else if (c == '\n') {
3814 /* Unterminated strings and character constants are 'legal'. */
3815 bp--; /* Don't consume the newline. */
3819 } else if (c == match)
3822 return (U_CHAR *) bp;
3826 * write out a #line command, for instance, after an #include file.
3827 * If CONDITIONAL is nonzero, we can omit the #line if it would
3828 * appear to be a no-op, and we can output a few newlines instead
3829 * if we want to increase the line number by a small amount.
3830 * FILE_CHANGE says whether we are entering a file, leaving, or neither.
3834 output_line_command (ip, op, conditional, file_change)
3837 enum file_change_code file_change;
3840 char line_cmd_buf[500];
3842 if (no_line_commands
3843 || ip->fname == NULL
3845 op->lineno = ip->lineno;
3850 if (ip->lineno == op->lineno)
3853 /* If the inherited line number is a little too small,
3854 output some newlines instead of a #line command. */
3855 if (ip->lineno > op->lineno && ip->lineno < op->lineno + 8) {
3856 check_expand (op, 10);
3857 while (ip->lineno > op->lineno) {
3865 sprintf (line_cmd_buf, "# %d \"%s\"", ip->lineno, ip->fname);
3866 if (file_change != same_file)
3867 strcat (line_cmd_buf, file_change == enter_file ? " 1" : " 2");
3868 if (system_include_depth > 0)
3869 strcat (line_cmd_buf, " 3");
3870 len = strlen (line_cmd_buf);
3871 line_cmd_buf[len++] = '\n';
3872 check_expand (op, len + 1);
3873 if (op->bufp > op->buf && op->bufp[-1] != '\n')
3875 memcpy (op->bufp, line_cmd_buf, len);
3877 op->lineno = ip->lineno;
3881 /* Expand a macro call.
3882 HP points to the symbol that is the macro being called.
3883 Put the result of expansion onto the input stack
3884 so that subsequent input by our caller will use it.
3886 If macro wants arguments, caller has already verified that
3887 an argument list follows; arguments come from the input stack. */
3890 macroexpand (hp, op)
3895 DEFINITION *defn = hp->value.defn;
3896 register U_CHAR *xbuf;
3898 int start_line = instack[indepth].lineno;
3900 CHECK_DEPTH (return;);
3902 /* it might not actually be a macro. */
3903 if (hp->type != T_MACRO) {
3904 special_symbol (hp, op);
3908 nargs = defn->nargs;
3912 struct argdata *args;
3913 const char *parse_error = 0;
3915 args = (struct argdata *) alloca ((nargs + 1) * sizeof (struct argdata));
3917 for (i = 0; i < nargs; i++) {
3918 args[i].raw = args[i].expanded = (U_CHAR *) "";
3919 args[i].raw_length = args[i].expand_length
3920 = args[i].stringified_length = 0;
3921 args[i].free1 = args[i].free2 = 0;
3924 /* Parse all the macro args that are supplied. I counts them.
3925 The first NARGS args are stored in ARGS.
3926 The rest are discarded. */
3929 /* Discard the open-parenthesis or comma before the next arg. */
3930 ++instack[indepth].bufp;
3932 = macarg ((i < nargs || (nargs == 0 && i == 0)) ? &args[i] : 0);
3935 error_with_line (line_for_error (start_line), parse_error);
3939 } while (*instack[indepth].bufp != ')');
3941 /* If we got one arg but it was just whitespace, call that 0 args. */
3943 register const U_CHAR *bp = args[0].raw;
3944 register const U_CHAR *lim = bp + args[0].raw_length;
3945 while (bp != lim && is_space (*bp)) bp++;
3950 if (nargs == 0 && i > 0)
3951 error ("arguments given to macro `%s'", hp->name);
3952 else if (i < nargs) {
3953 /* traditional C allows foo() if foo wants one argument. */
3954 if (nargs == 1 && i == 0)
3957 error ("no args to macro `%s'", hp->name);
3959 error ("only 1 arg to macro `%s'", hp->name);
3961 error ("only %d args to macro `%s'", i, hp->name);
3962 } else if (i > nargs)
3963 error ("too many (%d) args to macro `%s'", i, hp->name);
3965 /* Swallow the closeparen. */
3966 ++instack[indepth].bufp;
3968 /* If macro wants zero args, we parsed the arglist for checking only.
3969 Read directly from the macro definition. */
3971 xbuf = defn->expansion;
3972 xbuf_len = defn->length;
3974 register U_CHAR *exp = defn->expansion;
3975 register int offset; /* offset in expansion,
3976 copied a piece at a time */
3977 register int totlen; /* total amount of exp buffer filled so far */
3979 register struct reflist *ap;
3981 /* Macro really takes args. Compute the expansion of this call. */
3983 /* Compute length in characters of the macro's expansion. */
3984 xbuf_len = defn->length;
3985 for (ap = defn->pattern; ap != NULL; ap = ap->next) {
3987 xbuf_len += args[ap->argno].stringified_length;
3989 xbuf_len += args[ap->argno].raw_length;
3992 xbuf = (U_CHAR *) xmalloc (xbuf_len + 1);
3994 /* Generate in XBUF the complete expansion
3995 with arguments substituted in.
3996 TOTLEN is the total size generated so far.
3997 OFFSET is the index in the definition
3998 of where we are copying from. */
3999 offset = totlen = 0;
4000 for (ap = defn->pattern; ap != NULL; ap = ap->next) {
4001 register struct argdata *arg = &args[ap->argno];
4003 for (i = 0; i < ap->nchars; i++)
4004 xbuf[totlen++] = exp[offset++];
4006 if (ap->stringify != 0) {
4007 int arglen = arg->raw_length;
4013 && (c = arg->raw[i], is_space (c)))
4016 && (c = arg->raw[arglen - 1], is_space (c)))
4018 for (; i < arglen; i++) {
4021 /* Special markers Newline Space
4022 generate nothing for a stringified argument. */
4023 if (c == '\n' && arg->raw[i+1] != '\n') {
4028 /* Internal sequences of whitespace are replaced by one space
4029 except within an string or char token. */
4031 && (c == '\n' ? arg->raw[i+1] == '\n' : is_space (c))) {
4033 /* Note that Newline Space does occur within whitespace
4034 sequences; consider it part of the sequence. */
4035 if (c == '\n' && is_space (arg->raw[i+1]))
4037 else if (c != '\n' && is_space (c))
4054 } else if (c == '\"' || c == '\'')
4058 /* Escape these chars */
4059 if (c == '\"' || (in_string && c == '\\'))
4060 xbuf[totlen++] = '\\';
4064 sprintf ((char *) &xbuf[totlen], "\\%03o", (unsigned int) c);
4069 const U_CHAR *p1 = arg->raw;
4070 const U_CHAR *l1 = p1 + arg->raw_length;
4072 if (ap->raw_before) {
4073 while (p1 != l1 && is_space (*p1)) p1++;
4074 while (p1 != l1 && is_idchar (*p1))
4075 xbuf[totlen++] = *p1++;
4076 /* Delete any no-reexpansion marker that follows
4077 an identifier at the beginning of the argument
4078 if the argument is concatenated with what precedes it. */
4079 if (p1[0] == '\n' && p1[1] == '-')
4082 if (ap->raw_after) {
4083 /* Arg is concatenated after: delete trailing whitespace,
4084 whitespace markers, and no-reexpansion markers. */
4086 if (is_space (l1[-1])) l1--;
4087 else if (l1[-1] == '-') {
4088 const U_CHAR *p2 = l1 - 1;
4089 /* If a `-' is preceded by an odd number of newlines then it
4090 and the last newline are a no-reexpansion marker. */
4091 while (p2 != p1 && p2[-1] == '\n') p2--;
4092 if ((l1 - 1 - p2) & 1) {
4100 memmove (xbuf + totlen, p1, l1 - p1);
4104 if (totlen > xbuf_len)
4108 /* if there is anything left of the definition
4109 after handling the arg list, copy that in too. */
4111 for (i = offset; i < defn->length; i++)
4112 xbuf[totlen++] = exp[i];
4117 for (i = 0; i < nargs; i++) {
4118 if (args[i].free1 != 0)
4119 free (args[i].free1);
4120 if (args[i].free2 != 0)
4121 free (args[i].free2);
4125 xbuf = defn->expansion;
4126 xbuf_len = defn->length;
4129 /* Now put the expansion on the input stack
4130 so our caller will commence reading from it. */
4132 register FILE_BUF *ip2;
4134 ip2 = &instack[++indepth];
4139 ip2->length = xbuf_len;
4141 ip2->free_ptr = (nargs > 0) ? xbuf : 0;
4143 ip2->if_stack = if_stack;
4148 * Parse a macro argument and store the info on it into *ARGPTR.
4149 * Return nonzero to indicate a syntax error.
4154 register struct argdata *argptr;
4156 FILE_BUF *ip = &instack[indepth];
4161 /* Try to parse as much of the argument as exists at this
4162 input stack level. */
4163 U_CHAR *bp = macarg1 (ip->bufp, ip->buf + ip->length,
4164 &paren, &newlines, &comments);
4166 /* If we find the end of the argument at this level,
4167 set up *ARGPTR to point at it in the input stack. */
4168 if (!(ip->fname != 0 && (newlines != 0 || comments != 0))
4169 && bp != ip->buf + ip->length) {
4171 argptr->raw = ip->bufp;
4172 argptr->raw_length = bp - ip->bufp;
4176 /* This input stack level ends before the macro argument does.
4177 We must pop levels and keep parsing.
4178 Therefore, we must allocate a temporary buffer and copy
4179 the macro argument into it. */
4180 int bufsize = bp - ip->bufp;
4181 int extra = newlines;
4182 U_CHAR *buffer = (U_CHAR *) xmalloc (bufsize + extra + 1);
4183 int final_start = 0;
4185 memcpy (buffer, ip->bufp, bufsize);
4187 ip->lineno += newlines;
4189 while (bp == ip->buf + ip->length) {
4190 if (instack[indepth].macro == 0) {
4192 return "unterminated macro call";
4194 ip->macro->type = T_MACRO;
4196 free (ip->free_ptr);
4197 ip = &instack[--indepth];
4200 bp = macarg1 (ip->bufp, ip->buf + ip->length, &paren,
4201 &newlines, &comments);
4202 final_start = bufsize;
4203 bufsize += bp - ip->bufp;
4205 buffer = (U_CHAR *) xrealloc (buffer, bufsize + extra + 1);
4206 memcpy (buffer + bufsize - (bp - ip->bufp), ip->bufp, bp - ip->bufp);
4208 ip->lineno += newlines;
4211 /* Now, if arg is actually wanted, record its raw form,
4212 discarding comments and duplicating newlines in whatever
4213 part of it did not come from a macro expansion.
4214 EXTRA space has been preallocated for duplicating the newlines.
4215 FINAL_START is the index of the start of that part. */
4217 argptr->raw = buffer;
4218 argptr->raw_length = bufsize;
4219 argptr->free1 = buffer;
4220 argptr->newlines = newlines;
4221 argptr->comments = comments;
4222 if ((newlines || comments) && ip->fname != 0)
4225 discard_comments (argptr->raw + final_start,
4226 argptr->raw_length - final_start,
4228 argptr->raw[argptr->raw_length] = 0;
4229 if (argptr->raw_length > bufsize + extra)
4234 /* If we are not discarding this argument,
4235 macroexpand it and compute its length as stringified.
4236 All this info goes into *ARGPTR. */
4240 register const U_CHAR *buf, *lim;
4241 register int totlen;
4243 obuf = expand_to_temp_buffer (argptr->raw,
4244 argptr->raw + argptr->raw_length,
4247 argptr->expanded = obuf.buf;
4248 argptr->expand_length = obuf.length;
4249 argptr->free2 = obuf.buf;
4252 lim = buf + argptr->raw_length;
4255 while (buf != lim) {
4256 register U_CHAR c = *buf++;
4258 /* Internal sequences of whitespace are replaced by one space
4259 in most cases, but not always. So count all the whitespace
4260 in case we need to keep it all. */
4261 if (c == '\"' || c == '\\') /* escape these chars */
4263 else if (!ISPRINT (c))
4266 argptr->stringified_length = totlen;
4271 /* Scan text from START (inclusive) up to LIMIT (exclusive),
4272 counting parens in *DEPTHPTR,
4273 and return if reach LIMIT
4274 or before a `)' that would make *DEPTHPTR negative
4275 or before a comma when *DEPTHPTR is zero.
4276 Single and double quotes are matched and termination
4277 is inhibited within them. Comments also inhibit it.
4278 Value returned is pointer to stopping place.
4280 Increment *NEWLINES each time a newline is passed.
4281 Set *COMMENTS to 1 if a comment is seen. */
4284 macarg1 (start, limit, depthptr, newlines, comments)
4286 register const U_CHAR *limit;
4287 int *depthptr, *newlines, *comments;
4289 register U_CHAR *bp = start;
4291 while (bp < limit) {
4297 if (--(*depthptr) < 0)
4301 /* Traditionally, backslash makes following char not special. */
4305 /* But count source lines anyway. */
4314 if (bp[1] == '\\' && bp[2] == '\n')
4315 newline_fix (bp + 1);
4316 if (bp[1] != '*' || bp + 1 >= limit)
4320 while (bp + 1 < limit) {
4322 && bp[1] == '\\' && bp[2] == '\n')
4323 newline_fix (bp + 1);
4324 if (bp[0] == '*' && bp[1] == '/')
4326 if (*bp == '\n') ++*newlines;
4335 for (quotec = *bp++; bp + 1 < limit && *bp != quotec; bp++) {
4340 while (*bp == '\\' && bp[1] == '\n') {
4343 } else if (*bp == '\n') {
4352 if ((*depthptr) == 0)
4362 /* Discard comments and duplicate newlines
4363 in the string of length LENGTH at START,
4364 except inside of string constants.
4365 The string is copied into itself with its beginning staying fixed.
4367 NEWLINES is the number of newlines that must be duplicated.
4368 We assume that that much extra space is available past the end
4372 discard_comments (start, length, newlines)
4377 register U_CHAR *ibp;
4378 register U_CHAR *obp;
4379 register const U_CHAR *limit;
4382 /* If we have newlines to duplicate, copy everything
4383 that many characters up. Then, in the second part,
4384 we will have room to insert the newlines
4386 NEWLINES may actually be too large, because it counts
4387 newlines in string constants, and we don't duplicate those.
4388 But that does no harm. */
4390 ibp = start + length;
4391 obp = ibp + newlines;
4393 while (limit != ibp)
4397 ibp = start + newlines;
4398 limit = start + length + newlines;
4401 while (ibp < limit) {
4402 *obp++ = c = *ibp++;
4405 /* Duplicate the newline. */
4417 if (*ibp == '\\' && ibp[1] == '\n')
4419 /* Delete any comment. */
4420 if (ibp[0] != '*' || ibp + 1 >= limit)
4424 while (ibp + 1 < limit) {
4426 && ibp[1] == '\\' && ibp[2] == '\n')
4427 newline_fix (ibp + 1);
4428 if (ibp[0] == '*' && ibp[1] == '/')
4437 /* Notice and skip strings, so that we don't
4438 think that comments start inside them,
4439 and so we don't duplicate newlines in them. */
4442 while (ibp < limit) {
4443 *obp++ = c = *ibp++;
4446 if (c == '\n' && quotec == '\'')
4448 if (c == '\\' && ibp < limit) {
4449 while (*ibp == '\\' && ibp[1] == '\n')
4463 /* Core error handling routine. */
4465 v_message (mtype, line, msgid, ap)
4471 const char *fname = 0;
4474 if (mtype == WARNING && inhibit_warnings)
4477 for (i = indepth; i >= 0; i--)
4478 if (instack[i].fname != NULL) {
4480 line = instack[i].lineno;
4481 fname = instack[i].fname;
4486 fprintf (stderr, "%s:%d: ", fname, line);
4488 fprintf (stderr, "%s: ", progname);
4490 if (mtype == WARNING)
4491 fputs ("warning: ", stderr);
4493 vfprintf (stderr, msgid, ap);
4494 putc ('\n', stderr);
4501 * error - print error message and increment count of errors.
4504 error VPARAMS ((const char *msgid, ...))
4506 #ifndef ANSI_PROTOTYPES
4511 VA_START(ap, msgid);
4513 #ifndef ANSI_PROTOTYPES
4514 msgid = va_arg (ap, const char *);
4517 v_message (ERROR, 0, msgid, ap);
4521 error_with_line VPARAMS ((int line, const char *msgid, ...))
4523 #ifndef ANSI_PROTOTYPES
4529 VA_START(ap, msgid);
4531 #ifndef ANSI_PROTOTYPES
4532 line = va_arg (ap, int);
4533 msgid = va_arg (ap, const char *);
4536 v_message (ERROR, line, msgid, ap);
4539 /* Error including a message from `errno'. */
4541 error_from_errno (name)
4544 error ("%s: %s", name, strerror (errno));
4547 /* Print error message but don't count it. */
4549 warning VPARAMS ((const char *msgid, ...))
4551 #ifndef ANSI_PROTOTYPES
4556 VA_START(ap, msgid);
4558 #ifndef ANSI_PROTOTYPES
4559 msgid = va_arg (ap, const char *);
4562 v_message (WARNING, 0, msgid, ap);
4566 fatal VPARAMS ((const char *msgid, ...))
4568 #ifndef ANSI_PROTOTYPES
4573 VA_START(ap, msgid);
4575 #ifndef ANSI_PROTOTYPES
4576 msgid = va_arg (ap, const char *);
4579 v_message (FATAL, 0, msgid, ap);
4580 exit (FATAL_EXIT_CODE);
4583 /* More 'friendly' abort that prints the location at which we died. */
4585 fancy_abort (line, func)
4589 fatal ("Internal error in %s, at tradcpp.c:%d\n\
4590 Please submit a full bug report.\n\
4591 See %s for instructions.", func, line, GCCBUGURL);
4595 perror_with_name (name)
4598 fprintf (stderr, "%s: %s: %s\n", progname, name, strerror (errno));
4603 pfatal_with_name (name)
4606 perror_with_name (name);
4607 exit (FATAL_EXIT_CODE);
4610 /* Return the line at which an error occurred.
4611 The error is not necessarily associated with the current spot
4612 in the input stack, so LINE says where. LINE will have been
4613 copied from ip->lineno for the current input level.
4614 If the current level is for a file, we return LINE.
4615 But if the current level is not for a file, LINE is meaningless.
4616 In that case, we return the lineno of the innermost file. */
4618 line_for_error (line)
4624 for (i = indepth; i >= 0; ) {
4625 if (instack[i].fname != 0)
4630 line1 = instack[i].lineno;
4636 * If OBUF doesn't have NEEDED bytes after OPTR, make it bigger.
4638 * As things stand, nothing is ever placed in the output buffer to be
4639 * removed again except when it's KNOWN to be part of an identifier,
4640 * so flushing and moving down everything left, instead of expanding,
4645 grow_outbuf (obuf, needed)
4646 register FILE_BUF *obuf;
4647 register int needed;
4652 if (obuf->length - (obuf->bufp - obuf->buf) > needed)
4655 /* Make it at least twice as big as it is now. */
4657 /* Make it have at least 150% of the free space we will need. */
4658 minsize = (3 * needed) / 2 + (obuf->bufp - obuf->buf);
4659 if (minsize > obuf->length)
4660 obuf->length = minsize;
4662 p = (U_CHAR *) xrealloc (obuf->buf, obuf->length);
4663 obuf->bufp = p + (obuf->bufp - obuf->buf);
4667 /* Symbol table for macro names and special symbols */
4670 * install a name in the main hash table, even if it is already there.
4671 * name stops with first non alphanumeric, except leading '#'.
4672 * caller must check against redefinition if that is desired.
4673 * delete_macro () removes things installed by install () in fifo order.
4674 * this is important because of the `defined' special symbol used
4675 * in #if, and also if pushdef/popdef directives are ever implemented.
4677 * If LEN is >= 0, it is the length of the name.
4678 * Otherwise, compute the length by scanning the entire name.
4680 * If HASH is >= 0, it is the precomputed hash code.
4681 * Otherwise, compute the hash code.
4683 * caller must set the value, if any is desired.
4686 install (name, len, type, hash)
4689 enum node_type type;
4691 /* watch out here if sizeof (U_CHAR *) != sizeof (int) */
4693 register HASHNODE *hp;
4694 register int bucket;
4695 register const U_CHAR *p;
4700 while (is_idchar (*p))
4706 hash = hashf (name, len, HASHSIZE);
4708 hp = (HASHNODE *) xmalloc (sizeof (HASHNODE) + len + 1);
4710 hp->bucket_hdr = &hashtab[bucket];
4711 hp->next = hashtab[bucket];
4712 hashtab[bucket] = hp;
4714 if (hp->next != NULL)
4715 hp->next->prev = hp;
4718 hp->name = q = ((U_CHAR *) hp) + sizeof (HASHNODE);
4719 memcpy (q, name, len);
4725 * find the most recent hash node for name name (ending with first
4726 * non-identifier char) installed by install
4728 * If LEN is >= 0, it is the length of the name.
4729 * Otherwise, compute the length by scanning the entire name.
4731 * If HASH is >= 0, it is the precomputed hash code.
4732 * Otherwise, compute the hash code.
4735 lookup (name, len, hash)
4740 register const U_CHAR *bp;
4741 register HASHNODE *bucket;
4744 for (bp = name; is_idchar (*bp); bp++) ;
4749 hash = hashf (name, len, HASHSIZE);
4751 bucket = hashtab[hash];
4753 if (bucket->length == len
4754 && strncmp ((const char *)bucket->name, (const char *)name, len) == 0)
4756 bucket = bucket->next;
4762 * Delete a hash node. Some weirdness to free junk from macros.
4763 * More such weirdness will have to be added if you define more hash
4764 * types that need it.
4767 /* Note that the DEFINITION of a macro is removed from the hash table
4768 but its storage is not freed. This would be a storage leak
4769 except that it is not reasonable to keep undefining and redefining
4770 large numbers of macros many times.
4771 In any case, this is necessary, because a macro can be #undef'd
4772 in the middle of reading the arguments to a call to it.
4773 If #undef freed the DEFINITION, that would crash. */
4779 if (hp->prev != NULL)
4780 hp->prev->next = hp->next;
4781 if (hp->next != NULL)
4782 hp->next->prev = hp->prev;
4784 /* make sure that the bucket chain header that
4785 the deleted guy was on points to the right thing afterwards. */
4786 if (hp == *hp->bucket_hdr)
4787 *hp->bucket_hdr = hp->next;
4793 * return hash function on name. must be compatible with the one
4794 * computed a step at a time, elsewhere
4797 hashf (name, len, hashsize)
4798 register const U_CHAR *name;
4805 r = HASHSTEP (r, *name++);
4807 return MAKE_POS (r) % hashsize;
4810 /* Dump all macro definitions as #defines to stdout. */
4817 for (bucket = 0; bucket < HASHSIZE; bucket++) {
4818 register HASHNODE *hp;
4820 for (hp = hashtab[bucket]; hp; hp= hp->next) {
4821 if (hp->type == T_MACRO) {
4822 register DEFINITION *defn = hp->value.defn;
4828 /* Print the definition of the macro HP. */
4830 printf ("#define %s", hp->name);
4831 if (defn->nargs >= 0) {
4835 for (i = 0; i < defn->nargs; i++) {
4836 dump_arg_n (defn, i);
4837 if (i + 1 < defn->nargs)
4847 for (ap = defn->pattern; ap != NULL; ap = ap->next) {
4848 dump_defn_1 (defn->expansion, offset, ap->nchars);
4849 if (ap->nchars != 0)
4851 offset += ap->nchars;
4854 if (ap->raw_before && !concat)
4857 dump_arg_n (defn, ap->argno);
4858 if (ap->raw_after) {
4863 dump_defn_1 (defn->expansion, offset, defn->length - offset);
4870 /* Output to stdout a substring of a macro definition.
4871 BASE is the beginning of the definition.
4872 Output characters START thru LENGTH.
4873 Discard newlines outside of strings, thus
4874 converting funny-space markers to ordinary spaces. */
4876 dump_defn_1 (base, start, length)
4881 const U_CHAR *p = base + start;
4882 const U_CHAR *limit = base + start + length;
4887 else if (*p == '\"' || *p =='\'') {
4888 const U_CHAR *p1 = skip_quoted_string (p, limit, 0, 0, 0, 0);
4889 fwrite (p, p1 - p, 1, stdout);
4896 /* Print the name of argument number ARGNUM of macro definition DEFN.
4897 Recall that DEFN->argnames contains all the arg names
4898 concatenated in reverse order with comma-space in between. */
4900 dump_arg_n (defn, argnum)
4904 register const U_CHAR *p = defn->argnames;
4905 while (argnum + 1 < defn->nargs) {
4906 p = (const U_CHAR *) strchr ((const char *)p, ' ') + 1;
4910 while (*p && *p != ',') {
4916 /* Initialize the built-in macros. */
4917 #define DSC(x) U x, sizeof x - 1
4918 #define install_spec(name, type) \
4919 install(DSC(name), type, -1);
4920 #define install_value(name, val) \
4921 hp = install(DSC(name), T_CONST, -1); hp->value.cpval = val;
4923 initialize_builtins ()
4927 install_spec ("__BASE_FILE__", T_BASE_FILE);
4928 install_spec ("__DATE__", T_DATE);
4929 install_spec ("__FILE__", T_FILE);
4930 install_spec ("__TIME__", T_TIME);
4931 install_spec ("__VERSION__", T_VERSION);
4932 install_spec ("__INCLUDE_LEVEL__", T_INCLUDE_LEVEL);
4933 install_spec ("__LINE__", T_SPECLINE);
4935 #ifndef NO_BUILTIN_SIZE_TYPE
4936 install_value ("__SIZE_TYPE__", SIZE_TYPE);
4938 #ifndef NO_BUILTIN_PTRDIFF_TYPE
4939 install_value ("__PTRDIFF_TYPE__", PTRDIFF_TYPE);
4941 #ifndef NO_BUILTIN_WCHAR_TYPE
4942 install_value ("__WCHAR_TYPE__", WCHAR_TYPE);
4944 #ifndef NO_BUILTIN_WINT_TYPE
4945 install_value ("__WINT_TYPE__", WINT_TYPE);
4947 install_value ("__REGISTER_PREFIX__", REGISTER_PREFIX);
4948 install_value ("__USER_LABEL_PREFIX__", user_label_prefix);
4952 #undef install_value
4954 /* Common handler of command line directives -U, -D and -A. */
4956 run_directive (str, len, type)
4959 enum node_type type;
4961 struct directive *kt;
4962 FILE_BUF *ip = &instack[++indepth];
4963 ip->fname = "*command line*";
4965 ip->buf = ip->bufp = (U_CHAR *) str;
4970 ip->if_stack = if_stack;
4972 for (kt = directive_table; kt->type != type; kt++)
4975 (*kt->func) ((U_CHAR *) str, (U_CHAR *) str + len, NULL);
4979 /* Handle the -D option. If STR is just an identifier, define it with
4980 * value 1. If STR has anything after the identifier, then it should
4981 * be identifier-space-definition. */
4983 make_definition (str)
4989 /* Copy the entire option so we can modify it.
4990 Change the first "=" in the string to a space. If there is none,
4991 tack " 1" on the end. */
4993 /* Length including the null. */
4994 count = strlen (str);
4995 buf = (char *) alloca (count + 2);
4996 memcpy (buf, str, count);
4998 p = strchr (str, '=');
5007 run_directive (buf, count, T_DEFINE);
5010 /* Handle the -U option. */
5015 run_directive (str, strlen (str), T_UNDEF);
5018 /* Handles the #assert (-A) and #unassert (-A-) command line options. */
5020 make_assertion (str)
5023 enum node_type type = T_ASSERT;
5033 count = strlen (str);
5034 p = strchr (str, '=');
5037 /* Copy the entire option so we can modify it. Change the first
5038 "=" in the string to a '(', and tack a ')' on the end. */
5039 char *buf = (char *) alloca (count + 1);
5041 memcpy (buf, str, count);
5047 run_directive (str, count, type);
5050 /* Add output to `deps_buffer' for the -M switch.
5051 STRING points to the text to be output.
5052 SIZE is the number of bytes, or 0 meaning output until a null.
5053 If SIZE is nonzero, we break the line first, if it is long enough. */
5055 deps_output (string, size)
5059 #ifndef MAX_OUTPUT_COLUMNS
5060 #define MAX_OUTPUT_COLUMNS 75
5062 if (size != 0 && deps_column != 0
5063 && size + deps_column > MAX_OUTPUT_COLUMNS) {
5064 deps_output ("\\\n ", 0);
5069 size = strlen (string);
5071 if (deps_size + size + 1 > deps_allocated_size) {
5072 deps_allocated_size = deps_size + size + 50;
5073 deps_allocated_size *= 2;
5074 deps_buffer = (char *) xrealloc (deps_buffer, deps_allocated_size);
5076 memcpy (&deps_buffer[deps_size], string, size);
5078 deps_column += size;
5079 deps_buffer[deps_size] = 0;
5082 /* Get the file-mode and data size of the file open on FD
5083 and store them in *MODE_POINTER and *SIZE_POINTER. */
5086 file_size_and_mode (fd, mode_pointer, size_pointer)
5093 if (fstat (fd, &sbuf) < 0) return -1;
5094 if (mode_pointer) *mode_pointer = sbuf.st_mode;
5095 if (size_pointer) *size_pointer = sbuf.st_size;