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 /* different kinds of things that can appear in the value field
192 of a hash node. Actually, this may be useless now. */
199 /* The structure of a node in the hash table. The hash table
200 has entries for all tokens defined by #define commands (type T_MACRO),
201 plus some special tokens like __LINE__ (these each have their own
202 type, and the appropriate code is run when that type of node is seen.
203 It does not contain control words like "#define", which are recognized
204 by a separate piece of code. */
206 /* different flavors of hash nodes --- also used in keyword table */
208 T_DEFINE = 1, /* `#define' */
209 T_INCLUDE, /* `#include' */
210 T_IFDEF, /* `#ifdef' */
211 T_IFNDEF, /* `#ifndef' */
213 T_ELSE, /* `#else' */
214 T_ELIF, /* `#elif' */
215 T_UNDEF, /* `#undef' */
216 T_LINE, /* `#line' */
217 T_ENDIF, /* `#endif' */
218 T_ASSERT, /* `#assert' */
219 T_UNASSERT, /* `#unassert' */
220 T_SPECLINE, /* special symbol `__LINE__' */
221 T_DATE, /* `__DATE__' */
222 T_FILE, /* `__FILE__' */
223 T_BASE_FILE, /* `__BASE_FILE__' */
224 T_INCLUDE_LEVEL, /* `__INCLUDE_LEVEL__' */
225 T_VERSION, /* `__VERSION__' */
226 T_TIME, /* `__TIME__' */
227 T_CONST, /* Constant value, used by `__STDC__' */
228 T_MACRO, /* macro defined by `#define' */
229 T_SPEC_DEFINED, /* special `defined' macro for use in #if statements */
230 T_UNUSED /* Used for something not defined. */
234 struct hashnode *next; /* double links for easy deletion */
235 struct hashnode *prev;
236 struct hashnode **bucket_hdr; /* also, a back pointer to this node's hash
237 chain is kept, in case the node is the head
238 of the chain and gets deleted. */
239 enum node_type type; /* type of special token */
240 int length; /* length of token, for quick comparison */
241 U_CHAR *name; /* the actual name */
242 union hashval value; /* pointer to expansion, or whatever */
245 typedef struct hashnode HASHNODE;
247 /* Some definitions for the hash table. The hash function MUST be
248 computed as shown in hashf () below. That is because the rescan
249 loop computes the hash value `on the fly' for most tokens,
250 in order to avoid the overhead of a lot of procedure calls to
251 the hashf () function. Hashf () only exists for the sake of
252 politeness, for use when speed isn't so important. */
254 #define HASHSIZE 1403
255 HASHNODE *hashtab[HASHSIZE];
256 #define HASHSTEP(old, c) ((old << 2) + c)
257 #define MAKE_POS(v) (v & 0x7fffffff) /* make number positive */
259 /* `struct directive' defines one #-directive, including how to handle it. */
262 int length; /* Length of name */
263 void (*func) PARAMS ((U_CHAR *, U_CHAR *, FILE_BUF *));
264 /* Function to handle directive */
265 const char *name; /* Name of directive */
266 enum node_type type; /* Code which describes which directive. */
269 /* Last arg to output_line_command. */
270 enum file_change_code {same_file, enter_file, leave_file};
272 /* This structure represents one parsed argument in a macro call.
273 `raw' points to the argument text as written (`raw_length' is its length).
274 `expanded' points to the argument's macro-expansion
275 (its length is `expand_length').
276 `stringified_length' is the length the argument would have
278 `free1' and `free2', if nonzero, point to blocks to be freed
279 when the macro argument data is no longer needed. */
282 U_CHAR *raw, *expanded;
283 int raw_length, expand_length;
284 int stringified_length;
285 U_CHAR *free1, *free2;
290 /* The arglist structure is built by do_define to tell
291 collect_definition where the argument names begin. That
292 is, for a define like "#define f(x,y,z) foo+x-bar*y", the arglist
293 would contain pointers to the strings x, y, and z.
294 Collect_definition would then build a DEFINITION node,
295 with reflist nodes pointing to the places x, y, and z had
296 appeared. So the arglist is just convenience data passed
297 between these two routines. It is not kept around after
298 the current #define has been processed and entered into the
302 struct arglist *next;
308 /* Function prototypes. */
310 static void do_define PARAMS ((U_CHAR *, U_CHAR *, FILE_BUF *));
311 static void do_line PARAMS ((U_CHAR *, U_CHAR *, FILE_BUF *));
312 static void do_include PARAMS ((U_CHAR *, U_CHAR *, FILE_BUF *));
313 static void do_undef PARAMS ((U_CHAR *, U_CHAR *, FILE_BUF *));
314 static void do_if PARAMS ((U_CHAR *, U_CHAR *, FILE_BUF *));
315 static void do_ifdef PARAMS ((U_CHAR *, U_CHAR *, FILE_BUF *));
316 static void do_ifndef PARAMS ((U_CHAR *, U_CHAR *, FILE_BUF *));
317 static void do_else PARAMS ((U_CHAR *, U_CHAR *, FILE_BUF *));
318 static void do_elif PARAMS ((U_CHAR *, U_CHAR *, FILE_BUF *));
319 static void do_endif PARAMS ((U_CHAR *, U_CHAR *, FILE_BUF *));
320 static void do_assert PARAMS ((U_CHAR *, U_CHAR *, FILE_BUF *));
321 static void do_unassert PARAMS ((U_CHAR *, U_CHAR *, FILE_BUF *));
322 static void do_xifdef PARAMS ((U_CHAR *, U_CHAR *, enum node_type));
324 static struct hashnode *install PARAMS ((const U_CHAR *, int, enum node_type, int));
325 static int hashf PARAMS ((const U_CHAR *, int, int));
326 static int compare_defs PARAMS ((DEFINITION *, DEFINITION *));
327 static int comp_def_part PARAMS ((int, const U_CHAR *, int,
328 const U_CHAR *, int, int));
329 static void delete_macro PARAMS ((HASHNODE *));
331 /* First arg to v_message. */
332 enum msgtype { WARNING = 0, ERROR, FATAL };
333 static void v_message PARAMS ((enum msgtype mtype, int line,
334 const char *msgid, va_list ap))
335 ATTRIBUTE_PRINTF (3, 0);
337 static int line_for_error PARAMS ((int));
339 /* We know perfectly well which file this is, so we don't need to
342 #if (GCC_VERSION >= 2007)
343 #define abort() fancy_abort(__LINE__, __FUNCTION__)
345 #define abort() fancy_abort(__LINE__, 0);
348 static void macroexpand PARAMS ((HASHNODE *, FILE_BUF *));
349 static void special_symbol PARAMS ((HASHNODE *, FILE_BUF *));
350 static void dump_all_macros PARAMS ((void));
351 static void dump_defn_1 PARAMS ((const U_CHAR *, int, int));
352 static void dump_arg_n PARAMS ((DEFINITION *, int));
353 static void conditional_skip PARAMS ((FILE_BUF *, int, enum node_type));
354 static void skip_if_group PARAMS ((FILE_BUF *, int));
355 static void output_line_command PARAMS ((FILE_BUF *, FILE_BUF *,
356 int, enum file_change_code));
358 static int eval_if_expression PARAMS ((const U_CHAR *, int));
360 static void initialize_char_syntax PARAMS ((void));
361 static void initialize_builtins PARAMS ((void));
362 static void run_directive PARAMS ((const char *, size_t,
364 static void make_definition PARAMS ((const char *));
365 static void make_undef PARAMS ((const char *));
366 static void make_assertion PARAMS ((const char *));
368 static void grow_outbuf PARAMS ((FILE_BUF *, int));
369 static int handle_directive PARAMS ((FILE_BUF *, FILE_BUF *));
370 static void finclude PARAMS ((int, const char *, FILE_BUF *));
371 static void deps_output PARAMS ((const char *, int));
372 static void rescan PARAMS ((FILE_BUF *, int));
373 static void newline_fix PARAMS ((U_CHAR *));
374 static void name_newline_fix PARAMS ((U_CHAR *));
375 static U_CHAR *macarg1 PARAMS ((U_CHAR *, const U_CHAR *, int *,
377 static const char *macarg PARAMS ((struct argdata *));
378 static int discard_comments PARAMS ((U_CHAR *, int, int));
379 static int file_size_and_mode PARAMS ((int, int *, long *));
381 static U_CHAR *skip_to_end_of_comment PARAMS ((FILE_BUF *, int *));
382 static U_CHAR *skip_quoted_string PARAMS ((const U_CHAR *, const U_CHAR *,
383 int, int *, int *, int *));
385 int main PARAMS ((int, char **));
387 /* Convenience. Write U"string" to get an unsigned string constant. */
388 #define U (const unsigned char *)
390 /* Here is the actual list of #-directives, most-often-used first. */
392 struct directive directive_table[] = {
393 { 6, do_define, "define", T_DEFINE },
394 { 7, do_include, "include", T_INCLUDE },
395 { 5, do_endif, "endif", T_ENDIF },
396 { 5, do_ifdef, "ifdef", T_IFDEF },
397 { 2, do_if, "if", T_IF, },
398 { 4, do_else, "else", T_ELSE },
399 { 6, do_ifndef, "ifndef", T_IFNDEF },
400 { 5, do_undef, "undef", T_UNDEF },
401 { 4, do_line, "line", T_LINE },
402 { 4, do_elif, "elif", T_ELIF },
403 { 6, do_assert, "assert", T_ASSERT },
404 { 8, do_unassert,"unassert",T_UNASSERT},
405 { -1, 0, "", T_UNUSED},
408 /* table to tell if char can be part of a C identifier. */
409 U_CHAR is_idchar[256];
410 /* table to tell if char can be first char of a c identifier. */
411 U_CHAR is_idstart[256];
412 /* table to tell if c is horizontal space. */
413 U_CHAR is_hor_space[256];
414 /* table to tell if c is horizontal or vertical space. */
415 U_CHAR is_space[256];
417 #define SKIP_WHITE_SPACE(p) do { while (is_hor_space[*p]) p++; } while (0)
418 #define SKIP_ALL_WHITE_SPACE(p) do { while (is_space[*p]) p++; } while (0)
420 int errors = 0; /* Error counter for exit code */
422 static FILE_BUF expand_to_temp_buffer PARAMS ((const U_CHAR *, const U_CHAR *, int));
423 static DEFINITION *collect_expansion PARAMS ((U_CHAR *, U_CHAR *, int,
426 /* Stack of conditionals currently in progress
427 (including both successful and failing conditionals). */
430 struct if_stack *next; /* for chaining to the next stack frame */
431 const char *fname; /* copied from input when frame is made */
432 int lineno; /* similarly */
433 int if_succeeded; /* true if a leg of this if-group
434 has been passed through rescan */
435 enum node_type type; /* type of last directive seen in this group */
437 typedef struct if_stack IF_STACK_FRAME;
438 IF_STACK_FRAME *if_stack = NULL;
440 /* Buffer of -M output. */
444 /* Number of bytes allocated in above. */
445 int deps_allocated_size;
447 /* Number of bytes used. */
450 /* Number of bytes since the last newline. */
453 /* Nonzero means -I- has been seen,
454 so don't look for #include "foo" the source-file directory. */
457 /* Pending directives. */
458 enum pending_dir_t {PD_NONE = 0, PD_DEFINE, PD_UNDEF, PD_ASSERTION, PD_FILE};
460 typedef struct pending_dir pending_dir;
464 enum pending_dir_t type;
474 const char *in_fname, *out_fname;
477 pending_dir *pend = (pending_dir *) xcalloc (argc, sizeof (pending_dir));
478 int no_standard_includes = 0;
480 /* Non-0 means don't output the preprocessed program. */
481 int inhibit_output = 0;
483 /* Stream on which to print the dependency information. */
484 FILE *deps_stream = 0;
485 /* Target-name to write with the dependency information. */
486 char *deps_target = 0;
489 /* Get rid of any avoidable limit on stack size. */
493 /* Set the stack limit huge so that alloca (particularly stringtab
494 * in dbxread.c) does not fail. */
495 getrlimit (RLIMIT_STACK, &rlim);
496 rlim.rlim_cur = rlim.rlim_max;
497 setrlimit (RLIMIT_STACK, &rlim);
499 #endif /* RLIMIT_STACK defined */
506 /* Initialize is_idchar to allow $. */
507 initialize_char_syntax ();
509 no_line_commands = 0;
513 max_include_len = cpp_GCC_INCLUDE_DIR_len + 7; /* ??? */
515 /* Process switches and find input file name. */
517 for (i = 1; i < argc; i++) {
518 if (argv[i][0] != '-') {
519 if (out_fname != NULL)
520 fatal ("Usage: %s [switches] input output", argv[0]);
521 else if (in_fname != NULL)
532 break; /* Ignore for compatibility with ISO/extended cpp. */
535 if (!strcmp (argv[i], "-lang-c++")
536 || !strcmp (argv[i], "-lang-objc++"))
537 fatal ("-traditional is not supported in C++");
538 else if (!strcmp (argv[i], "-lang-c89"))
539 fatal ("-traditional and -ansi are mutually exclusive");
540 else if (!strcmp (argv[i], "-lang-objc"))
541 pend[i].type = PD_DEFINE, pend[i].arg = "__OBJC__";
542 else if (!strcmp (argv[i], "-lang-asm"))
543 pend[i].type = PD_DEFINE, pend[i].arg = "__ASSEMBLER__";
544 else if (!strcmp (argv[i], "-lang-fortran"))
545 pend[i].type = PD_DEFINE, pend[i].arg = "_LANGUAGE_FORTRAN";
546 /* All other possibilities ignored. */
550 if (!strcmp (argv[i], "-include"))
553 fatal ("Filename missing after -i option");
555 pend[i].type = PD_FILE, pend[i].arg = argv[i + 1], i++;
557 else if (!strcmp (argv[i], "-iprefix"))
558 i++; /* Ignore for compatibility */
559 else if (!strcmp (argv[i], "-isystem")
560 || !strcmp (argv[i], "-iwithprefix")
561 || !strcmp (argv[i], "-iwithprefixbefore")
562 || !strcmp (argv[i], "-idirafter"))
563 goto add_include; /* best we can do */
568 if (out_fname != NULL)
569 fatal ("Output filename specified twice");
571 fatal ("Filename missing after -o option");
572 out_fname = argv[++i];
573 if (!strcmp (out_fname, "-"))
578 inhibit_warnings = 1;
582 if (!strcmp (argv[i], "-Wcomments"))
584 else if (!strcmp (argv[i], "-Wcomment"))
586 else if (!strcmp (argv[i], "-Wall")) {
592 if (!strcmp (argv[i], "-fleading-underscore"))
593 user_label_prefix = "_";
594 else if (!strcmp (argv[i], "-fno-leading-underscore"))
595 user_label_prefix = "";
599 if (!strcmp (argv[i], "-M"))
601 else if (!strcmp (argv[i], "-MM"))
612 fprintf (stderr, "GNU traditional CPP version %s\n", version_string);
623 else if (i + 1 == argc)
624 fatal ("Macro name missing after -%c option", c);
629 pend[i].type = PD_DEFINE;
631 pend[i].type = PD_UNDEF;
633 pend[i].type = PD_ASSERTION;
639 put_out_comments = 1;
643 if (!strcmp (argv[i], "-pedantic"))
644 fatal ("-pedantic and -traditional are mutually exclusive");
648 if (!strcmp (argv[i], "-trigraphs"))
649 fatal ("-trigraphs and -traditional are mutually exclusive");
653 no_line_commands = 1;
656 case 'I': /* Add directory to path for includes. */
659 struct file_name_list *dirtmp;
661 if (! ignore_srcdir && !strcmp (argv[i] + 2, "-"))
664 dirtmp = (struct file_name_list *)
665 xmalloc (sizeof (struct file_name_list));
666 dirtmp->next = 0; /* New one goes on the end */
670 last_include->next = dirtmp;
671 last_include = dirtmp; /* Tail follows the last one */
672 if (argv[i][1] == 'I' && argv[i][2] != 0)
673 dirtmp->fname = argv[i] + 2;
674 else if (i + 1 == argc)
675 fatal ("Directory name missing after -I option");
677 dirtmp->fname = argv[++i];
678 if (strlen (dirtmp->fname) > max_include_len)
679 max_include_len = strlen (dirtmp->fname);
680 if (ignore_srcdir && first_bracket_include == 0)
681 first_bracket_include = dirtmp;
687 /* -nostdinc causes no default include directories.
688 You must specify all include-file directories with -I. */
689 no_standard_includes = 1;
692 case '\0': /* JF handle '-' as file name meaning stdin or stdout */
693 if (in_fname == NULL) {
696 } else if (out_fname == NULL) {
699 } /* else fall through into error */
702 fatal ("Invalid option `%s'", argv[i]);
707 if (user_label_prefix == 0)
708 user_label_prefix = USER_LABEL_PREFIX;
710 /* Initialize is_idchar. */
711 initialize_char_syntax ();
713 /* Install __LINE__, etc. Must follow initialize_char_syntax
714 and option processing. */
715 initialize_builtins ();
717 /* Do defines specified with -D and undefines specified with -U. */
718 for (i = 1; i < argc; i++)
719 if (pend[i].type == PD_DEFINE)
720 make_definition (pend[i].arg);
721 else if (pend[i].type == PD_UNDEF)
722 make_undef (pend[i].arg);
723 else if (pend[i].type == PD_ASSERTION)
724 make_assertion (pend[i].arg);
726 /* Unless -fnostdinc,
727 tack on the standard include file dirs to the specified list */
728 if (!no_standard_includes) {
729 const struct default_include *di;
730 struct file_name_list *old_last_include = last_include;
731 struct file_name_list *dirtmp;
732 for (di = cpp_include_defaults; di->fname; di++) {
735 dirtmp = (struct file_name_list *)
736 xmalloc (sizeof (struct file_name_list));
737 dirtmp->next = 0; /* New one goes on the end */
741 last_include->next = dirtmp;
742 last_include = dirtmp; /* Tail follows the last one */
743 dirtmp->fname = di->fname;
744 if (strlen (dirtmp->fname) > max_include_len)
745 max_include_len = strlen (dirtmp->fname);
748 if (ignore_srcdir && first_bracket_include == 0)
749 first_bracket_include = old_last_include->next;
752 /* Initialize output buffer */
754 outbuf.buf = (U_CHAR *) xmalloc (OUTBUF_SIZE);
755 outbuf.bufp = outbuf.buf;
756 outbuf.length = OUTBUF_SIZE;
758 /* Scan the -i files before the main input.
759 Much like #including them, but with no_output set
760 so that only their macro definitions matter. */
763 for (i = 1; i < argc; i++)
764 if (pend[i].type == PD_FILE)
766 int fd = open (pend[i].arg, O_RDONLY, 0666);
769 perror_with_name (pend[i].arg);
770 return FATAL_EXIT_CODE;
772 finclude (fd, pend[i].arg, &outbuf);
776 /* Pending directives no longer needed. */
779 /* Create an input stack level for the main input file
780 and copy the entire contents of the file into it. */
782 fp = &instack[++indepth];
784 /* JF check for stdin */
785 if (in_fname == NULL || *in_fname == 0) {
788 } else if ((f = open (in_fname, O_RDONLY, 0666)) < 0)
791 /* Either of two environment variables can specify output of deps.
792 Its value is either "OUTPUT_FILE" or "OUTPUT_FILE DEPS_TARGET",
793 where OUTPUT_FILE is the file to write deps info to
794 and DEPS_TARGET is the target to mention in the deps. */
797 && (getenv ("SUNPRO_DEPENDENCIES") != 0
798 || getenv ("DEPENDENCIES_OUTPUT") != 0))
800 char *spec = getenv ("DEPENDENCIES_OUTPUT");
806 spec = getenv ("SUNPRO_DEPENDENCIES");
812 /* Find the space before the DEPS_TARGET, if there is one. */
813 s = strchr (spec, ' ');
817 output_file = (char *) xmalloc (s - spec + 1);
818 memcpy (output_file, spec, s - spec);
819 output_file[s - spec] = 0;
827 deps_stream = fopen (output_file, "a");
828 if (deps_stream == 0)
829 pfatal_with_name (output_file);
831 /* If the -M option was used, output the deps to standard output. */
833 deps_stream = stdout;
835 /* For -M, print the expected object file name
836 as the target of this Make-rule. */
838 deps_allocated_size = 200;
839 deps_buffer = (char *) xmalloc (deps_allocated_size);
845 deps_output (deps_target, 0);
846 deps_output (":", 0);
847 } else if (*in_fname == 0)
848 deps_output ("-: ", 0);
851 const char *p = in_fname;
853 /* Discard all directory prefixes from P. */
859 /* Output P, but remove known suffixes. */
861 if (p[len - 2] == '.'
862 && (p[len - 1] == 'c' || p[len - 1] == 'C' || p[len - 1] == 'S'))
863 deps_output (p, len - 2);
864 else if (p[len - 3] == '.'
866 && p[len - 1] == 'c')
867 deps_output (p, len - 3);
870 /* Supply our own suffix. */
871 deps_output (".o : ", 0);
872 deps_output (in_fname, 0);
873 deps_output (" ", 0);
877 if (file_size_and_mode (f, &st_mode, &st_size))
879 fp->fname = in_fname;
881 /* JF all this is mine about reading pipes and ttys */
882 if (!S_ISREG (st_mode)) {
883 /* Read input from a file that is not a normal disk file.
884 We cannot preallocate a buffer with the correct size,
885 so we must read in the file a piece at the time and make it bigger. */
893 fp->buf = (U_CHAR *) xmalloc (bsize + 2);
896 cnt = read (f, bufp, bsize - size);
897 if (cnt < 0) goto sys_error; /* error! */
898 if (cnt == 0) break; /* End of file */
901 if (bsize == size) { /* Buffer is full! */
903 fp->buf = (U_CHAR *) xrealloc (fp->buf, bsize + 2);
904 bufp = fp->buf + size; /* May have moved */
909 /* Read a file whose size we can determine in advance.
910 For the sake of VMS, st_size is just an upper bound. */
913 fp->buf = (U_CHAR *) xmalloc (st_size + 2);
915 while (st_size > 0) {
916 i = read (f, fp->buf + fp->length, st_size);
926 fp->if_stack = if_stack;
928 /* Make sure data ends with a newline. And put a null after it. */
930 if (fp->length > 0 && fp->buf[fp->length-1] != '\n')
931 fp->buf[fp->length++] = '\n';
932 fp->buf[fp->length] = '\0';
934 /* Now that we know the input file is valid, open the output. */
936 if (!out_fname || !strcmp (out_fname, ""))
937 out_fname = "stdout";
938 else if (! freopen (out_fname, "w", stdout))
939 pfatal_with_name (out_fname);
941 output_line_command (fp, &outbuf, 0, same_file);
943 /* Scan the input, processing macros and directives. */
947 /* Now we have processed the entire input
948 Write whichever kind of output has been requested. */
953 else if (! inhibit_output && deps_stream != stdout) {
954 if (write (fileno (stdout), outbuf.buf, outbuf.bufp - outbuf.buf) < 0)
955 fatal ("I/O error on output");
959 fputs (deps_buffer, deps_stream);
960 putc ('\n', deps_stream);
961 if (deps_stream != stdout) {
962 fclose (deps_stream);
963 if (ferror (deps_stream))
964 fatal ("I/O error on output");
969 fatal ("I/O error on output");
972 exit (FATAL_EXIT_CODE);
973 exit (SUCCESS_EXIT_CODE);
976 pfatal_with_name (in_fname);
979 /* Move all backslash-newline pairs out of embarrassing places.
980 Exchange all such pairs following BP
981 with any potentially-embarrasing characters that follow them.
982 Potentially-embarrassing characters are / and *
983 (because a backslash-newline inside a comment delimiter
984 would cause it not to be recognized). */
989 register U_CHAR *p = bp;
990 register int count = 0;
992 /* First count the backslash-newline pairs here. */
994 while (*p++ == '\\' && *p++ == '\n')
999 /* Exit if what follows the backslash-newlines is not embarrassing. */
1001 if (count == 0 || (*p != '/' && *p != '*'))
1004 /* Copy all potentially embarrassing characters
1005 that follow the backslash-newline pairs
1006 down to where the pairs originally started. */
1008 while (*p == '*' || *p == '/')
1011 /* Now write the same number of pairs after the embarrassing chars. */
1012 while (count-- > 0) {
1018 /* Like newline_fix but for use within a directive-name.
1019 Move any backslash-newlines up past any following symbol constituents. */
1021 name_newline_fix (bp)
1024 register U_CHAR *p = bp;
1025 register int count = 0;
1027 /* First count the backslash-newline pairs here. */
1029 while (*p++ == '\\' && *p++ == '\n')
1034 /* What follows the backslash-newlines is not embarrassing. */
1036 if (count == 0 || !is_idchar[*p])
1039 /* Copy all potentially embarrassing characters
1040 that follow the backslash-newline pairs
1041 down to where the pairs originally started. */
1043 while (is_idchar[*p])
1046 /* Now write the same number of pairs after the embarrassing chars. */
1047 while (count-- > 0) {
1054 * The main loop of the program.
1056 * Read characters from the input stack, transferring them to the
1059 * Macros are expanded and push levels on the input stack.
1060 * At the end of such a level it is popped off and we keep reading.
1061 * At the end of any other kind of level, we return.
1062 * #-directives are handled, except within macros.
1064 * If OUTPUT_MARKS is nonzero, keep Newline markers found in the input
1065 * and insert them when appropriate. This is set while scanning macro
1066 * arguments before substitution. It is zero when scanning for final output.
1067 * There are three types of Newline markers:
1068 * * Newline - follows a macro name that was not expanded
1069 * because it appeared inside an expansion of the same macro.
1070 * This marker prevents future expansion of that identifier.
1071 * When the input is rescanned into the final output, these are deleted.
1072 * These are also deleted by ## concatenation.
1073 * * Newline Space (or Newline and any other whitespace character)
1074 * stands for a place that tokens must be separated or whitespace
1075 * is otherwise desirable, but where the ANSI standard specifies there
1076 * is no whitespace. This marker turns into a Space (or whichever other
1077 * whitespace char appears in the marker) in the final output,
1078 * but it turns into nothing in an argument that is stringified with #.
1079 * Such stringified arguments are the only place where the ANSI standard
1080 * specifies with precision that whitespace may not appear.
1082 * During this function, IP->bufp is kept cached in IBP for speed of access.
1083 * Likewise, OP->bufp is kept in OBP. Before calling a subroutine
1084 * IBP, IP and OBP must be copied back to memory. IP and IBP are
1085 * copied back with the RECACHE macro. OBP must be copied back from OP->bufp
1086 * explicitly, and before RECACHE, since RECACHE uses OBP.
1090 rescan (op, output_marks)
1094 /* Character being scanned in main loop. */
1097 /* Length of pending accumulated identifier. */
1098 register int ident_length = 0;
1100 /* Hash code of pending accumulated identifier. */
1101 register int hash = 0;
1103 /* Current input level (&instack[indepth]). */
1106 /* Pointer for scanning input. */
1107 register U_CHAR *ibp;
1109 /* Pointer to end of input. End of scan is controlled by LIMIT. */
1110 register U_CHAR *limit;
1112 /* Pointer for storing output. */
1113 register U_CHAR *obp;
1115 /* REDO_CHAR is nonzero if we are processing an identifier
1116 after backing up over the terminating character.
1117 Sometimes we process an identifier without backing up over
1118 the terminating character, if the terminating character
1119 is not special. Backing up is done so that the terminating character
1120 will be dispatched on again once the identifier is dealt with. */
1123 /* 1 if within an identifier inside of which a concatenation
1124 marker (Newline -) has been seen. */
1125 int concatenated = 0;
1127 /* While scanning a comment or a string constant,
1128 this records the line it started on, for error messages. */
1131 /* Record position of last `real' newline. */
1132 U_CHAR *beg_of_line;
1134 /* Pop the innermost input stack level, assuming it is a macro expansion. */
1137 do { ip->macro->type = T_MACRO; \
1138 if (ip->free_ptr) free (ip->free_ptr); \
1139 --indepth; } while (0)
1141 /* Reload `rescan's local variables that describe the current
1142 level of the input stack. */
1145 do { ip = &instack[indepth]; \
1147 limit = ip->buf + ip->length; \
1149 check_expand (op, limit - ibp); \
1151 obp = op->bufp; } while (0)
1153 if (no_output && instack[indepth].fname != 0)
1154 skip_if_group (&instack[indepth], 1);
1160 /* Our caller must always put a null after the end of
1161 the input at each input stack level. */
1174 /* Always merge lines ending with backslash-newline,
1175 even in middle of identifier. */
1178 --obp; /* remove backslash from obuf */
1181 /* Otherwise, backslash suppresses specialness of following char,
1182 so copy it here to prevent the switch from seeing it.
1183 But first get any pending identifier processed. */
1184 if (ident_length > 0)
1190 /* If this is expanding a macro definition, don't recognize
1191 preprocessor directives. */
1197 /* # keyword: a # must be the first char on the line */
1198 if (beg_of_line == 0)
1200 if (beg_of_line + 1 != ibp)
1203 /* This # can start a directive. */
1205 --obp; /* Don't copy the '#' */
1209 if (! handle_directive (ip, op)) {
1213 /* Not a known directive: treat it as ordinary text.
1214 IP, OP, IBP, etc. have not been changed. */
1215 if (no_output && instack[indepth].fname) {
1216 /* If not generating expanded output,
1217 what we do with ordinary text is skip it.
1218 Discard everything until next # directive. */
1219 skip_if_group (&instack[indepth], 1);
1224 ++obp; /* Copy the '#' after all */
1230 /* A # directive has been successfully processed. */
1231 /* If not generating expanded output, ignore everything until
1232 next # directive. */
1233 if (no_output && instack[indepth].fname)
1234 skip_if_group (&instack[indepth], 1);
1240 case '\"': /* skip quoted string */
1242 /* A single quoted string is treated like a double -- some
1243 programs (e.g., troff) are perverse this way */
1248 start_line = ip->lineno;
1250 /* Skip ahead to a matching quote. */
1254 if (ip->macro != 0) {
1255 /* try harder: this string crosses a macro expansion boundary */
1267 /* Traditionally, end of line ends a string constant with no error.
1268 So exit the loop and record the new line. */
1276 /* Backslash newline is replaced by nothing at all,
1277 but keep the line counts correct. */
1282 /* ANSI stupidly requires that in \\ the second \
1283 is *not* prevented from combining with a newline. */
1284 while (*ibp == '\\' && ibp[1] == '\n') {
1303 if (*ibp == '\\' && ibp[1] == '\n')
1305 /* Don't look for comments inside a macro definition. */
1308 /* A comment constitutes white space, so it can terminate an identifier.
1309 Process the identifier, if any. */
1316 /* We have a comment. Skip it, optionally copying it to output. */
1318 start_line = ip->lineno;
1320 ++ibp; /* Skip the star. */
1322 /* In K+R C, a comment is equivalent to nothing. Note that we
1323 already output the slash; we might not want it. */
1324 if (! put_out_comments)
1330 U_CHAR *before_bp = ibp;
1332 while (ibp < limit) {
1335 if (warn_comments && ibp < limit && *ibp == '*')
1336 warning("`/*' within comment");
1339 if (*ibp == '\\' && ibp[1] == '\n')
1341 if (ibp >= limit || *ibp == '/')
1346 /* Copy the newline into the output buffer, in order to
1347 avoid the pain of a #line every time a multiline comment
1349 if (!put_out_comments)
1357 error_with_line (line_for_error (start_line),
1358 "unterminated comment");
1361 if (put_out_comments) {
1362 memcpy (obp, before_bp, ibp - before_bp);
1363 obp += ibp - before_bp;
1369 case '0': case '1': case '2': case '3': case '4':
1370 case '5': case '6': case '7': case '8': case '9':
1371 /* If digit is not part of identifier, it starts a number,
1372 which means that following letters are not an identifier.
1373 "0x5" does not refer to an identifier "x5".
1374 So copy all alphanumerics that follow without accumulating
1375 as an identifier. Periods also, for sake of "3.e7". */
1377 if (ident_length == 0) {
1378 while (ibp < limit) {
1379 while (ibp < limit && ibp[0] == '\\' && ibp[1] == '\n') {
1384 if (!ISALNUM (c) && c != '.' && c != '_') {
1389 /* A sign can be part of a preprocessing number
1390 if it follows an e. */
1391 if (c == 'e' || c == 'E') {
1392 while (ibp < limit && ibp[0] == '\\' && ibp[1] == '\n') {
1396 if (ibp < limit && (*ibp == '+' || *ibp == '-')) {
1398 /* Traditional C does not let the token go past the sign. */
1408 case 'a': case 'b': case 'c': case 'd': case 'e': case 'f':
1409 case 'g': case 'h': case 'i': case 'j': case 'k': case 'l':
1410 case 'm': case 'n': case 'o': case 'p': case 'q': case 'r':
1411 case 's': case 't': case 'u': case 'v': case 'w': case 'x':
1413 case 'A': case 'B': case 'C': case 'D': case 'E': case 'F':
1414 case 'G': case 'H': case 'I': case 'J': case 'K': case 'L':
1415 case 'M': case 'N': case 'O': case 'P': case 'Q': case 'R':
1416 case 'S': case 'T': case 'U': case 'V': case 'W': case 'X':
1419 /* Compute step of hash function, to avoid a proc call on every token */
1420 hash = HASHSTEP (hash, c);
1424 /* If reprocessing a macro expansion, newline is a special marker. */
1425 if (ip->macro != 0) {
1426 /* Newline White is a "funny space" to separate tokens that are
1427 supposed to be separate but without space between.
1428 Here White means any horizontal whitespace character.
1429 Newline - marks a recursive macro use that is not
1430 supposed to be expandable. */
1433 /* Newline - inhibits expansion of preceding token.
1434 If expanding a macro arg, we keep the newline -.
1435 In final output, it is deleted. */
1436 if (! concatenated) {
1441 if (!output_marks) {
1444 /* If expanding a macro arg, keep the newline -. */
1447 } else if (is_space[*ibp]) {
1448 /* Newline Space does not prevent expansion of preceding token
1449 so expand the preceding token and then come back. */
1450 if (ident_length > 0)
1453 /* If generating final output, newline space makes a space. */
1454 if (!output_marks) {
1456 /* And Newline Newline makes a newline, so count it. */
1457 if (obp[-1] == '\n')
1460 /* If expanding a macro arg, keep the newline space.
1461 If the arg gets stringified, newline space makes nothing. */
1464 } else abort (); /* Newline followed by something random? */
1468 /* If there is a pending identifier, handle it and come back here. */
1469 if (ident_length > 0)
1474 /* Update the line counts and output a #line if necessary. */
1477 if (ip->lineno != op->lineno) {
1479 output_line_command (ip, op, 1, same_file);
1480 check_expand (op, ip->length - (ip->bufp - ip->buf));
1485 /* Come here either after (1) a null character that is part of the input
1486 or (2) at the end of the input, because there is a null there. */
1489 /* Our input really contains a null character. */
1492 /* At end of a macro-expansion level, pop it and read next level. */
1493 if (ip->macro != 0) {
1496 /* If we have an identifier that ends here, process it now, so
1497 we get the right error for recursion. */
1498 if (ident_length && ! is_idchar[*instack[indepth - 1].bufp]) {
1507 /* If we don't have a pending identifier,
1508 return at end of input. */
1509 if (ident_length == 0) {
1517 /* If we do have a pending identifier, just consider this null
1518 a special character and arrange to dispatch on it again.
1519 The second time, IDENT_LENGTH will be zero so we will return. */
1525 /* Handle the case of a character such as /, ', " or null
1526 seen following an identifier. Back over it so that
1527 after the identifier is processed the special char
1528 will be dispatched on again. */
1538 if (ident_length > 0) {
1539 register HASHNODE *hp;
1541 /* We have just seen an identifier end. If it's a macro, expand it.
1543 IDENT_LENGTH is the length of the identifier
1544 and HASH is its hash code.
1546 The identifier has already been copied to the output,
1547 so if it is a macro we must remove it.
1549 If REDO_CHAR is 0, the char that terminated the identifier
1550 has been skipped in the output and the input.
1551 OBP-IDENT_LENGTH-1 points to the identifier.
1552 If the identifier is a macro, we must back over the terminator.
1554 If REDO_CHAR is 1, the terminating char has already been
1555 backed over. OBP-IDENT_LENGTH points to the identifier. */
1557 for (hp = hashtab[MAKE_POS (hash) % HASHSIZE]; hp != NULL;
1560 if (hp->length == ident_length) {
1561 U_CHAR *obufp_before_macroname;
1562 int op_lineno_before_macroname;
1563 register int i = ident_length;
1564 register U_CHAR *p = hp->name;
1565 register U_CHAR *q = obp - i;
1570 do { /* All this to avoid a strncmp () */
1575 /* We found a use of a macro name.
1576 see if the context shows it is a macro call. */
1578 /* Back up over terminating character if not already done. */
1584 obufp_before_macroname = obp - ident_length;
1585 op_lineno_before_macroname = op->lineno;
1587 /* If macro wants an arglist, verify that a '(' follows.
1588 first skip all whitespace, copying it to the output
1589 after the macro name. Then, if there is no '(',
1590 decide this is not a macro call and leave things that way. */
1591 if (hp->type == T_MACRO && hp->value.defn->nargs >= 0)
1594 /* Scan forward over whitespace, copying it to the output. */
1595 if (ibp == limit && ip->macro != 0) {
1599 /* A comment: copy it unchanged or discard it. */
1600 else if (*ibp == '/' && ibp+1 != limit && ibp[1] == '*') {
1601 if (put_out_comments) {
1606 while (ibp + 1 != limit
1607 && !(ibp[0] == '*' && ibp[1] == '/')) {
1608 /* We need not worry about newline-marks,
1609 since they are never found in comments. */
1611 /* Newline in a file. Count it. */
1615 if (put_out_comments)
1621 if (put_out_comments) {
1626 else if (is_space[*ibp]) {
1628 if (ibp[-1] == '\n') {
1629 if (ip->macro == 0) {
1630 /* Newline in a file. Count it. */
1633 } else if (!output_marks) {
1634 /* A newline mark, and we don't want marks
1635 in the output. If it is newline-hyphen,
1636 discard it entirely. Otherwise, it is
1637 newline-whitechar, so keep the whitechar. */
1647 /* A newline mark; copy both chars to the output. */
1658 /* This is now known to be a macro call.
1659 Discard the macro name from the output,
1660 along with any following whitespace just copied. */
1661 obp = obufp_before_macroname;
1662 op->lineno = op_lineno_before_macroname;
1664 /* Expand the macro, reading arguments as needed,
1665 and push the expansion on the input stack. */
1668 macroexpand (hp, op);
1670 /* Reexamine input stack, since macroexpand has pushed
1671 a new level on it. */
1678 } /* End hash-table-search loop */
1679 ident_length = hash = 0; /* Stop collecting identifier */
1682 } /* End if (ident_length > 0) */
1684 } /* End per-char loop */
1686 /* Come here to return -- but first give an error message
1687 if there was an unterminated successful conditional. */
1689 if (if_stack != ip->if_stack) {
1691 switch (if_stack->type) {
1710 error_with_line (line_for_error (if_stack->lineno),
1711 "unterminated #%s conditional", str);
1713 if_stack = ip->if_stack;
1717 * Rescan a string into a temporary buffer and return the result
1718 * as a FILE_BUF. Note this function returns a struct, not a pointer.
1720 * OUTPUT_MARKS nonzero means keep Newline markers found in the input
1721 * and insert such markers when appropriate. See `rescan' for details.
1722 * OUTPUT_MARKS is 1 for macroexpanding a macro argument separately
1723 * before substitution; it is 0 for other uses.
1726 expand_to_temp_buffer (buf, limit, output_marks)
1727 const U_CHAR *buf, *limit;
1730 register FILE_BUF *ip;
1732 int length = limit - buf;
1734 int odepth = indepth;
1739 /* Set up the input on the input stack. */
1741 buf1 = (U_CHAR *) alloca (length + 1);
1743 register const U_CHAR *p1 = buf;
1744 register U_CHAR *p2 = buf1;
1751 /* Set up to receive the output. */
1753 obuf.length = length * 2 + 100; /* Usually enough. Why be stingy? */
1754 obuf.bufp = obuf.buf = (U_CHAR *) xmalloc (obuf.length);
1759 CHECK_DEPTH ({return obuf;});
1763 ip = &instack[indepth];
1767 ip->length = length;
1768 ip->buf = ip->bufp = buf1;
1769 ip->if_stack = if_stack;
1771 ip->lineno = obuf.lineno = 1;
1773 /* Scan the input, create the output. */
1775 rescan (&obuf, output_marks);
1777 /* Pop input stack to original state. */
1780 if (indepth != odepth)
1783 /* Record the output. */
1784 obuf.length = obuf.bufp - obuf.buf;
1790 * Process a # directive. Expects IP->bufp to point to the '#', as in
1791 * `#define foo bar'. Passes to the command handler
1792 * (do_define, do_include, etc.): the addresses of the 1st and
1793 * last chars of the command (starting immediately after the #
1794 * keyword), plus op and the keyword table pointer. If the command
1795 * contains comments it is copied into a temporary buffer sans comments
1796 * and the temporary buffer is passed to the command handler instead.
1797 * Likewise for backslash-newlines.
1799 * Returns nonzero if this was a known # directive.
1800 * Otherwise, returns zero, without advancing the input pointer.
1804 handle_directive (ip, op)
1807 register U_CHAR *bp, *cp;
1808 register struct directive *kt;
1809 register int ident_length;
1812 /* Nonzero means we must copy the entire command
1813 to get rid of comments or backslash-newlines. */
1814 int copy_command = 0;
1816 U_CHAR *ident, *after_ident;
1819 /* Skip whitespace and \-newline. */
1821 if (is_hor_space[*bp])
1823 else if (*bp == '/' && (newline_fix (bp + 1), bp[1]) == '*') {
1825 skip_to_end_of_comment (ip, &ip->lineno);
1827 } else if (*bp == '\\' && bp[1] == '\n') {
1828 bp += 2; ip->lineno++;
1832 /* Now find end of directive name.
1833 If we encounter a backslash-newline, exchange it with any following
1834 symbol-constituents so that we end up with a contiguous name. */
1841 if (*cp == '\\' && cp[1] == '\n')
1842 name_newline_fix (cp);
1848 ident_length = cp - bp;
1852 /* A line of just `#' becomes blank. */
1854 if (ident_length == 0 && *after_ident == '\n') {
1855 ip->bufp = after_ident;
1860 * Decode the keyword and call the appropriate expansion
1861 * routine, after moving the input pointer up to the next line.
1863 for (kt = directive_table; kt->length > 0; kt++) {
1864 if (kt->length == ident_length
1865 && !strncmp (kt->name, (const char *)ident, ident_length)) {
1866 register U_CHAR *buf;
1867 register U_CHAR *limit = ip->buf + ip->length;
1868 int unterminated = 0;
1870 /* Nonzero means do not delete comments within the directive.
1871 #define needs this to detect traditional token paste. */
1872 int keep_comments = kt->type == T_DEFINE;
1874 /* Find the end of this command (first newline not backslashed
1875 and not in a string or comment).
1876 Set COPY_COMMAND if the command must be copied
1877 (it contains a backslash-newline or a comment). */
1879 buf = bp = after_ident;
1880 while (bp < limit) {
1881 register U_CHAR c = *bp++;
1895 bp = skip_quoted_string (bp - 1, limit, ip->lineno, &ip->lineno, ©_command, &unterminated);
1897 /* Traditional preprocessing permits unterminated strings. */
1903 /* <...> is special for #include. */
1905 if (kt->type != T_INCLUDE)
1907 while (*bp && *bp != '>') bp++;
1911 if (*bp == '\\' && bp[1] == '\n')
1914 U_CHAR *obp = bp - 1;
1916 skip_to_end_of_comment (ip, &ip->lineno);
1918 /* No need to copy the command because of a comment at the end;
1919 just don't include the comment in the directive. */
1920 if (bp == limit || *bp == '\n') {
1924 /* Don't remove the comments if this is #define. */
1925 if (! keep_comments)
1931 --bp; /* Point to the newline */
1939 resume_p = ip->bufp;
1940 /* BP is the end of the directive.
1941 RESUME_P is the next interesting data after the directive.
1942 A comment may come between. */
1945 register U_CHAR *xp = buf;
1946 /* Need to copy entire command into temp buffer before dispatching */
1948 cp = (U_CHAR *) alloca (bp - buf + 5); /* room for cmd plus
1952 /* Copy to the new buffer, deleting comments
1953 and backslash-newlines (and whitespace surrounding the latter). */
1956 register U_CHAR c = *xp++;
1963 /* <...> is special for #include. */
1965 if (kt->type != T_INCLUDE)
1967 while (xp < bp && c != '>') {
1969 if (c == '\\' && xp < bp && *xp == '\n')
1980 if (cp != buf && is_space[cp[-1]]) {
1981 while (cp != buf && is_space[cp[-1]]) cp--;
1983 SKIP_WHITE_SPACE (xp);
1984 } else if (is_space[*xp]) {
1986 SKIP_WHITE_SPACE (xp);
1996 register const U_CHAR *bp1
1997 = skip_quoted_string (xp - 1, limit, ip->lineno, 0, 0, 0);
2006 skip_to_end_of_comment (ip, 0);
2008 while (xp != ip->bufp)
2010 /* Delete the slash. */
2018 /* Null-terminate the copy. */
2025 ip->bufp = resume_p;
2027 /* Call the appropriate command handler. buf now points to
2028 either the appropriate place in the input buffer, or to
2029 the temp buffer if it was necessary to make one. cp
2030 points to the first char after the contents of the (possibly
2031 copied) command, in either case. */
2032 (*kt->func) (buf, cp, op);
2033 check_expand (op, ip->length - (ip->bufp - ip->buf));
2042 static const char *const
2043 monthnames[] = {"Jan", "Feb", "Mar", "Apr", "May", "Jun",
2044 "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"};
2047 * expand things like __FILE__. Place the expansion into the output
2048 * buffer *without* rescanning.
2051 special_symbol (hp, op)
2059 FILE_BUF *ip = NULL;
2060 static struct tm *timebuf = NULL;
2062 int paren = 0; /* For special `defined' keyword */
2064 for (i = indepth; i >= 0; i--)
2065 if (instack[i].fname != NULL) {
2070 fatal ("not in any file?!");
2077 if (hp->type == T_FILE)
2080 string = instack[0].fname;
2084 char *tmp = (char *) alloca (3 + strlen (string));
2085 sprintf (tmp, "\"%s\"", string);
2094 case T_INCLUDE_LEVEL:
2096 char *tmp = (char *) alloca (8); /* Eigth bytes ought to be more than enough */
2098 for (i = indepth; i >= 0; i--)
2099 if (instack[i].fname != NULL)
2102 sprintf (tmp, "%d", true_indepth - 1);
2109 char *tmp = (char *) alloca (3 + strlen (version_string));
2110 sprintf (tmp, "\"%s\"", version_string);
2116 buf = hp->value.cpval;
2121 char *tmp = (char *) alloca (10);
2122 sprintf (tmp, "%d", ip->lineno);
2130 char *tmp = (char *) alloca (20);
2132 if (timebuf == NULL) {
2134 timebuf = localtime (&t);
2136 if (hp->type == T_DATE)
2137 sprintf (tmp, "\"%s %2d %4d\"", monthnames[timebuf->tm_mon],
2138 timebuf->tm_mday, timebuf->tm_year + 1900);
2140 sprintf (tmp, "\"%02d:%02d:%02d\"", timebuf->tm_hour, timebuf->tm_min,
2146 case T_SPEC_DEFINED:
2147 buf = " 0 "; /* Assume symbol is not defined */
2148 ip = &instack[indepth];
2149 SKIP_WHITE_SPACE (ip->bufp);
2150 if (*ip->bufp == '(') {
2152 ip->bufp++; /* Skip over the paren */
2153 SKIP_WHITE_SPACE (ip->bufp);
2156 if (!is_idstart[*ip->bufp])
2158 if (lookup (ip->bufp, -1, -1))
2160 while (is_idchar[*ip->bufp])
2162 SKIP_WHITE_SPACE (ip->bufp);
2164 if (*ip->bufp != ')')
2172 error ("`defined' must be followed by ident or (ident)");
2176 error ("cccp error: invalid special hash type"); /* time for gdb */
2180 check_expand (op, len);
2181 memcpy (op->bufp, buf, len);
2186 /* Routines to handle #directives */
2189 * Process include file by reading it in and calling rescan.
2190 * Expects to see "fname" or <fname> on the input.
2193 do_include (buf, limit, op)
2194 U_CHAR *buf, *limit;
2197 char *fname; /* Dynamically allocated fname buffer */
2198 U_CHAR *fbeg, *fend; /* Beginning and end of fname */
2200 struct file_name_list *stackp = include; /* Chain of dirs to search */
2201 struct file_name_list dsp[1]; /* First in chain, if #include "..." */
2204 int f; /* file number */
2206 int retried = 0; /* Have already tried macro
2207 expanding the include line*/
2208 FILE_BUF trybuf; /* It got expanded into here */
2209 int system_header_p = 0; /* 0 for "...", 1 for <...> */
2211 f= -1; /* JF we iz paranoid! */
2216 SKIP_WHITE_SPACE (fbeg);
2217 /* Discard trailing whitespace so we can easily see
2218 if we have parsed all the significant chars we were given. */
2219 while (limit != fbeg && is_hor_space[limit[-1]]) limit--;
2224 while (fend != limit && *fend != '\"')
2226 if (*fend == '\"' && fend + 1 == limit) {
2229 /* We have "filename". Figure out directory this source
2230 file is coming from and put it on the front of the list. */
2232 /* If -I- was specified, don't search current dir, only spec'd ones. */
2233 if (ignore_srcdir) break;
2235 for (fp = &instack[indepth]; fp >= instack; fp--)
2238 const char *ep, *nam;
2240 if ((nam = fp->fname) != NULL) {
2241 /* Found a named file. Figure out dir of the file,
2242 and put it in front of the search list. */
2243 dsp[0].next = stackp;
2245 ep = strrchr (nam, '/');
2249 f = (char *) alloca (n + 1);
2250 strncpy (f, nam, n);
2253 if (n > max_include_len) max_include_len = n;
2255 dsp[0].fname = 0; /* Current directory */
2266 while (fend != limit && *fend != '>') fend++;
2267 if (*fend == '>' && fend + 1 == limit) {
2268 system_header_p = 1;
2269 /* If -I-, start with the first -I dir after the -I-. */
2270 if (first_bracket_include)
2271 stackp = first_bracket_include;
2279 error ("#include expects \"fname\" or <fname>");
2282 trybuf = expand_to_temp_buffer (buf, limit, 0);
2283 buf = (U_CHAR *) alloca (trybuf.bufp - trybuf.buf + 1);
2284 memcpy (buf, trybuf.buf, trybuf.bufp - trybuf.buf);
2285 limit = buf + (trybuf.bufp - trybuf.buf);
2293 fname = (char *) alloca (max_include_len + flen + 2);
2294 /* + 2 above for slash and terminating null. */
2296 /* If specified file name is absolute, just open it. */
2299 strncpy (fname, (const char *)fbeg, flen);
2301 f = open (fname, O_RDONLY, 0666);
2303 /* Search directory path, trying to open the file.
2304 Copy each filename tried into FNAME. */
2306 for (; stackp; stackp = stackp->next) {
2307 if (stackp->fname) {
2308 strcpy (fname, stackp->fname);
2309 strcat (fname, "/");
2310 fname[strlen (fname) + flen] = 0;
2314 strncat (fname, (const char *)fbeg, flen);
2315 if ((f = open (fname, O_RDONLY, 0666)) >= 0)
2321 strncpy (fname, (const char *)fbeg, flen);
2323 error_from_errno (fname);
2325 /* For -M, add this file to the dependencies. */
2326 if (print_deps > (system_header_p || (system_include_depth > 0))) {
2327 if (system_header_p)
2328 warning ("nonexistent file <%.*s> omitted from dependency output",
2332 deps_output ((const char *)fbeg, fend - fbeg);
2333 deps_output (" ", 0);
2338 /* Check to see if this include file is a once-only include file.
2341 struct file_name_list* ptr;
2343 for (ptr = dont_repeat_files; ptr; ptr = ptr->next) {
2344 if (!strcmp (ptr->fname, fname)) {
2346 return; /* This file was once'd. */
2350 for (ptr = all_include_files; ptr; ptr = ptr->next) {
2351 if (!strcmp (ptr->fname, fname))
2352 break; /* This file was included before. */
2356 /* This is the first time for this file. */
2357 /* Add it to list of files included. */
2359 ptr = (struct file_name_list *) xmalloc (sizeof (struct file_name_list));
2360 ptr->next = all_include_files;
2361 all_include_files = ptr;
2362 ptr->fname = xstrdup (fname);
2364 /* For -M, add this file to the dependencies. */
2365 if (print_deps > (system_header_p || (system_include_depth > 0))) {
2366 deps_output (fname, strlen (fname));
2367 deps_output (" ", 0);
2371 if (system_header_p)
2372 system_include_depth++;
2374 /* Actually process the file. */
2375 finclude (f, fname, op);
2377 if (system_header_p)
2378 system_include_depth--;
2384 /* Process the contents of include file FNAME, already open on descriptor F,
2385 with output to OP. */
2388 finclude (f, fname, op)
2396 FILE_BUF *fp; /* For input stack frame */
2398 CHECK_DEPTH (return;);
2400 if (file_size_and_mode (f, &st_mode, &st_size))
2403 fp = &instack[indepth + 1];
2404 memset (fp, 0, sizeof (FILE_BUF));
2408 fp->if_stack = if_stack;
2410 if (S_ISREG (st_mode)) {
2411 fp->buf = (U_CHAR *) xmalloc (st_size + 2);
2414 /* Read the file contents, knowing that st_size is an upper bound
2415 on the number of bytes we can read. */
2416 while (st_size > 0) {
2417 i = read (f, fp->buf + fp->length, st_size);
2427 /* Cannot count its file size before reading. */
2434 basep = (U_CHAR *) xmalloc (bsize + 2);
2438 i = read (f, bufp, bsize - st_size);
2440 goto nope; /* error! */
2442 break; /* End of file */
2445 if (bsize == st_size) { /* Buffer is full! */
2447 basep = (U_CHAR *) xrealloc (basep, bsize + 2);
2448 bufp = basep + st_size; /* May have moved */
2453 fp->length = st_size;
2457 /* Make sure data ends with a newline. And put a null after it. */
2459 if (fp->length > 0 && fp->buf[fp->length-1] != '\n')
2460 fp->buf[fp->length++] = '\n';
2461 fp->buf[fp->length] = '\0';
2464 output_line_command (fp, op, 0, enter_file);
2467 output_line_command (&instack[indepth], op, 0, leave_file);
2472 perror_with_name (fname);
2477 /* Process a #define command.
2478 BUF points to the contents of the #define command, as a continguous string.
2479 LIMIT points to the first character past the end of the definition.
2480 KEYWORD is the keyword-table entry for #define. */
2483 do_define (buf, limit, op)
2484 U_CHAR *buf, *limit;
2485 FILE_BUF *op ATTRIBUTE_UNUSED;
2487 U_CHAR *bp; /* temp ptr into input buffer */
2488 U_CHAR *symname; /* remember where symbol name starts */
2489 int sym_length; /* and how long it is */
2492 int arglengths = 0; /* Accumulate lengths of arg names
2493 plus number of args. */
2498 while (is_hor_space[*bp])
2501 symname = bp; /* remember where it starts */
2502 while (is_idchar[*bp] && bp < limit) {
2505 sym_length = bp - symname;
2506 if (sym_length == 0)
2507 error ("invalid macro name");
2508 else if (!is_idstart[*symname]) {
2509 U_CHAR *msg; /* what pain... */
2510 msg = (U_CHAR *) alloca (sym_length + 1);
2511 memcpy (msg, symname, sym_length);
2512 msg[sym_length] = 0;
2513 error ("invalid macro name `%s'", msg);
2515 if (! strncmp ((const char *)symname, "defined", 7) && sym_length == 7)
2516 error ("defining `defined' as a macro");
2519 /* lossage will occur if identifiers or control keywords are broken
2520 across lines using backslash. This is not the right place to take
2524 struct arglist *arg_ptrs = NULL;
2527 bp++; /* skip '(' */
2528 SKIP_WHITE_SPACE (bp);
2530 /* Loop over macro argument names. */
2531 while (*bp != ')') {
2532 struct arglist *temp;
2534 temp = (struct arglist *) alloca (sizeof (struct arglist));
2536 temp->next = arg_ptrs;
2537 temp->argno = argno++;
2540 if (!is_idstart[*bp])
2541 warning ("parameter name starts with a digit in #define");
2543 /* Find the end of the arg name. */
2544 while (is_idchar[*bp]) {
2547 temp->length = bp - temp->name;
2548 arglengths += temp->length + 2;
2549 SKIP_WHITE_SPACE (bp);
2550 if (temp->length == 0 || (*bp != ',' && *bp != ')')) {
2551 error ("badly punctuated parameter list in #define");
2556 SKIP_WHITE_SPACE (bp);
2559 error ("unterminated parameter list in #define");
2564 ++bp; /* skip paren */
2565 while (is_hor_space[*bp]) /* and leading whitespace */
2567 /* now everything from bp before limit is the definition. */
2568 defn = collect_expansion (bp, limit, argno, arg_ptrs);
2570 /* Now set defn->argnames to the result of concatenating
2571 the argument names in reverse order
2572 with comma-space between them. */
2574 struct arglist *temp;
2576 U_CHAR *tmp = (U_CHAR *) xmalloc (arglengths + 1);
2578 for (temp = arg_ptrs; temp; temp = temp->next) {
2579 memcpy (&tmp[i], temp->name, temp->length);
2581 if (temp->next != 0) {
2587 defn->argnames = tmp;
2591 /* simple expansion or empty definition; skip leading whitespace */
2592 while (is_hor_space[*bp])
2594 /* now everything from bp before limit is the definition. */
2595 defn = collect_expansion (bp, limit, -1, 0);
2596 defn->argnames = (const U_CHAR *) "";
2599 hashcode = hashf (symname, sym_length, HASHSIZE);
2603 if ((hp = lookup (symname, sym_length, hashcode)) == NULL)
2604 hp = install (symname, sym_length, T_MACRO, hashcode);
2606 if (hp->type != T_MACRO || compare_defs (defn, hp->value.defn))
2607 warning ("\"%.*s\" redefined", sym_length, symname);
2609 /* Replace the old definition. */
2613 hp->value.defn = defn;
2618 * return zero if two DEFINITIONs are isomorphic
2621 compare_defs (d1, d2)
2622 DEFINITION *d1, *d2;
2624 register struct reflist *a1, *a2;
2625 register U_CHAR *p1 = d1->expansion;
2626 register U_CHAR *p2 = d2->expansion;
2629 if (d1->nargs != d2->nargs)
2631 if (strcmp ((const char *)d1->argnames, (const char *)d2->argnames))
2633 for (a1 = d1->pattern, a2 = d2->pattern; a1 && a2;
2634 a1 = a1->next, a2 = a2->next) {
2635 if (!((a1->nchars == a2->nchars
2636 && ! strncmp ((const char *)p1, (const char *)p2, a1->nchars))
2637 || ! comp_def_part (first, p1, a1->nchars, p2, a2->nchars, 0))
2638 || a1->argno != a2->argno
2639 || a1->stringify != a2->stringify
2640 || a1->raw_before != a2->raw_before
2641 || a1->raw_after != a2->raw_after)
2649 if (comp_def_part (first, p1, d1->length - (p1 - d1->expansion),
2650 p2, d2->length - (p2 - d2->expansion), 1))
2655 /* Return 1 if two parts of two macro definitions are effectively different.
2656 One of the parts starts at BEG1 and has LEN1 chars;
2657 the other has LEN2 chars at BEG2.
2658 Any sequence of whitespace matches any other sequence of whitespace.
2659 FIRST means these parts are the first of a macro definition;
2660 so ignore leading whitespace entirely.
2661 LAST means these parts are the last of a macro definition;
2662 so ignore trailing whitespace entirely. */
2664 comp_def_part (first, beg1, len1, beg2, len2, last)
2666 const U_CHAR *beg1, *beg2;
2670 register const U_CHAR *end1 = beg1 + len1;
2671 register const U_CHAR *end2 = beg2 + len2;
2673 while (beg1 != end1 && is_space[*beg1]) beg1++;
2674 while (beg2 != end2 && is_space[*beg2]) beg2++;
2677 while (beg1 != end1 && is_space[end1[-1]]) end1--;
2678 while (beg2 != end2 && is_space[end2[-1]]) end2--;
2680 while (beg1 != end1 && beg2 != end2) {
2681 if (is_space[*beg1] && is_space[*beg2]) {
2682 while (beg1 != end1 && is_space[*beg1]) beg1++;
2683 while (beg2 != end2 && is_space[*beg2]) beg2++;
2684 } else if (*beg1 == *beg2) {
2688 return (beg1 != end1) || (beg2 != end2);
2691 /* Read a replacement list for a macro with parameters.
2692 Build the DEFINITION structure.
2693 Reads characters of text starting at BUF until LIMIT.
2694 ARGLIST specifies the formal parameters to look for
2695 in the text of the definition; NARGS is the number of args
2696 in that list, or -1 for a macro name that wants no argument list.
2697 MACRONAME is the macro name itself (so we can avoid recursive expansion)
2698 and NAMELEN is its length in characters.
2700 Note that comments and backslash-newlines have already been deleted
2701 from the argument. */
2703 /* Leading and trailing Space, Tab, etc. are converted to markers
2704 Newline Space, Newline Tab, etc.
2705 Newline Space makes a space in the final output
2706 but is discarded if stringified. (Newline Tab is similar but
2707 makes a Tab instead.)
2709 If there is no trailing whitespace, a Newline Space is added at the end
2710 to prevent concatenation that would be contrary to the standard. */
2713 collect_expansion (buf, end, nargs, arglist)
2716 struct arglist *arglist;
2719 register U_CHAR *p, *limit, *lastp, *exp_p;
2720 struct reflist *endpat = NULL;
2721 /* Pointer to first nonspace after last ## seen. */
2723 /* Pointer to first nonspace after last single-# seen. */
2724 U_CHAR *stringify = 0;
2726 int expected_delimiter = '\0';
2728 /* Scan thru the replacement list, ignoring comments and quoted
2729 strings, picking up on the macro calls. It does a linear search
2730 thru the arg list on every potential symbol. Profiling might say
2731 that something smarter should happen. */
2736 /* Find the beginning of the trailing whitespace. */
2737 /* Find end of leading whitespace. */
2740 while (p < limit && is_space[limit[-1]]) limit--;
2741 while (p < limit && is_space[*p]) p++;
2743 /* Allocate space for the text in the macro definition.
2744 Leading and trailing whitespace chars need 2 bytes each.
2745 Each other input char may or may not need 1 byte,
2746 so this is an upper bound.
2747 The extra 2 are for invented trailing newline-marker and final null. */
2748 maxsize = (sizeof (DEFINITION)
2749 + 2 * (end - limit) + 2 * (p - buf)
2751 defn = (DEFINITION *) xcalloc (1, maxsize);
2753 defn->nargs = nargs;
2754 exp_p = defn->expansion = (U_CHAR *) defn + sizeof (DEFINITION);
2759 /* Convert leading whitespace to Newline-markers. */
2760 while (p < limit && is_space[*p]) {
2765 /* Process the main body of the definition. */
2767 int skipped_arg = 0;
2768 register U_CHAR c = *p++;
2772 /* In -traditional mode, recognize arguments inside strings and
2773 and character constants, and ignore special properties of #.
2774 Arguments inside strings are considered "stringified", but no
2775 extra quote marks are supplied. */
2779 if (expected_delimiter != '\0') {
2780 if (c == expected_delimiter)
2781 expected_delimiter = '\0';
2783 expected_delimiter = c;
2787 /* Backslash quotes delimiters and itself, but not macro args. */
2788 if (expected_delimiter != 0 && p < limit
2789 && (*p == expected_delimiter || *p == '\\')) {
2796 if (expected_delimiter != '\0') /* No comments inside strings. */
2799 /* If we find a comment that wasn't removed by handle_directive,
2800 this must be -traditional. So replace the comment with
2804 while (p < limit && !(p[-2] == '*' && p[-1] == '/'))
2810 if (is_idchar[c] && nargs > 0) {
2811 U_CHAR *id_beg = p - 1;
2815 while (p != limit && is_idchar[*p]) p++;
2816 id_len = p - id_beg;
2818 if (is_idstart[c]) {
2819 register struct arglist *arg;
2821 for (arg = arglist; arg != NULL; arg = arg->next) {
2822 struct reflist *tpat;
2824 if (arg->name[0] == c
2825 && arg->length == id_len
2826 && strncmp ((const char *)arg->name,
2827 (const char *)id_beg, id_len) == 0) {
2828 /* make a pat node for this arg and append it to the end of
2830 tpat = (struct reflist *) xmalloc (sizeof (struct reflist));
2832 tpat->raw_before = concat == id_beg;
2833 tpat->raw_after = 0;
2834 tpat->stringify = expected_delimiter != '\0';
2837 defn->pattern = tpat;
2839 endpat->next = tpat;
2842 tpat->argno = arg->argno;
2843 tpat->nchars = exp_p - lastp;
2845 register U_CHAR *p1 = p;
2846 SKIP_WHITE_SPACE (p1);
2847 if (p1 + 2 <= limit && p1[0] == '#' && p1[1] == '#')
2848 tpat->raw_after = 1;
2850 lastp = exp_p; /* place to start copying from next time */
2857 /* If this was not a macro arg, copy it into the expansion. */
2858 if (! skipped_arg) {
2859 register U_CHAR *lim1 = p;
2863 if (stringify == id_beg)
2864 error ("# operator should be followed by a macro argument name");
2870 /* Convert trailing whitespace to Newline-markers. */
2871 while (limit < end && is_space[*limit]) {
2873 *exp_p++ = *limit++;
2878 defn->length = exp_p - defn->expansion;
2880 /* Crash now if we overrun the allocated size. */
2881 if (defn->length + 1 > maxsize)
2888 * interpret #line command. Remembers previously seen fnames
2889 * in its very own hash table.
2891 #define FNAME_HASHSIZE 37
2893 do_line (buf, limit, op)
2894 U_CHAR *buf, *limit;
2897 register U_CHAR *bp;
2898 FILE_BUF *ip = &instack[indepth];
2901 enum file_change_code file_change = same_file;
2903 /* Expand any macros. */
2904 tem = expand_to_temp_buffer (buf, limit, 0);
2906 /* Point to macroexpanded line, which is null-terminated now. */
2908 SKIP_WHITE_SPACE (bp);
2910 if (!ISDIGIT (*bp)) {
2911 error ("invalid format #line command");
2915 /* The Newline at the end of this line remains to be processed.
2916 To put the next line at the specified line number,
2917 we must store a line number now that is one less. */
2918 new_lineno = atoi ((const char *)bp) - 1;
2920 /* skip over the line number. */
2921 while (ISDIGIT (*bp))
2924 #if 0 /* #line 10"foo.c" is supposed to be allowed. */
2925 if (*bp && !is_space[*bp]) {
2926 error ("invalid format #line command");
2931 SKIP_WHITE_SPACE (bp);
2934 static HASHNODE *fname_table[FNAME_HASHSIZE];
2935 HASHNODE *hp, **hash_bucket;
2941 while (*bp && *bp != '\"')
2944 error ("invalid format #line command");
2948 fname_length = bp - fname;
2951 SKIP_WHITE_SPACE (bp);
2954 file_change = enter_file;
2955 else if (*bp == '2')
2956 file_change = leave_file;
2958 error ("invalid format #line command");
2963 SKIP_WHITE_SPACE (bp);
2965 error ("invalid format #line command");
2971 &fname_table[hashf (fname, fname_length, FNAME_HASHSIZE)];
2972 for (hp = *hash_bucket; hp != NULL; hp = hp->next)
2973 if (hp->length == fname_length &&
2974 strncmp (hp->value.cpval, (const char *)fname, fname_length) == 0) {
2975 ip->fname = hp->value.cpval;
2980 /* Didn't find it; cons up a new one. */
2981 hp = (HASHNODE *) xcalloc (1, sizeof (HASHNODE) + fname_length + 1);
2982 hp->next = *hash_bucket;
2985 hp->length = fname_length;
2986 ip->fname = hp->value.cpval = q = ((char *) hp) + sizeof (HASHNODE);
2987 memcpy (q, fname, fname_length);
2990 error ("invalid format #line command");
2994 ip->lineno = new_lineno;
2995 output_line_command (ip, op, 0, file_change);
2996 check_expand (op, ip->length - (ip->bufp - ip->buf));
3000 * remove all definitions of symbol from symbol table.
3001 * according to un*x /lib/cpp, it is not an error to undef
3002 * something that has no definitions, so it isn't one here either.
3005 do_undef (buf, limit, op)
3007 U_CHAR *limit ATTRIBUTE_UNUSED;
3008 FILE_BUF *op ATTRIBUTE_UNUSED;
3012 SKIP_WHITE_SPACE (buf);
3014 if (! strncmp ((const char *)buf, "defined", 7) && ! is_idchar[buf[7]])
3015 warning ("undefining `defined'");
3017 while ((hp = lookup (buf, -1, -1)) != NULL) {
3018 if (hp->type != T_MACRO)
3019 warning ("undefining `%s'", hp->name);
3024 /* Function body to be provided later. */
3026 do_assert (buf, limit, op)
3027 U_CHAR *buf ATTRIBUTE_UNUSED;
3028 U_CHAR *limit ATTRIBUTE_UNUSED;
3029 FILE_BUF *op ATTRIBUTE_UNUSED;
3033 /* Function body to be provided later. */
3035 do_unassert (buf, limit, op)
3036 U_CHAR *buf ATTRIBUTE_UNUSED;
3037 U_CHAR *limit ATTRIBUTE_UNUSED;
3038 FILE_BUF *op ATTRIBUTE_UNUSED;
3043 * handle #if command by
3044 * 1) inserting special `defined' keyword into the hash table
3045 * that gets turned into 0 or 1 by special_symbol (thus,
3046 * if the luser has a symbol called `defined' already, it won't
3047 * work inside the #if command)
3048 * 2) rescan the input into a temporary output buffer
3049 * 3) pass the output buffer to the yacc parser and collect a value
3050 * 4) clean up the mess left from steps 1 and 2.
3051 * 5) call conditional_skip to skip til the next #endif (etc.),
3052 * or not, depending on the value from step 3.
3055 do_if (buf, limit, op)
3056 U_CHAR *buf, *limit;
3057 FILE_BUF *op ATTRIBUTE_UNUSED;
3060 FILE_BUF *ip = &instack[indepth];
3062 value = eval_if_expression (buf, limit - buf);
3063 conditional_skip (ip, value == 0, T_IF);
3067 * handle a #elif directive by not changing if_stack either.
3068 * see the comment above do_else.
3071 do_elif (buf, limit, op)
3072 U_CHAR *buf, *limit;
3076 FILE_BUF *ip = &instack[indepth];
3078 if (if_stack == instack[indepth].if_stack) {
3079 error ("#elif not within a conditional");
3082 if (if_stack->type != T_IF && if_stack->type != T_ELIF) {
3083 error ("#elif after #else");
3084 fprintf (stderr, " (matches line %d", if_stack->lineno);
3085 if (if_stack->fname != NULL && ip->fname != NULL &&
3086 strcmp (if_stack->fname, ip->fname) != 0)
3087 fprintf (stderr, ", file %s", if_stack->fname);
3088 fprintf (stderr, ")\n");
3090 if_stack->type = T_ELIF;
3093 if (if_stack->if_succeeded)
3094 skip_if_group (ip, 0);
3096 value = eval_if_expression (buf, limit - buf);
3098 skip_if_group (ip, 0);
3100 ++if_stack->if_succeeded; /* continue processing input */
3101 output_line_command (ip, op, 1, same_file);
3107 * evaluate a #if expression in BUF, of length LENGTH,
3108 * then parse the result as a C expression and return the value as an int.
3111 eval_if_expression (buf, length)
3116 HASHNODE *save_defined;
3119 save_defined = install (U"defined", -1, T_SPEC_DEFINED, -1);
3120 temp_obuf = expand_to_temp_buffer (buf, buf + length, 0);
3121 delete_macro (save_defined); /* clean up special symbol */
3123 value = parse_c_expression ((const char *)temp_obuf.buf);
3125 free (temp_obuf.buf);
3131 * routine to handle ifdef/ifndef. Try to look up the symbol,
3132 * then do or don't skip to the #endif/#else/#elif depending
3133 * on what directive is actually being processed.
3136 do_xifdef (buf, limit, type)
3137 U_CHAR *buf, *limit;
3138 enum node_type type;
3141 FILE_BUF *ip = &instack[indepth];
3144 /* Discard leading and trailing whitespace. */
3145 SKIP_WHITE_SPACE (buf);
3146 while (limit != buf && is_hor_space[limit[-1]]) limit--;
3148 /* Find the end of the identifier at the beginning. */
3149 for (end = buf; is_idchar[*end]; end++);
3152 skip = (type == T_IFDEF);
3154 skip = (lookup (buf, end-buf, -1) == NULL) ^ (type == T_IFNDEF);
3156 conditional_skip (ip, skip, T_IF);
3160 do_ifdef (buf, limit, op)
3161 U_CHAR *buf, *limit;
3162 FILE_BUF *op ATTRIBUTE_UNUSED;
3164 do_xifdef (buf, limit, T_IFDEF);
3168 do_ifndef (buf, limit, op)
3169 U_CHAR *buf, *limit;
3170 FILE_BUF *op ATTRIBUTE_UNUSED;
3172 do_xifdef (buf, limit, T_IFNDEF);
3176 * push TYPE on stack; then, if SKIP is nonzero, skip ahead.
3179 conditional_skip (ip, skip, type)
3182 enum node_type type;
3184 IF_STACK_FRAME *temp;
3186 temp = (IF_STACK_FRAME *) xcalloc (1, sizeof (IF_STACK_FRAME));
3187 temp->fname = ip->fname;
3188 temp->lineno = ip->lineno;
3189 temp->next = if_stack;
3192 if_stack->type = type;
3195 skip_if_group (ip, 0);
3198 ++if_stack->if_succeeded;
3199 output_line_command (ip, &outbuf, 1, same_file);
3204 * skip to #endif, #else, or #elif. adjust line numbers, etc.
3205 * leaves input ptr at the sharp sign found.
3206 * If ANY is nonzero, return at next directive of any sort.
3209 skip_if_group (ip, any)
3213 register U_CHAR *bp = ip->bufp, *cp;
3214 register U_CHAR *endb = ip->buf + ip->length;
3215 struct directive *kt;
3216 IF_STACK_FRAME *save_if_stack = if_stack; /* don't pop past here */
3217 U_CHAR *beg_of_line = bp;
3221 case '/': /* possible comment */
3222 if (*bp == '\\' && bp[1] == '\n')
3226 bp = skip_to_end_of_comment (ip, &ip->lineno);
3231 bp = skip_quoted_string (bp - 1, endb, ip->lineno, &ip->lineno, 0, 0);
3234 /* Char after backslash loses its special meaning. */
3237 ++ip->lineno; /* But do update the line-count. */
3248 /* # keyword: a # must be first nonblank char on the line */
3249 if (beg_of_line == 0)
3251 /* Scan from start of line, skipping whitespace, comments
3252 and backslash-newlines, and see if we reach this #.
3253 If not, this # is not special. */
3256 if (is_hor_space[*bp])
3258 else if (*bp == '\\' && bp[1] == '\n')
3260 else if (*bp == '/' && bp[1] == '*') {
3262 while (!(*bp == '*' && bp[1] == '/')) {
3271 if (bp != ip->bufp) {
3272 bp = ip->bufp + 1; /* Reset bp to after the #. */
3276 bp = ip->bufp + 1; /* Point after '#'. */
3278 /* Skip whitespace and \-newline. */
3280 if (is_hor_space[*bp])
3282 else if (*bp == '\\' && bp[1] == '\n')
3284 else if (*bp == '/' && bp[1] == '*') {
3286 while (!(*bp == '*' && bp[1] == '/'))
3295 /* Now find end of directive name.
3296 If we encounter a backslash-newline, exchange it with any following
3297 symbol-constituents so that we end up with a contiguous name. */
3303 if (*bp == '\\' && bp[1] == '\n')
3304 name_newline_fix (bp);
3311 for (kt = directive_table; kt->length >= 0; kt++) {
3312 IF_STACK_FRAME *temp;
3313 if (strncmp ((const char *)cp, kt->name, kt->length) == 0
3314 && !is_idchar[cp[kt->length]]) {
3316 /* If we are asked to return on next directive,
3325 temp = (IF_STACK_FRAME *) xcalloc (1, sizeof (IF_STACK_FRAME));
3326 temp->next = if_stack;
3328 temp->lineno = ip->lineno;
3329 temp->fname = ip->fname;
3330 temp->type = kt->type;
3335 if (if_stack == instack[indepth].if_stack) {
3336 error ("#%s not within a conditional", kt->name);
3339 else if (if_stack == save_if_stack)
3340 return; /* found what we came for */
3342 if (kt->type != T_ENDIF) {
3343 if (if_stack->type == T_ELSE)
3344 error ("#else or #elif after #else");
3345 if_stack->type = kt->type;
3350 if_stack = if_stack->next;
3355 /* Anything else is ignored. */
3364 /* after this returns, rescan will exit because ip->bufp
3365 now points to the end of the buffer.
3366 rescan is responsible for the error message also. */
3370 * handle a #else directive. Do this by just continuing processing
3371 * without changing if_stack ; this is so that the error message
3372 * for missing #endif's etc. will point to the original #if. It
3373 * is possible that something different would be better.
3376 do_else (buf, limit, op)
3377 U_CHAR *buf ATTRIBUTE_UNUSED;
3378 U_CHAR *limit ATTRIBUTE_UNUSED;
3381 FILE_BUF *ip = &instack[indepth];
3383 if (if_stack == instack[indepth].if_stack) {
3384 error ("#else not within a conditional");
3387 if (if_stack->type != T_IF && if_stack->type != T_ELIF) {
3388 error ("#else after #else");
3389 fprintf (stderr, " (matches line %d", if_stack->lineno);
3390 if (strcmp (if_stack->fname, ip->fname) != 0)
3391 fprintf (stderr, ", file %s", if_stack->fname);
3392 fprintf (stderr, ")\n");
3394 if_stack->type = T_ELSE;
3397 if (if_stack->if_succeeded)
3398 skip_if_group (ip, 0);
3400 ++if_stack->if_succeeded; /* continue processing input */
3401 output_line_command (ip, op, 1, same_file);
3406 * unstack after #endif command
3409 do_endif (buf, limit, op)
3410 U_CHAR *buf ATTRIBUTE_UNUSED;
3411 U_CHAR *limit ATTRIBUTE_UNUSED;
3414 if (if_stack == instack[indepth].if_stack)
3415 error ("unbalanced #endif");
3417 IF_STACK_FRAME *temp = if_stack;
3418 if_stack = if_stack->next;
3420 output_line_command (&instack[indepth], op, 1, same_file);
3425 * Skip a comment, assuming the input ptr immediately follows the
3426 * initial slash-star. Bump line counter as necessary.
3427 * (The canonical line counter is &ip->lineno).
3428 * Don't use this routine (or the next one) if bumping the line
3429 * counter is not sufficient to deal with newlines in the string.
3432 skip_to_end_of_comment (ip, line_counter)
3433 register FILE_BUF *ip;
3434 int *line_counter; /* place to remember newlines, or NULL */
3436 register U_CHAR *limit = ip->buf + ip->length;
3437 register U_CHAR *bp = ip->bufp;
3438 FILE_BUF *op = &outbuf; /* JF */
3439 int output = put_out_comments && !line_counter;
3441 /* JF this line_counter stuff is a crock to make sure the
3442 comment is only put out once, no matter how many times
3443 the comment is skipped. It almost works */
3448 while (bp < limit) {
3453 if (warn_comments && bp < limit && *bp == '*')
3454 warning("`/*' within comment");
3457 if (line_counter != NULL)
3463 if (*bp == '\\' && bp[1] == '\n')
3479 * Skip over a quoted string. BP points to the opening quote.
3480 * Returns a pointer after the closing quote. Don't go past LIMIT.
3481 * START_LINE is the line number of the starting point (but it need
3482 * not be valid if the starting point is inside a macro expansion).
3484 * The input stack state is not changed.
3486 * If COUNT_NEWLINES is nonzero, it points to an int to increment
3487 * for each newline passed.
3489 * If BACKSLASH_NEWLINES_P is nonzero, store 1 thru it
3490 * if we pass a backslash-newline.
3492 * If EOFP is nonzero, set *EOFP to 1 if the string is unterminated.
3495 skip_quoted_string (bp, limit, start_line, count_newlines, backslash_newlines_p, eofp)
3496 register const U_CHAR *bp;
3497 register const U_CHAR *limit;
3499 int *count_newlines;
3500 int *backslash_newlines_p;
3503 register U_CHAR c, match;
3508 error_with_line (line_for_error (start_line),
3509 "unterminated string or character constant");
3516 while (*bp == '\\' && bp[1] == '\n') {
3517 if (backslash_newlines_p)
3518 *backslash_newlines_p = 1;
3523 if (*bp == '\n' && count_newlines) {
3524 if (backslash_newlines_p)
3525 *backslash_newlines_p = 1;
3529 } else if (c == '\n') {
3530 /* Unterminated strings and character constants are 'legal'. */
3531 bp--; /* Don't consume the newline. */
3535 } else if (c == match)
3538 return (U_CHAR *) bp;
3542 * write out a #line command, for instance, after an #include file.
3543 * If CONDITIONAL is nonzero, we can omit the #line if it would
3544 * appear to be a no-op, and we can output a few newlines instead
3545 * if we want to increase the line number by a small amount.
3546 * FILE_CHANGE says whether we are entering a file, leaving, or neither.
3550 output_line_command (ip, op, conditional, file_change)
3553 enum file_change_code file_change;
3556 char line_cmd_buf[500];
3558 if (no_line_commands
3559 || ip->fname == NULL
3561 op->lineno = ip->lineno;
3566 if (ip->lineno == op->lineno)
3569 /* If the inherited line number is a little too small,
3570 output some newlines instead of a #line command. */
3571 if (ip->lineno > op->lineno && ip->lineno < op->lineno + 8) {
3572 check_expand (op, 10);
3573 while (ip->lineno > op->lineno) {
3581 sprintf (line_cmd_buf, "# %d \"%s\"", ip->lineno, ip->fname);
3582 if (file_change != same_file)
3583 strcat (line_cmd_buf, file_change == enter_file ? " 1" : " 2");
3584 if (system_include_depth > 0)
3585 strcat (line_cmd_buf, " 3");
3586 len = strlen (line_cmd_buf);
3587 line_cmd_buf[len++] = '\n';
3588 check_expand (op, len + 1);
3589 if (op->bufp > op->buf && op->bufp[-1] != '\n')
3591 memcpy (op->bufp, line_cmd_buf, len);
3593 op->lineno = ip->lineno;
3597 /* Expand a macro call.
3598 HP points to the symbol that is the macro being called.
3599 Put the result of expansion onto the input stack
3600 so that subsequent input by our caller will use it.
3602 If macro wants arguments, caller has already verified that
3603 an argument list follows; arguments come from the input stack. */
3606 macroexpand (hp, op)
3611 DEFINITION *defn = hp->value.defn;
3612 register U_CHAR *xbuf;
3614 int start_line = instack[indepth].lineno;
3616 CHECK_DEPTH (return;);
3618 /* it might not actually be a macro. */
3619 if (hp->type != T_MACRO) {
3620 special_symbol (hp, op);
3624 nargs = defn->nargs;
3628 struct argdata *args;
3629 const char *parse_error = 0;
3631 args = (struct argdata *) alloca ((nargs + 1) * sizeof (struct argdata));
3633 for (i = 0; i < nargs; i++) {
3634 args[i].raw = args[i].expanded = (U_CHAR *) "";
3635 args[i].raw_length = args[i].expand_length
3636 = args[i].stringified_length = 0;
3637 args[i].free1 = args[i].free2 = 0;
3640 /* Parse all the macro args that are supplied. I counts them.
3641 The first NARGS args are stored in ARGS.
3642 The rest are discarded. */
3645 /* Discard the open-parenthesis or comma before the next arg. */
3646 ++instack[indepth].bufp;
3648 = macarg ((i < nargs || (nargs == 0 && i == 0)) ? &args[i] : 0);
3651 error_with_line (line_for_error (start_line), parse_error);
3655 } while (*instack[indepth].bufp != ')');
3657 /* If we got one arg but it was just whitespace, call that 0 args. */
3659 register const U_CHAR *bp = args[0].raw;
3660 register const U_CHAR *lim = bp + args[0].raw_length;
3661 while (bp != lim && is_space[*bp]) bp++;
3666 if (nargs == 0 && i > 0)
3667 error ("arguments given to macro `%s'", hp->name);
3668 else if (i < nargs) {
3669 /* traditional C allows foo() if foo wants one argument. */
3670 if (nargs == 1 && i == 0)
3673 error ("no args to macro `%s'", hp->name);
3675 error ("only 1 arg to macro `%s'", hp->name);
3677 error ("only %d args to macro `%s'", i, hp->name);
3678 } else if (i > nargs)
3679 error ("too many (%d) args to macro `%s'", i, hp->name);
3681 /* Swallow the closeparen. */
3682 ++instack[indepth].bufp;
3684 /* If macro wants zero args, we parsed the arglist for checking only.
3685 Read directly from the macro definition. */
3687 xbuf = defn->expansion;
3688 xbuf_len = defn->length;
3690 register U_CHAR *exp = defn->expansion;
3691 register int offset; /* offset in expansion,
3692 copied a piece at a time */
3693 register int totlen; /* total amount of exp buffer filled so far */
3695 register struct reflist *ap;
3697 /* Macro really takes args. Compute the expansion of this call. */
3699 /* Compute length in characters of the macro's expansion. */
3700 xbuf_len = defn->length;
3701 for (ap = defn->pattern; ap != NULL; ap = ap->next) {
3703 xbuf_len += args[ap->argno].stringified_length;
3705 xbuf_len += args[ap->argno].raw_length;
3708 xbuf = (U_CHAR *) xmalloc (xbuf_len + 1);
3710 /* Generate in XBUF the complete expansion
3711 with arguments substituted in.
3712 TOTLEN is the total size generated so far.
3713 OFFSET is the index in the definition
3714 of where we are copying from. */
3715 offset = totlen = 0;
3716 for (ap = defn->pattern; ap != NULL; ap = ap->next) {
3717 register struct argdata *arg = &args[ap->argno];
3719 for (i = 0; i < ap->nchars; i++)
3720 xbuf[totlen++] = exp[offset++];
3722 if (ap->stringify != 0) {
3723 int arglen = arg->raw_length;
3729 && (c = arg->raw[i], is_space[c]))
3732 && (c = arg->raw[arglen - 1], is_space[c]))
3734 for (; i < arglen; i++) {
3737 /* Special markers Newline Space
3738 generate nothing for a stringified argument. */
3739 if (c == '\n' && arg->raw[i+1] != '\n') {
3744 /* Internal sequences of whitespace are replaced by one space
3745 except within an string or char token. */
3747 && (c == '\n' ? arg->raw[i+1] == '\n' : is_space[c])) {
3749 /* Note that Newline Space does occur within whitespace
3750 sequences; consider it part of the sequence. */
3751 if (c == '\n' && is_space[arg->raw[i+1]])
3753 else if (c != '\n' && is_space[c])
3770 } else if (c == '\"' || c == '\'')
3774 /* Escape these chars */
3775 if (c == '\"' || (in_string && c == '\\'))
3776 xbuf[totlen++] = '\\';
3780 sprintf ((char *) &xbuf[totlen], "\\%03o", (unsigned int) c);
3785 const U_CHAR *p1 = arg->raw;
3786 const U_CHAR *l1 = p1 + arg->raw_length;
3788 if (ap->raw_before) {
3789 while (p1 != l1 && is_space[*p1]) p1++;
3790 while (p1 != l1 && is_idchar[*p1])
3791 xbuf[totlen++] = *p1++;
3792 /* Delete any no-reexpansion marker that follows
3793 an identifier at the beginning of the argument
3794 if the argument is concatenated with what precedes it. */
3795 if (p1[0] == '\n' && p1[1] == '-')
3798 if (ap->raw_after) {
3799 /* Arg is concatenated after: delete trailing whitespace,
3800 whitespace markers, and no-reexpansion markers. */
3802 if (is_space[l1[-1]]) l1--;
3803 else if (l1[-1] == '-') {
3804 const U_CHAR *p2 = l1 - 1;
3805 /* If a `-' is preceded by an odd number of newlines then it
3806 and the last newline are a no-reexpansion marker. */
3807 while (p2 != p1 && p2[-1] == '\n') p2--;
3808 if ((l1 - 1 - p2) & 1) {
3816 memmove (xbuf + totlen, p1, l1 - p1);
3820 if (totlen > xbuf_len)
3824 /* if there is anything left of the definition
3825 after handling the arg list, copy that in too. */
3827 for (i = offset; i < defn->length; i++)
3828 xbuf[totlen++] = exp[i];
3833 for (i = 0; i < nargs; i++) {
3834 if (args[i].free1 != 0)
3835 free (args[i].free1);
3836 if (args[i].free2 != 0)
3837 free (args[i].free2);
3841 xbuf = defn->expansion;
3842 xbuf_len = defn->length;
3845 /* Now put the expansion on the input stack
3846 so our caller will commence reading from it. */
3848 register FILE_BUF *ip2;
3850 ip2 = &instack[++indepth];
3855 ip2->length = xbuf_len;
3857 ip2->free_ptr = (nargs > 0) ? xbuf : 0;
3859 ip2->if_stack = if_stack;
3864 * Parse a macro argument and store the info on it into *ARGPTR.
3865 * Return nonzero to indicate a syntax error.
3870 register struct argdata *argptr;
3872 FILE_BUF *ip = &instack[indepth];
3877 /* Try to parse as much of the argument as exists at this
3878 input stack level. */
3879 U_CHAR *bp = macarg1 (ip->bufp, ip->buf + ip->length,
3880 &paren, &newlines, &comments);
3882 /* If we find the end of the argument at this level,
3883 set up *ARGPTR to point at it in the input stack. */
3884 if (!(ip->fname != 0 && (newlines != 0 || comments != 0))
3885 && bp != ip->buf + ip->length) {
3887 argptr->raw = ip->bufp;
3888 argptr->raw_length = bp - ip->bufp;
3892 /* This input stack level ends before the macro argument does.
3893 We must pop levels and keep parsing.
3894 Therefore, we must allocate a temporary buffer and copy
3895 the macro argument into it. */
3896 int bufsize = bp - ip->bufp;
3897 int extra = newlines;
3898 U_CHAR *buffer = (U_CHAR *) xmalloc (bufsize + extra + 1);
3899 int final_start = 0;
3901 memcpy (buffer, ip->bufp, bufsize);
3903 ip->lineno += newlines;
3905 while (bp == ip->buf + ip->length) {
3906 if (instack[indepth].macro == 0) {
3908 return "unterminated macro call";
3910 ip->macro->type = T_MACRO;
3912 free (ip->free_ptr);
3913 ip = &instack[--indepth];
3916 bp = macarg1 (ip->bufp, ip->buf + ip->length, &paren,
3917 &newlines, &comments);
3918 final_start = bufsize;
3919 bufsize += bp - ip->bufp;
3921 buffer = (U_CHAR *) xrealloc (buffer, bufsize + extra + 1);
3922 memcpy (buffer + bufsize - (bp - ip->bufp), ip->bufp, bp - ip->bufp);
3924 ip->lineno += newlines;
3927 /* Now, if arg is actually wanted, record its raw form,
3928 discarding comments and duplicating newlines in whatever
3929 part of it did not come from a macro expansion.
3930 EXTRA space has been preallocated for duplicating the newlines.
3931 FINAL_START is the index of the start of that part. */
3933 argptr->raw = buffer;
3934 argptr->raw_length = bufsize;
3935 argptr->free1 = buffer;
3936 argptr->newlines = newlines;
3937 argptr->comments = comments;
3938 if ((newlines || comments) && ip->fname != 0)
3941 discard_comments (argptr->raw + final_start,
3942 argptr->raw_length - final_start,
3944 argptr->raw[argptr->raw_length] = 0;
3945 if (argptr->raw_length > bufsize + extra)
3950 /* If we are not discarding this argument,
3951 macroexpand it and compute its length as stringified.
3952 All this info goes into *ARGPTR. */
3956 register const U_CHAR *buf, *lim;
3957 register int totlen;
3959 obuf = expand_to_temp_buffer (argptr->raw,
3960 argptr->raw + argptr->raw_length,
3963 argptr->expanded = obuf.buf;
3964 argptr->expand_length = obuf.length;
3965 argptr->free2 = obuf.buf;
3968 lim = buf + argptr->raw_length;
3971 while (buf != lim) {
3972 register U_CHAR c = *buf++;
3974 /* Internal sequences of whitespace are replaced by one space
3975 in most cases, but not always. So count all the whitespace
3976 in case we need to keep it all. */
3977 if (c == '\"' || c == '\\') /* escape these chars */
3979 else if (!ISPRINT (c))
3982 argptr->stringified_length = totlen;
3987 /* Scan text from START (inclusive) up to LIMIT (exclusive),
3988 counting parens in *DEPTHPTR,
3989 and return if reach LIMIT
3990 or before a `)' that would make *DEPTHPTR negative
3991 or before a comma when *DEPTHPTR is zero.
3992 Single and double quotes are matched and termination
3993 is inhibited within them. Comments also inhibit it.
3994 Value returned is pointer to stopping place.
3996 Increment *NEWLINES each time a newline is passed.
3997 Set *COMMENTS to 1 if a comment is seen. */
4000 macarg1 (start, limit, depthptr, newlines, comments)
4002 register const U_CHAR *limit;
4003 int *depthptr, *newlines, *comments;
4005 register U_CHAR *bp = start;
4007 while (bp < limit) {
4013 if (--(*depthptr) < 0)
4017 /* Traditionally, backslash makes following char not special. */
4021 /* But count source lines anyway. */
4030 if (bp[1] == '\\' && bp[2] == '\n')
4031 newline_fix (bp + 1);
4032 if (bp[1] != '*' || bp + 1 >= limit)
4036 while (bp + 1 < limit) {
4038 && bp[1] == '\\' && bp[2] == '\n')
4039 newline_fix (bp + 1);
4040 if (bp[0] == '*' && bp[1] == '/')
4042 if (*bp == '\n') ++*newlines;
4051 for (quotec = *bp++; bp + 1 < limit && *bp != quotec; bp++) {
4056 while (*bp == '\\' && bp[1] == '\n') {
4059 } else if (*bp == '\n') {
4068 if ((*depthptr) == 0)
4078 /* Discard comments and duplicate newlines
4079 in the string of length LENGTH at START,
4080 except inside of string constants.
4081 The string is copied into itself with its beginning staying fixed.
4083 NEWLINES is the number of newlines that must be duplicated.
4084 We assume that that much extra space is available past the end
4088 discard_comments (start, length, newlines)
4093 register U_CHAR *ibp;
4094 register U_CHAR *obp;
4095 register const U_CHAR *limit;
4098 /* If we have newlines to duplicate, copy everything
4099 that many characters up. Then, in the second part,
4100 we will have room to insert the newlines
4102 NEWLINES may actually be too large, because it counts
4103 newlines in string constants, and we don't duplicate those.
4104 But that does no harm. */
4106 ibp = start + length;
4107 obp = ibp + newlines;
4109 while (limit != ibp)
4113 ibp = start + newlines;
4114 limit = start + length + newlines;
4117 while (ibp < limit) {
4118 *obp++ = c = *ibp++;
4121 /* Duplicate the newline. */
4133 if (*ibp == '\\' && ibp[1] == '\n')
4135 /* Delete any comment. */
4136 if (ibp[0] != '*' || ibp + 1 >= limit)
4140 while (ibp + 1 < limit) {
4142 && ibp[1] == '\\' && ibp[2] == '\n')
4143 newline_fix (ibp + 1);
4144 if (ibp[0] == '*' && ibp[1] == '/')
4153 /* Notice and skip strings, so that we don't
4154 think that comments start inside them,
4155 and so we don't duplicate newlines in them. */
4158 while (ibp < limit) {
4159 *obp++ = c = *ibp++;
4162 if (c == '\n' && quotec == '\'')
4164 if (c == '\\' && ibp < limit) {
4165 while (*ibp == '\\' && ibp[1] == '\n')
4179 /* Core error handling routine. */
4181 v_message (mtype, line, msgid, ap)
4187 const char *fname = 0;
4190 if (mtype == WARNING && inhibit_warnings)
4193 for (i = indepth; i >= 0; i--)
4194 if (instack[i].fname != NULL) {
4196 line = instack[i].lineno;
4197 fname = instack[i].fname;
4202 fprintf (stderr, "%s:%d: ", fname, line);
4204 fprintf (stderr, "%s: ", progname);
4206 if (mtype == WARNING)
4207 fputs ("warning: ", stderr);
4209 vfprintf (stderr, msgid, ap);
4210 putc ('\n', stderr);
4217 * error - print error message and increment count of errors.
4220 error VPARAMS ((const char *msgid, ...))
4222 #ifndef ANSI_PROTOTYPES
4227 VA_START(ap, msgid);
4229 #ifndef ANSI_PROTOTYPES
4230 msgid = va_arg (ap, const char *);
4233 v_message (ERROR, 0, msgid, ap);
4237 error_with_line VPARAMS ((int line, const char *msgid, ...))
4239 #ifndef ANSI_PROTOTYPES
4245 VA_START(ap, msgid);
4247 #ifndef ANSI_PROTOTYPES
4248 line = va_arg (ap, int);
4249 msgid = va_arg (ap, const char *);
4252 v_message (ERROR, line, msgid, ap);
4255 /* Error including a message from `errno'. */
4257 error_from_errno (name)
4260 error ("%s: %s", name, strerror (errno));
4263 /* Print error message but don't count it. */
4265 warning VPARAMS ((const char *msgid, ...))
4267 #ifndef ANSI_PROTOTYPES
4272 VA_START(ap, msgid);
4274 #ifndef ANSI_PROTOTYPES
4275 msgid = va_arg (ap, const char *);
4278 v_message (WARNING, 0, msgid, ap);
4282 fatal VPARAMS ((const char *msgid, ...))
4284 #ifndef ANSI_PROTOTYPES
4289 VA_START(ap, msgid);
4291 #ifndef ANSI_PROTOTYPES
4292 msgid = va_arg (ap, const char *);
4295 v_message (FATAL, 0, msgid, ap);
4296 exit (FATAL_EXIT_CODE);
4299 /* More 'friendly' abort that prints the location at which we died. */
4301 fancy_abort (line, func)
4305 fatal ("Internal error in %s, at tradcpp.c:%d\n\
4306 Please submit a full bug report.\n\
4307 See %s for instructions.", func, line, GCCBUGURL);
4311 perror_with_name (name)
4314 fprintf (stderr, "%s: %s: %s\n", progname, name, strerror (errno));
4319 pfatal_with_name (name)
4322 perror_with_name (name);
4323 exit (FATAL_EXIT_CODE);
4326 /* Return the line at which an error occurred.
4327 The error is not necessarily associated with the current spot
4328 in the input stack, so LINE says where. LINE will have been
4329 copied from ip->lineno for the current input level.
4330 If the current level is for a file, we return LINE.
4331 But if the current level is not for a file, LINE is meaningless.
4332 In that case, we return the lineno of the innermost file. */
4334 line_for_error (line)
4340 for (i = indepth; i >= 0; ) {
4341 if (instack[i].fname != 0)
4346 line1 = instack[i].lineno;
4352 * If OBUF doesn't have NEEDED bytes after OPTR, make it bigger.
4354 * As things stand, nothing is ever placed in the output buffer to be
4355 * removed again except when it's KNOWN to be part of an identifier,
4356 * so flushing and moving down everything left, instead of expanding,
4361 grow_outbuf (obuf, needed)
4362 register FILE_BUF *obuf;
4363 register int needed;
4368 if (obuf->length - (obuf->bufp - obuf->buf) > needed)
4371 /* Make it at least twice as big as it is now. */
4373 /* Make it have at least 150% of the free space we will need. */
4374 minsize = (3 * needed) / 2 + (obuf->bufp - obuf->buf);
4375 if (minsize > obuf->length)
4376 obuf->length = minsize;
4378 p = (U_CHAR *) xrealloc (obuf->buf, obuf->length);
4379 obuf->bufp = p + (obuf->bufp - obuf->buf);
4383 /* Symbol table for macro names and special symbols */
4386 * install a name in the main hash table, even if it is already there.
4387 * name stops with first non alphanumeric, except leading '#'.
4388 * caller must check against redefinition if that is desired.
4389 * delete_macro () removes things installed by install () in fifo order.
4390 * this is important because of the `defined' special symbol used
4391 * in #if, and also if pushdef/popdef directives are ever implemented.
4393 * If LEN is >= 0, it is the length of the name.
4394 * Otherwise, compute the length by scanning the entire name.
4396 * If HASH is >= 0, it is the precomputed hash code.
4397 * Otherwise, compute the hash code.
4399 * caller must set the value, if any is desired.
4402 install (name, len, type, hash)
4405 enum node_type type;
4407 /* watch out here if sizeof (U_CHAR *) != sizeof (int) */
4409 register HASHNODE *hp;
4410 register int bucket;
4411 register const U_CHAR *p;
4416 while (is_idchar[*p])
4422 hash = hashf (name, len, HASHSIZE);
4424 hp = (HASHNODE *) xmalloc (sizeof (HASHNODE) + len + 1);
4426 hp->bucket_hdr = &hashtab[bucket];
4427 hp->next = hashtab[bucket];
4428 hashtab[bucket] = hp;
4430 if (hp->next != NULL)
4431 hp->next->prev = hp;
4434 hp->name = q = ((U_CHAR *) hp) + sizeof (HASHNODE);
4435 memcpy (q, name, len);
4441 * find the most recent hash node for name name (ending with first
4442 * non-identifier char) installed by install
4444 * If LEN is >= 0, it is the length of the name.
4445 * Otherwise, compute the length by scanning the entire name.
4447 * If HASH is >= 0, it is the precomputed hash code.
4448 * Otherwise, compute the hash code.
4451 lookup (name, len, hash)
4456 register const U_CHAR *bp;
4457 register HASHNODE *bucket;
4460 for (bp = name; is_idchar[*bp]; bp++) ;
4465 hash = hashf (name, len, HASHSIZE);
4467 bucket = hashtab[hash];
4469 if (bucket->length == len
4470 && strncmp ((const char *)bucket->name, (const char *)name, len) == 0)
4472 bucket = bucket->next;
4478 * Delete a hash node. Some weirdness to free junk from macros.
4479 * More such weirdness will have to be added if you define more hash
4480 * types that need it.
4483 /* Note that the DEFINITION of a macro is removed from the hash table
4484 but its storage is not freed. This would be a storage leak
4485 except that it is not reasonable to keep undefining and redefining
4486 large numbers of macros many times.
4487 In any case, this is necessary, because a macro can be #undef'd
4488 in the middle of reading the arguments to a call to it.
4489 If #undef freed the DEFINITION, that would crash. */
4495 if (hp->prev != NULL)
4496 hp->prev->next = hp->next;
4497 if (hp->next != NULL)
4498 hp->next->prev = hp->prev;
4500 /* make sure that the bucket chain header that
4501 the deleted guy was on points to the right thing afterwards. */
4502 if (hp == *hp->bucket_hdr)
4503 *hp->bucket_hdr = hp->next;
4509 * return hash function on name. must be compatible with the one
4510 * computed a step at a time, elsewhere
4513 hashf (name, len, hashsize)
4514 register const U_CHAR *name;
4521 r = HASHSTEP (r, *name++);
4523 return MAKE_POS (r) % hashsize;
4526 /* Dump all macro definitions as #defines to stdout. */
4533 for (bucket = 0; bucket < HASHSIZE; bucket++) {
4534 register HASHNODE *hp;
4536 for (hp = hashtab[bucket]; hp; hp= hp->next) {
4537 if (hp->type == T_MACRO) {
4538 register DEFINITION *defn = hp->value.defn;
4544 /* Print the definition of the macro HP. */
4546 printf ("#define %s", hp->name);
4547 if (defn->nargs >= 0) {
4551 for (i = 0; i < defn->nargs; i++) {
4552 dump_arg_n (defn, i);
4553 if (i + 1 < defn->nargs)
4563 for (ap = defn->pattern; ap != NULL; ap = ap->next) {
4564 dump_defn_1 (defn->expansion, offset, ap->nchars);
4565 if (ap->nchars != 0)
4567 offset += ap->nchars;
4570 if (ap->raw_before && !concat)
4573 dump_arg_n (defn, ap->argno);
4574 if (ap->raw_after) {
4579 dump_defn_1 (defn->expansion, offset, defn->length - offset);
4586 /* Output to stdout a substring of a macro definition.
4587 BASE is the beginning of the definition.
4588 Output characters START thru LENGTH.
4589 Discard newlines outside of strings, thus
4590 converting funny-space markers to ordinary spaces. */
4592 dump_defn_1 (base, start, length)
4597 const U_CHAR *p = base + start;
4598 const U_CHAR *limit = base + start + length;
4603 else if (*p == '\"' || *p =='\'') {
4604 const U_CHAR *p1 = skip_quoted_string (p, limit, 0, 0, 0, 0);
4605 fwrite (p, p1 - p, 1, stdout);
4612 /* Print the name of argument number ARGNUM of macro definition DEFN.
4613 Recall that DEFN->argnames contains all the arg names
4614 concatenated in reverse order with comma-space in between. */
4616 dump_arg_n (defn, argnum)
4620 register const U_CHAR *p = defn->argnames;
4621 while (argnum + 1 < defn->nargs) {
4622 p = (const U_CHAR *) strchr ((const char *)p, ' ') + 1;
4626 while (*p && *p != ',') {
4632 /* Initialize syntactic classifications of characters. */
4634 initialize_char_syntax ()
4639 * Set up is_idchar and is_idstart tables. These should be
4640 * faster than saying (is_alpha (c) || c == '_'), etc.
4641 * Must do set up these things before calling any routines tthat
4644 for (i = 'a'; i <= 'z'; i++) {
4645 is_idchar[i - 'a' + 'A'] = 1;
4647 is_idstart[i - 'a' + 'A'] = 1;
4650 for (i = '0'; i <= '9'; i++)
4653 is_idstart['_'] = 1;
4655 /* horizontal space table */
4656 is_hor_space[' '] = 1;
4657 is_hor_space['\t'] = 1;
4658 is_hor_space['\v'] = 1;
4659 is_hor_space['\f'] = 1;
4660 is_hor_space['\r'] = 1;
4670 /* Initialize the built-in macros. */
4671 #define DSC(x) U x, sizeof x - 1
4672 #define install_spec(name, type) \
4673 install(DSC(name), type, -1);
4674 #define install_value(name, val) \
4675 hp = install(DSC(name), T_CONST, -1); hp->value.cpval = val;
4677 initialize_builtins ()
4681 install_spec ("__BASE_FILE__", T_BASE_FILE);
4682 install_spec ("__DATE__", T_DATE);
4683 install_spec ("__FILE__", T_FILE);
4684 install_spec ("__TIME__", T_TIME);
4685 install_spec ("__VERSION__", T_VERSION);
4686 install_spec ("__INCLUDE_LEVEL__", T_INCLUDE_LEVEL);
4687 install_spec ("__LINE__", T_SPECLINE);
4689 #ifndef NO_BUILTIN_SIZE_TYPE
4690 install_value ("__SIZE_TYPE__", SIZE_TYPE);
4692 #ifndef NO_BUILTIN_PTRDIFF_TYPE
4693 install_value ("__PTRDIFF_TYPE__", PTRDIFF_TYPE);
4695 #ifndef NO_BUILTIN_WCHAR_TYPE
4696 install_value ("__WCHAR_TYPE__", WCHAR_TYPE);
4698 #ifndef NO_BUILTIN_WINT_TYPE
4699 install_value ("__WINT_TYPE__", WINT_TYPE);
4701 install_value ("__REGISTER_PREFIX__", REGISTER_PREFIX);
4702 install_value ("__USER_LABEL_PREFIX__", user_label_prefix);
4706 #undef install_value
4708 /* Common handler of command line directives -U, -D and -A. */
4710 run_directive (str, len, type)
4713 enum node_type type;
4715 struct directive *kt;
4716 FILE_BUF *ip = &instack[++indepth];
4717 ip->fname = "*command line*";
4719 ip->buf = ip->bufp = (U_CHAR *) str;
4724 ip->if_stack = if_stack;
4726 for (kt = directive_table; kt->type != type; kt++)
4729 (*kt->func) ((U_CHAR *) str, (U_CHAR *) str + len, NULL);
4733 /* Handle the -D option. If STR is just an identifier, define it with
4734 * value 1. If STR has anything after the identifier, then it should
4735 * be identifier-space-definition. */
4737 make_definition (str)
4743 /* Copy the entire option so we can modify it.
4744 Change the first "=" in the string to a space. If there is none,
4745 tack " 1" on the end. */
4747 /* Length including the null. */
4748 count = strlen (str);
4749 buf = (char *) alloca (count + 2);
4750 memcpy (buf, str, count);
4752 p = strchr (str, '=');
4761 run_directive (buf, count, T_DEFINE);
4764 /* Handle the -U option. */
4769 run_directive (str, strlen (str), T_UNDEF);
4772 /* Handles the #assert (-A) and #unassert (-A-) command line options. */
4774 make_assertion (str)
4777 enum node_type type = T_ASSERT;
4787 count = strlen (str);
4788 p = strchr (str, '=');
4791 /* Copy the entire option so we can modify it. Change the first
4792 "=" in the string to a '(', and tack a ')' on the end. */
4793 char *buf = (char *) alloca (count + 1);
4795 memcpy (buf, str, count);
4801 run_directive (str, count, type);
4804 /* Add output to `deps_buffer' for the -M switch.
4805 STRING points to the text to be output.
4806 SIZE is the number of bytes, or 0 meaning output until a null.
4807 If SIZE is nonzero, we break the line first, if it is long enough. */
4809 deps_output (string, size)
4813 #ifndef MAX_OUTPUT_COLUMNS
4814 #define MAX_OUTPUT_COLUMNS 75
4816 if (size != 0 && deps_column != 0
4817 && size + deps_column > MAX_OUTPUT_COLUMNS) {
4818 deps_output ("\\\n ", 0);
4823 size = strlen (string);
4825 if (deps_size + size + 1 > deps_allocated_size) {
4826 deps_allocated_size = deps_size + size + 50;
4827 deps_allocated_size *= 2;
4828 deps_buffer = (char *) xrealloc (deps_buffer, deps_allocated_size);
4830 memcpy (&deps_buffer[deps_size], string, size);
4832 deps_column += size;
4833 deps_buffer[deps_size] = 0;
4836 /* Get the file-mode and data size of the file open on FD
4837 and store them in *MODE_POINTER and *SIZE_POINTER. */
4840 file_size_and_mode (fd, mode_pointer, size_pointer)
4847 if (fstat (fd, &sbuf) < 0) return -1;
4848 if (mode_pointer) *mode_pointer = sbuf.st_mode;
4849 if (size_pointer) *size_pointer = sbuf.st_size;