1 /* C Compatible Compiler Preprocessor (CCCP)
2 Copyright (C) 1986, 1987, 1989, 2000, 2001 Free Software Foundation, Inc.
3 Written by Paul Rubin, June 1986
4 Adapted to ANSI C, Richard Stallman, Jan 1987
5 Dusted off, polished, and adapted for use as traditional
6 preprocessor only, Zack Weinberg, Jul 2000
8 This program is free software; you can redistribute it and/or modify it
9 under the terms of the GNU General Public License as published by the
10 Free Software Foundation; either version 2, or (at your option) any
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
25 #include "cppdefault.h"
28 typedef unsigned char U_CHAR
;
30 /* Name under which this program was invoked. */
32 static const char *progname
;
34 /* Current maximum length of directory names in the search path
35 for include files. (Altered as we get more of them.) */
37 size_t max_include_len
;
39 /* Nonzero means copy comments into the output file. */
41 int put_out_comments
= 0;
43 /* Nonzero means print the names of included files rather than
44 the preprocessed output. 1 means just the #include "...",
45 2 means #include <...> as well. */
49 /* Nonzero means don't output line number information. */
53 /* Nonzero means inhibit output of the preprocessed text
54 and instead output the definitions of all user-defined macros
55 in a form suitable for use as input to cccp. */
59 /* Nonzero means don't print warning messages. -w. */
61 int inhibit_warnings
= 0;
63 /* Nonzero means warn if slash-star appears in a comment. */
67 /* Nonzero causes output not to be done,
68 but directives such as #define that have side effects
73 /* Value of __USER_LABEL_PREFIX__. Target-dependent, also controlled
74 by -f(no-)leading-underscore. */
75 static const char *user_label_prefix
;
77 /* I/O buffer structure.
78 The `fname' field is nonzero for source files and #include files
79 and for the dummy text used for -D and -U.
80 It is zero for rescanning results of macro expansion
81 and for expanding macro arguments. */
82 #define INPUT_STACK_MAX 200
89 /* Macro that this level is the expansion of.
90 Included so that we can reenable the macro
91 at the end of this level. */
92 struct hashnode
*macro
;
93 /* Value of if_stack at start of this file.
94 Used to prohibit unmatched #endif (etc) in an include file. */
95 struct if_stack
*if_stack
;
96 /* Object to be freed at end of input at this level. */
98 } instack
[INPUT_STACK_MAX
];
100 typedef struct file_buf FILE_BUF
;
102 /* Current nesting level of input sources.
103 `instack[indepth]' is the level currently being read. */
105 #define CHECK_DEPTH(code) \
106 if (indepth >= (INPUT_STACK_MAX - 1)) \
108 error_with_line (line_for_error (instack[indepth].lineno), \
109 "macro or #include recursion too deep"); \
113 /* Current depth in #include directives that use <...>. */
114 int system_include_depth
= 0;
116 /* The output buffer. Its LENGTH field is the amount of room allocated
117 for the buffer, not the number of chars actually present. To get
118 that, subtract outbuf.buf from outbuf.bufp. */
120 #define OUTBUF_SIZE 10 /* initial size of output buffer */
123 /* Grow output buffer OBUF points at
124 so it can hold at least NEEDED more chars. */
126 #define check_expand(OBUF, NEEDED) do { \
127 if ((OBUF)->length - ((OBUF)->bufp - (OBUF)->buf) <= (NEEDED)) \
128 grow_outbuf ((OBUF), (NEEDED)); \
131 struct file_name_list
133 struct file_name_list
*next
;
137 struct file_name_list
*include
= 0; /* First dir to search */
138 /* First dir to search for <file> */
139 struct file_name_list
*first_bracket_include
= 0;
140 struct file_name_list
*last_include
= 0; /* Last in chain */
142 /* List of included files that contained #once. */
143 struct file_name_list
*dont_repeat_files
= 0;
145 /* List of other included files. */
146 struct file_name_list
*all_include_files
= 0;
148 /* Structure allocated for every #define. For a simple replacement
151 nargs = -1, the `pattern' list is null, and the expansion is just
152 the replacement text. Nargs = 0 means a functionlike macro with no args,
154 #define getchar() getc (stdin) .
155 When there are args, the expansion is the replacement text with the
156 args squashed out, and the reflist is a list describing how to
157 build the output from the input: e.g., "3 chars, then the 1st arg,
158 then 9 chars, then the 3rd arg, then 0 chars, then the 2nd arg".
159 The chars here come from the expansion. Whatever is left of the
160 expansion after the last arg-occurrence is copied after that arg.
161 Note that the reflist can be arbitrarily long---
162 its length depends on the number of times the arguments appear in
163 the replacement text, not how many args there are. Example:
164 #define f(x) x+x+x+x+x+x+x would have replacement text "++++++" and
166 { (0, 1), (1, 1), (1, 1), ..., (1, 1), NULL }
167 where (x, y) means (nchars, argno). */
169 typedef struct definition DEFINITION
;
172 int length
; /* length of expansion string */
175 struct reflist
*next
;
176 char stringify
; /* nonzero if this arg was preceded by a
178 char raw_before
; /* Nonzero if a ## operator before arg. */
179 char raw_after
; /* Nonzero if a ## operator after arg. */
180 int nchars
; /* Number of literal chars to copy before
181 this arg occurrence. */
182 int argno
; /* Number of arg to substitute (origin-0) */
184 /* Names of macro args, concatenated in reverse order
185 with comma-space between them.
186 The only use of this is that we warn on redefinition
187 if this differs between the old and new definitions. */
188 const U_CHAR
*argnames
;
191 /* Chained list of answers to an assertion. */
195 const unsigned char *answer
;
199 /* different kinds of things that can appear in the value field
200 of a hash node. Actually, this may be useless now. */
204 struct answer
*answers
;
207 /* The structure of a node in the hash table. The hash table
208 has entries for all tokens defined by #define commands (type T_MACRO),
209 plus some special tokens like __LINE__ (these each have their own
210 type, and the appropriate code is run when that type of node is seen.
211 It does not contain control words like "#define", which are recognized
212 by a separate piece of code. */
214 /* different flavors of hash nodes --- also used in keyword table */
216 T_DEFINE
= 1, /* `#define' */
217 T_INCLUDE
, /* `#include' */
218 T_IFDEF
, /* `#ifdef' */
219 T_IFNDEF
, /* `#ifndef' */
221 T_ELSE
, /* `#else' */
222 T_ELIF
, /* `#elif' */
223 T_UNDEF
, /* `#undef' */
224 T_LINE
, /* `#line' */
225 T_ENDIF
, /* `#endif' */
226 T_ERROR
, /* `#error' */
227 T_WARNING
, /* `#warning' */
228 T_ASSERT
, /* `#assert' */
229 T_UNASSERT
, /* `#unassert' */
230 T_SPECLINE
, /* special symbol `__LINE__' */
231 T_DATE
, /* `__DATE__' */
232 T_FILE
, /* `__FILE__' */
233 T_BASE_FILE
, /* `__BASE_FILE__' */
234 T_INCLUDE_LEVEL
, /* `__INCLUDE_LEVEL__' */
235 T_VERSION
, /* `__VERSION__' */
236 T_TIME
, /* `__TIME__' */
237 T_CONST
, /* Constant value, used by `__STDC__' */
238 T_MACRO
, /* macro defined by `#define' */
239 T_SPEC_DEFINED
, /* special `defined' macro for use in #if statements */
240 T_UNUSED
/* Used for something not defined. */
244 struct hashnode
*next
; /* double links for easy deletion */
245 struct hashnode
*prev
;
246 struct hashnode
**bucket_hdr
; /* also, a back pointer to this node's hash
247 chain is kept, in case the node is the head
248 of the chain and gets deleted. */
249 enum node_type type
; /* type of special token */
250 int length
; /* length of token, for quick comparison */
251 U_CHAR
*name
; /* the actual name */
252 union hashval value
; /* pointer to expansion, or whatever */
255 typedef struct hashnode HASHNODE
;
257 static HASHNODE
*parse_assertion
PARAMS ((const unsigned char *,
258 const unsigned char *,
259 struct answer
**, int));
260 static struct answer
**find_answer
PARAMS ((HASHNODE
*,
261 const struct answer
*));
262 static int parse_answer
PARAMS ((const unsigned char *, const unsigned char *,
263 struct answer
**, int));
264 static unsigned char *canonicalize_text
PARAMS ((const unsigned char *,
265 const unsigned char *,
266 const unsigned char **));
268 /* Some definitions for the hash table. The hash function MUST be
269 computed as shown in hashf () below. That is because the rescan
270 loop computes the hash value `on the fly' for most tokens,
271 in order to avoid the overhead of a lot of procedure calls to
272 the hashf () function. Hashf () only exists for the sake of
273 politeness, for use when speed isn't so important. */
275 #define HASHSIZE 1403
276 HASHNODE
*hashtab
[HASHSIZE
];
277 #define HASHSTEP(old, c) ((old << 2) + c)
278 #define MAKE_POS(v) (v & 0x7fffffff) /* make number positive */
280 /* `struct directive' defines one #-directive, including how to handle it. */
283 int length
; /* Length of name */
284 void (*func
) PARAMS ((U_CHAR
*, U_CHAR
*, FILE_BUF
*));
285 /* Function to handle directive */
286 const char *name
; /* Name of directive */
287 enum node_type type
; /* Code which describes which directive. */
290 /* Last arg to output_line_command. */
291 enum file_change_code
{same_file
, enter_file
, leave_file
};
293 /* This structure represents one parsed argument in a macro call.
294 `raw' points to the argument text as written (`raw_length' is its length).
295 `expanded' points to the argument's macro-expansion
296 (its length is `expand_length').
297 `stringified_length' is the length the argument would have
299 `free1' and `free2', if nonzero, point to blocks to be freed
300 when the macro argument data is no longer needed. */
303 U_CHAR
*raw
, *expanded
;
304 int raw_length
, expand_length
;
305 int stringified_length
;
306 U_CHAR
*free1
, *free2
;
311 /* The arglist structure is built by do_define to tell
312 collect_definition where the argument names begin. That
313 is, for a define like "#define f(x,y,z) foo+x-bar*y", the arglist
314 would contain pointers to the strings x, y, and z.
315 Collect_definition would then build a DEFINITION node,
316 with reflist nodes pointing to the places x, y, and z had
317 appeared. So the arglist is just convenience data passed
318 between these two routines. It is not kept around after
319 the current #define has been processed and entered into the
323 struct arglist
*next
;
329 /* Function prototypes. */
331 static void do_define
PARAMS ((U_CHAR
*, U_CHAR
*, FILE_BUF
*));
332 static void do_error
PARAMS ((U_CHAR
*, U_CHAR
*, FILE_BUF
*));
333 static void do_warning
PARAMS ((U_CHAR
*, U_CHAR
*, FILE_BUF
*));
334 static void do_line
PARAMS ((U_CHAR
*, U_CHAR
*, FILE_BUF
*));
335 static void do_include
PARAMS ((U_CHAR
*, U_CHAR
*, FILE_BUF
*));
336 static void do_undef
PARAMS ((U_CHAR
*, U_CHAR
*, FILE_BUF
*));
337 static void do_if
PARAMS ((U_CHAR
*, U_CHAR
*, FILE_BUF
*));
338 static void do_ifdef
PARAMS ((U_CHAR
*, U_CHAR
*, FILE_BUF
*));
339 static void do_ifndef
PARAMS ((U_CHAR
*, U_CHAR
*, FILE_BUF
*));
340 static void do_else
PARAMS ((U_CHAR
*, U_CHAR
*, FILE_BUF
*));
341 static void do_elif
PARAMS ((U_CHAR
*, U_CHAR
*, FILE_BUF
*));
342 static void do_endif
PARAMS ((U_CHAR
*, U_CHAR
*, FILE_BUF
*));
343 static void do_assert
PARAMS ((U_CHAR
*, U_CHAR
*, FILE_BUF
*));
344 static void do_unassert
PARAMS ((U_CHAR
*, U_CHAR
*, FILE_BUF
*));
345 static void do_xifdef
PARAMS ((U_CHAR
*, U_CHAR
*, enum node_type
));
347 static struct hashnode
*install
PARAMS ((const U_CHAR
*, int, enum node_type
, int));
348 static int hashf
PARAMS ((const U_CHAR
*, int, int));
349 static int compare_defs
PARAMS ((DEFINITION
*, DEFINITION
*));
350 static int comp_def_part
PARAMS ((int, const U_CHAR
*, int,
351 const U_CHAR
*, int, int));
352 static void delete_macro
PARAMS ((HASHNODE
*));
354 /* First arg to v_message. */
355 enum msgtype
{ WARNING
= 0, ERROR
, FATAL
};
356 static void v_message
PARAMS ((enum msgtype mtype
, int line
,
357 const char *msgid
, va_list ap
))
358 ATTRIBUTE_PRINTF (3, 0);
360 static int line_for_error
PARAMS ((int));
362 /* We know perfectly well which file this is, so we don't need to
365 #if (GCC_VERSION >= 2007)
366 #define abort() fancy_abort(__LINE__, __FUNCTION__)
368 #define abort() fancy_abort(__LINE__, 0);
371 static void macroexpand
PARAMS ((HASHNODE
*, FILE_BUF
*));
372 static void special_symbol
PARAMS ((HASHNODE
*, FILE_BUF
*));
373 static void dump_all_macros
PARAMS ((void));
374 static void dump_defn_1
PARAMS ((const U_CHAR
*, int, int));
375 static void dump_arg_n
PARAMS ((DEFINITION
*, int));
376 static void conditional_skip
PARAMS ((FILE_BUF
*, int, enum node_type
));
377 static void skip_if_group
PARAMS ((FILE_BUF
*, int));
378 static void output_line_command
PARAMS ((FILE_BUF
*, FILE_BUF
*,
379 int, enum file_change_code
));
381 static int eval_if_expression
PARAMS ((const U_CHAR
*, int));
383 static void initialize_builtins
PARAMS ((void));
384 static void run_directive
PARAMS ((const char *, size_t,
386 static void make_definition
PARAMS ((const char *));
387 static void make_undef
PARAMS ((const char *));
388 static void make_assertion
PARAMS ((const char *));
390 static void grow_outbuf
PARAMS ((FILE_BUF
*, int));
391 static int handle_directive
PARAMS ((FILE_BUF
*, FILE_BUF
*));
392 static void finclude
PARAMS ((int, const char *, FILE_BUF
*));
393 static void deps_output
PARAMS ((const char *, int));
394 static void rescan
PARAMS ((FILE_BUF
*, int));
395 static void newline_fix
PARAMS ((U_CHAR
*));
396 static void name_newline_fix
PARAMS ((U_CHAR
*));
397 static U_CHAR
*macarg1
PARAMS ((U_CHAR
*, const U_CHAR
*, int *,
399 static const char *macarg
PARAMS ((struct argdata
*));
400 static int discard_comments
PARAMS ((U_CHAR
*, int, int));
401 static int file_size_and_mode
PARAMS ((int, int *, long *));
403 static U_CHAR
*skip_to_end_of_comment
PARAMS ((FILE_BUF
*, int *));
404 static U_CHAR
*skip_quoted_string
PARAMS ((const U_CHAR
*, const U_CHAR
*,
405 int, int *, int *, int *));
407 int main
PARAMS ((int, char **));
409 /* Convenience. Write U"string" to get an unsigned string constant. */
410 #define U (const unsigned char *)
412 /* Here is the actual list of #-directives, most-often-used first. */
414 struct directive directive_table
[] = {
415 { 6, do_define
, "define", T_DEFINE
},
416 { 7, do_include
, "include", T_INCLUDE
},
417 { 5, do_endif
, "endif", T_ENDIF
},
418 { 5, do_ifdef
, "ifdef", T_IFDEF
},
419 { 2, do_if
, "if", T_IF
, },
420 { 4, do_else
, "else", T_ELSE
},
421 { 6, do_ifndef
, "ifndef", T_IFNDEF
},
422 { 5, do_undef
, "undef", T_UNDEF
},
423 { 4, do_line
, "line", T_LINE
},
424 { 4, do_elif
, "elif", T_ELIF
},
425 { 5, do_error
, "error", T_ERROR
},
426 { 7, do_warning
, "warning", T_WARNING
},
427 { 6, do_assert
, "assert", T_ASSERT
},
428 { 8, do_unassert
,"unassert",T_UNASSERT
},
429 { -1, 0, "", T_UNUSED
},
432 #define SKIP_WHITE_SPACE(p) do { while (is_nvspace(*p)) p++; } while (0)
433 #define SKIP_ALL_WHITE_SPACE(p) do { while (is_space(*p)) p++; } while (0)
435 int errors
= 0; /* Error counter for exit code */
437 static FILE_BUF expand_to_temp_buffer
PARAMS ((const U_CHAR
*, const U_CHAR
*, int));
438 static DEFINITION
*collect_expansion
PARAMS ((U_CHAR
*, U_CHAR
*, int,
441 /* Stack of conditionals currently in progress
442 (including both successful and failing conditionals). */
445 struct if_stack
*next
; /* for chaining to the next stack frame */
446 const char *fname
; /* copied from input when frame is made */
447 int lineno
; /* similarly */
448 int if_succeeded
; /* true if a leg of this if-group
449 has been passed through rescan */
450 enum node_type type
; /* type of last directive seen in this group */
452 typedef struct if_stack IF_STACK_FRAME
;
453 IF_STACK_FRAME
*if_stack
= NULL
;
455 /* Buffer of -M output. */
459 /* Number of bytes allocated in above. */
460 int deps_allocated_size
;
462 /* Number of bytes used. */
465 /* Number of bytes since the last newline. */
468 /* Nonzero means -I- has been seen,
469 so don't look for #include "foo" the source-file directory. */
472 /* Pending directives. */
473 enum pending_dir_t
{PD_NONE
= 0, PD_DEFINE
, PD_UNDEF
, PD_ASSERTION
, PD_FILE
};
475 typedef struct pending_dir pending_dir
;
479 enum pending_dir_t type
;
489 const char *in_fname
, *out_fname
;
492 pending_dir
*pend
= (pending_dir
*) xcalloc (argc
, sizeof (pending_dir
));
493 int no_standard_includes
= 0;
495 /* Non-0 means don't output the preprocessed program. */
496 int inhibit_output
= 0;
498 /* Stream on which to print the dependency information. */
499 FILE *deps_stream
= 0;
500 /* Target-name to write with the dependency information. */
501 char *deps_target
= 0;
504 /* Get rid of any avoidable limit on stack size. */
508 /* Set the stack limit huge so that alloca (particularly stringtab
509 * in dbxread.c) does not fail. */
510 getrlimit (RLIMIT_STACK
, &rlim
);
511 rlim
.rlim_cur
= rlim
.rlim_max
;
512 setrlimit (RLIMIT_STACK
, &rlim
);
514 #endif /* RLIMIT_STACK defined */
521 no_line_commands
= 0;
525 max_include_len
= cpp_GCC_INCLUDE_DIR_len
+ 7; /* ??? */
527 /* Process switches and find input file name. */
529 for (i
= 1; i
< argc
; i
++) {
530 if (argv
[i
][0] != '-') {
531 if (out_fname
!= NULL
)
532 fatal ("Usage: %s [switches] input output", argv
[0]);
533 else if (in_fname
!= NULL
)
544 break; /* Ignore for compatibility with ISO/extended cpp. */
547 if (!strcmp (argv
[i
], "-lang-c++")
548 || !strcmp (argv
[i
], "-lang-objc++"))
549 fatal ("-traditional is not supported in C++");
550 else if (!strcmp (argv
[i
], "-lang-c89"))
551 fatal ("-traditional and -ansi are mutually exclusive");
552 else if (!strcmp (argv
[i
], "-lang-objc"))
553 pend
[i
].type
= PD_DEFINE
, pend
[i
].arg
= "__OBJC__";
554 else if (!strcmp (argv
[i
], "-lang-asm"))
555 pend
[i
].type
= PD_DEFINE
, pend
[i
].arg
= "__ASSEMBLER__";
556 else if (!strcmp (argv
[i
], "-lang-fortran"))
557 pend
[i
].type
= PD_DEFINE
, pend
[i
].arg
= "_LANGUAGE_FORTRAN";
558 /* All other possibilities ignored. */
562 if (!strcmp (argv
[i
], "-include"))
565 fatal ("Filename missing after -i option");
567 pend
[i
].type
= PD_FILE
, pend
[i
].arg
= argv
[i
+ 1], i
++;
569 else if (!strcmp (argv
[i
], "-iprefix"))
570 i
++; /* Ignore for compatibility */
571 else if (!strcmp (argv
[i
], "-isystem")
572 || !strcmp (argv
[i
], "-iwithprefix")
573 || !strcmp (argv
[i
], "-iwithprefixbefore")
574 || !strcmp (argv
[i
], "-idirafter"))
575 goto add_include
; /* best we can do */
580 if (out_fname
!= NULL
)
581 fatal ("Output filename specified twice");
583 fatal ("Filename missing after -o option");
584 out_fname
= argv
[++i
];
585 if (!strcmp (out_fname
, "-"))
590 inhibit_warnings
= 1;
594 if (!strcmp (argv
[i
], "-Wcomments"))
596 else if (!strcmp (argv
[i
], "-Wcomment"))
598 else if (!strcmp (argv
[i
], "-Wall")) {
604 if (!strcmp (argv
[i
], "-fleading-underscore"))
605 user_label_prefix
= "_";
606 else if (!strcmp (argv
[i
], "-fno-leading-underscore"))
607 user_label_prefix
= "";
611 if (!strcmp (argv
[i
], "-M"))
613 else if (!strcmp (argv
[i
], "-MM"))
624 fprintf (stderr
, "GNU traditional CPP version %s\n", version_string
);
635 else if (i
+ 1 == argc
)
636 fatal ("Macro name missing after -%c option", c
);
641 pend
[i
].type
= PD_DEFINE
;
643 pend
[i
].type
= PD_UNDEF
;
645 pend
[i
].type
= PD_ASSERTION
;
651 put_out_comments
= 1;
655 if (!strcmp (argv
[i
], "-pedantic"))
656 fatal ("-pedantic and -traditional are mutually exclusive");
660 if (!strcmp (argv
[i
], "-trigraphs"))
661 fatal ("-trigraphs and -traditional are mutually exclusive");
665 no_line_commands
= 1;
668 case 'I': /* Add directory to path for includes. */
671 struct file_name_list
*dirtmp
;
673 if (! ignore_srcdir
&& !strcmp (argv
[i
] + 2, "-"))
676 dirtmp
= (struct file_name_list
*)
677 xmalloc (sizeof (struct file_name_list
));
678 dirtmp
->next
= 0; /* New one goes on the end */
682 last_include
->next
= dirtmp
;
683 last_include
= dirtmp
; /* Tail follows the last one */
684 if (argv
[i
][1] == 'I' && argv
[i
][2] != 0)
685 dirtmp
->fname
= argv
[i
] + 2;
686 else if (i
+ 1 == argc
)
687 fatal ("Directory name missing after -I option");
689 dirtmp
->fname
= argv
[++i
];
690 if (strlen (dirtmp
->fname
) > max_include_len
)
691 max_include_len
= strlen (dirtmp
->fname
);
692 if (ignore_srcdir
&& first_bracket_include
== 0)
693 first_bracket_include
= dirtmp
;
699 /* -nostdinc causes no default include directories.
700 You must specify all include-file directories with -I. */
701 no_standard_includes
= 1;
704 case '\0': /* JF handle '-' as file name meaning stdin or stdout */
705 if (in_fname
== NULL
) {
708 } else if (out_fname
== NULL
) {
711 } /* else fall through into error */
714 fatal ("Invalid option `%s'", argv
[i
]);
719 if (user_label_prefix
== 0)
720 user_label_prefix
= USER_LABEL_PREFIX
;
722 /* Install __LINE__, etc. Must follow option processing. */
723 initialize_builtins ();
725 /* Do defines specified with -D and undefines specified with -U. */
726 for (i
= 1; i
< argc
; i
++)
727 if (pend
[i
].type
== PD_DEFINE
)
728 make_definition (pend
[i
].arg
);
729 else if (pend
[i
].type
== PD_UNDEF
)
730 make_undef (pend
[i
].arg
);
731 else if (pend
[i
].type
== PD_ASSERTION
)
732 make_assertion (pend
[i
].arg
);
734 /* Unless -fnostdinc,
735 tack on the standard include file dirs to the specified list */
736 if (!no_standard_includes
) {
737 const struct default_include
*di
;
738 struct file_name_list
*old_last_include
= last_include
;
739 struct file_name_list
*dirtmp
;
740 for (di
= cpp_include_defaults
; di
->fname
; di
++) {
743 dirtmp
= (struct file_name_list
*)
744 xmalloc (sizeof (struct file_name_list
));
745 dirtmp
->next
= 0; /* New one goes on the end */
749 last_include
->next
= dirtmp
;
750 last_include
= dirtmp
; /* Tail follows the last one */
751 dirtmp
->fname
= di
->fname
;
752 if (strlen (dirtmp
->fname
) > max_include_len
)
753 max_include_len
= strlen (dirtmp
->fname
);
756 if (ignore_srcdir
&& first_bracket_include
== 0)
757 first_bracket_include
= old_last_include
->next
;
760 /* Initialize output buffer */
762 outbuf
.buf
= (U_CHAR
*) xmalloc (OUTBUF_SIZE
);
763 outbuf
.bufp
= outbuf
.buf
;
764 outbuf
.length
= OUTBUF_SIZE
;
766 /* Scan the -i files before the main input.
767 Much like #including them, but with no_output set
768 so that only their macro definitions matter. */
772 for (i
= 1; i
< argc
; i
++)
773 if (pend
[i
].type
== PD_FILE
)
775 int fd
= open (pend
[i
].arg
, O_RDONLY
, 0666);
778 perror_with_name (pend
[i
].arg
);
779 return FATAL_EXIT_CODE
;
781 finclude (fd
, pend
[i
].arg
, &outbuf
);
786 /* Pending directives no longer needed. */
789 /* Create an input stack level for the main input file
790 and copy the entire contents of the file into it. */
792 fp
= &instack
[++indepth
];
794 /* JF check for stdin */
795 if (in_fname
== NULL
|| *in_fname
== 0) {
798 } else if ((f
= open (in_fname
, O_RDONLY
, 0666)) < 0)
801 /* Either of two environment variables can specify output of deps.
802 Its value is either "OUTPUT_FILE" or "OUTPUT_FILE DEPS_TARGET",
803 where OUTPUT_FILE is the file to write deps info to
804 and DEPS_TARGET is the target to mention in the deps. */
807 && (getenv ("SUNPRO_DEPENDENCIES") != 0
808 || getenv ("DEPENDENCIES_OUTPUT") != 0))
810 char *spec
= getenv ("DEPENDENCIES_OUTPUT");
816 spec
= getenv ("SUNPRO_DEPENDENCIES");
822 /* Find the space before the DEPS_TARGET, if there is one. */
823 s
= strchr (spec
, ' ');
827 output_file
= (char *) xmalloc (s
- spec
+ 1);
828 memcpy (output_file
, spec
, s
- spec
);
829 output_file
[s
- spec
] = 0;
837 deps_stream
= fopen (output_file
, "a");
838 if (deps_stream
== 0)
839 pfatal_with_name (output_file
);
841 /* If the -M option was used, output the deps to standard output. */
843 deps_stream
= stdout
;
845 /* For -M, print the expected object file name
846 as the target of this Make-rule. */
848 deps_allocated_size
= 200;
849 deps_buffer
= (char *) xmalloc (deps_allocated_size
);
855 deps_output (deps_target
, 0);
856 deps_output (":", 0);
857 } else if (*in_fname
== 0)
858 deps_output ("-: ", 0);
861 const char *p
= in_fname
;
863 /* Discard all directory prefixes from P. */
869 /* Output P, but remove known suffixes. */
871 if (p
[len
- 2] == '.'
872 && (p
[len
- 1] == 'c' || p
[len
- 1] == 'C' || p
[len
- 1] == 'S'))
873 deps_output (p
, len
- 2);
874 else if (p
[len
- 3] == '.'
876 && p
[len
- 1] == 'c')
877 deps_output (p
, len
- 3);
880 /* Supply our own suffix. */
881 deps_output (".o : ", 0);
882 deps_output (in_fname
, 0);
883 deps_output (" ", 0);
887 if (file_size_and_mode (f
, &st_mode
, &st_size
))
889 fp
->fname
= in_fname
;
891 /* JF all this is mine about reading pipes and ttys */
892 if (!S_ISREG (st_mode
)) {
893 /* Read input from a file that is not a normal disk file.
894 We cannot preallocate a buffer with the correct size,
895 so we must read in the file a piece at the time and make it bigger. */
903 fp
->buf
= (U_CHAR
*) xmalloc (bsize
+ 2);
906 cnt
= read (f
, bufp
, bsize
- size
);
907 if (cnt
< 0) goto sys_error
; /* error! */
908 if (cnt
== 0) break; /* End of file */
911 if (bsize
== size
) { /* Buffer is full! */
913 fp
->buf
= (U_CHAR
*) xrealloc (fp
->buf
, bsize
+ 2);
914 bufp
= fp
->buf
+ size
; /* May have moved */
919 /* Read a file whose size we can determine in advance.
920 For the sake of VMS, st_size is just an upper bound. */
923 fp
->buf
= (U_CHAR
*) xmalloc (st_size
+ 2);
925 while (st_size
> 0) {
926 i
= read (f
, fp
->buf
+ fp
->length
, st_size
);
936 fp
->if_stack
= if_stack
;
938 /* Make sure data ends with a newline. And put a null after it. */
940 if (fp
->length
> 0 && fp
->buf
[fp
->length
-1] != '\n')
941 fp
->buf
[fp
->length
++] = '\n';
942 fp
->buf
[fp
->length
] = '\0';
944 /* Now that we know the input file is valid, open the output. */
946 if (!out_fname
|| !strcmp (out_fname
, ""))
947 out_fname
= "stdout";
948 else if (! freopen (out_fname
, "w", stdout
))
949 pfatal_with_name (out_fname
);
951 output_line_command (fp
, &outbuf
, 0, same_file
);
953 /* Scan the input, processing macros and directives. */
957 /* Now we have processed the entire input
958 Write whichever kind of output has been requested. */
963 else if (! inhibit_output
&& deps_stream
!= stdout
) {
964 if (write (fileno (stdout
), outbuf
.buf
, outbuf
.bufp
- outbuf
.buf
) < 0)
965 fatal ("I/O error on output");
969 fputs (deps_buffer
, deps_stream
);
970 putc ('\n', deps_stream
);
971 if (deps_stream
!= stdout
) {
972 fclose (deps_stream
);
973 if (ferror (deps_stream
))
974 fatal ("I/O error on output");
979 fatal ("I/O error on output");
982 exit (FATAL_EXIT_CODE
);
983 exit (SUCCESS_EXIT_CODE
);
986 pfatal_with_name (in_fname
);
989 /* Move all backslash-newline pairs out of embarrassing places.
990 Exchange all such pairs following BP
991 with any potentially-embarrasing characters that follow them.
992 Potentially-embarrassing characters are / and *
993 (because a backslash-newline inside a comment delimiter
994 would cause it not to be recognized). */
999 register U_CHAR
*p
= bp
;
1000 register int count
= 0;
1002 /* First count the backslash-newline pairs here. */
1004 while (*p
++ == '\\' && *p
++ == '\n')
1009 /* Exit if what follows the backslash-newlines is not embarrassing. */
1011 if (count
== 0 || (*p
!= '/' && *p
!= '*'))
1014 /* Copy all potentially embarrassing characters
1015 that follow the backslash-newline pairs
1016 down to where the pairs originally started. */
1018 while (*p
== '*' || *p
== '/')
1021 /* Now write the same number of pairs after the embarrassing chars. */
1022 while (count
-- > 0) {
1028 /* Like newline_fix but for use within a directive-name.
1029 Move any backslash-newlines up past any following symbol constituents. */
1031 name_newline_fix (bp
)
1034 register U_CHAR
*p
= bp
;
1035 register int count
= 0;
1037 /* First count the backslash-newline pairs here. */
1039 while (*p
++ == '\\' && *p
++ == '\n')
1044 /* What follows the backslash-newlines is not embarrassing. */
1046 if (count
== 0 || !is_idchar (*p
))
1049 /* Copy all potentially embarrassing characters
1050 that follow the backslash-newline pairs
1051 down to where the pairs originally started. */
1053 while (is_idchar (*p
))
1056 /* Now write the same number of pairs after the embarrassing chars. */
1057 while (count
-- > 0) {
1064 * The main loop of the program.
1066 * Read characters from the input stack, transferring them to the
1069 * Macros are expanded and push levels on the input stack.
1070 * At the end of such a level it is popped off and we keep reading.
1071 * At the end of any other kind of level, we return.
1072 * #-directives are handled, except within macros.
1074 * If OUTPUT_MARKS is nonzero, keep Newline markers found in the input
1075 * and insert them when appropriate. This is set while scanning macro
1076 * arguments before substitution. It is zero when scanning for final output.
1077 * There are three types of Newline markers:
1078 * * Newline - follows a macro name that was not expanded
1079 * because it appeared inside an expansion of the same macro.
1080 * This marker prevents future expansion of that identifier.
1081 * When the input is rescanned into the final output, these are deleted.
1082 * These are also deleted by ## concatenation.
1083 * * Newline Space (or Newline and any other whitespace character)
1084 * stands for a place that tokens must be separated or whitespace
1085 * is otherwise desirable, but where the ANSI standard specifies there
1086 * is no whitespace. This marker turns into a Space (or whichever other
1087 * whitespace char appears in the marker) in the final output,
1088 * but it turns into nothing in an argument that is stringified with #.
1089 * Such stringified arguments are the only place where the ANSI standard
1090 * specifies with precision that whitespace may not appear.
1092 * During this function, IP->bufp is kept cached in IBP for speed of access.
1093 * Likewise, OP->bufp is kept in OBP. Before calling a subroutine
1094 * IBP, IP and OBP must be copied back to memory. IP and IBP are
1095 * copied back with the RECACHE macro. OBP must be copied back from OP->bufp
1096 * explicitly, and before RECACHE, since RECACHE uses OBP.
1100 rescan (op
, output_marks
)
1104 /* Character being scanned in main loop. */
1107 /* Length of pending accumulated identifier. */
1108 register int ident_length
= 0;
1110 /* Hash code of pending accumulated identifier. */
1111 register int hash
= 0;
1113 /* Current input level (&instack[indepth]). */
1116 /* Pointer for scanning input. */
1117 register U_CHAR
*ibp
;
1119 /* Pointer to end of input. End of scan is controlled by LIMIT. */
1120 register U_CHAR
*limit
;
1122 /* Pointer for storing output. */
1123 register U_CHAR
*obp
;
1125 /* REDO_CHAR is nonzero if we are processing an identifier
1126 after backing up over the terminating character.
1127 Sometimes we process an identifier without backing up over
1128 the terminating character, if the terminating character
1129 is not special. Backing up is done so that the terminating character
1130 will be dispatched on again once the identifier is dealt with. */
1133 /* 1 if within an identifier inside of which a concatenation
1134 marker (Newline -) has been seen. */
1135 int concatenated
= 0;
1137 /* While scanning a comment or a string constant,
1138 this records the line it started on, for error messages. */
1141 /* Record position of last `real' newline. */
1142 U_CHAR
*beg_of_line
;
1144 /* Pop the innermost input stack level, assuming it is a macro expansion. */
1147 do { ip->macro->type = T_MACRO; \
1148 if (ip->free_ptr) free (ip->free_ptr); \
1149 --indepth; } while (0)
1151 /* Reload `rescan's local variables that describe the current
1152 level of the input stack. */
1155 do { ip = &instack[indepth]; \
1157 limit = ip->buf + ip->length; \
1159 check_expand (op, limit - ibp); \
1161 obp = op->bufp; } while (0)
1163 if (no_output
&& instack
[indepth
].fname
!= 0)
1164 skip_if_group (&instack
[indepth
], 1);
1170 /* Our caller must always put a null after the end of
1171 the input at each input stack level. */
1184 /* Always merge lines ending with backslash-newline,
1185 even in middle of identifier. */
1188 --obp
; /* remove backslash from obuf */
1191 /* Otherwise, backslash suppresses specialness of following char,
1192 so copy it here to prevent the switch from seeing it.
1193 But first get any pending identifier processed. */
1194 if (ident_length
> 0)
1200 /* If this is expanding a macro definition, don't recognize
1201 preprocessor directives. */
1207 /* # keyword: a # must be the first char on the line */
1208 if (beg_of_line
== 0)
1210 if (beg_of_line
+ 1 != ibp
)
1213 /* This # can start a directive. */
1215 --obp
; /* Don't copy the '#' */
1219 if (! handle_directive (ip
, op
)) {
1223 /* Not a known directive: treat it as ordinary text.
1224 IP, OP, IBP, etc. have not been changed. */
1225 if (no_output
&& instack
[indepth
].fname
) {
1226 /* If not generating expanded output,
1227 what we do with ordinary text is skip it.
1228 Discard everything until next # directive. */
1229 skip_if_group (&instack
[indepth
], 1);
1234 ++obp
; /* Copy the '#' after all */
1240 /* A # directive has been successfully processed. */
1241 /* If not generating expanded output, ignore everything until
1242 next # directive. */
1243 if (no_output
&& instack
[indepth
].fname
)
1244 skip_if_group (&instack
[indepth
], 1);
1250 case '\"': /* skip quoted string */
1252 /* A single quoted string is treated like a double -- some
1253 programs (e.g., troff) are perverse this way */
1258 start_line
= ip
->lineno
;
1260 /* Skip ahead to a matching quote. */
1264 if (ip
->macro
!= 0) {
1265 /* try harder: this string crosses a macro expansion boundary */
1277 /* Traditionally, end of line ends a string constant with no error.
1278 So exit the loop and record the new line. */
1286 /* Backslash newline is replaced by nothing at all,
1287 but keep the line counts correct. */
1292 /* ANSI stupidly requires that in \\ the second \
1293 is *not* prevented from combining with a newline. */
1294 while (*ibp
== '\\' && ibp
[1] == '\n') {
1313 if (*ibp
== '\\' && ibp
[1] == '\n')
1315 /* Don't look for comments inside a macro definition. */
1318 /* A comment constitutes white space, so it can terminate an identifier.
1319 Process the identifier, if any. */
1326 /* We have a comment. Skip it, optionally copying it to output. */
1328 start_line
= ip
->lineno
;
1330 ++ibp
; /* Skip the star. */
1332 /* In K+R C, a comment is equivalent to nothing. Note that we
1333 already output the slash; we might not want it. */
1334 if (! put_out_comments
)
1340 U_CHAR
*before_bp
= ibp
;
1342 while (ibp
< limit
) {
1345 if (warn_comments
&& ibp
< limit
&& *ibp
== '*')
1346 warning("`/*' within comment");
1349 if (*ibp
== '\\' && ibp
[1] == '\n')
1351 if (ibp
>= limit
|| *ibp
== '/')
1356 /* Copy the newline into the output buffer, in order to
1357 avoid the pain of a #line every time a multiline comment
1359 if (!put_out_comments
)
1367 error_with_line (line_for_error (start_line
),
1368 "unterminated comment");
1371 if (put_out_comments
) {
1372 memcpy (obp
, before_bp
, ibp
- before_bp
);
1373 obp
+= ibp
- before_bp
;
1379 case '0': case '1': case '2': case '3': case '4':
1380 case '5': case '6': case '7': case '8': case '9':
1381 /* If digit is not part of identifier, it starts a number,
1382 which means that following letters are not an identifier.
1383 "0x5" does not refer to an identifier "x5".
1384 So copy all alphanumerics that follow without accumulating
1385 as an identifier. Periods also, for sake of "3.e7". */
1387 if (ident_length
== 0) {
1388 while (ibp
< limit
) {
1389 while (ibp
< limit
&& ibp
[0] == '\\' && ibp
[1] == '\n') {
1394 if (!ISALNUM (c
) && c
!= '.' && c
!= '_') {
1399 /* A sign can be part of a preprocessing number
1400 if it follows an e. */
1401 if (c
== 'e' || c
== 'E') {
1402 while (ibp
< limit
&& ibp
[0] == '\\' && ibp
[1] == '\n') {
1406 if (ibp
< limit
&& (*ibp
== '+' || *ibp
== '-')) {
1408 /* Traditional C does not let the token go past the sign. */
1418 case 'a': case 'b': case 'c': case 'd': case 'e': case 'f':
1419 case 'g': case 'h': case 'i': case 'j': case 'k': case 'l':
1420 case 'm': case 'n': case 'o': case 'p': case 'q': case 'r':
1421 case 's': case 't': case 'u': case 'v': case 'w': case 'x':
1423 case 'A': case 'B': case 'C': case 'D': case 'E': case 'F':
1424 case 'G': case 'H': case 'I': case 'J': case 'K': case 'L':
1425 case 'M': case 'N': case 'O': case 'P': case 'Q': case 'R':
1426 case 'S': case 'T': case 'U': case 'V': case 'W': case 'X':
1429 /* Compute step of hash function, to avoid a proc call on every token */
1430 hash
= HASHSTEP (hash
, c
);
1434 /* If reprocessing a macro expansion, newline is a special marker. */
1435 if (ip
->macro
!= 0) {
1436 /* Newline White is a "funny space" to separate tokens that are
1437 supposed to be separate but without space between.
1438 Here White means any horizontal whitespace character.
1439 Newline - marks a recursive macro use that is not
1440 supposed to be expandable. */
1443 /* Newline - inhibits expansion of preceding token.
1444 If expanding a macro arg, we keep the newline -.
1445 In final output, it is deleted. */
1446 if (! concatenated
) {
1451 if (!output_marks
) {
1454 /* If expanding a macro arg, keep the newline -. */
1457 } else if (is_space (*ibp
)) {
1458 /* Newline Space does not prevent expansion of preceding token
1459 so expand the preceding token and then come back. */
1460 if (ident_length
> 0)
1463 /* If generating final output, newline space makes a space. */
1464 if (!output_marks
) {
1466 /* And Newline Newline makes a newline, so count it. */
1467 if (obp
[-1] == '\n')
1470 /* If expanding a macro arg, keep the newline space.
1471 If the arg gets stringified, newline space makes nothing. */
1474 } else abort (); /* Newline followed by something random? */
1478 /* If there is a pending identifier, handle it and come back here. */
1479 if (ident_length
> 0)
1484 /* Update the line counts and output a #line if necessary. */
1487 if (ip
->lineno
!= op
->lineno
) {
1489 output_line_command (ip
, op
, 1, same_file
);
1490 check_expand (op
, ip
->length
- (ip
->bufp
- ip
->buf
));
1495 /* Come here either after (1) a null character that is part of the input
1496 or (2) at the end of the input, because there is a null there. */
1499 /* Our input really contains a null character. */
1502 /* At end of a macro-expansion level, pop it and read next level. */
1503 if (ip
->macro
!= 0) {
1506 /* If we have an identifier that ends here, process it now, so
1507 we get the right error for recursion. */
1508 if (ident_length
&& ! is_idchar (*instack
[indepth
- 1].bufp
)) {
1517 /* If we don't have a pending identifier,
1518 return at end of input. */
1519 if (ident_length
== 0) {
1527 /* If we do have a pending identifier, just consider this null
1528 a special character and arrange to dispatch on it again.
1529 The second time, IDENT_LENGTH will be zero so we will return. */
1535 /* Handle the case of a character such as /, ', " or null
1536 seen following an identifier. Back over it so that
1537 after the identifier is processed the special char
1538 will be dispatched on again. */
1548 if (ident_length
> 0) {
1549 register HASHNODE
*hp
;
1551 /* We have just seen an identifier end. If it's a macro, expand it.
1553 IDENT_LENGTH is the length of the identifier
1554 and HASH is its hash code.
1556 The identifier has already been copied to the output,
1557 so if it is a macro we must remove it.
1559 If REDO_CHAR is 0, the char that terminated the identifier
1560 has been skipped in the output and the input.
1561 OBP-IDENT_LENGTH-1 points to the identifier.
1562 If the identifier is a macro, we must back over the terminator.
1564 If REDO_CHAR is 1, the terminating char has already been
1565 backed over. OBP-IDENT_LENGTH points to the identifier. */
1567 for (hp
= hashtab
[MAKE_POS (hash
) % HASHSIZE
]; hp
!= NULL
;
1570 if (hp
->length
== ident_length
) {
1571 U_CHAR
*obufp_before_macroname
;
1572 int op_lineno_before_macroname
;
1573 register int i
= ident_length
;
1574 register U_CHAR
*p
= hp
->name
;
1575 register U_CHAR
*q
= obp
- i
;
1580 do { /* All this to avoid a strncmp () */
1585 /* We found a use of a macro name.
1586 see if the context shows it is a macro call. */
1588 /* Back up over terminating character if not already done. */
1594 obufp_before_macroname
= obp
- ident_length
;
1595 op_lineno_before_macroname
= op
->lineno
;
1597 /* If macro wants an arglist, verify that a '(' follows.
1598 first skip all whitespace, copying it to the output
1599 after the macro name. Then, if there is no '(',
1600 decide this is not a macro call and leave things that way. */
1601 if (hp
->type
== T_MACRO
&& hp
->value
.defn
->nargs
>= 0)
1604 /* Scan forward over whitespace, copying it to the output. */
1605 if (ibp
== limit
&& ip
->macro
!= 0) {
1609 /* A comment: copy it unchanged or discard it. */
1610 else if (*ibp
== '/' && ibp
+1 != limit
&& ibp
[1] == '*') {
1611 if (put_out_comments
) {
1616 while (ibp
+ 1 != limit
1617 && !(ibp
[0] == '*' && ibp
[1] == '/')) {
1618 /* We need not worry about newline-marks,
1619 since they are never found in comments. */
1621 /* Newline in a file. Count it. */
1625 if (put_out_comments
)
1631 if (put_out_comments
) {
1636 else if (is_space (*ibp
)) {
1638 if (ibp
[-1] == '\n') {
1639 if (ip
->macro
== 0) {
1640 /* Newline in a file. Count it. */
1643 } else if (!output_marks
) {
1644 /* A newline mark, and we don't want marks
1645 in the output. If it is newline-hyphen,
1646 discard it entirely. Otherwise, it is
1647 newline-whitechar, so keep the whitechar. */
1657 /* A newline mark; copy both chars to the output. */
1668 /* This is now known to be a macro call.
1669 Discard the macro name from the output,
1670 along with any following whitespace just copied. */
1671 obp
= obufp_before_macroname
;
1672 op
->lineno
= op_lineno_before_macroname
;
1674 /* Expand the macro, reading arguments as needed,
1675 and push the expansion on the input stack. */
1678 macroexpand (hp
, op
);
1680 /* Reexamine input stack, since macroexpand has pushed
1681 a new level on it. */
1688 } /* End hash-table-search loop */
1689 ident_length
= hash
= 0; /* Stop collecting identifier */
1692 } /* End if (ident_length > 0) */
1694 } /* End per-char loop */
1696 /* Come here to return -- but first give an error message
1697 if there was an unterminated successful conditional. */
1699 if (if_stack
!= ip
->if_stack
) {
1701 switch (if_stack
->type
) {
1720 error_with_line (line_for_error (if_stack
->lineno
),
1721 "unterminated #%s conditional", str
);
1723 if_stack
= ip
->if_stack
;
1727 * Rescan a string into a temporary buffer and return the result
1728 * as a FILE_BUF. Note this function returns a struct, not a pointer.
1730 * OUTPUT_MARKS nonzero means keep Newline markers found in the input
1731 * and insert such markers when appropriate. See `rescan' for details.
1732 * OUTPUT_MARKS is 1 for macroexpanding a macro argument separately
1733 * before substitution; it is 0 for other uses.
1736 expand_to_temp_buffer (buf
, limit
, output_marks
)
1737 const U_CHAR
*buf
, *limit
;
1740 register FILE_BUF
*ip
;
1742 int length
= limit
- buf
;
1744 int odepth
= indepth
;
1749 /* Set up the input on the input stack. */
1751 buf1
= (U_CHAR
*) alloca (length
+ 1);
1753 register const U_CHAR
*p1
= buf
;
1754 register U_CHAR
*p2
= buf1
;
1761 /* Set up to receive the output. */
1763 obuf
.length
= length
* 2 + 100; /* Usually enough. Why be stingy? */
1764 obuf
.bufp
= obuf
.buf
= (U_CHAR
*) xmalloc (obuf
.length
);
1769 CHECK_DEPTH ({return obuf
;});
1773 ip
= &instack
[indepth
];
1777 ip
->length
= length
;
1778 ip
->buf
= ip
->bufp
= buf1
;
1779 ip
->if_stack
= if_stack
;
1781 ip
->lineno
= obuf
.lineno
= 1;
1783 /* Scan the input, create the output. */
1785 rescan (&obuf
, output_marks
);
1787 /* Pop input stack to original state. */
1790 if (indepth
!= odepth
)
1793 /* Record the output. */
1794 obuf
.length
= obuf
.bufp
- obuf
.buf
;
1800 * Process a # directive. Expects IP->bufp to point to the '#', as in
1801 * `#define foo bar'. Passes to the command handler
1802 * (do_define, do_include, etc.): the addresses of the 1st and
1803 * last chars of the command (starting immediately after the #
1804 * keyword), plus op and the keyword table pointer. If the command
1805 * contains comments it is copied into a temporary buffer sans comments
1806 * and the temporary buffer is passed to the command handler instead.
1807 * Likewise for backslash-newlines.
1809 * Returns nonzero if this was a known # directive.
1810 * Otherwise, returns zero, without advancing the input pointer.
1814 handle_directive (ip
, op
)
1817 register U_CHAR
*bp
, *cp
;
1818 register struct directive
*kt
;
1819 register int ident_length
;
1822 /* Nonzero means we must copy the entire command
1823 to get rid of comments or backslash-newlines. */
1824 int copy_command
= 0;
1826 U_CHAR
*ident
, *after_ident
;
1829 /* Skip whitespace and \-newline. */
1831 if (is_nvspace (*bp
))
1833 else if (*bp
== '/' && (newline_fix (bp
+ 1), bp
[1]) == '*') {
1835 skip_to_end_of_comment (ip
, &ip
->lineno
);
1837 } else if (*bp
== '\\' && bp
[1] == '\n') {
1838 bp
+= 2; ip
->lineno
++;
1842 /* Now find end of directive name.
1843 If we encounter a backslash-newline, exchange it with any following
1844 symbol-constituents so that we end up with a contiguous name. */
1848 if (is_idchar (*cp
))
1851 if (*cp
== '\\' && cp
[1] == '\n')
1852 name_newline_fix (cp
);
1853 if (is_idchar (*cp
))
1858 ident_length
= cp
- bp
;
1862 /* A line of just `#' becomes blank. */
1864 if (ident_length
== 0 && *after_ident
== '\n') {
1865 ip
->bufp
= after_ident
;
1870 * Decode the keyword and call the appropriate expansion
1871 * routine, after moving the input pointer up to the next line.
1873 for (kt
= directive_table
; kt
->length
> 0; kt
++) {
1874 if (kt
->length
== ident_length
1875 && !strncmp (kt
->name
, (const char *)ident
, ident_length
)) {
1876 register U_CHAR
*buf
;
1877 register U_CHAR
*limit
= ip
->buf
+ ip
->length
;
1878 int unterminated
= 0;
1880 /* Nonzero means do not delete comments within the directive.
1881 #define needs this to detect traditional token paste. */
1882 int keep_comments
= kt
->type
== T_DEFINE
;
1884 /* Find the end of this command (first newline not backslashed
1885 and not in a string or comment).
1886 Set COPY_COMMAND if the command must be copied
1887 (it contains a backslash-newline or a comment). */
1889 buf
= bp
= after_ident
;
1890 while (bp
< limit
) {
1891 register U_CHAR c
= *bp
++;
1905 bp
= skip_quoted_string (bp
- 1, limit
, ip
->lineno
, &ip
->lineno
, ©_command
, &unterminated
);
1907 /* Traditional preprocessing permits unterminated strings. */
1913 /* <...> is special for #include. */
1915 if (kt
->type
!= T_INCLUDE
)
1917 while (*bp
&& *bp
!= '>') bp
++;
1921 if (*bp
== '\\' && bp
[1] == '\n')
1924 U_CHAR
*obp
= bp
- 1;
1926 skip_to_end_of_comment (ip
, &ip
->lineno
);
1928 /* No need to copy the command because of a comment at the end;
1929 just don't include the comment in the directive. */
1930 if (bp
== limit
|| *bp
== '\n') {
1934 /* Don't remove the comments if this is #define. */
1935 if (! keep_comments
)
1941 --bp
; /* Point to the newline */
1949 resume_p
= ip
->bufp
;
1950 /* BP is the end of the directive.
1951 RESUME_P is the next interesting data after the directive.
1952 A comment may come between. */
1955 register U_CHAR
*xp
= buf
;
1956 /* Need to copy entire command into temp buffer before dispatching */
1958 cp
= (U_CHAR
*) alloca (bp
- buf
+ 5); /* room for cmd plus
1962 /* Copy to the new buffer, deleting comments
1963 and backslash-newlines (and whitespace surrounding the latter). */
1966 register U_CHAR c
= *xp
++;
1973 /* <...> is special for #include. */
1975 if (kt
->type
!= T_INCLUDE
)
1977 while (xp
< bp
&& c
!= '>') {
1979 if (c
== '\\' && xp
< bp
&& *xp
== '\n')
1990 if (cp
!= buf
&& is_space (cp
[-1])) {
1991 while (cp
!= buf
&& is_space(cp
[-1])) cp
--;
1993 SKIP_WHITE_SPACE (xp
);
1994 } else if (is_space (*xp
)) {
1996 SKIP_WHITE_SPACE (xp
);
2006 register const U_CHAR
*bp1
2007 = skip_quoted_string (xp
- 1, limit
, ip
->lineno
, 0, 0, 0);
2016 skip_to_end_of_comment (ip
, 0);
2018 while (xp
!= ip
->bufp
)
2020 /* Delete the slash. */
2028 /* Null-terminate the copy. */
2035 ip
->bufp
= resume_p
;
2037 /* Call the appropriate command handler. buf now points to
2038 either the appropriate place in the input buffer, or to
2039 the temp buffer if it was necessary to make one. cp
2040 points to the first char after the contents of the (possibly
2041 copied) command, in either case. */
2042 (*kt
->func
) (buf
, cp
, op
);
2043 check_expand (op
, ip
->length
- (ip
->bufp
- ip
->buf
));
2052 static const char *const
2053 monthnames
[] = {"Jan", "Feb", "Mar", "Apr", "May", "Jun",
2054 "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"};
2057 * expand things like __FILE__. Place the expansion into the output
2058 * buffer *without* rescanning.
2061 special_symbol (hp
, op
)
2069 FILE_BUF
*ip
= NULL
;
2070 static struct tm
*timebuf
= NULL
;
2072 int paren
= 0; /* For special `defined' keyword */
2074 for (i
= indepth
; i
>= 0; i
--)
2075 if (instack
[i
].fname
!= NULL
) {
2080 fatal ("not in any file?!");
2087 if (hp
->type
== T_FILE
)
2090 string
= instack
[0].fname
;
2094 char *tmp
= (char *) alloca (3 + strlen (string
));
2095 sprintf (tmp
, "\"%s\"", string
);
2104 case T_INCLUDE_LEVEL
:
2106 char *tmp
= (char *) alloca (8); /* Eigth bytes ought to be more than enough */
2108 for (i
= indepth
; i
>= 0; i
--)
2109 if (instack
[i
].fname
!= NULL
)
2112 sprintf (tmp
, "%d", true_indepth
- 1);
2119 char *tmp
= (char *) alloca (3 + strlen (version_string
));
2120 sprintf (tmp
, "\"%s\"", version_string
);
2126 buf
= hp
->value
.cpval
;
2131 char *tmp
= (char *) alloca (10);
2132 sprintf (tmp
, "%d", ip
->lineno
);
2140 char *tmp
= (char *) alloca (20);
2142 if (timebuf
== NULL
) {
2144 timebuf
= localtime (&t
);
2146 if (hp
->type
== T_DATE
)
2147 sprintf (tmp
, "\"%s %2d %4d\"", monthnames
[timebuf
->tm_mon
],
2148 timebuf
->tm_mday
, timebuf
->tm_year
+ 1900);
2150 sprintf (tmp
, "\"%02d:%02d:%02d\"", timebuf
->tm_hour
, timebuf
->tm_min
,
2156 case T_SPEC_DEFINED
:
2157 buf
= " 0 "; /* Assume symbol is not defined */
2158 ip
= &instack
[indepth
];
2159 SKIP_WHITE_SPACE (ip
->bufp
);
2160 if (*ip
->bufp
== '(') {
2162 ip
->bufp
++; /* Skip over the paren */
2163 SKIP_WHITE_SPACE (ip
->bufp
);
2166 if (!is_idstart (*ip
->bufp
))
2169 HASHNODE
*hp
= lookup (ip
->bufp
, -1, -1);
2171 if (hp
&& hp
->type
!= T_UNUSED
&& hp
->type
!= T_SPEC_DEFINED
)
2174 while (is_idchar (*ip
->bufp
))
2176 SKIP_WHITE_SPACE (ip
->bufp
);
2178 if (*ip
->bufp
!= ')')
2186 error ("`defined' must be followed by ident or (ident)");
2190 error ("cccp error: invalid special hash type"); /* time for gdb */
2194 check_expand (op
, len
);
2195 memcpy (op
->bufp
, buf
, len
);
2200 /* Routines to handle #directives */
2203 * Process include file by reading it in and calling rescan.
2204 * Expects to see "fname" or <fname> on the input.
2207 do_include (buf
, limit
, op
)
2208 U_CHAR
*buf
, *limit
;
2211 char *fname
; /* Dynamically allocated fname buffer */
2212 U_CHAR
*fbeg
, *fend
; /* Beginning and end of fname */
2214 struct file_name_list
*stackp
= include
; /* Chain of dirs to search */
2215 struct file_name_list dsp
[1]; /* First in chain, if #include "..." */
2218 int f
; /* file number */
2220 int retried
= 0; /* Have already tried macro
2221 expanding the include line*/
2222 FILE_BUF trybuf
; /* It got expanded into here */
2223 int system_header_p
= 0; /* 0 for "...", 1 for <...> */
2225 f
= -1; /* JF we iz paranoid! */
2230 SKIP_WHITE_SPACE (fbeg
);
2231 /* Discard trailing whitespace so we can easily see
2232 if we have parsed all the significant chars we were given. */
2233 while (limit
!= fbeg
&& is_nvspace (limit
[-1])) limit
--;
2238 while (fend
!= limit
&& *fend
!= '\"')
2240 if (*fend
== '\"' && fend
+ 1 == limit
) {
2243 /* We have "filename". Figure out directory this source
2244 file is coming from and put it on the front of the list. */
2246 /* If -I- was specified, don't search current dir, only spec'd ones. */
2247 if (ignore_srcdir
) break;
2249 for (fp
= &instack
[indepth
]; fp
>= instack
; fp
--)
2252 const char *ep
, *nam
;
2254 if ((nam
= fp
->fname
) != NULL
) {
2255 /* Found a named file. Figure out dir of the file,
2256 and put it in front of the search list. */
2257 dsp
[0].next
= stackp
;
2259 ep
= strrchr (nam
, '/');
2263 f
= (char *) alloca (n
+ 1);
2264 strncpy (f
, nam
, n
);
2267 if (n
> max_include_len
) max_include_len
= n
;
2269 dsp
[0].fname
= 0; /* Current directory */
2280 while (fend
!= limit
&& *fend
!= '>') fend
++;
2281 if (*fend
== '>' && fend
+ 1 == limit
) {
2282 system_header_p
= 1;
2283 /* If -I-, start with the first -I dir after the -I-. */
2284 if (first_bracket_include
)
2285 stackp
= first_bracket_include
;
2293 error ("#include expects \"fname\" or <fname>");
2296 trybuf
= expand_to_temp_buffer (buf
, limit
, 0);
2297 buf
= (U_CHAR
*) alloca (trybuf
.bufp
- trybuf
.buf
+ 1);
2298 memcpy (buf
, trybuf
.buf
, trybuf
.bufp
- trybuf
.buf
);
2299 limit
= buf
+ (trybuf
.bufp
- trybuf
.buf
);
2307 fname
= (char *) alloca (max_include_len
+ flen
+ 2);
2308 /* + 2 above for slash and terminating null. */
2310 /* If specified file name is absolute, just open it. */
2313 strncpy (fname
, (const char *)fbeg
, flen
);
2315 f
= open (fname
, O_RDONLY
, 0666);
2317 /* Search directory path, trying to open the file.
2318 Copy each filename tried into FNAME. */
2320 for (; stackp
; stackp
= stackp
->next
) {
2321 if (stackp
->fname
) {
2322 strcpy (fname
, stackp
->fname
);
2323 strcat (fname
, "/");
2324 fname
[strlen (fname
) + flen
] = 0;
2328 strncat (fname
, (const char *)fbeg
, flen
);
2329 if ((f
= open (fname
, O_RDONLY
, 0666)) >= 0)
2335 strncpy (fname
, (const char *)fbeg
, flen
);
2337 error_from_errno (fname
);
2339 /* For -M, add this file to the dependencies. */
2340 if (print_deps
> (system_header_p
|| (system_include_depth
> 0))) {
2341 if (system_header_p
)
2342 warning ("nonexistent file <%.*s> omitted from dependency output",
2346 deps_output ((const char *)fbeg
, flen
);
2347 deps_output (" ", 0);
2352 /* Check to see if this include file is a once-only include file.
2355 struct file_name_list
* ptr
;
2357 for (ptr
= dont_repeat_files
; ptr
; ptr
= ptr
->next
) {
2358 if (!strcmp (ptr
->fname
, fname
)) {
2360 return; /* This file was once'd. */
2364 for (ptr
= all_include_files
; ptr
; ptr
= ptr
->next
) {
2365 if (!strcmp (ptr
->fname
, fname
))
2366 break; /* This file was included before. */
2370 /* This is the first time for this file. */
2371 /* Add it to list of files included. */
2373 ptr
= (struct file_name_list
*) xmalloc (sizeof (struct file_name_list
));
2374 ptr
->next
= all_include_files
;
2375 all_include_files
= ptr
;
2376 ptr
->fname
= xstrdup (fname
);
2378 /* For -M, add this file to the dependencies. */
2379 if (print_deps
> (system_header_p
|| (system_include_depth
> 0))) {
2380 deps_output (fname
, strlen (fname
));
2381 deps_output (" ", 0);
2385 if (system_header_p
)
2386 system_include_depth
++;
2388 /* Actually process the file. */
2389 finclude (f
, fname
, op
);
2391 if (system_header_p
)
2392 system_include_depth
--;
2398 /* Process the contents of include file FNAME, already open on descriptor F,
2399 with output to OP. */
2402 finclude (f
, fname
, op
)
2410 FILE_BUF
*fp
; /* For input stack frame */
2412 CHECK_DEPTH (return;);
2414 if (file_size_and_mode (f
, &st_mode
, &st_size
))
2417 fp
= &instack
[indepth
+ 1];
2418 memset (fp
, 0, sizeof (FILE_BUF
));
2422 fp
->if_stack
= if_stack
;
2424 if (S_ISREG (st_mode
)) {
2425 fp
->buf
= (U_CHAR
*) xmalloc (st_size
+ 2);
2428 /* Read the file contents, knowing that st_size is an upper bound
2429 on the number of bytes we can read. */
2430 while (st_size
> 0) {
2431 i
= read (f
, fp
->buf
+ fp
->length
, st_size
);
2441 /* Cannot count its file size before reading. */
2448 basep
= (U_CHAR
*) xmalloc (bsize
+ 2);
2452 i
= read (f
, bufp
, bsize
- st_size
);
2454 goto nope
; /* error! */
2456 break; /* End of file */
2459 if (bsize
== st_size
) { /* Buffer is full! */
2461 basep
= (U_CHAR
*) xrealloc (basep
, bsize
+ 2);
2462 bufp
= basep
+ st_size
; /* May have moved */
2467 fp
->length
= st_size
;
2471 /* Make sure data ends with a newline. And put a null after it. */
2473 if (fp
->length
> 0 && fp
->buf
[fp
->length
-1] != '\n')
2474 fp
->buf
[fp
->length
++] = '\n';
2475 fp
->buf
[fp
->length
] = '\0';
2478 output_line_command (fp
, op
, 0, enter_file
);
2481 instack
[indepth
].lineno
++;
2482 instack
[indepth
].bufp
++; /* Skip the new line. */
2483 output_line_command (&instack
[indepth
], op
, 0, leave_file
);
2488 perror_with_name (fname
);
2493 /* Process a #define command.
2494 BUF points to the contents of the #define command, as a continguous string.
2495 LIMIT points to the first character past the end of the definition.
2496 KEYWORD is the keyword-table entry for #define. */
2499 do_define (buf
, limit
, op
)
2500 U_CHAR
*buf
, *limit
;
2501 FILE_BUF
*op ATTRIBUTE_UNUSED
;
2503 U_CHAR
*bp
; /* temp ptr into input buffer */
2504 U_CHAR
*symname
; /* remember where symbol name starts */
2505 int sym_length
; /* and how long it is */
2508 int arglengths
= 0; /* Accumulate lengths of arg names
2509 plus number of args. */
2514 while (is_nvspace (*bp
))
2517 symname
= bp
; /* remember where it starts */
2518 while (is_idchar (*bp
) && bp
< limit
) {
2521 sym_length
= bp
- symname
;
2522 if (sym_length
== 0)
2524 error ("invalid macro name");
2527 else if (!is_idstart (*symname
)) {
2528 U_CHAR
*msg
; /* what pain... */
2529 msg
= (U_CHAR
*) alloca (sym_length
+ 1);
2530 memcpy (msg
, symname
, sym_length
);
2531 msg
[sym_length
] = 0;
2532 error ("invalid macro name `%s'", msg
);
2535 if (! strncmp ((const char *)symname
, "defined", 7) && sym_length
== 7)
2537 error ("\"defined\" cannot be used as a macro name");
2542 /* lossage will occur if identifiers or control keywords are broken
2543 across lines using backslash. This is not the right place to take
2547 struct arglist
*arg_ptrs
= NULL
;
2550 bp
++; /* skip '(' */
2551 SKIP_WHITE_SPACE (bp
);
2553 /* Loop over macro argument names. */
2554 while (*bp
!= ')') {
2555 struct arglist
*temp
;
2557 temp
= (struct arglist
*) alloca (sizeof (struct arglist
));
2559 temp
->next
= arg_ptrs
;
2560 temp
->argno
= argno
++;
2563 if (!is_idstart (*bp
))
2564 warning ("parameter name starts with a digit in #define");
2566 /* Find the end of the arg name. */
2567 while (is_idchar (*bp
)) {
2570 temp
->length
= bp
- temp
->name
;
2571 arglengths
+= temp
->length
+ 2;
2572 SKIP_WHITE_SPACE (bp
);
2573 if (temp
->length
== 0 || (*bp
!= ',' && *bp
!= ')')) {
2574 error ("badly punctuated parameter list in #define");
2579 SKIP_WHITE_SPACE (bp
);
2582 error ("unterminated parameter list in #define");
2587 ++bp
; /* skip paren */
2588 while (is_nvspace (*bp
)) /* and leading whitespace */
2590 /* now everything from bp before limit is the definition. */
2591 defn
= collect_expansion (bp
, limit
, argno
, arg_ptrs
);
2593 /* Now set defn->argnames to the result of concatenating
2594 the argument names in reverse order
2595 with comma-space between them. */
2597 struct arglist
*temp
;
2599 U_CHAR
*tmp
= (U_CHAR
*) xmalloc (arglengths
+ 1);
2601 for (temp
= arg_ptrs
; temp
; temp
= temp
->next
) {
2602 memcpy (&tmp
[i
], temp
->name
, temp
->length
);
2604 if (temp
->next
!= 0) {
2610 defn
->argnames
= tmp
;
2614 /* simple expansion or empty definition; skip leading whitespace */
2615 while (is_nvspace (*bp
))
2617 /* now everything from bp before limit is the definition. */
2618 defn
= collect_expansion (bp
, limit
, -1, 0);
2619 defn
->argnames
= (const U_CHAR
*) "";
2622 hashcode
= hashf (symname
, sym_length
, HASHSIZE
);
2626 if ((hp
= lookup (symname
, sym_length
, hashcode
)) == NULL
)
2627 hp
= install (symname
, sym_length
, T_MACRO
, hashcode
);
2629 if (hp
->type
!= T_MACRO
|| compare_defs (defn
, hp
->value
.defn
))
2630 warning ("\"%.*s\" redefined", sym_length
, symname
);
2632 /* Replace the old definition. */
2636 hp
->value
.defn
= defn
;
2641 * return zero if two DEFINITIONs are isomorphic
2644 compare_defs (d1
, d2
)
2645 DEFINITION
*d1
, *d2
;
2647 register struct reflist
*a1
, *a2
;
2648 register U_CHAR
*p1
= d1
->expansion
;
2649 register U_CHAR
*p2
= d2
->expansion
;
2652 if (d1
->nargs
!= d2
->nargs
)
2654 if (strcmp ((const char *)d1
->argnames
, (const char *)d2
->argnames
))
2656 for (a1
= d1
->pattern
, a2
= d2
->pattern
; a1
&& a2
;
2657 a1
= a1
->next
, a2
= a2
->next
) {
2658 if (!((a1
->nchars
== a2
->nchars
2659 && ! strncmp ((const char *)p1
, (const char *)p2
, a1
->nchars
))
2660 || ! comp_def_part (first
, p1
, a1
->nchars
, p2
, a2
->nchars
, 0))
2661 || a1
->argno
!= a2
->argno
2662 || a1
->stringify
!= a2
->stringify
2663 || a1
->raw_before
!= a2
->raw_before
2664 || a1
->raw_after
!= a2
->raw_after
)
2672 if (comp_def_part (first
, p1
, d1
->length
- (p1
- d1
->expansion
),
2673 p2
, d2
->length
- (p2
- d2
->expansion
), 1))
2678 /* Return 1 if two parts of two macro definitions are effectively different.
2679 One of the parts starts at BEG1 and has LEN1 chars;
2680 the other has LEN2 chars at BEG2.
2681 Any sequence of whitespace matches any other sequence of whitespace.
2682 FIRST means these parts are the first of a macro definition;
2683 so ignore leading whitespace entirely.
2684 LAST means these parts are the last of a macro definition;
2685 so ignore trailing whitespace entirely. */
2687 comp_def_part (first
, beg1
, len1
, beg2
, len2
, last
)
2689 const U_CHAR
*beg1
, *beg2
;
2693 register const U_CHAR
*end1
= beg1
+ len1
;
2694 register const U_CHAR
*end2
= beg2
+ len2
;
2696 while (beg1
!= end1
&& is_space (*beg1
)) beg1
++;
2697 while (beg2
!= end2
&& is_space (*beg2
)) beg2
++;
2700 while (beg1
!= end1
&& is_space (end1
[-1])) end1
--;
2701 while (beg2
!= end2
&& is_space (end2
[-1])) end2
--;
2703 while (beg1
!= end1
&& beg2
!= end2
) {
2704 if (is_space (*beg1
) && is_space (*beg2
)) {
2705 while (beg1
!= end1
&& is_space (*beg1
)) beg1
++;
2706 while (beg2
!= end2
&& is_space (*beg2
)) beg2
++;
2707 } else if (*beg1
== *beg2
) {
2711 return (beg1
!= end1
) || (beg2
!= end2
);
2714 /* Read a replacement list for a macro with parameters.
2715 Build the DEFINITION structure.
2716 Reads characters of text starting at BUF until LIMIT.
2717 ARGLIST specifies the formal parameters to look for
2718 in the text of the definition; NARGS is the number of args
2719 in that list, or -1 for a macro name that wants no argument list.
2720 MACRONAME is the macro name itself (so we can avoid recursive expansion)
2721 and NAMELEN is its length in characters.
2723 Note that comments and backslash-newlines have already been deleted
2724 from the argument. */
2726 /* Leading and trailing Space, Tab, etc. are converted to markers
2727 Newline Space, Newline Tab, etc.
2728 Newline Space makes a space in the final output
2729 but is discarded if stringified. (Newline Tab is similar but
2730 makes a Tab instead.)
2732 If there is no trailing whitespace, a Newline Space is added at the end
2733 to prevent concatenation that would be contrary to the standard. */
2736 collect_expansion (buf
, end
, nargs
, arglist
)
2739 struct arglist
*arglist
;
2742 register U_CHAR
*p
, *limit
, *lastp
, *exp_p
;
2743 struct reflist
*endpat
= NULL
;
2744 /* Pointer to first nonspace after last ## seen. */
2746 /* Pointer to first nonspace after last single-# seen. */
2747 U_CHAR
*stringify
= 0;
2749 int expected_delimiter
= '\0';
2751 /* Scan thru the replacement list, ignoring comments and quoted
2752 strings, picking up on the macro calls. It does a linear search
2753 thru the arg list on every potential symbol. Profiling might say
2754 that something smarter should happen. */
2759 /* Find the beginning of the trailing whitespace. */
2760 /* Find end of leading whitespace. */
2763 while (p
< limit
&& is_space (limit
[-1])) limit
--;
2764 while (p
< limit
&& is_space (*p
)) p
++;
2766 /* Allocate space for the text in the macro definition.
2767 Leading and trailing whitespace chars need 2 bytes each.
2768 Each other input char may or may not need 1 byte,
2769 so this is an upper bound.
2770 The extra 2 are for invented trailing newline-marker and final null. */
2771 maxsize
= (sizeof (DEFINITION
)
2772 + 2 * (end
- limit
) + 2 * (p
- buf
)
2774 defn
= (DEFINITION
*) xcalloc (1, maxsize
);
2776 defn
->nargs
= nargs
;
2777 exp_p
= defn
->expansion
= (U_CHAR
*) defn
+ sizeof (DEFINITION
);
2782 /* Convert leading whitespace to Newline-markers. */
2783 while (p
< limit
&& is_space (*p
)) {
2788 /* Process the main body of the definition. */
2790 int skipped_arg
= 0;
2791 register U_CHAR c
= *p
++;
2795 /* In -traditional mode, recognize arguments inside strings and
2796 and character constants, and ignore special properties of #.
2797 Arguments inside strings are considered "stringified", but no
2798 extra quote marks are supplied. */
2802 if (expected_delimiter
!= '\0') {
2803 if (c
== expected_delimiter
)
2804 expected_delimiter
= '\0';
2806 expected_delimiter
= c
;
2810 /* Backslash quotes delimiters and itself, but not macro args. */
2811 if (expected_delimiter
!= 0 && p
< limit
2812 && (*p
== expected_delimiter
|| *p
== '\\')) {
2819 if (expected_delimiter
!= '\0') /* No comments inside strings. */
2822 /* If we find a comment that wasn't removed by handle_directive,
2823 this must be -traditional. So replace the comment with
2827 while (p
< limit
&& !(p
[-2] == '*' && p
[-1] == '/'))
2833 if (is_idchar (c
) && nargs
> 0) {
2834 U_CHAR
*id_beg
= p
- 1;
2838 while (p
!= limit
&& is_idchar (*p
)) p
++;
2839 id_len
= p
- id_beg
;
2841 if (is_idstart (c
)) {
2842 register struct arglist
*arg
;
2844 for (arg
= arglist
; arg
!= NULL
; arg
= arg
->next
) {
2845 struct reflist
*tpat
;
2847 if (arg
->name
[0] == c
2848 && arg
->length
== id_len
2849 && strncmp ((const char *)arg
->name
,
2850 (const char *)id_beg
, id_len
) == 0) {
2851 /* make a pat node for this arg and append it to the end of
2853 tpat
= (struct reflist
*) xmalloc (sizeof (struct reflist
));
2855 tpat
->raw_before
= concat
== id_beg
;
2856 tpat
->raw_after
= 0;
2857 tpat
->stringify
= expected_delimiter
!= '\0';
2860 defn
->pattern
= tpat
;
2862 endpat
->next
= tpat
;
2865 tpat
->argno
= arg
->argno
;
2866 tpat
->nchars
= exp_p
- lastp
;
2868 register U_CHAR
*p1
= p
;
2869 SKIP_WHITE_SPACE (p1
);
2870 if (p1
+ 2 <= limit
&& p1
[0] == '#' && p1
[1] == '#')
2871 tpat
->raw_after
= 1;
2873 lastp
= exp_p
; /* place to start copying from next time */
2880 /* If this was not a macro arg, copy it into the expansion. */
2881 if (! skipped_arg
) {
2882 register U_CHAR
*lim1
= p
;
2886 if (stringify
== id_beg
)
2887 error ("# operator should be followed by a macro argument name");
2893 /* Convert trailing whitespace to Newline-markers. */
2894 while (limit
< end
&& is_space (*limit
)) {
2896 *exp_p
++ = *limit
++;
2901 defn
->length
= exp_p
- defn
->expansion
;
2903 /* Crash now if we overrun the allocated size. */
2904 if (defn
->length
+ 1 > maxsize
)
2911 * interpret #line command. Remembers previously seen fnames
2912 * in its very own hash table.
2914 #define FNAME_HASHSIZE 37
2916 do_line (buf
, limit
, op
)
2917 U_CHAR
*buf
, *limit
;
2920 register U_CHAR
*bp
;
2921 FILE_BUF
*ip
= &instack
[indepth
];
2924 enum file_change_code file_change
= same_file
;
2926 /* Expand any macros. */
2927 tem
= expand_to_temp_buffer (buf
, limit
, 0);
2929 /* Point to macroexpanded line, which is null-terminated now. */
2931 SKIP_WHITE_SPACE (bp
);
2933 if (!ISDIGIT (*bp
)) {
2934 error ("invalid format #line command");
2938 /* The Newline at the end of this line remains to be processed.
2939 To put the next line at the specified line number,
2940 we must store a line number now that is one less. */
2941 new_lineno
= atoi ((const char *)bp
);
2943 /* skip over the line number. */
2944 while (ISDIGIT (*bp
))
2947 SKIP_WHITE_SPACE (bp
);
2950 static HASHNODE
*fname_table
[FNAME_HASHSIZE
];
2951 HASHNODE
*hp
, **hash_bucket
;
2957 while (*bp
&& *bp
!= '\"')
2960 error ("invalid format #line command");
2964 fname_length
= bp
- fname
;
2967 SKIP_WHITE_SPACE (bp
);
2970 file_change
= enter_file
;
2971 else if (*bp
== '2')
2972 file_change
= leave_file
;
2974 error ("invalid format #line command");
2979 SKIP_WHITE_SPACE (bp
);
2981 error ("invalid format #line command");
2987 &fname_table
[hashf (fname
, fname_length
, FNAME_HASHSIZE
)];
2988 for (hp
= *hash_bucket
; hp
!= NULL
; hp
= hp
->next
)
2989 if (hp
->length
== fname_length
&&
2990 strncmp (hp
->value
.cpval
, (const char *)fname
, fname_length
) == 0) {
2991 ip
->fname
= hp
->value
.cpval
;
2996 /* Didn't find it; cons up a new one. */
2997 hp
= (HASHNODE
*) xcalloc (1, sizeof (HASHNODE
) + fname_length
+ 1);
2998 hp
->next
= *hash_bucket
;
3001 hp
->length
= fname_length
;
3002 ip
->fname
= hp
->value
.cpval
= q
= ((char *) hp
) + sizeof (HASHNODE
);
3003 memcpy (q
, fname
, fname_length
);
3006 error ("invalid format #line command");
3010 ip
->lineno
= new_lineno
;
3011 output_line_command (ip
, op
, 0, file_change
);
3012 ip
->bufp
++; /* Skip the new line. */
3013 check_expand (op
, ip
->length
- (ip
->bufp
- ip
->buf
));
3017 * remove all definitions of symbol from symbol table.
3018 * according to un*x /lib/cpp, it is not an error to undef
3019 * something that has no definitions, so it isn't one here either.
3022 do_undef (buf
, limit
, op
)
3024 U_CHAR
*limit ATTRIBUTE_UNUSED
;
3025 FILE_BUF
*op ATTRIBUTE_UNUSED
;
3029 SKIP_WHITE_SPACE (buf
);
3031 if (! strncmp ((const char *)buf
, "defined", 7) && ! is_idchar (buf
[7]))
3032 warning ("undefining `defined'");
3034 while ((hp
= lookup (buf
, -1, -1)) != NULL
) {
3035 if (hp
->type
!= T_MACRO
)
3036 warning ("undefining `%s'", hp
->name
);
3041 /* Read the tokens of the answer into the macro pool. Only commit the
3042 memory if we intend it as permanent storage, i.e. the #assert case.
3043 Returns 0 on success. */
3046 parse_answer (buf
, limit
, answerp
, type
)
3047 const unsigned char *buf
, *limit
;
3048 struct answer
**answerp
;
3051 const unsigned char *start
;
3053 /* Skip leading whitespace. */
3054 if (buf
< limit
&& *buf
== ' ')
3057 /* Parentheses are optional here. */
3058 if (buf
== limit
&& type
== T_UNASSERT
)
3061 if (buf
== limit
|| *buf
++ != '(')
3066 error ("missing '(' after predicate");
3070 /* Drop whitespace at start. */
3071 while (buf
< limit
&& *buf
== ' ')
3075 while (buf
< limit
&& *buf
!= ')')
3080 error ("missing ')' to complete answer");
3086 error ("predicate's answer is empty");
3090 if ((type
== T_ASSERT
|| type
== T_UNASSERT
) && buf
+ 1 != limit
)
3092 error ("extra text at end of directive");
3096 /* Lose trailing whitespace. */
3100 *answerp
= (struct answer
*) xmalloc (sizeof (struct answer
));
3101 (*answerp
)->answer
= start
;
3102 (*answerp
)->len
= buf
- start
;
3107 /* Parses an assertion, returning a pointer to the hash node of the
3108 predicate, or 0 on error. If an answer was supplied, it is placed
3109 in ANSWERP, otherwise it is set to 0. */
3111 parse_assertion (buf
, limit
, answerp
, type
)
3112 const unsigned char *buf
, *limit
;
3113 struct answer
**answerp
;
3116 HASHNODE
*result
= 0;
3117 const unsigned char *climit
;
3118 unsigned char *bp
, *symname
= canonicalize_text (buf
, limit
, &climit
);
3122 if (bp
< climit
&& is_idstart (*bp
))
3126 while (bp
< climit
&& is_idchar (*bp
));
3133 if (symname
== climit
)
3134 error ("assertion without predicate");
3136 error ("predicate must be an identifier");
3138 /* Unfortunately, because of the way we handle #if, we don't avoid
3139 macro expansion in answers. This is not easy to fix. */
3140 else if (parse_answer (bp
, climit
, answerp
, type
) == 0)
3142 unsigned char *sym
= alloca (len
+ 1);
3145 /* Prefix '#' to get it out of macro namespace. */
3147 memcpy (sym
+ 1, symname
, len
);
3149 hashcode
= hashf (sym
, len
+ 1, HASHSIZE
);
3150 result
= lookup (sym
, len
+ 1, hashcode
);
3152 result
= install (sym
, len
+ 1, T_UNUSED
, hashcode
);
3158 /* Test an assertion within a preprocessor conditional. Returns zero
3159 on error or failure, one on success. */
3161 test_assertion (pbuf
)
3162 unsigned char **pbuf
; /* NUL-terminated. */
3164 unsigned char *buf
= *pbuf
;
3165 unsigned char *limit
= buf
+ strlen ((char *) buf
);
3166 struct answer
*answer
;
3170 node
= parse_assertion (buf
, limit
, &answer
, T_IF
);
3173 result
= (node
->type
== T_ASSERT
&&
3174 (answer
== 0 || *find_answer (node
, answer
) != 0));
3176 /* Yuk. We update pbuf to point after the assertion test.
3177 First, move past the identifier. */
3178 if (is_space (*buf
))
3180 while (is_idchar (*buf
))
3182 /* If we have an answer, we need to move past the parentheses. */
3184 while (*buf
++ != ')')
3192 /* Handle a #error directive. */
3194 do_error (buf
, limit
, op
)
3197 FILE_BUF
*op ATTRIBUTE_UNUSED
;
3199 error ("#error%.*s", (int) (limit
- buf
), buf
);
3202 /* Handle a #warning directive. */
3204 do_warning (buf
, limit
, op
)
3207 FILE_BUF
*op ATTRIBUTE_UNUSED
;
3209 warning ("#warning%.*s", (int) (limit
- buf
), buf
);
3212 /* Handle a #assert directive. */
3214 do_assert (buf
, limit
, op
)
3217 FILE_BUF
*op ATTRIBUTE_UNUSED
;
3219 struct answer
*new_answer
;
3222 node
= parse_assertion (buf
, limit
, &new_answer
, T_ASSERT
);
3225 /* Place the new answer in the answer list. First check there
3226 is not a duplicate. */
3227 new_answer
->next
= 0;
3228 if (node
->type
== T_ASSERT
)
3230 if (*find_answer (node
, new_answer
))
3233 warning ("\"%s\" re-asserted", node
->name
+ 1);
3236 new_answer
->next
= node
->value
.answers
;
3238 node
->type
= T_ASSERT
;
3239 node
->value
.answers
= new_answer
;
3243 /* Function body to be provided later. */
3245 do_unassert (buf
, limit
, op
)
3248 FILE_BUF
*op ATTRIBUTE_UNUSED
;
3251 struct answer
*answer
;
3253 node
= parse_assertion (buf
, limit
, &answer
, T_UNASSERT
);
3254 /* It isn't an error to #unassert something that isn't asserted. */
3257 if (node
->type
== T_ASSERT
)
3261 struct answer
**p
= find_answer (node
, answer
), *temp
;
3263 /* Remove the answer from the list. */
3268 /* Did we free the last answer? */
3269 if (node
->value
.answers
== 0)
3270 delete_macro (node
);
3273 delete_macro (node
);
3280 /* Returns a pointer to the pointer to the answer in the answer chain,
3281 or a pointer to NULL if the answer is not in the chain. */
3282 static struct answer
**
3283 find_answer (node
, candidate
)
3285 const struct answer
*candidate
;
3287 struct answer
**result
;
3289 for (result
= &node
->value
.answers
; *result
; result
= &(*result
)->next
)
3291 struct answer
*answer
= *result
;
3293 if (answer
->len
== candidate
->len
3294 && !memcmp (answer
->answer
, candidate
->answer
, answer
->len
))
3301 /* Return a malloced buffer with leading and trailing whitespace
3302 removed, and all instances of internal whitespace reduced to a
3304 static unsigned char *
3305 canonicalize_text (buf
, limit
, climit
)
3306 const unsigned char *buf
, *limit
, **climit
;
3308 unsigned int len
= limit
- buf
;
3309 unsigned char *result
= (unsigned char *) xmalloc (len
), *dest
;
3311 for (dest
= result
; buf
< limit
;)
3313 if (! is_space (*buf
))
3317 while (++buf
< limit
&& is_space (*buf
))
3319 if (dest
!= result
&& buf
!= limit
)
3329 * handle #if command by
3330 * 1) inserting special `defined' keyword into the hash table
3331 * that gets turned into 0 or 1 by special_symbol (thus,
3332 * if the luser has a symbol called `defined' already, it won't
3333 * work inside the #if command)
3334 * 2) rescan the input into a temporary output buffer
3335 * 3) pass the output buffer to the yacc parser and collect a value
3336 * 4) clean up the mess left from steps 1 and 2.
3337 * 5) call conditional_skip to skip til the next #endif (etc.),
3338 * or not, depending on the value from step 3.
3341 do_if (buf
, limit
, op
)
3342 U_CHAR
*buf
, *limit
;
3343 FILE_BUF
*op ATTRIBUTE_UNUSED
;
3346 FILE_BUF
*ip
= &instack
[indepth
];
3348 value
= eval_if_expression (buf
, limit
- buf
);
3349 conditional_skip (ip
, value
== 0, T_IF
);
3353 * handle a #elif directive by not changing if_stack either.
3354 * see the comment above do_else.
3357 do_elif (buf
, limit
, op
)
3358 U_CHAR
*buf
, *limit
;
3362 FILE_BUF
*ip
= &instack
[indepth
];
3364 if (if_stack
== instack
[indepth
].if_stack
) {
3365 error ("#elif not within a conditional");
3368 if (if_stack
->type
!= T_IF
&& if_stack
->type
!= T_ELIF
) {
3369 error ("#elif after #else");
3370 fprintf (stderr
, " (matches line %d", if_stack
->lineno
);
3371 if (if_stack
->fname
!= NULL
&& ip
->fname
!= NULL
&&
3372 strcmp (if_stack
->fname
, ip
->fname
) != 0)
3373 fprintf (stderr
, ", file %s", if_stack
->fname
);
3374 fprintf (stderr
, ")\n");
3376 if_stack
->type
= T_ELIF
;
3379 if (if_stack
->if_succeeded
)
3380 skip_if_group (ip
, 0);
3382 value
= eval_if_expression (buf
, limit
- buf
);
3384 skip_if_group (ip
, 0);
3386 ++if_stack
->if_succeeded
; /* continue processing input */
3387 output_line_command (ip
, op
, 1, same_file
);
3393 * evaluate a #if expression in BUF, of length LENGTH,
3394 * then parse the result as a C expression and return the value as an int.
3397 eval_if_expression (buf
, length
)
3402 HASHNODE
*save_defined
;
3405 save_defined
= install (U
"defined", -1, T_SPEC_DEFINED
, -1);
3406 temp_obuf
= expand_to_temp_buffer (buf
, buf
+ length
, 0);
3407 delete_macro (save_defined
); /* clean up special symbol */
3409 value
= parse_c_expression ((const char *)temp_obuf
.buf
);
3411 free (temp_obuf
.buf
);
3417 * routine to handle ifdef/ifndef. Try to look up the symbol,
3418 * then do or don't skip to the #endif/#else/#elif depending
3419 * on what directive is actually being processed.
3422 do_xifdef (buf
, limit
, type
)
3423 U_CHAR
*buf
, *limit
;
3424 enum node_type type
;
3427 FILE_BUF
*ip
= &instack
[indepth
];
3430 /* Discard leading and trailing whitespace. */
3431 SKIP_WHITE_SPACE (buf
);
3432 while (limit
!= buf
&& is_nvspace (limit
[-1])) limit
--;
3434 /* Find the end of the identifier at the beginning. */
3435 for (end
= buf
; is_idchar (*end
); end
++);
3438 skip
= (type
== T_IFDEF
);
3440 skip
= (lookup (buf
, end
-buf
, -1) == NULL
) ^ (type
== T_IFNDEF
);
3442 conditional_skip (ip
, skip
, T_IF
);
3446 do_ifdef (buf
, limit
, op
)
3447 U_CHAR
*buf
, *limit
;
3448 FILE_BUF
*op ATTRIBUTE_UNUSED
;
3450 do_xifdef (buf
, limit
, T_IFDEF
);
3454 do_ifndef (buf
, limit
, op
)
3455 U_CHAR
*buf
, *limit
;
3456 FILE_BUF
*op ATTRIBUTE_UNUSED
;
3458 do_xifdef (buf
, limit
, T_IFNDEF
);
3462 * push TYPE on stack; then, if SKIP is nonzero, skip ahead.
3465 conditional_skip (ip
, skip
, type
)
3468 enum node_type type
;
3470 IF_STACK_FRAME
*temp
;
3472 temp
= (IF_STACK_FRAME
*) xcalloc (1, sizeof (IF_STACK_FRAME
));
3473 temp
->fname
= ip
->fname
;
3474 temp
->lineno
= ip
->lineno
;
3475 temp
->next
= if_stack
;
3478 if_stack
->type
= type
;
3481 skip_if_group (ip
, 0);
3484 ++if_stack
->if_succeeded
;
3485 output_line_command (ip
, &outbuf
, 1, same_file
);
3490 * skip to #endif, #else, or #elif. adjust line numbers, etc.
3491 * leaves input ptr at the sharp sign found.
3492 * If ANY is nonzero, return at next directive of any sort.
3495 skip_if_group (ip
, any
)
3499 register U_CHAR
*bp
= ip
->bufp
, *cp
;
3500 register U_CHAR
*endb
= ip
->buf
+ ip
->length
;
3501 struct directive
*kt
;
3502 IF_STACK_FRAME
*save_if_stack
= if_stack
; /* don't pop past here */
3503 U_CHAR
*beg_of_line
= bp
;
3507 case '/': /* possible comment */
3508 if (*bp
== '\\' && bp
[1] == '\n')
3512 bp
= skip_to_end_of_comment (ip
, &ip
->lineno
);
3517 bp
= skip_quoted_string (bp
- 1, endb
, ip
->lineno
, &ip
->lineno
, 0, 0);
3520 /* Char after backslash loses its special meaning. */
3523 ++ip
->lineno
; /* But do update the line-count. */
3534 /* # keyword: a # must be first nonblank char on the line */
3535 if (beg_of_line
== 0)
3537 /* Scan from start of line, skipping whitespace, comments
3538 and backslash-newlines, and see if we reach this #.
3539 If not, this # is not special. */
3542 if (is_nvspace (*bp
))
3544 else if (*bp
== '\\' && bp
[1] == '\n')
3546 else if (*bp
== '/' && bp
[1] == '*') {
3548 while (!(*bp
== '*' && bp
[1] == '/')) {
3557 if (bp
!= ip
->bufp
) {
3558 bp
= ip
->bufp
+ 1; /* Reset bp to after the #. */
3562 bp
= ip
->bufp
+ 1; /* Point after '#'. */
3564 /* Skip whitespace and \-newline. */
3566 if (is_nvspace (*bp
))
3568 else if (*bp
== '\\' && bp
[1] == '\n')
3570 else if (*bp
== '/' && bp
[1] == '*') {
3572 while (!(*bp
== '*' && bp
[1] == '/'))
3581 /* Now find end of directive name.
3582 If we encounter a backslash-newline, exchange it with any following
3583 symbol-constituents so that we end up with a contiguous name. */
3586 if (is_idchar (*bp
))
3589 if (*bp
== '\\' && bp
[1] == '\n')
3590 name_newline_fix (bp
);
3591 if (is_idchar (*bp
))
3597 for (kt
= directive_table
; kt
->length
>= 0; kt
++) {
3598 IF_STACK_FRAME
*temp
;
3599 if (strncmp ((const char *)cp
, kt
->name
, kt
->length
) == 0
3600 && !is_idchar (cp
[kt
->length
])) {
3602 /* If we are asked to return on next directive,
3611 temp
= (IF_STACK_FRAME
*) xcalloc (1, sizeof (IF_STACK_FRAME
));
3612 temp
->next
= if_stack
;
3614 temp
->lineno
= ip
->lineno
;
3615 temp
->fname
= ip
->fname
;
3616 temp
->type
= kt
->type
;
3621 if (if_stack
== instack
[indepth
].if_stack
) {
3622 error ("#%s not within a conditional", kt
->name
);
3625 else if (if_stack
== save_if_stack
)
3626 return; /* found what we came for */
3628 if (kt
->type
!= T_ENDIF
) {
3629 if (if_stack
->type
== T_ELSE
)
3630 error ("#else or #elif after #else");
3631 if_stack
->type
= kt
->type
;
3636 if_stack
= if_stack
->next
;
3641 /* Anything else is ignored. */
3650 /* after this returns, rescan will exit because ip->bufp
3651 now points to the end of the buffer.
3652 rescan is responsible for the error message also. */
3656 * handle a #else directive. Do this by just continuing processing
3657 * without changing if_stack ; this is so that the error message
3658 * for missing #endif's etc. will point to the original #if. It
3659 * is possible that something different would be better.
3662 do_else (buf
, limit
, op
)
3663 U_CHAR
*buf ATTRIBUTE_UNUSED
;
3664 U_CHAR
*limit ATTRIBUTE_UNUSED
;
3667 FILE_BUF
*ip
= &instack
[indepth
];
3669 if (if_stack
== instack
[indepth
].if_stack
) {
3670 error ("#else not within a conditional");
3673 if (if_stack
->type
!= T_IF
&& if_stack
->type
!= T_ELIF
) {
3674 error ("#else after #else");
3675 fprintf (stderr
, " (matches line %d", if_stack
->lineno
);
3676 if (strcmp (if_stack
->fname
, ip
->fname
) != 0)
3677 fprintf (stderr
, ", file %s", if_stack
->fname
);
3678 fprintf (stderr
, ")\n");
3680 if_stack
->type
= T_ELSE
;
3683 if (if_stack
->if_succeeded
)
3684 skip_if_group (ip
, 0);
3686 ++if_stack
->if_succeeded
; /* continue processing input */
3687 output_line_command (ip
, op
, 1, same_file
);
3692 * unstack after #endif command
3695 do_endif (buf
, limit
, op
)
3696 U_CHAR
*buf ATTRIBUTE_UNUSED
;
3697 U_CHAR
*limit ATTRIBUTE_UNUSED
;
3700 if (if_stack
== instack
[indepth
].if_stack
)
3701 error ("unbalanced #endif");
3703 IF_STACK_FRAME
*temp
= if_stack
;
3704 if_stack
= if_stack
->next
;
3706 output_line_command (&instack
[indepth
], op
, 1, same_file
);
3711 * Skip a comment, assuming the input ptr immediately follows the
3712 * initial slash-star. Bump line counter as necessary.
3713 * (The canonical line counter is &ip->lineno).
3714 * Don't use this routine (or the next one) if bumping the line
3715 * counter is not sufficient to deal with newlines in the string.
3718 skip_to_end_of_comment (ip
, line_counter
)
3719 register FILE_BUF
*ip
;
3720 int *line_counter
; /* place to remember newlines, or NULL */
3722 register U_CHAR
*limit
= ip
->buf
+ ip
->length
;
3723 register U_CHAR
*bp
= ip
->bufp
;
3724 FILE_BUF
*op
= &outbuf
; /* JF */
3725 int output
= put_out_comments
&& !line_counter
;
3727 /* JF this line_counter stuff is a crock to make sure the
3728 comment is only put out once, no matter how many times
3729 the comment is skipped. It almost works */
3734 while (bp
< limit
) {
3739 if (warn_comments
&& bp
< limit
&& *bp
== '*')
3740 warning("`/*' within comment");
3743 if (line_counter
!= NULL
)
3749 if (*bp
== '\\' && bp
[1] == '\n')
3765 * Skip over a quoted string. BP points to the opening quote.
3766 * Returns a pointer after the closing quote. Don't go past LIMIT.
3767 * START_LINE is the line number of the starting point (but it need
3768 * not be valid if the starting point is inside a macro expansion).
3770 * The input stack state is not changed.
3772 * If COUNT_NEWLINES is nonzero, it points to an int to increment
3773 * for each newline passed.
3775 * If BACKSLASH_NEWLINES_P is nonzero, store 1 thru it
3776 * if we pass a backslash-newline.
3778 * If EOFP is nonzero, set *EOFP to 1 if the string is unterminated.
3781 skip_quoted_string (bp
, limit
, start_line
, count_newlines
, backslash_newlines_p
, eofp
)
3782 register const U_CHAR
*bp
;
3783 register const U_CHAR
*limit
;
3785 int *count_newlines
;
3786 int *backslash_newlines_p
;
3789 register U_CHAR c
, match
;
3794 error_with_line (line_for_error (start_line
),
3795 "unterminated string or character constant");
3802 while (*bp
== '\\' && bp
[1] == '\n') {
3803 if (backslash_newlines_p
)
3804 *backslash_newlines_p
= 1;
3809 if (*bp
== '\n' && count_newlines
) {
3810 if (backslash_newlines_p
)
3811 *backslash_newlines_p
= 1;
3815 } else if (c
== '\n') {
3816 /* Unterminated strings and character constants are 'legal'. */
3817 bp
--; /* Don't consume the newline. */
3821 } else if (c
== match
)
3824 return (U_CHAR
*) bp
;
3828 * write out a #line command, for instance, after an #include file.
3829 * If CONDITIONAL is nonzero, we can omit the #line if it would
3830 * appear to be a no-op, and we can output a few newlines instead
3831 * if we want to increase the line number by a small amount.
3832 * FILE_CHANGE says whether we are entering a file, leaving, or neither.
3836 output_line_command (ip
, op
, conditional
, file_change
)
3839 enum file_change_code file_change
;
3842 char line_cmd_buf
[500];
3844 if (no_line_commands
3845 || ip
->fname
== NULL
3847 op
->lineno
= ip
->lineno
;
3852 if (ip
->lineno
== op
->lineno
)
3855 /* If the inherited line number is a little too small,
3856 output some newlines instead of a #line command. */
3857 if (ip
->lineno
> op
->lineno
&& ip
->lineno
< op
->lineno
+ 8) {
3858 check_expand (op
, 10);
3859 while (ip
->lineno
> op
->lineno
) {
3867 sprintf (line_cmd_buf
, "# %d \"%s\"", ip
->lineno
, ip
->fname
);
3868 if (file_change
!= same_file
)
3869 strcat (line_cmd_buf
, file_change
== enter_file
? " 1" : " 2");
3870 if (system_include_depth
> 0)
3871 strcat (line_cmd_buf
, " 3");
3872 len
= strlen (line_cmd_buf
);
3873 line_cmd_buf
[len
++] = '\n';
3874 check_expand (op
, len
+ 1);
3875 if (op
->bufp
> op
->buf
&& op
->bufp
[-1] != '\n')
3877 memcpy (op
->bufp
, line_cmd_buf
, len
);
3879 op
->lineno
= ip
->lineno
;
3883 /* Expand a macro call.
3884 HP points to the symbol that is the macro being called.
3885 Put the result of expansion onto the input stack
3886 so that subsequent input by our caller will use it.
3888 If macro wants arguments, caller has already verified that
3889 an argument list follows; arguments come from the input stack. */
3892 macroexpand (hp
, op
)
3897 DEFINITION
*defn
= hp
->value
.defn
;
3898 register U_CHAR
*xbuf
;
3900 int start_line
= instack
[indepth
].lineno
;
3902 CHECK_DEPTH (return;);
3904 /* it might not actually be a macro. */
3905 if (hp
->type
!= T_MACRO
) {
3906 special_symbol (hp
, op
);
3910 nargs
= defn
->nargs
;
3914 struct argdata
*args
;
3915 const char *parse_error
= 0;
3917 args
= (struct argdata
*) alloca ((nargs
+ 1) * sizeof (struct argdata
));
3919 for (i
= 0; i
< nargs
; i
++) {
3920 args
[i
].raw
= args
[i
].expanded
= (U_CHAR
*) "";
3921 args
[i
].raw_length
= args
[i
].expand_length
3922 = args
[i
].stringified_length
= 0;
3923 args
[i
].free1
= args
[i
].free2
= 0;
3926 /* Parse all the macro args that are supplied. I counts them.
3927 The first NARGS args are stored in ARGS.
3928 The rest are discarded. */
3931 /* Discard the open-parenthesis or comma before the next arg. */
3932 ++instack
[indepth
].bufp
;
3934 = macarg ((i
< nargs
|| (nargs
== 0 && i
== 0)) ? &args
[i
] : 0);
3937 error_with_line (line_for_error (start_line
), parse_error
);
3941 } while (*instack
[indepth
].bufp
!= ')');
3943 /* If we got one arg but it was just whitespace, call that 0 args. */
3945 register const U_CHAR
*bp
= args
[0].raw
;
3946 register const U_CHAR
*lim
= bp
+ args
[0].raw_length
;
3947 while (bp
!= lim
&& is_space (*bp
)) bp
++;
3952 if (nargs
== 0 && i
> 0)
3953 error ("arguments given to macro `%s'", hp
->name
);
3954 else if (i
< nargs
) {
3955 /* traditional C allows foo() if foo wants one argument. */
3956 if (nargs
== 1 && i
== 0)
3959 error ("no args to macro `%s'", hp
->name
);
3961 error ("only 1 arg to macro `%s'", hp
->name
);
3963 error ("only %d args to macro `%s'", i
, hp
->name
);
3964 } else if (i
> nargs
)
3965 error ("too many (%d) args to macro `%s'", i
, hp
->name
);
3967 /* Swallow the closeparen. */
3968 ++instack
[indepth
].bufp
;
3970 /* If macro wants zero args, we parsed the arglist for checking only.
3971 Read directly from the macro definition. */
3973 xbuf
= defn
->expansion
;
3974 xbuf_len
= defn
->length
;
3976 register U_CHAR
*exp
= defn
->expansion
;
3977 register int offset
; /* offset in expansion,
3978 copied a piece at a time */
3979 register int totlen
; /* total amount of exp buffer filled so far */
3981 register struct reflist
*ap
;
3983 /* Macro really takes args. Compute the expansion of this call. */
3985 /* Compute length in characters of the macro's expansion. */
3986 xbuf_len
= defn
->length
;
3987 for (ap
= defn
->pattern
; ap
!= NULL
; ap
= ap
->next
) {
3989 xbuf_len
+= args
[ap
->argno
].stringified_length
;
3991 xbuf_len
+= args
[ap
->argno
].raw_length
;
3994 xbuf
= (U_CHAR
*) xmalloc (xbuf_len
+ 1);
3996 /* Generate in XBUF the complete expansion
3997 with arguments substituted in.
3998 TOTLEN is the total size generated so far.
3999 OFFSET is the index in the definition
4000 of where we are copying from. */
4001 offset
= totlen
= 0;
4002 for (ap
= defn
->pattern
; ap
!= NULL
; ap
= ap
->next
) {
4003 register struct argdata
*arg
= &args
[ap
->argno
];
4005 for (i
= 0; i
< ap
->nchars
; i
++)
4006 xbuf
[totlen
++] = exp
[offset
++];
4008 if (ap
->stringify
!= 0) {
4009 int arglen
= arg
->raw_length
;
4015 && (c
= arg
->raw
[i
], is_space (c
)))
4018 && (c
= arg
->raw
[arglen
- 1], is_space (c
)))
4020 for (; i
< arglen
; i
++) {
4023 /* Special markers Newline Space
4024 generate nothing for a stringified argument. */
4025 if (c
== '\n' && arg
->raw
[i
+1] != '\n') {
4030 /* Internal sequences of whitespace are replaced by one space
4031 except within an string or char token. */
4033 && (c
== '\n' ? arg
->raw
[i
+1] == '\n' : is_space (c
))) {
4035 /* Note that Newline Space does occur within whitespace
4036 sequences; consider it part of the sequence. */
4037 if (c
== '\n' && is_space (arg
->raw
[i
+1]))
4039 else if (c
!= '\n' && is_space (c
))
4056 } else if (c
== '\"' || c
== '\'')
4060 /* Escape these chars */
4061 if (c
== '\"' || (in_string
&& c
== '\\'))
4062 xbuf
[totlen
++] = '\\';
4066 sprintf ((char *) &xbuf
[totlen
], "\\%03o", (unsigned int) c
);
4071 const U_CHAR
*p1
= arg
->raw
;
4072 const U_CHAR
*l1
= p1
+ arg
->raw_length
;
4074 if (ap
->raw_before
) {
4075 while (p1
!= l1
&& is_space (*p1
)) p1
++;
4076 while (p1
!= l1
&& is_idchar (*p1
))
4077 xbuf
[totlen
++] = *p1
++;
4078 /* Delete any no-reexpansion marker that follows
4079 an identifier at the beginning of the argument
4080 if the argument is concatenated with what precedes it. */
4081 if (p1
[0] == '\n' && p1
[1] == '-')
4084 if (ap
->raw_after
) {
4085 /* Arg is concatenated after: delete trailing whitespace,
4086 whitespace markers, and no-reexpansion markers. */
4088 if (is_space (l1
[-1])) l1
--;
4089 else if (l1
[-1] == '-') {
4090 const U_CHAR
*p2
= l1
- 1;
4091 /* If a `-' is preceded by an odd number of newlines then it
4092 and the last newline are a no-reexpansion marker. */
4093 while (p2
!= p1
&& p2
[-1] == '\n') p2
--;
4094 if ((l1
- 1 - p2
) & 1) {
4102 memmove (xbuf
+ totlen
, p1
, l1
- p1
);
4106 if (totlen
> xbuf_len
)
4110 /* if there is anything left of the definition
4111 after handling the arg list, copy that in too. */
4113 for (i
= offset
; i
< defn
->length
; i
++)
4114 xbuf
[totlen
++] = exp
[i
];
4119 for (i
= 0; i
< nargs
; i
++) {
4120 if (args
[i
].free1
!= 0)
4121 free (args
[i
].free1
);
4122 if (args
[i
].free2
!= 0)
4123 free (args
[i
].free2
);
4127 xbuf
= defn
->expansion
;
4128 xbuf_len
= defn
->length
;
4131 /* Now put the expansion on the input stack
4132 so our caller will commence reading from it. */
4134 register FILE_BUF
*ip2
;
4136 ip2
= &instack
[++indepth
];
4141 ip2
->length
= xbuf_len
;
4143 ip2
->free_ptr
= (nargs
> 0) ? xbuf
: 0;
4145 ip2
->if_stack
= if_stack
;
4150 * Parse a macro argument and store the info on it into *ARGPTR.
4151 * Return nonzero to indicate a syntax error.
4156 register struct argdata
*argptr
;
4158 FILE_BUF
*ip
= &instack
[indepth
];
4163 /* Try to parse as much of the argument as exists at this
4164 input stack level. */
4165 U_CHAR
*bp
= macarg1 (ip
->bufp
, ip
->buf
+ ip
->length
,
4166 &paren
, &newlines
, &comments
);
4168 /* If we find the end of the argument at this level,
4169 set up *ARGPTR to point at it in the input stack. */
4170 if (!(ip
->fname
!= 0 && (newlines
!= 0 || comments
!= 0))
4171 && bp
!= ip
->buf
+ ip
->length
) {
4173 argptr
->raw
= ip
->bufp
;
4174 argptr
->raw_length
= bp
- ip
->bufp
;
4178 /* This input stack level ends before the macro argument does.
4179 We must pop levels and keep parsing.
4180 Therefore, we must allocate a temporary buffer and copy
4181 the macro argument into it. */
4182 int bufsize
= bp
- ip
->bufp
;
4183 int extra
= newlines
;
4184 U_CHAR
*buffer
= (U_CHAR
*) xmalloc (bufsize
+ extra
+ 1);
4185 int final_start
= 0;
4187 memcpy (buffer
, ip
->bufp
, bufsize
);
4189 ip
->lineno
+= newlines
;
4191 while (bp
== ip
->buf
+ ip
->length
) {
4192 if (instack
[indepth
].macro
== 0) {
4194 return "unterminated macro call";
4196 ip
->macro
->type
= T_MACRO
;
4198 free (ip
->free_ptr
);
4199 ip
= &instack
[--indepth
];
4202 bp
= macarg1 (ip
->bufp
, ip
->buf
+ ip
->length
, &paren
,
4203 &newlines
, &comments
);
4204 final_start
= bufsize
;
4205 bufsize
+= bp
- ip
->bufp
;
4207 buffer
= (U_CHAR
*) xrealloc (buffer
, bufsize
+ extra
+ 1);
4208 memcpy (buffer
+ bufsize
- (bp
- ip
->bufp
), ip
->bufp
, bp
- ip
->bufp
);
4210 ip
->lineno
+= newlines
;
4213 /* Now, if arg is actually wanted, record its raw form,
4214 discarding comments and duplicating newlines in whatever
4215 part of it did not come from a macro expansion.
4216 EXTRA space has been preallocated for duplicating the newlines.
4217 FINAL_START is the index of the start of that part. */
4219 argptr
->raw
= buffer
;
4220 argptr
->raw_length
= bufsize
;
4221 argptr
->free1
= buffer
;
4222 argptr
->newlines
= newlines
;
4223 argptr
->comments
= comments
;
4224 if ((newlines
|| comments
) && ip
->fname
!= 0)
4227 discard_comments (argptr
->raw
+ final_start
,
4228 argptr
->raw_length
- final_start
,
4230 argptr
->raw
[argptr
->raw_length
] = 0;
4231 if (argptr
->raw_length
> bufsize
+ extra
)
4236 /* If we are not discarding this argument,
4237 macroexpand it and compute its length as stringified.
4238 All this info goes into *ARGPTR. */
4242 register const U_CHAR
*buf
, *lim
;
4243 register int totlen
;
4245 obuf
= expand_to_temp_buffer (argptr
->raw
,
4246 argptr
->raw
+ argptr
->raw_length
,
4249 argptr
->expanded
= obuf
.buf
;
4250 argptr
->expand_length
= obuf
.length
;
4251 argptr
->free2
= obuf
.buf
;
4254 lim
= buf
+ argptr
->raw_length
;
4257 while (buf
!= lim
) {
4258 register U_CHAR c
= *buf
++;
4260 /* Internal sequences of whitespace are replaced by one space
4261 in most cases, but not always. So count all the whitespace
4262 in case we need to keep it all. */
4263 if (c
== '\"' || c
== '\\') /* escape these chars */
4265 else if (!ISPRINT (c
))
4268 argptr
->stringified_length
= totlen
;
4273 /* Scan text from START (inclusive) up to LIMIT (exclusive),
4274 counting parens in *DEPTHPTR,
4275 and return if reach LIMIT
4276 or before a `)' that would make *DEPTHPTR negative
4277 or before a comma when *DEPTHPTR is zero.
4278 Single and double quotes are matched and termination
4279 is inhibited within them. Comments also inhibit it.
4280 Value returned is pointer to stopping place.
4282 Increment *NEWLINES each time a newline is passed.
4283 Set *COMMENTS to 1 if a comment is seen. */
4286 macarg1 (start
, limit
, depthptr
, newlines
, comments
)
4288 register const U_CHAR
*limit
;
4289 int *depthptr
, *newlines
, *comments
;
4291 register U_CHAR
*bp
= start
;
4293 while (bp
< limit
) {
4299 if (--(*depthptr
) < 0)
4303 /* Traditionally, backslash makes following char not special. */
4307 /* But count source lines anyway. */
4316 if (bp
[1] == '\\' && bp
[2] == '\n')
4317 newline_fix (bp
+ 1);
4318 if (bp
[1] != '*' || bp
+ 1 >= limit
)
4322 while (bp
+ 1 < limit
) {
4324 && bp
[1] == '\\' && bp
[2] == '\n')
4325 newline_fix (bp
+ 1);
4326 if (bp
[0] == '*' && bp
[1] == '/')
4328 if (*bp
== '\n') ++*newlines
;
4337 for (quotec
= *bp
++; bp
+ 1 < limit
&& *bp
!= quotec
; bp
++) {
4342 while (*bp
== '\\' && bp
[1] == '\n') {
4345 } else if (*bp
== '\n') {
4354 if ((*depthptr
) == 0)
4364 /* Discard comments and duplicate newlines
4365 in the string of length LENGTH at START,
4366 except inside of string constants.
4367 The string is copied into itself with its beginning staying fixed.
4369 NEWLINES is the number of newlines that must be duplicated.
4370 We assume that that much extra space is available past the end
4374 discard_comments (start
, length
, newlines
)
4379 register U_CHAR
*ibp
;
4380 register U_CHAR
*obp
;
4381 register const U_CHAR
*limit
;
4384 /* If we have newlines to duplicate, copy everything
4385 that many characters up. Then, in the second part,
4386 we will have room to insert the newlines
4388 NEWLINES may actually be too large, because it counts
4389 newlines in string constants, and we don't duplicate those.
4390 But that does no harm. */
4392 ibp
= start
+ length
;
4393 obp
= ibp
+ newlines
;
4395 while (limit
!= ibp
)
4399 ibp
= start
+ newlines
;
4400 limit
= start
+ length
+ newlines
;
4403 while (ibp
< limit
) {
4404 *obp
++ = c
= *ibp
++;
4407 /* Duplicate the newline. */
4419 if (*ibp
== '\\' && ibp
[1] == '\n')
4421 /* Delete any comment. */
4422 if (ibp
[0] != '*' || ibp
+ 1 >= limit
)
4426 while (ibp
+ 1 < limit
) {
4428 && ibp
[1] == '\\' && ibp
[2] == '\n')
4429 newline_fix (ibp
+ 1);
4430 if (ibp
[0] == '*' && ibp
[1] == '/')
4439 /* Notice and skip strings, so that we don't
4440 think that comments start inside them,
4441 and so we don't duplicate newlines in them. */
4444 while (ibp
< limit
) {
4445 *obp
++ = c
= *ibp
++;
4448 if (c
== '\n' && quotec
== '\'')
4450 if (c
== '\\' && ibp
< limit
) {
4451 while (*ibp
== '\\' && ibp
[1] == '\n')
4465 /* Core error handling routine. */
4467 v_message (mtype
, line
, msgid
, ap
)
4473 const char *fname
= 0;
4476 if (mtype
== WARNING
&& inhibit_warnings
)
4479 for (i
= indepth
; i
>= 0; i
--)
4480 if (instack
[i
].fname
!= NULL
) {
4482 line
= instack
[i
].lineno
;
4483 fname
= instack
[i
].fname
;
4488 fprintf (stderr
, "%s:%d: ", fname
, line
);
4490 fprintf (stderr
, "%s: ", progname
);
4492 if (mtype
== WARNING
)
4493 fputs ("warning: ", stderr
);
4495 vfprintf (stderr
, msgid
, ap
);
4496 putc ('\n', stderr
);
4503 * error - print error message and increment count of errors.
4506 error
VPARAMS ((const char *msgid
, ...))
4508 #ifndef ANSI_PROTOTYPES
4513 VA_START(ap
, msgid
);
4515 #ifndef ANSI_PROTOTYPES
4516 msgid
= va_arg (ap
, const char *);
4519 v_message (ERROR
, 0, msgid
, ap
);
4523 error_with_line
VPARAMS ((int line
, const char *msgid
, ...))
4525 #ifndef ANSI_PROTOTYPES
4531 VA_START(ap
, msgid
);
4533 #ifndef ANSI_PROTOTYPES
4534 line
= va_arg (ap
, int);
4535 msgid
= va_arg (ap
, const char *);
4538 v_message (ERROR
, line
, msgid
, ap
);
4541 /* Error including a message from `errno'. */
4543 error_from_errno (name
)
4546 error ("%s: %s", name
, strerror (errno
));
4549 /* Print error message but don't count it. */
4551 warning
VPARAMS ((const char *msgid
, ...))
4553 #ifndef ANSI_PROTOTYPES
4558 VA_START(ap
, msgid
);
4560 #ifndef ANSI_PROTOTYPES
4561 msgid
= va_arg (ap
, const char *);
4564 v_message (WARNING
, 0, msgid
, ap
);
4568 fatal
VPARAMS ((const char *msgid
, ...))
4570 #ifndef ANSI_PROTOTYPES
4575 VA_START(ap
, msgid
);
4577 #ifndef ANSI_PROTOTYPES
4578 msgid
= va_arg (ap
, const char *);
4581 v_message (FATAL
, 0, msgid
, ap
);
4582 exit (FATAL_EXIT_CODE
);
4585 /* More 'friendly' abort that prints the location at which we died. */
4587 fancy_abort (line
, func
)
4591 fatal ("Internal error in %s, at tradcpp.c:%d\n\
4592 Please submit a full bug report.\n\
4593 See %s for instructions.", func
, line
, GCCBUGURL
);
4597 perror_with_name (name
)
4600 fprintf (stderr
, "%s: %s: %s\n", progname
, name
, strerror (errno
));
4605 pfatal_with_name (name
)
4608 perror_with_name (name
);
4609 exit (FATAL_EXIT_CODE
);
4612 /* Return the line at which an error occurred.
4613 The error is not necessarily associated with the current spot
4614 in the input stack, so LINE says where. LINE will have been
4615 copied from ip->lineno for the current input level.
4616 If the current level is for a file, we return LINE.
4617 But if the current level is not for a file, LINE is meaningless.
4618 In that case, we return the lineno of the innermost file. */
4620 line_for_error (line
)
4626 for (i
= indepth
; i
>= 0; ) {
4627 if (instack
[i
].fname
!= 0)
4632 line1
= instack
[i
].lineno
;
4638 * If OBUF doesn't have NEEDED bytes after OPTR, make it bigger.
4640 * As things stand, nothing is ever placed in the output buffer to be
4641 * removed again except when it's KNOWN to be part of an identifier,
4642 * so flushing and moving down everything left, instead of expanding,
4647 grow_outbuf (obuf
, needed
)
4648 register FILE_BUF
*obuf
;
4649 register int needed
;
4654 if (obuf
->length
- (obuf
->bufp
- obuf
->buf
) > needed
)
4657 /* Make it at least twice as big as it is now. */
4659 /* Make it have at least 150% of the free space we will need. */
4660 minsize
= (3 * needed
) / 2 + (obuf
->bufp
- obuf
->buf
);
4661 if (minsize
> obuf
->length
)
4662 obuf
->length
= minsize
;
4664 p
= (U_CHAR
*) xrealloc (obuf
->buf
, obuf
->length
);
4665 obuf
->bufp
= p
+ (obuf
->bufp
- obuf
->buf
);
4669 /* Symbol table for macro names and special symbols */
4672 * install a name in the main hash table, even if it is already there.
4673 * name stops with first non alphanumeric, except leading '#'.
4674 * caller must check against redefinition if that is desired.
4675 * delete_macro () removes things installed by install () in fifo order.
4676 * this is important because of the `defined' special symbol used
4677 * in #if, and also if pushdef/popdef directives are ever implemented.
4679 * If LEN is >= 0, it is the length of the name.
4680 * Otherwise, compute the length by scanning the entire name.
4682 * If HASH is >= 0, it is the precomputed hash code.
4683 * Otherwise, compute the hash code.
4685 * caller must set the value, if any is desired.
4688 install (name
, len
, type
, hash
)
4691 enum node_type type
;
4693 /* watch out here if sizeof (U_CHAR *) != sizeof (int) */
4695 register HASHNODE
*hp
;
4696 register int bucket
;
4697 register const U_CHAR
*p
;
4702 while (is_idchar (*p
))
4708 hash
= hashf (name
, len
, HASHSIZE
);
4710 hp
= (HASHNODE
*) xmalloc (sizeof (HASHNODE
) + len
+ 1);
4712 hp
->bucket_hdr
= &hashtab
[bucket
];
4713 hp
->next
= hashtab
[bucket
];
4714 hashtab
[bucket
] = hp
;
4716 if (hp
->next
!= NULL
)
4717 hp
->next
->prev
= hp
;
4720 hp
->name
= q
= ((U_CHAR
*) hp
) + sizeof (HASHNODE
);
4721 memcpy (q
, name
, len
);
4727 * find the most recent hash node for name name (ending with first
4728 * non-identifier char) installed by install
4730 * If LEN is >= 0, it is the length of the name.
4731 * Otherwise, compute the length by scanning the entire name.
4733 * If HASH is >= 0, it is the precomputed hash code.
4734 * Otherwise, compute the hash code.
4737 lookup (name
, len
, hash
)
4742 register const U_CHAR
*bp
;
4743 register HASHNODE
*bucket
;
4746 for (bp
= name
; is_idchar (*bp
); bp
++) ;
4751 hash
= hashf (name
, len
, HASHSIZE
);
4753 bucket
= hashtab
[hash
];
4755 if (bucket
->length
== len
4756 && strncmp ((const char *)bucket
->name
, (const char *)name
, len
) == 0)
4758 bucket
= bucket
->next
;
4764 * Delete a hash node. Some weirdness to free junk from macros.
4765 * More such weirdness will have to be added if you define more hash
4766 * types that need it.
4769 /* Note that the DEFINITION of a macro is removed from the hash table
4770 but its storage is not freed. This would be a storage leak
4771 except that it is not reasonable to keep undefining and redefining
4772 large numbers of macros many times.
4773 In any case, this is necessary, because a macro can be #undef'd
4774 in the middle of reading the arguments to a call to it.
4775 If #undef freed the DEFINITION, that would crash. */
4781 if (hp
->prev
!= NULL
)
4782 hp
->prev
->next
= hp
->next
;
4783 if (hp
->next
!= NULL
)
4784 hp
->next
->prev
= hp
->prev
;
4786 /* make sure that the bucket chain header that
4787 the deleted guy was on points to the right thing afterwards. */
4788 if (hp
== *hp
->bucket_hdr
)
4789 *hp
->bucket_hdr
= hp
->next
;
4795 * return hash function on name. must be compatible with the one
4796 * computed a step at a time, elsewhere
4799 hashf (name
, len
, hashsize
)
4800 register const U_CHAR
*name
;
4807 r
= HASHSTEP (r
, *name
++);
4809 return MAKE_POS (r
) % hashsize
;
4812 /* Dump all macro definitions as #defines to stdout. */
4819 for (bucket
= 0; bucket
< HASHSIZE
; bucket
++) {
4820 register HASHNODE
*hp
;
4822 for (hp
= hashtab
[bucket
]; hp
; hp
= hp
->next
) {
4823 if (hp
->type
== T_MACRO
) {
4824 register DEFINITION
*defn
= hp
->value
.defn
;
4830 /* Print the definition of the macro HP. */
4832 printf ("#define %s", hp
->name
);
4833 if (defn
->nargs
>= 0) {
4837 for (i
= 0; i
< defn
->nargs
; i
++) {
4838 dump_arg_n (defn
, i
);
4839 if (i
+ 1 < defn
->nargs
)
4849 for (ap
= defn
->pattern
; ap
!= NULL
; ap
= ap
->next
) {
4850 dump_defn_1 (defn
->expansion
, offset
, ap
->nchars
);
4851 if (ap
->nchars
!= 0)
4853 offset
+= ap
->nchars
;
4856 if (ap
->raw_before
&& !concat
)
4859 dump_arg_n (defn
, ap
->argno
);
4860 if (ap
->raw_after
) {
4865 dump_defn_1 (defn
->expansion
, offset
, defn
->length
- offset
);
4872 /* Output to stdout a substring of a macro definition.
4873 BASE is the beginning of the definition.
4874 Output characters START thru LENGTH.
4875 Discard newlines outside of strings, thus
4876 converting funny-space markers to ordinary spaces. */
4878 dump_defn_1 (base
, start
, length
)
4883 const U_CHAR
*p
= base
+ start
;
4884 const U_CHAR
*limit
= base
+ start
+ length
;
4889 else if (*p
== '\"' || *p
=='\'') {
4890 const U_CHAR
*p1
= skip_quoted_string (p
, limit
, 0, 0, 0, 0);
4891 fwrite (p
, p1
- p
, 1, stdout
);
4898 /* Print the name of argument number ARGNUM of macro definition DEFN.
4899 Recall that DEFN->argnames contains all the arg names
4900 concatenated in reverse order with comma-space in between. */
4902 dump_arg_n (defn
, argnum
)
4906 register const U_CHAR
*p
= defn
->argnames
;
4907 while (argnum
+ 1 < defn
->nargs
) {
4908 p
= (const U_CHAR
*) strchr ((const char *)p
, ' ') + 1;
4912 while (*p
&& *p
!= ',') {
4918 /* Initialize the built-in macros. */
4919 #define DSC(x) U x, sizeof x - 1
4920 #define install_spec(name, type) \
4921 install(DSC(name), type, -1);
4922 #define install_value(name, val) \
4923 hp = install(DSC(name), T_CONST, -1); hp->value.cpval = val;
4925 initialize_builtins ()
4929 install_spec ("__BASE_FILE__", T_BASE_FILE
);
4930 install_spec ("__DATE__", T_DATE
);
4931 install_spec ("__FILE__", T_FILE
);
4932 install_spec ("__TIME__", T_TIME
);
4933 install_spec ("__VERSION__", T_VERSION
);
4934 install_spec ("__INCLUDE_LEVEL__", T_INCLUDE_LEVEL
);
4935 install_spec ("__LINE__", T_SPECLINE
);
4937 #ifndef NO_BUILTIN_SIZE_TYPE
4938 install_value ("__SIZE_TYPE__", SIZE_TYPE
);
4940 #ifndef NO_BUILTIN_PTRDIFF_TYPE
4941 install_value ("__PTRDIFF_TYPE__", PTRDIFF_TYPE
);
4943 #ifndef NO_BUILTIN_WCHAR_TYPE
4944 install_value ("__WCHAR_TYPE__", WCHAR_TYPE
);
4946 #ifndef NO_BUILTIN_WINT_TYPE
4947 install_value ("__WINT_TYPE__", WINT_TYPE
);
4949 install_value ("__REGISTER_PREFIX__", REGISTER_PREFIX
);
4950 install_value ("__USER_LABEL_PREFIX__", user_label_prefix
);
4954 #undef install_value
4956 /* Common handler of command line directives -U, -D and -A. */
4958 run_directive (str
, len
, type
)
4961 enum node_type type
;
4963 struct directive
*kt
;
4964 FILE_BUF
*ip
= &instack
[++indepth
];
4965 ip
->fname
= "*command line*";
4967 ip
->buf
= ip
->bufp
= (U_CHAR
*) str
;
4972 ip
->if_stack
= if_stack
;
4974 for (kt
= directive_table
; kt
->type
!= type
; kt
++)
4977 (*kt
->func
) ((U_CHAR
*) str
, (U_CHAR
*) str
+ len
, NULL
);
4981 /* Handle the -D option. If STR is just an identifier, define it with
4982 * value 1. If STR has anything after the identifier, then it should
4983 * be identifier-space-definition. */
4985 make_definition (str
)
4991 /* Copy the entire option so we can modify it.
4992 Change the first "=" in the string to a space. If there is none,
4993 tack " 1" on the end. */
4995 /* Length including the null. */
4996 count
= strlen (str
);
4997 buf
= (char *) alloca (count
+ 2);
4998 memcpy (buf
, str
, count
);
5000 p
= strchr (str
, '=');
5009 run_directive (buf
, count
, T_DEFINE
);
5012 /* Handle the -U option. */
5017 run_directive (str
, strlen (str
), T_UNDEF
);
5020 /* Handles the #assert (-A) and #unassert (-A-) command line options. */
5022 make_assertion (str
)
5025 enum node_type type
= T_ASSERT
;
5035 count
= strlen (str
);
5036 p
= strchr (str
, '=');
5039 /* Copy the entire option so we can modify it. Change the first
5040 "=" in the string to a '(', and tack a ')' on the end. */
5041 char *buf
= (char *) alloca (count
+ 1);
5043 memcpy (buf
, str
, count
);
5049 run_directive (str
, count
, type
);
5052 /* Add output to `deps_buffer' for the -M switch.
5053 STRING points to the text to be output.
5054 SIZE is the number of bytes, or 0 meaning output until a null.
5055 If SIZE is nonzero, we break the line first, if it is long enough. */
5057 deps_output (string
, size
)
5061 #ifndef MAX_OUTPUT_COLUMNS
5062 #define MAX_OUTPUT_COLUMNS 75
5064 if (size
!= 0 && deps_column
!= 0
5065 && size
+ deps_column
> MAX_OUTPUT_COLUMNS
) {
5066 deps_output ("\\\n ", 0);
5071 size
= strlen (string
);
5073 if (deps_size
+ size
+ 1 > deps_allocated_size
) {
5074 deps_allocated_size
= deps_size
+ size
+ 50;
5075 deps_allocated_size
*= 2;
5076 deps_buffer
= (char *) xrealloc (deps_buffer
, deps_allocated_size
);
5078 memcpy (&deps_buffer
[deps_size
], string
, size
);
5080 deps_column
+= size
;
5081 deps_buffer
[deps_size
] = 0;
5084 /* Get the file-mode and data size of the file open on FD
5085 and store them in *MODE_POINTER and *SIZE_POINTER. */
5088 file_size_and_mode (fd
, mode_pointer
, size_pointer
)
5095 if (fstat (fd
, &sbuf
) < 0) return -1;
5096 if (mode_pointer
) *mode_pointer
= sbuf
.st_mode
;
5097 if (size_pointer
) *size_pointer
= sbuf
.st_size
;