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"
30 typedef unsigned char U_CHAR
;
32 /* Name under which this program was invoked. */
34 static const char *progname
;
36 /* Current maximum length of directory names in the search path
37 for include files. (Altered as we get more of them.) */
39 size_t max_include_len
;
41 /* Nonzero means copy comments into the output file. */
43 int put_out_comments
= 0;
45 /* mkdeps.h opaque structure that encapsulates dependency information. */
48 /* Nonzero means print the names of included files rather than
49 the preprocessed output. 1 means just the #include "...",
50 2 means #include <...> as well. */
54 /* Nonzero means print dummy targets for each header file. */
56 int print_deps_phony_targets
= 0;
58 /* If true, fopen (deps_file, "a") else fopen (deps_file, "w"). */
62 /* File name which deps are being written to. This is 0 if deps are
63 being written to stdout. */
65 const char *deps_file
= 0;
67 /* Nonzero if missing .h files in -M output are assumed to be
68 generated files and not errors. */
70 int deps_missing_files
= 0;
72 /* Nonzero means don't output line number information. */
76 /* Nonzero means inhibit output of the preprocessed text
77 and instead output the definitions of all user-defined macros
78 in a form suitable for use as input to cccp. */
82 /* Nonzero means don't print warning messages. -w. */
84 int inhibit_warnings
= 0;
86 /* Non-0 means don't output the preprocessed program. */
87 int inhibit_output
= 0;
89 /* Nonzero means chars are signed. */
90 #if DEFAULT_SIGNED_CHAR
91 int flag_signed_char
= 1;
93 int flag_signed_char
= 0;
96 /* Nonzero means warn if slash-star appears in a comment. */
100 /* Nonzero causes output not to be done,
101 but directives such as #define that have side effects
106 /* Value of __USER_LABEL_PREFIX__. Target-dependent, also controlled
107 by -f(no-)leading-underscore. */
108 static const char *user_label_prefix
;
110 /* I/O buffer structure.
111 The `fname' field is nonzero for source files and #include files
112 and for the dummy text used for -D and -U.
113 It is zero for rescanning results of macro expansion
114 and for expanding macro arguments. */
115 #define INPUT_STACK_MAX 200
116 struct file_name_list
;
123 /* Macro that this level is the expansion of.
124 Included so that we can reenable the macro
125 at the end of this level. */
126 struct hashnode
*macro
;
127 /* Value of if_stack at start of this file.
128 Used to prohibit unmatched #endif (etc) in an include file. */
129 struct if_stack
*if_stack
;
130 /* Object to be freed at end of input at this level. */
132 /* Position to start scanning for #include_next in this file. */
133 struct file_name_list
*next_header_dir
;
134 } instack
[INPUT_STACK_MAX
];
136 typedef struct file_buf FILE_BUF
;
138 /* Current nesting level of input sources.
139 `instack[indepth]' is the level currently being read. */
141 #define CHECK_DEPTH(code) \
142 if (indepth >= (INPUT_STACK_MAX - 1)) \
144 error_with_line (line_for_error (instack[indepth].lineno), \
145 "macro or #include recursion too deep"); \
149 /* Current depth in #include directives that use <...>. */
150 int system_include_depth
= 0;
152 /* The output buffer. Its LENGTH field is the amount of room allocated
153 for the buffer, not the number of chars actually present. To get
154 that, subtract outbuf.buf from outbuf.bufp. */
156 #define OUTBUF_SIZE 10 /* initial size of output buffer */
159 /* Grow output buffer OBUF points at
160 so it can hold at least NEEDED more chars. */
162 #define check_expand(OBUF, NEEDED) do { \
163 if ((OBUF)->length - ((OBUF)->bufp - (OBUF)->buf) <= (NEEDED)) \
164 grow_outbuf ((OBUF), (NEEDED)); \
167 struct file_name_list
169 struct file_name_list
*next
;
173 struct file_name_list
*include
= 0; /* First dir to search */
174 /* First dir to search for <file> */
175 struct file_name_list
*first_bracket_include
= 0;
176 struct file_name_list
*last_include
= 0; /* Last in chain */
178 /* List of included files that contained #once. */
179 struct file_name_list
*dont_repeat_files
= 0;
181 /* List of other included files. */
182 struct file_name_list
*all_include_files
= 0;
184 /* Structure allocated for every #define. For a simple replacement
187 nargs = -1, the `pattern' list is null, and the expansion is just
188 the replacement text. Nargs = 0 means a functionlike macro with no args,
190 #define getchar() getc (stdin) .
191 When there are args, the expansion is the replacement text with the
192 args squashed out, and the reflist is a list describing how to
193 build the output from the input: e.g., "3 chars, then the 1st arg,
194 then 9 chars, then the 3rd arg, then 0 chars, then the 2nd arg".
195 The chars here come from the expansion. Whatever is left of the
196 expansion after the last arg-occurrence is copied after that arg.
197 Note that the reflist can be arbitrarily long---
198 its length depends on the number of times the arguments appear in
199 the replacement text, not how many args there are. Example:
200 #define f(x) x+x+x+x+x+x+x would have replacement text "++++++" and
202 { (0, 1), (1, 1), (1, 1), ..., (1, 1), NULL }
203 where (x, y) means (nchars, argno). */
205 typedef struct definition DEFINITION
;
208 int length
; /* length of expansion string */
211 struct reflist
*next
;
212 char stringify
; /* nonzero if this arg was preceded by a
214 char raw_before
; /* Nonzero if a ## operator before arg. */
215 char raw_after
; /* Nonzero if a ## operator after arg. */
216 int nchars
; /* Number of literal chars to copy before
217 this arg occurrence. */
218 int argno
; /* Number of arg to substitute (origin-0) */
220 /* Names of macro args, concatenated in reverse order
221 with comma-space between them.
222 The only use of this is that we warn on redefinition
223 if this differs between the old and new definitions. */
224 const U_CHAR
*argnames
;
227 /* Chained list of answers to an assertion. */
231 const unsigned char *answer
;
235 /* different kinds of things that can appear in the value field
236 of a hash node. Actually, this may be useless now. */
240 struct answer
*answers
;
243 /* The structure of a node in the hash table. The hash table
244 has entries for all tokens defined by #define commands (type T_MACRO),
245 plus some special tokens like __LINE__ (these each have their own
246 type, and the appropriate code is run when that type of node is seen.
247 It does not contain control words like "#define", which are recognized
248 by a separate piece of code. */
250 /* different flavors of hash nodes --- also used in keyword table */
252 T_DEFINE
= 1, /* `#define' */
253 T_INCLUDE
, /* `#include' */
254 T_INCLUDE_NEXT
,/* `#include_next' */
255 T_IFDEF
, /* `#ifdef' */
256 T_IFNDEF
, /* `#ifndef' */
258 T_ELSE
, /* `#else' */
259 T_ELIF
, /* `#elif' */
260 T_UNDEF
, /* `#undef' */
261 T_LINE
, /* `#line' */
262 T_ENDIF
, /* `#endif' */
263 T_ERROR
, /* `#error' */
264 T_WARNING
, /* `#warning' */
265 T_ASSERT
, /* `#assert' */
266 T_UNASSERT
, /* `#unassert' */
267 T_SPECLINE
, /* special symbol `__LINE__' */
268 T_DATE
, /* `__DATE__' */
269 T_FILE
, /* `__FILE__' */
270 T_BASE_FILE
, /* `__BASE_FILE__' */
271 T_INCLUDE_LEVEL
, /* `__INCLUDE_LEVEL__' */
272 T_VERSION
, /* `__VERSION__' */
273 T_TIME
, /* `__TIME__' */
274 T_CONST
, /* Constant value, used by `__STDC__' */
275 T_MACRO
, /* macro defined by `#define' */
276 T_SPEC_DEFINED
, /* special `defined' macro for use in #if statements */
277 T_UNUSED
/* Used for something not defined. */
281 struct hashnode
*next
; /* double links for easy deletion */
282 struct hashnode
*prev
;
283 struct hashnode
**bucket_hdr
; /* also, a back pointer to this node's hash
284 chain is kept, in case the node is the head
285 of the chain and gets deleted. */
286 enum node_type type
; /* type of special token */
287 int length
; /* length of token, for quick comparison */
288 U_CHAR
*name
; /* the actual name */
289 union hashval value
; /* pointer to expansion, or whatever */
292 typedef struct hashnode HASHNODE
;
294 static HASHNODE
*parse_assertion
PARAMS ((const unsigned char *,
295 const unsigned char *,
296 struct answer
**, int));
297 static struct answer
**find_answer
PARAMS ((HASHNODE
*,
298 const struct answer
*));
299 static int parse_answer
PARAMS ((const unsigned char *, const unsigned char *,
300 struct answer
**, int));
301 static unsigned char *canonicalize_text
PARAMS ((const unsigned char *,
302 const unsigned char *,
303 const unsigned char **));
305 /* Some definitions for the hash table. The hash function MUST be
306 computed as shown in hashf () below. That is because the rescan
307 loop computes the hash value `on the fly' for most tokens,
308 in order to avoid the overhead of a lot of procedure calls to
309 the hashf () function. Hashf () only exists for the sake of
310 politeness, for use when speed isn't so important. */
312 #define HASHSIZE 1403
313 HASHNODE
*hashtab
[HASHSIZE
];
314 #define HASHSTEP(old, c) ((old << 2) + c)
315 #define MAKE_POS(v) (v & 0x7fffffff) /* make number positive */
317 /* `struct directive' defines one #-directive, including how to handle it. */
320 const int length
; /* Length of name */
321 void (*const func
) PARAMS ((U_CHAR
*, U_CHAR
*, FILE_BUF
*));
322 /* Function to handle directive */
323 const char *const name
; /* Name of directive */
324 const enum node_type type
; /* Code which describes which directive. */
327 /* Last arg to output_line_command. */
328 enum file_change_code
{same_file
, enter_file
, leave_file
};
330 /* This structure represents one parsed argument in a macro call.
331 `raw' points to the argument text as written (`raw_length' is its length).
332 `expanded' points to the argument's macro-expansion
333 (its length is `expand_length').
334 `stringified_length' is the length the argument would have
336 `free1' and `free2', if nonzero, point to blocks to be freed
337 when the macro argument data is no longer needed. */
340 U_CHAR
*raw
, *expanded
;
341 int raw_length
, expand_length
;
342 int stringified_length
;
343 U_CHAR
*free1
, *free2
;
348 /* The arglist structure is built by do_define to tell
349 collect_definition where the argument names begin. That
350 is, for a define like "#define f(x,y,z) foo+x-bar*y", the arglist
351 would contain pointers to the strings x, y, and z.
352 Collect_definition would then build a DEFINITION node,
353 with reflist nodes pointing to the places x, y, and z had
354 appeared. So the arglist is just convenience data passed
355 between these two routines. It is not kept around after
356 the current #define has been processed and entered into the
360 struct arglist
*next
;
366 /* Function prototypes. */
368 static void do_define
PARAMS ((U_CHAR
*, U_CHAR
*, FILE_BUF
*));
369 static void do_error
PARAMS ((U_CHAR
*, U_CHAR
*, FILE_BUF
*));
370 static void do_warning
PARAMS ((U_CHAR
*, U_CHAR
*, FILE_BUF
*));
371 static void do_line
PARAMS ((U_CHAR
*, U_CHAR
*, FILE_BUF
*));
372 static void do_include
PARAMS ((U_CHAR
*, U_CHAR
*, FILE_BUF
*));
373 static void do_include_next
PARAMS ((U_CHAR
*, U_CHAR
*, FILE_BUF
*));
374 static void do_undef
PARAMS ((U_CHAR
*, U_CHAR
*, FILE_BUF
*));
375 static void do_if
PARAMS ((U_CHAR
*, U_CHAR
*, FILE_BUF
*));
376 static void do_ifdef
PARAMS ((U_CHAR
*, U_CHAR
*, FILE_BUF
*));
377 static void do_ifndef
PARAMS ((U_CHAR
*, U_CHAR
*, FILE_BUF
*));
378 static void do_else
PARAMS ((U_CHAR
*, U_CHAR
*, FILE_BUF
*));
379 static void do_elif
PARAMS ((U_CHAR
*, U_CHAR
*, FILE_BUF
*));
380 static void do_endif
PARAMS ((U_CHAR
*, U_CHAR
*, FILE_BUF
*));
381 static void do_assert
PARAMS ((U_CHAR
*, U_CHAR
*, FILE_BUF
*));
382 static void do_unassert
PARAMS ((U_CHAR
*, U_CHAR
*, FILE_BUF
*));
383 static void do_xifdef
PARAMS ((U_CHAR
*, U_CHAR
*, enum node_type
));
385 static struct hashnode
*install
PARAMS ((const U_CHAR
*, int, enum node_type
, int));
386 static int hashf
PARAMS ((const U_CHAR
*, int, int));
387 static int compare_defs
PARAMS ((DEFINITION
*, DEFINITION
*));
388 static int comp_def_part
PARAMS ((int, const U_CHAR
*, int,
389 const U_CHAR
*, int, int));
390 static void delete_macro
PARAMS ((HASHNODE
*));
392 /* First arg to v_message. */
393 enum msgtype
{ MT_WARNING
= 0, MT_ERROR
, MT_FATAL
};
394 static void v_message
PARAMS ((enum msgtype mtype
, int line
,
395 const char *msgid
, va_list ap
))
396 ATTRIBUTE_PRINTF (3, 0);
398 static int line_for_error
PARAMS ((int));
400 /* We know perfectly well which file this is, so we don't need to
403 #if (GCC_VERSION >= 2007)
404 #define abort() fancy_abort(__LINE__, __FUNCTION__)
406 #define abort() fancy_abort(__LINE__, 0);
409 static void macroexpand
PARAMS ((HASHNODE
*, FILE_BUF
*));
410 static void special_symbol
PARAMS ((HASHNODE
*, FILE_BUF
*));
411 static void dump_all_macros
PARAMS ((void));
412 static void dump_defn_1
PARAMS ((const U_CHAR
*, int, int));
413 static void dump_arg_n
PARAMS ((DEFINITION
*, int));
414 static void conditional_skip
PARAMS ((FILE_BUF
*, int, enum node_type
));
415 static void skip_if_group
PARAMS ((FILE_BUF
*, int));
416 static void output_line_command
PARAMS ((FILE_BUF
*, FILE_BUF
*,
417 int, enum file_change_code
));
419 static int eval_if_expression
PARAMS ((const U_CHAR
*, int));
421 static void output_deps
PARAMS ((void));
422 static void initialize_builtins
PARAMS ((void));
423 static void run_directive
PARAMS ((const char *, size_t,
425 static void make_definition
PARAMS ((const char *));
426 static void make_undef
PARAMS ((const char *));
427 static void make_assertion
PARAMS ((const char *));
429 static void grow_outbuf
PARAMS ((FILE_BUF
*, int));
430 static int handle_directive
PARAMS ((FILE_BUF
*, FILE_BUF
*));
431 static void process_include
PARAMS ((struct file_name_list
*,
432 const U_CHAR
*, int, int, FILE_BUF
*));
433 static void fixup_newlines
PARAMS ((FILE_BUF
*));
434 static void finclude
PARAMS ((int, const char *,
435 struct file_name_list
*, FILE_BUF
*));
436 static void init_dependency_output
PARAMS ((void));
437 static void rescan
PARAMS ((FILE_BUF
*, int));
438 static void newline_fix
PARAMS ((U_CHAR
*));
439 static void name_newline_fix
PARAMS ((U_CHAR
*));
440 static U_CHAR
*macarg1
PARAMS ((U_CHAR
*, const U_CHAR
*, int *,
442 static const char *macarg
PARAMS ((struct argdata
*));
443 static int discard_comments
PARAMS ((U_CHAR
*, int, int));
444 static int file_size_and_mode
PARAMS ((int, int *, long *));
446 static U_CHAR
*skip_to_end_of_comment
PARAMS ((FILE_BUF
*, int *));
447 static U_CHAR
*skip_quoted_string
PARAMS ((const U_CHAR
*, const U_CHAR
*,
448 int, int *, int *, int *));
450 int main
PARAMS ((int, char **));
452 /* Convenience. Write U"string" to get an unsigned string constant. */
453 #define U (const unsigned char *)
455 /* Here is the actual list of #-directives, most-often-used first. */
457 static const struct directive directive_table
[] = {
458 { 6, do_define
, "define", T_DEFINE
},
459 { 7, do_include
, "include", T_INCLUDE
},
460 { 5, do_endif
, "endif", T_ENDIF
},
461 { 5, do_ifdef
, "ifdef", T_IFDEF
},
462 { 2, do_if
, "if", T_IF
, },
463 { 4, do_else
, "else", T_ELSE
},
464 { 6, do_ifndef
, "ifndef", T_IFNDEF
},
465 { 5, do_undef
, "undef", T_UNDEF
},
466 { 4, do_line
, "line", T_LINE
},
467 { 4, do_elif
, "elif", T_ELIF
},
468 { 5, do_error
, "error", T_ERROR
},
469 { 7, do_warning
, "warning", T_WARNING
},
470 { 12, do_include_next
, "include_next", T_INCLUDE_NEXT
},
471 { 6, do_assert
, "assert", T_ASSERT
},
472 { 8, do_unassert
,"unassert",T_UNASSERT
},
473 { -1, 0, "", T_UNUSED
},
476 #define SKIP_WHITE_SPACE(p) do { while (is_nvspace(*p)) p++; } while (0)
477 #define SKIP_ALL_WHITE_SPACE(p) do { while (is_space(*p)) p++; } while (0)
479 int errors
= 0; /* Error counter for exit code */
481 static FILE_BUF expand_to_temp_buffer
PARAMS ((const U_CHAR
*, const U_CHAR
*, int));
482 static DEFINITION
*collect_expansion
PARAMS ((U_CHAR
*, U_CHAR
*, int,
485 /* Stack of conditionals currently in progress
486 (including both successful and failing conditionals). */
489 struct if_stack
*next
; /* for chaining to the next stack frame */
490 const char *fname
; /* copied from input when frame is made */
491 int lineno
; /* similarly */
492 int if_succeeded
; /* true if a leg of this if-group
493 has been passed through rescan */
494 enum node_type type
; /* type of last directive seen in this group */
496 typedef struct if_stack IF_STACK_FRAME
;
497 IF_STACK_FRAME
*if_stack
= NULL
;
499 /* Nonzero means -I- has been seen,
500 so don't look for #include "foo" the source-file directory. */
503 /* Pending directives. */
504 enum pending_dir_t
{PD_NONE
= 0, PD_DEFINE
, PD_UNDEF
, PD_ASSERTION
, PD_FILE
};
506 typedef struct pending_dir pending_dir
;
510 enum pending_dir_t type
;
520 const char *in_fname
, *out_fname
;
523 pending_dir
*pend
= (pending_dir
*) xcalloc (argc
, sizeof (pending_dir
));
524 int no_standard_includes
= 0;
529 /* Get rid of any avoidable limit on stack size. */
533 /* Set the stack limit huge so that alloca (particularly stringtab
534 * in dbxread.c) does not fail. */
535 getrlimit (RLIMIT_STACK
, &rlim
);
536 rlim
.rlim_cur
= rlim
.rlim_max
;
537 setrlimit (RLIMIT_STACK
, &rlim
);
539 #endif /* RLIMIT_STACK defined */
546 no_line_commands
= 0;
550 max_include_len
= cpp_GCC_INCLUDE_DIR_len
+ 7; /* ??? */
554 /* It's simplest to just create this struct whether or not it will
558 /* Process switches and find input file name. */
560 for (i
= 1; i
< argc
; i
++) {
561 if (argv
[i
][0] != '-') {
562 if (out_fname
!= NULL
)
563 fatal ("usage: %s [switches] input output", argv
[0]);
564 else if (in_fname
!= NULL
)
574 break; /* Ignore for compatibility with ISO/extended cpp. */
577 if (!strcmp (argv
[i
], "-lang-c++")
578 || !strcmp (argv
[i
], "-lang-objc++"))
579 fatal ("-traditional is not supported in C++");
580 else if (!strcmp (argv
[i
], "-lang-c89"))
581 fatal ("-traditional and -ansi are mutually exclusive");
582 else if (!strcmp (argv
[i
], "-lang-objc"))
583 pend
[i
].type
= PD_DEFINE
, pend
[i
].arg
= "__OBJC__";
584 else if (!strcmp (argv
[i
], "-lang-asm"))
585 pend
[i
].type
= PD_DEFINE
, pend
[i
].arg
= "__ASSEMBLER__";
586 else if (!strcmp (argv
[i
], "-lang-fortran"))
587 pend
[i
].type
= PD_DEFINE
, pend
[i
].arg
= "_LANGUAGE_FORTRAN";
588 /* All other possibilities ignored. */
592 if (!strcmp (argv
[i
], "-include"))
595 fatal ("filename missing after -i option");
597 pend
[i
].type
= PD_FILE
, pend
[i
].arg
= argv
[i
+ 1], i
++;
599 else if (!strcmp (argv
[i
], "-iprefix"))
600 i
++; /* Ignore for compatibility */
601 else if (!strcmp (argv
[i
], "-isystem")
602 || !strcmp (argv
[i
], "-iwithprefix")
603 || !strcmp (argv
[i
], "-iwithprefixbefore")
604 || !strcmp (argv
[i
], "-idirafter"))
605 goto add_include
; /* best we can do */
610 if (out_fname
!= NULL
)
611 fatal ("output filename specified twice");
613 fatal ("filename missing after -o option");
614 out_fname
= argv
[++i
];
615 if (!strcmp (out_fname
, "-"))
620 inhibit_warnings
= 1;
624 if (!strcmp (argv
[i
], "-Wcomments"))
626 else if (!strcmp (argv
[i
], "-Wcomment"))
628 else if (!strcmp (argv
[i
], "-Wall")) {
634 if (!strcmp (argv
[i
], "-fleading-underscore"))
635 user_label_prefix
= "_";
636 else if (!strcmp (argv
[i
], "-fno-leading-underscore"))
637 user_label_prefix
= "";
638 else if (!strcmp (argv
[i
], "-fsigned-char"))
639 flag_signed_char
= 1;
640 else if (!strcmp (argv
[i
], "-funsigned-char"))
641 flag_signed_char
= 0;
648 /* -MD and -MMD for tradcpp are deprecated and undocumented
649 (use -M or -MM with -MF instead), and probably should be
650 removed with the next major GCC version. For the moment
651 we allow these for the benefit of Automake 1.4, which
652 uses these when dependency tracking is enabled. Automake
653 1.5 will fix this. */
654 if (!strncmp (argv
[i
], "-MD", 3)) {
657 } else if (!strncmp (argv
[i
], "-MMD", 4)) {
660 } else if (!strcmp (argv
[i
], "-M")) {
662 } else if (!strcmp (argv
[i
], "-MM")) {
664 } else if (!strcmp (argv
[i
], "-MG")) {
665 deps_missing_files
= 1;
666 } else if (!strcmp (argv
[i
], "-MF")) {
668 } else if (!strcmp (argv
[i
], "-MP")) {
669 print_deps_phony_targets
= 1;
670 } else if (!strcmp (argv
[i
], "-MQ") || !strcmp (argv
[i
], "-MT")) {
671 /* Add a target. -MQ quotes for Make. */
672 const char *tgt
= argv
[i
] + 3;
673 int quoted
= argv
[i
][2] == 'Q';
675 if (*tgt
== '\0' && i
+ 1 == argc
)
676 fatal ("target missing after %s option", argv
[i
]);
682 deps_add_target (deps
, tgt
, quoted
);
689 else if (i
+ 1 == argc
)
690 fatal ("filename missing after %s option", argv
[i
]);
692 deps_file
= argv
[++i
];
703 fprintf (stderr
, "GNU traditional CPP version %s\n", version_string
);
714 else if (i
+ 1 == argc
)
715 fatal ("macro name missing after -%c option", c
);
720 pend
[i
].type
= PD_DEFINE
;
722 pend
[i
].type
= PD_UNDEF
;
724 pend
[i
].type
= PD_ASSERTION
;
730 put_out_comments
= 1;
734 if (!strcmp (argv
[i
], "-pedantic"))
735 fatal ("-pedantic and -traditional are mutually exclusive");
739 if (!strcmp (argv
[i
], "-trigraphs"))
740 fatal ("-trigraphs and -traditional are mutually exclusive");
744 no_line_commands
= 1;
747 case 'I': /* Add directory to path for includes. */
750 struct file_name_list
*dirtmp
;
752 if (! ignore_srcdir
&& !strcmp (argv
[i
] + 2, "-"))
755 dirtmp
= (struct file_name_list
*)
756 xmalloc (sizeof (struct file_name_list
));
757 dirtmp
->next
= 0; /* New one goes on the end */
761 last_include
->next
= dirtmp
;
762 last_include
= dirtmp
; /* Tail follows the last one */
763 if (argv
[i
][1] == 'I' && argv
[i
][2] != 0)
764 dirtmp
->fname
= argv
[i
] + 2;
765 else if (i
+ 1 == argc
)
766 fatal ("directory name missing after -I option");
768 dirtmp
->fname
= argv
[++i
];
769 if (strlen (dirtmp
->fname
) > max_include_len
)
770 max_include_len
= strlen (dirtmp
->fname
);
771 if (ignore_srcdir
&& first_bracket_include
== 0)
772 first_bracket_include
= dirtmp
;
778 /* -nostdinc causes no default include directories.
779 You must specify all include-file directories with -I. */
780 no_standard_includes
= 1;
783 case '\0': /* JF handle '-' as file name meaning stdin or stdout */
784 if (in_fname
== NULL
) {
787 } else if (out_fname
== NULL
) {
790 } /* else fall through into error */
793 fatal ("invalid option `%s'", argv
[i
]);
798 init_dependency_output ();
800 /* After checking the environment variables, check if -M or -MM has
801 not been specified, but other -M options have. */
803 && (deps_missing_files
|| deps_file
|| print_deps_phony_targets
))
804 fatal ("you must additionally specify either -M or -MM");
806 if (user_label_prefix
== 0)
807 user_label_prefix
= USER_LABEL_PREFIX
;
811 /* Set the default target (if there is none already), and
812 the dependency on the main file. */
813 deps_add_default_target (deps
, in_fname
);
815 deps_add_dep (deps
, in_fname
);
818 /* Install __LINE__, etc. Must follow option processing. */
819 initialize_builtins ();
821 /* Do defines specified with -D and undefines specified with -U. */
822 for (i
= 1; i
< argc
; i
++)
823 if (pend
[i
].type
== PD_DEFINE
)
824 make_definition (pend
[i
].arg
);
825 else if (pend
[i
].type
== PD_UNDEF
)
826 make_undef (pend
[i
].arg
);
827 else if (pend
[i
].type
== PD_ASSERTION
)
828 make_assertion (pend
[i
].arg
);
830 /* Unless -fnostdinc,
831 tack on the standard include file dirs to the specified list */
832 if (!no_standard_includes
) {
833 const struct default_include
*di
;
834 struct file_name_list
*old_last_include
= last_include
;
835 struct file_name_list
*dirtmp
;
836 for (di
= cpp_include_defaults
; di
->fname
; di
++) {
839 dirtmp
= (struct file_name_list
*)
840 xmalloc (sizeof (struct file_name_list
));
841 dirtmp
->next
= 0; /* New one goes on the end */
845 last_include
->next
= dirtmp
;
846 last_include
= dirtmp
; /* Tail follows the last one */
847 dirtmp
->fname
= di
->fname
;
848 if (strlen (dirtmp
->fname
) > max_include_len
)
849 max_include_len
= strlen (dirtmp
->fname
);
852 if (ignore_srcdir
&& first_bracket_include
== 0)
853 first_bracket_include
= old_last_include
->next
;
856 /* Initialize output buffer */
858 outbuf
.buf
= (U_CHAR
*) xmalloc (OUTBUF_SIZE
);
859 outbuf
.bufp
= outbuf
.buf
;
860 outbuf
.length
= OUTBUF_SIZE
;
862 /* Scan the -i files before the main input.
863 Much like #including them, but with no_output set
864 so that only their macro definitions matter. */
868 for (i
= 1; i
< argc
; i
++)
869 if (pend
[i
].type
== PD_FILE
)
871 int fd
= open (pend
[i
].arg
, O_RDONLY
, 0666);
874 perror_with_name (pend
[i
].arg
);
875 return FATAL_EXIT_CODE
;
878 /* For -M, add this file to the dependencies. */
880 deps_add_dep (deps
, pend
[i
].arg
);
882 finclude (fd
, pend
[i
].arg
, 0, &outbuf
);
887 /* Pending directives no longer needed. */
890 /* Create an input stack level for the main input file
891 and copy the entire contents of the file into it. */
893 fp
= &instack
[++indepth
];
895 /* JF check for stdin */
896 if (in_fname
== NULL
|| *in_fname
== 0) {
899 } else if ((f
= open (in_fname
, O_RDONLY
, 0666)) < 0)
902 if (file_size_and_mode (f
, &st_mode
, &st_size
))
904 fp
->fname
= in_fname
;
906 /* JF all this is mine about reading pipes and ttys */
907 if (!S_ISREG (st_mode
)) {
908 /* Read input from a file that is not a normal disk file.
909 We cannot preallocate a buffer with the correct size,
910 so we must read in the file a piece at the time and make it bigger. */
918 fp
->buf
= (U_CHAR
*) xmalloc (bsize
+ 2);
921 cnt
= read (f
, bufp
, bsize
- size
);
922 if (cnt
< 0) goto sys_error
; /* error! */
923 if (cnt
== 0) break; /* End of file */
926 if (bsize
== size
) { /* Buffer is full! */
928 fp
->buf
= (U_CHAR
*) xrealloc (fp
->buf
, bsize
+ 2);
929 bufp
= fp
->buf
+ size
; /* May have moved */
934 /* Read a file whose size we can determine in advance.
935 For the sake of VMS, st_size is just an upper bound. */
938 fp
->buf
= (U_CHAR
*) xmalloc (st_size
+ 2);
940 while (st_size
> 0) {
941 i
= read (f
, fp
->buf
+ fp
->length
, st_size
);
951 fp
->if_stack
= if_stack
;
954 /* Make sure data ends with a newline. And put a null after it. */
956 if (fp
->length
> 0 && fp
->buf
[fp
->length
-1] != '\n')
957 fp
->buf
[fp
->length
++] = '\n';
958 fp
->buf
[fp
->length
] = '\0';
960 /* Now that we know the input file is valid, open the output. */
962 if (!out_fname
|| !strcmp (out_fname
, ""))
963 out_fname
= "stdout";
964 else if (! freopen (out_fname
, "w", stdout
))
965 pfatal_with_name (out_fname
);
967 output_line_command (fp
, &outbuf
, 0, same_file
);
969 /* Scan the input, processing macros and directives. */
973 /* Now we have processed the entire input
974 Write whichever kind of output has been requested. */
979 else if (! inhibit_output
)
980 if (write (fileno (stdout
), outbuf
.buf
, outbuf
.bufp
- outbuf
.buf
) < 0)
981 fatal ("I/O error on output");
983 /* Don't write the deps file if preprocessing has failed. */
984 if (print_deps
&& errors
== 0)
987 /* Destruct the deps object. */
991 fatal ("I/O error on output");
994 exit (FATAL_EXIT_CODE
);
995 exit (SUCCESS_EXIT_CODE
);
998 pfatal_with_name (in_fname
);
1001 /* Set up dependency-file output. */
1003 init_dependency_output ()
1005 char *spec
, *s
, *output_file
;
1007 /* Either of two environment variables can specify output of deps.
1008 Its value is either "OUTPUT_FILE" or "OUTPUT_FILE DEPS_TARGET",
1009 where OUTPUT_FILE is the file to write deps info to
1010 and DEPS_TARGET is the target to mention in the deps. */
1012 if (print_deps
== 0)
1014 spec
= getenv ("DEPENDENCIES_OUTPUT");
1019 spec
= getenv ("SUNPRO_DEPENDENCIES");
1026 /* Find the space before the DEPS_TARGET, if there is one. */
1027 s
= strchr (spec
, ' ');
1030 /* Let the caller perform MAKE quoting. */
1031 deps_add_target (deps
, s
+ 1, 0);
1032 output_file
= (char *) xmalloc (s
- spec
+ 1);
1033 memcpy (output_file
, spec
, s
- spec
);
1034 output_file
[s
- spec
] = 0;
1039 /* Command line overrides environment variables. */
1041 deps_file
= output_file
;
1045 /* If dependencies go to standard output, or -MG is used, we should
1046 suppress output. The user may be requesting other stuff to
1047 stdout, with -dM, -v etc. We let them shoot themselves in the
1049 if (deps_file
== 0 || deps_missing_files
)
1053 /* Use mkdeps.c to output dependency information. */
1057 /* Stream on which to print the dependency information. */
1058 FILE *deps_stream
= 0;
1059 const char *const deps_mode
= deps_append
? "a" : "w";
1062 deps_stream
= stdout
;
1065 deps_stream
= fopen (deps_file
, deps_mode
);
1066 if (deps_stream
== 0)
1068 error_from_errno (deps_file
);
1073 deps_write (deps
, deps_stream
, 72);
1075 if (print_deps_phony_targets
)
1076 deps_phony_targets (deps
, deps_stream
);
1078 /* Don't close stdout. */
1081 if (ferror (deps_stream
) || fclose (deps_stream
) != 0)
1082 fatal ("I/O error on output");
1086 /* Move all backslash-newline pairs out of embarrassing places.
1087 Exchange all such pairs following BP
1088 with any potentially-embarrasing characters that follow them.
1089 Potentially-embarrassing characters are / and *
1090 (because a backslash-newline inside a comment delimiter
1091 would cause it not to be recognized). */
1099 /* First count the backslash-newline pairs here. */
1101 while (*p
++ == '\\' && *p
++ == '\n')
1106 /* Exit if what follows the backslash-newlines is not embarrassing. */
1108 if (count
== 0 || (*p
!= '/' && *p
!= '*'))
1111 /* Copy all potentially embarrassing characters
1112 that follow the backslash-newline pairs
1113 down to where the pairs originally started. */
1115 while (*p
== '*' || *p
== '/')
1118 /* Now write the same number of pairs after the embarrassing chars. */
1119 while (count
-- > 0) {
1125 /* Like newline_fix but for use within a directive-name.
1126 Move any backslash-newlines up past any following symbol constituents. */
1128 name_newline_fix (bp
)
1134 /* First count the backslash-newline pairs here. */
1136 while (*p
++ == '\\' && *p
++ == '\n')
1141 /* What follows the backslash-newlines is not embarrassing. */
1143 if (count
== 0 || !is_idchar (*p
))
1146 /* Copy all potentially embarrassing characters
1147 that follow the backslash-newline pairs
1148 down to where the pairs originally started. */
1150 while (is_idchar (*p
))
1153 /* Now write the same number of pairs after the embarrassing chars. */
1154 while (count
-- > 0) {
1161 * The main loop of the program.
1163 * Read characters from the input stack, transferring them to the
1166 * Macros are expanded and push levels on the input stack.
1167 * At the end of such a level it is popped off and we keep reading.
1168 * At the end of any other kind of level, we return.
1169 * #-directives are handled, except within macros.
1171 * If OUTPUT_MARKS is nonzero, keep Newline markers found in the input
1172 * and insert them when appropriate. This is set while scanning macro
1173 * arguments before substitution. It is zero when scanning for final output.
1174 * There are three types of Newline markers:
1175 * * Newline - follows a macro name that was not expanded
1176 * because it appeared inside an expansion of the same macro.
1177 * This marker prevents future expansion of that identifier.
1178 * When the input is rescanned into the final output, these are deleted.
1179 * These are also deleted by ## concatenation.
1180 * * Newline Space (or Newline and any other whitespace character)
1181 * stands for a place that tokens must be separated or whitespace
1182 * is otherwise desirable, but where the ANSI standard specifies there
1183 * is no whitespace. This marker turns into a Space (or whichever other
1184 * whitespace char appears in the marker) in the final output,
1185 * but it turns into nothing in an argument that is stringified with #.
1186 * Such stringified arguments are the only place where the ANSI standard
1187 * specifies with precision that whitespace may not appear.
1189 * During this function, IP->bufp is kept cached in IBP for speed of access.
1190 * Likewise, OP->bufp is kept in OBP. Before calling a subroutine
1191 * IBP, IP and OBP must be copied back to memory. IP and IBP are
1192 * copied back with the RECACHE macro. OBP must be copied back from OP->bufp
1193 * explicitly, and before RECACHE, since RECACHE uses OBP.
1197 rescan (op
, output_marks
)
1201 /* Character being scanned in main loop. */
1204 /* Length of pending accumulated identifier. */
1205 int ident_length
= 0;
1207 /* Hash code of pending accumulated identifier. */
1210 /* Current input level (&instack[indepth]). */
1213 /* Pointer for scanning input. */
1216 /* Pointer to end of input. End of scan is controlled by LIMIT. */
1219 /* Pointer for storing output. */
1222 /* REDO_CHAR is nonzero if we are processing an identifier
1223 after backing up over the terminating character.
1224 Sometimes we process an identifier without backing up over
1225 the terminating character, if the terminating character
1226 is not special. Backing up is done so that the terminating character
1227 will be dispatched on again once the identifier is dealt with. */
1230 /* 1 if within an identifier inside of which a concatenation
1231 marker (Newline -) has been seen. */
1232 int concatenated
= 0;
1234 /* While scanning a comment or a string constant,
1235 this records the line it started on, for error messages. */
1238 /* Record position of last `real' newline. */
1239 U_CHAR
*beg_of_line
;
1241 /* This has to be a global bacause of RECACHE. */
1242 U_CHAR
*obufp_before_macroname
= NULL
;
1244 /* Pop the innermost input stack level, assuming it is a macro expansion. */
1247 do { ip->macro->type = T_MACRO; \
1248 if (ip->free_ptr) free (ip->free_ptr); \
1249 --indepth; } while (0)
1251 /* Reload `rescan's local variables that describe the current
1252 level of the input stack. */
1255 do { ip = &instack[indepth]; \
1257 limit = ip->buf + ip->length; \
1259 check_expand (op, limit - ibp); \
1261 obufp_before_macroname += op->bufp - obp; \
1262 obp = op->bufp; } while (0)
1264 if (no_output
&& instack
[indepth
].fname
!= 0)
1265 skip_if_group (&instack
[indepth
], 1);
1271 /* Our caller must always put a null after the end of
1272 the input at each input stack level. */
1285 /* Always merge lines ending with backslash-newline,
1286 even in middle of identifier. */
1289 --obp
; /* remove backslash from obuf */
1292 /* Otherwise, backslash suppresses specialness of following char,
1293 so copy it here to prevent the switch from seeing it.
1294 But first get any pending identifier processed. */
1295 if (ident_length
> 0)
1301 /* If this is expanding a macro definition, don't recognize
1302 preprocessor directives. */
1308 /* # keyword: a # must be the first char on the line */
1309 if (beg_of_line
== 0)
1311 if (beg_of_line
+ 1 != ibp
)
1314 /* This # can start a directive. */
1316 --obp
; /* Don't copy the '#' */
1320 if (! handle_directive (ip
, op
)) {
1324 /* Not a known directive: treat it as ordinary text.
1325 IP, OP, IBP, etc. have not been changed. */
1326 if (no_output
&& instack
[indepth
].fname
) {
1327 /* If not generating expanded output,
1328 what we do with ordinary text is skip it.
1329 Discard everything until next # directive. */
1330 skip_if_group (&instack
[indepth
], 1);
1335 ++obp
; /* Copy the '#' after all */
1341 /* A # directive has been successfully processed. */
1342 /* If not generating expanded output, ignore everything until
1343 next # directive. */
1344 if (no_output
&& instack
[indepth
].fname
)
1345 skip_if_group (&instack
[indepth
], 1);
1351 case '\"': /* skip quoted string */
1353 /* A single quoted string is treated like a double -- some
1354 programs (e.g., troff) are perverse this way */
1359 start_line
= ip
->lineno
;
1361 /* Skip ahead to a matching quote. */
1365 if (ip
->macro
!= 0) {
1366 /* try harder: this string crosses a macro expansion boundary */
1378 /* Traditionally, end of line ends a string constant with no error.
1379 So exit the loop and record the new line. */
1387 /* Backslash newline is replaced by nothing at all,
1388 but keep the line counts correct. */
1393 /* ANSI stupidly requires that in \\ the second \
1394 is *not* prevented from combining with a newline. */
1395 while (*ibp
== '\\' && ibp
[1] == '\n') {
1414 if (*ibp
== '\\' && ibp
[1] == '\n')
1416 /* Don't look for comments inside a macro definition. */
1419 /* A comment constitutes white space, so it can terminate an identifier.
1420 Process the identifier, if any. */
1427 /* We have a comment. Skip it, optionally copying it to output. */
1429 start_line
= ip
->lineno
;
1431 ++ibp
; /* Skip the star. */
1433 /* In K+R C, a comment is equivalent to nothing. Note that we
1434 already output the slash; we might not want it. */
1435 if (! put_out_comments
)
1441 U_CHAR
*before_bp
= ibp
;
1443 while (ibp
< limit
) {
1446 if (warn_comments
&& ibp
< limit
&& *ibp
== '*')
1447 warning("`/*' within comment");
1450 if (*ibp
== '\\' && ibp
[1] == '\n')
1452 if (ibp
>= limit
|| *ibp
== '/')
1457 /* Copy the newline into the output buffer, in order to
1458 avoid the pain of a #line every time a multiline comment
1460 if (!put_out_comments
)
1468 error_with_line (line_for_error (start_line
),
1469 "unterminated comment");
1472 if (put_out_comments
) {
1473 memcpy (obp
, before_bp
, ibp
- before_bp
);
1474 obp
+= ibp
- before_bp
;
1480 case '0': case '1': case '2': case '3': case '4':
1481 case '5': case '6': case '7': case '8': case '9':
1482 /* If digit is not part of identifier, it starts a number,
1483 which means that following letters are not an identifier.
1484 "0x5" does not refer to an identifier "x5".
1485 So copy all alphanumerics that follow without accumulating
1486 as an identifier. Periods also, for sake of "3.e7". */
1488 if (ident_length
== 0) {
1489 while (ibp
< limit
) {
1490 while (ibp
< limit
&& ibp
[0] == '\\' && ibp
[1] == '\n') {
1495 if (! ISIDNUM (c
) && c
!= '.') {
1500 /* A sign can be part of a preprocessing number
1501 if it follows an e. */
1502 if (c
== 'e' || c
== 'E') {
1503 while (ibp
< limit
&& ibp
[0] == '\\' && ibp
[1] == '\n') {
1507 if (ibp
< limit
&& (*ibp
== '+' || *ibp
== '-')) {
1509 /* Traditional C does not let the token go past the sign. */
1519 case 'a': case 'b': case 'c': case 'd': case 'e': case 'f':
1520 case 'g': case 'h': case 'i': case 'j': case 'k': case 'l':
1521 case 'm': case 'n': case 'o': case 'p': case 'q': case 'r':
1522 case 's': case 't': case 'u': case 'v': case 'w': case 'x':
1524 case 'A': case 'B': case 'C': case 'D': case 'E': case 'F':
1525 case 'G': case 'H': case 'I': case 'J': case 'K': case 'L':
1526 case 'M': case 'N': case 'O': case 'P': case 'Q': case 'R':
1527 case 'S': case 'T': case 'U': case 'V': case 'W': case 'X':
1530 /* Compute step of hash function, to avoid a proc call on every token */
1531 hash
= HASHSTEP (hash
, c
);
1535 /* If reprocessing a macro expansion, newline is a special marker. */
1536 if (ip
->macro
!= 0) {
1537 /* Newline White is a "funny space" to separate tokens that are
1538 supposed to be separate but without space between.
1539 Here White means any horizontal whitespace character.
1540 Newline - marks a recursive macro use that is not
1541 supposed to be expandable. */
1544 /* Newline - inhibits expansion of preceding token.
1545 If expanding a macro arg, we keep the newline -.
1546 In final output, it is deleted. */
1547 if (! concatenated
) {
1552 if (!output_marks
) {
1555 /* If expanding a macro arg, keep the newline -. */
1558 } else if (is_space (*ibp
)) {
1559 /* Newline Space does not prevent expansion of preceding token
1560 so expand the preceding token and then come back. */
1561 if (ident_length
> 0)
1564 /* If generating final output, newline space makes a space. */
1565 if (!output_marks
) {
1567 /* And Newline Newline makes a newline, so count it. */
1568 if (obp
[-1] == '\n')
1571 /* If expanding a macro arg, keep the newline space.
1572 If the arg gets stringified, newline space makes nothing. */
1575 } else abort (); /* Newline followed by something random? */
1579 /* If there is a pending identifier, handle it and come back here. */
1580 if (ident_length
> 0)
1585 /* Update the line counts and output a #line if necessary. */
1588 if (ip
->lineno
!= op
->lineno
) {
1590 output_line_command (ip
, op
, 1, same_file
);
1591 check_expand (op
, ip
->length
- (ip
->bufp
- ip
->buf
));
1596 /* Come here either after (1) a null character that is part of the input
1597 or (2) at the end of the input, because there is a null there. */
1600 /* Our input really contains a null character. */
1603 /* At end of a macro-expansion level, pop it and read next level. */
1604 if (ip
->macro
!= 0) {
1607 /* If we have an identifier that ends here, process it now, so
1608 we get the right error for recursion. */
1609 if (ident_length
&& ! is_idchar (*instack
[indepth
- 1].bufp
)) {
1618 /* If we don't have a pending identifier,
1619 return at end of input. */
1620 if (ident_length
== 0) {
1628 /* If we do have a pending identifier, just consider this null
1629 a special character and arrange to dispatch on it again.
1630 The second time, IDENT_LENGTH will be zero so we will return. */
1636 /* Handle the case of a character such as /, ', " or null
1637 seen following an identifier. Back over it so that
1638 after the identifier is processed the special char
1639 will be dispatched on again. */
1649 if (ident_length
> 0) {
1652 /* We have just seen an identifier end. If it's a macro, expand it.
1654 IDENT_LENGTH is the length of the identifier
1655 and HASH is its hash code.
1657 The identifier has already been copied to the output,
1658 so if it is a macro we must remove it.
1660 If REDO_CHAR is 0, the char that terminated the identifier
1661 has been skipped in the output and the input.
1662 OBP-IDENT_LENGTH-1 points to the identifier.
1663 If the identifier is a macro, we must back over the terminator.
1665 If REDO_CHAR is 1, the terminating char has already been
1666 backed over. OBP-IDENT_LENGTH points to the identifier. */
1668 for (hp
= hashtab
[MAKE_POS (hash
) % HASHSIZE
]; hp
!= NULL
;
1671 if (hp
->length
== ident_length
) {
1672 /* obufp_before_macroname is used only in this block,
1673 but it has to be global because of RECACHE. */
1674 int op_lineno_before_macroname
;
1675 int i
= ident_length
;
1676 U_CHAR
*p
= hp
->name
;
1677 U_CHAR
*q
= obp
- i
;
1682 do { /* All this to avoid a strncmp () */
1687 /* We found a use of a macro name.
1688 see if the context shows it is a macro call. */
1690 /* Back up over terminating character if not already done. */
1696 obufp_before_macroname
= obp
- ident_length
;
1697 op_lineno_before_macroname
= op
->lineno
;
1699 /* If macro wants an arglist, verify that a '(' follows.
1700 first skip all whitespace, copying it to the output
1701 after the macro name. Then, if there is no '(',
1702 decide this is not a macro call and leave things that way. */
1703 if (hp
->type
== T_MACRO
&& hp
->value
.defn
->nargs
>= 0)
1706 /* Scan forward over whitespace, copying it to the output. */
1707 if (ibp
== limit
&& ip
->macro
!= 0) {
1711 /* A comment: copy it unchanged or discard it. */
1712 else if (*ibp
== '/' && ibp
+1 != limit
&& ibp
[1] == '*') {
1713 if (put_out_comments
) {
1718 while (ibp
+ 1 != limit
1719 && !(ibp
[0] == '*' && ibp
[1] == '/')) {
1720 /* We need not worry about newline-marks,
1721 since they are never found in comments. */
1723 /* Newline in a file. Count it. */
1727 if (put_out_comments
)
1733 if (put_out_comments
) {
1738 else if (is_space (*ibp
)) {
1740 if (ibp
[-1] == '\n') {
1741 if (ip
->macro
== 0) {
1742 /* Newline in a file. Count it. */
1745 } else if (!output_marks
) {
1746 /* A newline mark, and we don't want marks
1747 in the output. If it is newline-hyphen,
1748 discard it entirely. Otherwise, it is
1749 newline-whitechar, so keep the whitechar. */
1759 /* A newline mark; copy both chars to the output. */
1770 /* This is now known to be a macro call.
1771 Discard the macro name from the output,
1772 along with any following whitespace just copied. */
1773 obp
= obufp_before_macroname
;
1774 op
->lineno
= op_lineno_before_macroname
;
1776 /* Expand the macro, reading arguments as needed,
1777 and push the expansion on the input stack. */
1780 macroexpand (hp
, op
);
1782 /* Reexamine input stack, since macroexpand has pushed
1783 a new level on it. */
1790 } /* End hash-table-search loop */
1791 ident_length
= hash
= 0; /* Stop collecting identifier */
1794 } /* End if (ident_length > 0) */
1796 } /* End per-char loop */
1798 /* Come here to return -- but first give an error message
1799 if there was an unterminated successful conditional. */
1801 if (if_stack
!= ip
->if_stack
) {
1803 switch (if_stack
->type
) {
1822 error_with_line (line_for_error (if_stack
->lineno
),
1823 "unterminated #%s conditional", str
);
1825 if_stack
= ip
->if_stack
;
1829 * Rescan a string into a temporary buffer and return the result
1830 * as a FILE_BUF. Note this function returns a struct, not a pointer.
1832 * OUTPUT_MARKS nonzero means keep Newline markers found in the input
1833 * and insert such markers when appropriate. See `rescan' for details.
1834 * OUTPUT_MARKS is 1 for macroexpanding a macro argument separately
1835 * before substitution; it is 0 for other uses.
1838 expand_to_temp_buffer (buf
, limit
, output_marks
)
1839 const U_CHAR
*buf
, *limit
;
1844 int length
= limit
- buf
;
1846 int odepth
= indepth
;
1851 /* Set up the input on the input stack. */
1853 buf1
= (U_CHAR
*) alloca (length
+ 1);
1855 const U_CHAR
*p1
= buf
;
1863 /* Set up to receive the output. */
1865 obuf
.length
= length
* 2 + 100; /* Usually enough. Why be stingy? */
1866 obuf
.bufp
= obuf
.buf
= (U_CHAR
*) xmalloc (obuf
.length
);
1871 CHECK_DEPTH ({return obuf
;});
1875 ip
= &instack
[indepth
];
1879 ip
->length
= length
;
1880 ip
->buf
= ip
->bufp
= buf1
;
1881 ip
->if_stack
= if_stack
;
1883 ip
->lineno
= obuf
.lineno
= 1;
1885 /* Scan the input, create the output. */
1887 rescan (&obuf
, output_marks
);
1889 /* Pop input stack to original state. */
1892 if (indepth
!= odepth
)
1895 /* Record the output. */
1896 obuf
.length
= obuf
.bufp
- obuf
.buf
;
1902 * Process a # directive. Expects IP->bufp to point to the '#', as in
1903 * `#define foo bar'. Passes to the command handler
1904 * (do_define, do_include, etc.): the addresses of the 1st and
1905 * last chars of the command (starting immediately after the #
1906 * keyword), plus op and the keyword table pointer. If the command
1907 * contains comments it is copied into a temporary buffer sans comments
1908 * and the temporary buffer is passed to the command handler instead.
1909 * Likewise for backslash-newlines.
1911 * Returns nonzero if this was a known # directive.
1912 * Otherwise, returns zero, without advancing the input pointer.
1916 handle_directive (ip
, op
)
1920 const struct directive
*kt
;
1924 /* Nonzero means we must copy the entire command
1925 to get rid of comments or backslash-newlines. */
1926 int copy_command
= 0;
1928 U_CHAR
*ident
, *after_ident
;
1931 /* Skip whitespace and \-newline. */
1933 if (is_nvspace (*bp
))
1935 else if (*bp
== '/' && (newline_fix (bp
+ 1), bp
[1]) == '*') {
1937 skip_to_end_of_comment (ip
, &ip
->lineno
);
1939 } else if (*bp
== '\\' && bp
[1] == '\n') {
1940 bp
+= 2; ip
->lineno
++;
1944 /* Now find end of directive name.
1945 If we encounter a backslash-newline, exchange it with any following
1946 symbol-constituents so that we end up with a contiguous name. */
1950 if (is_idchar (*cp
))
1953 if (*cp
== '\\' && cp
[1] == '\n')
1954 name_newline_fix (cp
);
1955 if (is_idchar (*cp
))
1960 ident_length
= cp
- bp
;
1964 /* A line of just `#' becomes blank. */
1966 if (ident_length
== 0 && *after_ident
== '\n') {
1967 ip
->bufp
= after_ident
;
1972 * Decode the keyword and call the appropriate expansion
1973 * routine, after moving the input pointer up to the next line.
1975 for (kt
= directive_table
; kt
->length
> 0; kt
++) {
1976 if (kt
->length
== ident_length
1977 && !strncmp (kt
->name
, (const char *)ident
, ident_length
)) {
1979 U_CHAR
*limit
= ip
->buf
+ ip
->length
;
1980 int unterminated
= 0;
1982 /* Nonzero means do not delete comments within the directive.
1983 #define needs this to detect traditional token paste. */
1984 int keep_comments
= kt
->type
== T_DEFINE
;
1986 /* Find the end of this command (first newline not backslashed
1987 and not in a string or comment).
1988 Set COPY_COMMAND if the command must be copied
1989 (it contains a backslash-newline or a comment). */
1991 buf
= bp
= after_ident
;
1992 while (bp
< limit
) {
2007 bp
= skip_quoted_string (bp
- 1, limit
, ip
->lineno
, &ip
->lineno
, ©_command
, &unterminated
);
2009 /* Traditional preprocessing permits unterminated strings. */
2015 /* <...> is special for #include. */
2017 if (kt
->type
!= T_INCLUDE
)
2019 while (*bp
&& *bp
!= '>') bp
++;
2023 if (*bp
== '\\' && bp
[1] == '\n')
2026 U_CHAR
*obp
= bp
- 1;
2028 skip_to_end_of_comment (ip
, &ip
->lineno
);
2030 /* No need to copy the command because of a comment at the end;
2031 just don't include the comment in the directive. */
2032 if (bp
== limit
|| *bp
== '\n') {
2036 /* Don't remove the comments if this is #define. */
2037 if (! keep_comments
)
2043 --bp
; /* Point to the newline */
2051 resume_p
= ip
->bufp
;
2052 /* BP is the end of the directive.
2053 RESUME_P is the next interesting data after the directive.
2054 A comment may come between. */
2058 /* Need to copy entire command into temp buffer before dispatching */
2060 cp
= (U_CHAR
*) alloca (bp
- buf
+ 5); /* room for cmd plus
2064 /* Copy to the new buffer, deleting comments
2065 and backslash-newlines (and whitespace surrounding the latter). */
2075 /* <...> is special for #include. */
2077 if (kt
->type
!= T_INCLUDE
)
2079 while (xp
< bp
&& c
!= '>') {
2081 if (c
== '\\' && xp
< bp
&& *xp
== '\n')
2092 if (cp
!= buf
&& is_space (cp
[-1])) {
2093 while (cp
!= buf
&& is_space(cp
[-1])) cp
--;
2095 SKIP_WHITE_SPACE (xp
);
2096 } else if (is_nvspace (*xp
)) {
2098 SKIP_WHITE_SPACE (xp
);
2109 = skip_quoted_string (xp
- 1, limit
, ip
->lineno
, 0, 0, 0);
2118 skip_to_end_of_comment (ip
, 0);
2120 while (xp
!= ip
->bufp
)
2122 /* Delete the slash. */
2130 /* Null-terminate the copy. */
2137 ip
->bufp
= resume_p
;
2139 /* Call the appropriate command handler. buf now points to
2140 either the appropriate place in the input buffer, or to
2141 the temp buffer if it was necessary to make one. cp
2142 points to the first char after the contents of the (possibly
2143 copied) command, in either case. */
2144 (*kt
->func
) (buf
, cp
, op
);
2145 check_expand (op
, ip
->length
- (ip
->bufp
- ip
->buf
));
2154 static const char *const
2155 monthnames
[] = {"Jan", "Feb", "Mar", "Apr", "May", "Jun",
2156 "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"};
2159 * expand things like __FILE__. Place the expansion into the output
2160 * buffer *without* rescanning.
2163 special_symbol (hp
, op
)
2171 FILE_BUF
*ip
= NULL
;
2172 static struct tm
*timebuf
= NULL
;
2174 int paren
= 0; /* For special `defined' keyword */
2176 for (i
= indepth
; i
>= 0; i
--)
2177 if (instack
[i
].fname
!= NULL
) {
2182 fatal ("not in any file?!");
2189 if (hp
->type
== T_FILE
)
2192 string
= instack
[0].fname
;
2196 char *tmp
= (char *) alloca (3 + strlen (string
));
2197 sprintf (tmp
, "\"%s\"", string
);
2206 case T_INCLUDE_LEVEL
:
2208 char *tmp
= (char *) alloca (8); /* Eigth bytes ought to be more than enough */
2210 for (i
= indepth
; i
>= 0; i
--)
2211 if (instack
[i
].fname
!= NULL
)
2214 sprintf (tmp
, "%d", true_indepth
- 1);
2221 char *tmp
= (char *) alloca (3 + strlen (version_string
));
2222 sprintf (tmp
, "\"%s\"", version_string
);
2228 buf
= hp
->value
.cpval
;
2233 char *tmp
= (char *) alloca (10);
2234 sprintf (tmp
, "%d", ip
->lineno
);
2242 char *tmp
= (char *) alloca (20);
2244 if (timebuf
== NULL
) {
2246 timebuf
= localtime (&t
);
2248 if (hp
->type
== T_DATE
)
2249 sprintf (tmp
, "\"%s %2d %4d\"", monthnames
[timebuf
->tm_mon
],
2250 timebuf
->tm_mday
, timebuf
->tm_year
+ 1900);
2252 sprintf (tmp
, "\"%02d:%02d:%02d\"", timebuf
->tm_hour
, timebuf
->tm_min
,
2258 case T_SPEC_DEFINED
:
2259 buf
= " 0 "; /* Assume symbol is not defined */
2260 ip
= &instack
[indepth
];
2261 SKIP_WHITE_SPACE (ip
->bufp
);
2262 if (*ip
->bufp
== '(') {
2264 ip
->bufp
++; /* Skip over the paren */
2265 SKIP_WHITE_SPACE (ip
->bufp
);
2268 if (!is_idstart (*ip
->bufp
))
2271 HASHNODE
*hp
= lookup (ip
->bufp
, -1, -1);
2273 if (hp
&& hp
->type
!= T_UNUSED
&& hp
->type
!= T_SPEC_DEFINED
)
2276 while (is_idchar (*ip
->bufp
))
2278 SKIP_WHITE_SPACE (ip
->bufp
);
2280 if (*ip
->bufp
!= ')')
2288 error ("`defined' must be followed by ident or (ident)");
2292 error ("cccp error: invalid special hash type"); /* time for gdb */
2296 check_expand (op
, len
);
2297 memcpy (op
->bufp
, buf
, len
);
2302 /* Routines to handle #directives */
2305 * Process include file by reading it in and calling rescan.
2306 * Expects to see "fname" or <fname> on the input.
2309 do_include (buf
, limit
, op
)
2310 U_CHAR
*buf
, *limit
;
2313 U_CHAR
*fbeg
, *fend
; /* Beginning and end of fname */
2315 struct file_name_list
*stackp
= include
; /* Chain of dirs to search */
2316 struct file_name_list dsp
[1]; /* First in chain, if #include "..." */
2319 int retried
= 0; /* Have already tried macro
2320 expanding the include line*/
2321 FILE_BUF trybuf
; /* It got expanded into here */
2322 int system_header_p
= 0; /* 0 for "...", 1 for <...> */
2327 SKIP_WHITE_SPACE (fbeg
);
2328 /* Discard trailing whitespace so we can easily see
2329 if we have parsed all the significant chars we were given. */
2330 while (limit
!= fbeg
&& is_nvspace (limit
[-1])) limit
--;
2335 while (fend
!= limit
&& *fend
!= '\"')
2337 if (*fend
== '\"' && fend
+ 1 == limit
) {
2340 /* We have "filename". Figure out directory this source
2341 file is coming from and put it on the front of the list. */
2343 /* If -I- was specified, don't search current dir, only spec'd ones. */
2344 if (ignore_srcdir
) break;
2346 for (fp
= &instack
[indepth
]; fp
>= instack
; fp
--)
2349 const char *ep
, *nam
;
2351 if ((nam
= fp
->fname
) != NULL
) {
2352 /* Found a named file. Figure out dir of the file,
2353 and put it in front of the search list. */
2354 dsp
[0].next
= stackp
;
2356 ep
= strrchr (nam
, '/');
2360 f
= (char *) alloca (n
+ 1);
2361 strncpy (f
, nam
, n
);
2364 if (n
> max_include_len
) max_include_len
= n
;
2366 dsp
[0].fname
= 0; /* Current directory */
2377 while (fend
!= limit
&& *fend
!= '>') fend
++;
2378 if (*fend
== '>' && fend
+ 1 == limit
) {
2379 system_header_p
= 1;
2380 /* If -I-, start with the first -I dir after the -I-. */
2381 if (first_bracket_include
)
2382 stackp
= first_bracket_include
;
2390 error ("#include expects \"fname\" or <fname>");
2393 trybuf
= expand_to_temp_buffer (buf
, limit
, 0);
2394 buf
= (U_CHAR
*) alloca (trybuf
.bufp
- trybuf
.buf
+ 1);
2395 memcpy (buf
, trybuf
.buf
, trybuf
.bufp
- trybuf
.buf
);
2396 limit
= buf
+ (trybuf
.bufp
- trybuf
.buf
);
2404 process_include (stackp
, fbeg
, flen
, system_header_p
, op
);
2408 do_include_next (buf
, limit
, op
)
2409 U_CHAR
*buf
, *limit
;
2412 U_CHAR
*fbeg
, *fend
; /* Beginning and end of fname */
2414 struct file_name_list
*stackp
; /* Chain of dirs to search */
2417 int retried
= 0; /* Have already tried macro
2418 expanding the include line*/
2419 FILE_BUF trybuf
; /* It got expanded into here */
2420 int system_header_p
= 0; /* 0 for "...", 1 for <...> */
2422 /* Treat as plain #include if we don't know where to start
2424 stackp
= instack
[indepth
].next_header_dir
;
2427 do_include (buf
, limit
, op
);
2434 SKIP_WHITE_SPACE (fbeg
);
2435 /* Discard trailing whitespace so we can easily see
2436 if we have parsed all the significant chars we were given. */
2437 while (limit
!= fbeg
&& is_nvspace (limit
[-1])) limit
--;
2442 while (fend
!= limit
&& *fend
!= '\"')
2444 if (*fend
== '\"' && fend
+ 1 == limit
)
2450 while (fend
!= limit
&& *fend
!= '>') fend
++;
2451 if (*fend
== '>' && fend
+ 1 == limit
) {
2452 system_header_p
= 1;
2460 error ("#include expects \"fname\" or <fname>");
2463 trybuf
= expand_to_temp_buffer (buf
, limit
, 0);
2464 buf
= (U_CHAR
*) alloca (trybuf
.bufp
- trybuf
.buf
+ 1);
2465 memcpy (buf
, trybuf
.buf
, trybuf
.bufp
- trybuf
.buf
);
2466 limit
= buf
+ (trybuf
.bufp
- trybuf
.buf
);
2474 process_include (stackp
, fbeg
, flen
, system_header_p
, op
);
2478 process_include (stackp
, fbeg
, flen
, system_header_p
, op
)
2479 struct file_name_list
*stackp
;
2482 int system_header_p
;
2486 int f
= -1; /* file number */
2488 fname
= (char *) alloca (max_include_len
+ flen
+ 2);
2489 /* + 2 above for slash and terminating null. */
2491 /* If specified file name is absolute, just open it. */
2493 if (IS_ABSOLUTE_PATHNAME (fbeg
)) {
2494 strncpy (fname
, (const char *)fbeg
, flen
);
2496 f
= open (fname
, O_RDONLY
, 0666);
2498 /* Search directory path, trying to open the file.
2499 Copy each filename tried into FNAME. */
2501 for (; stackp
; stackp
= stackp
->next
) {
2502 if (stackp
->fname
) {
2503 strcpy (fname
, stackp
->fname
);
2504 strcat (fname
, "/");
2505 fname
[strlen (fname
) + flen
] = 0;
2509 strncat (fname
, (const char *)fbeg
, flen
);
2510 if ((f
= open (fname
, O_RDONLY
, 0666)) >= 0)
2516 strncpy (fname
, (const char *)fbeg
, flen
);
2518 if (deps_missing_files
2519 && print_deps
> (system_header_p
|| (system_include_depth
> 0))) {
2521 /* If requested as a system header, assume it belongs in
2522 the first system header directory. */
2523 if (first_bracket_include
)
2524 stackp
= first_bracket_include
;
2528 if (!system_header_p
|| IS_ABSOLUTE_PATHNAME (fbeg
) || !stackp
->fname
)
2529 deps_add_dep (deps
, fname
);
2532 int len
= strlen(stackp
->fname
);
2534 p
= (char *) alloca (len
+ flen
+ 2);
2535 memcpy (p
, stackp
->fname
, len
);
2537 memcpy (p
+ len
, fbeg
, flen
);
2540 deps_add_dep (deps
, p
);
2542 } else if (print_deps
2543 && print_deps
<= (system_header_p
2544 || (system_include_depth
> 0)))
2545 warning ("no include path in which to find %.*s", flen
, fbeg
);
2547 error_from_errno (fname
);
2551 /* Check to see if this include file is a once-only include file.
2554 struct file_name_list
* ptr
;
2556 for (ptr
= dont_repeat_files
; ptr
; ptr
= ptr
->next
) {
2557 if (!strcmp (ptr
->fname
, fname
)) {
2559 return; /* This file was once'd. */
2563 for (ptr
= all_include_files
; ptr
; ptr
= ptr
->next
) {
2564 if (!strcmp (ptr
->fname
, fname
))
2565 break; /* This file was included before. */
2569 /* This is the first time for this file. */
2570 /* Add it to list of files included. */
2572 ptr
= (struct file_name_list
*) xmalloc (sizeof (struct file_name_list
));
2573 ptr
->next
= all_include_files
;
2574 all_include_files
= ptr
;
2575 ptr
->fname
= xstrdup (fname
);
2577 /* For -M, add this file to the dependencies. */
2578 if (print_deps
> (system_header_p
|| (system_include_depth
> 0)))
2579 deps_add_dep (deps
, fname
);
2582 if (system_header_p
)
2583 system_include_depth
++;
2585 /* Actually process the file. */
2586 finclude (f
, fname
, stackp
->next
, op
);
2588 if (system_header_p
)
2589 system_include_depth
--;
2595 /* Replace all CR NL, NL CR and CR sequences with NL. */
2601 U_CHAR
*p
, *q
, *end
;
2603 if (fp
->length
<= 0)
2606 end
= fp
->buf
+ fp
->length
;
2608 p
= (U_CHAR
*) strchr ((const char *) fp
->buf
, '\r');
2613 if (p
> fp
->buf
&& p
[-1] == '\n')
2624 p
+= 1 + (p
[0] + p
[1] == '\n' + '\r');
2629 fp
->length
= q
- fp
->buf
;
2632 /* Process the contents of include file FNAME, already open on descriptor F,
2633 with output to OP. */
2636 finclude (f
, fname
, nhd
, op
)
2639 struct file_name_list
*nhd
;
2645 FILE_BUF
*fp
; /* For input stack frame */
2647 CHECK_DEPTH (return;);
2649 if (file_size_and_mode (f
, &st_mode
, &st_size
))
2652 fp
= &instack
[indepth
+ 1];
2653 memset (fp
, 0, sizeof (FILE_BUF
));
2657 fp
->if_stack
= if_stack
;
2658 fp
->next_header_dir
= nhd
;
2660 if (S_ISREG (st_mode
)) {
2661 fp
->buf
= (U_CHAR
*) xmalloc (st_size
+ 2);
2664 /* Read the file contents, knowing that st_size is an upper bound
2665 on the number of bytes we can read. */
2666 while (st_size
> 0) {
2667 i
= read (f
, fp
->buf
+ fp
->length
, st_size
);
2677 /* Cannot count its file size before reading. */
2684 basep
= (U_CHAR
*) xmalloc (bsize
+ 2);
2688 i
= read (f
, bufp
, bsize
- st_size
);
2690 goto nope
; /* error! */
2692 break; /* End of file */
2695 if (bsize
== st_size
) { /* Buffer is full! */
2697 basep
= (U_CHAR
*) xrealloc (basep
, bsize
+ 2);
2698 bufp
= basep
+ st_size
; /* May have moved */
2703 fp
->length
= st_size
;
2706 fixup_newlines (fp
);
2708 /* Make sure data ends with a newline. And put a null after it. */
2710 if (fp
->length
> 0 && fp
->buf
[fp
->length
-1] != '\n')
2711 fp
->buf
[fp
->length
++] = '\n';
2712 fp
->buf
[fp
->length
] = '\0';
2715 output_line_command (fp
, op
, 0, enter_file
);
2718 instack
[indepth
].lineno
++;
2719 instack
[indepth
].bufp
++; /* Skip the new line. */
2720 output_line_command (&instack
[indepth
], op
, 0, leave_file
);
2725 perror_with_name (fname
);
2730 /* Process a #define command.
2731 BUF points to the contents of the #define command, as a continguous string.
2732 LIMIT points to the first character past the end of the definition.
2733 KEYWORD is the keyword-table entry for #define. */
2736 do_define (buf
, limit
, op
)
2737 U_CHAR
*buf
, *limit
;
2738 FILE_BUF
*op ATTRIBUTE_UNUSED
;
2740 U_CHAR
*bp
; /* temp ptr into input buffer */
2741 U_CHAR
*symname
; /* remember where symbol name starts */
2742 int sym_length
; /* and how long it is */
2745 int arglengths
= 0; /* Accumulate lengths of arg names
2746 plus number of args. */
2751 while (is_nvspace (*bp
))
2754 symname
= bp
; /* remember where it starts */
2755 while (is_idchar (*bp
) && bp
< limit
) {
2758 sym_length
= bp
- symname
;
2759 if (sym_length
== 0)
2761 error ("invalid macro name");
2764 else if (!is_idstart (*symname
)) {
2765 U_CHAR
*msg
; /* what pain... */
2766 msg
= (U_CHAR
*) alloca (sym_length
+ 1);
2767 memcpy (msg
, symname
, sym_length
);
2768 msg
[sym_length
] = 0;
2769 error ("invalid macro name `%s'", msg
);
2772 if (! strncmp ((const char *)symname
, "defined", 7) && sym_length
== 7)
2774 error ("\"defined\" cannot be used as a macro name");
2779 /* lossage will occur if identifiers or control keywords are broken
2780 across lines using backslash. This is not the right place to take
2784 struct arglist
*arg_ptrs
= NULL
;
2787 bp
++; /* skip '(' */
2788 SKIP_WHITE_SPACE (bp
);
2790 /* Loop over macro argument names. */
2791 while (*bp
!= ')') {
2792 struct arglist
*temp
;
2794 temp
= (struct arglist
*) alloca (sizeof (struct arglist
));
2796 temp
->next
= arg_ptrs
;
2797 temp
->argno
= argno
++;
2800 if (!is_idstart (*bp
))
2801 warning ("parameter name starts with a digit in #define");
2803 /* Find the end of the arg name. */
2804 while (is_idchar (*bp
)) {
2807 temp
->length
= bp
- temp
->name
;
2808 arglengths
+= temp
->length
+ 2;
2809 SKIP_WHITE_SPACE (bp
);
2810 if (temp
->length
== 0 || (*bp
!= ',' && *bp
!= ')')) {
2811 error ("badly punctuated parameter list in #define");
2816 SKIP_WHITE_SPACE (bp
);
2819 error ("unterminated parameter list in #define");
2824 ++bp
; /* skip paren */
2825 while (is_nvspace (*bp
) && bp
< limit
) /* and leading whitespace */
2827 /* now everything from bp before limit is the definition. */
2828 defn
= collect_expansion (bp
, limit
, argno
, arg_ptrs
);
2830 /* Now set defn->argnames to the result of concatenating
2831 the argument names in reverse order
2832 with comma-space between them. */
2834 struct arglist
*temp
;
2836 U_CHAR
*tmp
= (U_CHAR
*) xmalloc (arglengths
+ 1);
2838 for (temp
= arg_ptrs
; temp
; temp
= temp
->next
) {
2839 memcpy (&tmp
[i
], temp
->name
, temp
->length
);
2841 if (temp
->next
!= 0) {
2847 defn
->argnames
= tmp
;
2851 /* simple expansion or empty definition; skip leading whitespace */
2852 while (is_nvspace (*bp
) && bp
< limit
)
2854 /* now everything from bp before limit is the definition. */
2855 defn
= collect_expansion (bp
, limit
, -1, 0);
2856 defn
->argnames
= (const U_CHAR
*) "";
2859 hashcode
= hashf (symname
, sym_length
, HASHSIZE
);
2863 if ((hp
= lookup (symname
, sym_length
, hashcode
)) == NULL
)
2864 hp
= install (symname
, sym_length
, T_MACRO
, hashcode
);
2866 if (hp
->type
!= T_MACRO
|| compare_defs (defn
, hp
->value
.defn
))
2867 warning ("\"%.*s\" redefined", sym_length
, symname
);
2869 /* Replace the old definition. */
2873 hp
->value
.defn
= defn
;
2878 * return zero if two DEFINITIONs are isomorphic
2881 compare_defs (d1
, d2
)
2882 DEFINITION
*d1
, *d2
;
2884 struct reflist
*a1
, *a2
;
2885 U_CHAR
*p1
= d1
->expansion
;
2886 U_CHAR
*p2
= d2
->expansion
;
2889 if (d1
->nargs
!= d2
->nargs
)
2891 if (strcmp ((const char *)d1
->argnames
, (const char *)d2
->argnames
))
2893 for (a1
= d1
->pattern
, a2
= d2
->pattern
; a1
&& a2
;
2894 a1
= a1
->next
, a2
= a2
->next
) {
2895 if (!((a1
->nchars
== a2
->nchars
2896 && ! strncmp ((const char *)p1
, (const char *)p2
, a1
->nchars
))
2897 || ! comp_def_part (first
, p1
, a1
->nchars
, p2
, a2
->nchars
, 0))
2898 || a1
->argno
!= a2
->argno
2899 || a1
->stringify
!= a2
->stringify
2900 || a1
->raw_before
!= a2
->raw_before
2901 || a1
->raw_after
!= a2
->raw_after
)
2909 if (comp_def_part (first
, p1
, d1
->length
- (p1
- d1
->expansion
),
2910 p2
, d2
->length
- (p2
- d2
->expansion
), 1))
2915 /* Return 1 if two parts of two macro definitions are effectively different.
2916 One of the parts starts at BEG1 and has LEN1 chars;
2917 the other has LEN2 chars at BEG2.
2918 Any sequence of whitespace matches any other sequence of whitespace.
2919 FIRST means these parts are the first of a macro definition;
2920 so ignore leading whitespace entirely.
2921 LAST means these parts are the last of a macro definition;
2922 so ignore trailing whitespace entirely. */
2924 comp_def_part (first
, beg1
, len1
, beg2
, len2
, last
)
2926 const U_CHAR
*beg1
, *beg2
;
2930 const U_CHAR
*end1
= beg1
+ len1
;
2931 const U_CHAR
*end2
= beg2
+ len2
;
2933 while (beg1
!= end1
&& is_space (*beg1
)) beg1
++;
2934 while (beg2
!= end2
&& is_space (*beg2
)) beg2
++;
2937 while (beg1
!= end1
&& is_space (end1
[-1])) end1
--;
2938 while (beg2
!= end2
&& is_space (end2
[-1])) end2
--;
2940 while (beg1
!= end1
&& beg2
!= end2
) {
2941 if (is_space (*beg1
) && is_space (*beg2
)) {
2942 while (beg1
!= end1
&& is_space (*beg1
)) beg1
++;
2943 while (beg2
!= end2
&& is_space (*beg2
)) beg2
++;
2944 } else if (*beg1
== *beg2
) {
2948 return (beg1
!= end1
) || (beg2
!= end2
);
2951 /* Read a replacement list for a macro with parameters.
2952 Build the DEFINITION structure.
2953 Reads characters of text starting at BUF until LIMIT.
2954 ARGLIST specifies the formal parameters to look for
2955 in the text of the definition; NARGS is the number of args
2956 in that list, or -1 for a macro name that wants no argument list.
2957 MACRONAME is the macro name itself (so we can avoid recursive expansion)
2958 and NAMELEN is its length in characters.
2960 Note that comments and backslash-newlines have already been deleted
2961 from the argument. */
2963 /* Leading and trailing Space, Tab, etc. are converted to markers
2964 Newline Space, Newline Tab, etc.
2965 Newline Space makes a space in the final output
2966 but is discarded if stringified. (Newline Tab is similar but
2967 makes a Tab instead.)
2969 If there is no trailing whitespace, a Newline Space is added at the end
2970 to prevent concatenation that would be contrary to the standard. */
2973 collect_expansion (buf
, end
, nargs
, arglist
)
2976 struct arglist
*arglist
;
2979 U_CHAR
*p
, *limit
, *lastp
, *exp_p
;
2980 struct reflist
*endpat
= NULL
;
2981 /* Pointer to first nonspace after last ## seen. */
2983 /* Pointer to first nonspace after last single-# seen. */
2984 U_CHAR
*stringify
= 0;
2986 int expected_delimiter
= '\0';
2988 /* Scan thru the replacement list, ignoring comments and quoted
2989 strings, picking up on the macro calls. It does a linear search
2990 thru the arg list on every potential symbol. Profiling might say
2991 that something smarter should happen. */
2996 /* Find the beginning of the trailing whitespace. */
2997 /* Find end of leading whitespace. */
3000 while (p
< limit
&& is_space (limit
[-1])) limit
--;
3001 while (p
< limit
&& is_space (*p
)) p
++;
3003 /* Allocate space for the text in the macro definition.
3004 Leading and trailing whitespace chars need 2 bytes each.
3005 Each other input char may or may not need 1 byte,
3006 so this is an upper bound.
3007 The extra 2 are for invented trailing newline-marker and final null. */
3008 maxsize
= (sizeof (DEFINITION
)
3009 + 2 * (end
- limit
) + 2 * (p
- buf
)
3011 defn
= (DEFINITION
*) xcalloc (1, maxsize
);
3013 defn
->nargs
= nargs
;
3014 exp_p
= defn
->expansion
= (U_CHAR
*) defn
+ sizeof (DEFINITION
);
3019 /* Convert leading whitespace to Newline-markers. */
3020 while (p
< limit
&& is_space (*p
)) {
3025 /* Process the main body of the definition. */
3027 int skipped_arg
= 0;
3032 /* In -traditional mode, recognize arguments inside strings and
3033 and character constants, and ignore special properties of #.
3034 Arguments inside strings are considered "stringified", but no
3035 extra quote marks are supplied. */
3039 if (expected_delimiter
!= '\0') {
3040 if (c
== expected_delimiter
)
3041 expected_delimiter
= '\0';
3043 expected_delimiter
= c
;
3047 /* Backslash quotes delimiters and itself, but not macro args. */
3048 if (expected_delimiter
!= 0 && p
< limit
3049 && (*p
== expected_delimiter
|| *p
== '\\')) {
3056 if (expected_delimiter
!= '\0') /* No comments inside strings. */
3059 /* If we find a comment that wasn't removed by handle_directive,
3060 this must be -traditional. So replace the comment with
3064 while (p
< limit
&& !(p
[-2] == '*' && p
[-1] == '/'))
3070 if (is_idchar (c
) && nargs
> 0) {
3071 U_CHAR
*id_beg
= p
- 1;
3075 while (p
!= limit
&& is_idchar (*p
)) p
++;
3076 id_len
= p
- id_beg
;
3078 if (is_idstart (c
)) {
3079 struct arglist
*arg
;
3081 for (arg
= arglist
; arg
!= NULL
; arg
= arg
->next
) {
3082 struct reflist
*tpat
;
3084 if (arg
->name
[0] == c
3085 && arg
->length
== id_len
3086 && strncmp ((const char *)arg
->name
,
3087 (const char *)id_beg
, id_len
) == 0) {
3088 /* make a pat node for this arg and append it to the end of
3090 tpat
= (struct reflist
*) xmalloc (sizeof (struct reflist
));
3092 tpat
->raw_before
= concat
== id_beg
;
3093 tpat
->raw_after
= 0;
3094 tpat
->stringify
= expected_delimiter
!= '\0';
3097 defn
->pattern
= tpat
;
3099 endpat
->next
= tpat
;
3102 tpat
->argno
= arg
->argno
;
3103 tpat
->nchars
= exp_p
- lastp
;
3106 SKIP_WHITE_SPACE (p1
);
3107 if (p1
+ 2 <= limit
&& p1
[0] == '#' && p1
[1] == '#')
3108 tpat
->raw_after
= 1;
3110 lastp
= exp_p
; /* place to start copying from next time */
3117 /* If this was not a macro arg, copy it into the expansion. */
3118 if (! skipped_arg
) {
3123 if (stringify
== id_beg
)
3124 error ("# operator should be followed by a macro argument name");
3130 /* Convert trailing whitespace to Newline-markers. */
3131 while (limit
< end
&& is_space (*limit
)) {
3133 *exp_p
++ = *limit
++;
3138 defn
->length
= exp_p
- defn
->expansion
;
3140 /* Crash now if we overrun the allocated size. */
3141 if (defn
->length
+ 1 > maxsize
)
3148 * interpret #line command. Remembers previously seen fnames
3149 * in its very own hash table.
3151 #define FNAME_HASHSIZE 37
3153 do_line (buf
, limit
, op
)
3154 U_CHAR
*buf
, *limit
;
3158 FILE_BUF
*ip
= &instack
[indepth
];
3161 enum file_change_code file_change
= same_file
;
3163 /* Expand any macros. */
3164 tem
= expand_to_temp_buffer (buf
, limit
, 0);
3166 /* Point to macroexpanded line, which is null-terminated now. */
3168 SKIP_WHITE_SPACE (bp
);
3170 if (!ISDIGIT (*bp
)) {
3171 error ("invalid format #line command");
3175 /* The Newline at the end of this line remains to be processed.
3176 To put the next line at the specified line number,
3177 we must store a line number now that is one less. */
3178 new_lineno
= atoi ((const char *)bp
);
3180 /* skip over the line number. */
3181 while (ISDIGIT (*bp
))
3184 SKIP_WHITE_SPACE (bp
);
3187 static HASHNODE
*fname_table
[FNAME_HASHSIZE
];
3188 HASHNODE
*hp
, **hash_bucket
;
3194 while (*bp
&& *bp
!= '\"')
3197 error ("invalid format #line command");
3201 fname_length
= bp
- fname
;
3204 SKIP_WHITE_SPACE (bp
);
3207 file_change
= enter_file
;
3208 else if (*bp
== '2')
3209 file_change
= leave_file
;
3211 error ("invalid format #line command");
3216 SKIP_WHITE_SPACE (bp
);
3218 error ("invalid format #line command");
3224 &fname_table
[hashf (fname
, fname_length
, FNAME_HASHSIZE
)];
3225 for (hp
= *hash_bucket
; hp
!= NULL
; hp
= hp
->next
)
3226 if (hp
->length
== fname_length
&&
3227 strncmp (hp
->value
.cpval
, (const char *)fname
, fname_length
) == 0) {
3228 ip
->fname
= hp
->value
.cpval
;
3233 /* Didn't find it; cons up a new one. */
3234 hp
= (HASHNODE
*) xcalloc (1, sizeof (HASHNODE
) + fname_length
+ 1);
3235 hp
->next
= *hash_bucket
;
3238 hp
->length
= fname_length
;
3239 ip
->fname
= hp
->value
.cpval
= q
= ((char *) hp
) + sizeof (HASHNODE
);
3240 memcpy (q
, fname
, fname_length
);
3243 error ("invalid format #line command");
3247 ip
->lineno
= new_lineno
;
3248 output_line_command (ip
, op
, 0, file_change
);
3249 ip
->bufp
++; /* Skip the new line. */
3250 check_expand (op
, ip
->length
- (ip
->bufp
- ip
->buf
));
3254 * remove all definitions of symbol from symbol table.
3255 * according to un*x /lib/cpp, it is not an error to undef
3256 * something that has no definitions, so it isn't one here either.
3259 do_undef (buf
, limit
, op
)
3261 U_CHAR
*limit ATTRIBUTE_UNUSED
;
3262 FILE_BUF
*op ATTRIBUTE_UNUSED
;
3266 SKIP_WHITE_SPACE (buf
);
3268 if (! strncmp ((const char *)buf
, "defined", 7) && ! is_idchar (buf
[7]))
3269 warning ("undefining `defined'");
3271 while ((hp
= lookup (buf
, -1, -1)) != NULL
) {
3272 if (hp
->type
!= T_MACRO
)
3273 warning ("undefining `%s'", hp
->name
);
3278 /* Read the tokens of the answer into the macro pool. Only commit the
3279 memory if we intend it as permanent storage, i.e. the #assert case.
3280 Returns 0 on success. */
3283 parse_answer (buf
, limit
, answerp
, type
)
3284 const unsigned char *buf
, *limit
;
3285 struct answer
**answerp
;
3288 const unsigned char *start
;
3290 /* Skip leading whitespace. */
3291 if (buf
< limit
&& *buf
== ' ')
3294 /* Parentheses are optional here. */
3295 if (buf
== limit
&& type
== T_UNASSERT
)
3298 if (buf
== limit
|| *buf
++ != '(')
3303 error ("missing '(' after predicate");
3307 /* Drop whitespace at start. */
3308 while (buf
< limit
&& *buf
== ' ')
3312 while (buf
< limit
&& *buf
!= ')')
3317 error ("missing ')' to complete answer");
3323 error ("predicate's answer is empty");
3327 if ((type
== T_ASSERT
|| type
== T_UNASSERT
) && buf
+ 1 != limit
)
3329 error ("extra text at end of directive");
3333 /* Lose trailing whitespace. */
3337 *answerp
= (struct answer
*) xmalloc (sizeof (struct answer
));
3338 (*answerp
)->answer
= start
;
3339 (*answerp
)->len
= buf
- start
;
3344 /* Parses an assertion, returning a pointer to the hash node of the
3345 predicate, or 0 on error. If an answer was supplied, it is placed
3346 in ANSWERP, otherwise it is set to 0. */
3348 parse_assertion (buf
, limit
, answerp
, type
)
3349 const unsigned char *buf
, *limit
;
3350 struct answer
**answerp
;
3353 HASHNODE
*result
= 0;
3354 const unsigned char *climit
;
3355 unsigned char *bp
, *symname
= canonicalize_text (buf
, limit
, &climit
);
3359 if (bp
< climit
&& is_idstart (*bp
))
3363 while (bp
< climit
&& is_idchar (*bp
));
3370 if (symname
== climit
)
3371 error ("assertion without predicate");
3373 error ("predicate must be an identifier");
3375 /* Unfortunately, because of the way we handle #if, we don't avoid
3376 macro expansion in answers. This is not easy to fix. */
3377 else if (parse_answer (bp
, climit
, answerp
, type
) == 0)
3379 unsigned char *sym
= alloca (len
+ 1);
3382 /* Prefix '#' to get it out of macro namespace. */
3384 memcpy (sym
+ 1, symname
, len
);
3386 hashcode
= hashf (sym
, len
+ 1, HASHSIZE
);
3387 result
= lookup (sym
, len
+ 1, hashcode
);
3389 result
= install (sym
, len
+ 1, T_UNUSED
, hashcode
);
3395 /* Test an assertion within a preprocessor conditional. Returns zero
3396 on error or failure, one on success. */
3398 test_assertion (pbuf
)
3399 unsigned char **pbuf
; /* NUL-terminated. */
3401 unsigned char *buf
= *pbuf
;
3402 unsigned char *limit
= buf
+ strlen ((char *) buf
);
3403 struct answer
*answer
;
3407 node
= parse_assertion (buf
, limit
, &answer
, T_IF
);
3410 result
= (node
->type
== T_ASSERT
&&
3411 (answer
== 0 || *find_answer (node
, answer
) != 0));
3413 /* Yuk. We update pbuf to point after the assertion test.
3414 First, move past the identifier. */
3415 if (is_space (*buf
))
3417 while (is_idchar (*buf
))
3419 /* If we have an answer, we need to move past the parentheses. */
3421 while (*buf
++ != ')')
3429 /* Handle a #error directive. */
3431 do_error (buf
, limit
, op
)
3434 FILE_BUF
*op ATTRIBUTE_UNUSED
;
3436 error ("#error%.*s", (int) (limit
- buf
), buf
);
3439 /* Handle a #warning directive. */
3441 do_warning (buf
, limit
, op
)
3444 FILE_BUF
*op ATTRIBUTE_UNUSED
;
3446 warning ("#warning%.*s", (int) (limit
- buf
), buf
);
3449 /* Handle a #assert directive. */
3451 do_assert (buf
, limit
, op
)
3454 FILE_BUF
*op ATTRIBUTE_UNUSED
;
3456 struct answer
*new_answer
;
3459 node
= parse_assertion (buf
, limit
, &new_answer
, T_ASSERT
);
3462 /* Place the new answer in the answer list. First check there
3463 is not a duplicate. */
3464 new_answer
->next
= 0;
3465 if (node
->type
== T_ASSERT
)
3467 if (*find_answer (node
, new_answer
))
3470 warning ("\"%s\" re-asserted", node
->name
+ 1);
3473 new_answer
->next
= node
->value
.answers
;
3475 node
->type
= T_ASSERT
;
3476 node
->value
.answers
= new_answer
;
3480 /* Function body to be provided later. */
3482 do_unassert (buf
, limit
, op
)
3485 FILE_BUF
*op ATTRIBUTE_UNUSED
;
3488 struct answer
*answer
;
3490 node
= parse_assertion (buf
, limit
, &answer
, T_UNASSERT
);
3491 /* It isn't an error to #unassert something that isn't asserted. */
3494 if (node
->type
== T_ASSERT
)
3498 struct answer
**p
= find_answer (node
, answer
), *temp
;
3500 /* Remove the answer from the list. */
3505 /* Did we free the last answer? */
3506 if (node
->value
.answers
== 0)
3507 delete_macro (node
);
3510 delete_macro (node
);
3517 /* Returns a pointer to the pointer to the answer in the answer chain,
3518 or a pointer to NULL if the answer is not in the chain. */
3519 static struct answer
**
3520 find_answer (node
, candidate
)
3522 const struct answer
*candidate
;
3524 struct answer
**result
;
3526 for (result
= &node
->value
.answers
; *result
; result
= &(*result
)->next
)
3528 struct answer
*answer
= *result
;
3530 if (answer
->len
== candidate
->len
3531 && !memcmp (answer
->answer
, candidate
->answer
, answer
->len
))
3538 /* Return a malloced buffer with leading and trailing whitespace
3539 removed, and all instances of internal whitespace reduced to a
3541 static unsigned char *
3542 canonicalize_text (buf
, limit
, climit
)
3543 const unsigned char *buf
, *limit
, **climit
;
3545 unsigned int len
= limit
- buf
;
3546 unsigned char *result
= (unsigned char *) xmalloc (len
), *dest
;
3548 for (dest
= result
; buf
< limit
;)
3550 if (! is_space (*buf
))
3554 while (++buf
< limit
&& is_space (*buf
))
3556 if (dest
!= result
&& buf
!= limit
)
3566 * handle #if command by
3567 * 1) inserting special `defined' keyword into the hash table
3568 * that gets turned into 0 or 1 by special_symbol (thus,
3569 * if the luser has a symbol called `defined' already, it won't
3570 * work inside the #if command)
3571 * 2) rescan the input into a temporary output buffer
3572 * 3) pass the output buffer to the yacc parser and collect a value
3573 * 4) clean up the mess left from steps 1 and 2.
3574 * 5) call conditional_skip to skip til the next #endif (etc.),
3575 * or not, depending on the value from step 3.
3578 do_if (buf
, limit
, op
)
3579 U_CHAR
*buf
, *limit
;
3580 FILE_BUF
*op ATTRIBUTE_UNUSED
;
3583 FILE_BUF
*ip
= &instack
[indepth
];
3585 value
= eval_if_expression (buf
, limit
- buf
);
3586 conditional_skip (ip
, value
== 0, T_IF
);
3590 * handle a #elif directive by not changing if_stack either.
3591 * see the comment above do_else.
3594 do_elif (buf
, limit
, op
)
3595 U_CHAR
*buf
, *limit
;
3599 FILE_BUF
*ip
= &instack
[indepth
];
3601 if (if_stack
== instack
[indepth
].if_stack
) {
3602 error ("#elif not within a conditional");
3605 if (if_stack
->type
!= T_IF
&& if_stack
->type
!= T_ELIF
) {
3606 error ("#elif after #else");
3607 fprintf (stderr
, " (matches line %d", if_stack
->lineno
);
3608 if (if_stack
->fname
!= NULL
&& ip
->fname
!= NULL
&&
3609 strcmp (if_stack
->fname
, ip
->fname
) != 0)
3610 fprintf (stderr
, ", file %s", if_stack
->fname
);
3611 fprintf (stderr
, ")\n");
3613 if_stack
->type
= T_ELIF
;
3616 if (if_stack
->if_succeeded
)
3617 skip_if_group (ip
, 0);
3619 value
= eval_if_expression (buf
, limit
- buf
);
3621 skip_if_group (ip
, 0);
3623 ++if_stack
->if_succeeded
; /* continue processing input */
3624 output_line_command (ip
, op
, 1, same_file
);
3630 * evaluate a #if expression in BUF, of length LENGTH,
3631 * then parse the result as a C expression and return the value as an int.
3634 eval_if_expression (buf
, length
)
3639 HASHNODE
*save_defined
;
3642 save_defined
= install (U
"defined", -1, T_SPEC_DEFINED
, -1);
3643 temp_obuf
= expand_to_temp_buffer (buf
, buf
+ length
, 0);
3644 delete_macro (save_defined
); /* clean up special symbol */
3646 value
= parse_c_expression ((const char *)temp_obuf
.buf
);
3648 free (temp_obuf
.buf
);
3654 * routine to handle ifdef/ifndef. Try to look up the symbol,
3655 * then do or don't skip to the #endif/#else/#elif depending
3656 * on what directive is actually being processed.
3659 do_xifdef (buf
, limit
, type
)
3660 U_CHAR
*buf
, *limit
;
3661 enum node_type type
;
3664 FILE_BUF
*ip
= &instack
[indepth
];
3667 /* Discard leading and trailing whitespace. */
3668 SKIP_WHITE_SPACE (buf
);
3669 while (limit
!= buf
&& is_nvspace (limit
[-1])) limit
--;
3671 /* Find the end of the identifier at the beginning. */
3672 for (end
= buf
; is_idchar (*end
); end
++);
3675 skip
= (type
== T_IFDEF
);
3677 skip
= (lookup (buf
, end
-buf
, -1) == NULL
) ^ (type
== T_IFNDEF
);
3679 conditional_skip (ip
, skip
, T_IF
);
3683 do_ifdef (buf
, limit
, op
)
3684 U_CHAR
*buf
, *limit
;
3685 FILE_BUF
*op ATTRIBUTE_UNUSED
;
3687 do_xifdef (buf
, limit
, T_IFDEF
);
3691 do_ifndef (buf
, limit
, op
)
3692 U_CHAR
*buf
, *limit
;
3693 FILE_BUF
*op ATTRIBUTE_UNUSED
;
3695 do_xifdef (buf
, limit
, T_IFNDEF
);
3699 * push TYPE on stack; then, if SKIP is nonzero, skip ahead.
3702 conditional_skip (ip
, skip
, type
)
3705 enum node_type type
;
3707 IF_STACK_FRAME
*temp
;
3709 temp
= (IF_STACK_FRAME
*) xcalloc (1, sizeof (IF_STACK_FRAME
));
3710 temp
->fname
= ip
->fname
;
3711 temp
->lineno
= ip
->lineno
;
3712 temp
->next
= if_stack
;
3715 if_stack
->type
= type
;
3718 skip_if_group (ip
, 0);
3721 ++if_stack
->if_succeeded
;
3722 output_line_command (ip
, &outbuf
, 1, same_file
);
3727 * skip to #endif, #else, or #elif. adjust line numbers, etc.
3728 * leaves input ptr at the sharp sign found.
3729 * If ANY is nonzero, return at next directive of any sort.
3732 skip_if_group (ip
, any
)
3736 U_CHAR
*bp
= ip
->bufp
, *cp
;
3737 U_CHAR
*endb
= ip
->buf
+ ip
->length
;
3738 const struct directive
*kt
;
3739 IF_STACK_FRAME
*save_if_stack
= if_stack
; /* don't pop past here */
3740 U_CHAR
*beg_of_line
= bp
;
3744 case '/': /* possible comment */
3745 if (*bp
== '\\' && bp
[1] == '\n')
3749 bp
= skip_to_end_of_comment (ip
, &ip
->lineno
);
3754 bp
= skip_quoted_string (bp
- 1, endb
, ip
->lineno
, &ip
->lineno
, 0, 0);
3757 /* Char after backslash loses its special meaning. */
3760 ++ip
->lineno
; /* But do update the line-count. */
3771 /* # keyword: a # must be first nonblank char on the line */
3772 if (beg_of_line
== 0)
3774 /* Scan from start of line, skipping whitespace, comments
3775 and backslash-newlines, and see if we reach this #.
3776 If not, this # is not special. */
3779 if (is_nvspace (*bp
))
3781 else if (*bp
== '\\' && bp
[1] == '\n')
3783 else if (*bp
== '/' && bp
[1] == '*') {
3785 while (!(*bp
== '*' && bp
[1] == '/')) {
3794 if (bp
!= ip
->bufp
) {
3795 bp
= ip
->bufp
+ 1; /* Reset bp to after the #. */
3799 bp
= ip
->bufp
+ 1; /* Point after '#'. */
3801 /* Skip whitespace and \-newline. */
3803 if (is_nvspace (*bp
))
3805 else if (*bp
== '\\' && bp
[1] == '\n')
3807 else if (*bp
== '/' && bp
[1] == '*') {
3809 while (!(*bp
== '*' && bp
[1] == '/'))
3818 /* Now find end of directive name.
3819 If we encounter a backslash-newline, exchange it with any following
3820 symbol-constituents so that we end up with a contiguous name. */
3823 if (is_idchar (*bp
))
3826 if (*bp
== '\\' && bp
[1] == '\n')
3827 name_newline_fix (bp
);
3828 if (is_idchar (*bp
))
3834 for (kt
= directive_table
; kt
->length
>= 0; kt
++) {
3835 IF_STACK_FRAME
*temp
;
3836 if (strncmp ((const char *)cp
, kt
->name
, kt
->length
) == 0
3837 && !is_idchar (cp
[kt
->length
])) {
3839 /* If we are asked to return on next directive,
3848 temp
= (IF_STACK_FRAME
*) xcalloc (1, sizeof (IF_STACK_FRAME
));
3849 temp
->next
= if_stack
;
3851 temp
->lineno
= ip
->lineno
;
3852 temp
->fname
= ip
->fname
;
3853 temp
->type
= kt
->type
;
3858 if (if_stack
== instack
[indepth
].if_stack
) {
3859 error ("#%s not within a conditional", kt
->name
);
3862 else if (if_stack
== save_if_stack
)
3863 return; /* found what we came for */
3865 if (kt
->type
!= T_ENDIF
) {
3866 if (if_stack
->type
== T_ELSE
)
3867 error ("#else or #elif after #else");
3868 if_stack
->type
= kt
->type
;
3873 if_stack
= if_stack
->next
;
3878 /* Anything else is ignored. */
3887 /* after this returns, rescan will exit because ip->bufp
3888 now points to the end of the buffer.
3889 rescan is responsible for the error message also. */
3893 * handle a #else directive. Do this by just continuing processing
3894 * without changing if_stack ; this is so that the error message
3895 * for missing #endif's etc. will point to the original #if. It
3896 * is possible that something different would be better.
3899 do_else (buf
, limit
, op
)
3900 U_CHAR
*buf ATTRIBUTE_UNUSED
;
3901 U_CHAR
*limit ATTRIBUTE_UNUSED
;
3904 FILE_BUF
*ip
= &instack
[indepth
];
3906 if (if_stack
== instack
[indepth
].if_stack
) {
3907 error ("#else not within a conditional");
3910 if (if_stack
->type
!= T_IF
&& if_stack
->type
!= T_ELIF
) {
3911 error ("#else after #else");
3912 fprintf (stderr
, " (matches line %d", if_stack
->lineno
);
3913 if (strcmp (if_stack
->fname
, ip
->fname
) != 0)
3914 fprintf (stderr
, ", file %s", if_stack
->fname
);
3915 fprintf (stderr
, ")\n");
3917 if_stack
->type
= T_ELSE
;
3920 if (if_stack
->if_succeeded
)
3921 skip_if_group (ip
, 0);
3923 ++if_stack
->if_succeeded
; /* continue processing input */
3924 output_line_command (ip
, op
, 1, same_file
);
3929 * unstack after #endif command
3932 do_endif (buf
, limit
, op
)
3933 U_CHAR
*buf ATTRIBUTE_UNUSED
;
3934 U_CHAR
*limit ATTRIBUTE_UNUSED
;
3937 if (if_stack
== instack
[indepth
].if_stack
)
3938 error ("unbalanced #endif");
3940 IF_STACK_FRAME
*temp
= if_stack
;
3941 if_stack
= if_stack
->next
;
3943 output_line_command (&instack
[indepth
], op
, 1, same_file
);
3948 * Skip a comment, assuming the input ptr immediately follows the
3949 * initial slash-star. Bump line counter as necessary.
3950 * (The canonical line counter is &ip->lineno).
3951 * Don't use this routine (or the next one) if bumping the line
3952 * counter is not sufficient to deal with newlines in the string.
3955 skip_to_end_of_comment (ip
, line_counter
)
3957 int *line_counter
; /* place to remember newlines, or NULL */
3959 U_CHAR
*limit
= ip
->buf
+ ip
->length
;
3960 U_CHAR
*bp
= ip
->bufp
;
3961 FILE_BUF
*op
= &outbuf
; /* JF */
3962 int output
= put_out_comments
&& !line_counter
;
3964 /* JF this line_counter stuff is a crock to make sure the
3965 comment is only put out once, no matter how many times
3966 the comment is skipped. It almost works */
3971 while (bp
< limit
) {
3976 if (warn_comments
&& bp
< limit
&& *bp
== '*')
3977 warning("`/*' within comment");
3980 if (line_counter
!= NULL
)
3986 if (*bp
== '\\' && bp
[1] == '\n')
4002 * Skip over a quoted string. BP points to the opening quote.
4003 * Returns a pointer after the closing quote. Don't go past LIMIT.
4004 * START_LINE is the line number of the starting point (but it need
4005 * not be valid if the starting point is inside a macro expansion).
4007 * The input stack state is not changed.
4009 * If COUNT_NEWLINES is nonzero, it points to an int to increment
4010 * for each newline passed.
4012 * If BACKSLASH_NEWLINES_P is nonzero, store 1 thru it
4013 * if we pass a backslash-newline.
4015 * If EOFP is nonzero, set *EOFP to 1 if the string is unterminated.
4018 skip_quoted_string (bp
, limit
, start_line
, count_newlines
, backslash_newlines_p
, eofp
)
4020 const U_CHAR
*limit
;
4022 int *count_newlines
;
4023 int *backslash_newlines_p
;
4031 error_with_line (line_for_error (start_line
),
4032 "unterminated string or character constant");
4039 while (*bp
== '\\' && bp
[1] == '\n') {
4040 if (backslash_newlines_p
)
4041 *backslash_newlines_p
= 1;
4046 if (*bp
== '\n' && count_newlines
) {
4047 if (backslash_newlines_p
)
4048 *backslash_newlines_p
= 1;
4052 } else if (c
== '\n') {
4053 /* Unterminated strings and character constants are 'legal'. */
4054 bp
--; /* Don't consume the newline. */
4058 } else if (c
== match
)
4061 return (U_CHAR
*) bp
;
4065 * write out a #line command, for instance, after an #include file.
4066 * If CONDITIONAL is nonzero, we can omit the #line if it would
4067 * appear to be a no-op, and we can output a few newlines instead
4068 * if we want to increase the line number by a small amount.
4069 * FILE_CHANGE says whether we are entering a file, leaving, or neither.
4073 output_line_command (ip
, op
, conditional
, file_change
)
4076 enum file_change_code file_change
;
4079 char line_cmd_buf
[500];
4081 if (no_line_commands
4082 || ip
->fname
== NULL
4084 op
->lineno
= ip
->lineno
;
4089 if (ip
->lineno
== op
->lineno
)
4092 /* If the inherited line number is a little too small,
4093 output some newlines instead of a #line command. */
4094 if (ip
->lineno
> op
->lineno
&& ip
->lineno
< op
->lineno
+ 8) {
4095 check_expand (op
, 10);
4096 while (ip
->lineno
> op
->lineno
) {
4104 sprintf (line_cmd_buf
, "# %d \"%s\"", ip
->lineno
, ip
->fname
);
4105 if (file_change
!= same_file
)
4106 strcat (line_cmd_buf
, file_change
== enter_file
? " 1" : " 2");
4107 if (system_include_depth
> 0)
4108 strcat (line_cmd_buf
, " 3");
4109 len
= strlen (line_cmd_buf
);
4110 line_cmd_buf
[len
++] = '\n';
4111 check_expand (op
, len
+ 1);
4112 if (op
->bufp
> op
->buf
&& op
->bufp
[-1] != '\n')
4114 memcpy (op
->bufp
, line_cmd_buf
, len
);
4116 op
->lineno
= ip
->lineno
;
4120 /* Expand a macro call.
4121 HP points to the symbol that is the macro being called.
4122 Put the result of expansion onto the input stack
4123 so that subsequent input by our caller will use it.
4125 If macro wants arguments, caller has already verified that
4126 an argument list follows; arguments come from the input stack. */
4129 macroexpand (hp
, op
)
4134 DEFINITION
*defn
= hp
->value
.defn
;
4137 int start_line
= instack
[indepth
].lineno
;
4139 CHECK_DEPTH (return;);
4141 /* it might not actually be a macro. */
4142 if (hp
->type
!= T_MACRO
) {
4143 special_symbol (hp
, op
);
4147 nargs
= defn
->nargs
;
4151 struct argdata
*args
;
4152 const char *parse_error
= 0;
4154 args
= (struct argdata
*) alloca ((nargs
+ 1) * sizeof (struct argdata
));
4156 for (i
= 0; i
< nargs
; i
++) {
4157 args
[i
].raw
= args
[i
].expanded
= (U_CHAR
*) "";
4158 args
[i
].raw_length
= args
[i
].expand_length
4159 = args
[i
].stringified_length
= 0;
4160 args
[i
].free1
= args
[i
].free2
= 0;
4163 /* Parse all the macro args that are supplied. I counts them.
4164 The first NARGS args are stored in ARGS.
4165 The rest are discarded. */
4168 /* Discard the open-parenthesis or comma before the next arg. */
4169 ++instack
[indepth
].bufp
;
4171 = macarg ((i
< nargs
|| (nargs
== 0 && i
== 0)) ? &args
[i
] : 0);
4174 error_with_line (line_for_error (start_line
), "%s", parse_error
);
4178 } while (*instack
[indepth
].bufp
!= ')');
4180 /* If we got one arg but it was just whitespace, call that 0 args. */
4182 const U_CHAR
*bp
= args
[0].raw
;
4183 const U_CHAR
*lim
= bp
+ args
[0].raw_length
;
4184 while (bp
!= lim
&& is_space (*bp
)) bp
++;
4189 if (nargs
== 0 && i
> 0)
4190 error ("arguments given to macro `%s'", hp
->name
);
4191 else if (i
< nargs
) {
4192 /* traditional C allows foo() if foo wants one argument. */
4193 if (nargs
== 1 && i
== 0)
4196 error ("no args to macro `%s'", hp
->name
);
4198 error ("only 1 arg to macro `%s'", hp
->name
);
4200 error ("only %d args to macro `%s'", i
, hp
->name
);
4201 } else if (i
> nargs
)
4202 error ("too many (%d) args to macro `%s'", i
, hp
->name
);
4204 /* Swallow the closeparen. */
4205 ++instack
[indepth
].bufp
;
4207 /* If macro wants zero args, we parsed the arglist for checking only.
4208 Read directly from the macro definition. */
4210 xbuf
= defn
->expansion
;
4211 xbuf_len
= defn
->length
;
4213 U_CHAR
*exp
= defn
->expansion
;
4214 int offset
; /* offset in expansion,
4215 copied a piece at a time */
4216 int totlen
; /* total amount of exp buffer filled so far */
4220 /* Macro really takes args. Compute the expansion of this call. */
4222 /* Compute length in characters of the macro's expansion. */
4223 xbuf_len
= defn
->length
;
4224 for (ap
= defn
->pattern
; ap
!= NULL
; ap
= ap
->next
) {
4226 xbuf_len
+= args
[ap
->argno
].stringified_length
;
4228 xbuf_len
+= args
[ap
->argno
].raw_length
;
4231 xbuf
= (U_CHAR
*) xmalloc (xbuf_len
+ 1);
4233 /* Generate in XBUF the complete expansion
4234 with arguments substituted in.
4235 TOTLEN is the total size generated so far.
4236 OFFSET is the index in the definition
4237 of where we are copying from. */
4238 offset
= totlen
= 0;
4239 for (ap
= defn
->pattern
; ap
!= NULL
; ap
= ap
->next
) {
4240 struct argdata
*arg
= &args
[ap
->argno
];
4242 for (i
= 0; i
< ap
->nchars
; i
++)
4243 xbuf
[totlen
++] = exp
[offset
++];
4245 if (ap
->stringify
!= 0) {
4246 int arglen
= arg
->raw_length
;
4252 && (c
= arg
->raw
[i
], is_space (c
)))
4255 && (c
= arg
->raw
[arglen
- 1], is_space (c
)))
4257 for (; i
< arglen
; i
++) {
4260 /* Special markers Newline Space
4261 generate nothing for a stringified argument. */
4262 if (c
== '\n' && arg
->raw
[i
+1] != '\n') {
4267 /* Internal sequences of whitespace are replaced by one space
4268 except within an string or char token. */
4270 && (c
== '\n' ? arg
->raw
[i
+1] == '\n' : is_space (c
))) {
4272 /* Note that Newline Space does occur within whitespace
4273 sequences; consider it part of the sequence. */
4274 if (c
== '\n' && is_space (arg
->raw
[i
+1]))
4276 else if (c
!= '\n' && is_space (c
))
4293 } else if (c
== '\"' || c
== '\'')
4297 /* Escape these chars */
4298 if (c
== '\"' || (in_string
&& c
== '\\'))
4299 xbuf
[totlen
++] = '\\';
4303 sprintf ((char *) &xbuf
[totlen
], "\\%03o", (unsigned int) c
);
4308 const U_CHAR
*p1
= arg
->raw
;
4309 const U_CHAR
*l1
= p1
+ arg
->raw_length
;
4311 if (ap
->raw_before
) {
4312 while (p1
!= l1
&& is_space (*p1
)) p1
++;
4313 while (p1
!= l1
&& is_idchar (*p1
))
4314 xbuf
[totlen
++] = *p1
++;
4315 /* Delete any no-reexpansion marker that follows
4316 an identifier at the beginning of the argument
4317 if the argument is concatenated with what precedes it. */
4318 if (p1
[0] == '\n' && p1
[1] == '-')
4321 if (ap
->raw_after
) {
4322 /* Arg is concatenated after: delete trailing whitespace,
4323 whitespace markers, and no-reexpansion markers. */
4325 if (is_space (l1
[-1])) l1
--;
4326 else if (l1
[-1] == '-') {
4327 const U_CHAR
*p2
= l1
- 1;
4328 /* If a `-' is preceded by an odd number of newlines then it
4329 and the last newline are a no-reexpansion marker. */
4330 while (p2
!= p1
&& p2
[-1] == '\n') p2
--;
4331 if ((l1
- 1 - p2
) & 1) {
4339 memmove (xbuf
+ totlen
, p1
, l1
- p1
);
4343 if (totlen
> xbuf_len
)
4347 /* if there is anything left of the definition
4348 after handling the arg list, copy that in too. */
4350 for (i
= offset
; i
< defn
->length
; i
++)
4351 xbuf
[totlen
++] = exp
[i
];
4356 for (i
= 0; i
< nargs
; i
++) {
4357 if (args
[i
].free1
!= 0)
4358 free (args
[i
].free1
);
4359 if (args
[i
].free2
!= 0)
4360 free (args
[i
].free2
);
4364 xbuf
= defn
->expansion
;
4365 xbuf_len
= defn
->length
;
4368 /* Now put the expansion on the input stack
4369 so our caller will commence reading from it. */
4373 ip2
= &instack
[++indepth
];
4378 ip2
->length
= xbuf_len
;
4380 ip2
->free_ptr
= (nargs
> 0) ? xbuf
: 0;
4382 ip2
->if_stack
= if_stack
;
4387 * Parse a macro argument and store the info on it into *ARGPTR.
4388 * Return nonzero to indicate a syntax error.
4393 struct argdata
*argptr
;
4395 FILE_BUF
*ip
= &instack
[indepth
];
4400 /* Try to parse as much of the argument as exists at this
4401 input stack level. */
4402 U_CHAR
*bp
= macarg1 (ip
->bufp
, ip
->buf
+ ip
->length
,
4403 &paren
, &newlines
, &comments
);
4405 /* If we find the end of the argument at this level,
4406 set up *ARGPTR to point at it in the input stack. */
4407 if (!(ip
->fname
!= 0 && (newlines
!= 0 || comments
!= 0))
4408 && bp
!= ip
->buf
+ ip
->length
) {
4410 argptr
->raw
= ip
->bufp
;
4411 argptr
->raw_length
= bp
- ip
->bufp
;
4415 /* This input stack level ends before the macro argument does.
4416 We must pop levels and keep parsing.
4417 Therefore, we must allocate a temporary buffer and copy
4418 the macro argument into it. */
4419 int bufsize
= bp
- ip
->bufp
;
4420 int extra
= newlines
;
4421 U_CHAR
*buffer
= (U_CHAR
*) xmalloc (bufsize
+ extra
+ 1);
4422 int final_start
= 0;
4424 memcpy (buffer
, ip
->bufp
, bufsize
);
4426 ip
->lineno
+= newlines
;
4428 while (bp
== ip
->buf
+ ip
->length
) {
4429 if (instack
[indepth
].macro
== 0) {
4431 return "unterminated macro call";
4433 ip
->macro
->type
= T_MACRO
;
4435 free (ip
->free_ptr
);
4436 ip
= &instack
[--indepth
];
4439 bp
= macarg1 (ip
->bufp
, ip
->buf
+ ip
->length
, &paren
,
4440 &newlines
, &comments
);
4441 final_start
= bufsize
;
4442 bufsize
+= bp
- ip
->bufp
;
4444 buffer
= (U_CHAR
*) xrealloc (buffer
, bufsize
+ extra
+ 1);
4445 memcpy (buffer
+ bufsize
- (bp
- ip
->bufp
), ip
->bufp
, bp
- ip
->bufp
);
4447 ip
->lineno
+= newlines
;
4450 /* Now, if arg is actually wanted, record its raw form,
4451 discarding comments and duplicating newlines in whatever
4452 part of it did not come from a macro expansion.
4453 EXTRA space has been preallocated for duplicating the newlines.
4454 FINAL_START is the index of the start of that part. */
4456 argptr
->raw
= buffer
;
4457 argptr
->raw_length
= bufsize
;
4458 argptr
->free1
= buffer
;
4459 argptr
->newlines
= newlines
;
4460 argptr
->comments
= comments
;
4461 if ((newlines
|| comments
) && ip
->fname
!= 0)
4464 discard_comments (argptr
->raw
+ final_start
,
4465 argptr
->raw_length
- final_start
,
4467 argptr
->raw
[argptr
->raw_length
] = 0;
4468 if (argptr
->raw_length
> bufsize
+ extra
)
4473 /* If we are not discarding this argument,
4474 macroexpand it and compute its length as stringified.
4475 All this info goes into *ARGPTR. */
4479 const U_CHAR
*buf
, *lim
;
4482 obuf
= expand_to_temp_buffer (argptr
->raw
,
4483 argptr
->raw
+ argptr
->raw_length
,
4486 argptr
->expanded
= obuf
.buf
;
4487 argptr
->expand_length
= obuf
.length
;
4488 argptr
->free2
= obuf
.buf
;
4491 lim
= buf
+ argptr
->raw_length
;
4494 while (buf
!= lim
) {
4497 /* Internal sequences of whitespace are replaced by one space
4498 in most cases, but not always. So count all the whitespace
4499 in case we need to keep it all. */
4500 if (c
== '\"' || c
== '\\') /* escape these chars */
4502 else if (!ISPRINT (c
))
4505 argptr
->stringified_length
= totlen
;
4510 /* Scan text from START (inclusive) up to LIMIT (exclusive),
4511 counting parens in *DEPTHPTR,
4512 and return if reach LIMIT
4513 or before a `)' that would make *DEPTHPTR negative
4514 or before a comma when *DEPTHPTR is zero.
4515 Single and double quotes are matched and termination
4516 is inhibited within them. Comments also inhibit it.
4517 Value returned is pointer to stopping place.
4519 Increment *NEWLINES each time a newline is passed.
4520 Set *COMMENTS to 1 if a comment is seen. */
4523 macarg1 (start
, limit
, depthptr
, newlines
, comments
)
4525 const U_CHAR
*limit
;
4526 int *depthptr
, *newlines
, *comments
;
4530 while (bp
< limit
) {
4536 if (--(*depthptr
) < 0)
4540 /* Traditionally, backslash makes following char not special. */
4544 /* But count source lines anyway. */
4553 if (bp
[1] == '\\' && bp
[2] == '\n')
4554 newline_fix (bp
+ 1);
4555 if (bp
[1] != '*' || bp
+ 1 >= limit
)
4559 while (bp
+ 1 < limit
) {
4561 && bp
[1] == '\\' && bp
[2] == '\n')
4562 newline_fix (bp
+ 1);
4563 if (bp
[0] == '*' && bp
[1] == '/')
4565 if (*bp
== '\n') ++*newlines
;
4574 for (quotec
= *bp
++; bp
+ 1 < limit
&& *bp
!= quotec
; bp
++) {
4579 while (*bp
== '\\' && bp
[1] == '\n') {
4582 } else if (*bp
== '\n') {
4591 if ((*depthptr
) == 0)
4601 /* Discard comments and duplicate newlines
4602 in the string of length LENGTH at START,
4603 except inside of string constants.
4604 The string is copied into itself with its beginning staying fixed.
4606 NEWLINES is the number of newlines that must be duplicated.
4607 We assume that that much extra space is available past the end
4611 discard_comments (start
, length
, newlines
)
4618 const U_CHAR
*limit
;
4621 /* If we have newlines to duplicate, copy everything
4622 that many characters up. Then, in the second part,
4623 we will have room to insert the newlines
4625 NEWLINES may actually be too large, because it counts
4626 newlines in string constants, and we don't duplicate those.
4627 But that does no harm. */
4629 ibp
= start
+ length
;
4630 obp
= ibp
+ newlines
;
4632 while (limit
!= ibp
)
4636 ibp
= start
+ newlines
;
4637 limit
= start
+ length
+ newlines
;
4640 while (ibp
< limit
) {
4641 *obp
++ = c
= *ibp
++;
4644 /* Duplicate the newline. */
4656 if (*ibp
== '\\' && ibp
[1] == '\n')
4658 /* Delete any comment. */
4659 if (ibp
[0] != '*' || ibp
+ 1 >= limit
)
4663 while (ibp
+ 1 < limit
) {
4665 && ibp
[1] == '\\' && ibp
[2] == '\n')
4666 newline_fix (ibp
+ 1);
4667 if (ibp
[0] == '*' && ibp
[1] == '/')
4676 /* Notice and skip strings, so that we don't
4677 think that comments start inside them,
4678 and so we don't duplicate newlines in them. */
4681 while (ibp
< limit
) {
4682 *obp
++ = c
= *ibp
++;
4685 if (c
== '\n' && quotec
== '\'')
4687 if (c
== '\\' && ibp
< limit
) {
4688 while (*ibp
== '\\' && ibp
[1] == '\n')
4702 /* Core error handling routine. */
4704 v_message (mtype
, line
, msgid
, ap
)
4710 const char *fname
= 0;
4713 if (mtype
== MT_WARNING
&& inhibit_warnings
)
4716 for (i
= indepth
; i
>= 0; i
--)
4717 if (instack
[i
].fname
!= NULL
) {
4719 line
= instack
[i
].lineno
;
4720 fname
= instack
[i
].fname
;
4725 fprintf (stderr
, "%s:%d: ", fname
, line
);
4727 fprintf (stderr
, "%s: ", progname
);
4729 if (mtype
== MT_WARNING
)
4730 fputs (_("warning: "), stderr
);
4732 vfprintf (stderr
, _(msgid
), ap
);
4733 putc ('\n', stderr
);
4735 if (mtype
== MT_ERROR
)
4740 * error - print error message and increment count of errors.
4743 error
VPARAMS ((const char *msgid
, ...))
4746 VA_FIXEDARG (ap
, const char *, msgid
);
4748 v_message (MT_ERROR
, 0, msgid
, ap
);
4753 error_with_line
VPARAMS ((int line
, const char *msgid
, ...))
4756 VA_FIXEDARG (ap
, int, line
);
4757 VA_FIXEDARG (ap
, const char *, msgid
);
4759 v_message (MT_ERROR
, line
, msgid
, ap
);
4763 /* Error including a message from `errno'. */
4765 error_from_errno (name
)
4768 error ("%s: %s", name
, strerror (errno
));
4771 /* Print error message but don't count it. */
4773 warning
VPARAMS ((const char *msgid
, ...))
4776 VA_FIXEDARG (ap
, const char *, msgid
);
4778 v_message (MT_WARNING
, 0, msgid
, ap
);
4783 fatal
VPARAMS ((const char *msgid
, ...))
4786 VA_FIXEDARG (ap
, const char *, msgid
);
4788 v_message (MT_FATAL
, 0, msgid
, ap
);
4790 exit (FATAL_EXIT_CODE
);
4793 /* More 'friendly' abort that prints the location at which we died. */
4795 fancy_abort (line
, func
)
4799 fatal ("internal error in %s, at tradcpp.c:%d\n\
4800 Please submit a full bug report.\n\
4801 See %s for instructions.", func
, line
, GCCBUGURL
);
4805 perror_with_name (name
)
4808 fprintf (stderr
, "%s: %s: %s\n", progname
, name
, strerror (errno
));
4813 pfatal_with_name (name
)
4816 perror_with_name (name
);
4817 exit (FATAL_EXIT_CODE
);
4820 /* Return the line at which an error occurred.
4821 The error is not necessarily associated with the current spot
4822 in the input stack, so LINE says where. LINE will have been
4823 copied from ip->lineno for the current input level.
4824 If the current level is for a file, we return LINE.
4825 But if the current level is not for a file, LINE is meaningless.
4826 In that case, we return the lineno of the innermost file. */
4828 line_for_error (line
)
4834 for (i
= indepth
; i
>= 0; ) {
4835 if (instack
[i
].fname
!= 0)
4840 line1
= instack
[i
].lineno
;
4846 * If OBUF doesn't have NEEDED bytes after OPTR, make it bigger.
4848 * As things stand, nothing is ever placed in the output buffer to be
4849 * removed again except when it's KNOWN to be part of an identifier,
4850 * so flushing and moving down everything left, instead of expanding,
4855 grow_outbuf (obuf
, needed
)
4862 if (obuf
->length
- (obuf
->bufp
- obuf
->buf
) > needed
)
4865 /* Make it at least twice as big as it is now. */
4867 /* Make it have at least 150% of the free space we will need. */
4868 minsize
= (3 * needed
) / 2 + (obuf
->bufp
- obuf
->buf
);
4869 if (minsize
> obuf
->length
)
4870 obuf
->length
= minsize
;
4872 p
= (U_CHAR
*) xrealloc (obuf
->buf
, obuf
->length
);
4873 obuf
->bufp
= p
+ (obuf
->bufp
- obuf
->buf
);
4877 /* Symbol table for macro names and special symbols */
4880 * install a name in the main hash table, even if it is already there.
4881 * name stops with first non alphanumeric, except leading '#'.
4882 * caller must check against redefinition if that is desired.
4883 * delete_macro () removes things installed by install () in fifo order.
4884 * this is important because of the `defined' special symbol used
4885 * in #if, and also if pushdef/popdef directives are ever implemented.
4887 * If LEN is >= 0, it is the length of the name.
4888 * Otherwise, compute the length by scanning the entire name.
4890 * If HASH is >= 0, it is the precomputed hash code.
4891 * Otherwise, compute the hash code.
4893 * caller must set the value, if any is desired.
4896 install (name
, len
, type
, hash
)
4899 enum node_type type
;
4901 /* watch out here if sizeof (U_CHAR *) != sizeof (int) */
4910 while (is_idchar (*p
))
4916 hash
= hashf (name
, len
, HASHSIZE
);
4918 hp
= (HASHNODE
*) xmalloc (sizeof (HASHNODE
) + len
+ 1);
4920 hp
->bucket_hdr
= &hashtab
[bucket
];
4921 hp
->next
= hashtab
[bucket
];
4922 hashtab
[bucket
] = hp
;
4924 if (hp
->next
!= NULL
)
4925 hp
->next
->prev
= hp
;
4928 hp
->name
= q
= ((U_CHAR
*) hp
) + sizeof (HASHNODE
);
4929 memcpy (q
, name
, len
);
4935 * find the most recent hash node for name name (ending with first
4936 * non-identifier char) installed by install
4938 * If LEN is >= 0, it is the length of the name.
4939 * Otherwise, compute the length by scanning the entire name.
4941 * If HASH is >= 0, it is the precomputed hash code.
4942 * Otherwise, compute the hash code.
4945 lookup (name
, len
, hash
)
4954 for (bp
= name
; is_idchar (*bp
); bp
++) ;
4959 hash
= hashf (name
, len
, HASHSIZE
);
4961 bucket
= hashtab
[hash
];
4963 if (bucket
->length
== len
4964 && strncmp ((const char *)bucket
->name
, (const char *)name
, len
) == 0)
4966 bucket
= bucket
->next
;
4972 * Delete a hash node. Some weirdness to free junk from macros.
4973 * More such weirdness will have to be added if you define more hash
4974 * types that need it.
4977 /* Note that the DEFINITION of a macro is removed from the hash table
4978 but its storage is not freed. This would be a storage leak
4979 except that it is not reasonable to keep undefining and redefining
4980 large numbers of macros many times.
4981 In any case, this is necessary, because a macro can be #undef'd
4982 in the middle of reading the arguments to a call to it.
4983 If #undef freed the DEFINITION, that would crash. */
4989 if (hp
->prev
!= NULL
)
4990 hp
->prev
->next
= hp
->next
;
4991 if (hp
->next
!= NULL
)
4992 hp
->next
->prev
= hp
->prev
;
4994 /* make sure that the bucket chain header that
4995 the deleted guy was on points to the right thing afterwards. */
4996 if (hp
== *hp
->bucket_hdr
)
4997 *hp
->bucket_hdr
= hp
->next
;
5003 * return hash function on name. must be compatible with the one
5004 * computed a step at a time, elsewhere
5007 hashf (name
, len
, hashsize
)
5015 r
= HASHSTEP (r
, *name
++);
5017 return MAKE_POS (r
) % hashsize
;
5020 /* Dump all macro definitions as #defines to stdout. */
5027 for (bucket
= 0; bucket
< HASHSIZE
; bucket
++) {
5030 for (hp
= hashtab
[bucket
]; hp
; hp
= hp
->next
) {
5031 if (hp
->type
== T_MACRO
) {
5032 DEFINITION
*defn
= hp
->value
.defn
;
5038 /* Print the definition of the macro HP. */
5040 printf ("#define %s", hp
->name
);
5041 if (defn
->nargs
>= 0) {
5045 for (i
= 0; i
< defn
->nargs
; i
++) {
5046 dump_arg_n (defn
, i
);
5047 if (i
+ 1 < defn
->nargs
)
5057 for (ap
= defn
->pattern
; ap
!= NULL
; ap
= ap
->next
) {
5058 dump_defn_1 (defn
->expansion
, offset
, ap
->nchars
);
5059 if (ap
->nchars
!= 0)
5061 offset
+= ap
->nchars
;
5064 if (ap
->raw_before
&& !concat
)
5067 dump_arg_n (defn
, ap
->argno
);
5068 if (ap
->raw_after
) {
5073 dump_defn_1 (defn
->expansion
, offset
, defn
->length
- offset
);
5080 /* Output to stdout a substring of a macro definition.
5081 BASE is the beginning of the definition.
5082 Output characters START thru LENGTH.
5083 Discard newlines outside of strings, thus
5084 converting funny-space markers to ordinary spaces. */
5086 dump_defn_1 (base
, start
, length
)
5091 const U_CHAR
*p
= base
+ start
;
5092 const U_CHAR
*limit
= base
+ start
+ length
;
5097 else if (*p
== '\"' || *p
=='\'') {
5098 const U_CHAR
*p1
= skip_quoted_string (p
, limit
, 0, 0, 0, 0);
5099 fwrite (p
, p1
- p
, 1, stdout
);
5106 /* Print the name of argument number ARGNUM of macro definition DEFN.
5107 Recall that DEFN->argnames contains all the arg names
5108 concatenated in reverse order with comma-space in between. */
5110 dump_arg_n (defn
, argnum
)
5114 const U_CHAR
*p
= defn
->argnames
;
5115 while (argnum
+ 1 < defn
->nargs
) {
5116 p
= (const U_CHAR
*) strchr ((const char *)p
, ' ') + 1;
5120 while (*p
&& *p
!= ',') {
5126 /* Initialize the built-in macros. */
5127 #define DSC(x) U x, sizeof x - 1
5128 #define install_spec(name, type) \
5129 install(DSC(name), type, -1);
5130 #define install_value(name, val) \
5131 hp = install(DSC(name), T_CONST, -1); hp->value.cpval = val;
5133 initialize_builtins ()
5137 install_spec ("__BASE_FILE__", T_BASE_FILE
);
5138 install_spec ("__DATE__", T_DATE
);
5139 install_spec ("__FILE__", T_FILE
);
5140 install_spec ("__TIME__", T_TIME
);
5141 install_spec ("__VERSION__", T_VERSION
);
5142 install_spec ("__INCLUDE_LEVEL__", T_INCLUDE_LEVEL
);
5143 install_spec ("__LINE__", T_SPECLINE
);
5145 #ifndef NO_BUILTIN_SIZE_TYPE
5146 install_value ("__SIZE_TYPE__", SIZE_TYPE
);
5148 #ifndef NO_BUILTIN_PTRDIFF_TYPE
5149 install_value ("__PTRDIFF_TYPE__", PTRDIFF_TYPE
);
5151 #ifndef NO_BUILTIN_WCHAR_TYPE
5152 install_value ("__WCHAR_TYPE__", WCHAR_TYPE
);
5154 #ifndef NO_BUILTIN_WINT_TYPE
5155 install_value ("__WINT_TYPE__", WINT_TYPE
);
5157 install_value ("__REGISTER_PREFIX__", REGISTER_PREFIX
);
5158 install_value ("__USER_LABEL_PREFIX__", user_label_prefix
);
5160 if (flag_signed_char
== 0)
5161 install_value ("__CHAR_UNSIGNED__", "1");
5165 #undef install_value
5167 /* Common handler of command line directives -U, -D and -A. */
5169 run_directive (str
, len
, type
)
5172 enum node_type type
;
5174 const struct directive
*kt
;
5175 FILE_BUF
*ip
= &instack
[++indepth
];
5176 ip
->fname
= "*command line*";
5178 ip
->buf
= ip
->bufp
= (U_CHAR
*) str
;
5183 ip
->if_stack
= if_stack
;
5185 for (kt
= directive_table
; kt
->type
!= type
; kt
++)
5188 (*kt
->func
) ((U_CHAR
*) str
, (U_CHAR
*) str
+ len
, NULL
);
5192 /* Handle the -D option. If STR is just an identifier, define it with
5193 * value 1. If STR has anything after the identifier, then it should
5194 * be identifier-space-definition. */
5196 make_definition (str
)
5202 /* Copy the entire option so we can modify it.
5203 Change the first "=" in the string to a space. If there is none,
5204 tack " 1" on the end. */
5206 /* Length including the null. */
5207 count
= strlen (str
);
5208 buf
= (char *) alloca (count
+ 2);
5209 memcpy (buf
, str
, count
);
5211 p
= strchr (str
, '=');
5220 run_directive (buf
, count
, T_DEFINE
);
5223 /* Handle the -U option. */
5228 run_directive (str
, strlen (str
), T_UNDEF
);
5231 /* Handles the #assert (-A) and #unassert (-A-) command line options. */
5233 make_assertion (str
)
5236 enum node_type type
= T_ASSERT
;
5246 count
= strlen (str
);
5247 p
= strchr (str
, '=');
5250 /* Copy the entire option so we can modify it. Change the first
5251 "=" in the string to a '(', and tack a ')' on the end. */
5252 char *buf
= (char *) alloca (count
+ 1);
5254 memcpy (buf
, str
, count
);
5260 run_directive (str
, count
, type
);
5263 /* Get the file-mode and data size of the file open on FD
5264 and store them in *MODE_POINTER and *SIZE_POINTER. */
5267 file_size_and_mode (fd
, mode_pointer
, size_pointer
)
5274 if (fstat (fd
, &sbuf
) < 0) return -1;
5275 if (mode_pointer
) *mode_pointer
= sbuf
.st_mode
;
5276 if (size_pointer
) *size_pointer
= sbuf
.st_size
;