1 /* C Compatible Compiler Preprocessor (CCCP)
2 Copyright (C) 1986, 1987, 1989, 2000 Free Software Foundation, Inc.
3 Written by Paul Rubin, June 1986
4 Adapted to ANSI C, Richard Stallman, Jan 1987
5 Dusted off, polished, and adapted for use as traditional
6 preprocessor only, Zack Weinberg, Jul 2000
8 This program is free software; you can redistribute it and/or modify it
9 under the terms of the GNU General Public License as published by the
10 Free Software Foundation; either version 2, or (at your option) any
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
25 #include "cppdefault.h"
28 typedef unsigned char U_CHAR
;
30 /* Name under which this program was invoked. */
32 static const char *progname
;
34 /* Current maximum length of directory names in the search path
35 for include files. (Altered as we get more of them.) */
37 size_t max_include_len
;
39 /* Nonzero means copy comments into the output file. */
41 int put_out_comments
= 0;
43 /* Nonzero means print the names of included files rather than
44 the preprocessed output. 1 means just the #include "...",
45 2 means #include <...> as well. */
49 /* Nonzero means don't output line number information. */
53 /* Nonzero means inhibit output of the preprocessed text
54 and instead output the definitions of all user-defined macros
55 in a form suitable for use as input to cccp. */
59 /* Nonzero means don't print warning messages. -w. */
61 int inhibit_warnings
= 0;
63 /* Nonzero means warn if slash-star appears in a comment. */
67 /* Nonzero causes output not to be done,
68 but directives such as #define that have side effects
73 /* Value of __USER_LABEL_PREFIX__. Target-dependent, also controlled
74 by -f(no-)leading-underscore. */
75 static const char *user_label_prefix
;
77 /* I/O buffer structure.
78 The `fname' field is nonzero for source files and #include files
79 and for the dummy text used for -D and -U.
80 It is zero for rescanning results of macro expansion
81 and for expanding macro arguments. */
82 #define INPUT_STACK_MAX 200
89 /* Macro that this level is the expansion of.
90 Included so that we can reenable the macro
91 at the end of this level. */
92 struct hashnode
*macro
;
93 /* Value of if_stack at start of this file.
94 Used to prohibit unmatched #endif (etc) in an include file. */
95 struct if_stack
*if_stack
;
96 /* Object to be freed at end of input at this level. */
98 } instack
[INPUT_STACK_MAX
];
100 typedef struct file_buf FILE_BUF
;
102 /* Current nesting level of input sources.
103 `instack[indepth]' is the level currently being read. */
105 #define CHECK_DEPTH(code) \
106 if (indepth >= (INPUT_STACK_MAX - 1)) \
108 error_with_line (line_for_error (instack[indepth].lineno), \
109 "macro or #include recursion too deep"); \
113 /* Current depth in #include directives that use <...>. */
114 int system_include_depth
= 0;
116 /* The output buffer. Its LENGTH field is the amount of room allocated
117 for the buffer, not the number of chars actually present. To get
118 that, subtract outbuf.buf from outbuf.bufp. */
120 #define OUTBUF_SIZE 10 /* initial size of output buffer */
123 /* Grow output buffer OBUF points at
124 so it can hold at least NEEDED more chars. */
126 #define check_expand(OBUF, NEEDED) do { \
127 if ((OBUF)->length - ((OBUF)->bufp - (OBUF)->buf) <= (NEEDED)) \
128 grow_outbuf ((OBUF), (NEEDED)); \
131 struct file_name_list
133 struct file_name_list
*next
;
137 struct file_name_list
*include
= 0; /* First dir to search */
138 /* First dir to search for <file> */
139 struct file_name_list
*first_bracket_include
= 0;
140 struct file_name_list
*last_include
= 0; /* Last in chain */
142 /* List of included files that contained #once. */
143 struct file_name_list
*dont_repeat_files
= 0;
145 /* List of other included files. */
146 struct file_name_list
*all_include_files
= 0;
148 /* Structure allocated for every #define. For a simple replacement
151 nargs = -1, the `pattern' list is null, and the expansion is just
152 the replacement text. Nargs = 0 means a functionlike macro with no args,
154 #define getchar() getc (stdin) .
155 When there are args, the expansion is the replacement text with the
156 args squashed out, and the reflist is a list describing how to
157 build the output from the input: e.g., "3 chars, then the 1st arg,
158 then 9 chars, then the 3rd arg, then 0 chars, then the 2nd arg".
159 The chars here come from the expansion. Whatever is left of the
160 expansion after the last arg-occurrence is copied after that arg.
161 Note that the reflist can be arbitrarily long---
162 its length depends on the number of times the arguments appear in
163 the replacement text, not how many args there are. Example:
164 #define f(x) x+x+x+x+x+x+x would have replacement text "++++++" and
166 { (0, 1), (1, 1), (1, 1), ..., (1, 1), NULL }
167 where (x, y) means (nchars, argno). */
169 typedef struct definition DEFINITION
;
172 int length
; /* length of expansion string */
175 struct reflist
*next
;
176 char stringify
; /* nonzero if this arg was preceded by a
178 char raw_before
; /* Nonzero if a ## operator before arg. */
179 char raw_after
; /* Nonzero if a ## operator after arg. */
180 int nchars
; /* Number of literal chars to copy before
181 this arg occurrence. */
182 int argno
; /* Number of arg to substitute (origin-0) */
184 /* Names of macro args, concatenated in reverse order
185 with comma-space between them.
186 The only use of this is that we warn on redefinition
187 if this differs between the old and new definitions. */
188 const U_CHAR
*argnames
;
191 /* Chained list of answers to an assertion. */
195 const unsigned char *answer
;
199 /* different kinds of things that can appear in the value field
200 of a hash node. Actually, this may be useless now. */
204 struct answer
*answers
;
207 /* The structure of a node in the hash table. The hash table
208 has entries for all tokens defined by #define commands (type T_MACRO),
209 plus some special tokens like __LINE__ (these each have their own
210 type, and the appropriate code is run when that type of node is seen.
211 It does not contain control words like "#define", which are recognized
212 by a separate piece of code. */
214 /* different flavors of hash nodes --- also used in keyword table */
216 T_DEFINE
= 1, /* `#define' */
217 T_INCLUDE
, /* `#include' */
218 T_IFDEF
, /* `#ifdef' */
219 T_IFNDEF
, /* `#ifndef' */
221 T_ELSE
, /* `#else' */
222 T_ELIF
, /* `#elif' */
223 T_UNDEF
, /* `#undef' */
224 T_LINE
, /* `#line' */
225 T_ENDIF
, /* `#endif' */
226 T_ASSERT
, /* `#assert' */
227 T_UNASSERT
, /* `#unassert' */
228 T_SPECLINE
, /* special symbol `__LINE__' */
229 T_DATE
, /* `__DATE__' */
230 T_FILE
, /* `__FILE__' */
231 T_BASE_FILE
, /* `__BASE_FILE__' */
232 T_INCLUDE_LEVEL
, /* `__INCLUDE_LEVEL__' */
233 T_VERSION
, /* `__VERSION__' */
234 T_TIME
, /* `__TIME__' */
235 T_CONST
, /* Constant value, used by `__STDC__' */
236 T_MACRO
, /* macro defined by `#define' */
237 T_SPEC_DEFINED
, /* special `defined' macro for use in #if statements */
238 T_UNUSED
/* Used for something not defined. */
242 struct hashnode
*next
; /* double links for easy deletion */
243 struct hashnode
*prev
;
244 struct hashnode
**bucket_hdr
; /* also, a back pointer to this node's hash
245 chain is kept, in case the node is the head
246 of the chain and gets deleted. */
247 enum node_type type
; /* type of special token */
248 int length
; /* length of token, for quick comparison */
249 U_CHAR
*name
; /* the actual name */
250 union hashval value
; /* pointer to expansion, or whatever */
253 typedef struct hashnode HASHNODE
;
255 static HASHNODE
*parse_assertion
PARAMS ((const unsigned char *,
256 const unsigned char *,
257 struct answer
**, int));
258 static struct answer
**find_answer
PARAMS ((HASHNODE
*,
259 const struct answer
*));
260 static int parse_answer
PARAMS ((const unsigned char *, const unsigned char *,
261 struct answer
**, int));
262 static unsigned char *canonicalize_text
PARAMS ((const unsigned char *,
263 const unsigned char *,
264 const unsigned char **));
266 /* Some definitions for the hash table. The hash function MUST be
267 computed as shown in hashf () below. That is because the rescan
268 loop computes the hash value `on the fly' for most tokens,
269 in order to avoid the overhead of a lot of procedure calls to
270 the hashf () function. Hashf () only exists for the sake of
271 politeness, for use when speed isn't so important. */
273 #define HASHSIZE 1403
274 HASHNODE
*hashtab
[HASHSIZE
];
275 #define HASHSTEP(old, c) ((old << 2) + c)
276 #define MAKE_POS(v) (v & 0x7fffffff) /* make number positive */
278 /* `struct directive' defines one #-directive, including how to handle it. */
281 int length
; /* Length of name */
282 void (*func
) PARAMS ((U_CHAR
*, U_CHAR
*, FILE_BUF
*));
283 /* Function to handle directive */
284 const char *name
; /* Name of directive */
285 enum node_type type
; /* Code which describes which directive. */
288 /* Last arg to output_line_command. */
289 enum file_change_code
{same_file
, enter_file
, leave_file
};
291 /* This structure represents one parsed argument in a macro call.
292 `raw' points to the argument text as written (`raw_length' is its length).
293 `expanded' points to the argument's macro-expansion
294 (its length is `expand_length').
295 `stringified_length' is the length the argument would have
297 `free1' and `free2', if nonzero, point to blocks to be freed
298 when the macro argument data is no longer needed. */
301 U_CHAR
*raw
, *expanded
;
302 int raw_length
, expand_length
;
303 int stringified_length
;
304 U_CHAR
*free1
, *free2
;
309 /* The arglist structure is built by do_define to tell
310 collect_definition where the argument names begin. That
311 is, for a define like "#define f(x,y,z) foo+x-bar*y", the arglist
312 would contain pointers to the strings x, y, and z.
313 Collect_definition would then build a DEFINITION node,
314 with reflist nodes pointing to the places x, y, and z had
315 appeared. So the arglist is just convenience data passed
316 between these two routines. It is not kept around after
317 the current #define has been processed and entered into the
321 struct arglist
*next
;
327 /* Function prototypes. */
329 static void do_define
PARAMS ((U_CHAR
*, U_CHAR
*, FILE_BUF
*));
330 static void do_line
PARAMS ((U_CHAR
*, U_CHAR
*, FILE_BUF
*));
331 static void do_include
PARAMS ((U_CHAR
*, U_CHAR
*, FILE_BUF
*));
332 static void do_undef
PARAMS ((U_CHAR
*, U_CHAR
*, FILE_BUF
*));
333 static void do_if
PARAMS ((U_CHAR
*, U_CHAR
*, FILE_BUF
*));
334 static void do_ifdef
PARAMS ((U_CHAR
*, U_CHAR
*, FILE_BUF
*));
335 static void do_ifndef
PARAMS ((U_CHAR
*, U_CHAR
*, FILE_BUF
*));
336 static void do_else
PARAMS ((U_CHAR
*, U_CHAR
*, FILE_BUF
*));
337 static void do_elif
PARAMS ((U_CHAR
*, U_CHAR
*, FILE_BUF
*));
338 static void do_endif
PARAMS ((U_CHAR
*, U_CHAR
*, FILE_BUF
*));
339 static void do_assert
PARAMS ((U_CHAR
*, U_CHAR
*, FILE_BUF
*));
340 static void do_unassert
PARAMS ((U_CHAR
*, U_CHAR
*, FILE_BUF
*));
341 static void do_xifdef
PARAMS ((U_CHAR
*, U_CHAR
*, enum node_type
));
343 static struct hashnode
*install
PARAMS ((const U_CHAR
*, int, enum node_type
, int));
344 static int hashf
PARAMS ((const U_CHAR
*, int, int));
345 static int compare_defs
PARAMS ((DEFINITION
*, DEFINITION
*));
346 static int comp_def_part
PARAMS ((int, const U_CHAR
*, int,
347 const U_CHAR
*, int, int));
348 static void delete_macro
PARAMS ((HASHNODE
*));
350 /* First arg to v_message. */
351 enum msgtype
{ WARNING
= 0, ERROR
, FATAL
};
352 static void v_message
PARAMS ((enum msgtype mtype
, int line
,
353 const char *msgid
, va_list ap
))
354 ATTRIBUTE_PRINTF (3, 0);
356 static int line_for_error
PARAMS ((int));
358 /* We know perfectly well which file this is, so we don't need to
361 #if (GCC_VERSION >= 2007)
362 #define abort() fancy_abort(__LINE__, __FUNCTION__)
364 #define abort() fancy_abort(__LINE__, 0);
367 static void macroexpand
PARAMS ((HASHNODE
*, FILE_BUF
*));
368 static void special_symbol
PARAMS ((HASHNODE
*, FILE_BUF
*));
369 static void dump_all_macros
PARAMS ((void));
370 static void dump_defn_1
PARAMS ((const U_CHAR
*, int, int));
371 static void dump_arg_n
PARAMS ((DEFINITION
*, int));
372 static void conditional_skip
PARAMS ((FILE_BUF
*, int, enum node_type
));
373 static void skip_if_group
PARAMS ((FILE_BUF
*, int));
374 static void output_line_command
PARAMS ((FILE_BUF
*, FILE_BUF
*,
375 int, enum file_change_code
));
377 static int eval_if_expression
PARAMS ((const U_CHAR
*, int));
379 static void initialize_char_syntax
PARAMS ((void));
380 static void initialize_builtins
PARAMS ((void));
381 static void run_directive
PARAMS ((const char *, size_t,
383 static void make_definition
PARAMS ((const char *));
384 static void make_undef
PARAMS ((const char *));
385 static void make_assertion
PARAMS ((const char *));
387 static void grow_outbuf
PARAMS ((FILE_BUF
*, int));
388 static int handle_directive
PARAMS ((FILE_BUF
*, FILE_BUF
*));
389 static void finclude
PARAMS ((int, const char *, FILE_BUF
*));
390 static void deps_output
PARAMS ((const char *, int));
391 static void rescan
PARAMS ((FILE_BUF
*, int));
392 static void newline_fix
PARAMS ((U_CHAR
*));
393 static void name_newline_fix
PARAMS ((U_CHAR
*));
394 static U_CHAR
*macarg1
PARAMS ((U_CHAR
*, const U_CHAR
*, int *,
396 static const char *macarg
PARAMS ((struct argdata
*));
397 static int discard_comments
PARAMS ((U_CHAR
*, int, int));
398 static int file_size_and_mode
PARAMS ((int, int *, long *));
400 static U_CHAR
*skip_to_end_of_comment
PARAMS ((FILE_BUF
*, int *));
401 static U_CHAR
*skip_quoted_string
PARAMS ((const U_CHAR
*, const U_CHAR
*,
402 int, int *, int *, int *));
404 int main
PARAMS ((int, char **));
406 /* Convenience. Write U"string" to get an unsigned string constant. */
407 #define U (const unsigned char *)
409 /* Here is the actual list of #-directives, most-often-used first. */
411 struct directive directive_table
[] = {
412 { 6, do_define
, "define", T_DEFINE
},
413 { 7, do_include
, "include", T_INCLUDE
},
414 { 5, do_endif
, "endif", T_ENDIF
},
415 { 5, do_ifdef
, "ifdef", T_IFDEF
},
416 { 2, do_if
, "if", T_IF
, },
417 { 4, do_else
, "else", T_ELSE
},
418 { 6, do_ifndef
, "ifndef", T_IFNDEF
},
419 { 5, do_undef
, "undef", T_UNDEF
},
420 { 4, do_line
, "line", T_LINE
},
421 { 4, do_elif
, "elif", T_ELIF
},
422 { 6, do_assert
, "assert", T_ASSERT
},
423 { 8, do_unassert
,"unassert",T_UNASSERT
},
424 { -1, 0, "", T_UNUSED
},
427 /* table to tell if char can be part of a C identifier. */
428 U_CHAR is_idchar
[256];
429 /* table to tell if char can be first char of a c identifier. */
430 U_CHAR is_idstart
[256];
431 /* table to tell if c is horizontal space. */
432 U_CHAR is_hor_space
[256];
433 /* table to tell if c is horizontal or vertical space. */
434 U_CHAR is_space
[256];
436 #define SKIP_WHITE_SPACE(p) do { while (is_hor_space[*p]) p++; } while (0)
437 #define SKIP_ALL_WHITE_SPACE(p) do { while (is_space[*p]) p++; } while (0)
439 int errors
= 0; /* Error counter for exit code */
441 static FILE_BUF expand_to_temp_buffer
PARAMS ((const U_CHAR
*, const U_CHAR
*, int));
442 static DEFINITION
*collect_expansion
PARAMS ((U_CHAR
*, U_CHAR
*, int,
445 /* Stack of conditionals currently in progress
446 (including both successful and failing conditionals). */
449 struct if_stack
*next
; /* for chaining to the next stack frame */
450 const char *fname
; /* copied from input when frame is made */
451 int lineno
; /* similarly */
452 int if_succeeded
; /* true if a leg of this if-group
453 has been passed through rescan */
454 enum node_type type
; /* type of last directive seen in this group */
456 typedef struct if_stack IF_STACK_FRAME
;
457 IF_STACK_FRAME
*if_stack
= NULL
;
459 /* Buffer of -M output. */
463 /* Number of bytes allocated in above. */
464 int deps_allocated_size
;
466 /* Number of bytes used. */
469 /* Number of bytes since the last newline. */
472 /* Nonzero means -I- has been seen,
473 so don't look for #include "foo" the source-file directory. */
476 /* Pending directives. */
477 enum pending_dir_t
{PD_NONE
= 0, PD_DEFINE
, PD_UNDEF
, PD_ASSERTION
, PD_FILE
};
479 typedef struct pending_dir pending_dir
;
483 enum pending_dir_t type
;
493 const char *in_fname
, *out_fname
;
496 pending_dir
*pend
= (pending_dir
*) xcalloc (argc
, sizeof (pending_dir
));
497 int no_standard_includes
= 0;
499 /* Non-0 means don't output the preprocessed program. */
500 int inhibit_output
= 0;
502 /* Stream on which to print the dependency information. */
503 FILE *deps_stream
= 0;
504 /* Target-name to write with the dependency information. */
505 char *deps_target
= 0;
508 /* Get rid of any avoidable limit on stack size. */
512 /* Set the stack limit huge so that alloca (particularly stringtab
513 * in dbxread.c) does not fail. */
514 getrlimit (RLIMIT_STACK
, &rlim
);
515 rlim
.rlim_cur
= rlim
.rlim_max
;
516 setrlimit (RLIMIT_STACK
, &rlim
);
518 #endif /* RLIMIT_STACK defined */
525 /* Initialize is_idchar to allow $. */
526 initialize_char_syntax ();
528 no_line_commands
= 0;
532 max_include_len
= cpp_GCC_INCLUDE_DIR_len
+ 7; /* ??? */
534 /* Process switches and find input file name. */
536 for (i
= 1; i
< argc
; i
++) {
537 if (argv
[i
][0] != '-') {
538 if (out_fname
!= NULL
)
539 fatal ("Usage: %s [switches] input output", argv
[0]);
540 else if (in_fname
!= NULL
)
551 break; /* Ignore for compatibility with ISO/extended cpp. */
554 if (!strcmp (argv
[i
], "-lang-c++")
555 || !strcmp (argv
[i
], "-lang-objc++"))
556 fatal ("-traditional is not supported in C++");
557 else if (!strcmp (argv
[i
], "-lang-c89"))
558 fatal ("-traditional and -ansi are mutually exclusive");
559 else if (!strcmp (argv
[i
], "-lang-objc"))
560 pend
[i
].type
= PD_DEFINE
, pend
[i
].arg
= "__OBJC__";
561 else if (!strcmp (argv
[i
], "-lang-asm"))
562 pend
[i
].type
= PD_DEFINE
, pend
[i
].arg
= "__ASSEMBLER__";
563 else if (!strcmp (argv
[i
], "-lang-fortran"))
564 pend
[i
].type
= PD_DEFINE
, pend
[i
].arg
= "_LANGUAGE_FORTRAN";
565 /* All other possibilities ignored. */
569 if (!strcmp (argv
[i
], "-include"))
572 fatal ("Filename missing after -i option");
574 pend
[i
].type
= PD_FILE
, pend
[i
].arg
= argv
[i
+ 1], i
++;
576 else if (!strcmp (argv
[i
], "-iprefix"))
577 i
++; /* Ignore for compatibility */
578 else if (!strcmp (argv
[i
], "-isystem")
579 || !strcmp (argv
[i
], "-iwithprefix")
580 || !strcmp (argv
[i
], "-iwithprefixbefore")
581 || !strcmp (argv
[i
], "-idirafter"))
582 goto add_include
; /* best we can do */
587 if (out_fname
!= NULL
)
588 fatal ("Output filename specified twice");
590 fatal ("Filename missing after -o option");
591 out_fname
= argv
[++i
];
592 if (!strcmp (out_fname
, "-"))
597 inhibit_warnings
= 1;
601 if (!strcmp (argv
[i
], "-Wcomments"))
603 else if (!strcmp (argv
[i
], "-Wcomment"))
605 else if (!strcmp (argv
[i
], "-Wall")) {
611 if (!strcmp (argv
[i
], "-fleading-underscore"))
612 user_label_prefix
= "_";
613 else if (!strcmp (argv
[i
], "-fno-leading-underscore"))
614 user_label_prefix
= "";
618 if (!strcmp (argv
[i
], "-M"))
620 else if (!strcmp (argv
[i
], "-MM"))
631 fprintf (stderr
, "GNU traditional CPP version %s\n", version_string
);
642 else if (i
+ 1 == argc
)
643 fatal ("Macro name missing after -%c option", c
);
648 pend
[i
].type
= PD_DEFINE
;
650 pend
[i
].type
= PD_UNDEF
;
652 pend
[i
].type
= PD_ASSERTION
;
658 put_out_comments
= 1;
662 if (!strcmp (argv
[i
], "-pedantic"))
663 fatal ("-pedantic and -traditional are mutually exclusive");
667 if (!strcmp (argv
[i
], "-trigraphs"))
668 fatal ("-trigraphs and -traditional are mutually exclusive");
672 no_line_commands
= 1;
675 case 'I': /* Add directory to path for includes. */
678 struct file_name_list
*dirtmp
;
680 if (! ignore_srcdir
&& !strcmp (argv
[i
] + 2, "-"))
683 dirtmp
= (struct file_name_list
*)
684 xmalloc (sizeof (struct file_name_list
));
685 dirtmp
->next
= 0; /* New one goes on the end */
689 last_include
->next
= dirtmp
;
690 last_include
= dirtmp
; /* Tail follows the last one */
691 if (argv
[i
][1] == 'I' && argv
[i
][2] != 0)
692 dirtmp
->fname
= argv
[i
] + 2;
693 else if (i
+ 1 == argc
)
694 fatal ("Directory name missing after -I option");
696 dirtmp
->fname
= argv
[++i
];
697 if (strlen (dirtmp
->fname
) > max_include_len
)
698 max_include_len
= strlen (dirtmp
->fname
);
699 if (ignore_srcdir
&& first_bracket_include
== 0)
700 first_bracket_include
= dirtmp
;
706 /* -nostdinc causes no default include directories.
707 You must specify all include-file directories with -I. */
708 no_standard_includes
= 1;
711 case '\0': /* JF handle '-' as file name meaning stdin or stdout */
712 if (in_fname
== NULL
) {
715 } else if (out_fname
== NULL
) {
718 } /* else fall through into error */
721 fatal ("Invalid option `%s'", argv
[i
]);
726 if (user_label_prefix
== 0)
727 user_label_prefix
= USER_LABEL_PREFIX
;
729 /* Initialize is_idchar. */
730 initialize_char_syntax ();
732 /* Install __LINE__, etc. Must follow initialize_char_syntax
733 and option processing. */
734 initialize_builtins ();
736 /* Do defines specified with -D and undefines specified with -U. */
737 for (i
= 1; i
< argc
; i
++)
738 if (pend
[i
].type
== PD_DEFINE
)
739 make_definition (pend
[i
].arg
);
740 else if (pend
[i
].type
== PD_UNDEF
)
741 make_undef (pend
[i
].arg
);
742 else if (pend
[i
].type
== PD_ASSERTION
)
743 make_assertion (pend
[i
].arg
);
745 /* Unless -fnostdinc,
746 tack on the standard include file dirs to the specified list */
747 if (!no_standard_includes
) {
748 const struct default_include
*di
;
749 struct file_name_list
*old_last_include
= last_include
;
750 struct file_name_list
*dirtmp
;
751 for (di
= cpp_include_defaults
; di
->fname
; di
++) {
754 dirtmp
= (struct file_name_list
*)
755 xmalloc (sizeof (struct file_name_list
));
756 dirtmp
->next
= 0; /* New one goes on the end */
760 last_include
->next
= dirtmp
;
761 last_include
= dirtmp
; /* Tail follows the last one */
762 dirtmp
->fname
= di
->fname
;
763 if (strlen (dirtmp
->fname
) > max_include_len
)
764 max_include_len
= strlen (dirtmp
->fname
);
767 if (ignore_srcdir
&& first_bracket_include
== 0)
768 first_bracket_include
= old_last_include
->next
;
771 /* Initialize output buffer */
773 outbuf
.buf
= (U_CHAR
*) xmalloc (OUTBUF_SIZE
);
774 outbuf
.bufp
= outbuf
.buf
;
775 outbuf
.length
= OUTBUF_SIZE
;
777 /* Scan the -i files before the main input.
778 Much like #including them, but with no_output set
779 so that only their macro definitions matter. */
782 for (i
= 1; i
< argc
; i
++)
783 if (pend
[i
].type
== PD_FILE
)
785 int fd
= open (pend
[i
].arg
, O_RDONLY
, 0666);
788 perror_with_name (pend
[i
].arg
);
789 return FATAL_EXIT_CODE
;
791 finclude (fd
, pend
[i
].arg
, &outbuf
);
795 /* Pending directives no longer needed. */
798 /* Create an input stack level for the main input file
799 and copy the entire contents of the file into it. */
801 fp
= &instack
[++indepth
];
803 /* JF check for stdin */
804 if (in_fname
== NULL
|| *in_fname
== 0) {
807 } else if ((f
= open (in_fname
, O_RDONLY
, 0666)) < 0)
810 /* Either of two environment variables can specify output of deps.
811 Its value is either "OUTPUT_FILE" or "OUTPUT_FILE DEPS_TARGET",
812 where OUTPUT_FILE is the file to write deps info to
813 and DEPS_TARGET is the target to mention in the deps. */
816 && (getenv ("SUNPRO_DEPENDENCIES") != 0
817 || getenv ("DEPENDENCIES_OUTPUT") != 0))
819 char *spec
= getenv ("DEPENDENCIES_OUTPUT");
825 spec
= getenv ("SUNPRO_DEPENDENCIES");
831 /* Find the space before the DEPS_TARGET, if there is one. */
832 s
= strchr (spec
, ' ');
836 output_file
= (char *) xmalloc (s
- spec
+ 1);
837 memcpy (output_file
, spec
, s
- spec
);
838 output_file
[s
- spec
] = 0;
846 deps_stream
= fopen (output_file
, "a");
847 if (deps_stream
== 0)
848 pfatal_with_name (output_file
);
850 /* If the -M option was used, output the deps to standard output. */
852 deps_stream
= stdout
;
854 /* For -M, print the expected object file name
855 as the target of this Make-rule. */
857 deps_allocated_size
= 200;
858 deps_buffer
= (char *) xmalloc (deps_allocated_size
);
864 deps_output (deps_target
, 0);
865 deps_output (":", 0);
866 } else if (*in_fname
== 0)
867 deps_output ("-: ", 0);
870 const char *p
= in_fname
;
872 /* Discard all directory prefixes from P. */
878 /* Output P, but remove known suffixes. */
880 if (p
[len
- 2] == '.'
881 && (p
[len
- 1] == 'c' || p
[len
- 1] == 'C' || p
[len
- 1] == 'S'))
882 deps_output (p
, len
- 2);
883 else if (p
[len
- 3] == '.'
885 && p
[len
- 1] == 'c')
886 deps_output (p
, len
- 3);
889 /* Supply our own suffix. */
890 deps_output (".o : ", 0);
891 deps_output (in_fname
, 0);
892 deps_output (" ", 0);
896 if (file_size_and_mode (f
, &st_mode
, &st_size
))
898 fp
->fname
= in_fname
;
900 /* JF all this is mine about reading pipes and ttys */
901 if (!S_ISREG (st_mode
)) {
902 /* Read input from a file that is not a normal disk file.
903 We cannot preallocate a buffer with the correct size,
904 so we must read in the file a piece at the time and make it bigger. */
912 fp
->buf
= (U_CHAR
*) xmalloc (bsize
+ 2);
915 cnt
= read (f
, bufp
, bsize
- size
);
916 if (cnt
< 0) goto sys_error
; /* error! */
917 if (cnt
== 0) break; /* End of file */
920 if (bsize
== size
) { /* Buffer is full! */
922 fp
->buf
= (U_CHAR
*) xrealloc (fp
->buf
, bsize
+ 2);
923 bufp
= fp
->buf
+ size
; /* May have moved */
928 /* Read a file whose size we can determine in advance.
929 For the sake of VMS, st_size is just an upper bound. */
932 fp
->buf
= (U_CHAR
*) xmalloc (st_size
+ 2);
934 while (st_size
> 0) {
935 i
= read (f
, fp
->buf
+ fp
->length
, st_size
);
945 fp
->if_stack
= if_stack
;
947 /* Make sure data ends with a newline. And put a null after it. */
949 if (fp
->length
> 0 && fp
->buf
[fp
->length
-1] != '\n')
950 fp
->buf
[fp
->length
++] = '\n';
951 fp
->buf
[fp
->length
] = '\0';
953 /* Now that we know the input file is valid, open the output. */
955 if (!out_fname
|| !strcmp (out_fname
, ""))
956 out_fname
= "stdout";
957 else if (! freopen (out_fname
, "w", stdout
))
958 pfatal_with_name (out_fname
);
960 output_line_command (fp
, &outbuf
, 0, same_file
);
962 /* Scan the input, processing macros and directives. */
966 /* Now we have processed the entire input
967 Write whichever kind of output has been requested. */
972 else if (! inhibit_output
&& deps_stream
!= stdout
) {
973 if (write (fileno (stdout
), outbuf
.buf
, outbuf
.bufp
- outbuf
.buf
) < 0)
974 fatal ("I/O error on output");
978 fputs (deps_buffer
, deps_stream
);
979 putc ('\n', deps_stream
);
980 if (deps_stream
!= stdout
) {
981 fclose (deps_stream
);
982 if (ferror (deps_stream
))
983 fatal ("I/O error on output");
988 fatal ("I/O error on output");
991 exit (FATAL_EXIT_CODE
);
992 exit (SUCCESS_EXIT_CODE
);
995 pfatal_with_name (in_fname
);
998 /* Move all backslash-newline pairs out of embarrassing places.
999 Exchange all such pairs following BP
1000 with any potentially-embarrasing characters that follow them.
1001 Potentially-embarrassing characters are / and *
1002 (because a backslash-newline inside a comment delimiter
1003 would cause it not to be recognized). */
1008 register U_CHAR
*p
= bp
;
1009 register int count
= 0;
1011 /* First count the backslash-newline pairs here. */
1013 while (*p
++ == '\\' && *p
++ == '\n')
1018 /* Exit if what follows the backslash-newlines is not embarrassing. */
1020 if (count
== 0 || (*p
!= '/' && *p
!= '*'))
1023 /* Copy all potentially embarrassing characters
1024 that follow the backslash-newline pairs
1025 down to where the pairs originally started. */
1027 while (*p
== '*' || *p
== '/')
1030 /* Now write the same number of pairs after the embarrassing chars. */
1031 while (count
-- > 0) {
1037 /* Like newline_fix but for use within a directive-name.
1038 Move any backslash-newlines up past any following symbol constituents. */
1040 name_newline_fix (bp
)
1043 register U_CHAR
*p
= bp
;
1044 register int count
= 0;
1046 /* First count the backslash-newline pairs here. */
1048 while (*p
++ == '\\' && *p
++ == '\n')
1053 /* What follows the backslash-newlines is not embarrassing. */
1055 if (count
== 0 || !is_idchar
[*p
])
1058 /* Copy all potentially embarrassing characters
1059 that follow the backslash-newline pairs
1060 down to where the pairs originally started. */
1062 while (is_idchar
[*p
])
1065 /* Now write the same number of pairs after the embarrassing chars. */
1066 while (count
-- > 0) {
1073 * The main loop of the program.
1075 * Read characters from the input stack, transferring them to the
1078 * Macros are expanded and push levels on the input stack.
1079 * At the end of such a level it is popped off and we keep reading.
1080 * At the end of any other kind of level, we return.
1081 * #-directives are handled, except within macros.
1083 * If OUTPUT_MARKS is nonzero, keep Newline markers found in the input
1084 * and insert them when appropriate. This is set while scanning macro
1085 * arguments before substitution. It is zero when scanning for final output.
1086 * There are three types of Newline markers:
1087 * * Newline - follows a macro name that was not expanded
1088 * because it appeared inside an expansion of the same macro.
1089 * This marker prevents future expansion of that identifier.
1090 * When the input is rescanned into the final output, these are deleted.
1091 * These are also deleted by ## concatenation.
1092 * * Newline Space (or Newline and any other whitespace character)
1093 * stands for a place that tokens must be separated or whitespace
1094 * is otherwise desirable, but where the ANSI standard specifies there
1095 * is no whitespace. This marker turns into a Space (or whichever other
1096 * whitespace char appears in the marker) in the final output,
1097 * but it turns into nothing in an argument that is stringified with #.
1098 * Such stringified arguments are the only place where the ANSI standard
1099 * specifies with precision that whitespace may not appear.
1101 * During this function, IP->bufp is kept cached in IBP for speed of access.
1102 * Likewise, OP->bufp is kept in OBP. Before calling a subroutine
1103 * IBP, IP and OBP must be copied back to memory. IP and IBP are
1104 * copied back with the RECACHE macro. OBP must be copied back from OP->bufp
1105 * explicitly, and before RECACHE, since RECACHE uses OBP.
1109 rescan (op
, output_marks
)
1113 /* Character being scanned in main loop. */
1116 /* Length of pending accumulated identifier. */
1117 register int ident_length
= 0;
1119 /* Hash code of pending accumulated identifier. */
1120 register int hash
= 0;
1122 /* Current input level (&instack[indepth]). */
1125 /* Pointer for scanning input. */
1126 register U_CHAR
*ibp
;
1128 /* Pointer to end of input. End of scan is controlled by LIMIT. */
1129 register U_CHAR
*limit
;
1131 /* Pointer for storing output. */
1132 register U_CHAR
*obp
;
1134 /* REDO_CHAR is nonzero if we are processing an identifier
1135 after backing up over the terminating character.
1136 Sometimes we process an identifier without backing up over
1137 the terminating character, if the terminating character
1138 is not special. Backing up is done so that the terminating character
1139 will be dispatched on again once the identifier is dealt with. */
1142 /* 1 if within an identifier inside of which a concatenation
1143 marker (Newline -) has been seen. */
1144 int concatenated
= 0;
1146 /* While scanning a comment or a string constant,
1147 this records the line it started on, for error messages. */
1150 /* Record position of last `real' newline. */
1151 U_CHAR
*beg_of_line
;
1153 /* Pop the innermost input stack level, assuming it is a macro expansion. */
1156 do { ip->macro->type = T_MACRO; \
1157 if (ip->free_ptr) free (ip->free_ptr); \
1158 --indepth; } while (0)
1160 /* Reload `rescan's local variables that describe the current
1161 level of the input stack. */
1164 do { ip = &instack[indepth]; \
1166 limit = ip->buf + ip->length; \
1168 check_expand (op, limit - ibp); \
1170 obp = op->bufp; } while (0)
1172 if (no_output
&& instack
[indepth
].fname
!= 0)
1173 skip_if_group (&instack
[indepth
], 1);
1179 /* Our caller must always put a null after the end of
1180 the input at each input stack level. */
1193 /* Always merge lines ending with backslash-newline,
1194 even in middle of identifier. */
1197 --obp
; /* remove backslash from obuf */
1200 /* Otherwise, backslash suppresses specialness of following char,
1201 so copy it here to prevent the switch from seeing it.
1202 But first get any pending identifier processed. */
1203 if (ident_length
> 0)
1209 /* If this is expanding a macro definition, don't recognize
1210 preprocessor directives. */
1216 /* # keyword: a # must be the first char on the line */
1217 if (beg_of_line
== 0)
1219 if (beg_of_line
+ 1 != ibp
)
1222 /* This # can start a directive. */
1224 --obp
; /* Don't copy the '#' */
1228 if (! handle_directive (ip
, op
)) {
1232 /* Not a known directive: treat it as ordinary text.
1233 IP, OP, IBP, etc. have not been changed. */
1234 if (no_output
&& instack
[indepth
].fname
) {
1235 /* If not generating expanded output,
1236 what we do with ordinary text is skip it.
1237 Discard everything until next # directive. */
1238 skip_if_group (&instack
[indepth
], 1);
1243 ++obp
; /* Copy the '#' after all */
1249 /* A # directive has been successfully processed. */
1250 /* If not generating expanded output, ignore everything until
1251 next # directive. */
1252 if (no_output
&& instack
[indepth
].fname
)
1253 skip_if_group (&instack
[indepth
], 1);
1259 case '\"': /* skip quoted string */
1261 /* A single quoted string is treated like a double -- some
1262 programs (e.g., troff) are perverse this way */
1267 start_line
= ip
->lineno
;
1269 /* Skip ahead to a matching quote. */
1273 if (ip
->macro
!= 0) {
1274 /* try harder: this string crosses a macro expansion boundary */
1286 /* Traditionally, end of line ends a string constant with no error.
1287 So exit the loop and record the new line. */
1295 /* Backslash newline is replaced by nothing at all,
1296 but keep the line counts correct. */
1301 /* ANSI stupidly requires that in \\ the second \
1302 is *not* prevented from combining with a newline. */
1303 while (*ibp
== '\\' && ibp
[1] == '\n') {
1322 if (*ibp
== '\\' && ibp
[1] == '\n')
1324 /* Don't look for comments inside a macro definition. */
1327 /* A comment constitutes white space, so it can terminate an identifier.
1328 Process the identifier, if any. */
1335 /* We have a comment. Skip it, optionally copying it to output. */
1337 start_line
= ip
->lineno
;
1339 ++ibp
; /* Skip the star. */
1341 /* In K+R C, a comment is equivalent to nothing. Note that we
1342 already output the slash; we might not want it. */
1343 if (! put_out_comments
)
1349 U_CHAR
*before_bp
= ibp
;
1351 while (ibp
< limit
) {
1354 if (warn_comments
&& ibp
< limit
&& *ibp
== '*')
1355 warning("`/*' within comment");
1358 if (*ibp
== '\\' && ibp
[1] == '\n')
1360 if (ibp
>= limit
|| *ibp
== '/')
1365 /* Copy the newline into the output buffer, in order to
1366 avoid the pain of a #line every time a multiline comment
1368 if (!put_out_comments
)
1376 error_with_line (line_for_error (start_line
),
1377 "unterminated comment");
1380 if (put_out_comments
) {
1381 memcpy (obp
, before_bp
, ibp
- before_bp
);
1382 obp
+= ibp
- before_bp
;
1388 case '0': case '1': case '2': case '3': case '4':
1389 case '5': case '6': case '7': case '8': case '9':
1390 /* If digit is not part of identifier, it starts a number,
1391 which means that following letters are not an identifier.
1392 "0x5" does not refer to an identifier "x5".
1393 So copy all alphanumerics that follow without accumulating
1394 as an identifier. Periods also, for sake of "3.e7". */
1396 if (ident_length
== 0) {
1397 while (ibp
< limit
) {
1398 while (ibp
< limit
&& ibp
[0] == '\\' && ibp
[1] == '\n') {
1403 if (!ISALNUM (c
) && c
!= '.' && c
!= '_') {
1408 /* A sign can be part of a preprocessing number
1409 if it follows an e. */
1410 if (c
== 'e' || c
== 'E') {
1411 while (ibp
< limit
&& ibp
[0] == '\\' && ibp
[1] == '\n') {
1415 if (ibp
< limit
&& (*ibp
== '+' || *ibp
== '-')) {
1417 /* Traditional C does not let the token go past the sign. */
1427 case 'a': case 'b': case 'c': case 'd': case 'e': case 'f':
1428 case 'g': case 'h': case 'i': case 'j': case 'k': case 'l':
1429 case 'm': case 'n': case 'o': case 'p': case 'q': case 'r':
1430 case 's': case 't': case 'u': case 'v': case 'w': case 'x':
1432 case 'A': case 'B': case 'C': case 'D': case 'E': case 'F':
1433 case 'G': case 'H': case 'I': case 'J': case 'K': case 'L':
1434 case 'M': case 'N': case 'O': case 'P': case 'Q': case 'R':
1435 case 'S': case 'T': case 'U': case 'V': case 'W': case 'X':
1438 /* Compute step of hash function, to avoid a proc call on every token */
1439 hash
= HASHSTEP (hash
, c
);
1443 /* If reprocessing a macro expansion, newline is a special marker. */
1444 if (ip
->macro
!= 0) {
1445 /* Newline White is a "funny space" to separate tokens that are
1446 supposed to be separate but without space between.
1447 Here White means any horizontal whitespace character.
1448 Newline - marks a recursive macro use that is not
1449 supposed to be expandable. */
1452 /* Newline - inhibits expansion of preceding token.
1453 If expanding a macro arg, we keep the newline -.
1454 In final output, it is deleted. */
1455 if (! concatenated
) {
1460 if (!output_marks
) {
1463 /* If expanding a macro arg, keep the newline -. */
1466 } else if (is_space
[*ibp
]) {
1467 /* Newline Space does not prevent expansion of preceding token
1468 so expand the preceding token and then come back. */
1469 if (ident_length
> 0)
1472 /* If generating final output, newline space makes a space. */
1473 if (!output_marks
) {
1475 /* And Newline Newline makes a newline, so count it. */
1476 if (obp
[-1] == '\n')
1479 /* If expanding a macro arg, keep the newline space.
1480 If the arg gets stringified, newline space makes nothing. */
1483 } else abort (); /* Newline followed by something random? */
1487 /* If there is a pending identifier, handle it and come back here. */
1488 if (ident_length
> 0)
1493 /* Update the line counts and output a #line if necessary. */
1496 if (ip
->lineno
!= op
->lineno
) {
1498 output_line_command (ip
, op
, 1, same_file
);
1499 check_expand (op
, ip
->length
- (ip
->bufp
- ip
->buf
));
1504 /* Come here either after (1) a null character that is part of the input
1505 or (2) at the end of the input, because there is a null there. */
1508 /* Our input really contains a null character. */
1511 /* At end of a macro-expansion level, pop it and read next level. */
1512 if (ip
->macro
!= 0) {
1515 /* If we have an identifier that ends here, process it now, so
1516 we get the right error for recursion. */
1517 if (ident_length
&& ! is_idchar
[*instack
[indepth
- 1].bufp
]) {
1526 /* If we don't have a pending identifier,
1527 return at end of input. */
1528 if (ident_length
== 0) {
1536 /* If we do have a pending identifier, just consider this null
1537 a special character and arrange to dispatch on it again.
1538 The second time, IDENT_LENGTH will be zero so we will return. */
1544 /* Handle the case of a character such as /, ', " or null
1545 seen following an identifier. Back over it so that
1546 after the identifier is processed the special char
1547 will be dispatched on again. */
1557 if (ident_length
> 0) {
1558 register HASHNODE
*hp
;
1560 /* We have just seen an identifier end. If it's a macro, expand it.
1562 IDENT_LENGTH is the length of the identifier
1563 and HASH is its hash code.
1565 The identifier has already been copied to the output,
1566 so if it is a macro we must remove it.
1568 If REDO_CHAR is 0, the char that terminated the identifier
1569 has been skipped in the output and the input.
1570 OBP-IDENT_LENGTH-1 points to the identifier.
1571 If the identifier is a macro, we must back over the terminator.
1573 If REDO_CHAR is 1, the terminating char has already been
1574 backed over. OBP-IDENT_LENGTH points to the identifier. */
1576 for (hp
= hashtab
[MAKE_POS (hash
) % HASHSIZE
]; hp
!= NULL
;
1579 if (hp
->length
== ident_length
) {
1580 U_CHAR
*obufp_before_macroname
;
1581 int op_lineno_before_macroname
;
1582 register int i
= ident_length
;
1583 register U_CHAR
*p
= hp
->name
;
1584 register U_CHAR
*q
= obp
- i
;
1589 do { /* All this to avoid a strncmp () */
1594 /* We found a use of a macro name.
1595 see if the context shows it is a macro call. */
1597 /* Back up over terminating character if not already done. */
1603 obufp_before_macroname
= obp
- ident_length
;
1604 op_lineno_before_macroname
= op
->lineno
;
1606 /* If macro wants an arglist, verify that a '(' follows.
1607 first skip all whitespace, copying it to the output
1608 after the macro name. Then, if there is no '(',
1609 decide this is not a macro call and leave things that way. */
1610 if (hp
->type
== T_MACRO
&& hp
->value
.defn
->nargs
>= 0)
1613 /* Scan forward over whitespace, copying it to the output. */
1614 if (ibp
== limit
&& ip
->macro
!= 0) {
1618 /* A comment: copy it unchanged or discard it. */
1619 else if (*ibp
== '/' && ibp
+1 != limit
&& ibp
[1] == '*') {
1620 if (put_out_comments
) {
1625 while (ibp
+ 1 != limit
1626 && !(ibp
[0] == '*' && ibp
[1] == '/')) {
1627 /* We need not worry about newline-marks,
1628 since they are never found in comments. */
1630 /* Newline in a file. Count it. */
1634 if (put_out_comments
)
1640 if (put_out_comments
) {
1645 else if (is_space
[*ibp
]) {
1647 if (ibp
[-1] == '\n') {
1648 if (ip
->macro
== 0) {
1649 /* Newline in a file. Count it. */
1652 } else if (!output_marks
) {
1653 /* A newline mark, and we don't want marks
1654 in the output. If it is newline-hyphen,
1655 discard it entirely. Otherwise, it is
1656 newline-whitechar, so keep the whitechar. */
1666 /* A newline mark; copy both chars to the output. */
1677 /* This is now known to be a macro call.
1678 Discard the macro name from the output,
1679 along with any following whitespace just copied. */
1680 obp
= obufp_before_macroname
;
1681 op
->lineno
= op_lineno_before_macroname
;
1683 /* Expand the macro, reading arguments as needed,
1684 and push the expansion on the input stack. */
1687 macroexpand (hp
, op
);
1689 /* Reexamine input stack, since macroexpand has pushed
1690 a new level on it. */
1697 } /* End hash-table-search loop */
1698 ident_length
= hash
= 0; /* Stop collecting identifier */
1701 } /* End if (ident_length > 0) */
1703 } /* End per-char loop */
1705 /* Come here to return -- but first give an error message
1706 if there was an unterminated successful conditional. */
1708 if (if_stack
!= ip
->if_stack
) {
1710 switch (if_stack
->type
) {
1729 error_with_line (line_for_error (if_stack
->lineno
),
1730 "unterminated #%s conditional", str
);
1732 if_stack
= ip
->if_stack
;
1736 * Rescan a string into a temporary buffer and return the result
1737 * as a FILE_BUF. Note this function returns a struct, not a pointer.
1739 * OUTPUT_MARKS nonzero means keep Newline markers found in the input
1740 * and insert such markers when appropriate. See `rescan' for details.
1741 * OUTPUT_MARKS is 1 for macroexpanding a macro argument separately
1742 * before substitution; it is 0 for other uses.
1745 expand_to_temp_buffer (buf
, limit
, output_marks
)
1746 const U_CHAR
*buf
, *limit
;
1749 register FILE_BUF
*ip
;
1751 int length
= limit
- buf
;
1753 int odepth
= indepth
;
1758 /* Set up the input on the input stack. */
1760 buf1
= (U_CHAR
*) alloca (length
+ 1);
1762 register const U_CHAR
*p1
= buf
;
1763 register U_CHAR
*p2
= buf1
;
1770 /* Set up to receive the output. */
1772 obuf
.length
= length
* 2 + 100; /* Usually enough. Why be stingy? */
1773 obuf
.bufp
= obuf
.buf
= (U_CHAR
*) xmalloc (obuf
.length
);
1778 CHECK_DEPTH ({return obuf
;});
1782 ip
= &instack
[indepth
];
1786 ip
->length
= length
;
1787 ip
->buf
= ip
->bufp
= buf1
;
1788 ip
->if_stack
= if_stack
;
1790 ip
->lineno
= obuf
.lineno
= 1;
1792 /* Scan the input, create the output. */
1794 rescan (&obuf
, output_marks
);
1796 /* Pop input stack to original state. */
1799 if (indepth
!= odepth
)
1802 /* Record the output. */
1803 obuf
.length
= obuf
.bufp
- obuf
.buf
;
1809 * Process a # directive. Expects IP->bufp to point to the '#', as in
1810 * `#define foo bar'. Passes to the command handler
1811 * (do_define, do_include, etc.): the addresses of the 1st and
1812 * last chars of the command (starting immediately after the #
1813 * keyword), plus op and the keyword table pointer. If the command
1814 * contains comments it is copied into a temporary buffer sans comments
1815 * and the temporary buffer is passed to the command handler instead.
1816 * Likewise for backslash-newlines.
1818 * Returns nonzero if this was a known # directive.
1819 * Otherwise, returns zero, without advancing the input pointer.
1823 handle_directive (ip
, op
)
1826 register U_CHAR
*bp
, *cp
;
1827 register struct directive
*kt
;
1828 register int ident_length
;
1831 /* Nonzero means we must copy the entire command
1832 to get rid of comments or backslash-newlines. */
1833 int copy_command
= 0;
1835 U_CHAR
*ident
, *after_ident
;
1838 /* Skip whitespace and \-newline. */
1840 if (is_hor_space
[*bp
])
1842 else if (*bp
== '/' && (newline_fix (bp
+ 1), bp
[1]) == '*') {
1844 skip_to_end_of_comment (ip
, &ip
->lineno
);
1846 } else if (*bp
== '\\' && bp
[1] == '\n') {
1847 bp
+= 2; ip
->lineno
++;
1851 /* Now find end of directive name.
1852 If we encounter a backslash-newline, exchange it with any following
1853 symbol-constituents so that we end up with a contiguous name. */
1860 if (*cp
== '\\' && cp
[1] == '\n')
1861 name_newline_fix (cp
);
1867 ident_length
= cp
- bp
;
1871 /* A line of just `#' becomes blank. */
1873 if (ident_length
== 0 && *after_ident
== '\n') {
1874 ip
->bufp
= after_ident
;
1879 * Decode the keyword and call the appropriate expansion
1880 * routine, after moving the input pointer up to the next line.
1882 for (kt
= directive_table
; kt
->length
> 0; kt
++) {
1883 if (kt
->length
== ident_length
1884 && !strncmp (kt
->name
, (const char *)ident
, ident_length
)) {
1885 register U_CHAR
*buf
;
1886 register U_CHAR
*limit
= ip
->buf
+ ip
->length
;
1887 int unterminated
= 0;
1889 /* Nonzero means do not delete comments within the directive.
1890 #define needs this to detect traditional token paste. */
1891 int keep_comments
= kt
->type
== T_DEFINE
;
1893 /* Find the end of this command (first newline not backslashed
1894 and not in a string or comment).
1895 Set COPY_COMMAND if the command must be copied
1896 (it contains a backslash-newline or a comment). */
1898 buf
= bp
= after_ident
;
1899 while (bp
< limit
) {
1900 register U_CHAR c
= *bp
++;
1914 bp
= skip_quoted_string (bp
- 1, limit
, ip
->lineno
, &ip
->lineno
, ©_command
, &unterminated
);
1916 /* Traditional preprocessing permits unterminated strings. */
1922 /* <...> is special for #include. */
1924 if (kt
->type
!= T_INCLUDE
)
1926 while (*bp
&& *bp
!= '>') bp
++;
1930 if (*bp
== '\\' && bp
[1] == '\n')
1933 U_CHAR
*obp
= bp
- 1;
1935 skip_to_end_of_comment (ip
, &ip
->lineno
);
1937 /* No need to copy the command because of a comment at the end;
1938 just don't include the comment in the directive. */
1939 if (bp
== limit
|| *bp
== '\n') {
1943 /* Don't remove the comments if this is #define. */
1944 if (! keep_comments
)
1950 --bp
; /* Point to the newline */
1958 resume_p
= ip
->bufp
;
1959 /* BP is the end of the directive.
1960 RESUME_P is the next interesting data after the directive.
1961 A comment may come between. */
1964 register U_CHAR
*xp
= buf
;
1965 /* Need to copy entire command into temp buffer before dispatching */
1967 cp
= (U_CHAR
*) alloca (bp
- buf
+ 5); /* room for cmd plus
1971 /* Copy to the new buffer, deleting comments
1972 and backslash-newlines (and whitespace surrounding the latter). */
1975 register U_CHAR c
= *xp
++;
1982 /* <...> is special for #include. */
1984 if (kt
->type
!= T_INCLUDE
)
1986 while (xp
< bp
&& c
!= '>') {
1988 if (c
== '\\' && xp
< bp
&& *xp
== '\n')
1999 if (cp
!= buf
&& is_space
[cp
[-1]]) {
2000 while (cp
!= buf
&& is_space
[cp
[-1]]) cp
--;
2002 SKIP_WHITE_SPACE (xp
);
2003 } else if (is_space
[*xp
]) {
2005 SKIP_WHITE_SPACE (xp
);
2015 register const U_CHAR
*bp1
2016 = skip_quoted_string (xp
- 1, limit
, ip
->lineno
, 0, 0, 0);
2025 skip_to_end_of_comment (ip
, 0);
2027 while (xp
!= ip
->bufp
)
2029 /* Delete the slash. */
2037 /* Null-terminate the copy. */
2044 ip
->bufp
= resume_p
;
2046 /* Call the appropriate command handler. buf now points to
2047 either the appropriate place in the input buffer, or to
2048 the temp buffer if it was necessary to make one. cp
2049 points to the first char after the contents of the (possibly
2050 copied) command, in either case. */
2051 (*kt
->func
) (buf
, cp
, op
);
2052 check_expand (op
, ip
->length
- (ip
->bufp
- ip
->buf
));
2061 static const char *const
2062 monthnames
[] = {"Jan", "Feb", "Mar", "Apr", "May", "Jun",
2063 "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"};
2066 * expand things like __FILE__. Place the expansion into the output
2067 * buffer *without* rescanning.
2070 special_symbol (hp
, op
)
2078 FILE_BUF
*ip
= NULL
;
2079 static struct tm
*timebuf
= NULL
;
2081 int paren
= 0; /* For special `defined' keyword */
2083 for (i
= indepth
; i
>= 0; i
--)
2084 if (instack
[i
].fname
!= NULL
) {
2089 fatal ("not in any file?!");
2096 if (hp
->type
== T_FILE
)
2099 string
= instack
[0].fname
;
2103 char *tmp
= (char *) alloca (3 + strlen (string
));
2104 sprintf (tmp
, "\"%s\"", string
);
2113 case T_INCLUDE_LEVEL
:
2115 char *tmp
= (char *) alloca (8); /* Eigth bytes ought to be more than enough */
2117 for (i
= indepth
; i
>= 0; i
--)
2118 if (instack
[i
].fname
!= NULL
)
2121 sprintf (tmp
, "%d", true_indepth
- 1);
2128 char *tmp
= (char *) alloca (3 + strlen (version_string
));
2129 sprintf (tmp
, "\"%s\"", version_string
);
2135 buf
= hp
->value
.cpval
;
2140 char *tmp
= (char *) alloca (10);
2141 sprintf (tmp
, "%d", ip
->lineno
);
2149 char *tmp
= (char *) alloca (20);
2151 if (timebuf
== NULL
) {
2153 timebuf
= localtime (&t
);
2155 if (hp
->type
== T_DATE
)
2156 sprintf (tmp
, "\"%s %2d %4d\"", monthnames
[timebuf
->tm_mon
],
2157 timebuf
->tm_mday
, timebuf
->tm_year
+ 1900);
2159 sprintf (tmp
, "\"%02d:%02d:%02d\"", timebuf
->tm_hour
, timebuf
->tm_min
,
2165 case T_SPEC_DEFINED
:
2166 buf
= " 0 "; /* Assume symbol is not defined */
2167 ip
= &instack
[indepth
];
2168 SKIP_WHITE_SPACE (ip
->bufp
);
2169 if (*ip
->bufp
== '(') {
2171 ip
->bufp
++; /* Skip over the paren */
2172 SKIP_WHITE_SPACE (ip
->bufp
);
2175 if (!is_idstart
[*ip
->bufp
])
2177 if (lookup (ip
->bufp
, -1, -1))
2179 while (is_idchar
[*ip
->bufp
])
2181 SKIP_WHITE_SPACE (ip
->bufp
);
2183 if (*ip
->bufp
!= ')')
2191 error ("`defined' must be followed by ident or (ident)");
2195 error ("cccp error: invalid special hash type"); /* time for gdb */
2199 check_expand (op
, len
);
2200 memcpy (op
->bufp
, buf
, len
);
2205 /* Routines to handle #directives */
2208 * Process include file by reading it in and calling rescan.
2209 * Expects to see "fname" or <fname> on the input.
2212 do_include (buf
, limit
, op
)
2213 U_CHAR
*buf
, *limit
;
2216 char *fname
; /* Dynamically allocated fname buffer */
2217 U_CHAR
*fbeg
, *fend
; /* Beginning and end of fname */
2219 struct file_name_list
*stackp
= include
; /* Chain of dirs to search */
2220 struct file_name_list dsp
[1]; /* First in chain, if #include "..." */
2223 int f
; /* file number */
2225 int retried
= 0; /* Have already tried macro
2226 expanding the include line*/
2227 FILE_BUF trybuf
; /* It got expanded into here */
2228 int system_header_p
= 0; /* 0 for "...", 1 for <...> */
2230 f
= -1; /* JF we iz paranoid! */
2235 SKIP_WHITE_SPACE (fbeg
);
2236 /* Discard trailing whitespace so we can easily see
2237 if we have parsed all the significant chars we were given. */
2238 while (limit
!= fbeg
&& is_hor_space
[limit
[-1]]) limit
--;
2243 while (fend
!= limit
&& *fend
!= '\"')
2245 if (*fend
== '\"' && fend
+ 1 == limit
) {
2248 /* We have "filename". Figure out directory this source
2249 file is coming from and put it on the front of the list. */
2251 /* If -I- was specified, don't search current dir, only spec'd ones. */
2252 if (ignore_srcdir
) break;
2254 for (fp
= &instack
[indepth
]; fp
>= instack
; fp
--)
2257 const char *ep
, *nam
;
2259 if ((nam
= fp
->fname
) != NULL
) {
2260 /* Found a named file. Figure out dir of the file,
2261 and put it in front of the search list. */
2262 dsp
[0].next
= stackp
;
2264 ep
= strrchr (nam
, '/');
2268 f
= (char *) alloca (n
+ 1);
2269 strncpy (f
, nam
, n
);
2272 if (n
> max_include_len
) max_include_len
= n
;
2274 dsp
[0].fname
= 0; /* Current directory */
2285 while (fend
!= limit
&& *fend
!= '>') fend
++;
2286 if (*fend
== '>' && fend
+ 1 == limit
) {
2287 system_header_p
= 1;
2288 /* If -I-, start with the first -I dir after the -I-. */
2289 if (first_bracket_include
)
2290 stackp
= first_bracket_include
;
2298 error ("#include expects \"fname\" or <fname>");
2301 trybuf
= expand_to_temp_buffer (buf
, limit
, 0);
2302 buf
= (U_CHAR
*) alloca (trybuf
.bufp
- trybuf
.buf
+ 1);
2303 memcpy (buf
, trybuf
.buf
, trybuf
.bufp
- trybuf
.buf
);
2304 limit
= buf
+ (trybuf
.bufp
- trybuf
.buf
);
2312 fname
= (char *) alloca (max_include_len
+ flen
+ 2);
2313 /* + 2 above for slash and terminating null. */
2315 /* If specified file name is absolute, just open it. */
2318 strncpy (fname
, (const char *)fbeg
, flen
);
2320 f
= open (fname
, O_RDONLY
, 0666);
2322 /* Search directory path, trying to open the file.
2323 Copy each filename tried into FNAME. */
2325 for (; stackp
; stackp
= stackp
->next
) {
2326 if (stackp
->fname
) {
2327 strcpy (fname
, stackp
->fname
);
2328 strcat (fname
, "/");
2329 fname
[strlen (fname
) + flen
] = 0;
2333 strncat (fname
, (const char *)fbeg
, flen
);
2334 if ((f
= open (fname
, O_RDONLY
, 0666)) >= 0)
2340 strncpy (fname
, (const char *)fbeg
, flen
);
2342 error_from_errno (fname
);
2344 /* For -M, add this file to the dependencies. */
2345 if (print_deps
> (system_header_p
|| (system_include_depth
> 0))) {
2346 if (system_header_p
)
2347 warning ("nonexistent file <%.*s> omitted from dependency output",
2351 deps_output ((const char *)fbeg
, fend
- fbeg
);
2352 deps_output (" ", 0);
2357 /* Check to see if this include file is a once-only include file.
2360 struct file_name_list
* ptr
;
2362 for (ptr
= dont_repeat_files
; ptr
; ptr
= ptr
->next
) {
2363 if (!strcmp (ptr
->fname
, fname
)) {
2365 return; /* This file was once'd. */
2369 for (ptr
= all_include_files
; ptr
; ptr
= ptr
->next
) {
2370 if (!strcmp (ptr
->fname
, fname
))
2371 break; /* This file was included before. */
2375 /* This is the first time for this file. */
2376 /* Add it to list of files included. */
2378 ptr
= (struct file_name_list
*) xmalloc (sizeof (struct file_name_list
));
2379 ptr
->next
= all_include_files
;
2380 all_include_files
= ptr
;
2381 ptr
->fname
= xstrdup (fname
);
2383 /* For -M, add this file to the dependencies. */
2384 if (print_deps
> (system_header_p
|| (system_include_depth
> 0))) {
2385 deps_output (fname
, strlen (fname
));
2386 deps_output (" ", 0);
2390 if (system_header_p
)
2391 system_include_depth
++;
2393 /* Actually process the file. */
2394 finclude (f
, fname
, op
);
2396 if (system_header_p
)
2397 system_include_depth
--;
2403 /* Process the contents of include file FNAME, already open on descriptor F,
2404 with output to OP. */
2407 finclude (f
, fname
, op
)
2415 FILE_BUF
*fp
; /* For input stack frame */
2417 CHECK_DEPTH (return;);
2419 if (file_size_and_mode (f
, &st_mode
, &st_size
))
2422 fp
= &instack
[indepth
+ 1];
2423 memset (fp
, 0, sizeof (FILE_BUF
));
2427 fp
->if_stack
= if_stack
;
2429 if (S_ISREG (st_mode
)) {
2430 fp
->buf
= (U_CHAR
*) xmalloc (st_size
+ 2);
2433 /* Read the file contents, knowing that st_size is an upper bound
2434 on the number of bytes we can read. */
2435 while (st_size
> 0) {
2436 i
= read (f
, fp
->buf
+ fp
->length
, st_size
);
2446 /* Cannot count its file size before reading. */
2453 basep
= (U_CHAR
*) xmalloc (bsize
+ 2);
2457 i
= read (f
, bufp
, bsize
- st_size
);
2459 goto nope
; /* error! */
2461 break; /* End of file */
2464 if (bsize
== st_size
) { /* Buffer is full! */
2466 basep
= (U_CHAR
*) xrealloc (basep
, bsize
+ 2);
2467 bufp
= basep
+ st_size
; /* May have moved */
2472 fp
->length
= st_size
;
2476 /* Make sure data ends with a newline. And put a null after it. */
2478 if (fp
->length
> 0 && fp
->buf
[fp
->length
-1] != '\n')
2479 fp
->buf
[fp
->length
++] = '\n';
2480 fp
->buf
[fp
->length
] = '\0';
2483 output_line_command (fp
, op
, 0, enter_file
);
2486 output_line_command (&instack
[indepth
], op
, 0, leave_file
);
2491 perror_with_name (fname
);
2496 /* Process a #define command.
2497 BUF points to the contents of the #define command, as a continguous string.
2498 LIMIT points to the first character past the end of the definition.
2499 KEYWORD is the keyword-table entry for #define. */
2502 do_define (buf
, limit
, op
)
2503 U_CHAR
*buf
, *limit
;
2504 FILE_BUF
*op ATTRIBUTE_UNUSED
;
2506 U_CHAR
*bp
; /* temp ptr into input buffer */
2507 U_CHAR
*symname
; /* remember where symbol name starts */
2508 int sym_length
; /* and how long it is */
2511 int arglengths
= 0; /* Accumulate lengths of arg names
2512 plus number of args. */
2517 while (is_hor_space
[*bp
])
2520 symname
= bp
; /* remember where it starts */
2521 while (is_idchar
[*bp
] && bp
< limit
) {
2524 sym_length
= bp
- symname
;
2525 if (sym_length
== 0)
2526 error ("invalid macro name");
2527 else if (!is_idstart
[*symname
]) {
2528 U_CHAR
*msg
; /* what pain... */
2529 msg
= (U_CHAR
*) alloca (sym_length
+ 1);
2530 memcpy (msg
, symname
, sym_length
);
2531 msg
[sym_length
] = 0;
2532 error ("invalid macro name `%s'", msg
);
2534 if (! strncmp ((const char *)symname
, "defined", 7) && sym_length
== 7)
2535 error ("defining `defined' as a macro");
2538 /* lossage will occur if identifiers or control keywords are broken
2539 across lines using backslash. This is not the right place to take
2543 struct arglist
*arg_ptrs
= NULL
;
2546 bp
++; /* skip '(' */
2547 SKIP_WHITE_SPACE (bp
);
2549 /* Loop over macro argument names. */
2550 while (*bp
!= ')') {
2551 struct arglist
*temp
;
2553 temp
= (struct arglist
*) alloca (sizeof (struct arglist
));
2555 temp
->next
= arg_ptrs
;
2556 temp
->argno
= argno
++;
2559 if (!is_idstart
[*bp
])
2560 warning ("parameter name starts with a digit in #define");
2562 /* Find the end of the arg name. */
2563 while (is_idchar
[*bp
]) {
2566 temp
->length
= bp
- temp
->name
;
2567 arglengths
+= temp
->length
+ 2;
2568 SKIP_WHITE_SPACE (bp
);
2569 if (temp
->length
== 0 || (*bp
!= ',' && *bp
!= ')')) {
2570 error ("badly punctuated parameter list in #define");
2575 SKIP_WHITE_SPACE (bp
);
2578 error ("unterminated parameter list in #define");
2583 ++bp
; /* skip paren */
2584 while (is_hor_space
[*bp
]) /* and leading whitespace */
2586 /* now everything from bp before limit is the definition. */
2587 defn
= collect_expansion (bp
, limit
, argno
, arg_ptrs
);
2589 /* Now set defn->argnames to the result of concatenating
2590 the argument names in reverse order
2591 with comma-space between them. */
2593 struct arglist
*temp
;
2595 U_CHAR
*tmp
= (U_CHAR
*) xmalloc (arglengths
+ 1);
2597 for (temp
= arg_ptrs
; temp
; temp
= temp
->next
) {
2598 memcpy (&tmp
[i
], temp
->name
, temp
->length
);
2600 if (temp
->next
!= 0) {
2606 defn
->argnames
= tmp
;
2610 /* simple expansion or empty definition; skip leading whitespace */
2611 while (is_hor_space
[*bp
])
2613 /* now everything from bp before limit is the definition. */
2614 defn
= collect_expansion (bp
, limit
, -1, 0);
2615 defn
->argnames
= (const U_CHAR
*) "";
2618 hashcode
= hashf (symname
, sym_length
, HASHSIZE
);
2622 if ((hp
= lookup (symname
, sym_length
, hashcode
)) == NULL
)
2623 hp
= install (symname
, sym_length
, T_MACRO
, hashcode
);
2625 if (hp
->type
!= T_MACRO
|| compare_defs (defn
, hp
->value
.defn
))
2626 warning ("\"%.*s\" redefined", sym_length
, symname
);
2628 /* Replace the old definition. */
2632 hp
->value
.defn
= defn
;
2637 * return zero if two DEFINITIONs are isomorphic
2640 compare_defs (d1
, d2
)
2641 DEFINITION
*d1
, *d2
;
2643 register struct reflist
*a1
, *a2
;
2644 register U_CHAR
*p1
= d1
->expansion
;
2645 register U_CHAR
*p2
= d2
->expansion
;
2648 if (d1
->nargs
!= d2
->nargs
)
2650 if (strcmp ((const char *)d1
->argnames
, (const char *)d2
->argnames
))
2652 for (a1
= d1
->pattern
, a2
= d2
->pattern
; a1
&& a2
;
2653 a1
= a1
->next
, a2
= a2
->next
) {
2654 if (!((a1
->nchars
== a2
->nchars
2655 && ! strncmp ((const char *)p1
, (const char *)p2
, a1
->nchars
))
2656 || ! comp_def_part (first
, p1
, a1
->nchars
, p2
, a2
->nchars
, 0))
2657 || a1
->argno
!= a2
->argno
2658 || a1
->stringify
!= a2
->stringify
2659 || a1
->raw_before
!= a2
->raw_before
2660 || a1
->raw_after
!= a2
->raw_after
)
2668 if (comp_def_part (first
, p1
, d1
->length
- (p1
- d1
->expansion
),
2669 p2
, d2
->length
- (p2
- d2
->expansion
), 1))
2674 /* Return 1 if two parts of two macro definitions are effectively different.
2675 One of the parts starts at BEG1 and has LEN1 chars;
2676 the other has LEN2 chars at BEG2.
2677 Any sequence of whitespace matches any other sequence of whitespace.
2678 FIRST means these parts are the first of a macro definition;
2679 so ignore leading whitespace entirely.
2680 LAST means these parts are the last of a macro definition;
2681 so ignore trailing whitespace entirely. */
2683 comp_def_part (first
, beg1
, len1
, beg2
, len2
, last
)
2685 const U_CHAR
*beg1
, *beg2
;
2689 register const U_CHAR
*end1
= beg1
+ len1
;
2690 register const U_CHAR
*end2
= beg2
+ len2
;
2692 while (beg1
!= end1
&& is_space
[*beg1
]) beg1
++;
2693 while (beg2
!= end2
&& is_space
[*beg2
]) beg2
++;
2696 while (beg1
!= end1
&& is_space
[end1
[-1]]) end1
--;
2697 while (beg2
!= end2
&& is_space
[end2
[-1]]) end2
--;
2699 while (beg1
!= end1
&& beg2
!= end2
) {
2700 if (is_space
[*beg1
] && is_space
[*beg2
]) {
2701 while (beg1
!= end1
&& is_space
[*beg1
]) beg1
++;
2702 while (beg2
!= end2
&& is_space
[*beg2
]) beg2
++;
2703 } else if (*beg1
== *beg2
) {
2707 return (beg1
!= end1
) || (beg2
!= end2
);
2710 /* Read a replacement list for a macro with parameters.
2711 Build the DEFINITION structure.
2712 Reads characters of text starting at BUF until LIMIT.
2713 ARGLIST specifies the formal parameters to look for
2714 in the text of the definition; NARGS is the number of args
2715 in that list, or -1 for a macro name that wants no argument list.
2716 MACRONAME is the macro name itself (so we can avoid recursive expansion)
2717 and NAMELEN is its length in characters.
2719 Note that comments and backslash-newlines have already been deleted
2720 from the argument. */
2722 /* Leading and trailing Space, Tab, etc. are converted to markers
2723 Newline Space, Newline Tab, etc.
2724 Newline Space makes a space in the final output
2725 but is discarded if stringified. (Newline Tab is similar but
2726 makes a Tab instead.)
2728 If there is no trailing whitespace, a Newline Space is added at the end
2729 to prevent concatenation that would be contrary to the standard. */
2732 collect_expansion (buf
, end
, nargs
, arglist
)
2735 struct arglist
*arglist
;
2738 register U_CHAR
*p
, *limit
, *lastp
, *exp_p
;
2739 struct reflist
*endpat
= NULL
;
2740 /* Pointer to first nonspace after last ## seen. */
2742 /* Pointer to first nonspace after last single-# seen. */
2743 U_CHAR
*stringify
= 0;
2745 int expected_delimiter
= '\0';
2747 /* Scan thru the replacement list, ignoring comments and quoted
2748 strings, picking up on the macro calls. It does a linear search
2749 thru the arg list on every potential symbol. Profiling might say
2750 that something smarter should happen. */
2755 /* Find the beginning of the trailing whitespace. */
2756 /* Find end of leading whitespace. */
2759 while (p
< limit
&& is_space
[limit
[-1]]) limit
--;
2760 while (p
< limit
&& is_space
[*p
]) p
++;
2762 /* Allocate space for the text in the macro definition.
2763 Leading and trailing whitespace chars need 2 bytes each.
2764 Each other input char may or may not need 1 byte,
2765 so this is an upper bound.
2766 The extra 2 are for invented trailing newline-marker and final null. */
2767 maxsize
= (sizeof (DEFINITION
)
2768 + 2 * (end
- limit
) + 2 * (p
- buf
)
2770 defn
= (DEFINITION
*) xcalloc (1, maxsize
);
2772 defn
->nargs
= nargs
;
2773 exp_p
= defn
->expansion
= (U_CHAR
*) defn
+ sizeof (DEFINITION
);
2778 /* Convert leading whitespace to Newline-markers. */
2779 while (p
< limit
&& is_space
[*p
]) {
2784 /* Process the main body of the definition. */
2786 int skipped_arg
= 0;
2787 register U_CHAR c
= *p
++;
2791 /* In -traditional mode, recognize arguments inside strings and
2792 and character constants, and ignore special properties of #.
2793 Arguments inside strings are considered "stringified", but no
2794 extra quote marks are supplied. */
2798 if (expected_delimiter
!= '\0') {
2799 if (c
== expected_delimiter
)
2800 expected_delimiter
= '\0';
2802 expected_delimiter
= c
;
2806 /* Backslash quotes delimiters and itself, but not macro args. */
2807 if (expected_delimiter
!= 0 && p
< limit
2808 && (*p
== expected_delimiter
|| *p
== '\\')) {
2815 if (expected_delimiter
!= '\0') /* No comments inside strings. */
2818 /* If we find a comment that wasn't removed by handle_directive,
2819 this must be -traditional. So replace the comment with
2823 while (p
< limit
&& !(p
[-2] == '*' && p
[-1] == '/'))
2829 if (is_idchar
[c
] && nargs
> 0) {
2830 U_CHAR
*id_beg
= p
- 1;
2834 while (p
!= limit
&& is_idchar
[*p
]) p
++;
2835 id_len
= p
- id_beg
;
2837 if (is_idstart
[c
]) {
2838 register struct arglist
*arg
;
2840 for (arg
= arglist
; arg
!= NULL
; arg
= arg
->next
) {
2841 struct reflist
*tpat
;
2843 if (arg
->name
[0] == c
2844 && arg
->length
== id_len
2845 && strncmp ((const char *)arg
->name
,
2846 (const char *)id_beg
, id_len
) == 0) {
2847 /* make a pat node for this arg and append it to the end of
2849 tpat
= (struct reflist
*) xmalloc (sizeof (struct reflist
));
2851 tpat
->raw_before
= concat
== id_beg
;
2852 tpat
->raw_after
= 0;
2853 tpat
->stringify
= expected_delimiter
!= '\0';
2856 defn
->pattern
= tpat
;
2858 endpat
->next
= tpat
;
2861 tpat
->argno
= arg
->argno
;
2862 tpat
->nchars
= exp_p
- lastp
;
2864 register U_CHAR
*p1
= p
;
2865 SKIP_WHITE_SPACE (p1
);
2866 if (p1
+ 2 <= limit
&& p1
[0] == '#' && p1
[1] == '#')
2867 tpat
->raw_after
= 1;
2869 lastp
= exp_p
; /* place to start copying from next time */
2876 /* If this was not a macro arg, copy it into the expansion. */
2877 if (! skipped_arg
) {
2878 register U_CHAR
*lim1
= p
;
2882 if (stringify
== id_beg
)
2883 error ("# operator should be followed by a macro argument name");
2889 /* Convert trailing whitespace to Newline-markers. */
2890 while (limit
< end
&& is_space
[*limit
]) {
2892 *exp_p
++ = *limit
++;
2897 defn
->length
= exp_p
- defn
->expansion
;
2899 /* Crash now if we overrun the allocated size. */
2900 if (defn
->length
+ 1 > maxsize
)
2907 * interpret #line command. Remembers previously seen fnames
2908 * in its very own hash table.
2910 #define FNAME_HASHSIZE 37
2912 do_line (buf
, limit
, op
)
2913 U_CHAR
*buf
, *limit
;
2916 register U_CHAR
*bp
;
2917 FILE_BUF
*ip
= &instack
[indepth
];
2920 enum file_change_code file_change
= same_file
;
2922 /* Expand any macros. */
2923 tem
= expand_to_temp_buffer (buf
, limit
, 0);
2925 /* Point to macroexpanded line, which is null-terminated now. */
2927 SKIP_WHITE_SPACE (bp
);
2929 if (!ISDIGIT (*bp
)) {
2930 error ("invalid format #line command");
2934 /* The Newline at the end of this line remains to be processed.
2935 To put the next line at the specified line number,
2936 we must store a line number now that is one less. */
2937 new_lineno
= atoi ((const char *)bp
) - 1;
2939 /* skip over the line number. */
2940 while (ISDIGIT (*bp
))
2943 #if 0 /* #line 10"foo.c" is supposed to be allowed. */
2944 if (*bp
&& !is_space
[*bp
]) {
2945 error ("invalid format #line command");
2950 SKIP_WHITE_SPACE (bp
);
2953 static HASHNODE
*fname_table
[FNAME_HASHSIZE
];
2954 HASHNODE
*hp
, **hash_bucket
;
2960 while (*bp
&& *bp
!= '\"')
2963 error ("invalid format #line command");
2967 fname_length
= bp
- fname
;
2970 SKIP_WHITE_SPACE (bp
);
2973 file_change
= enter_file
;
2974 else if (*bp
== '2')
2975 file_change
= leave_file
;
2977 error ("invalid format #line command");
2982 SKIP_WHITE_SPACE (bp
);
2984 error ("invalid format #line command");
2990 &fname_table
[hashf (fname
, fname_length
, FNAME_HASHSIZE
)];
2991 for (hp
= *hash_bucket
; hp
!= NULL
; hp
= hp
->next
)
2992 if (hp
->length
== fname_length
&&
2993 strncmp (hp
->value
.cpval
, (const char *)fname
, fname_length
) == 0) {
2994 ip
->fname
= hp
->value
.cpval
;
2999 /* Didn't find it; cons up a new one. */
3000 hp
= (HASHNODE
*) xcalloc (1, sizeof (HASHNODE
) + fname_length
+ 1);
3001 hp
->next
= *hash_bucket
;
3004 hp
->length
= fname_length
;
3005 ip
->fname
= hp
->value
.cpval
= q
= ((char *) hp
) + sizeof (HASHNODE
);
3006 memcpy (q
, fname
, fname_length
);
3009 error ("invalid format #line command");
3013 ip
->lineno
= new_lineno
;
3014 output_line_command (ip
, op
, 0, file_change
);
3015 check_expand (op
, ip
->length
- (ip
->bufp
- ip
->buf
));
3019 * remove all definitions of symbol from symbol table.
3020 * according to un*x /lib/cpp, it is not an error to undef
3021 * something that has no definitions, so it isn't one here either.
3024 do_undef (buf
, limit
, op
)
3026 U_CHAR
*limit ATTRIBUTE_UNUSED
;
3027 FILE_BUF
*op ATTRIBUTE_UNUSED
;
3031 SKIP_WHITE_SPACE (buf
);
3033 if (! strncmp ((const char *)buf
, "defined", 7) && ! is_idchar
[buf
[7]])
3034 warning ("undefining `defined'");
3036 while ((hp
= lookup (buf
, -1, -1)) != NULL
) {
3037 if (hp
->type
!= T_MACRO
)
3038 warning ("undefining `%s'", hp
->name
);
3043 /* Read the tokens of the answer into the macro pool. Only commit the
3044 memory if we intend it as permanent storage, i.e. the #assert case.
3045 Returns 0 on success. */
3048 parse_answer (buf
, limit
, answerp
, type
)
3049 const unsigned char *buf
, *limit
;
3050 struct answer
**answerp
;
3053 const unsigned char *start
;
3055 /* Skip leading whitespace. */
3056 if (buf
< limit
&& *buf
== ' ')
3059 /* Parentheses are optional here. */
3060 if (buf
== limit
&& type
== T_UNASSERT
)
3063 if (buf
== limit
|| *buf
++ != '(')
3068 error ("missing '(' after predicate");
3072 /* Drop whitespace at start. */
3073 while (buf
< limit
&& *buf
== ' ')
3077 while (buf
< limit
&& *buf
!= ')')
3082 error ("missing ')' to complete answer");
3088 error ("predicate's answer is empty");
3092 if ((type
== T_ASSERT
|| type
== T_UNASSERT
) && buf
+ 1 != limit
)
3094 error ("extra text at end of directive");
3098 /* Lose trailing whitespace. */
3102 *answerp
= (struct answer
*) xmalloc (sizeof (struct answer
));
3103 (*answerp
)->answer
= start
;
3104 (*answerp
)->len
= buf
- start
;
3109 /* Parses an assertion, returning a pointer to the hash node of the
3110 predicate, or 0 on error. If an answer was supplied, it is placed
3111 in ANSWERP, otherwise it is set to 0. */
3113 parse_assertion (buf
, limit
, answerp
, type
)
3114 const unsigned char *buf
, *limit
;
3115 struct answer
**answerp
;
3118 HASHNODE
*result
= 0;
3119 const unsigned char *climit
;
3120 unsigned char *bp
, *symname
= canonicalize_text (buf
, limit
, &climit
);
3124 if (bp
< climit
&& is_idstart
[*bp
])
3128 while (bp
< climit
&& is_idchar
[*bp
]);
3135 if (symname
== climit
)
3136 error ("assertion without predicate");
3138 error ("predicate must be an identifier");
3140 /* Unfortunately, because of the way we handle #if, we don't avoid
3141 macro expansion in answers. This is not easy to fix. */
3142 else if (parse_answer (bp
, climit
, answerp
, type
) == 0)
3144 unsigned char *sym
= alloca (len
+ 1);
3147 /* Prefix '#' to get it out of macro namespace. */
3149 memcpy (sym
+ 1, symname
, len
);
3151 hashcode
= hashf (sym
, len
+ 1, HASHSIZE
);
3152 result
= lookup (sym
, len
+ 1, hashcode
);
3154 result
= install (sym
, len
+ 1, T_UNUSED
, hashcode
);
3160 /* Test an assertion within a preprocessor conditional. Returns zero
3161 on error or failure, one on success. */
3163 test_assertion (pbuf
)
3164 unsigned char **pbuf
; /* NUL-terminated. */
3166 unsigned char *buf
= *pbuf
;
3167 unsigned char *limit
= buf
+ strlen ((char *) buf
);
3168 struct answer
*answer
;
3172 node
= parse_assertion (buf
, limit
, &answer
, T_IF
);
3175 result
= (node
->type
== T_ASSERT
&&
3176 (answer
== 0 || *find_answer (node
, answer
) != 0));
3178 /* Yuk. We update pbuf to point after the assertion test.
3179 First, move past the identifier. */
3182 while (is_idchar
[*buf
])
3184 /* If we have an answer, we need to move past the parentheses. */
3186 while (*buf
++ != ')')
3194 /* Handle a #assert directive. */
3196 do_assert (buf
, limit
, op
)
3199 FILE_BUF
*op ATTRIBUTE_UNUSED
;
3201 struct answer
*new_answer
;
3204 node
= parse_assertion (buf
, limit
, &new_answer
, T_ASSERT
);
3207 /* Place the new answer in the answer list. First check there
3208 is not a duplicate. */
3209 new_answer
->next
= 0;
3210 if (node
->type
== T_ASSERT
)
3212 if (*find_answer (node
, new_answer
))
3215 warning ("\"%s\" re-asserted", node
->name
+ 1);
3218 new_answer
->next
= node
->value
.answers
;
3220 node
->type
= T_ASSERT
;
3221 node
->value
.answers
= new_answer
;
3225 /* Function body to be provided later. */
3227 do_unassert (buf
, limit
, op
)
3230 FILE_BUF
*op ATTRIBUTE_UNUSED
;
3233 struct answer
*answer
;
3235 node
= parse_assertion (buf
, limit
, &answer
, T_UNASSERT
);
3236 /* It isn't an error to #unassert something that isn't asserted. */
3239 if (node
->type
== T_ASSERT
)
3243 struct answer
**p
= find_answer (node
, answer
), *temp
;
3245 /* Remove the answer from the list. */
3250 /* Did we free the last answer? */
3251 if (node
->value
.answers
== 0)
3252 delete_macro (node
);
3255 delete_macro (node
);
3262 /* Returns a pointer to the pointer to the answer in the answer chain,
3263 or a pointer to NULL if the answer is not in the chain. */
3264 static struct answer
**
3265 find_answer (node
, candidate
)
3267 const struct answer
*candidate
;
3269 struct answer
**result
;
3271 for (result
= &node
->value
.answers
; *result
; result
= &(*result
)->next
)
3273 struct answer
*answer
= *result
;
3275 if (answer
->len
== candidate
->len
3276 && !memcmp (answer
->answer
, candidate
->answer
, answer
->len
))
3283 /* Return a malloced buffer with leading and trailing whitespace
3284 removed, and all instances of internal whitespace reduced to a
3286 static unsigned char *
3287 canonicalize_text (buf
, limit
, climit
)
3288 const unsigned char *buf
, *limit
, **climit
;
3290 unsigned int len
= limit
- buf
;
3291 unsigned char *result
= (unsigned char *) xmalloc (len
), *dest
;
3293 for (dest
= result
; buf
< limit
;)
3295 if (! is_space
[*buf
])
3299 while (++buf
< limit
&& is_space
[*buf
])
3301 if (dest
!= result
&& buf
!= limit
)
3311 * handle #if command by
3312 * 1) inserting special `defined' keyword into the hash table
3313 * that gets turned into 0 or 1 by special_symbol (thus,
3314 * if the luser has a symbol called `defined' already, it won't
3315 * work inside the #if command)
3316 * 2) rescan the input into a temporary output buffer
3317 * 3) pass the output buffer to the yacc parser and collect a value
3318 * 4) clean up the mess left from steps 1 and 2.
3319 * 5) call conditional_skip to skip til the next #endif (etc.),
3320 * or not, depending on the value from step 3.
3323 do_if (buf
, limit
, op
)
3324 U_CHAR
*buf
, *limit
;
3325 FILE_BUF
*op ATTRIBUTE_UNUSED
;
3328 FILE_BUF
*ip
= &instack
[indepth
];
3330 value
= eval_if_expression (buf
, limit
- buf
);
3331 conditional_skip (ip
, value
== 0, T_IF
);
3335 * handle a #elif directive by not changing if_stack either.
3336 * see the comment above do_else.
3339 do_elif (buf
, limit
, op
)
3340 U_CHAR
*buf
, *limit
;
3344 FILE_BUF
*ip
= &instack
[indepth
];
3346 if (if_stack
== instack
[indepth
].if_stack
) {
3347 error ("#elif not within a conditional");
3350 if (if_stack
->type
!= T_IF
&& if_stack
->type
!= T_ELIF
) {
3351 error ("#elif after #else");
3352 fprintf (stderr
, " (matches line %d", if_stack
->lineno
);
3353 if (if_stack
->fname
!= NULL
&& ip
->fname
!= NULL
&&
3354 strcmp (if_stack
->fname
, ip
->fname
) != 0)
3355 fprintf (stderr
, ", file %s", if_stack
->fname
);
3356 fprintf (stderr
, ")\n");
3358 if_stack
->type
= T_ELIF
;
3361 if (if_stack
->if_succeeded
)
3362 skip_if_group (ip
, 0);
3364 value
= eval_if_expression (buf
, limit
- buf
);
3366 skip_if_group (ip
, 0);
3368 ++if_stack
->if_succeeded
; /* continue processing input */
3369 output_line_command (ip
, op
, 1, same_file
);
3375 * evaluate a #if expression in BUF, of length LENGTH,
3376 * then parse the result as a C expression and return the value as an int.
3379 eval_if_expression (buf
, length
)
3384 HASHNODE
*save_defined
;
3387 save_defined
= install (U
"defined", -1, T_SPEC_DEFINED
, -1);
3388 temp_obuf
= expand_to_temp_buffer (buf
, buf
+ length
, 0);
3389 delete_macro (save_defined
); /* clean up special symbol */
3391 value
= parse_c_expression ((const char *)temp_obuf
.buf
);
3393 free (temp_obuf
.buf
);
3399 * routine to handle ifdef/ifndef. Try to look up the symbol,
3400 * then do or don't skip to the #endif/#else/#elif depending
3401 * on what directive is actually being processed.
3404 do_xifdef (buf
, limit
, type
)
3405 U_CHAR
*buf
, *limit
;
3406 enum node_type type
;
3409 FILE_BUF
*ip
= &instack
[indepth
];
3412 /* Discard leading and trailing whitespace. */
3413 SKIP_WHITE_SPACE (buf
);
3414 while (limit
!= buf
&& is_hor_space
[limit
[-1]]) limit
--;
3416 /* Find the end of the identifier at the beginning. */
3417 for (end
= buf
; is_idchar
[*end
]; end
++);
3420 skip
= (type
== T_IFDEF
);
3422 skip
= (lookup (buf
, end
-buf
, -1) == NULL
) ^ (type
== T_IFNDEF
);
3424 conditional_skip (ip
, skip
, T_IF
);
3428 do_ifdef (buf
, limit
, op
)
3429 U_CHAR
*buf
, *limit
;
3430 FILE_BUF
*op ATTRIBUTE_UNUSED
;
3432 do_xifdef (buf
, limit
, T_IFDEF
);
3436 do_ifndef (buf
, limit
, op
)
3437 U_CHAR
*buf
, *limit
;
3438 FILE_BUF
*op ATTRIBUTE_UNUSED
;
3440 do_xifdef (buf
, limit
, T_IFNDEF
);
3444 * push TYPE on stack; then, if SKIP is nonzero, skip ahead.
3447 conditional_skip (ip
, skip
, type
)
3450 enum node_type type
;
3452 IF_STACK_FRAME
*temp
;
3454 temp
= (IF_STACK_FRAME
*) xcalloc (1, sizeof (IF_STACK_FRAME
));
3455 temp
->fname
= ip
->fname
;
3456 temp
->lineno
= ip
->lineno
;
3457 temp
->next
= if_stack
;
3460 if_stack
->type
= type
;
3463 skip_if_group (ip
, 0);
3466 ++if_stack
->if_succeeded
;
3467 output_line_command (ip
, &outbuf
, 1, same_file
);
3472 * skip to #endif, #else, or #elif. adjust line numbers, etc.
3473 * leaves input ptr at the sharp sign found.
3474 * If ANY is nonzero, return at next directive of any sort.
3477 skip_if_group (ip
, any
)
3481 register U_CHAR
*bp
= ip
->bufp
, *cp
;
3482 register U_CHAR
*endb
= ip
->buf
+ ip
->length
;
3483 struct directive
*kt
;
3484 IF_STACK_FRAME
*save_if_stack
= if_stack
; /* don't pop past here */
3485 U_CHAR
*beg_of_line
= bp
;
3489 case '/': /* possible comment */
3490 if (*bp
== '\\' && bp
[1] == '\n')
3494 bp
= skip_to_end_of_comment (ip
, &ip
->lineno
);
3499 bp
= skip_quoted_string (bp
- 1, endb
, ip
->lineno
, &ip
->lineno
, 0, 0);
3502 /* Char after backslash loses its special meaning. */
3505 ++ip
->lineno
; /* But do update the line-count. */
3516 /* # keyword: a # must be first nonblank char on the line */
3517 if (beg_of_line
== 0)
3519 /* Scan from start of line, skipping whitespace, comments
3520 and backslash-newlines, and see if we reach this #.
3521 If not, this # is not special. */
3524 if (is_hor_space
[*bp
])
3526 else if (*bp
== '\\' && bp
[1] == '\n')
3528 else if (*bp
== '/' && bp
[1] == '*') {
3530 while (!(*bp
== '*' && bp
[1] == '/')) {
3539 if (bp
!= ip
->bufp
) {
3540 bp
= ip
->bufp
+ 1; /* Reset bp to after the #. */
3544 bp
= ip
->bufp
+ 1; /* Point after '#'. */
3546 /* Skip whitespace and \-newline. */
3548 if (is_hor_space
[*bp
])
3550 else if (*bp
== '\\' && bp
[1] == '\n')
3552 else if (*bp
== '/' && bp
[1] == '*') {
3554 while (!(*bp
== '*' && bp
[1] == '/'))
3563 /* Now find end of directive name.
3564 If we encounter a backslash-newline, exchange it with any following
3565 symbol-constituents so that we end up with a contiguous name. */
3571 if (*bp
== '\\' && bp
[1] == '\n')
3572 name_newline_fix (bp
);
3579 for (kt
= directive_table
; kt
->length
>= 0; kt
++) {
3580 IF_STACK_FRAME
*temp
;
3581 if (strncmp ((const char *)cp
, kt
->name
, kt
->length
) == 0
3582 && !is_idchar
[cp
[kt
->length
]]) {
3584 /* If we are asked to return on next directive,
3593 temp
= (IF_STACK_FRAME
*) xcalloc (1, sizeof (IF_STACK_FRAME
));
3594 temp
->next
= if_stack
;
3596 temp
->lineno
= ip
->lineno
;
3597 temp
->fname
= ip
->fname
;
3598 temp
->type
= kt
->type
;
3603 if (if_stack
== instack
[indepth
].if_stack
) {
3604 error ("#%s not within a conditional", kt
->name
);
3607 else if (if_stack
== save_if_stack
)
3608 return; /* found what we came for */
3610 if (kt
->type
!= T_ENDIF
) {
3611 if (if_stack
->type
== T_ELSE
)
3612 error ("#else or #elif after #else");
3613 if_stack
->type
= kt
->type
;
3618 if_stack
= if_stack
->next
;
3623 /* Anything else is ignored. */
3632 /* after this returns, rescan will exit because ip->bufp
3633 now points to the end of the buffer.
3634 rescan is responsible for the error message also. */
3638 * handle a #else directive. Do this by just continuing processing
3639 * without changing if_stack ; this is so that the error message
3640 * for missing #endif's etc. will point to the original #if. It
3641 * is possible that something different would be better.
3644 do_else (buf
, limit
, op
)
3645 U_CHAR
*buf ATTRIBUTE_UNUSED
;
3646 U_CHAR
*limit ATTRIBUTE_UNUSED
;
3649 FILE_BUF
*ip
= &instack
[indepth
];
3651 if (if_stack
== instack
[indepth
].if_stack
) {
3652 error ("#else not within a conditional");
3655 if (if_stack
->type
!= T_IF
&& if_stack
->type
!= T_ELIF
) {
3656 error ("#else after #else");
3657 fprintf (stderr
, " (matches line %d", if_stack
->lineno
);
3658 if (strcmp (if_stack
->fname
, ip
->fname
) != 0)
3659 fprintf (stderr
, ", file %s", if_stack
->fname
);
3660 fprintf (stderr
, ")\n");
3662 if_stack
->type
= T_ELSE
;
3665 if (if_stack
->if_succeeded
)
3666 skip_if_group (ip
, 0);
3668 ++if_stack
->if_succeeded
; /* continue processing input */
3669 output_line_command (ip
, op
, 1, same_file
);
3674 * unstack after #endif command
3677 do_endif (buf
, limit
, op
)
3678 U_CHAR
*buf ATTRIBUTE_UNUSED
;
3679 U_CHAR
*limit ATTRIBUTE_UNUSED
;
3682 if (if_stack
== instack
[indepth
].if_stack
)
3683 error ("unbalanced #endif");
3685 IF_STACK_FRAME
*temp
= if_stack
;
3686 if_stack
= if_stack
->next
;
3688 output_line_command (&instack
[indepth
], op
, 1, same_file
);
3693 * Skip a comment, assuming the input ptr immediately follows the
3694 * initial slash-star. Bump line counter as necessary.
3695 * (The canonical line counter is &ip->lineno).
3696 * Don't use this routine (or the next one) if bumping the line
3697 * counter is not sufficient to deal with newlines in the string.
3700 skip_to_end_of_comment (ip
, line_counter
)
3701 register FILE_BUF
*ip
;
3702 int *line_counter
; /* place to remember newlines, or NULL */
3704 register U_CHAR
*limit
= ip
->buf
+ ip
->length
;
3705 register U_CHAR
*bp
= ip
->bufp
;
3706 FILE_BUF
*op
= &outbuf
; /* JF */
3707 int output
= put_out_comments
&& !line_counter
;
3709 /* JF this line_counter stuff is a crock to make sure the
3710 comment is only put out once, no matter how many times
3711 the comment is skipped. It almost works */
3716 while (bp
< limit
) {
3721 if (warn_comments
&& bp
< limit
&& *bp
== '*')
3722 warning("`/*' within comment");
3725 if (line_counter
!= NULL
)
3731 if (*bp
== '\\' && bp
[1] == '\n')
3747 * Skip over a quoted string. BP points to the opening quote.
3748 * Returns a pointer after the closing quote. Don't go past LIMIT.
3749 * START_LINE is the line number of the starting point (but it need
3750 * not be valid if the starting point is inside a macro expansion).
3752 * The input stack state is not changed.
3754 * If COUNT_NEWLINES is nonzero, it points to an int to increment
3755 * for each newline passed.
3757 * If BACKSLASH_NEWLINES_P is nonzero, store 1 thru it
3758 * if we pass a backslash-newline.
3760 * If EOFP is nonzero, set *EOFP to 1 if the string is unterminated.
3763 skip_quoted_string (bp
, limit
, start_line
, count_newlines
, backslash_newlines_p
, eofp
)
3764 register const U_CHAR
*bp
;
3765 register const U_CHAR
*limit
;
3767 int *count_newlines
;
3768 int *backslash_newlines_p
;
3771 register U_CHAR c
, match
;
3776 error_with_line (line_for_error (start_line
),
3777 "unterminated string or character constant");
3784 while (*bp
== '\\' && bp
[1] == '\n') {
3785 if (backslash_newlines_p
)
3786 *backslash_newlines_p
= 1;
3791 if (*bp
== '\n' && count_newlines
) {
3792 if (backslash_newlines_p
)
3793 *backslash_newlines_p
= 1;
3797 } else if (c
== '\n') {
3798 /* Unterminated strings and character constants are 'legal'. */
3799 bp
--; /* Don't consume the newline. */
3803 } else if (c
== match
)
3806 return (U_CHAR
*) bp
;
3810 * write out a #line command, for instance, after an #include file.
3811 * If CONDITIONAL is nonzero, we can omit the #line if it would
3812 * appear to be a no-op, and we can output a few newlines instead
3813 * if we want to increase the line number by a small amount.
3814 * FILE_CHANGE says whether we are entering a file, leaving, or neither.
3818 output_line_command (ip
, op
, conditional
, file_change
)
3821 enum file_change_code file_change
;
3824 char line_cmd_buf
[500];
3826 if (no_line_commands
3827 || ip
->fname
== NULL
3829 op
->lineno
= ip
->lineno
;
3834 if (ip
->lineno
== op
->lineno
)
3837 /* If the inherited line number is a little too small,
3838 output some newlines instead of a #line command. */
3839 if (ip
->lineno
> op
->lineno
&& ip
->lineno
< op
->lineno
+ 8) {
3840 check_expand (op
, 10);
3841 while (ip
->lineno
> op
->lineno
) {
3849 sprintf (line_cmd_buf
, "# %d \"%s\"", ip
->lineno
, ip
->fname
);
3850 if (file_change
!= same_file
)
3851 strcat (line_cmd_buf
, file_change
== enter_file
? " 1" : " 2");
3852 if (system_include_depth
> 0)
3853 strcat (line_cmd_buf
, " 3");
3854 len
= strlen (line_cmd_buf
);
3855 line_cmd_buf
[len
++] = '\n';
3856 check_expand (op
, len
+ 1);
3857 if (op
->bufp
> op
->buf
&& op
->bufp
[-1] != '\n')
3859 memcpy (op
->bufp
, line_cmd_buf
, len
);
3861 op
->lineno
= ip
->lineno
;
3865 /* Expand a macro call.
3866 HP points to the symbol that is the macro being called.
3867 Put the result of expansion onto the input stack
3868 so that subsequent input by our caller will use it.
3870 If macro wants arguments, caller has already verified that
3871 an argument list follows; arguments come from the input stack. */
3874 macroexpand (hp
, op
)
3879 DEFINITION
*defn
= hp
->value
.defn
;
3880 register U_CHAR
*xbuf
;
3882 int start_line
= instack
[indepth
].lineno
;
3884 CHECK_DEPTH (return;);
3886 /* it might not actually be a macro. */
3887 if (hp
->type
!= T_MACRO
) {
3888 special_symbol (hp
, op
);
3892 nargs
= defn
->nargs
;
3896 struct argdata
*args
;
3897 const char *parse_error
= 0;
3899 args
= (struct argdata
*) alloca ((nargs
+ 1) * sizeof (struct argdata
));
3901 for (i
= 0; i
< nargs
; i
++) {
3902 args
[i
].raw
= args
[i
].expanded
= (U_CHAR
*) "";
3903 args
[i
].raw_length
= args
[i
].expand_length
3904 = args
[i
].stringified_length
= 0;
3905 args
[i
].free1
= args
[i
].free2
= 0;
3908 /* Parse all the macro args that are supplied. I counts them.
3909 The first NARGS args are stored in ARGS.
3910 The rest are discarded. */
3913 /* Discard the open-parenthesis or comma before the next arg. */
3914 ++instack
[indepth
].bufp
;
3916 = macarg ((i
< nargs
|| (nargs
== 0 && i
== 0)) ? &args
[i
] : 0);
3919 error_with_line (line_for_error (start_line
), parse_error
);
3923 } while (*instack
[indepth
].bufp
!= ')');
3925 /* If we got one arg but it was just whitespace, call that 0 args. */
3927 register const U_CHAR
*bp
= args
[0].raw
;
3928 register const U_CHAR
*lim
= bp
+ args
[0].raw_length
;
3929 while (bp
!= lim
&& is_space
[*bp
]) bp
++;
3934 if (nargs
== 0 && i
> 0)
3935 error ("arguments given to macro `%s'", hp
->name
);
3936 else if (i
< nargs
) {
3937 /* traditional C allows foo() if foo wants one argument. */
3938 if (nargs
== 1 && i
== 0)
3941 error ("no args to macro `%s'", hp
->name
);
3943 error ("only 1 arg to macro `%s'", hp
->name
);
3945 error ("only %d args to macro `%s'", i
, hp
->name
);
3946 } else if (i
> nargs
)
3947 error ("too many (%d) args to macro `%s'", i
, hp
->name
);
3949 /* Swallow the closeparen. */
3950 ++instack
[indepth
].bufp
;
3952 /* If macro wants zero args, we parsed the arglist for checking only.
3953 Read directly from the macro definition. */
3955 xbuf
= defn
->expansion
;
3956 xbuf_len
= defn
->length
;
3958 register U_CHAR
*exp
= defn
->expansion
;
3959 register int offset
; /* offset in expansion,
3960 copied a piece at a time */
3961 register int totlen
; /* total amount of exp buffer filled so far */
3963 register struct reflist
*ap
;
3965 /* Macro really takes args. Compute the expansion of this call. */
3967 /* Compute length in characters of the macro's expansion. */
3968 xbuf_len
= defn
->length
;
3969 for (ap
= defn
->pattern
; ap
!= NULL
; ap
= ap
->next
) {
3971 xbuf_len
+= args
[ap
->argno
].stringified_length
;
3973 xbuf_len
+= args
[ap
->argno
].raw_length
;
3976 xbuf
= (U_CHAR
*) xmalloc (xbuf_len
+ 1);
3978 /* Generate in XBUF the complete expansion
3979 with arguments substituted in.
3980 TOTLEN is the total size generated so far.
3981 OFFSET is the index in the definition
3982 of where we are copying from. */
3983 offset
= totlen
= 0;
3984 for (ap
= defn
->pattern
; ap
!= NULL
; ap
= ap
->next
) {
3985 register struct argdata
*arg
= &args
[ap
->argno
];
3987 for (i
= 0; i
< ap
->nchars
; i
++)
3988 xbuf
[totlen
++] = exp
[offset
++];
3990 if (ap
->stringify
!= 0) {
3991 int arglen
= arg
->raw_length
;
3997 && (c
= arg
->raw
[i
], is_space
[c
]))
4000 && (c
= arg
->raw
[arglen
- 1], is_space
[c
]))
4002 for (; i
< arglen
; i
++) {
4005 /* Special markers Newline Space
4006 generate nothing for a stringified argument. */
4007 if (c
== '\n' && arg
->raw
[i
+1] != '\n') {
4012 /* Internal sequences of whitespace are replaced by one space
4013 except within an string or char token. */
4015 && (c
== '\n' ? arg
->raw
[i
+1] == '\n' : is_space
[c
])) {
4017 /* Note that Newline Space does occur within whitespace
4018 sequences; consider it part of the sequence. */
4019 if (c
== '\n' && is_space
[arg
->raw
[i
+1]])
4021 else if (c
!= '\n' && is_space
[c
])
4038 } else if (c
== '\"' || c
== '\'')
4042 /* Escape these chars */
4043 if (c
== '\"' || (in_string
&& c
== '\\'))
4044 xbuf
[totlen
++] = '\\';
4048 sprintf ((char *) &xbuf
[totlen
], "\\%03o", (unsigned int) c
);
4053 const U_CHAR
*p1
= arg
->raw
;
4054 const U_CHAR
*l1
= p1
+ arg
->raw_length
;
4056 if (ap
->raw_before
) {
4057 while (p1
!= l1
&& is_space
[*p1
]) p1
++;
4058 while (p1
!= l1
&& is_idchar
[*p1
])
4059 xbuf
[totlen
++] = *p1
++;
4060 /* Delete any no-reexpansion marker that follows
4061 an identifier at the beginning of the argument
4062 if the argument is concatenated with what precedes it. */
4063 if (p1
[0] == '\n' && p1
[1] == '-')
4066 if (ap
->raw_after
) {
4067 /* Arg is concatenated after: delete trailing whitespace,
4068 whitespace markers, and no-reexpansion markers. */
4070 if (is_space
[l1
[-1]]) l1
--;
4071 else if (l1
[-1] == '-') {
4072 const U_CHAR
*p2
= l1
- 1;
4073 /* If a `-' is preceded by an odd number of newlines then it
4074 and the last newline are a no-reexpansion marker. */
4075 while (p2
!= p1
&& p2
[-1] == '\n') p2
--;
4076 if ((l1
- 1 - p2
) & 1) {
4084 memmove (xbuf
+ totlen
, p1
, l1
- p1
);
4088 if (totlen
> xbuf_len
)
4092 /* if there is anything left of the definition
4093 after handling the arg list, copy that in too. */
4095 for (i
= offset
; i
< defn
->length
; i
++)
4096 xbuf
[totlen
++] = exp
[i
];
4101 for (i
= 0; i
< nargs
; i
++) {
4102 if (args
[i
].free1
!= 0)
4103 free (args
[i
].free1
);
4104 if (args
[i
].free2
!= 0)
4105 free (args
[i
].free2
);
4109 xbuf
= defn
->expansion
;
4110 xbuf_len
= defn
->length
;
4113 /* Now put the expansion on the input stack
4114 so our caller will commence reading from it. */
4116 register FILE_BUF
*ip2
;
4118 ip2
= &instack
[++indepth
];
4123 ip2
->length
= xbuf_len
;
4125 ip2
->free_ptr
= (nargs
> 0) ? xbuf
: 0;
4127 ip2
->if_stack
= if_stack
;
4132 * Parse a macro argument and store the info on it into *ARGPTR.
4133 * Return nonzero to indicate a syntax error.
4138 register struct argdata
*argptr
;
4140 FILE_BUF
*ip
= &instack
[indepth
];
4145 /* Try to parse as much of the argument as exists at this
4146 input stack level. */
4147 U_CHAR
*bp
= macarg1 (ip
->bufp
, ip
->buf
+ ip
->length
,
4148 &paren
, &newlines
, &comments
);
4150 /* If we find the end of the argument at this level,
4151 set up *ARGPTR to point at it in the input stack. */
4152 if (!(ip
->fname
!= 0 && (newlines
!= 0 || comments
!= 0))
4153 && bp
!= ip
->buf
+ ip
->length
) {
4155 argptr
->raw
= ip
->bufp
;
4156 argptr
->raw_length
= bp
- ip
->bufp
;
4160 /* This input stack level ends before the macro argument does.
4161 We must pop levels and keep parsing.
4162 Therefore, we must allocate a temporary buffer and copy
4163 the macro argument into it. */
4164 int bufsize
= bp
- ip
->bufp
;
4165 int extra
= newlines
;
4166 U_CHAR
*buffer
= (U_CHAR
*) xmalloc (bufsize
+ extra
+ 1);
4167 int final_start
= 0;
4169 memcpy (buffer
, ip
->bufp
, bufsize
);
4171 ip
->lineno
+= newlines
;
4173 while (bp
== ip
->buf
+ ip
->length
) {
4174 if (instack
[indepth
].macro
== 0) {
4176 return "unterminated macro call";
4178 ip
->macro
->type
= T_MACRO
;
4180 free (ip
->free_ptr
);
4181 ip
= &instack
[--indepth
];
4184 bp
= macarg1 (ip
->bufp
, ip
->buf
+ ip
->length
, &paren
,
4185 &newlines
, &comments
);
4186 final_start
= bufsize
;
4187 bufsize
+= bp
- ip
->bufp
;
4189 buffer
= (U_CHAR
*) xrealloc (buffer
, bufsize
+ extra
+ 1);
4190 memcpy (buffer
+ bufsize
- (bp
- ip
->bufp
), ip
->bufp
, bp
- ip
->bufp
);
4192 ip
->lineno
+= newlines
;
4195 /* Now, if arg is actually wanted, record its raw form,
4196 discarding comments and duplicating newlines in whatever
4197 part of it did not come from a macro expansion.
4198 EXTRA space has been preallocated for duplicating the newlines.
4199 FINAL_START is the index of the start of that part. */
4201 argptr
->raw
= buffer
;
4202 argptr
->raw_length
= bufsize
;
4203 argptr
->free1
= buffer
;
4204 argptr
->newlines
= newlines
;
4205 argptr
->comments
= comments
;
4206 if ((newlines
|| comments
) && ip
->fname
!= 0)
4209 discard_comments (argptr
->raw
+ final_start
,
4210 argptr
->raw_length
- final_start
,
4212 argptr
->raw
[argptr
->raw_length
] = 0;
4213 if (argptr
->raw_length
> bufsize
+ extra
)
4218 /* If we are not discarding this argument,
4219 macroexpand it and compute its length as stringified.
4220 All this info goes into *ARGPTR. */
4224 register const U_CHAR
*buf
, *lim
;
4225 register int totlen
;
4227 obuf
= expand_to_temp_buffer (argptr
->raw
,
4228 argptr
->raw
+ argptr
->raw_length
,
4231 argptr
->expanded
= obuf
.buf
;
4232 argptr
->expand_length
= obuf
.length
;
4233 argptr
->free2
= obuf
.buf
;
4236 lim
= buf
+ argptr
->raw_length
;
4239 while (buf
!= lim
) {
4240 register U_CHAR c
= *buf
++;
4242 /* Internal sequences of whitespace are replaced by one space
4243 in most cases, but not always. So count all the whitespace
4244 in case we need to keep it all. */
4245 if (c
== '\"' || c
== '\\') /* escape these chars */
4247 else if (!ISPRINT (c
))
4250 argptr
->stringified_length
= totlen
;
4255 /* Scan text from START (inclusive) up to LIMIT (exclusive),
4256 counting parens in *DEPTHPTR,
4257 and return if reach LIMIT
4258 or before a `)' that would make *DEPTHPTR negative
4259 or before a comma when *DEPTHPTR is zero.
4260 Single and double quotes are matched and termination
4261 is inhibited within them. Comments also inhibit it.
4262 Value returned is pointer to stopping place.
4264 Increment *NEWLINES each time a newline is passed.
4265 Set *COMMENTS to 1 if a comment is seen. */
4268 macarg1 (start
, limit
, depthptr
, newlines
, comments
)
4270 register const U_CHAR
*limit
;
4271 int *depthptr
, *newlines
, *comments
;
4273 register U_CHAR
*bp
= start
;
4275 while (bp
< limit
) {
4281 if (--(*depthptr
) < 0)
4285 /* Traditionally, backslash makes following char not special. */
4289 /* But count source lines anyway. */
4298 if (bp
[1] == '\\' && bp
[2] == '\n')
4299 newline_fix (bp
+ 1);
4300 if (bp
[1] != '*' || bp
+ 1 >= limit
)
4304 while (bp
+ 1 < limit
) {
4306 && bp
[1] == '\\' && bp
[2] == '\n')
4307 newline_fix (bp
+ 1);
4308 if (bp
[0] == '*' && bp
[1] == '/')
4310 if (*bp
== '\n') ++*newlines
;
4319 for (quotec
= *bp
++; bp
+ 1 < limit
&& *bp
!= quotec
; bp
++) {
4324 while (*bp
== '\\' && bp
[1] == '\n') {
4327 } else if (*bp
== '\n') {
4336 if ((*depthptr
) == 0)
4346 /* Discard comments and duplicate newlines
4347 in the string of length LENGTH at START,
4348 except inside of string constants.
4349 The string is copied into itself with its beginning staying fixed.
4351 NEWLINES is the number of newlines that must be duplicated.
4352 We assume that that much extra space is available past the end
4356 discard_comments (start
, length
, newlines
)
4361 register U_CHAR
*ibp
;
4362 register U_CHAR
*obp
;
4363 register const U_CHAR
*limit
;
4366 /* If we have newlines to duplicate, copy everything
4367 that many characters up. Then, in the second part,
4368 we will have room to insert the newlines
4370 NEWLINES may actually be too large, because it counts
4371 newlines in string constants, and we don't duplicate those.
4372 But that does no harm. */
4374 ibp
= start
+ length
;
4375 obp
= ibp
+ newlines
;
4377 while (limit
!= ibp
)
4381 ibp
= start
+ newlines
;
4382 limit
= start
+ length
+ newlines
;
4385 while (ibp
< limit
) {
4386 *obp
++ = c
= *ibp
++;
4389 /* Duplicate the newline. */
4401 if (*ibp
== '\\' && ibp
[1] == '\n')
4403 /* Delete any comment. */
4404 if (ibp
[0] != '*' || ibp
+ 1 >= limit
)
4408 while (ibp
+ 1 < limit
) {
4410 && ibp
[1] == '\\' && ibp
[2] == '\n')
4411 newline_fix (ibp
+ 1);
4412 if (ibp
[0] == '*' && ibp
[1] == '/')
4421 /* Notice and skip strings, so that we don't
4422 think that comments start inside them,
4423 and so we don't duplicate newlines in them. */
4426 while (ibp
< limit
) {
4427 *obp
++ = c
= *ibp
++;
4430 if (c
== '\n' && quotec
== '\'')
4432 if (c
== '\\' && ibp
< limit
) {
4433 while (*ibp
== '\\' && ibp
[1] == '\n')
4447 /* Core error handling routine. */
4449 v_message (mtype
, line
, msgid
, ap
)
4455 const char *fname
= 0;
4458 if (mtype
== WARNING
&& inhibit_warnings
)
4461 for (i
= indepth
; i
>= 0; i
--)
4462 if (instack
[i
].fname
!= NULL
) {
4464 line
= instack
[i
].lineno
;
4465 fname
= instack
[i
].fname
;
4470 fprintf (stderr
, "%s:%d: ", fname
, line
);
4472 fprintf (stderr
, "%s: ", progname
);
4474 if (mtype
== WARNING
)
4475 fputs ("warning: ", stderr
);
4477 vfprintf (stderr
, msgid
, ap
);
4478 putc ('\n', stderr
);
4485 * error - print error message and increment count of errors.
4488 error
VPARAMS ((const char *msgid
, ...))
4490 #ifndef ANSI_PROTOTYPES
4495 VA_START(ap
, msgid
);
4497 #ifndef ANSI_PROTOTYPES
4498 msgid
= va_arg (ap
, const char *);
4501 v_message (ERROR
, 0, msgid
, ap
);
4505 error_with_line
VPARAMS ((int line
, const char *msgid
, ...))
4507 #ifndef ANSI_PROTOTYPES
4513 VA_START(ap
, msgid
);
4515 #ifndef ANSI_PROTOTYPES
4516 line
= va_arg (ap
, int);
4517 msgid
= va_arg (ap
, const char *);
4520 v_message (ERROR
, line
, msgid
, ap
);
4523 /* Error including a message from `errno'. */
4525 error_from_errno (name
)
4528 error ("%s: %s", name
, strerror (errno
));
4531 /* Print error message but don't count it. */
4533 warning
VPARAMS ((const char *msgid
, ...))
4535 #ifndef ANSI_PROTOTYPES
4540 VA_START(ap
, msgid
);
4542 #ifndef ANSI_PROTOTYPES
4543 msgid
= va_arg (ap
, const char *);
4546 v_message (WARNING
, 0, msgid
, ap
);
4550 fatal
VPARAMS ((const char *msgid
, ...))
4552 #ifndef ANSI_PROTOTYPES
4557 VA_START(ap
, msgid
);
4559 #ifndef ANSI_PROTOTYPES
4560 msgid
= va_arg (ap
, const char *);
4563 v_message (FATAL
, 0, msgid
, ap
);
4564 exit (FATAL_EXIT_CODE
);
4567 /* More 'friendly' abort that prints the location at which we died. */
4569 fancy_abort (line
, func
)
4573 fatal ("Internal error in %s, at tradcpp.c:%d\n\
4574 Please submit a full bug report.\n\
4575 See %s for instructions.", func
, line
, GCCBUGURL
);
4579 perror_with_name (name
)
4582 fprintf (stderr
, "%s: %s: %s\n", progname
, name
, strerror (errno
));
4587 pfatal_with_name (name
)
4590 perror_with_name (name
);
4591 exit (FATAL_EXIT_CODE
);
4594 /* Return the line at which an error occurred.
4595 The error is not necessarily associated with the current spot
4596 in the input stack, so LINE says where. LINE will have been
4597 copied from ip->lineno for the current input level.
4598 If the current level is for a file, we return LINE.
4599 But if the current level is not for a file, LINE is meaningless.
4600 In that case, we return the lineno of the innermost file. */
4602 line_for_error (line
)
4608 for (i
= indepth
; i
>= 0; ) {
4609 if (instack
[i
].fname
!= 0)
4614 line1
= instack
[i
].lineno
;
4620 * If OBUF doesn't have NEEDED bytes after OPTR, make it bigger.
4622 * As things stand, nothing is ever placed in the output buffer to be
4623 * removed again except when it's KNOWN to be part of an identifier,
4624 * so flushing and moving down everything left, instead of expanding,
4629 grow_outbuf (obuf
, needed
)
4630 register FILE_BUF
*obuf
;
4631 register int needed
;
4636 if (obuf
->length
- (obuf
->bufp
- obuf
->buf
) > needed
)
4639 /* Make it at least twice as big as it is now. */
4641 /* Make it have at least 150% of the free space we will need. */
4642 minsize
= (3 * needed
) / 2 + (obuf
->bufp
- obuf
->buf
);
4643 if (minsize
> obuf
->length
)
4644 obuf
->length
= minsize
;
4646 p
= (U_CHAR
*) xrealloc (obuf
->buf
, obuf
->length
);
4647 obuf
->bufp
= p
+ (obuf
->bufp
- obuf
->buf
);
4651 /* Symbol table for macro names and special symbols */
4654 * install a name in the main hash table, even if it is already there.
4655 * name stops with first non alphanumeric, except leading '#'.
4656 * caller must check against redefinition if that is desired.
4657 * delete_macro () removes things installed by install () in fifo order.
4658 * this is important because of the `defined' special symbol used
4659 * in #if, and also if pushdef/popdef directives are ever implemented.
4661 * If LEN is >= 0, it is the length of the name.
4662 * Otherwise, compute the length by scanning the entire name.
4664 * If HASH is >= 0, it is the precomputed hash code.
4665 * Otherwise, compute the hash code.
4667 * caller must set the value, if any is desired.
4670 install (name
, len
, type
, hash
)
4673 enum node_type type
;
4675 /* watch out here if sizeof (U_CHAR *) != sizeof (int) */
4677 register HASHNODE
*hp
;
4678 register int bucket
;
4679 register const U_CHAR
*p
;
4684 while (is_idchar
[*p
])
4690 hash
= hashf (name
, len
, HASHSIZE
);
4692 hp
= (HASHNODE
*) xmalloc (sizeof (HASHNODE
) + len
+ 1);
4694 hp
->bucket_hdr
= &hashtab
[bucket
];
4695 hp
->next
= hashtab
[bucket
];
4696 hashtab
[bucket
] = hp
;
4698 if (hp
->next
!= NULL
)
4699 hp
->next
->prev
= hp
;
4702 hp
->name
= q
= ((U_CHAR
*) hp
) + sizeof (HASHNODE
);
4703 memcpy (q
, name
, len
);
4709 * find the most recent hash node for name name (ending with first
4710 * non-identifier char) installed by install
4712 * If LEN is >= 0, it is the length of the name.
4713 * Otherwise, compute the length by scanning the entire name.
4715 * If HASH is >= 0, it is the precomputed hash code.
4716 * Otherwise, compute the hash code.
4719 lookup (name
, len
, hash
)
4724 register const U_CHAR
*bp
;
4725 register HASHNODE
*bucket
;
4728 for (bp
= name
; is_idchar
[*bp
]; bp
++) ;
4733 hash
= hashf (name
, len
, HASHSIZE
);
4735 bucket
= hashtab
[hash
];
4737 if (bucket
->length
== len
4738 && strncmp ((const char *)bucket
->name
, (const char *)name
, len
) == 0)
4740 bucket
= bucket
->next
;
4746 * Delete a hash node. Some weirdness to free junk from macros.
4747 * More such weirdness will have to be added if you define more hash
4748 * types that need it.
4751 /* Note that the DEFINITION of a macro is removed from the hash table
4752 but its storage is not freed. This would be a storage leak
4753 except that it is not reasonable to keep undefining and redefining
4754 large numbers of macros many times.
4755 In any case, this is necessary, because a macro can be #undef'd
4756 in the middle of reading the arguments to a call to it.
4757 If #undef freed the DEFINITION, that would crash. */
4763 if (hp
->prev
!= NULL
)
4764 hp
->prev
->next
= hp
->next
;
4765 if (hp
->next
!= NULL
)
4766 hp
->next
->prev
= hp
->prev
;
4768 /* make sure that the bucket chain header that
4769 the deleted guy was on points to the right thing afterwards. */
4770 if (hp
== *hp
->bucket_hdr
)
4771 *hp
->bucket_hdr
= hp
->next
;
4777 * return hash function on name. must be compatible with the one
4778 * computed a step at a time, elsewhere
4781 hashf (name
, len
, hashsize
)
4782 register const U_CHAR
*name
;
4789 r
= HASHSTEP (r
, *name
++);
4791 return MAKE_POS (r
) % hashsize
;
4794 /* Dump all macro definitions as #defines to stdout. */
4801 for (bucket
= 0; bucket
< HASHSIZE
; bucket
++) {
4802 register HASHNODE
*hp
;
4804 for (hp
= hashtab
[bucket
]; hp
; hp
= hp
->next
) {
4805 if (hp
->type
== T_MACRO
) {
4806 register DEFINITION
*defn
= hp
->value
.defn
;
4812 /* Print the definition of the macro HP. */
4814 printf ("#define %s", hp
->name
);
4815 if (defn
->nargs
>= 0) {
4819 for (i
= 0; i
< defn
->nargs
; i
++) {
4820 dump_arg_n (defn
, i
);
4821 if (i
+ 1 < defn
->nargs
)
4831 for (ap
= defn
->pattern
; ap
!= NULL
; ap
= ap
->next
) {
4832 dump_defn_1 (defn
->expansion
, offset
, ap
->nchars
);
4833 if (ap
->nchars
!= 0)
4835 offset
+= ap
->nchars
;
4838 if (ap
->raw_before
&& !concat
)
4841 dump_arg_n (defn
, ap
->argno
);
4842 if (ap
->raw_after
) {
4847 dump_defn_1 (defn
->expansion
, offset
, defn
->length
- offset
);
4854 /* Output to stdout a substring of a macro definition.
4855 BASE is the beginning of the definition.
4856 Output characters START thru LENGTH.
4857 Discard newlines outside of strings, thus
4858 converting funny-space markers to ordinary spaces. */
4860 dump_defn_1 (base
, start
, length
)
4865 const U_CHAR
*p
= base
+ start
;
4866 const U_CHAR
*limit
= base
+ start
+ length
;
4871 else if (*p
== '\"' || *p
=='\'') {
4872 const U_CHAR
*p1
= skip_quoted_string (p
, limit
, 0, 0, 0, 0);
4873 fwrite (p
, p1
- p
, 1, stdout
);
4880 /* Print the name of argument number ARGNUM of macro definition DEFN.
4881 Recall that DEFN->argnames contains all the arg names
4882 concatenated in reverse order with comma-space in between. */
4884 dump_arg_n (defn
, argnum
)
4888 register const U_CHAR
*p
= defn
->argnames
;
4889 while (argnum
+ 1 < defn
->nargs
) {
4890 p
= (const U_CHAR
*) strchr ((const char *)p
, ' ') + 1;
4894 while (*p
&& *p
!= ',') {
4900 /* Initialize syntactic classifications of characters. */
4902 initialize_char_syntax ()
4907 * Set up is_idchar and is_idstart tables. These should be
4908 * faster than saying (is_alpha (c) || c == '_'), etc.
4909 * Must do set up these things before calling any routines tthat
4912 for (i
= 'a'; i
<= 'z'; i
++) {
4913 is_idchar
[i
- 'a' + 'A'] = 1;
4915 is_idstart
[i
- 'a' + 'A'] = 1;
4918 for (i
= '0'; i
<= '9'; i
++)
4921 is_idstart
['_'] = 1;
4923 /* horizontal space table */
4924 is_hor_space
[' '] = 1;
4925 is_hor_space
['\t'] = 1;
4926 is_hor_space
['\v'] = 1;
4927 is_hor_space
['\f'] = 1;
4928 is_hor_space
['\r'] = 1;
4938 /* Initialize the built-in macros. */
4939 #define DSC(x) U x, sizeof x - 1
4940 #define install_spec(name, type) \
4941 install(DSC(name), type, -1);
4942 #define install_value(name, val) \
4943 hp = install(DSC(name), T_CONST, -1); hp->value.cpval = val;
4945 initialize_builtins ()
4949 install_spec ("__BASE_FILE__", T_BASE_FILE
);
4950 install_spec ("__DATE__", T_DATE
);
4951 install_spec ("__FILE__", T_FILE
);
4952 install_spec ("__TIME__", T_TIME
);
4953 install_spec ("__VERSION__", T_VERSION
);
4954 install_spec ("__INCLUDE_LEVEL__", T_INCLUDE_LEVEL
);
4955 install_spec ("__LINE__", T_SPECLINE
);
4957 #ifndef NO_BUILTIN_SIZE_TYPE
4958 install_value ("__SIZE_TYPE__", SIZE_TYPE
);
4960 #ifndef NO_BUILTIN_PTRDIFF_TYPE
4961 install_value ("__PTRDIFF_TYPE__", PTRDIFF_TYPE
);
4963 #ifndef NO_BUILTIN_WCHAR_TYPE
4964 install_value ("__WCHAR_TYPE__", WCHAR_TYPE
);
4966 #ifndef NO_BUILTIN_WINT_TYPE
4967 install_value ("__WINT_TYPE__", WINT_TYPE
);
4969 install_value ("__REGISTER_PREFIX__", REGISTER_PREFIX
);
4970 install_value ("__USER_LABEL_PREFIX__", user_label_prefix
);
4974 #undef install_value
4976 /* Common handler of command line directives -U, -D and -A. */
4978 run_directive (str
, len
, type
)
4981 enum node_type type
;
4983 struct directive
*kt
;
4984 FILE_BUF
*ip
= &instack
[++indepth
];
4985 ip
->fname
= "*command line*";
4987 ip
->buf
= ip
->bufp
= (U_CHAR
*) str
;
4992 ip
->if_stack
= if_stack
;
4994 for (kt
= directive_table
; kt
->type
!= type
; kt
++)
4997 (*kt
->func
) ((U_CHAR
*) str
, (U_CHAR
*) str
+ len
, NULL
);
5001 /* Handle the -D option. If STR is just an identifier, define it with
5002 * value 1. If STR has anything after the identifier, then it should
5003 * be identifier-space-definition. */
5005 make_definition (str
)
5011 /* Copy the entire option so we can modify it.
5012 Change the first "=" in the string to a space. If there is none,
5013 tack " 1" on the end. */
5015 /* Length including the null. */
5016 count
= strlen (str
);
5017 buf
= (char *) alloca (count
+ 2);
5018 memcpy (buf
, str
, count
);
5020 p
= strchr (str
, '=');
5029 run_directive (buf
, count
, T_DEFINE
);
5032 /* Handle the -U option. */
5037 run_directive (str
, strlen (str
), T_UNDEF
);
5040 /* Handles the #assert (-A) and #unassert (-A-) command line options. */
5042 make_assertion (str
)
5045 enum node_type type
= T_ASSERT
;
5055 count
= strlen (str
);
5056 p
= strchr (str
, '=');
5059 /* Copy the entire option so we can modify it. Change the first
5060 "=" in the string to a '(', and tack a ')' on the end. */
5061 char *buf
= (char *) alloca (count
+ 1);
5063 memcpy (buf
, str
, count
);
5069 run_directive (str
, count
, type
);
5072 /* Add output to `deps_buffer' for the -M switch.
5073 STRING points to the text to be output.
5074 SIZE is the number of bytes, or 0 meaning output until a null.
5075 If SIZE is nonzero, we break the line first, if it is long enough. */
5077 deps_output (string
, size
)
5081 #ifndef MAX_OUTPUT_COLUMNS
5082 #define MAX_OUTPUT_COLUMNS 75
5084 if (size
!= 0 && deps_column
!= 0
5085 && size
+ deps_column
> MAX_OUTPUT_COLUMNS
) {
5086 deps_output ("\\\n ", 0);
5091 size
= strlen (string
);
5093 if (deps_size
+ size
+ 1 > deps_allocated_size
) {
5094 deps_allocated_size
= deps_size
+ size
+ 50;
5095 deps_allocated_size
*= 2;
5096 deps_buffer
= (char *) xrealloc (deps_buffer
, deps_allocated_size
);
5098 memcpy (&deps_buffer
[deps_size
], string
, size
);
5100 deps_column
+= size
;
5101 deps_buffer
[deps_size
] = 0;
5104 /* Get the file-mode and data size of the file open on FD
5105 and store them in *MODE_POINTER and *SIZE_POINTER. */
5108 file_size_and_mode (fd
, mode_pointer
, size_pointer
)
5115 if (fstat (fd
, &sbuf
) < 0) return -1;
5116 if (mode_pointer
) *mode_pointer
= sbuf
.st_mode
;
5117 if (size_pointer
) *size_pointer
= sbuf
.st_size
;