2 Copyright (C) 1986, 87, 89, 92-6, 1997 Free Software Foundation, Inc.
3 Contributed by Per Bothner, 1994-95.
4 Based on CCCP program by Paul Rubin, June 1986
5 Adapted to ANSI C, Richard Stallman, Jan 1987
7 This program is free software; you can redistribute it and/or modify it
8 under the terms of the GNU General Public License as published by the
9 Free Software Foundation; either version 2, or (at your option) any
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
21 In other words, you are welcome to use, share and improve this program.
22 You are forbidden to forbid anyone else to use, share and improve
23 what you give them. Help stamp out software-hoarding! */
27 #include "../src/config.h"
35 /* The macro EMACS is defined when cpp is distributed as part of Emacs,
36 for the sake of machines with limited C compilers. */
39 #endif /* not EMACS */
41 #ifndef STANDARD_INCLUDE_DIR
42 #define STANDARD_INCLUDE_DIR "/usr/include"
45 #if 0 /* We can't get ptrdiff_t, so I arranged not to need PTR_INT_TYPE. */
47 #define PTR_INT_TYPE ptrdiff_t
49 #define PTR_INT_TYPE long
60 /* By default, colon separates directories in a path. */
61 #ifndef PATH_SEPARATOR
62 #define PATH_SEPARATOR ':'
74 #include <sys/time.h> /* for __DATE__ and __TIME__ */
75 #include <sys/resource.h>
77 #include <sys/times.h>
83 /* This defines "errno" properly for VMS, and gives us EACCES. */
86 extern char *index ();
87 extern char *rindex ();
95 #define MIN(X,Y) ((X) < (Y) ? (X) : (Y))
96 #define MAX(X,Y) ((X) > (Y) ? (X) : (Y))
98 /* Find the largest host integer type and set its size and type. */
100 #ifndef HOST_BITS_PER_WIDE_INT
102 #if HOST_BITS_PER_LONG > HOST_BITS_PER_INT
103 #define HOST_BITS_PER_WIDE_INT HOST_BITS_PER_LONG
104 #define HOST_WIDE_INT long
106 #define HOST_BITS_PER_WIDE_INT HOST_BITS_PER_INT
107 #define HOST_WIDE_INT int
113 #define S_ISREG(m) (((m) & S_IFMT) == S_IFREG)
117 #define S_ISDIR(m) (((m) & S_IFMT) == S_IFDIR)
120 /* Define a generic NULL if one hasn't already been defined. */
127 #if defined (USE_PROTOTYPES) ? USE_PROTOTYPES : defined (__STDC__)
128 #define GENERIC_PTR void *
130 #define GENERIC_PTR char *
135 #define NULL_PTR ((GENERIC_PTR) 0)
138 #ifndef INCLUDE_LEN_FUDGE
139 #define INCLUDE_LEN_FUDGE 0
142 /* Symbols to predefine. */
144 #ifdef CPP_PREDEFINES
145 static char *predefs
= CPP_PREDEFINES
;
147 static char *predefs
= "";
150 /* We let tm.h override the types used here, to handle trivial differences
151 such as the choice of unsigned int or long unsigned int for size_t.
152 When machines start needing nontrivial differences in the size type,
153 it would be best to do something here to figure out automatically
154 from other information what type to use. */
156 /* The string value for __SIZE_TYPE__. */
159 #define SIZE_TYPE "long unsigned int"
162 /* The string value for __PTRDIFF_TYPE__. */
165 #define PTRDIFF_TYPE "long int"
168 /* The string value for __WCHAR_TYPE__. */
171 #define WCHAR_TYPE "int"
173 #define CPP_WCHAR_TYPE(PFILE) \
174 (CPP_OPTIONS (PFILE)->cplusplus ? "__wchar_t" : WCHAR_TYPE)
176 /* The string value for __USER_LABEL_PREFIX__ */
178 #ifndef USER_LABEL_PREFIX
179 #define USER_LABEL_PREFIX ""
182 /* The string value for __REGISTER_PREFIX__ */
184 #ifndef REGISTER_PREFIX
185 #define REGISTER_PREFIX ""
188 /* In the definition of a #assert name, this structure forms
189 a list of the individual values asserted.
190 Each value is itself a list of "tokens".
191 These are strings that are compared by name. */
193 struct tokenlist_list
{
194 struct tokenlist_list
*next
;
195 struct arglist
*tokens
;
198 struct assertion_hashnode
{
199 struct assertion_hashnode
*next
; /* double links for easy deletion */
200 struct assertion_hashnode
*prev
;
201 /* also, a back pointer to this node's hash
202 chain is kept, in case the node is the head
203 of the chain and gets deleted. */
204 struct assertion_hashnode
**bucket_hdr
;
205 int length
; /* length of token, for quick comparison */
206 U_CHAR
*name
; /* the actual name */
207 /* List of token-sequences. */
208 struct tokenlist_list
*value
;
211 #define SKIP_WHITE_SPACE(p) do { while (is_hor_space[*p]) p++; } while (0)
212 #define SKIP_ALL_WHITE_SPACE(p) do { while (is_space[*p]) p++; } while (0)
214 #define PEEKN(N) (CPP_BUFFER (pfile)->rlimit - CPP_BUFFER (pfile)->cur >= (N) ? CPP_BUFFER (pfile)->cur[N] : EOF)
215 #define FORWARD(N) CPP_FORWARD (CPP_BUFFER (pfile), (N))
216 #define GETC() CPP_BUF_GET (CPP_BUFFER (pfile))
217 #define PEEKC() CPP_BUF_PEEK (CPP_BUFFER (pfile))
218 /* CPP_IS_MACRO_BUFFER is true if the buffer contains macro expansion.
219 (Note that it is false while we're expanding marco *arguments*.) */
220 #define CPP_IS_MACRO_BUFFER(PBUF) ((PBUF)->cleanup == macro_cleanup)
222 /* Move all backslash-newline pairs out of embarrassing places.
223 Exchange all such pairs following BP
224 with any potentially-embarrassing characters that follow them.
225 Potentially-embarrassing characters are / and *
226 (because a backslash-newline inside a comment delimiter
227 would cause it not to be recognized). */
229 #define NEWLINE_FIX \
230 do {while (PEEKC() == '\\' && PEEKN(1) == '\n') FORWARD(2); } while(0)
232 /* Same, but assume we've already read the potential '\\' into C. */
233 #define NEWLINE_FIX1(C) do { \
234 while ((C) == '\\' && PEEKC() == '\n') { FORWARD(1); (C) = GETC(); }\
238 struct cpp_pending
*next
;
243 /* Forward declarations. */
245 extern char *xmalloc ();
247 static void add_import ();
248 static void append_include_chain ();
249 static void make_undef ();
250 static void make_assertion ();
251 static void path_include ();
252 static void initialize_builtins ();
253 static void initialize_char_syntax ();
254 static void dump_arg_n ();
255 static void dump_defn_1 ();
256 extern void delete_macro ();
257 static void trigraph_pcp ();
258 static int finclude ();
259 static void validate_else ();
260 static int comp_def_part ();
262 extern void fancy_abort ();
264 static void pipe_closed ();
265 static void print_containing_files ();
266 static int lookup_import ();
267 static int redundant_include_p ();
268 static is_system_include ();
269 static struct file_name_map
*read_name_map ();
270 static char *read_filename_string ();
271 static int open_include_file ();
272 static int check_preconditions ();
273 static void pcfinclude ();
274 static void pcstring_used ();
275 static int check_macro_name ();
276 static int compare_defs ();
277 static int compare_token_lists ();
278 static HOST_WIDE_INT
eval_if_expression ();
279 static int change_newlines ();
281 static int file_size_and_mode ();
282 static struct arglist
*read_token_list ();
283 static void free_token_list ();
284 static int safe_read ();
285 static void push_macro_expansion
PARAMS ((cpp_reader
*,
286 U_CHAR
*, int, HASHNODE
*));
287 static struct cpp_pending
*nreverse_pending
PARAMS ((struct cpp_pending
*));
288 extern char *xrealloc ();
289 static char *xcalloc ();
290 static char *savestring ();
292 static void conditional_skip ();
293 static void skip_if_group ();
295 /* Last arg to output_line_command. */
296 enum file_change_code
{same_file
, enter_file
, leave_file
};
298 /* External declarations. */
300 extern HOST_WIDE_INT cpp_parse_expr
PARAMS ((cpp_reader
*));
302 extern char *getenv ();
303 extern FILE *fdopen ();
304 extern char *version_string
;
305 extern struct tm
*localtime ();
307 /* These functions are declared to return int instead of void since they
308 are going to be placed in a table and some old compilers have trouble with
309 pointers to functions returning void. */
311 static int do_define ();
312 static int do_line ();
313 static int do_include ();
314 static int do_undef ();
315 static int do_error ();
316 static int do_pragma ();
317 static int do_ident ();
319 static int do_xifdef ();
320 static int do_else ();
321 static int do_elif ();
322 static int do_endif ();
323 static int do_sccs ();
324 static int do_once ();
325 static int do_assert ();
326 static int do_unassert ();
327 static int do_warning ();
329 struct file_name_list
331 struct file_name_list
*next
;
333 /* If the following is nonzero, it is a macro name.
334 Don't include the file again if that macro is defined. */
335 U_CHAR
*control_macro
;
336 /* If the following is nonzero, it is a C-language system include
338 int c_system_include_path
;
339 /* Mapping of file names for this directory. */
340 struct file_name_map
*name_map
;
341 /* Non-zero if name_map is valid. */
345 /* If a buffer's dir field is SELF_DIR_DUMMY, it means the file was found
346 via the same directory as the file that #included it. */
347 #define SELF_DIR_DUMMY ((struct file_name_list *) (~0))
349 /* #include "file" looks in source file dir, then stack. */
350 /* #include <file> just looks in the stack. */
351 /* -I directories are added to the end, then the defaults are added. */
353 static struct default_include
{
354 char *fname
; /* The name of the directory. */
355 int cplusplus
; /* Only look here if we're compiling C++. */
356 int cxx_aware
; /* Includes in this directory don't need to
357 be wrapped in extern "C" when compiling
359 } include_defaults_array
[]
360 #ifdef INCLUDE_DEFAULTS
364 /* Pick up GNU C++ specific include files. */
365 { GPLUSPLUS_INCLUDE_DIR
, 1, 1 },
366 { OLD_GPLUSPLUS_INCLUDE_DIR
, 1, 1 },
368 /* This is the dir for fixincludes. Put it just before
369 the files that we fix. */
370 { GCC_INCLUDE_DIR
, 0, 0 },
371 /* For cross-compilation, this dir name is generated
372 automatically in Makefile.in. */
373 { CROSS_INCLUDE_DIR
, 0, 0 },
374 #ifdef TOOL_INCLUDE_DIR
375 /* This is another place that the target system's headers might be. */
376 { TOOL_INCLUDE_DIR
, 0, 1 },
378 #else /* not CROSS_COMPILE */
379 #ifdef LOCAL_INCLUDE_DIR
380 /* This should be /usr/local/include and should come before
381 the fixincludes-fixed header files. */
382 { LOCAL_INCLUDE_DIR
, 0, 1 },
384 #ifdef TOOL_INCLUDE_DIR
385 /* This is here ahead of GCC_INCLUDE_DIR because assert.h goes here.
386 Likewise, behind LOCAL_INCLUDE_DIR, where glibc puts its assert.h. */
387 { TOOL_INCLUDE_DIR
, 0, 1 },
389 /* This is the dir for fixincludes. Put it just before
390 the files that we fix. */
391 { GCC_INCLUDE_DIR
, 0, 0 },
392 /* Some systems have an extra dir of include files. */
393 #ifdef SYSTEM_INCLUDE_DIR
394 { SYSTEM_INCLUDE_DIR
, 0, 0 },
396 { STANDARD_INCLUDE_DIR
, 0, 0 },
397 #endif /* not CROSS_COMPILE */
400 #endif /* no INCLUDE_DEFAULTS */
402 /* `struct directive' defines one #-directive, including how to handle it. */
405 int length
; /* Length of name */
406 int (*func
)(); /* Function to handle directive */
407 char *name
; /* Name of directive */
408 enum node_type type
; /* Code which describes which directive. */
409 char command_reads_line
; /* One if rest of line is read by func. */
410 char traditional_comments
; /* Nonzero: keep comments if -traditional. */
411 char pass_thru
; /* Copy preprocessed directive to output file.*/
414 /* Here is the actual list of #-directives, most-often-used first.
415 The initialize_builtins function assumes #define is the very first. */
417 static struct directive directive_table
[] = {
418 { 6, do_define
, "define", T_DEFINE
, 0, 1},
419 { 5, do_xifdef
, "ifdef", T_IFDEF
, 1},
420 { 6, do_xifdef
, "ifndef", T_IFNDEF
, 1},
421 { 7, do_include
, "include", T_INCLUDE
, 1},
422 { 12, do_include
, "include_next", T_INCLUDE_NEXT
, 1},
423 { 6, do_include
, "import", T_IMPORT
, 1},
424 { 5, do_endif
, "endif", T_ENDIF
, 1},
425 { 4, do_else
, "else", T_ELSE
, 1},
426 { 2, do_if
, "if", T_IF
, 1},
427 { 4, do_elif
, "elif", T_ELIF
, 1},
428 { 5, do_undef
, "undef", T_UNDEF
},
429 { 5, do_error
, "error", T_ERROR
},
430 { 7, do_warning
, "warning", T_WARNING
},
431 { 6, do_pragma
, "pragma", T_PRAGMA
, 0, 0, 1},
432 { 4, do_line
, "line", T_LINE
, 1},
433 { 5, do_ident
, "ident", T_IDENT
, 1, 0, 1},
434 #ifdef SCCS_DIRECTIVE
435 { 4, do_sccs
, "sccs", T_SCCS
},
437 { 6, do_assert
, "assert", T_ASSERT
, 1},
438 { 8, do_unassert
, "unassert", T_UNASSERT
, 1},
439 { -1, 0, "", T_UNUSED
},
442 /* table to tell if char can be part of a C identifier. */
443 U_CHAR is_idchar
[256];
444 /* table to tell if char can be first char of a c identifier. */
445 U_CHAR is_idstart
[256];
446 /* table to tell if c is horizontal space. */
447 U_CHAR is_hor_space
[256];
448 /* table to tell if c is horizontal or vertical space. */
449 static U_CHAR is_space
[256];
451 /* Initialize syntactic classifications of characters. */
454 initialize_char_syntax (opts
)
455 struct cpp_options
*opts
;
460 * Set up is_idchar and is_idstart tables. These should be
461 * faster than saying (is_alpha (c) || c == '_'), etc.
462 * Set up these things before calling any routines tthat
465 for (i
= 'a'; i
<= 'z'; i
++) {
466 is_idchar
[i
- 'a' + 'A'] = 1;
468 is_idstart
[i
- 'a' + 'A'] = 1;
471 for (i
= '0'; i
<= '9'; i
++)
475 is_idchar
['$'] = opts
->dollars_in_ident
;
476 is_idstart
['$'] = opts
->dollars_in_ident
;
478 /* horizontal space table */
479 is_hor_space
[' '] = 1;
480 is_hor_space
['\t'] = 1;
481 is_hor_space
['\v'] = 1;
482 is_hor_space
['\f'] = 1;
483 is_hor_space
['\r'] = 1;
494 /* Place into PFILE a quoted string representing the string SRC.
495 Caller must reserve enough space in pfile->token_buffer. */
498 quote_string (pfile
, src
)
504 CPP_PUTC_Q (pfile
, '\"');
506 switch ((c
= *src
++))
510 CPP_PUTC_Q (pfile
, c
);
513 sprintf (CPP_PWRITTEN (pfile
), "\\%03o", c
);
514 CPP_ADJUST_WRITTEN (pfile
, 4);
520 CPP_PUTC_Q (pfile
, '\\');
521 CPP_PUTC_Q (pfile
, c
);
525 CPP_PUTC_Q (pfile
, '\"');
526 CPP_NUL_TERMINATE_Q (pfile
);
531 /* Re-allocates PFILE->token_buffer so it will hold at least N more chars. */
534 cpp_grow_buffer (pfile
, n
)
538 long old_written
= CPP_WRITTEN (pfile
);
539 pfile
->token_buffer_size
= n
+ 2 * pfile
->token_buffer_size
;
540 pfile
->token_buffer
= (U_CHAR
*)
541 xrealloc(pfile
->token_buffer
, pfile
->token_buffer_size
);
542 CPP_SET_WRITTEN (pfile
, old_written
);
547 * process a given definition string, for initialization
548 * If STR is just an identifier, define it with value 1.
549 * If STR has anything after the identifier, then it should
550 * be identifier=definition.
554 cpp_define (pfile
, str
)
564 cpp_error (pfile
, "malformed option `-D %s'", str
);
567 while (is_idchar
[*++p
])
571 buf
= (U_CHAR
*) alloca (p
- buf
+ 4);
572 strcpy ((char *)buf
, str
);
573 strcat ((char *)buf
, " 1");
577 cpp_error (pfile
, "malformed option `-D %s'", str
);
583 /* Copy the entire option so we can modify it. */
584 buf
= (U_CHAR
*) alloca (2 * strlen (str
) + 1);
585 strncpy (buf
, str
, p
- str
);
586 /* Change the = to a space. */
588 /* Scan for any backslash-newline and remove it. */
593 if (*p
== '\\' && p
[1] == '\n')
601 do_define (pfile
, NULL
, buf
, buf
+ strlen (buf
));
604 /* Process the string STR as if it appeared as the body of a #assert.
605 OPTION is the option name for which STR was the argument. */
608 make_assertion (pfile
, option
, str
)
613 struct directive
*kt
;
616 /* Copy the entire option so we can modify it. */
617 buf
= (U_CHAR
*) alloca (strlen (str
) + 1);
618 strcpy ((char *) buf
, str
);
619 /* Scan for any backslash-newline and remove it. */
623 if (*p
== '\\' && p
[1] == '\n')
632 if (!is_idstart
[*p
]) {
633 cpp_error (pfile
, "malformed option `%s %s'", option
, str
);
636 while (is_idchar
[*++p
])
638 while (*p
== ' ' || *p
== '\t') p
++;
639 if (! (*p
== 0 || *p
== '(')) {
640 cpp_error (pfile
, "malformed option `%s %s'", option
, str
);
644 if (cpp_push_buffer (pfile
, buf
, strlen (buf
)) != NULL
)
646 do_assert (pfile
, NULL
, NULL
, NULL
);
647 cpp_pop_buffer (pfile
);
651 /* Append a chain of `struct file_name_list's
652 to the end of the main include chain.
653 FIRST is the beginning of the chain to append, and LAST is the end. */
656 append_include_chain (pfile
, first
, last
)
658 struct file_name_list
*first
, *last
;
660 struct cpp_options
*opts
= CPP_OPTIONS (pfile
);
661 struct file_name_list
*dir
;
666 if (opts
->include
== 0)
667 opts
->include
= first
;
669 opts
->last_include
->next
= first
;
671 if (opts
->first_bracket_include
== 0)
672 opts
->first_bracket_include
= first
;
674 for (dir
= first
; ; dir
= dir
->next
) {
675 int len
= strlen (dir
->fname
) + INCLUDE_LEN_FUDGE
;
676 if (len
> pfile
->max_include_len
)
677 pfile
->max_include_len
= len
;
683 opts
->last_include
= last
;
686 /* Add output to `deps_buffer' for the -M switch.
687 STRING points to the text to be output.
688 SPACER is ':' for targets, ' ' for dependencies, zero for text
689 to be inserted literally. */
692 deps_output (pfile
, string
, spacer
)
697 int size
= strlen (string
);
702 #ifndef MAX_OUTPUT_COLUMNS
703 #define MAX_OUTPUT_COLUMNS 72
706 && pfile
->deps_column
> 0
707 && (pfile
->deps_column
+ size
) > MAX_OUTPUT_COLUMNS
)
709 deps_output (pfile
, " \\\n ", 0);
710 pfile
->deps_column
= 0;
713 if (pfile
->deps_size
+ size
+ 8 > pfile
->deps_allocated_size
)
715 pfile
->deps_allocated_size
= (pfile
->deps_size
+ size
+ 50) * 2;
716 pfile
->deps_buffer
= (char *) xrealloc (pfile
->deps_buffer
,
717 pfile
->deps_allocated_size
);
719 if (spacer
== ' ' && pfile
->deps_column
> 0)
720 pfile
->deps_buffer
[pfile
->deps_size
++] = ' ';
721 bcopy (string
, &pfile
->deps_buffer
[pfile
->deps_size
], size
);
722 pfile
->deps_size
+= size
;
723 pfile
->deps_column
+= size
;
725 pfile
->deps_buffer
[pfile
->deps_size
++] = ':';
726 pfile
->deps_buffer
[pfile
->deps_size
] = 0;
729 /* Given a colon-separated list of file names PATH,
730 add all the names to the search path for include files. */
733 path_include (pfile
, path
)
745 struct file_name_list
*dirtmp
;
747 /* Find the end of this name. */
748 while (*q
!= 0 && *q
!= PATH_SEPARATOR
) q
++;
750 /* An empty name in the path stands for the current directory. */
751 name
= (char *) xmalloc (2);
755 /* Otherwise use the directory that is named. */
756 name
= (char *) xmalloc (q
- p
+ 1);
757 bcopy (p
, name
, q
- p
);
761 dirtmp
= (struct file_name_list
*)
762 xmalloc (sizeof (struct file_name_list
));
763 dirtmp
->next
= 0; /* New one goes on the end */
764 dirtmp
->control_macro
= 0;
765 dirtmp
->c_system_include_path
= 0;
766 dirtmp
->fname
= name
;
767 dirtmp
->got_name_map
= 0;
768 append_include_chain (pfile
, dirtmp
, dirtmp
);
770 /* Advance past this name. */
774 /* Skip the colon. */
780 cpp_options_init (opts
)
783 bzero ((char *) opts
, sizeof *opts
);
784 opts
->in_fname
= NULL
;
785 opts
->out_fname
= NULL
;
787 /* Initialize is_idchar to allow $. */
788 opts
->dollars_in_ident
= 1;
789 initialize_char_syntax (opts
);
791 opts
->no_line_commands
= 0;
792 opts
->no_trigraphs
= 1;
793 opts
->put_out_comments
= 0;
794 opts
->print_include_names
= 0;
795 opts
->dump_macros
= dump_none
;
798 opts
->cplusplus_comments
= 0;
805 opts
->pedantic_errors
= 0;
806 opts
->inhibit_warnings
= 0;
807 opts
->warn_comments
= 0;
808 opts
->warn_import
= 1;
809 opts
->warnings_are_errors
= 0;
813 null_underflow (pfile
)
820 null_cleanup (pbuf
, pfile
)
828 macro_cleanup (pbuf
, pfile
)
832 HASHNODE
*macro
= (HASHNODE
*) pbuf
->data
;
833 if (macro
->type
== T_DISABLED
)
834 macro
->type
= T_MACRO
;
835 if (macro
->type
!= T_MACRO
|| pbuf
->buf
!= macro
->value
.defn
->expansion
)
841 file_cleanup (pbuf
, pfile
)
853 /* Assuming we have read '/'.
854 If this is the start of a comment (followed by '*' or '/'),
855 skip to the end of the comment, and return ' '.
856 Return EOF if we reached the end of file before the end of the comment.
857 If not the start of a comment, return '/'. */
860 skip_comment (pfile
, linep
)
865 while (PEEKC() == '\\' && PEEKN(1) == '\n')
880 while (c
== '\\' && PEEKC() == '\n')
884 FORWARD(1), c
= GETC();
886 if (prev_c
== '*' && c
== '/')
888 if (c
== '\n' && linep
)
892 else if (PEEKC() == '/' && CPP_OPTIONS (pfile
)->cplusplus_comments
)
899 return ' '; /* Allow // to be terminated by EOF. */
900 while (c
== '\\' && PEEKC() == '\n')
909 /* Don't consider final '\n' to be part of comment. */
919 /* Skip whitespace \-newline and comments. Does not macro-expand. */
922 cpp_skip_hspace (pfile
)
932 if ((c
== '\f' || c
== '\v') && CPP_PEDANTIC (pfile
))
933 cpp_pedwarn (pfile
, "%s in preprocessing directive",
934 c
== '\f' ? "formfeed" : "vertical tab");
940 c
= skip_comment (pfile
, NULL
);
943 if (c
== EOF
|| c
== '/')
946 else if (c
== '\\' && PEEKN(1) == '\n') {
949 else if (c
== '@' && CPP_BUFFER (pfile
)->has_escapes
950 && is_hor_space
[PEEKN(1)])
956 /* Read the rest of the current line.
957 The line is appended to PFILE's output buffer. */
960 copy_rest_of_line (pfile
)
963 struct cpp_options
*opts
= CPP_OPTIONS (pfile
);
980 goto scan_directive_token
;
984 if (nextc
== '*' || (opts
->cplusplus_comments
&& nextc
== '*'))
985 goto scan_directive_token
;
989 if (CPP_PEDANTIC (pfile
))
990 cpp_pedwarn (pfile
, "%s in preprocessing directive",
991 c
== '\f' ? "formfeed" : "vertical tab");
997 scan_directive_token
:
999 cpp_get_token (pfile
);
1002 CPP_PUTC (pfile
, c
);
1005 CPP_NUL_TERMINATE (pfile
);
1009 skip_rest_of_line (pfile
)
1012 long old
= CPP_WRITTEN (pfile
);
1013 copy_rest_of_line (pfile
);
1014 CPP_SET_WRITTEN (pfile
, old
);
1017 /* Handle a possible # directive.
1018 '#' has already been read. */
1021 handle_directive (pfile
)
1024 register struct directive
*kt
;
1027 U_CHAR
*ident
, *line_end
;
1028 long old_written
= CPP_WRITTEN (pfile
);
1030 cpp_skip_hspace (pfile
);
1033 if (c
>= '0' && c
<= '9')
1035 /* Handle # followed by a line number. */
1036 if (CPP_PEDANTIC (pfile
))
1037 cpp_pedwarn (pfile
, "`#' followed by integer");
1038 do_line (pfile
, NULL
);
1039 goto done_a_directive
;
1042 /* Now find the directive name. */
1043 CPP_PUTC (pfile
, '#');
1044 parse_name (pfile
, GETC());
1045 ident
= pfile
->token_buffer
+ old_written
+ 1;
1046 ident_length
= CPP_PWRITTEN (pfile
) - ident
;
1047 if (ident_length
== 0 && PEEKC() == '\n')
1049 /* A line of just `#' becomes blank. */
1050 goto done_a_directive
;
1054 if (ident_length
== 0 || !is_idstart
[*ident
]) {
1056 while (is_idchar
[*p
]) {
1057 if (*p
< '0' || *p
> '9')
1061 /* Avoid error for `###' and similar cases unless -pedantic. */
1063 while (*p
== '#' || is_hor_space
[*p
]) p
++;
1065 if (pedantic
&& !lang_asm
)
1066 cpp_warning (pfile
, "invalid preprocessor directive");
1072 cpp_error (pfile
, "invalid preprocessor directive name");
1078 * Decode the keyword and call the appropriate expansion
1079 * routine, after moving the input pointer up to the next line.
1081 for (kt
= directive_table
; ; kt
++) {
1082 if (kt
->length
<= 0)
1083 goto not_a_directive
;
1084 if (kt
->length
== ident_length
&& !strncmp (kt
->name
, ident
, ident_length
))
1088 if (kt
->command_reads_line
)
1092 /* Nonzero means do not delete comments within the directive.
1093 #define needs this when -traditional. */
1094 int comments
= CPP_TRADITIONAL (pfile
) && kt
->traditional_comments
;
1095 int save_put_out_comments
= CPP_OPTIONS (pfile
)->put_out_comments
;
1096 CPP_OPTIONS (pfile
)->put_out_comments
= comments
;
1097 after_ident
= CPP_WRITTEN (pfile
);
1098 copy_rest_of_line (pfile
);
1099 CPP_OPTIONS (pfile
)->put_out_comments
= save_put_out_comments
;
1102 /* For #pragma and #define, we may want to pass through the directive.
1103 Other directives may create output, but we don't want the directive
1104 itself out, so we pop it now. For example #include may write a #line
1105 command (see comment in do_include), and conditionals may emit
1106 #failed ... #endfailed stuff. But note that popping the buffer
1107 means the parameters to kt->func may point after pfile->limit
1108 so these parameters are invalid as soon as something gets appended
1109 to the token_buffer. */
1111 line_end
= CPP_PWRITTEN (pfile
);
1112 if (!kt
->pass_thru
&& kt
->type
!= T_DEFINE
)
1113 CPP_SET_WRITTEN (pfile
, old_written
);
1115 (*kt
->func
) (pfile
, kt
, pfile
->token_buffer
+ after_ident
, line_end
);
1117 || (kt
->type
== T_DEFINE
1118 && CPP_OPTIONS (pfile
)->dump_macros
== dump_definitions
))
1120 /* Just leave the entire #define in the output stack. */
1122 else if (kt
->type
== T_DEFINE
1123 && CPP_OPTIONS (pfile
)->dump_macros
== dump_names
)
1125 U_CHAR
*p
= pfile
->token_buffer
+ old_written
+ 7; /* Skip "#define". */
1126 SKIP_WHITE_SPACE (p
);
1127 while (is_idchar
[*p
]) p
++;
1129 CPP_PUTC (pfile
, '\n');
1131 else if (kt
->type
== T_DEFINE
)
1132 CPP_SET_WRITTEN (pfile
, old_written
);
1140 /* Pass a directive through to the output file.
1141 BUF points to the contents of the directive, as a contiguous string.
1142 LIMIT points to the first character past the end of the directive.
1143 KEYWORD is the keyword-table entry for the directive. */
1146 pass_thru_directive (buf
, limit
, pfile
, keyword
)
1147 U_CHAR
*buf
, *limit
;
1149 struct directive
*keyword
;
1151 register unsigned keyword_length
= keyword
->length
;
1153 CPP_RESERVE (pfile
, 1 + keyword_length
+ (limit
- buf
));
1154 CPP_PUTC_Q (pfile
, '#');
1155 CPP_PUTS_Q (pfile
, keyword
->name
, keyword_length
);
1156 if (limit
!= buf
&& buf
[0] != ' ')
1157 CPP_PUTC_Q (pfile
, ' ');
1158 CPP_PUTS_Q (pfile
, buf
, limit
- buf
);
1160 CPP_PUTS_Q (pfile
, '\n');
1161 /* Count the line we have just made in the output,
1162 to get in sync properly. */
1167 /* The arglist structure is built by do_define to tell
1168 collect_definition where the argument names begin. That
1169 is, for a define like "#define f(x,y,z) foo+x-bar*y", the arglist
1170 would contain pointers to the strings x, y, and z.
1171 Collect_definition would then build a DEFINITION node,
1172 with reflist nodes pointing to the places x, y, and z had
1173 appeared. So the arglist is just convenience data passed
1174 between these two routines. It is not kept around after
1175 the current #define has been processed and entered into the
1179 struct arglist
*next
;
1186 /* Read a replacement list for a macro with parameters.
1187 Build the DEFINITION structure.
1188 Reads characters of text starting at BUF until END.
1189 ARGLIST specifies the formal parameters to look for
1190 in the text of the definition; NARGS is the number of args
1191 in that list, or -1 for a macro name that wants no argument list.
1192 MACRONAME is the macro name itself (so we can avoid recursive expansion)
1193 and NAMELEN is its length in characters.
1195 Note that comments, backslash-newlines, and leading white space
1196 have already been deleted from the argument. */
1199 collect_expansion (pfile
, buf
, limit
, nargs
, arglist
)
1201 U_CHAR
*buf
, *limit
;
1203 struct arglist
*arglist
;
1206 register U_CHAR
*p
, *lastp
, *exp_p
;
1207 struct reflist
*endpat
= NULL
;
1208 /* Pointer to first nonspace after last ## seen. */
1210 /* Pointer to first nonspace after last single-# seen. */
1211 U_CHAR
*stringify
= 0;
1213 int expected_delimiter
= '\0';
1215 /* Scan thru the replacement list, ignoring comments and quoted
1216 strings, picking up on the macro calls. It does a linear search
1217 thru the arg list on every potential symbol. Profiling might say
1218 that something smarter should happen. */
1223 /* Find the beginning of the trailing whitespace. */
1225 while (p
< limit
&& is_space
[limit
[-1]]) limit
--;
1227 /* Allocate space for the text in the macro definition.
1228 Leading and trailing whitespace chars need 2 bytes each.
1229 Each other input char may or may not need 1 byte,
1230 so this is an upper bound. The extra 5 are for invented
1231 leading and trailing newline-marker and final null. */
1232 maxsize
= (sizeof (DEFINITION
)
1234 /* Occurrences of '@' get doubled, so allocate extra space for them. */
1238 defn
= (DEFINITION
*) xcalloc (1, maxsize
);
1240 defn
->nargs
= nargs
;
1241 exp_p
= defn
->expansion
= (U_CHAR
*) defn
+ sizeof (DEFINITION
);
1246 /* Add one initial space escape-marker to prevent accidental
1247 token-pasting (often removed by macroexpand). */
1251 if (limit
- p
>= 2 && p
[0] == '#' && p
[1] == '#') {
1252 cpp_error (pfile
, "`##' at start of macro definition");
1256 /* Process the main body of the definition. */
1258 int skipped_arg
= 0;
1259 register U_CHAR c
= *p
++;
1263 if (!CPP_TRADITIONAL (pfile
)) {
1267 if (expected_delimiter
!= '\0') {
1268 if (c
== expected_delimiter
)
1269 expected_delimiter
= '\0';
1271 expected_delimiter
= c
;
1275 if (p
< limit
&& expected_delimiter
) {
1276 /* In a string, backslash goes through
1277 and makes next char ordinary. */
1283 /* An '@' in a string or character constant stands for itself,
1284 and does not need to be escaped. */
1285 if (!expected_delimiter
)
1290 /* # is ordinary inside a string. */
1291 if (expected_delimiter
)
1293 if (p
< limit
&& *p
== '#') {
1294 /* ##: concatenate preceding and following tokens. */
1295 /* Take out the first #, discard preceding whitespace. */
1297 while (exp_p
> lastp
&& is_hor_space
[exp_p
[-1]])
1299 /* Skip the second #. */
1301 /* Discard following whitespace. */
1302 SKIP_WHITE_SPACE (p
);
1305 cpp_error (pfile
, "`##' at end of macro definition");
1306 } else if (nargs
>= 0) {
1307 /* Single #: stringify following argument ref.
1308 Don't leave the # in the expansion. */
1310 SKIP_WHITE_SPACE (p
);
1311 if (p
== limit
|| ! is_idstart
[*p
]
1312 || (*p
== 'L' && p
+ 1 < limit
&& (p
[1] == '\'' || p
[1] == '"')))
1314 "`#' operator is not followed by a macro argument name");
1321 /* In -traditional mode, recognize arguments inside strings and
1322 and character constants, and ignore special properties of #.
1323 Arguments inside strings are considered "stringified", but no
1324 extra quote marks are supplied. */
1328 if (expected_delimiter
!= '\0') {
1329 if (c
== expected_delimiter
)
1330 expected_delimiter
= '\0';
1332 expected_delimiter
= c
;
1336 /* Backslash quotes delimiters and itself, but not macro args. */
1337 if (expected_delimiter
!= 0 && p
< limit
1338 && (*p
== expected_delimiter
|| *p
== '\\')) {
1345 if (expected_delimiter
!= '\0') /* No comments inside strings. */
1348 /* If we find a comment that wasn't removed by handle_directive,
1349 this must be -traditional. So replace the comment with
1353 while (p
< limit
&& !(p
[-2] == '*' && p
[-1] == '/'))
1356 /* Mark this as a concatenation-point, as if it had been ##. */
1364 /* Handle the start of a symbol. */
1365 if (is_idchar
[c
] && nargs
> 0) {
1366 U_CHAR
*id_beg
= p
- 1;
1370 while (p
!= limit
&& is_idchar
[*p
]) p
++;
1371 id_len
= p
- id_beg
;
1374 && ! (id_len
== 1 && c
== 'L' && (*p
== '\'' || *p
== '"'))) {
1375 register struct arglist
*arg
;
1377 for (arg
= arglist
; arg
!= NULL
; arg
= arg
->next
) {
1378 struct reflist
*tpat
;
1380 if (arg
->name
[0] == c
1381 && arg
->length
== id_len
1382 && strncmp (arg
->name
, id_beg
, id_len
) == 0) {
1383 if (expected_delimiter
&& CPP_OPTIONS (pfile
)->warn_stringify
) {
1384 if (CPP_TRADITIONAL (pfile
)) {
1385 cpp_warning (pfile
, "macro argument `%.*s' is stringified.",
1389 "macro arg `%.*s' would be stringified with -traditional.",
1393 /* If ANSI, don't actually substitute inside a string. */
1394 if (!CPP_TRADITIONAL (pfile
) && expected_delimiter
)
1396 /* make a pat node for this arg and append it to the end of
1398 tpat
= (struct reflist
*) xmalloc (sizeof (struct reflist
));
1400 tpat
->raw_before
= concat
== id_beg
;
1401 tpat
->raw_after
= 0;
1402 tpat
->rest_args
= arg
->rest_args
;
1403 tpat
->stringify
= (CPP_TRADITIONAL (pfile
)
1404 ? expected_delimiter
!= '\0'
1405 : stringify
== id_beg
);
1408 defn
->pattern
= tpat
;
1410 endpat
->next
= tpat
;
1413 tpat
->argno
= arg
->argno
;
1414 tpat
->nchars
= exp_p
- lastp
;
1416 register U_CHAR
*p1
= p
;
1417 SKIP_WHITE_SPACE (p1
);
1418 if (p1
+ 2 <= limit
&& p1
[0] == '#' && p1
[1] == '#')
1419 tpat
->raw_after
= 1;
1421 lastp
= exp_p
; /* place to start copying from next time */
1428 /* If this was not a macro arg, copy it into the expansion. */
1429 if (! skipped_arg
) {
1430 register U_CHAR
*lim1
= p
;
1434 if (stringify
== id_beg
)
1436 "`#' operator should be followed by a macro argument name");
1441 if (!CPP_TRADITIONAL (pfile
) && expected_delimiter
== 0)
1443 /* If ANSI, put in a "@ " marker to prevent token pasting.
1444 But not if "inside a string" (which in ANSI mode
1445 happens only for -D option). */
1452 defn
->length
= exp_p
- defn
->expansion
;
1454 /* Crash now if we overrun the allocated size. */
1455 if (defn
->length
+ 1 > maxsize
)
1459 /* This isn't worth the time it takes. */
1460 /* give back excess storage */
1461 defn
->expansion
= (U_CHAR
*) xrealloc (defn
->expansion
, defn
->length
+ 1);
1468 * special extension string that can be added to the last macro argument to
1469 * allow it to absorb the "rest" of the arguments when expanded. Ex:
1470 * #define wow(a, b...) process (b, a, b)
1471 * { wow (1, 2, 3); } -> { process (2, 3, 1, 2, 3); }
1472 * { wow (one, two); } -> { process (two, one, two); }
1473 * if this "rest_arg" is used with the concat token '##' and if it is not
1474 * supplied then the token attached to with ## will not be outputted. Ex:
1475 * #define wow (a, b...) process (b ## , a, ## b)
1476 * { wow (1, 2); } -> { process (2, 1, 2); }
1477 * { wow (one); } -> { process (one); {
1479 static char rest_extension
[] = "...";
1480 #define REST_EXTENSION_LENGTH (sizeof (rest_extension) - 1)
1482 /* Create a DEFINITION node from a #define directive. Arguments are
1483 as for do_define. */
1486 create_definition (buf
, limit
, pfile
, predefinition
)
1487 U_CHAR
*buf
, *limit
;
1491 U_CHAR
*bp
; /* temp ptr into input buffer */
1492 U_CHAR
*symname
; /* remember where symbol name starts */
1493 int sym_length
; /* and how long it is */
1496 char *file
= CPP_BUFFER (pfile
) ? CPP_BUFFER (pfile
)->nominal_fname
: "";
1498 int arglengths
= 0; /* Accumulate lengths of arg names
1499 plus number of args. */
1501 cpp_buf_line_and_col (CPP_BUFFER (pfile
), &line
, &col
);
1505 while (is_hor_space
[*bp
])
1508 symname
= bp
; /* remember where it starts */
1510 sym_length
= check_macro_name (pfile
, bp
, "macro");
1513 /* Lossage will occur if identifiers or control keywords are broken
1514 across lines using backslash. This is not the right place to take
1518 struct arglist
*arg_ptrs
= NULL
;
1521 bp
++; /* skip '(' */
1522 SKIP_WHITE_SPACE (bp
);
1524 /* Loop over macro argument names. */
1525 while (*bp
!= ')') {
1526 struct arglist
*temp
;
1528 temp
= (struct arglist
*) alloca (sizeof (struct arglist
));
1530 temp
->next
= arg_ptrs
;
1531 temp
->argno
= argno
++;
1532 temp
->rest_args
= 0;
1536 cpp_pedwarn (pfile
, "another parameter follows `%s'", rest_extension
);
1538 if (!is_idstart
[*bp
])
1539 cpp_pedwarn (pfile
, "invalid character in macro parameter name");
1541 /* Find the end of the arg name. */
1542 while (is_idchar
[*bp
]) {
1544 /* do we have a "special" rest-args extension here? */
1545 if (limit
- bp
> REST_EXTENSION_LENGTH
1546 && strncmp (rest_extension
, bp
, REST_EXTENSION_LENGTH
) == 0) {
1548 temp
->rest_args
= 1;
1552 temp
->length
= bp
- temp
->name
;
1554 bp
+= REST_EXTENSION_LENGTH
;
1555 arglengths
+= temp
->length
+ 2;
1556 SKIP_WHITE_SPACE (bp
);
1557 if (temp
->length
== 0 || (*bp
!= ',' && *bp
!= ')')) {
1558 cpp_error (pfile
, "badly punctuated parameter list in `#define'");
1563 SKIP_WHITE_SPACE (bp
);
1566 cpp_error (pfile
, "unterminated parameter list in `#define'");
1570 struct arglist
*otemp
;
1572 for (otemp
= temp
->next
; otemp
!= NULL
; otemp
= otemp
->next
)
1573 if (temp
->length
== otemp
->length
1574 && strncmp (temp
->name
, otemp
->name
, temp
->length
) == 0) {
1577 name
= (U_CHAR
*) alloca (temp
->length
+ 1);
1578 (void) strncpy (name
, temp
->name
, temp
->length
);
1579 name
[temp
->length
] = '\0';
1581 "duplicate argument name `%s' in `#define'", name
);
1587 ++bp
; /* skip paren */
1588 SKIP_WHITE_SPACE (bp
);
1589 /* now everything from bp before limit is the definition. */
1590 defn
= collect_expansion (pfile
, bp
, limit
, argno
, arg_ptrs
);
1591 defn
->rest_args
= rest_args
;
1593 /* Now set defn->args.argnames to the result of concatenating
1594 the argument names in reverse order
1595 with comma-space between them. */
1596 defn
->args
.argnames
= (U_CHAR
*) xmalloc (arglengths
+ 1);
1598 struct arglist
*temp
;
1600 for (temp
= arg_ptrs
; temp
; temp
= temp
->next
) {
1601 bcopy (temp
->name
, &defn
->args
.argnames
[i
], temp
->length
);
1603 if (temp
->next
!= 0) {
1604 defn
->args
.argnames
[i
++] = ',';
1605 defn
->args
.argnames
[i
++] = ' ';
1608 defn
->args
.argnames
[i
] = 0;
1611 /* Simple expansion or empty definition. */
1615 if (is_hor_space
[*bp
]) {
1617 SKIP_WHITE_SPACE (bp
);
1620 case '!': case '"': case '#': case '%': case '&': case '\'':
1621 case ')': case '*': case '+': case ',': case '-': case '.':
1622 case '/': case ':': case ';': case '<': case '=': case '>':
1623 case '?': case '[': case '\\': case ']': case '^': case '{':
1624 case '|': case '}': case '~':
1625 cpp_warning (pfile
, "missing white space after `#define %.*s'",
1626 sym_length
, symname
);
1630 cpp_pedwarn (pfile
, "missing white space after `#define %.*s'",
1631 sym_length
, symname
);
1636 /* now everything from bp before limit is the definition. */
1637 defn
= collect_expansion (pfile
, bp
, limit
, -1, NULL_PTR
);
1638 defn
->args
.argnames
= (U_CHAR
*) "";
1644 /* OP is null if this is a predefinition */
1645 defn
->predefined
= predefinition
;
1647 mdef
.symnam
= symname
;
1648 mdef
.symlen
= sym_length
;
1657 /* Check a purported macro name SYMNAME, and yield its length.
1658 USAGE is the kind of name this is intended for. */
1661 check_macro_name (pfile
, symname
, usage
)
1669 for (p
= symname
; is_idchar
[*p
]; p
++)
1671 sym_length
= p
- symname
;
1673 || (sym_length
== 1 && *symname
== 'L' && (*p
== '\'' || *p
== '"')))
1674 cpp_error (pfile
, "invalid %s name", usage
);
1675 else if (!is_idstart
[*symname
]) {
1676 U_CHAR
*msg
; /* what pain... */
1677 msg
= (U_CHAR
*) alloca (sym_length
+ 1);
1678 bcopy (symname
, msg
, sym_length
);
1679 msg
[sym_length
] = 0;
1680 cpp_error (pfile
, "invalid %s name `%s'", usage
, msg
);
1682 if (! strncmp (symname
, "defined", 7) && sym_length
== 7)
1683 cpp_error (pfile
, "invalid %s name `defined'", usage
);
1688 /* Return zero if two DEFINITIONs are isomorphic. */
1691 compare_defs (d1
, d2
)
1692 DEFINITION
*d1
, *d2
;
1694 register struct reflist
*a1
, *a2
;
1695 register U_CHAR
*p1
= d1
->expansion
;
1696 register U_CHAR
*p2
= d2
->expansion
;
1699 if (d1
->nargs
!= d2
->nargs
)
1701 if (strcmp ((char *)d1
->args
.argnames
, (char *)d2
->args
.argnames
))
1703 for (a1
= d1
->pattern
, a2
= d2
->pattern
; a1
&& a2
;
1704 a1
= a1
->next
, a2
= a2
->next
) {
1705 if (!((a1
->nchars
== a2
->nchars
&& ! strncmp (p1
, p2
, a1
->nchars
))
1706 || ! comp_def_part (first
, p1
, a1
->nchars
, p2
, a2
->nchars
, 0))
1707 || a1
->argno
!= a2
->argno
1708 || a1
->stringify
!= a2
->stringify
1709 || a1
->raw_before
!= a2
->raw_before
1710 || a1
->raw_after
!= a2
->raw_after
)
1718 if (comp_def_part (first
, p1
, d1
->length
- (p1
- d1
->expansion
),
1719 p2
, d2
->length
- (p2
- d2
->expansion
), 1))
1724 /* Return 1 if two parts of two macro definitions are effectively different.
1725 One of the parts starts at BEG1 and has LEN1 chars;
1726 the other has LEN2 chars at BEG2.
1727 Any sequence of whitespace matches any other sequence of whitespace.
1728 FIRST means these parts are the first of a macro definition;
1729 so ignore leading whitespace entirely.
1730 LAST means these parts are the last of a macro definition;
1731 so ignore trailing whitespace entirely. */
1734 comp_def_part (first
, beg1
, len1
, beg2
, len2
, last
)
1736 U_CHAR
*beg1
, *beg2
;
1740 register U_CHAR
*end1
= beg1
+ len1
;
1741 register U_CHAR
*end2
= beg2
+ len2
;
1743 while (beg1
!= end1
&& is_space
[*beg1
]) beg1
++;
1744 while (beg2
!= end2
&& is_space
[*beg2
]) beg2
++;
1747 while (beg1
!= end1
&& is_space
[end1
[-1]]) end1
--;
1748 while (beg2
!= end2
&& is_space
[end2
[-1]]) end2
--;
1750 while (beg1
!= end1
&& beg2
!= end2
) {
1751 if (is_space
[*beg1
] && is_space
[*beg2
]) {
1752 while (beg1
!= end1
&& is_space
[*beg1
]) beg1
++;
1753 while (beg2
!= end2
&& is_space
[*beg2
]) beg2
++;
1754 } else if (*beg1
== *beg2
) {
1758 return (beg1
!= end1
) || (beg2
!= end2
);
1761 /* Process a #define command.
1762 BUF points to the contents of the #define command, as a contiguous string.
1763 LIMIT points to the first character past the end of the definition.
1764 KEYWORD is the keyword-table entry for #define,
1765 or NULL for a "predefined" macro. */
1768 do_define (pfile
, keyword
, buf
, limit
)
1770 struct directive
*keyword
;
1771 U_CHAR
*buf
, *limit
;
1778 /* If this is a precompiler run (with -pcp) pass thru #define commands. */
1779 if (pcp_outfile
&& keyword
)
1780 pass_thru_directive (buf
, limit
, pfile
, keyword
);
1783 mdef
= create_definition (buf
, limit
, pfile
, keyword
== NULL
);
1787 hashcode
= hashf (mdef
.symnam
, mdef
.symlen
, HASHSIZE
);
1789 if ((hp
= cpp_lookup (pfile
, mdef
.symnam
, mdef
.symlen
, hashcode
)) != NULL
)
1792 /* Redefining a precompiled key is ok. */
1793 if (hp
->type
== T_PCSTRING
)
1795 /* Redefining a macro is ok if the definitions are the same. */
1796 else if (hp
->type
== T_MACRO
)
1797 ok
= ! compare_defs (mdef
.defn
, hp
->value
.defn
);
1798 /* Redefining a constant is ok with -D. */
1799 else if (hp
->type
== T_CONST
)
1800 ok
= ! CPP_OPTIONS (pfile
)->done_initializing
;
1801 /* Print the warning if it's not ok. */
1804 U_CHAR
*msg
; /* what pain... */
1806 /* If we are passing through #define and #undef directives, do
1807 that for this re-definition now. */
1808 if (CPP_OPTIONS (pfile
)->debug_output
&& keyword
)
1809 pass_thru_directive (buf
, limit
, pfile
, keyword
);
1811 msg
= (U_CHAR
*) alloca (mdef
.symlen
+ 22);
1813 bcopy (mdef
.symnam
, msg
+ 1, mdef
.symlen
);
1814 strcpy ((char *) (msg
+ mdef
.symlen
+ 1), "' redefined");
1815 cpp_pedwarn (pfile
, msg
);
1816 if (hp
->type
== T_MACRO
)
1817 cpp_pedwarn_with_file_and_line (pfile
, hp
->value
.defn
->file
, hp
->value
.defn
->line
,
1818 "this is the location of the previous definition");
1820 /* Replace the old definition. */
1822 hp
->value
.defn
= mdef
.defn
;
1826 /* If we are passing through #define and #undef directives, do
1827 that for this new definition now. */
1828 if (CPP_OPTIONS (pfile
)->debug_output
&& keyword
)
1829 pass_thru_directive (buf
, limit
, pfile
, keyword
);
1830 install (mdef
.symnam
, mdef
.symlen
, T_MACRO
, 0,
1831 (char *) mdef
.defn
, hashcode
);
1841 /* This structure represents one parsed argument in a macro call.
1842 `raw' points to the argument text as written (`raw_length' is its length).
1843 `expanded' points to the argument's macro-expansion
1844 (its length is `expand_length').
1845 `stringified_length' is the length the argument would have
1847 `use_count' is the number of times this macro arg is substituted
1848 into the macro. If the actual use count exceeds 10,
1849 the value stored is 10. */
1851 /* raw and expanded are relative to ARG_BASE */
1852 #define ARG_BASE ((pfile)->token_buffer)
1855 /* Strings relative to pfile->token_buffer */
1856 long raw
, expanded
, stringified
;
1857 int raw_length
, expand_length
;
1858 int stringified_length
;
1863 /* Allocate a new cpp_buffer for PFILE, and push it on the input buffer stack.
1864 If BUFFER != NULL, then use the LENGTH characters in BUFFER
1865 as the new input buffer.
1866 Return the new buffer, or NULL on failure. */
1869 cpp_push_buffer (pfile
, buffer
, length
)
1874 register cpp_buffer
*buf
= CPP_BUFFER (pfile
);
1875 if (buf
== pfile
->buffer_stack
)
1877 cpp_fatal (pfile
, "%s: macro or `#include' recursion too deep",
1882 bzero ((char *) buf
, sizeof (cpp_buffer
));
1883 CPP_BUFFER (pfile
) = buf
;
1884 buf
->if_stack
= pfile
->if_stack
;
1885 buf
->cleanup
= null_cleanup
;
1886 buf
->underflow
= null_underflow
;
1887 buf
->buf
= buf
->cur
= buffer
;
1888 buf
->alimit
= buf
->rlimit
= buffer
+ length
;
1894 cpp_pop_buffer (pfile
)
1897 cpp_buffer
*buf
= CPP_BUFFER (pfile
);
1898 (*buf
->cleanup
) (buf
, pfile
);
1899 return ++CPP_BUFFER (pfile
);
1902 /* Scan until CPP_BUFFER (PFILE) is exhausted into PFILE->token_buffer.
1903 Pop the buffer when done. */
1906 cpp_scan_buffer (pfile
)
1909 cpp_buffer
*buffer
= CPP_BUFFER (pfile
);
1912 enum cpp_token token
= cpp_get_token (pfile
);
1913 if (token
== CPP_EOF
) /* Should not happen ... */
1915 if (token
== CPP_POP
&& CPP_BUFFER (pfile
) == buffer
)
1917 cpp_pop_buffer (pfile
);
1924 * Rescan a string (which may have escape marks) into pfile's buffer.
1925 * Place the result in pfile->token_buffer.
1927 * The input is copied before it is scanned, so it is safe to pass
1928 * it something from the token_buffer that will get overwritten
1929 * (because it follows CPP_WRITTEN). This is used by do_include.
1933 cpp_expand_to_buffer (pfile
, buf
, length
)
1938 register cpp_buffer
*ip
;
1940 U_CHAR
*limit
= buf
+ length
;
1943 int odepth
= indepth
;
1949 /* Set up the input on the input stack. */
1951 buf1
= (U_CHAR
*) alloca (length
+ 1);
1953 register U_CHAR
*p1
= buf
;
1954 register U_CHAR
*p2
= buf1
;
1961 ip
= cpp_push_buffer (pfile
, buf1
, length
);
1964 ip
->has_escapes
= 1;
1966 ip
->lineno
= obuf
.lineno
= 1;
1969 /* Scan the input, create the output. */
1970 cpp_scan_buffer (pfile
);
1973 if (indepth
!= odepth
)
1977 CPP_NUL_TERMINATE (pfile
);
1982 adjust_position (buf
, limit
, linep
, colp
)
1992 (*linep
)++, (*colp
) = 1;
1998 /* Move line_base forward, updating lineno and colno. */
2001 update_position (pbuf
)
2002 register cpp_buffer
*pbuf
;
2004 unsigned char *old_pos
= pbuf
->buf
+ pbuf
->line_base
;
2005 unsigned char *new_pos
= pbuf
->cur
;
2006 register struct parse_marker
*mark
;
2007 for (mark
= pbuf
->marks
; mark
!= NULL
; mark
= mark
->next
)
2009 if (pbuf
->buf
+ mark
->position
< new_pos
)
2010 new_pos
= pbuf
->buf
+ mark
->position
;
2012 pbuf
->line_base
+= new_pos
- old_pos
;
2013 adjust_position (old_pos
, new_pos
, &pbuf
->lineno
, &pbuf
->colno
);
2017 cpp_buf_line_and_col (pbuf
, linep
, colp
)
2018 register cpp_buffer
*pbuf
;
2026 *linep
= pbuf
->lineno
;
2027 *colp
= pbuf
->colno
;
2028 adjust_position (pbuf
->buf
+ pbuf
->line_base
, pbuf
->cur
, linep
, colp
);
2037 /* Return the cpp_buffer that corresponds to a file (not a macro). */
2040 cpp_file_buffer (pfile
)
2043 cpp_buffer
*ip
= CPP_BUFFER (pfile
);
2045 for ( ; ip
!= CPP_NULL_BUFFER (pfile
); ip
= CPP_PREV_BUFFER (ip
))
2046 if (ip
->fname
!= NULL
)
2052 count_newlines (buf
, limit
)
2053 register U_CHAR
*buf
;
2054 register U_CHAR
*limit
;
2056 register long count
= 0;
2067 * write out a #line command, for instance, after an #include file.
2068 * If CONDITIONAL is nonzero, we can omit the #line if it would
2069 * appear to be a no-op, and we can output a few newlines instead
2070 * if we want to increase the line number by a small amount.
2071 * FILE_CHANGE says whether we are entering a file, leaving, or neither.
2075 output_line_command (pfile
, conditional
, file_change
)
2078 enum file_change_code file_change
;
2081 char *line_cmd_buf
, *line_end
;
2083 cpp_buffer
*ip
= CPP_BUFFER (pfile
);
2085 if (ip
->fname
== NULL
)
2088 update_position (ip
);
2090 if (CPP_OPTIONS (pfile
)->no_line_commands
2091 || CPP_OPTIONS (pfile
)->no_output
)
2094 line
= CPP_BUFFER (pfile
)->lineno
;
2095 col
= CPP_BUFFER (pfile
)->colno
;
2096 adjust_position (CPP_LINE_BASE (ip
), ip
->cur
, &line
, &col
);
2098 if (CPP_OPTIONS (pfile
)->no_line_commands
)
2102 if (line
== pfile
->lineno
)
2105 /* If the inherited line number is a little too small,
2106 output some newlines instead of a #line command. */
2107 if (line
> pfile
->lineno
&& line
< pfile
->lineno
+ 8) {
2108 CPP_RESERVE (pfile
, 20);
2109 while (line
> pfile
->lineno
) {
2110 CPP_PUTC_Q (pfile
, '\n');
2118 /* Don't output a line number of 0 if we can help it. */
2119 if (ip
->lineno
== 0 && ip
->bufp
- ip
->buf
< ip
->length
2120 && *ip
->bufp
== '\n') {
2126 CPP_RESERVE (pfile
, 4 * strlen (ip
->nominal_fname
) + 50);
2128 #ifdef OUTPUT_LINE_COMMANDS
2129 static char sharp_line
[] = "#line ";
2131 static char sharp_line
[] = "# ";
2133 CPP_PUTS_Q (pfile
, sharp_line
, sizeof(sharp_line
)-1);
2136 sprintf (CPP_PWRITTEN (pfile
), "%d ", line
);
2137 CPP_ADJUST_WRITTEN (pfile
, strlen (CPP_PWRITTEN (pfile
)));
2139 quote_string (pfile
, ip
->nominal_fname
);
2140 if (file_change
!= same_file
) {
2141 CPP_PUTC_Q (pfile
, ' ');
2142 CPP_PUTC_Q (pfile
, file_change
== enter_file
? '1' : '2');
2144 /* Tell cc1 if following text comes from a system header file. */
2145 if (ip
->system_header_p
) {
2146 CPP_PUTC_Q (pfile
, ' ');
2147 CPP_PUTC_Q (pfile
, '3');
2149 #ifndef NO_IMPLICIT_EXTERN_C
2150 /* Tell cc1plus if following text should be treated as C. */
2151 if (ip
->system_header_p
== 2 && CPP_OPTIONS (pfile
)->cplusplus
) {
2152 CPP_PUTC_Q (pfile
, ' ');
2153 CPP_PUTC_Q (pfile
, '4');
2156 CPP_PUTC_Q (pfile
, '\n');
2157 pfile
->lineno
= line
;
2161 * Parse a macro argument and append the info on PFILE's token_buffer.
2162 * REST_ARGS means to absorb the rest of the args.
2163 * Return nonzero to indicate a syntax error.
2166 static enum cpp_token
2167 macarg (pfile
, rest_args
)
2172 enum cpp_token token
;
2173 long arg_start
= CPP_WRITTEN (pfile
);
2174 char save_put_out_comments
= CPP_OPTIONS (pfile
)->put_out_comments
;
2175 CPP_OPTIONS (pfile
)->put_out_comments
= 0;
2177 /* Try to parse as much of the argument as exists at this
2178 input stack level. */
2179 pfile
->no_macro_expand
++;
2182 token
= cpp_get_token (pfile
);
2188 /* If we've hit end of file, it's an error (reported by caller).
2189 Ditto if it's the end of cpp_expand_to_buffer text.
2190 If we've hit end of macro, just continue. */
2191 if (! CPP_IS_MACRO_BUFFER (CPP_BUFFER (pfile
)))
2202 /* if we've returned to lowest level and
2203 we aren't absorbing all args */
2204 if (paren
== 0 && rest_args
== 0)
2208 /* Remove ',' or ')' from argument buffer. */
2209 CPP_ADJUST_WRITTEN (pfile
, -1);
2216 CPP_OPTIONS (pfile
)->put_out_comments
= save_put_out_comments
;
2217 pfile
->no_macro_expand
--;
2222 /* Turn newlines to spaces in the string of length LENGTH at START,
2223 except inside of string constants.
2224 The string is copied into itself with its beginning staying fixed. */
2227 change_newlines (start
, length
)
2231 register U_CHAR
*ibp
;
2232 register U_CHAR
*obp
;
2233 register U_CHAR
*limit
;
2237 limit
= start
+ length
;
2240 while (ibp
< limit
) {
2241 *obp
++ = c
= *ibp
++;
2246 /* Notice and skip strings, so that we don't delete newlines in them. */
2249 while (ibp
< limit
) {
2250 *obp
++ = c
= *ibp
++;
2253 if (c
== '\n' && quotec
== '\'')
2269 if (!pfile
->timebuf
) {
2270 time_t t
= time ((time_t *) 0);
2271 pfile
->timebuf
= localtime (&t
);
2273 return pfile
->timebuf
;
2276 static char *monthnames
[] = {"Jan", "Feb", "Mar", "Apr", "May", "Jun",
2277 "Jul", "Aug", "Sep", "Oct", "Nov", "Dec",
2281 * expand things like __FILE__. Place the expansion into the output
2282 * buffer *without* rescanning.
2286 special_symbol (hp
, pfile
)
2293 cpp_buffer
*ip
= NULL
;
2296 int paren
= 0; /* For special `defined' keyword */
2299 if (pcp_outfile
&& pcp_inside_if
2300 && hp
->type
!= T_SPEC_DEFINED
&& hp
->type
!= T_CONST
)
2302 "Predefined macro `%s' used inside `#if' during precompilation",
2306 for (ip
= CPP_BUFFER (pfile
); ; ip
= CPP_PREV_BUFFER (ip
))
2308 if (ip
== CPP_NULL_BUFFER (pfile
))
2310 cpp_error (pfile
, "cccp error: not in any file?!");
2311 return; /* the show must go on */
2313 if (ip
->fname
!= NULL
)
2323 if (hp
->type
== T_BASE_FILE
)
2325 while (CPP_PREV_BUFFER (ip
) != CPP_NULL_BUFFER (pfile
))
2326 ip
= CPP_PREV_BUFFER (ip
);
2328 string
= ip
->nominal_fname
;
2332 CPP_RESERVE (pfile
, 3 + 4 * strlen (string
));
2333 quote_string (pfile
, string
);
2337 case T_INCLUDE_LEVEL
:
2339 ip
= CPP_BUFFER (pfile
);
2340 for (; ip
!= CPP_NULL_BUFFER (pfile
); ip
= CPP_PREV_BUFFER (ip
))
2341 if (ip
->fname
!= NULL
)
2344 buf
= (char *) alloca (8); /* Eight bytes ought to be more than enough */
2345 sprintf (buf
, "%d", true_indepth
- 1);
2349 buf
= (char *) alloca (3 + strlen (version_string
));
2350 sprintf (buf
, "\"%s\"", version_string
);
2353 #ifndef NO_BUILTIN_SIZE_TYPE
2359 #ifndef NO_BUILTIN_PTRDIFF_TYPE
2360 case T_PTRDIFF_TYPE
:
2366 buf
= CPP_WCHAR_TYPE (pfile
);
2369 case T_USER_LABEL_PREFIX_TYPE
:
2370 buf
= USER_LABEL_PREFIX
;
2373 case T_REGISTER_PREFIX_TYPE
:
2374 buf
= REGISTER_PREFIX
;
2378 buf
= (char *) alloca (4 * sizeof (int));
2379 sprintf (buf
, "%d", hp
->value
.ival
);
2381 if (pcp_inside_if
&& pcp_outfile
)
2382 /* Output a precondition for this macro use */
2383 fprintf (pcp_outfile
, "#define %s %d\n", hp
->name
, hp
->value
.ival
);
2389 long line
= ip
->lineno
;
2390 long col
= ip
->colno
;
2391 adjust_position (CPP_LINE_BASE (ip
), ip
->cur
, &line
, &col
);
2393 buf
= (char *) alloca (10);
2394 sprintf (buf
, "%d", line
);
2400 buf
= (char *) alloca (20);
2401 timebuf
= timestamp (pfile
);
2402 if (hp
->type
== T_DATE
)
2403 sprintf (buf
, "\"%s %2d %4d\"", monthnames
[timebuf
->tm_mon
],
2404 timebuf
->tm_mday
, timebuf
->tm_year
+ 1900);
2406 sprintf (buf
, "\"%02d:%02d:%02d\"", timebuf
->tm_hour
, timebuf
->tm_min
,
2410 case T_SPEC_DEFINED
:
2411 buf
= " 0 "; /* Assume symbol is not defined */
2412 ip
= CPP_BUFFER (pfile
);
2413 SKIP_WHITE_SPACE (ip
->cur
);
2414 if (*ip
->cur
== '(')
2417 ip
->cur
++; /* Skip over the paren */
2418 SKIP_WHITE_SPACE (ip
->cur
);
2421 if (!is_idstart
[*ip
->cur
])
2423 if (ip
->cur
[0] == 'L' && (ip
->cur
[1] == '\'' || ip
->cur
[1] == '"'))
2425 if (hp
= cpp_lookup (pfile
, ip
->cur
, -1, -1))
2428 if (pcp_outfile
&& pcp_inside_if
2429 && (hp
->type
== T_CONST
2430 || (hp
->type
== T_MACRO
&& hp
->value
.defn
->predefined
)))
2431 /* Output a precondition for this macro use. */
2432 fprintf (pcp_outfile
, "#define %s\n", hp
->name
);
2438 if (pcp_outfile
&& pcp_inside_if
)
2440 /* Output a precondition for this macro use */
2441 U_CHAR
*cp
= ip
->bufp
;
2442 fprintf (pcp_outfile
, "#undef ");
2443 while (is_idchar
[*cp
]) /* Ick! */
2444 fputc (*cp
++, pcp_outfile
);
2445 putc ('\n', pcp_outfile
);
2448 while (is_idchar
[*ip
->cur
])
2450 SKIP_WHITE_SPACE (ip
->cur
);
2453 if (*ip
->cur
!= ')')
2461 cpp_error (pfile
, "`defined' without an identifier");
2465 cpp_error (pfile
, "cccp error: invalid special hash type"); /* time for gdb */
2469 CPP_RESERVE (pfile
, len
+ 1);
2470 CPP_PUTS_Q (pfile
, buf
, len
);
2471 CPP_NUL_TERMINATE_Q (pfile
);
2476 /* Write out a #define command for the special named MACRO_NAME
2477 to PFILE's token_buffer. */
2480 dump_special_to_buffer (pfile
, macro_name
)
2484 static char define_directive
[] = "#define ";
2485 int macro_name_length
= strlen (macro_name
);
2486 output_line_command (pfile
, 0, same_file
);
2487 CPP_RESERVE (pfile
, sizeof(define_directive
) + macro_name_length
);
2488 CPP_PUTS_Q (pfile
, define_directive
, sizeof(define_directive
)-1);
2489 CPP_PUTS_Q (pfile
, macro_name
, macro_name_length
);
2490 CPP_PUTC_Q (pfile
, ' ');
2491 cpp_expand_to_buffer (pfile
, macro_name
, macro_name_length
);
2492 CPP_PUTC (pfile
, '\n');
2495 /* Initialize the built-in macros. */
2498 initialize_builtins (pfile
)
2501 install ("__LINE__", -1, T_SPECLINE
, 0, 0, -1);
2502 install ("__DATE__", -1, T_DATE
, 0, 0, -1);
2503 install ("__FILE__", -1, T_FILE
, 0, 0, -1);
2504 install ("__BASE_FILE__", -1, T_BASE_FILE
, 0, 0, -1);
2505 install ("__INCLUDE_LEVEL__", -1, T_INCLUDE_LEVEL
, 0, 0, -1);
2506 install ("__VERSION__", -1, T_VERSION
, 0, 0, -1);
2507 #ifndef NO_BUILTIN_SIZE_TYPE
2508 install ("__SIZE_TYPE__", -1, T_SIZE_TYPE
, 0, 0, -1);
2510 #ifndef NO_BUILTIN_PTRDIFF_TYPE
2511 install ("__PTRDIFF_TYPE__ ", -1, T_PTRDIFF_TYPE
, 0, 0, -1);
2513 install ("__WCHAR_TYPE__", -1, T_WCHAR_TYPE
, 0, 0, -1);
2514 install ("__USER_LABEL_PREFIX__", -1, T_USER_LABEL_PREFIX_TYPE
, 0, 0, -1);
2515 install ("__REGISTER_PREFIX__", -1, T_REGISTER_PREFIX_TYPE
, 0, 0, -1);
2516 install ("__TIME__", -1, T_TIME
, 0, 0, -1);
2517 if (!CPP_TRADITIONAL (pfile
))
2518 install ("__STDC__", -1, T_CONST
, STDC_VALUE
, 0, -1);
2519 if (CPP_OPTIONS (pfile
)->objc
)
2520 install ("__OBJC__", -1, T_CONST
, 1, 0, -1);
2521 /* This is supplied using a -D by the compiler driver
2522 so that it is present only when truly compiling with GNU C. */
2523 /* install ("__GNUC__", -1, T_CONST, 2, 0, -1); */
2525 if (CPP_OPTIONS (pfile
)->debug_output
)
2527 dump_special_to_buffer (pfile
, "__BASE_FILE__");
2528 dump_special_to_buffer (pfile
, "__VERSION__");
2529 #ifndef NO_BUILTIN_SIZE_TYPE
2530 dump_special_to_buffer (pfile
, "__SIZE_TYPE__");
2532 #ifndef NO_BUILTIN_PTRDIFF_TYPE
2533 dump_special_to_buffer (pfile
, "__PTRDIFF_TYPE__");
2535 dump_special_to_buffer (pfile
, "__WCHAR_TYPE__");
2536 dump_special_to_buffer (pfile
, "__DATE__");
2537 dump_special_to_buffer (pfile
, "__TIME__");
2538 if (!CPP_TRADITIONAL (pfile
))
2539 dump_special_to_buffer (pfile
, "__STDC__");
2540 if (CPP_OPTIONS (pfile
)->objc
)
2541 dump_special_to_buffer (pfile
, "__OBJC__");
2545 /* Return 1 iff a token ending in C1 followed directly by a token C2
2546 could cause mis-tokenization. */
2549 unsafe_chars (c1
, c2
)
2555 if (c2
== c1
|| c2
== '=')
2559 case '0': case '1': case '2': case '3': case '4':
2560 case '5': case '6': case '7': case '8': case '9':
2561 case 'e': case 'E': case 'p': case 'P':
2562 if (c2
== '-' || c2
== '+')
2563 return 1; /* could extend a pre-processing number */
2566 if (c2
== '\'' || c2
== '\"')
2567 return 1; /* Could turn into L"xxx" or L'xxx'. */
2571 case 'a': case 'b': case 'c': case 'd': case 'f':
2572 case 'g': case 'h': case 'i': case 'j': case 'k': case 'l':
2573 case 'm': case 'n': case 'o': case 'q': case 'r':
2574 case 's': case 't': case 'u': case 'v': case 'w': case 'x':
2576 case 'A': case 'B': case 'C': case 'D': case 'F':
2577 case 'G': case 'H': case 'I': case 'J': case 'K':
2578 case 'M': case 'N': case 'O': case 'Q': case 'R':
2579 case 'S': case 'T': case 'U': case 'V': case 'W': case 'X':
2581 /* We're in the middle of either a name or a pre-processing number. */
2582 return (is_idchar
[c2
] || c2
== '.');
2583 case '<': case '>': case '!': case '%': case '#': case ':':
2584 case '^': case '&': case '|': case '*': case '/': case '=':
2585 return (c2
== c1
|| c2
== '=');
2590 /* Expand a macro call.
2591 HP points to the symbol that is the macro being called.
2592 Put the result of expansion onto the input stack
2593 so that subsequent input by our caller will use it.
2595 If macro wants arguments, caller has already verified that
2596 an argument list follows; arguments come from the input stack. */
2599 macroexpand (pfile
, hp
)
2604 DEFINITION
*defn
= hp
->value
.defn
;
2605 register U_CHAR
*xbuf
;
2606 long start_line
, start_column
;
2608 struct argdata
*args
;
2609 long old_written
= CPP_WRITTEN (pfile
);
2611 int start_line
= instack
[indepth
].lineno
;
2613 int rest_args
, rest_zero
;
2617 CHECK_DEPTH (return;);
2621 /* This macro is being used inside a #if, which means it must be */
2622 /* recorded as a precondition. */
2623 if (pcp_inside_if
&& pcp_outfile
&& defn
->predefined
)
2624 dump_single_macro (hp
, pcp_outfile
);
2627 pfile
->output_escapes
++;
2628 cpp_buf_line_and_col (cpp_file_buffer (pfile
), &start_line
, &start_column
);
2630 nargs
= defn
->nargs
;
2634 enum cpp_token token
;
2636 args
= (struct argdata
*) alloca ((nargs
+ 1) * sizeof (struct argdata
));
2638 for (i
= 0; i
< nargs
; i
++)
2640 args
[i
].raw
= args
[i
].expanded
= 0;
2641 args
[i
].raw_length
= 0;
2642 args
[i
].expand_length
= args
[i
].stringified_length
= -1;
2643 args
[i
].use_count
= 0;
2646 /* Parse all the macro args that are supplied. I counts them.
2647 The first NARGS args are stored in ARGS.
2648 The rest are discarded. If rest_args is set then we assume
2649 macarg absorbed the rest of the args. */
2653 FORWARD(1); /* Discard the open-parenthesis before the first arg. */
2658 if (i
< nargs
|| (nargs
== 0 && i
== 0))
2660 /* if we are working on last arg which absorbs rest of args... */
2661 if (i
== nargs
- 1 && defn
->rest_args
)
2663 args
[i
].raw
= CPP_WRITTEN (pfile
);
2664 token
= macarg (pfile
, rest_args
);
2665 args
[i
].raw_length
= CPP_WRITTEN (pfile
) - args
[i
].raw
;
2666 args
[i
].newlines
= 0; /* FIXME */
2669 token
= macarg (pfile
, 0);
2670 if (token
== CPP_EOF
|| token
== CPP_POP
)
2672 cpp_error_with_line (pfile
, start_line
, start_column
,
2673 "unterminated macro call");
2677 } while (token
== CPP_COMMA
);
2679 /* If we got one arg but it was just whitespace, call that 0 args. */
2682 register U_CHAR
*bp
= ARG_BASE
+ args
[0].raw
;
2683 register U_CHAR
*lim
= bp
+ args
[0].raw_length
;
2684 /* cpp.texi says for foo ( ) we provide one argument.
2685 However, if foo wants just 0 arguments, treat this as 0. */
2687 while (bp
!= lim
&& is_space
[*bp
]) bp
++;
2692 /* Don't output an error message if we have already output one for
2693 a parse error above. */
2695 if (nargs
== 0 && i
> 0)
2697 cpp_error (pfile
, "arguments given to macro `%s'", hp
->name
);
2701 /* traditional C allows foo() if foo wants one argument. */
2702 if (nargs
== 1 && i
== 0 && CPP_TRADITIONAL (pfile
))
2704 /* the rest args token is allowed to absorb 0 tokens */
2705 else if (i
== nargs
- 1 && defn
->rest_args
)
2708 cpp_error (pfile
, "macro `%s' used without args", hp
->name
);
2710 cpp_error (pfile
, "macro `%s' used with just one arg", hp
->name
);
2712 cpp_error (pfile
, "macro `%s' used with only %d args",
2718 "macro `%s' used with too many (%d) args", hp
->name
, i
);
2722 /* If macro wants zero args, we parsed the arglist for checking only.
2723 Read directly from the macro definition. */
2726 xbuf
= defn
->expansion
;
2727 xbuf_len
= defn
->length
;
2731 register U_CHAR
*exp
= defn
->expansion
;
2732 register int offset
; /* offset in expansion,
2733 copied a piece at a time */
2734 register int totlen
; /* total amount of exp buffer filled so far */
2736 register struct reflist
*ap
, *last_ap
;
2738 /* Macro really takes args. Compute the expansion of this call. */
2740 /* Compute length in characters of the macro's expansion.
2741 Also count number of times each arg is used. */
2742 xbuf_len
= defn
->length
;
2743 for (ap
= defn
->pattern
; ap
!= NULL
; ap
= ap
->next
)
2747 register struct argdata
*arg
= &args
[ap
->argno
];
2748 /* Stringify it it hasn't already been */
2749 if (arg
->stringified_length
< 0)
2751 int arglen
= arg
->raw_length
;
2755 /* Initially need_space is -1. Otherwise, 1 means the
2756 previous character was a space, but we suppressed it;
2757 0 means the previous character was a non-space. */
2758 int need_space
= -1;
2760 arg
->stringified
= CPP_WRITTEN (pfile
);
2761 if (!CPP_TRADITIONAL (pfile
))
2762 CPP_PUTC (pfile
, '\"'); /* insert beginning quote */
2763 for (; i
< arglen
; i
++)
2765 c
= (ARG_BASE
+ arg
->raw
)[i
];
2769 /* Internal sequences of whitespace are replaced by
2770 one space except within an string or char token.*/
2773 if (CPP_WRITTEN (pfile
) > arg
->stringified
2774 && (CPP_PWRITTEN (pfile
))[-1] == '@')
2776 /* "@ " escape markers are removed */
2777 CPP_ADJUST_WRITTEN (pfile
, -1);
2780 if (need_space
== 0)
2784 else if (need_space
> 0)
2785 CPP_PUTC (pfile
, ' ');
2800 else if (c
== '\"' || c
== '\'')
2804 /* Escape these chars */
2805 if (c
== '\"' || (in_string
&& c
== '\\'))
2806 CPP_PUTC (pfile
, '\\');
2808 CPP_PUTC (pfile
, c
);
2811 CPP_RESERVE (pfile
, 4);
2812 sprintf (CPP_PWRITTEN (pfile
), "\\%03o",
2814 CPP_ADJUST_WRITTEN (pfile
, 4);
2817 if (!CPP_TRADITIONAL (pfile
))
2818 CPP_PUTC (pfile
, '\"'); /* insert ending quote */
2819 arg
->stringified_length
2820 = CPP_WRITTEN (pfile
) - arg
->stringified
;
2822 xbuf_len
+= args
[ap
->argno
].stringified_length
;
2824 else if (ap
->raw_before
|| ap
->raw_after
|| CPP_TRADITIONAL (pfile
))
2825 /* Add 4 for two newline-space markers to prevent
2826 token concatenation. */
2827 xbuf_len
+= args
[ap
->argno
].raw_length
+ 4;
2830 /* We have an ordinary (expanded) occurrence of the arg.
2831 So compute its expansion, if we have not already. */
2832 if (args
[ap
->argno
].expand_length
< 0)
2834 args
[ap
->argno
].expanded
= CPP_WRITTEN (pfile
);
2835 cpp_expand_to_buffer (pfile
,
2836 ARG_BASE
+ args
[ap
->argno
].raw
,
2837 args
[ap
->argno
].raw_length
);
2839 args
[ap
->argno
].expand_length
2840 = CPP_WRITTEN (pfile
) - args
[ap
->argno
].expanded
;
2843 /* Add 4 for two newline-space markers to prevent
2844 token concatenation. */
2845 xbuf_len
+= args
[ap
->argno
].expand_length
+ 4;
2847 if (args
[ap
->argno
].use_count
< 10)
2848 args
[ap
->argno
].use_count
++;
2851 xbuf
= (U_CHAR
*) xmalloc (xbuf_len
+ 1);
2853 /* Generate in XBUF the complete expansion
2854 with arguments substituted in.
2855 TOTLEN is the total size generated so far.
2856 OFFSET is the index in the definition
2857 of where we are copying from. */
2858 offset
= totlen
= 0;
2859 for (last_ap
= NULL
, ap
= defn
->pattern
; ap
!= NULL
;
2860 last_ap
= ap
, ap
= ap
->next
)
2862 register struct argdata
*arg
= &args
[ap
->argno
];
2863 int count_before
= totlen
;
2865 /* Add chars to XBUF. */
2866 for (i
= 0; i
< ap
->nchars
; i
++, offset
++)
2867 xbuf
[totlen
++] = exp
[offset
];
2869 /* If followed by an empty rest arg with concatenation,
2870 delete the last run of nonwhite chars. */
2871 if (rest_zero
&& totlen
> count_before
2872 && ((ap
->rest_args
&& ap
->raw_before
)
2873 || (last_ap
!= NULL
&& last_ap
->rest_args
2874 && last_ap
->raw_after
)))
2876 /* Delete final whitespace. */
2877 while (totlen
> count_before
&& is_space
[xbuf
[totlen
- 1]])
2880 /* Delete the nonwhites before them. */
2881 while (totlen
> count_before
&& ! is_space
[xbuf
[totlen
- 1]])
2885 if (ap
->stringify
!= 0)
2887 bcopy (ARG_BASE
+ arg
->stringified
,
2888 xbuf
+ totlen
, arg
->stringified_length
);
2889 totlen
+= arg
->stringified_length
;
2891 else if (ap
->raw_before
|| ap
->raw_after
|| CPP_TRADITIONAL (pfile
))
2893 U_CHAR
*p1
= ARG_BASE
+ arg
->raw
;
2894 U_CHAR
*l1
= p1
+ arg
->raw_length
;
2897 while (p1
!= l1
&& is_space
[*p1
]) p1
++;
2898 while (p1
!= l1
&& is_idchar
[*p1
])
2899 xbuf
[totlen
++] = *p1
++;
2900 /* Delete any no-reexpansion marker that follows
2901 an identifier at the beginning of the argument
2902 if the argument is concatenated with what precedes it. */
2903 if (p1
[0] == '@' && p1
[1] == '-')
2908 /* Arg is concatenated after: delete trailing whitespace,
2909 whitespace markers, and no-reexpansion markers. */
2912 if (is_space
[l1
[-1]]) l1
--;
2913 else if (l1
[-1] == '-')
2915 U_CHAR
*p2
= l1
- 1;
2916 /* If a `-' is preceded by an odd number of newlines then it
2917 and the last newline are a no-reexpansion marker. */
2918 while (p2
!= p1
&& p2
[-1] == '\n') p2
--;
2919 if ((l1
- 1 - p2
) & 1) {
2928 bcopy (p1
, xbuf
+ totlen
, l1
- p1
);
2933 U_CHAR
*expanded
= ARG_BASE
+ arg
->expanded
;
2934 if (!ap
->raw_before
&& totlen
> 0 && arg
->expand_length
2935 && !CPP_TRADITIONAL(pfile
)
2936 && unsafe_chars (xbuf
[totlen
-1], expanded
[0]))
2938 xbuf
[totlen
++] = '@';
2939 xbuf
[totlen
++] = ' ';
2942 bcopy (expanded
, xbuf
+ totlen
, arg
->expand_length
);
2943 totlen
+= arg
->expand_length
;
2945 if (!ap
->raw_after
&& totlen
> 0 && offset
< defn
->length
2946 && !CPP_TRADITIONAL(pfile
)
2947 && unsafe_chars (xbuf
[totlen
-1], exp
[offset
]))
2949 xbuf
[totlen
++] = '@';
2950 xbuf
[totlen
++] = ' ';
2953 /* If a macro argument with newlines is used multiple times,
2954 then only expand the newlines once. This avoids creating
2955 output lines which don't correspond to any input line,
2956 which confuses gdb and gcov. */
2957 if (arg
->use_count
> 1 && arg
->newlines
> 0)
2959 /* Don't bother doing change_newlines for subsequent
2963 = change_newlines (expanded
, arg
->expand_length
);
2967 if (totlen
> xbuf_len
)
2971 /* if there is anything left of the definition
2972 after handling the arg list, copy that in too. */
2974 for (i
= offset
; i
< defn
->length
; i
++)
2976 /* if we've reached the end of the macro */
2979 if (! (rest_zero
&& last_ap
!= NULL
&& last_ap
->rest_args
2980 && last_ap
->raw_after
))
2981 xbuf
[totlen
++] = exp
[i
];
2989 pfile
->output_escapes
--;
2991 /* Now put the expansion on the input stack
2992 so our caller will commence reading from it. */
2993 push_macro_expansion (pfile
, xbuf
, xbuf_len
, hp
);
2994 CPP_BUFFER (pfile
)->has_escapes
= 1;
2996 /* Pop the space we've used in the token_buffer for argument expansion. */
2997 CPP_SET_WRITTEN (pfile
, old_written
);
2999 /* Recursive macro use sometimes works traditionally.
3000 #define foo(x,y) bar (x (y,0), y)
3003 if (!CPP_TRADITIONAL (pfile
))
3004 hp
->type
= T_DISABLED
;
3008 push_macro_expansion (pfile
, xbuf
, xbuf_len
, hp
)
3010 register U_CHAR
*xbuf
;
3014 register cpp_buffer
*mbuf
= cpp_push_buffer (pfile
, xbuf
, xbuf_len
);
3017 mbuf
->cleanup
= macro_cleanup
;
3020 /* The first chars of the expansion should be a "@ " added by
3021 collect_expansion. This is to prevent accidental token-pasting
3022 between the text preceding the macro invocation, and the macro
3025 We would like to avoid adding unneeded spaces (for the sake of
3026 tools that use cpp, such as imake). In some common cases we can
3027 tell that it is safe to omit the space.
3029 The character before the macro invocation cannot have been an
3030 idchar (or else it would have been pasted with the idchars of
3031 the macro name). Therefore, if the first non-space character
3032 of the expansion is an idchar, we do not need the extra space
3033 to prevent token pasting.
3035 Also, we don't need the extra space if the first char is '(',
3036 or some other (less common) characters. */
3038 if (xbuf
[0] == '@' && xbuf
[1] == ' '
3039 && (is_idchar
[xbuf
[2]] || xbuf
[2] == '(' || xbuf
[2] == '\''
3040 || xbuf
[2] == '\"'))
3044 /* Like cpp_get_token, except that it does not read past end-of-line.
3045 Also, horizontal space is skipped, and macros are popped. */
3047 static enum cpp_token
3048 get_directive_token (pfile
)
3053 long old_written
= CPP_WRITTEN (pfile
);
3054 enum cpp_token token
;
3055 cpp_skip_hspace (pfile
);
3056 if (PEEKC () == '\n')
3058 token
= cpp_get_token (pfile
);
3062 if (! CPP_IS_MACRO_BUFFER (CPP_BUFFER (pfile
)))
3064 /* ... else fall though ... */
3065 case CPP_HSPACE
: case CPP_COMMENT
:
3066 CPP_SET_WRITTEN (pfile
, old_written
);
3074 /* Handle #include and #import.
3075 This function expects to see "fname" or <fname> on the input.
3077 The input is normally in part of the output_buffer following
3078 CPP_WRITTEN, and will get overwritten by output_line_command.
3079 I.e. in input file specification has been popped by handle_directive.
3083 do_include (pfile
, keyword
, unused1
, unused2
)
3085 struct directive
*keyword
;
3086 U_CHAR
*unused1
, *unused2
;
3088 int importing
= (keyword
->type
== T_IMPORT
);
3089 int skip_dirs
= (keyword
->type
== T_INCLUDE_NEXT
);
3090 char *fname
; /* Dynamically allocated fname buffer */
3093 U_CHAR
*fbeg
, *fend
; /* Beginning and end of fname */
3094 enum cpp_token token
;
3096 /* Chain of dirs to search */
3097 struct file_name_list
*search_start
= CPP_OPTIONS (pfile
)->include
;
3098 struct file_name_list dsp
[1]; /* First in chain, if #include "..." */
3099 struct file_name_list
*searchptr
= 0;
3100 long old_written
= CPP_WRITTEN (pfile
);
3104 int f
; /* file number */
3106 int retried
= 0; /* Have already tried macro
3107 expanding the include line */
3108 int angle_brackets
= 0; /* 0 for "...", 1 for <...> */
3113 f
= -1; /* JF we iz paranoid! */
3115 if (CPP_PEDANTIC (pfile
) && !CPP_BUFFER (pfile
)->system_header_p
)
3118 cpp_pedwarn (pfile
, "ANSI C does not allow `#import'");
3120 cpp_pedwarn (pfile
, "ANSI C does not allow `#include_next'");
3123 if (importing
&& CPP_OPTIONS (pfile
)->warn_import
3124 && !CPP_OPTIONS (pfile
)->inhibit_warnings
3125 && !CPP_BUFFER (pfile
)->system_header_p
&& !pfile
->import_warning
)
3127 pfile
->import_warning
= 1;
3128 cpp_warning (pfile
, "using `#import' is not recommended");
3129 fprintf (stderr
, "The fact that a certain header file need not be processed more than once\n");
3130 fprintf (stderr
, "should be indicated in the header file, not where it is used.\n");
3131 fprintf (stderr
, "The best way to do this is with a conditional of this form:\n\n");
3132 fprintf (stderr
, " #ifndef _FOO_H_INCLUDED\n");
3133 fprintf (stderr
, " #define _FOO_H_INCLUDED\n");
3134 fprintf (stderr
, " ... <real contents of file> ...\n");
3135 fprintf (stderr
, " #endif /* Not _FOO_H_INCLUDED */\n\n");
3136 fprintf (stderr
, "Then users can use `#include' any number of times.\n");
3137 fprintf (stderr
, "GNU C automatically avoids processing the file more than once\n");
3138 fprintf (stderr
, "when it is equipped with such a conditional.\n");
3141 pfile
->parsing_include_directive
++;
3142 token
= get_directive_token (pfile
);
3143 pfile
->parsing_include_directive
--;
3145 if (token
== CPP_STRING
)
3147 /* FIXME - check no trailing garbage */
3148 fbeg
= pfile
->token_buffer
+ old_written
+ 1;
3149 fend
= CPP_PWRITTEN (pfile
) - 1;
3150 if (fbeg
[-1] == '<')
3153 /* If -I-, start with the first -I dir after the -I-. */
3154 if (CPP_OPTIONS (pfile
)->first_bracket_include
)
3155 search_start
= CPP_OPTIONS (pfile
)->first_bracket_include
;
3157 /* If -I- was specified, don't search current dir, only spec'd ones. */
3158 else if (! CPP_OPTIONS (pfile
)->ignore_srcdir
)
3160 cpp_buffer
*fp
= CPP_BUFFER (pfile
);
3161 /* We have "filename". Figure out directory this source
3162 file is coming from and put it on the front of the list. */
3164 for ( ; fp
!= CPP_NULL_BUFFER (pfile
); fp
= CPP_PREV_BUFFER (fp
))
3169 if ((nam
= fp
->nominal_fname
) != NULL
)
3171 /* Found a named file. Figure out dir of the file,
3172 and put it in front of the search list. */
3173 dsp
[0].next
= search_start
;
3176 ep
= rindex (nam
, '/');
3178 ep
= rindex (nam
, ']');
3179 if (ep
== NULL
) ep
= rindex (nam
, '>');
3180 if (ep
== NULL
) ep
= rindex (nam
, ':');
3181 if (ep
!= NULL
) ep
++;
3186 dsp
[0].fname
= (char *) alloca (n
+ 1);
3187 strncpy (dsp
[0].fname
, nam
, n
);
3188 dsp
[0].fname
[n
] = '\0';
3189 if (n
+ INCLUDE_LEN_FUDGE
> pfile
->max_include_len
)
3190 pfile
->max_include_len
= n
+ INCLUDE_LEN_FUDGE
;
3194 dsp
[0].fname
= 0; /* Current directory */
3196 dsp
[0].got_name_map
= 0;
3203 else if (token
== CPP_NAME
)
3206 * Support '#include xyz' like VAX-C to allow for easy use of all the
3207 * decwindow include files. It defaults to '#include <xyz.h>' (so the
3208 * code from case '<' is repeated here) and generates a warning.
3211 "VAX-C-style include specification found, use '#include <filename.h>' !");
3213 /* If -I-, start with the first -I dir after the -I-. */
3214 if (CPP_OPTIONS (pfile
)->first_bracket_include
)
3215 search_start
= CPP_OPTIONS (pfile
)->first_bracket_include
;
3216 fbeg
= pfile
->token_buffer
+ old_written
;
3217 fend
= CPP_PWRITTEN (pfile
);
3223 "`#%s' expects \"FILENAME\" or <FILENAME>", keyword
->name
);
3224 CPP_SET_WRITTEN (pfile
, old_written
);
3225 skip_rest_of_line (pfile
);
3231 token
= get_directive_token (pfile
);
3232 if (token
!= CPP_VSPACE
)
3234 cpp_error (pfile
, "junk at end of `#include'");
3235 while (token
!= CPP_VSPACE
&& token
!= CPP_EOF
&& token
!= CPP_POP
)
3236 token
= get_directive_token (pfile
);
3239 /* For #include_next, skip in the search path
3240 past the dir in which the containing file was found. */
3243 cpp_buffer
*fp
= CPP_BUFFER (pfile
);
3244 for (; fp
!= CPP_NULL_BUFFER (pfile
); fp
= CPP_PREV_BUFFER (fp
))
3245 if (fp
->fname
!= NULL
)
3247 /* fp->dir is null if the containing file was specified with
3248 an absolute file name. In that case, don't skip anything. */
3249 if (fp
->dir
== SELF_DIR_DUMMY
)
3250 search_start
= CPP_OPTIONS (pfile
)->include
;
3252 search_start
= fp
->dir
->next
;
3257 CPP_SET_WRITTEN (pfile
, old_written
);
3263 cpp_error (pfile
, "empty file name in `#%s'", keyword
->name
);
3267 /* Allocate this permanently, because it gets stored in the definitions
3269 fname
= (char *) xmalloc (pfile
->max_include_len
+ flen
+ 4);
3270 /* + 2 above for slash and terminating null. */
3271 /* + 2 added for '.h' on VMS (to support '#include filename') */
3273 /* If specified file name is absolute, just open it. */
3276 strncpy (fname
, fbeg
, flen
);
3278 if (redundant_include_p (pfile
, fname
))
3281 f
= lookup_import (pfile
, fname
, NULL_PTR
);
3283 f
= open_include_file (pfile
, fname
, NULL_PTR
);
3285 return 0; /* Already included this file */
3287 /* Search directory path, trying to open the file.
3288 Copy each filename tried into FNAME. */
3290 for (searchptr
= search_start
; searchptr
; searchptr
= searchptr
->next
) {
3291 if (searchptr
->fname
) {
3292 /* The empty string in a search path is ignored.
3293 This makes it possible to turn off entirely
3294 a standard piece of the list. */
3295 if (searchptr
->fname
[0] == 0)
3297 strcpy (fname
, searchptr
->fname
);
3298 strcat (fname
, "/");
3299 fname
[strlen (fname
) + flen
] = 0;
3303 strncat (fname
, fbeg
, flen
);
3305 /* Change this 1/2 Unix 1/2 VMS file specification into a
3306 full VMS file specification */
3307 if (searchptr
->fname
&& (searchptr
->fname
[0] != 0)) {
3308 /* Fix up the filename */
3309 hack_vms_include_specification (fname
);
3311 /* This is a normal VMS filespec, so use it unchanged. */
3312 strncpy (fname
, fbeg
, flen
);
3314 /* if it's '#include filename', add the missing .h */
3315 if (index(fname
,'.')==NULL
) {
3316 strcat (fname
, ".h");
3320 /* ??? There are currently 3 separate mechanisms for avoiding processing
3321 of redundant include files: #import, #pragma once, and
3322 redundant_include_p. It would be nice if they were unified. */
3323 if (redundant_include_p (pfile
, fname
))
3326 f
= lookup_import (pfile
, fname
, searchptr
);
3328 f
= open_include_file (pfile
, fname
, searchptr
);
3330 return 0; /* Already included this file */
3332 else if (f
== -1 && errno
== EACCES
)
3333 cpp_warning (pfile
, "Header file %s exists, but is not readable",
3343 /* A file that was not found. */
3344 strncpy (fname
, fbeg
, flen
);
3346 /* If generating dependencies and -MG was specified, we assume missing
3347 files are leaf files, living in the same directory as the source file
3348 or other similar place; these missing files may be generated from
3349 other files and may not exist yet (eg: y.tab.h). */
3351 if (CPP_OPTIONS(pfile
)->print_deps_missing_files
3352 && CPP_PRINT_DEPS (pfile
)
3353 > (angle_brackets
|| (pfile
->system_include_depth
> 0)))
3355 /* If it was requested as a system header file,
3356 then assume it belongs in the first place to look for such. */
3359 for (searchptr
= search_start
; searchptr
;
3360 searchptr
= searchptr
->next
)
3362 if (searchptr
->fname
)
3366 if (searchptr
->fname
[0] == 0)
3368 p
= (char *) alloca (strlen (searchptr
->fname
)
3369 + strlen (fname
) + 2);
3370 strcpy (p
, searchptr
->fname
);
3373 deps_output (pfile
, p
, ' ');
3380 /* Otherwise, omit the directory, as if the file existed
3381 in the directory with the source. */
3382 deps_output (pfile
, fname
, ' ');
3385 /* If -M was specified, and this header file won't be added to the
3386 dependency list, then don't count this as an error, because we can
3387 still produce correct output. Otherwise, we can't produce correct
3388 output, because there may be dependencies we need inside the missing
3389 file, and we don't know what directory this missing file exists in.*/
3390 else if (CPP_PRINT_DEPS (pfile
)
3391 && (CPP_PRINT_DEPS (pfile
)
3392 <= (angle_brackets
|| (pfile
->system_include_depth
> 0))))
3393 cpp_warning (pfile
, "No include path in which to find %s", fname
);
3394 else if (search_start
)
3395 cpp_error_from_errno (pfile
, fname
);
3397 cpp_error (pfile
, "No include path in which to find %s", fname
);
3400 /* Check to see if this include file is a once-only include file.
3403 struct file_name_list
*ptr
;
3405 for (ptr
= pfile
->dont_repeat_files
; ptr
; ptr
= ptr
->next
) {
3406 if (!strcmp (ptr
->fname
, fname
)) {
3408 return 0; /* This file was once'd. */
3412 for (ptr
= pfile
->all_include_files
; ptr
; ptr
= ptr
->next
) {
3413 if (!strcmp (ptr
->fname
, fname
))
3414 break; /* This file was included before. */
3418 /* This is the first time for this file. */
3419 /* Add it to list of files included. */
3421 ptr
= (struct file_name_list
*) xmalloc (sizeof (struct file_name_list
));
3422 ptr
->control_macro
= 0;
3423 ptr
->c_system_include_path
= 0;
3424 ptr
->next
= pfile
->all_include_files
;
3425 pfile
->all_include_files
= ptr
;
3426 ptr
->fname
= savestring (fname
);
3427 ptr
->got_name_map
= 0;
3429 /* For -M, add this file to the dependencies. */
3430 if (CPP_PRINT_DEPS (pfile
)
3431 > (angle_brackets
|| (pfile
->system_include_depth
> 0)))
3432 deps_output (pfile
, fname
, ' ');
3435 /* Handle -H option. */
3436 if (CPP_OPTIONS(pfile
)->print_include_names
)
3438 cpp_buffer
*buf
= CPP_BUFFER (pfile
);
3439 while ((buf
= CPP_PREV_BUFFER (buf
)) != CPP_NULL_BUFFER (pfile
))
3441 fprintf (stderr
, "%s\n", fname
);
3445 pfile
->system_include_depth
++;
3447 /* Actually process the file. */
3449 /* Record file on "seen" list for #import. */
3450 add_import (pfile
, f
, fname
);
3452 pcftry
= (char *) alloca (strlen (fname
) + 30);
3464 sprintf (pcftry
, "%s%d", fname
, pcfnum
++);
3466 pcf
= open (pcftry
, O_RDONLY
, 0666);
3472 if (bcmp ((char *) &stat_f
.st_ino
, (char *) &s
.st_ino
,
3474 || stat_f
.st_dev
!= s
.st_dev
)
3476 pcfbuf
= check_precompiled (pcf
, fname
, &pcfbuflimit
);
3477 /* Don't need it any more. */
3482 /* Don't need it at all. */
3487 } while (pcf
!= -1 && !pcfbuf
);
3491 /* Actually process the file */
3492 if (cpp_push_buffer (pfile
, NULL
, 0) == NULL
)
3494 if (finclude (pfile
, f
, fname
, is_system_include (pfile
, fname
),
3495 searchptr
!= dsp
? searchptr
: SELF_DIR_DUMMY
))
3497 output_line_command (pfile
, 0, enter_file
);
3498 pfile
->only_seen_white
= 2;
3502 pfile
->system_include_depth
--;
3507 /* Return nonzero if there is no need to include file NAME
3508 because it has already been included and it contains a conditional
3509 to make a repeated include do nothing. */
3512 redundant_include_p (pfile
, name
)
3516 struct file_name_list
*l
= pfile
->all_include_files
;
3517 for (; l
; l
= l
->next
)
3518 if (! strcmp (name
, l
->fname
)
3520 && cpp_lookup (pfile
, l
->control_macro
, -1, -1))
3525 /* Return nonzero if the given FILENAME is an absolute pathname which
3526 designates a file within one of the known "system" include file
3527 directories. We assume here that if the given FILENAME looks like
3528 it is the name of a file which resides either directly in a "system"
3529 include file directory, or within any subdirectory thereof, then the
3530 given file must be a "system" include file. This function tells us
3531 if we should suppress pedantic errors/warnings for the given FILENAME.
3533 The value is 2 if the file is a C-language system header file
3534 for which C++ should (on most systems) assume `extern "C"'. */
3537 is_system_include (pfile
, filename
)
3539 register char *filename
;
3541 struct file_name_list
*searchptr
;
3543 for (searchptr
= CPP_OPTIONS (pfile
)->first_system_include
; searchptr
;
3544 searchptr
= searchptr
->next
)
3545 if (searchptr
->fname
) {
3546 register char *sys_dir
= searchptr
->fname
;
3547 register unsigned length
= strlen (sys_dir
);
3549 if (! strncmp (sys_dir
, filename
, length
) && filename
[length
] == '/')
3551 if (searchptr
->c_system_include_path
)
3562 * Install a name in the assertion hash table.
3564 * If LEN is >= 0, it is the length of the name.
3565 * Otherwise, compute the length by scanning the entire name.
3567 * If HASH is >= 0, it is the precomputed hash code.
3568 * Otherwise, compute the hash code.
3571 static ASSERTION_HASHNODE
*
3572 assertion_install (pfile
, name
, len
, hash
)
3578 register ASSERTION_HASHNODE
*hp
;
3579 register int i
, bucket
;
3580 register U_CHAR
*p
, *q
;
3582 i
= sizeof (ASSERTION_HASHNODE
) + len
+ 1;
3583 hp
= (ASSERTION_HASHNODE
*) xmalloc (i
);
3585 hp
->bucket_hdr
= &pfile
->assertion_hashtab
[bucket
];
3586 hp
->next
= pfile
->assertion_hashtab
[bucket
];
3587 pfile
->assertion_hashtab
[bucket
] = hp
;
3589 if (hp
->next
!= NULL
)
3590 hp
->next
->prev
= hp
;
3593 hp
->name
= ((U_CHAR
*) hp
) + sizeof (ASSERTION_HASHNODE
);
3596 for (i
= 0; i
< len
; i
++)
3602 * find the most recent hash node for name name (ending with first
3603 * non-identifier char) installed by install
3605 * If LEN is >= 0, it is the length of the name.
3606 * Otherwise, compute the length by scanning the entire name.
3608 * If HASH is >= 0, it is the precomputed hash code.
3609 * Otherwise, compute the hash code.
3612 static ASSERTION_HASHNODE
*
3613 assertion_lookup (pfile
, name
, len
, hash
)
3619 register ASSERTION_HASHNODE
*bucket
;
3621 bucket
= pfile
->assertion_hashtab
[hash
];
3623 if (bucket
->length
== len
&& strncmp (bucket
->name
, name
, len
) == 0)
3625 bucket
= bucket
->next
;
3631 delete_assertion (hp
)
3632 ASSERTION_HASHNODE
*hp
;
3634 struct tokenlist_list
*tail
;
3635 if (hp
->prev
!= NULL
)
3636 hp
->prev
->next
= hp
->next
;
3637 if (hp
->next
!= NULL
)
3638 hp
->next
->prev
= hp
->prev
;
3640 for (tail
= hp
->value
; tail
; )
3642 struct tokenlist_list
*next
= tail
->next
;
3643 free_token_list (tail
->tokens
);
3648 /* Make sure that the bucket chain header that
3649 the deleted guy was on points to the right thing afterwards. */
3650 if (hp
== *hp
->bucket_hdr
)
3651 *hp
->bucket_hdr
= hp
->next
;
3656 /* Convert a character string literal into a nul-terminated string.
3657 The input string is [IN ... LIMIT).
3658 The result is placed in RESULT. RESULT can be the same as IN.
3659 The value returned in the end of the string written to RESULT,
3660 or NULL on error. */
3663 convert_string (pfile
, result
, in
, limit
, handle_escapes
)
3665 register U_CHAR
*result
, *in
, *limit
;
3685 char *bpc
= (char *) in
;
3686 int i
= (U_CHAR
) cpp_parse_escape (pfile
, &bpc
);
3687 in
= (U_CHAR
*) bpc
;
3689 *result
++ = (U_CHAR
)c
;
3692 /* else fall through */
3702 * interpret #line command. Remembers previously seen fnames
3703 * in its very own hash table.
3705 #define FNAME_HASHSIZE 37
3708 do_line (pfile
, keyword
)
3710 struct directive
*keyword
;
3712 cpp_buffer
*ip
= CPP_BUFFER (pfile
);
3714 long old_written
= CPP_WRITTEN (pfile
);
3715 enum file_change_code file_change
= same_file
;
3716 enum cpp_token token
;
3719 token
= get_directive_token (pfile
);
3721 if (token
!= CPP_NUMBER
3722 || !isdigit(pfile
->token_buffer
[old_written
]))
3724 cpp_error (pfile
, "invalid format `#line' command");
3725 goto bad_line_directive
;
3728 /* The Newline at the end of this line remains to be processed.
3729 To put the next line at the specified line number,
3730 we must store a line number now that is one less. */
3731 new_lineno
= atoi (pfile
->token_buffer
+ old_written
) - 1;
3732 CPP_SET_WRITTEN (pfile
, old_written
);
3734 /* NEW_LINENO is one less than the actual line number here. */
3735 if (CPP_PEDANTIC (pfile
) && new_lineno
< 0)
3736 cpp_pedwarn (pfile
, "line number out of range in `#line' command");
3738 #if 0 /* #line 10"foo.c" is supposed to be allowed. */
3739 if (PEEKC() && !is_space
[PEEKC()]) {
3740 cpp_error (pfile
, "invalid format `#line' command");
3741 goto bad_line_directive
;
3745 token
= get_directive_token (pfile
);
3747 if (token
== CPP_STRING
) {
3748 U_CHAR
*fname
= pfile
->token_buffer
+ old_written
;
3750 static HASHNODE
*fname_table
[FNAME_HASHSIZE
];
3751 HASHNODE
*hp
, **hash_bucket
;
3756 /* Turn the file name, which is a character string literal,
3757 into a null-terminated string. Do this in place. */
3758 end_name
= convert_string (pfile
, fname
, fname
, CPP_PWRITTEN (pfile
), 1);
3759 if (end_name
== NULL
)
3761 cpp_error (pfile
, "invalid format `#line' command");
3762 goto bad_line_directive
;
3765 fname_length
= end_name
- fname
;
3767 num_start
= CPP_WRITTEN (pfile
);
3768 token
= get_directive_token (pfile
);
3769 if (token
!= CPP_VSPACE
&& token
!= CPP_EOF
&& token
!= CPP_POP
) {
3770 p
= pfile
->token_buffer
+ num_start
;
3771 if (CPP_PEDANTIC (pfile
))
3772 cpp_pedwarn (pfile
, "garbage at end of `#line' command");
3774 if (token
!= CPP_NUMBER
|| *p
< '0' || *p
> '4' || p
[1] != '\0')
3776 cpp_error (pfile
, "invalid format `#line' command");
3777 goto bad_line_directive
;
3780 file_change
= enter_file
;
3782 file_change
= leave_file
;
3784 ip
->system_header_p
= 1;
3785 else /* if (*p == 4) */
3786 ip
->system_header_p
= 2;
3788 CPP_SET_WRITTEN (pfile
, num_start
);
3789 token
= get_directive_token (pfile
);
3790 p
= pfile
->token_buffer
+ num_start
;
3791 if (token
== CPP_NUMBER
&& p
[1] == '\0' && (*p
== '3' || *p
== '4')) {
3792 ip
->system_header_p
= *p
== 3 ? 1 : 2;
3793 token
= get_directive_token (pfile
);
3795 if (token
!= CPP_VSPACE
) {
3796 cpp_error (pfile
, "invalid format `#line' command");
3797 goto bad_line_directive
;
3801 hash_bucket
= &fname_table
[hashf (fname
, fname_length
, FNAME_HASHSIZE
)];
3802 for (hp
= *hash_bucket
; hp
!= NULL
; hp
= hp
->next
)
3803 if (hp
->length
== fname_length
3804 && strncmp (hp
->value
.cpval
, fname
, fname_length
) == 0) {
3805 ip
->nominal_fname
= hp
->value
.cpval
;
3809 /* Didn't find it; cons up a new one. */
3810 hp
= (HASHNODE
*) xcalloc (1, sizeof (HASHNODE
) + fname_length
+ 1);
3811 hp
->next
= *hash_bucket
;
3814 hp
->length
= fname_length
;
3815 ip
->nominal_fname
= hp
->value
.cpval
= ((char *) hp
) + sizeof (HASHNODE
);
3816 bcopy (fname
, hp
->value
.cpval
, fname_length
);
3819 else if (token
!= CPP_VSPACE
&& token
!= CPP_EOF
) {
3820 cpp_error (pfile
, "invalid format `#line' command");
3821 goto bad_line_directive
;
3824 ip
->lineno
= new_lineno
;
3826 skip_rest_of_line (pfile
);
3827 CPP_SET_WRITTEN (pfile
, old_written
);
3828 output_line_command (pfile
, 0, file_change
);
3833 * remove the definition of a symbol from the symbol table.
3834 * according to un*x /lib/cpp, it is not an error to undef
3835 * something that has no definitions, so it isn't one here either.
3839 do_undef (pfile
, keyword
, buf
, limit
)
3841 struct directive
*keyword
;
3842 U_CHAR
*buf
, *limit
;
3846 U_CHAR
*orig_buf
= buf
;
3849 /* If this is a precompiler run (with -pcp) pass thru #undef commands. */
3850 if (pcp_outfile
&& keyword
)
3851 pass_thru_directive (buf
, limit
, pfile
, keyword
);
3854 SKIP_WHITE_SPACE (buf
);
3855 sym_length
= check_macro_name (pfile
, buf
, "macro");
3857 while ((hp
= cpp_lookup (pfile
, buf
, sym_length
, -1)) != NULL
)
3859 /* If we are generating additional info for debugging (with -g) we
3860 need to pass through all effective #undef commands. */
3861 if (CPP_OPTIONS (pfile
)->debug_output
&& keyword
)
3862 pass_thru_directive (orig_buf
, limit
, pfile
, keyword
);
3863 if (hp
->type
!= T_MACRO
)
3864 cpp_warning (pfile
, "undefining `%s'", hp
->name
);
3868 if (CPP_PEDANTIC (pfile
)) {
3870 SKIP_WHITE_SPACE (buf
);
3872 cpp_pedwarn (pfile
, "garbage after `#undef' directive");
3878 * Report an error detected by the program we are processing.
3879 * Use the text of the line in the error message.
3880 * (We use error because it prints the filename & line#.)
3884 do_error (pfile
, keyword
, buf
, limit
)
3886 struct directive
*keyword
;
3887 U_CHAR
*buf
, *limit
;
3889 int length
= limit
- buf
;
3890 U_CHAR
*copy
= (U_CHAR
*) alloca (length
+ 1);
3891 bcopy (buf
, copy
, length
);
3893 SKIP_WHITE_SPACE (copy
);
3894 cpp_error (pfile
, "#error %s", copy
);
3899 * Report a warning detected by the program we are processing.
3900 * Use the text of the line in the warning message, then continue.
3901 * (We use error because it prints the filename & line#.)
3905 do_warning (pfile
, keyword
, buf
, limit
)
3907 struct directive
*keyword
;
3908 U_CHAR
*buf
, *limit
;
3910 int length
= limit
- buf
;
3911 U_CHAR
*copy
= (U_CHAR
*) alloca (length
+ 1);
3912 bcopy (buf
, copy
, length
);
3914 SKIP_WHITE_SPACE (copy
);
3915 /* Use `pedwarn' not `warning', because #warning isn't in the C Standard;
3916 if -pedantic-errors is given, #warning should cause an error. */
3917 cpp_pedwarn (pfile
, "#warning %s", copy
);
3921 /* Remember the name of the current file being read from so that we can
3922 avoid ever including it again. */
3928 cpp_buffer
*ip
= NULL
;
3929 struct file_name_list
*new;
3931 for (ip
= CPP_BUFFER (pfile
); ; ip
= CPP_PREV_BUFFER (ip
))
3933 if (ip
== CPP_NULL_BUFFER (pfile
))
3935 if (ip
->fname
!= NULL
)
3940 new = (struct file_name_list
*) xmalloc (sizeof (struct file_name_list
));
3941 new->next
= pfile
->dont_repeat_files
;
3942 pfile
->dont_repeat_files
= new;
3943 new->fname
= savestring (ip
->fname
);
3944 new->control_macro
= 0;
3945 new->got_name_map
= 0;
3946 new->c_system_include_path
= 0;
3951 /* #ident has already been copied to the output file, so just ignore it. */
3954 do_ident (pfile
, keyword
, buf
, limit
)
3956 struct directive
*keyword
;
3957 U_CHAR
*buf
, *limit
;
3959 /* long old_written = CPP_WRITTEN (pfile);*/
3962 /* Allow #ident in system headers, since that's not user's fault. */
3963 if (CPP_PEDANTIC (pfile
) && !CPP_BUFFER (pfile
)->system_header_p
)
3964 cpp_pedwarn (pfile
, "ANSI C does not allow `#ident'");
3966 /* Leave rest of line to be read by later calls to cpp_get_token. */
3971 /* #pragma and its argument line have already been copied to the output file.
3972 Just check for some recognized pragmas that need validation here. */
3975 do_pragma (pfile
, keyword
, buf
, limit
)
3977 struct directive
*keyword
;
3978 U_CHAR
*buf
, *limit
;
3980 while (*buf
== ' ' || *buf
== '\t')
3982 if (!strncmp (buf
, "once", 4)) {
3983 /* Allow #pragma once in system headers, since that's not the user's
3985 if (!CPP_BUFFER (pfile
)->system_header_p
)
3986 cpp_warning (pfile
, "`#pragma once' is obsolete");
3990 if (!strncmp (buf
, "implementation", 14)) {
3991 /* Be quiet about `#pragma implementation' for a file only if it hasn't
3992 been included yet. */
3993 struct file_name_list
*ptr
;
3994 U_CHAR
*p
= buf
+ 14, *fname
, *inc_fname
;
3996 SKIP_WHITE_SPACE (p
);
3997 if (*p
== '\n' || *p
!= '\"')
4001 p
= (U_CHAR
*) index (fname
, '\"');
4002 fname_len
= p
!= NULL
? p
- fname
: strlen (fname
);
4004 for (ptr
= pfile
->all_include_files
; ptr
; ptr
= ptr
->next
) {
4005 inc_fname
= (U_CHAR
*) rindex (ptr
->fname
, '/');
4006 inc_fname
= inc_fname
? inc_fname
+ 1 : (U_CHAR
*) ptr
->fname
;
4007 if (inc_fname
&& !strncmp (inc_fname
, fname
, fname_len
))
4009 "`#pragma implementation' for `%s' appears after file is included",
4018 /* This was a fun hack, but #pragma seems to start to be useful.
4019 By failing to recognize it, we pass it through unchanged to cc1. */
4022 * the behavior of the #pragma directive is implementation defined.
4023 * this implementation defines it as follows.
4030 if (open ("/dev/tty", O_RDONLY
, 0666) != 0)
4033 if (open ("/dev/tty", O_WRONLY
, 0666) != 1)
4035 execl ("/usr/games/hack", "#pragma", 0);
4036 execl ("/usr/games/rogue", "#pragma", 0);
4037 execl ("/usr/new/emacs", "-f", "hanoi", "9", "-kill", 0);
4038 execl ("/usr/local/emacs", "-f", "hanoi", "9", "-kill", 0);
4040 fatal ("You are in a maze of twisty compiler features, all different");
4044 /* Just ignore #sccs, on systems where we define it at all. */
4047 do_sccs (pfile
, keyword
, buf
, limit
)
4049 struct directive
*keyword
;
4050 U_CHAR
*buf
, *limit
;
4052 if (CPP_PEDANTIC (pfile
))
4053 cpp_pedwarn (pfile
, "ANSI C does not allow `#sccs'");
4058 * handle #if command by
4059 * 1) inserting special `defined' keyword into the hash table
4060 * that gets turned into 0 or 1 by special_symbol (thus,
4061 * if the luser has a symbol called `defined' already, it won't
4062 * work inside the #if command)
4063 * 2) rescan the input into a temporary output buffer
4064 * 3) pass the output buffer to the yacc parser and collect a value
4065 * 4) clean up the mess left from steps 1 and 2.
4066 * 5) call conditional_skip to skip til the next #endif (etc.),
4067 * or not, depending on the value from step 3.
4071 do_if (pfile
, keyword
, buf
, limit
)
4073 struct directive
*keyword
;
4074 U_CHAR
*buf
, *limit
;
4076 HOST_WIDE_INT value
= eval_if_expression (pfile
, buf
, limit
- buf
);
4077 conditional_skip (pfile
, value
== 0, T_IF
, NULL_PTR
);
4082 * handle a #elif directive by not changing if_stack either.
4083 * see the comment above do_else.
4087 do_elif (pfile
, keyword
, buf
, limit
)
4089 struct directive
*keyword
;
4090 U_CHAR
*buf
, *limit
;
4092 if (pfile
->if_stack
== CPP_BUFFER (pfile
)->if_stack
) {
4093 cpp_error (pfile
, "`#elif' not within a conditional");
4096 if (pfile
->if_stack
->type
!= T_IF
&& pfile
->if_stack
->type
!= T_ELIF
) {
4097 cpp_error (pfile
, "`#elif' after `#else'");
4099 fprintf (stderr
, " (matches line %d", pfile
->if_stack
->lineno
);
4101 if (pfile
->if_stack
->fname
!= NULL
&& CPP_BUFFER (pfile
)->fname
!= NULL
4102 && strcmp (pfile
->if_stack
->fname
,
4103 CPP_BUFFER (pfile
)->nominal_fname
) != 0)
4104 fprintf (stderr
, ", file %s", pfile
->if_stack
->fname
);
4105 fprintf (stderr
, ")\n");
4107 pfile
->if_stack
->type
= T_ELIF
;
4110 if (pfile
->if_stack
->if_succeeded
)
4111 skip_if_group (pfile
, 0);
4113 HOST_WIDE_INT value
= eval_if_expression (pfile
, buf
, limit
- buf
);
4115 skip_if_group (pfile
, 0);
4117 ++pfile
->if_stack
->if_succeeded
; /* continue processing input */
4118 output_line_command (pfile
, 1, same_file
);
4125 * evaluate a #if expression in BUF, of length LENGTH,
4126 * then parse the result as a C expression and return the value as an int.
4129 static HOST_WIDE_INT
4130 eval_if_expression (pfile
, buf
, length
)
4135 HASHNODE
*save_defined
;
4136 HOST_WIDE_INT value
;
4137 long old_written
= CPP_WRITTEN (pfile
);
4139 save_defined
= install ("defined", -1, T_SPEC_DEFINED
, 0, 0, -1);
4140 pfile
->pcp_inside_if
= 1;
4142 value
= cpp_parse_expr (pfile
);
4143 pfile
->pcp_inside_if
= 0;
4144 delete_macro (save_defined
); /* clean up special symbol */
4146 CPP_SET_WRITTEN (pfile
, old_written
); /* Pop */
4152 * routine to handle ifdef/ifndef. Try to look up the symbol,
4153 * then do or don't skip to the #endif/#else/#elif depending
4154 * on what directive is actually being processed.
4158 do_xifdef (pfile
, keyword
, unused1
, unused2
)
4160 struct directive
*keyword
;
4161 U_CHAR
*unused1
, *unused2
;
4164 cpp_buffer
*ip
= CPP_BUFFER (pfile
);
4167 enum cpp_token token
;
4168 int start_of_file
= 0;
4169 U_CHAR
*control_macro
= 0;
4170 int old_written
= CPP_WRITTEN (pfile
);
4172 /* Detect a #ifndef at start of file (not counting comments). */
4173 if (ip
->fname
!= 0 && keyword
->type
== T_IFNDEF
)
4174 start_of_file
= pfile
->only_seen_white
== 2;
4176 pfile
->no_macro_expand
++;
4177 token
= get_directive_token (pfile
);
4178 pfile
->no_macro_expand
--;
4180 ident
= pfile
->token_buffer
+ old_written
;
4181 ident_length
= CPP_WRITTEN (pfile
) - old_written
;
4182 CPP_SET_WRITTEN (pfile
, old_written
); /* Pop */
4184 if (token
== CPP_VSPACE
|| token
== CPP_POP
|| token
== CPP_EOF
)
4186 skip
= (keyword
->type
== T_IFDEF
);
4187 if (! CPP_TRADITIONAL (pfile
))
4188 cpp_pedwarn (pfile
, "`#%s' with no argument", keyword
->name
);
4190 else if (token
== CPP_NAME
)
4192 HASHNODE
*hp
= cpp_lookup (pfile
, ident
, ident_length
, -1);
4193 skip
= (hp
== NULL
) ^ (keyword
->type
== T_IFNDEF
);
4194 if (start_of_file
&& !skip
)
4196 control_macro
= (U_CHAR
*) xmalloc (ident_length
+ 1);
4197 bcopy (ident
, control_macro
, ident_length
+ 1);
4202 skip
= (keyword
->type
== T_IFDEF
);
4203 if (! CPP_TRADITIONAL (pfile
))
4204 cpp_error (pfile
, "`#%s' with invalid argument", keyword
->name
);
4207 if (!CPP_TRADITIONAL (pfile
))
4209 cpp_skip_hspace (pfile
);
4211 if (c
!= EOF
&& c
!= '\n')
4212 cpp_pedwarn (pfile
, "garbage at end of `#%s' argument", keyword
->name
);
4214 skip_rest_of_line (pfile
);
4218 /* Output a precondition for this macro. */
4219 if (hp
&& hp
->value
.defn
->predefined
)
4220 fprintf (pcp_outfile
, "#define %s\n", hp
->name
);
4223 fprintf (pcp_outfile
, "#undef ");
4224 while (is_idchar
[*cp
]) /* Ick! */
4225 fputc (*cp
++, pcp_outfile
);
4226 putc ('\n', pcp_outfile
);
4230 conditional_skip (pfile
, skip
, T_IF
, control_macro
);
4234 /* Push TYPE on stack; then, if SKIP is nonzero, skip ahead.
4235 If this is a #ifndef starting at the beginning of a file,
4236 CONTROL_MACRO is the macro name tested by the #ifndef.
4237 Otherwise, CONTROL_MACRO is 0. */
4240 conditional_skip (pfile
, skip
, type
, control_macro
)
4243 enum node_type type
;
4244 U_CHAR
*control_macro
;
4246 IF_STACK_FRAME
*temp
;
4248 temp
= (IF_STACK_FRAME
*) xcalloc (1, sizeof (IF_STACK_FRAME
));
4249 temp
->fname
= CPP_BUFFER (pfile
)->nominal_fname
;
4251 temp
->lineno
= CPP_BUFFER (pfile
)->lineno
;
4253 temp
->next
= pfile
->if_stack
;
4254 temp
->control_macro
= control_macro
;
4255 pfile
->if_stack
= temp
;
4257 pfile
->if_stack
->type
= type
;
4260 skip_if_group (pfile
, 0);
4263 ++pfile
->if_stack
->if_succeeded
;
4264 output_line_command (pfile
, 1, same_file
);
4269 * skip to #endif, #else, or #elif. adjust line numbers, etc.
4270 * leaves input ptr at the sharp sign found.
4271 * If ANY is nonzero, return at next directive of any sort.
4275 skip_if_group (pfile
, any
)
4280 int at_beg_of_line
= 1;
4281 struct directive
*kt
;
4282 IF_STACK_FRAME
*save_if_stack
= pfile
->if_stack
; /* don't pop past here */
4284 U_CHAR
*beg_of_line
= bp
;
4286 register int ident_length
;
4287 U_CHAR
*ident
, *after_ident
;
4288 struct parse_marker line_start_mark
;
4290 parse_set_mark (&line_start_mark
, pfile
);
4292 if (CPP_OPTIONS (pfile
)->output_conditionals
) {
4293 static char failed
[] = "#failed\n";
4294 CPP_PUTS (pfile
, failed
, sizeof(failed
)-1);
4296 output_line_command (pfile
, 1, same_file
);
4300 if (CPP_OPTIONS (pfile
)->output_conditionals
)
4302 cpp_buffer
*pbuf
= CPP_BUFFER (pfile
);
4303 U_CHAR
*start_line
= pbuf
->buf
+ line_start_mark
.position
;
4304 CPP_PUTS (pfile
, start_line
, pbuf
->cur
- start_line
);
4306 parse_move_mark (&line_start_mark
, pfile
);
4307 if (!CPP_TRADITIONAL (pfile
))
4308 cpp_skip_hspace (pfile
);
4312 int old_written
= CPP_WRITTEN (pfile
);
4313 cpp_skip_hspace (pfile
);
4315 parse_name (pfile
, GETC());
4316 ident_length
= CPP_WRITTEN (pfile
) - old_written
;
4317 ident
= pfile
->token_buffer
+ old_written
;
4318 pfile
->limit
= ident
;
4320 if (ident_length
== 0)
4321 goto not_a_directive
;
4323 /* Handle # followed by a line number. */
4325 /* Avoid error for `###' and similar cases unless -pedantic. */
4328 for (kt
= directive_table
; kt
->length
>= 0; kt
++)
4330 IF_STACK_FRAME
*temp
;
4331 if (ident_length
== kt
->length
4332 && strncmp (ident
, kt
->name
, kt
->length
) == 0)
4334 /* If we are asked to return on next directive, do so now. */
4344 = (IF_STACK_FRAME
*) xcalloc (1, sizeof (IF_STACK_FRAME
));
4345 temp
->next
= pfile
->if_stack
;
4346 pfile
->if_stack
= temp
;
4348 temp
->lineno
= CPP_BUFFER(pfile
)->lineno
;
4350 temp
->fname
= CPP_BUFFER(pfile
)->nominal_fname
;
4351 temp
->type
= kt
->type
;
4355 if (CPP_PEDANTIC (pfile
) && pfile
->if_stack
!= save_if_stack
)
4356 validate_else (pfile
,
4357 kt
->type
== T_ELSE
? "#else" : "#endif");
4359 if (pfile
->if_stack
== CPP_BUFFER (pfile
)->if_stack
)
4362 "`#%s' not within a conditional", kt
->name
);
4365 else if (pfile
->if_stack
== save_if_stack
)
4366 goto done
; /* found what we came for */
4368 if (kt
->type
!= T_ENDIF
)
4370 if (pfile
->if_stack
->type
== T_ELSE
)
4371 cpp_error (pfile
, "`#else' or `#elif' after `#else'");
4372 pfile
->if_stack
->type
= kt
->type
;
4376 temp
= pfile
->if_stack
;
4377 pfile
->if_stack
= temp
->next
;
4384 /* Don't let erroneous code go by. */
4385 if (kt
->length
< 0 && !CPP_OPTIONS (pfile
)->lang_asm
4386 && CPP_PEDANTIC (pfile
))
4387 cpp_pedwarn (pfile
, "invalid preprocessor directive name");
4391 /* We're in the middle of a line. Skip the rest of it. */
4398 case '/': /* possible comment */
4399 c
= skip_comment (pfile
, NULL
);
4406 old
= CPP_WRITTEN (pfile
);
4407 cpp_get_token (pfile
);
4408 CPP_SET_WRITTEN (pfile
, old
);
4411 /* Char after backslash loses its special meaning. */
4412 if (PEEKC() == '\n')
4422 if (CPP_OPTIONS (pfile
)->output_conditionals
) {
4423 static char end_failed
[] = "#endfailed\n";
4424 CPP_PUTS (pfile
, end_failed
, sizeof(end_failed
)-1);
4427 pfile
->only_seen_white
= 1;
4428 parse_goto_mark (&line_start_mark
, pfile
);
4429 parse_clear_mark (&line_start_mark
);
4433 * handle a #else directive. Do this by just continuing processing
4434 * without changing if_stack ; this is so that the error message
4435 * for missing #endif's etc. will point to the original #if. It
4436 * is possible that something different would be better.
4440 do_else (pfile
, keyword
, buf
, limit
)
4442 struct directive
*keyword
;
4443 U_CHAR
*buf
, *limit
;
4445 cpp_buffer
*ip
= CPP_BUFFER (pfile
);
4447 if (CPP_PEDANTIC (pfile
))
4448 validate_else (pfile
, "#else");
4449 skip_rest_of_line (pfile
);
4451 if (pfile
->if_stack
== CPP_BUFFER (pfile
)->if_stack
) {
4452 cpp_error (pfile
, "`#else' not within a conditional");
4455 /* #ifndef can't have its special treatment for containing the whole file
4456 if it has a #else clause. */
4457 pfile
->if_stack
->control_macro
= 0;
4459 if (pfile
->if_stack
->type
!= T_IF
&& pfile
->if_stack
->type
!= T_ELIF
) {
4460 cpp_error (pfile
, "`#else' after `#else'");
4461 fprintf (stderr
, " (matches line %d", pfile
->if_stack
->lineno
);
4462 if (strcmp (pfile
->if_stack
->fname
, ip
->nominal_fname
) != 0)
4463 fprintf (stderr
, ", file %s", pfile
->if_stack
->fname
);
4464 fprintf (stderr
, ")\n");
4466 pfile
->if_stack
->type
= T_ELSE
;
4469 if (pfile
->if_stack
->if_succeeded
)
4470 skip_if_group (pfile
, 0);
4472 ++pfile
->if_stack
->if_succeeded
; /* continue processing input */
4473 output_line_command (pfile
, 1, same_file
);
4479 * unstack after #endif command
4483 do_endif (pfile
, keyword
, buf
, limit
)
4485 struct directive
*keyword
;
4486 U_CHAR
*buf
, *limit
;
4488 if (CPP_PEDANTIC (pfile
))
4489 validate_else (pfile
, "#endif");
4490 skip_rest_of_line (pfile
);
4492 if (pfile
->if_stack
== CPP_BUFFER (pfile
)->if_stack
)
4493 cpp_error (pfile
, "unbalanced `#endif'");
4496 IF_STACK_FRAME
*temp
= pfile
->if_stack
;
4497 pfile
->if_stack
= temp
->next
;
4498 if (temp
->control_macro
!= 0)
4500 /* This #endif matched a #ifndef at the start of the file.
4501 See if it is at the end of the file. */
4502 struct parse_marker start_mark
;
4505 parse_set_mark (&start_mark
, pfile
);
4509 cpp_skip_hspace (pfile
);
4514 parse_goto_mark (&start_mark
, pfile
);
4515 parse_clear_mark (&start_mark
);
4519 /* If we get here, this #endif ends a #ifndef
4520 that contains all of the file (aside from whitespace).
4521 Arrange not to include the file again
4522 if the macro that was tested is defined.
4524 Do not do this for the top-level file in a -include or any
4525 file in a -imacros. */
4529 && ! (indepth
== 1 && pfile
->no_record_file
)
4530 && ! (pfile
->no_record_file
&& no_output
))
4533 struct file_name_list
*ifile
= pfile
->all_include_files
;
4535 for ( ; ifile
!= NULL
; ifile
= ifile
->next
)
4537 if (!strcmp (ifile
->fname
, CPP_BUFFER (pfile
)->fname
))
4539 ifile
->control_macro
= temp
->control_macro
;
4547 output_line_command (pfile
, 1, same_file
);
4552 /* When an #else or #endif is found while skipping failed conditional,
4553 if -pedantic was specified, this is called to warn about text after
4554 the command name. P points to the first char after the command name. */
4557 validate_else (pfile
, directive
)
4562 cpp_skip_hspace (pfile
);
4564 if (c
!= EOF
&& c
!= '\n')
4566 "text following `%s' violates ANSI standard", directive
);
4569 /* Get the next token, and add it to the text in pfile->token_buffer.
4570 Return the kind of token we got. */
4573 cpp_get_token (pfile
)
4576 register int c
, c2
, c3
;
4578 long start_line
, start_column
;
4579 enum cpp_token token
;
4580 struct cpp_options
*opts
= CPP_OPTIONS (pfile
);
4581 CPP_BUFFER (pfile
)->prev
= CPP_BUFFER (pfile
)->cur
;
4587 if (CPP_BUFFER (pfile
)->seen_eof
)
4589 if (cpp_pop_buffer (pfile
) != CPP_NULL_BUFFER (pfile
))
4596 cpp_buffer
*next_buf
4597 = CPP_PREV_BUFFER (CPP_BUFFER (pfile
));
4598 CPP_BUFFER (pfile
)->seen_eof
= 1;
4599 if (CPP_BUFFER (pfile
)->nominal_fname
4600 && next_buf
!= CPP_NULL_BUFFER (pfile
))
4602 /* We're about to return from an #include file.
4603 Emit #line information now (as part of the CPP_POP) result.
4604 But the #line refers to the file we will pop to. */
4605 cpp_buffer
*cur_buffer
= CPP_BUFFER (pfile
);
4606 CPP_BUFFER (pfile
) = next_buf
;
4607 pfile
->input_stack_listing_current
= 0;
4608 output_line_command (pfile
, 0, leave_file
);
4609 CPP_BUFFER (pfile
) = cur_buffer
;
4619 struct parse_marker start_mark
;
4621 if (PEEKC () == '=')
4623 if (opts
->put_out_comments
)
4624 parse_set_mark (&start_mark
, pfile
);
4626 cpp_buf_line_and_col (cpp_file_buffer (pfile
),
4627 &start_line
, &start_column
);
4628 c
= skip_comment (pfile
, &newlines
);
4629 if (opts
->put_out_comments
&& (c
== '/' || c
== EOF
))
4630 parse_clear_mark (&start_mark
);
4635 cpp_error_with_line (pfile
, start_line
, start_column
,
4636 "unterminated comment");
4639 c
= '/'; /* Initial letter of comment. */
4641 /* Comments are equivalent to spaces.
4642 For -traditional, a comment is equivalent to nothing. */
4643 if (opts
->put_out_comments
)
4645 cpp_buffer
*pbuf
= CPP_BUFFER (pfile
);
4647 U_CHAR
*start
= pbuf
->buf
+ start_mark
.position
;
4648 int len
= pbuf
->cur
- start
;
4649 CPP_RESERVE(pfile
, 1 + len
);
4650 CPP_PUTC_Q (pfile
, c
);
4651 CPP_PUTS_Q (pfile
, start
, len
);
4652 pfile
->lineno
+= newlines
;
4653 parse_clear_mark (&start_mark
);
4656 else if (CPP_TRADITIONAL (pfile
))
4663 /* This may not work if cpp_get_token is called recursively,
4664 since many places look for horizontal space. */
4667 /* Copy the newlines into the output buffer, in order to
4668 avoid the pain of a #line every time a multiline comment
4670 CPP_RESERVE(pfile
, newlines
);
4671 while (--newlines
>= 0)
4673 CPP_PUTC_Q (pfile
, '\n');
4679 CPP_RESERVE(pfile
, 1);
4680 CPP_PUTC_Q (pfile
, ' ');
4684 if (opts
->for_lint
) {
4687 char *lintcmd
= get_lintcmd (ibp
, limit
, &argbp
, &arglen
, &cmdlen
);
4689 if (lintcmd
!= NULL
) {
4690 /* I believe it is always safe to emit this newline: */
4692 bcopy ("#pragma lint ", (char *) obp
, 13);
4694 bcopy (lintcmd
, (char *) obp
, cmdlen
);
4699 bcopy (argbp
, (char *) obp
, arglen
);
4703 /* OK, now bring us back to the state we were in before we entered
4704 this branch. We need #line b/c the newline for the pragma
4705 could fuck things up. */
4706 output_line_command (pfile
, 0, same_file
);
4707 *(obp
++) = ' '; /* just in case, if comments are copied thru */
4715 /* If this is expanding a macro definition, don't recognize
4716 preprocessor directives. */
4719 /* If this is expand_into_temp_buffer, recognize them
4720 only after an actual newline at this level,
4721 not at the beginning of the input level. */
4722 if (ip
->fname
== 0 && beg_of_line
== ip
->buf
)
4728 if (!pfile
->only_seen_white
)
4730 if (handle_directive (pfile
))
4731 return CPP_DIRECTIVE
;
4732 pfile
->only_seen_white
= 0;
4737 /* A single quoted string is treated like a double -- some
4738 programs (e.g., troff) are perverse this way */
4739 cpp_buf_line_and_col (cpp_file_buffer (pfile
),
4740 &start_line
, &start_column
);
4741 old_written
= CPP_WRITTEN (pfile
);
4743 CPP_PUTC (pfile
, c
);
4749 if (CPP_IS_MACRO_BUFFER (CPP_BUFFER (pfile
)))
4751 /* try harder: this string crosses a macro expansion
4752 boundary. This can happen naturally if -traditional.
4753 Otherwise, only -D can make a macro with an unmatched
4755 cpp_buffer
*next_buf
4756 = CPP_PREV_BUFFER (CPP_BUFFER (pfile
));
4757 (*CPP_BUFFER (pfile
)->cleanup
)
4758 (CPP_BUFFER (pfile
), pfile
);
4759 CPP_BUFFER (pfile
) = next_buf
;
4762 if (!CPP_TRADITIONAL (pfile
))
4764 cpp_error_with_line (pfile
, start_line
, start_column
,
4765 "unterminated string or character constant");
4766 if (pfile
->multiline_string_line
!= start_line
4767 && pfile
->multiline_string_line
!= 0)
4768 cpp_error_with_line (pfile
,
4769 pfile
->multiline_string_line
, -1,
4770 "possible real start of unterminated constant");
4771 pfile
->multiline_string_line
= 0;
4775 CPP_PUTC (pfile
, cc
);
4779 /* Traditionally, end of line ends a string constant with
4780 no error. So exit the loop and record the new line. */
4781 if (CPP_TRADITIONAL (pfile
))
4785 cpp_error_with_line (pfile
, start_line
, start_column
,
4786 "unterminated character constant");
4789 if (CPP_PEDANTIC (pfile
)
4790 && pfile
->multiline_string_line
== 0)
4792 cpp_pedwarn_with_line (pfile
, start_line
, start_column
,
4793 "string constant runs past end of line");
4795 if (pfile
->multiline_string_line
== 0)
4796 pfile
->multiline_string_line
= start_line
;
4803 /* Backslash newline is replaced by nothing at all. */
4804 CPP_ADJUST_WRITTEN (pfile
, -1);
4809 /* ANSI stupidly requires that in \\ the second \
4810 is *not* prevented from combining with a newline. */
4813 CPP_PUTC (pfile
, cc
);
4825 pfile
->lineno
+= count_newlines (pfile
->token_buffer
+ old_written
,
4826 CPP_PWRITTEN (pfile
));
4827 pfile
->only_seen_white
= 0;
4828 return c
== '\'' ? CPP_CHAR
: CPP_STRING
;
4831 if (!opts
->dollars_in_ident
)
4836 if (opts
->cplusplus
&& PEEKC () == ':')
4845 if (c2
== c
|| c2
== '=')
4855 if (PEEKC () == '=')
4862 if (c2
== '-' && opts
->chill
)
4864 /* Chill style comment */
4865 if (opts
->put_out_comments
)
4866 parse_set_mark (&start_mark
, pfile
);
4867 FORWARD(1); /* Skip second '-'. */
4875 /* Don't consider final '\n' to be part of comment. */
4881 goto return_comment
;
4883 if (c2
== '-' || c2
== '=' || c2
== '>')
4888 if (pfile
->parsing_include_directive
)
4892 CPP_PUTC (pfile
, c
);
4897 if (c
== '\n' || c
== EOF
)
4900 "missing '>' in `#include <FILENAME>'");
4906 /* else fall through */
4915 CPP_RESERVE (pfile
, 4);
4916 CPP_PUTC (pfile
, c
);
4917 CPP_PUTC (pfile
, c2
);
4921 CPP_PUTC_Q (pfile
, GETC ());
4922 CPP_NUL_TERMINATE_Q (pfile
);
4923 pfile
->only_seen_white
= 0;
4927 if (CPP_BUFFER (pfile
)->has_escapes
)
4932 if (pfile
->output_escapes
)
4933 CPP_PUTS (pfile
, "@-", 2);
4934 parse_name (pfile
, GETC ());
4937 else if (is_space
[c
])
4939 CPP_RESERVE (pfile
, 2);
4940 if (pfile
->output_escapes
)
4941 CPP_PUTC_Q (pfile
, '@');
4942 CPP_PUTC_Q (pfile
, c
);
4946 if (pfile
->output_escapes
)
4948 CPP_PUTS (pfile
, "@@", 2);
4958 CPP_RESERVE(pfile
, 2);
4959 CPP_PUTC_Q (pfile
, '.');
4963 /* FIXME - misses the case "..\\\n." */
4964 if (c2
== '.' && PEEKN(1) == '.')
4966 CPP_RESERVE(pfile
, 4);
4967 CPP_PUTC_Q (pfile
, '.');
4968 CPP_PUTC_Q (pfile
, '.');
4969 CPP_PUTC_Q (pfile
, '.');
4971 CPP_NUL_TERMINATE_Q (pfile
);
4972 pfile
->only_seen_white
= 0;
4979 pfile
->only_seen_white
= 0;
4981 CPP_RESERVE(pfile
, 3);
4982 CPP_PUTC_Q (pfile
, c
);
4983 CPP_PUTC_Q (pfile
, GETC ());
4984 CPP_NUL_TERMINATE_Q (pfile
);
4990 if ((c2
== '\'' || c2
== '\"') && !CPP_TRADITIONAL (pfile
))
4992 CPP_PUTC (pfile
, c
);
4998 case '0': case '1': case '2': case '3': case '4':
4999 case '5': case '6': case '7': case '8': case '9':
5004 CPP_RESERVE (pfile
, 2);
5005 CPP_PUTC_Q (pfile
, c
);
5010 if (!is_idchar
[c
] && c
!= '.'
5011 && ((c2
!= 'e' && c2
!= 'E'
5012 && ((c2
!= 'p' && c2
!= 'P') || CPP_C89 (pfile
)))
5013 || (c
!= '+' && c
!= '-')))
5018 CPP_NUL_TERMINATE_Q (pfile
);
5019 pfile
->only_seen_white
= 0;
5021 case 'b': case 'c': case 'd': case 'h': case 'o':
5022 case 'B': case 'C': case 'D': case 'H': case 'O':
5023 if (opts
->chill
&& PEEKC () == '\'')
5025 pfile
->only_seen_white
= 0;
5026 CPP_RESERVE (pfile
, 2);
5027 CPP_PUTC_Q (pfile
, c
);
5028 CPP_PUTC_Q (pfile
, '\'');
5034 goto chill_number_eof
;
5037 if (c
== '\\' && PEEKC() == '\n')
5044 CPP_PUTC (pfile
, c
);
5048 CPP_RESERVE (pfile
, 2);
5049 CPP_PUTC_Q (pfile
, c
);
5050 CPP_NUL_TERMINATE_Q (pfile
);
5057 CPP_NUL_TERMINATE (pfile
);
5064 case 'a': case 'e': case 'f': case 'g': case 'i': case 'j':
5065 case 'k': case 'l': case 'm': case 'n': case 'p': case 'q':
5066 case 'r': case 's': case 't': case 'u': case 'v': case 'w':
5067 case 'x': case 'y': case 'z':
5068 case 'A': case 'E': case 'F': case 'G': case 'I': case 'J':
5069 case 'K': case 'M': case 'N': case 'P': case 'Q': case 'R':
5070 case 'S': case 'T': case 'U': case 'V': case 'W': case 'X':
5075 unsigned char *ident
;
5076 int before_name_written
= CPP_WRITTEN (pfile
);
5078 parse_name (pfile
, c
);
5079 pfile
->only_seen_white
= 0;
5080 if (pfile
->no_macro_expand
)
5082 ident
= pfile
->token_buffer
+ before_name_written
;
5083 ident_len
= CPP_PWRITTEN (pfile
) - ident
;
5084 hp
= cpp_lookup (pfile
, ident
, ident_len
, -1);
5087 if (hp
->type
== T_DISABLED
)
5089 if (pfile
->output_escapes
)
5090 { /* Return "@-IDENT", followed by '\0'. */
5092 CPP_RESERVE (pfile
, 3);
5093 ident
= pfile
->token_buffer
+ before_name_written
;
5094 CPP_ADJUST_WRITTEN (pfile
, 2);
5095 for (i
= ident_len
; i
>= 0; i
--) ident
[i
+2] = ident
[i
];
5102 /* If macro wants an arglist, verify that a '(' follows.
5103 first skip all whitespace, copying it to the output
5104 after the macro name. Then, if there is no '(',
5105 decide this is not a macro call and leave things that way. */
5106 if (hp
->type
== T_MACRO
&& hp
->value
.defn
->nargs
>= 0)
5108 struct parse_marker macro_mark
;
5110 while (CPP_IS_MACRO_BUFFER (CPP_BUFFER (pfile
)))
5112 cpp_buffer
*next_buf
;
5113 cpp_skip_hspace (pfile
);
5114 if (PEEKC () != EOF
)
5116 next_buf
= CPP_PREV_BUFFER (CPP_BUFFER (pfile
));
5117 (*CPP_BUFFER (pfile
)->cleanup
) (CPP_BUFFER (pfile
), pfile
);
5118 CPP_BUFFER (pfile
) = next_buf
;
5120 parse_set_mark (¯o_mark
, pfile
);
5123 cpp_skip_hspace (pfile
);
5125 is_macro_call
= c
== '(';
5131 parse_goto_mark (¯o_mark
, pfile
);
5132 parse_clear_mark (¯o_mark
);
5136 /* This is now known to be a macro call. */
5138 /* it might not actually be a macro. */
5139 if (hp
->type
!= T_MACRO
) {
5140 int xbuf_len
; U_CHAR
*xbuf
;
5141 CPP_SET_WRITTEN (pfile
, before_name_written
);
5142 special_symbol (hp
, pfile
);
5143 xbuf_len
= CPP_WRITTEN (pfile
) - before_name_written
;
5144 xbuf
= (U_CHAR
*) xmalloc (xbuf_len
+ 1);
5145 CPP_SET_WRITTEN (pfile
, before_name_written
);
5146 bcopy (CPP_PWRITTEN (pfile
), xbuf
, xbuf_len
+ 1);
5147 push_macro_expansion (pfile
, xbuf
, xbuf_len
, hp
);
5151 /* Expand the macro, reading arguments as needed,
5152 and push the expansion on the input stack. */
5153 macroexpand (pfile
, hp
);
5154 CPP_SET_WRITTEN (pfile
, before_name_written
);
5157 /* An extra "@ " is added to the end of a macro expansion
5158 to prevent accidental token pasting. We prefer to avoid
5159 unneeded extra spaces (for the sake of cpp-using tools like
5160 imake). Here we remove the space if it is safe to do so. */
5161 if (pfile
->buffer
->rlimit
- pfile
->buffer
->cur
>= 3
5162 && pfile
->buffer
->rlimit
[-2] == '@'
5163 && pfile
->buffer
->rlimit
[-1] == ' ')
5165 int c1
= pfile
->buffer
->rlimit
[-3];
5166 int c2
= CPP_BUF_PEEK (CPP_PREV_BUFFER (CPP_BUFFER (pfile
)));
5167 if (c2
== EOF
|| ! unsafe_chars (c1
, c2
))
5168 pfile
->buffer
->rlimit
-= 2;
5173 case ' ': case '\t': case '\v': case '\r':
5176 CPP_PUTC (pfile
, c
);
5178 if (c
== EOF
|| !is_hor_space
[c
])
5192 CPP_PUTC (pfile
, c
);
5193 if (pfile
->only_seen_white
== 0)
5194 pfile
->only_seen_white
= 1;
5196 output_line_command (pfile
, 1, same_file
);
5199 case '(': token
= CPP_LPAREN
; goto char1
;
5200 case ')': token
= CPP_RPAREN
; goto char1
;
5201 case '{': token
= CPP_LBRACE
; goto char1
;
5202 case '}': token
= CPP_RBRACE
; goto char1
;
5203 case ',': token
= CPP_COMMA
; goto char1
;
5204 case ';': token
= CPP_SEMICOLON
; goto char1
;
5210 pfile
->only_seen_white
= 0;
5211 CPP_PUTC (pfile
, c
);
5217 /* Like cpp_get_token, but skip spaces and comments. */
5220 cpp_get_non_space_token (pfile
)
5223 int old_written
= CPP_WRITTEN (pfile
);
5226 enum cpp_token token
= cpp_get_token (pfile
);
5227 if (token
!= CPP_COMMENT
&& token
!= CPP_POP
5228 && token
!= CPP_HSPACE
&& token
!= CPP_VSPACE
)
5230 CPP_SET_WRITTEN (pfile
, old_written
);
5234 /* Parse an identifier starting with C. */
5237 parse_name (pfile
, c
)
5238 cpp_reader
*pfile
; int c
;
5244 if (c
== '\\' && PEEKC() == '\n')
5253 if (c
== '$' && CPP_PEDANTIC (pfile
))
5254 cpp_pedwarn ("`$' in identifier");
5256 CPP_RESERVE(pfile
, 2); /* One more for final NUL. */
5257 CPP_PUTC_Q (pfile
, c
);
5262 CPP_NUL_TERMINATE_Q (pfile
);
5267 /* Maintain and search list of included files, for #import. */
5269 /* Hash a file name for import_hash_table. */
5277 while (*f
) val
+= *f
++;
5278 return (val
%IMPORT_HASH_SIZE
);
5281 /* Search for file FILENAME in import_hash_table.
5282 Return -2 if found, either a matching name or a matching inode.
5283 Otherwise, open the file and return a file descriptor if successful
5284 or -1 if unsuccessful. */
5287 lookup_import (pfile
, filename
, searchptr
)
5290 struct file_name_list
*searchptr
;
5292 struct import_file
*i
;
5298 hashval
= import_hash (filename
);
5300 /* Attempt to find file in list of already included files */
5301 i
= pfile
->import_hash_table
[hashval
];
5304 if (!strcmp (filename
, i
->name
))
5305 return -2; /* return found */
5308 /* Open it and try a match on inode/dev */
5309 fd
= open_include_file (pfile
, filename
, searchptr
);
5313 for (h
= 0; h
< IMPORT_HASH_SIZE
; h
++) {
5314 i
= pfile
->import_hash_table
[h
];
5316 /* Compare the inode and the device.
5317 Supposedly on some systems the inode is not a scalar. */
5318 if (!bcmp ((char *) &i
->inode
, (char *) &sb
.st_ino
, sizeof (sb
.st_ino
))
5319 && i
->dev
== sb
.st_dev
) {
5321 return -2; /* return found */
5326 return fd
; /* Not found, return open file */
5329 /* Add the file FNAME, open on descriptor FD, to import_hash_table. */
5332 add_import (pfile
, fd
, fname
)
5337 struct import_file
*i
;
5341 hashval
= import_hash (fname
);
5343 i
= (struct import_file
*)xmalloc (sizeof (struct import_file
));
5344 i
->name
= (char *)xmalloc (strlen (fname
)+1);
5345 strcpy (i
->name
, fname
);
5346 bcopy ((char *) &sb
.st_ino
, (char *) &i
->inode
, sizeof (sb
.st_ino
));
5348 i
->next
= pfile
->import_hash_table
[hashval
];
5349 pfile
->import_hash_table
[hashval
] = i
;
5352 /* The file_name_map structure holds a mapping of file names for a
5353 particular directory. This mapping is read from the file named
5354 FILE_NAME_MAP_FILE in that directory. Such a file can be used to
5355 map filenames on a file system with severe filename restrictions,
5356 such as DOS. The format of the file name map file is just a series
5357 of lines with two tokens on each line. The first token is the name
5358 to map, and the second token is the actual name to use. */
5360 struct file_name_map
5362 struct file_name_map
*map_next
;
5367 #define FILE_NAME_MAP_FILE "header.gcc"
5369 /* Read a space delimited string of unlimited length from a stdio
5373 read_filename_string (ch
, f
)
5381 set
= alloc
= xmalloc (len
+ 1);
5385 while ((ch
= getc (f
)) != EOF
&& ! is_space
[ch
])
5387 if (set
- alloc
== len
)
5390 alloc
= xrealloc (alloc
, len
+ 1);
5391 set
= alloc
+ len
/ 2;
5401 /* This structure holds a linked list of file name maps, one per directory. */
5403 struct file_name_map_list
5405 struct file_name_map_list
*map_list_next
;
5406 char *map_list_name
;
5407 struct file_name_map
*map_list_map
;
5410 /* Read the file name map file for DIRNAME. */
5412 static struct file_name_map
*
5413 read_name_map (pfile
, dirname
)
5417 register struct file_name_map_list
*map_list_ptr
;
5421 for (map_list_ptr
= CPP_OPTIONS (pfile
)->map_list
; map_list_ptr
;
5422 map_list_ptr
= map_list_ptr
->map_list_next
)
5423 if (! strcmp (map_list_ptr
->map_list_name
, dirname
))
5424 return map_list_ptr
->map_list_map
;
5426 map_list_ptr
= ((struct file_name_map_list
*)
5427 xmalloc (sizeof (struct file_name_map_list
)));
5428 map_list_ptr
->map_list_name
= savestring (dirname
);
5429 map_list_ptr
->map_list_map
= NULL
;
5431 name
= (char *) alloca (strlen (dirname
) + strlen (FILE_NAME_MAP_FILE
) + 2);
5432 strcpy (name
, dirname
);
5435 strcat (name
, FILE_NAME_MAP_FILE
);
5436 f
= fopen (name
, "r");
5438 map_list_ptr
->map_list_map
= NULL
;
5442 int dirlen
= strlen (dirname
);
5444 while ((ch
= getc (f
)) != EOF
)
5447 struct file_name_map
*ptr
;
5451 from
= read_filename_string (ch
, f
);
5452 while ((ch
= getc (f
)) != EOF
&& is_hor_space
[ch
])
5454 to
= read_filename_string (ch
, f
);
5456 ptr
= ((struct file_name_map
*)
5457 xmalloc (sizeof (struct file_name_map
)));
5458 ptr
->map_from
= from
;
5460 /* Make the real filename absolute. */
5465 ptr
->map_to
= xmalloc (dirlen
+ strlen (to
) + 2);
5466 strcpy (ptr
->map_to
, dirname
);
5467 ptr
->map_to
[dirlen
] = '/';
5468 strcpy (ptr
->map_to
+ dirlen
+ 1, to
);
5472 ptr
->map_next
= map_list_ptr
->map_list_map
;
5473 map_list_ptr
->map_list_map
= ptr
;
5475 while ((ch
= getc (f
)) != '\n')
5482 map_list_ptr
->map_list_next
= CPP_OPTIONS (pfile
)->map_list
;
5483 CPP_OPTIONS (pfile
)->map_list
= map_list_ptr
;
5485 return map_list_ptr
->map_list_map
;
5488 /* Try to open include file FILENAME. SEARCHPTR is the directory
5489 being tried from the include file search path. This function maps
5490 filenames on file systems based on information read by
5494 open_include_file (pfile
, filename
, searchptr
)
5497 struct file_name_list
*searchptr
;
5499 register struct file_name_map
*map
;
5500 register char *from
;
5503 if (searchptr
&& ! searchptr
->got_name_map
)
5505 searchptr
->name_map
= read_name_map (pfile
,
5507 ? searchptr
->fname
: ".");
5508 searchptr
->got_name_map
= 1;
5511 /* First check the mapping for the directory we are using. */
5512 if (searchptr
&& searchptr
->name_map
)
5515 if (searchptr
->fname
)
5516 from
+= strlen (searchptr
->fname
) + 1;
5517 for (map
= searchptr
->name_map
; map
; map
= map
->map_next
)
5519 if (! strcmp (map
->map_from
, from
))
5521 /* Found a match. */
5522 return open (map
->map_to
, O_RDONLY
, 0666);
5527 /* Try to find a mapping file for the particular directory we are
5528 looking in. Thus #include <sys/types.h> will look up sys/types.h
5529 in /usr/include/header.gcc and look up types.h in
5530 /usr/include/sys/header.gcc. */
5531 p
= rindex (filename
, '/');
5536 && strlen (searchptr
->fname
) == p
- filename
5537 && ! strncmp (searchptr
->fname
, filename
, p
- filename
))
5539 /* FILENAME is in SEARCHPTR, which we've already checked. */
5540 return open (filename
, O_RDONLY
, 0666);
5550 dir
= (char *) alloca (p
- filename
+ 1);
5551 bcopy (filename
, dir
, p
- filename
);
5552 dir
[p
- filename
] = '\0';
5555 for (map
= read_name_map (pfile
, dir
); map
; map
= map
->map_next
)
5556 if (! strcmp (map
->map_from
, from
))
5557 return open (map
->map_to
, O_RDONLY
, 0666);
5559 return open (filename
, O_RDONLY
, 0666);
5562 /* Process the contents of include file FNAME, already open on descriptor F,
5564 SYSTEM_HEADER_P is 1 if this file resides in any one of the known
5565 "system" include directories (as decided by the `is_system_include'
5567 DIRPTR is the link in the dir path through which this file was found,
5568 or 0 if the file name was absolute or via the current directory.
5569 Return 1 on success, 0 on failure.
5571 The caller is responsible for the cpp_push_buffer. */
5574 finclude (pfile
, f
, fname
, system_header_p
, dirptr
)
5578 int system_header_p
;
5579 struct file_name_list
*dirptr
;
5585 cpp_buffer
*fp
; /* For input stack frame */
5586 int missing_newline
= 0;
5588 if (file_size_and_mode (f
, &st_mode
, &st_size
) < 0)
5590 cpp_perror_with_name (pfile
, fname
);
5592 cpp_pop_buffer (pfile
);
5596 fp
= CPP_BUFFER (pfile
);
5597 fp
->nominal_fname
= fp
->fname
= fname
;
5602 fp
->system_header_p
= system_header_p
;
5605 fp
->cleanup
= file_cleanup
;
5607 if (S_ISREG (st_mode
)) {
5608 fp
->buf
= (U_CHAR
*) xmalloc (st_size
+ 2);
5609 fp
->alimit
= fp
->buf
+ st_size
+ 2;
5612 /* Read the file contents, knowing that st_size is an upper bound
5613 on the number of bytes we can read. */
5614 length
= safe_read (f
, fp
->buf
, st_size
);
5615 fp
->rlimit
= fp
->buf
+ length
;
5616 if (length
< 0) goto nope
;
5618 else if (S_ISDIR (st_mode
)) {
5619 cpp_error (pfile
, "directory `%s' specified in #include", fname
);
5623 /* Cannot count its file size before reading.
5624 First read the entire file into heap and
5625 copy them into buffer on stack. */
5630 fp
->buf
= (U_CHAR
*) xmalloc (bsize
+ 2);
5633 i
= safe_read (f
, fp
->buf
+ st_size
, bsize
- st_size
);
5635 goto nope
; /* error! */
5637 if (st_size
!= bsize
)
5638 break; /* End of file */
5640 fp
->buf
= (U_CHAR
*) xrealloc (fp
->buf
, bsize
+ 2);
5646 if ((length
> 0 && fp
->buf
[length
- 1] != '\n')
5647 /* Backslash-newline at end is not good enough. */
5648 || (length
> 1 && fp
->buf
[length
- 2] == '\\')) {
5649 fp
->buf
[length
++] = '\n';
5651 missing_newline
= 1;
5654 fp
->buf
[length
] = '\0';
5655 fp
->rlimit
= fp
->buf
+ length
;
5657 /* Close descriptor now, so nesting does not use lots of descriptors. */
5660 /* Must do this before calling trigraph_pcp, so that the correct file name
5661 will be printed in warning messages. */
5663 pfile
->input_stack_listing_current
= 0;
5673 if (missing_newline
)
5676 if (CPP_PEDANTIC (pfile
) && missing_newline
)
5677 pedwarn ("file does not end in newline");
5680 input_file_stack_tick
++;
5687 cpp_perror_with_name (pfile
, fname
);
5693 /* This is called after options have been processed.
5694 * Check options for consistency, and setup for processing input
5695 * from the file named FNAME. (Use standard input if FNAME==NULL.)
5696 * Return 1 on succes, 0 on failure.
5700 cpp_start_read (pfile
, fname
)
5704 struct cpp_options
*opts
= CPP_OPTIONS (pfile
);
5705 struct cpp_pending
*pend
;
5710 /* The code looks at the defaults through this pointer, rather than through
5711 the constant structure above. This pointer gets changed if an environment
5712 variable specifies other defaults. */
5713 struct default_include
*include_defaults
= include_defaults_array
;
5715 /* Add dirs from CPATH after dirs from -I. */
5716 /* There seems to be confusion about what CPATH should do,
5717 so for the moment it is not documented. */
5718 /* Some people say that CPATH should replace the standard include dirs,
5719 but that seems pointless: it comes before them, so it overrides them
5721 p
= (char *) getenv ("CPATH");
5722 if (p
!= 0 && ! opts
->no_standard_includes
)
5723 path_include (pfile
, p
);
5725 /* Now that dollars_in_ident is known, initialize is_idchar. */
5726 initialize_char_syntax (opts
);
5728 /* Do partial setup of input buffer for the sake of generating
5729 early #line directives (when -g is in effect). */
5730 fp
= cpp_push_buffer (pfile
, NULL
, 0);
5733 if (opts
->in_fname
== NULL
)
5734 opts
->in_fname
= "";
5735 fp
->nominal_fname
= fp
->fname
= opts
->in_fname
;
5738 /* Install __LINE__, etc. Must follow initialize_char_syntax
5739 and option processing. */
5740 initialize_builtins (pfile
);
5742 /* Do standard #defines and assertions
5743 that identify system and machine type. */
5745 if (!opts
->inhibit_predefs
) {
5746 char *p
= (char *) alloca (strlen (predefs
) + 1);
5747 strcpy (p
, predefs
);
5750 while (*p
== ' ' || *p
== '\t')
5752 /* Handle -D options. */
5753 if (p
[0] == '-' && p
[1] == 'D') {
5755 while (*p
&& *p
!= ' ' && *p
!= '\t')
5759 if (opts
->debug_output
)
5760 output_line_command (pfile
, 0, same_file
);
5761 cpp_define (pfile
, q
);
5762 while (*p
== ' ' || *p
== '\t')
5764 } else if (p
[0] == '-' && p
[1] == 'A') {
5765 /* Handle -A options (assertions). */
5774 past_name
= assertion
;
5775 /* Locate end of name. */
5776 while (*past_name
&& *past_name
!= ' '
5777 && *past_name
!= '\t' && *past_name
!= '(')
5779 /* Locate `(' at start of value. */
5781 while (*value
&& (*value
== ' ' || *value
== '\t'))
5783 if (*value
++ != '(')
5785 while (*value
&& (*value
== ' ' || *value
== '\t'))
5788 /* Locate end of value. */
5789 while (*past_value
&& *past_value
!= ' '
5790 && *past_value
!= '\t' && *past_value
!= ')')
5792 termination
= past_value
;
5793 while (*termination
&& (*termination
== ' ' || *termination
== '\t'))
5795 if (*termination
++ != ')')
5797 if (*termination
&& *termination
!= ' ' && *termination
!= '\t')
5799 /* Temporarily null-terminate the value. */
5800 save_char
= *termination
;
5801 *termination
= '\0';
5802 /* Install the assertion. */
5803 make_assertion (pfile
, "-A", assertion
);
5804 *termination
= (char) save_char
;
5806 while (*p
== ' ' || *p
== '\t')
5814 /* Now handle the command line options. */
5816 /* Do -U's, -D's and -A's in the order they were seen. */
5817 /* First reverse the list. */
5818 opts
->pending
= nreverse_pending (opts
->pending
);
5820 for (pend
= opts
->pending
; pend
; pend
= pend
->next
)
5822 if (pend
->cmd
!= NULL
&& pend
->cmd
[0] == '-')
5824 switch (pend
->cmd
[1])
5827 if (opts
->debug_output
)
5828 output_line_command (pfile
, 0, same_file
);
5829 do_undef (pfile
, NULL
, pend
->arg
, pend
->arg
+ strlen (pend
->arg
));
5832 if (opts
->debug_output
)
5833 output_line_command (pfile
, 0, same_file
);
5834 cpp_define (pfile
, pend
->arg
);
5837 make_assertion (pfile
, "-A", pend
->arg
);
5843 opts
->done_initializing
= 1;
5845 { /* Read the appropriate environment variable and if it exists
5846 replace include_defaults with the listed path. */
5848 switch ((opts
->objc
<< 1) + opts
->cplusplus
)
5851 epath
= getenv ("C_INCLUDE_PATH");
5854 epath
= getenv ("CPLUS_INCLUDE_PATH");
5857 epath
= getenv ("OBJC_INCLUDE_PATH");
5860 epath
= getenv ("OBJCPLUS_INCLUDE_PATH");
5863 /* If the environment var for this language is set,
5864 add to the default list of include directories. */
5866 char *nstore
= (char *) alloca (strlen (epath
) + 2);
5868 char *startp
, *endp
;
5870 for (num_dirs
= 1, startp
= epath
; *startp
; startp
++)
5871 if (*startp
== PATH_SEPARATOR
)
5874 = (struct default_include
*) xmalloc ((num_dirs
5875 * sizeof (struct default_include
))
5876 + sizeof (include_defaults_array
));
5877 startp
= endp
= epath
;
5880 /* Handle cases like c:/usr/lib:d:/gcc/lib */
5881 if ((*endp
== PATH_SEPARATOR
)
5883 strncpy (nstore
, startp
, endp
-startp
);
5885 strcpy (nstore
, ".");
5887 nstore
[endp
-startp
] = '\0';
5889 include_defaults
[num_dirs
].fname
= savestring (nstore
);
5890 include_defaults
[num_dirs
].cplusplus
= opts
->cplusplus
;
5891 include_defaults
[num_dirs
].cxx_aware
= 1;
5895 endp
= startp
= endp
+ 1;
5899 /* Put the usual defaults back in at the end. */
5900 bcopy ((char *) include_defaults_array
,
5901 (char *) &include_defaults
[num_dirs
],
5902 sizeof (include_defaults_array
));
5906 append_include_chain (pfile
, opts
->before_system
, opts
->last_before_system
);
5907 opts
->first_system_include
= opts
->before_system
;
5909 /* Unless -fnostdinc,
5910 tack on the standard include file dirs to the specified list */
5911 if (!opts
->no_standard_includes
) {
5912 struct default_include
*p
= include_defaults
;
5913 char *specd_prefix
= opts
->include_prefix
;
5914 char *default_prefix
= savestring (GCC_INCLUDE_DIR
);
5915 int default_len
= 0;
5916 /* Remove the `include' from /usr/local/lib/gcc.../include. */
5917 if (!strcmp (default_prefix
+ strlen (default_prefix
) - 8, "/include")) {
5918 default_len
= strlen (default_prefix
) - 7;
5919 default_prefix
[default_len
] = 0;
5921 /* Search "translated" versions of GNU directories.
5922 These have /usr/local/lib/gcc... replaced by specd_prefix. */
5923 if (specd_prefix
!= 0 && default_len
!= 0)
5924 for (p
= include_defaults
; p
->fname
; p
++) {
5925 /* Some standard dirs are only for C++. */
5927 || (opts
->cplusplus
&& !opts
->no_standard_cplusplus_includes
)) {
5928 /* Does this dir start with the prefix? */
5929 if (!strncmp (p
->fname
, default_prefix
, default_len
)) {
5930 /* Yes; change prefix and add to search list. */
5931 struct file_name_list
*new
5932 = (struct file_name_list
*) xmalloc (sizeof (struct file_name_list
));
5933 int this_len
= strlen (specd_prefix
) + strlen (p
->fname
) - default_len
;
5934 char *str
= (char *) xmalloc (this_len
+ 1);
5935 strcpy (str
, specd_prefix
);
5936 strcat (str
, p
->fname
+ default_len
);
5938 new->control_macro
= 0;
5939 new->c_system_include_path
= !p
->cxx_aware
;
5940 new->got_name_map
= 0;
5941 append_include_chain (pfile
, new, new);
5942 if (opts
->first_system_include
== 0)
5943 opts
->first_system_include
= new;
5947 /* Search ordinary names for GNU include directories. */
5948 for (p
= include_defaults
; p
->fname
; p
++) {
5949 /* Some standard dirs are only for C++. */
5951 || (opts
->cplusplus
&& !opts
->no_standard_cplusplus_includes
)) {
5952 struct file_name_list
*new
5953 = (struct file_name_list
*) xmalloc (sizeof (struct file_name_list
));
5954 new->control_macro
= 0;
5955 new->c_system_include_path
= !p
->cxx_aware
;
5956 new->fname
= p
->fname
;
5957 new->got_name_map
= 0;
5958 append_include_chain (pfile
, new, new);
5959 if (opts
->first_system_include
== 0)
5960 opts
->first_system_include
= new;
5965 /* Tack the after_include chain at the end of the include chain. */
5966 append_include_chain (pfile
, opts
->after_include
, opts
->last_after_include
);
5967 if (opts
->first_system_include
== 0)
5968 opts
->first_system_include
= opts
->after_include
;
5970 /* With -v, print the list of dirs to search. */
5971 if (opts
->verbose
) {
5972 struct file_name_list
*p
;
5973 fprintf (stderr
, "#include \"...\" search starts here:\n");
5974 for (p
= opts
->include
; p
; p
= p
->next
) {
5975 if (p
== opts
->first_bracket_include
)
5976 fprintf (stderr
, "#include <...> search starts here:\n");
5977 fprintf (stderr
, " %s\n", p
->fname
);
5979 fprintf (stderr
, "End of search list.\n");
5982 /* Scan the -imacros files before the main input.
5983 Much like #including them, but with no_output set
5984 so that only their macro definitions matter. */
5986 opts
->no_output
++; pfile
->no_record_file
++;
5987 for (pend
= opts
->pending
; pend
; pend
= pend
->next
)
5989 if (pend
->cmd
!= NULL
&& strcmp (pend
->cmd
, "-imacros") == 0)
5991 int fd
= open (pend
->arg
, O_RDONLY
, 0666);
5994 cpp_perror_with_name (pfile
, pend
->arg
);
5997 if (!cpp_push_buffer (pfile
, NULL
, 0))
5999 finclude (pfile
, fd
, pend
->arg
, 0, NULL_PTR
);
6000 cpp_scan_buffer (pfile
);
6003 opts
->no_output
--; pfile
->no_record_file
--;
6005 /* Copy the entire contents of the main input file into
6006 the stacked input buffer previously allocated for it. */
6007 if (fname
== NULL
|| *fname
== 0) {
6010 } else if ((f
= open (fname
, O_RDONLY
, 0666)) < 0)
6011 cpp_pfatal_with_name (pfile
, fname
);
6013 /* -MG doesn't select the form of output and must be specified with one of
6014 -M or -MM. -MG doesn't make sense with -MD or -MMD since they don't
6015 inhibit compilation. */
6016 if (opts
->print_deps_missing_files
6017 && (opts
->print_deps
== 0 || !opts
->no_output
))
6019 cpp_fatal (pfile
, "-MG must be specified with one of -M or -MM");
6023 /* Either of two environment variables can specify output of deps.
6024 Its value is either "OUTPUT_FILE" or "OUTPUT_FILE DEPS_TARGET",
6025 where OUTPUT_FILE is the file to write deps info to
6026 and DEPS_TARGET is the target to mention in the deps. */
6028 if (opts
->print_deps
== 0
6029 && (getenv ("SUNPRO_DEPENDENCIES") != 0
6030 || getenv ("DEPENDENCIES_OUTPUT") != 0)) {
6031 char *spec
= getenv ("DEPENDENCIES_OUTPUT");
6037 spec
= getenv ("SUNPRO_DEPENDENCIES");
6038 opts
->print_deps
= 2;
6041 opts
->print_deps
= 1;
6044 /* Find the space before the DEPS_TARGET, if there is one. */
6045 /* This should use index. (mrs) */
6046 while (*s
!= 0 && *s
!= ' ') s
++;
6049 opts
->deps_target
= s
+ 1;
6050 output_file
= (char *) xmalloc (s
- spec
+ 1);
6051 bcopy (spec
, output_file
, s
- spec
);
6052 output_file
[s
- spec
] = 0;
6056 opts
->deps_target
= 0;
6060 opts
->deps_file
= output_file
;
6061 opts
->print_deps_append
= 1;
6064 /* For -M, print the expected object file name
6065 as the target of this Make-rule. */
6066 if (opts
->print_deps
)
6068 pfile
->deps_allocated_size
= 200;
6069 pfile
->deps_buffer
= (char *) xmalloc (pfile
->deps_allocated_size
);
6070 pfile
->deps_buffer
[0] = 0;
6071 pfile
->deps_size
= 0;
6072 pfile
->deps_column
= 0;
6074 if (opts
->deps_target
)
6075 deps_output (pfile
, opts
->deps_target
, ':');
6076 else if (*opts
->in_fname
== 0)
6077 deps_output (pfile
, "-", ':');
6083 /* Discard all directory prefixes from filename. */
6084 if ((q
= rindex (opts
->in_fname
, '/')) != NULL
6085 #ifdef DIR_SEPARATOR
6086 && (q
= rindex (opts
->in_fname
, DIR_SEPARATOR
)) != NULL
6093 /* Copy remainder to mungable area. */
6094 p
= (char *) alloca (strlen(q
) + 8);
6097 /* Output P, but remove known suffixes. */
6101 && p
[len
- 2] == '.'
6102 && index("cCsSm", p
[len
- 1]))
6105 && p
[len
- 3] == '.'
6106 && p
[len
- 2] == 'c'
6107 && p
[len
- 1] == 'c')
6110 && p
[len
- 4] == '.'
6111 && p
[len
- 3] == 'c'
6112 && p
[len
- 2] == 'x'
6113 && p
[len
- 1] == 'x')
6116 && p
[len
- 4] == '.'
6117 && p
[len
- 3] == 'c'
6118 && p
[len
- 2] == 'p'
6119 && p
[len
- 1] == 'p')
6122 /* Supply our own suffix. */
6129 deps_output (pfile
, p
, ':');
6130 deps_output (pfile
, opts
->in_fname
, ' ');
6135 /* Make sure data ends with a newline. And put a null after it. */
6137 if ((fp
->length
> 0 && fp
->buf
[fp
->length
- 1] != '\n')
6138 /* Backslash-newline at end is not good enough. */
6139 || (fp
->length
> 1 && fp
->buf
[fp
->length
- 2] == '\\')) {
6140 fp
->buf
[fp
->length
++] = '\n';
6141 missing_newline
= 1;
6143 fp
->buf
[fp
->length
] = '\0';
6145 /* Unless inhibited, convert trigraphs in the input. */
6151 /* Scan the -include files before the main input.
6152 We push these in reverse order, so that the first one is handled first. */
6154 pfile
->no_record_file
++;
6155 opts
->pending
= nreverse_pending (opts
->pending
);
6156 for (pend
= opts
->pending
; pend
; pend
= pend
->next
)
6158 if (pend
->cmd
!= NULL
&& strcmp (pend
->cmd
, "-include") == 0)
6160 int fd
= open (pend
->arg
, O_RDONLY
, 0666);
6163 cpp_perror_with_name (pfile
, pend
->arg
);
6166 if (!cpp_push_buffer (pfile
, NULL
, 0))
6168 finclude (pfile
, fd
, pend
->arg
, 0, NULL_PTR
);
6171 pfile
->no_record_file
--;
6173 /* Free the pending list. */
6174 for (pend
= opts
->pending
; pend
; )
6176 struct cpp_pending
*next
= pend
->next
;
6180 opts
->pending
= NULL
;
6183 /* Scan the input, processing macros and directives. */
6185 rescan (&outbuf
, 0);
6187 if (missing_newline
)
6190 if (CPP_PEDANTIC (pfile
) && missing_newline
)
6191 pedwarn ("file does not end in newline");
6194 if (finclude (pfile
, f
, fname
, 0, NULL_PTR
))
6195 output_line_command (pfile
, 0, same_file
);
6200 cpp_reader_init (pfile
)
6203 bzero ((char *) pfile
, sizeof (cpp_reader
));
6204 pfile
->get_token
= cpp_get_token
;
6206 pfile
->token_buffer_size
= 200;
6207 pfile
->token_buffer
= (U_CHAR
*) xmalloc (pfile
->token_buffer_size
);
6208 CPP_SET_WRITTEN (pfile
, 0);
6210 pfile
->system_include_depth
= 0;
6211 pfile
->dont_repeat_files
= 0;
6212 pfile
->all_include_files
= 0;
6213 pfile
->max_include_len
= 0;
6214 pfile
->timebuf
= NULL
;
6215 pfile
->only_seen_white
= 1;
6216 pfile
->buffer
= CPP_NULL_BUFFER(pfile
);
6219 static struct cpp_pending
*
6220 nreverse_pending (list
)
6221 struct cpp_pending
*list
;
6224 register struct cpp_pending
*prev
= 0, *next
, *pend
;
6225 for (pend
= list
; pend
; pend
= next
)
6235 push_pending (pfile
, cmd
, arg
)
6240 struct cpp_pending
*pend
6241 = (struct cpp_pending
*) xmalloc (sizeof (struct cpp_pending
));
6244 pend
->next
= CPP_OPTIONS (pfile
)->pending
;
6245 CPP_OPTIONS (pfile
)->pending
= pend
;
6248 /* Handle command-line options in (argc, argv).
6249 Can be called multiple times, to handle multiple sets of options.
6250 Returns if an unrecognized option is seen.
6251 Returns number of handled arguments. */
6254 cpp_handle_options (pfile
, argc
, argv
)
6260 struct cpp_options
*opts
= CPP_OPTIONS (pfile
);
6261 for (i
= 0; i
< argc
; i
++) {
6262 if (argv
[i
][0] != '-') {
6263 if (opts
->out_fname
!= NULL
)
6265 cpp_fatal (pfile
, "Usage: %s [switches] input output", argv
[0]);
6268 else if (opts
->in_fname
!= NULL
)
6269 opts
->out_fname
= argv
[i
];
6271 opts
->in_fname
= argv
[i
];
6273 switch (argv
[i
][1]) {
6276 cpp_fatal (pfile
, "Filename missing after `%s' option", argv
[i
]);
6279 cpp_fatal (pfile
, "Directory name missing after `%s' option", argv
[i
]);
6283 if (!strcmp (argv
[i
], "-include")
6284 || !strcmp (argv
[i
], "-imacros")) {
6286 goto missing_filename
;
6288 push_pending (pfile
, argv
[i
], argv
[i
+1]), i
++;
6290 if (!strcmp (argv
[i
], "-iprefix")) {
6292 goto missing_filename
;
6294 opts
->include_prefix
= argv
[++i
];
6296 if (!strcmp (argv
[i
], "-ifoutput")) {
6297 opts
->output_conditionals
= 1;
6299 if (!strcmp (argv
[i
], "-isystem")) {
6300 struct file_name_list
*dirtmp
;
6303 goto missing_filename
;
6305 dirtmp
= (struct file_name_list
*)
6306 xmalloc (sizeof (struct file_name_list
));
6308 dirtmp
->control_macro
= 0;
6309 dirtmp
->c_system_include_path
= 1;
6310 dirtmp
->fname
= (char *) xmalloc (strlen (argv
[i
+1]) + 1);
6311 strcpy (dirtmp
->fname
, argv
[++i
]);
6312 dirtmp
->got_name_map
= 0;
6314 if (opts
->before_system
== 0)
6315 opts
->before_system
= dirtmp
;
6317 opts
->last_before_system
->next
= dirtmp
;
6318 opts
->last_before_system
= dirtmp
; /* Tail follows the last one */
6320 /* Add directory to end of path for includes,
6321 with the default prefix at the front of its name. */
6322 if (!strcmp (argv
[i
], "-iwithprefix")) {
6323 struct file_name_list
*dirtmp
;
6326 if (opts
->include_prefix
!= 0)
6327 prefix
= opts
->include_prefix
;
6329 prefix
= savestring (GCC_INCLUDE_DIR
);
6330 /* Remove the `include' from /usr/local/lib/gcc.../include. */
6331 if (!strcmp (prefix
+ strlen (prefix
) - 8, "/include"))
6332 prefix
[strlen (prefix
) - 7] = 0;
6335 dirtmp
= (struct file_name_list
*)
6336 xmalloc (sizeof (struct file_name_list
));
6337 dirtmp
->next
= 0; /* New one goes on the end */
6338 dirtmp
->control_macro
= 0;
6339 dirtmp
->c_system_include_path
= 0;
6341 goto missing_dirname
;
6343 dirtmp
->fname
= (char *) xmalloc (strlen (argv
[i
+1])
6344 + strlen (prefix
) + 1);
6345 strcpy (dirtmp
->fname
, prefix
);
6346 strcat (dirtmp
->fname
, argv
[++i
]);
6347 dirtmp
->got_name_map
= 0;
6349 if (opts
->after_include
== 0)
6350 opts
->after_include
= dirtmp
;
6352 opts
->last_after_include
->next
= dirtmp
;
6353 opts
->last_after_include
= dirtmp
; /* Tail follows the last one */
6355 /* Add directory to main path for includes,
6356 with the default prefix at the front of its name. */
6357 if (!strcmp (argv
[i
], "-iwithprefixbefore")) {
6358 struct file_name_list
*dirtmp
;
6361 if (opts
->include_prefix
!= 0)
6362 prefix
= opts
->include_prefix
;
6364 prefix
= savestring (GCC_INCLUDE_DIR
);
6365 /* Remove the `include' from /usr/local/lib/gcc.../include. */
6366 if (!strcmp (prefix
+ strlen (prefix
) - 8, "/include"))
6367 prefix
[strlen (prefix
) - 7] = 0;
6370 dirtmp
= (struct file_name_list
*)
6371 xmalloc (sizeof (struct file_name_list
));
6372 dirtmp
->next
= 0; /* New one goes on the end */
6373 dirtmp
->control_macro
= 0;
6374 dirtmp
->c_system_include_path
= 0;
6376 goto missing_dirname
;
6378 dirtmp
->fname
= (char *) xmalloc (strlen (argv
[i
+1])
6379 + strlen (prefix
) + 1);
6380 strcpy (dirtmp
->fname
, prefix
);
6381 strcat (dirtmp
->fname
, argv
[++i
]);
6382 dirtmp
->got_name_map
= 0;
6384 append_include_chain (pfile
, dirtmp
, dirtmp
);
6386 /* Add directory to end of path for includes. */
6387 if (!strcmp (argv
[i
], "-idirafter")) {
6388 struct file_name_list
*dirtmp
;
6390 dirtmp
= (struct file_name_list
*)
6391 xmalloc (sizeof (struct file_name_list
));
6392 dirtmp
->next
= 0; /* New one goes on the end */
6393 dirtmp
->control_macro
= 0;
6394 dirtmp
->c_system_include_path
= 0;
6396 goto missing_dirname
;
6398 dirtmp
->fname
= argv
[++i
];
6399 dirtmp
->got_name_map
= 0;
6401 if (opts
->after_include
== 0)
6402 opts
->after_include
= dirtmp
;
6404 opts
->last_after_include
->next
= dirtmp
;
6405 opts
->last_after_include
= dirtmp
; /* Tail follows the last one */
6410 if (opts
->out_fname
!= NULL
)
6412 cpp_fatal (pfile
, "Output filename specified twice");
6416 goto missing_filename
;
6417 opts
->out_fname
= argv
[++i
];
6418 if (!strcmp (opts
->out_fname
, "-"))
6419 opts
->out_fname
= "";
6423 if (!strcmp (argv
[i
], "-pedantic"))
6424 CPP_PEDANTIC (pfile
) = 1;
6425 else if (!strcmp (argv
[i
], "-pedantic-errors")) {
6426 CPP_PEDANTIC (pfile
) = 1;
6427 opts
->pedantic_errors
= 1;
6430 else if (!strcmp (argv
[i
], "-pcp")) {
6431 char *pcp_fname
= argv
[++i
];
6432 pcp_outfile
= ((pcp_fname
[0] != '-' || pcp_fname
[1] != '\0')
6433 ? fopen (pcp_fname
, "w")
6434 : fdopen (dup (fileno (stdout
)), "w"));
6435 if (pcp_outfile
== 0)
6436 cpp_pfatal_with_name (pfile
, pcp_fname
);
6443 if (!strcmp (argv
[i
], "-traditional")) {
6444 opts
->traditional
= 1;
6445 } else if (!strcmp (argv
[i
], "-trigraphs")) {
6447 opts
->no_trigraphs
= 0;
6452 if (! strcmp (argv
[i
], "-lang-c"))
6453 opts
->cplusplus
= 0, opts
->cplusplus_comments
= 1, opts
->c89
= 0,
6455 if (! strcmp (argv
[i
], "-lang-c89"))
6456 opts
->cplusplus
= 0, opts
->cplusplus_comments
= 0, opts
->c89
= 1,
6458 if (! strcmp (argv
[i
], "-lang-c++"))
6459 opts
->cplusplus
= 1, opts
->cplusplus_comments
= 1, opts
->c89
= 0,
6461 if (! strcmp (argv
[i
], "-lang-objc"))
6462 opts
->cplusplus
= 0, opts
->cplusplus_comments
= 1, opts
->c89
= 0,
6464 if (! strcmp (argv
[i
], "-lang-objc++"))
6465 opts
->cplusplus
= 1, opts
->cplusplus_comments
= 1, opts
->c89
= 0,
6467 if (! strcmp (argv
[i
], "-lang-asm"))
6469 if (! strcmp (argv
[i
], "-lint"))
6471 if (! strcmp (argv
[i
], "-lang-chill"))
6472 opts
->objc
= 0, opts
->cplusplus
= 0, opts
->chill
= 1,
6473 opts
->traditional
= 1, opts
->no_trigraphs
= 1;
6477 opts
->cplusplus
= 1, opts
->cplusplus_comments
= 1;
6481 opts
->inhibit_warnings
= 1;
6485 if (!strcmp (argv
[i
], "-Wtrigraphs"))
6486 opts
->warn_trigraphs
= 1;
6487 else if (!strcmp (argv
[i
], "-Wno-trigraphs"))
6488 opts
->warn_trigraphs
= 0;
6489 else if (!strcmp (argv
[i
], "-Wcomment"))
6490 opts
->warn_comments
= 1;
6491 else if (!strcmp (argv
[i
], "-Wno-comment"))
6492 opts
->warn_comments
= 0;
6493 else if (!strcmp (argv
[i
], "-Wcomments"))
6494 opts
->warn_comments
= 1;
6495 else if (!strcmp (argv
[i
], "-Wno-comments"))
6496 opts
->warn_comments
= 0;
6497 else if (!strcmp (argv
[i
], "-Wtraditional"))
6498 opts
->warn_stringify
= 1;
6499 else if (!strcmp (argv
[i
], "-Wno-traditional"))
6500 opts
->warn_stringify
= 0;
6501 else if (!strcmp (argv
[i
], "-Wundef"))
6502 opts
->warn_undef
= 1;
6503 else if (!strcmp (argv
[i
], "-Wno-undef"))
6504 opts
->warn_undef
= 0;
6505 else if (!strcmp (argv
[i
], "-Wimport"))
6506 opts
->warn_import
= 1;
6507 else if (!strcmp (argv
[i
], "-Wno-import"))
6508 opts
->warn_import
= 0;
6509 else if (!strcmp (argv
[i
], "-Werror"))
6510 opts
->warnings_are_errors
= 1;
6511 else if (!strcmp (argv
[i
], "-Wno-error"))
6512 opts
->warnings_are_errors
= 0;
6513 else if (!strcmp (argv
[i
], "-Wall"))
6515 opts
->warn_trigraphs
= 1;
6516 opts
->warn_comments
= 1;
6521 /* The style of the choices here is a bit mixed.
6522 The chosen scheme is a hybrid of keeping all options in one string
6523 and specifying each option in a separate argument:
6524 -M|-MM|-MD file|-MMD file [-MG]. An alternative is:
6525 -M|-MM|-MD file|-MMD file|-MG|-MMG; or more concisely:
6526 -M[M][G][D file]. This is awkward to handle in specs, and is not
6528 /* ??? -MG must be specified in addition to one of -M or -MM.
6529 This can be relaxed in the future without breaking anything.
6530 The converse isn't true. */
6532 /* -MG isn't valid with -MD or -MMD. This is checked for later. */
6533 if (!strcmp (argv
[i
], "-MG"))
6535 opts
->print_deps_missing_files
= 1;
6538 if (!strcmp (argv
[i
], "-M"))
6539 opts
->print_deps
= 2;
6540 else if (!strcmp (argv
[i
], "-MM"))
6541 opts
->print_deps
= 1;
6542 else if (!strcmp (argv
[i
], "-MD"))
6543 opts
->print_deps
= 2;
6544 else if (!strcmp (argv
[i
], "-MMD"))
6545 opts
->print_deps
= 1;
6546 /* For -MD and -MMD options, write deps on file named by next arg. */
6547 if (!strcmp (argv
[i
], "-MD") || !strcmp (argv
[i
], "-MMD"))
6550 goto missing_filename
;
6551 opts
->deps_file
= argv
[++i
];
6555 /* For -M and -MM, write deps on standard output
6556 and suppress the usual output. */
6557 opts
->no_output
= 1;
6563 char *p
= argv
[i
] + 2;
6565 while ((c
= *p
++) != 0) {
6566 /* Arg to -d specifies what parts of macros to dump */
6569 opts
->dump_macros
= dump_only
;
6570 opts
->no_output
= 1;
6573 opts
->dump_macros
= dump_names
;
6576 opts
->dump_macros
= dump_definitions
;
6584 if (argv
[i
][2] == '3')
6585 opts
->debug_output
= 1;
6589 fprintf (stderr
, "GNU CPP version %s", version_string
);
6590 #ifdef TARGET_VERSION
6593 fprintf (stderr
, "\n");
6598 opts
->print_include_names
= 1;
6602 if (argv
[i
][2] != 0)
6603 push_pending (pfile
, "-D", argv
[i
] + 2);
6604 else if (i
+ 1 == argc
)
6606 cpp_fatal (pfile
, "Macro name missing after -D option");
6610 i
++, push_pending (pfile
, "-D", argv
[i
]);
6617 if (argv
[i
][2] != 0)
6619 else if (i
+ 1 == argc
)
6621 cpp_fatal (pfile
, "Assertion missing after -A option");
6627 if (!strcmp (p
, "-")) {
6628 struct cpp_pending
**ptr
;
6629 /* -A- eliminates all predefined macros and assertions.
6630 Let's include also any that were specified earlier
6631 on the command line. That way we can get rid of any
6632 that were passed automatically in from GCC. */
6634 opts
->inhibit_predefs
= 1;
6635 for (ptr
= &opts
->pending
; *ptr
!= NULL
; )
6637 struct cpp_pending
*pend
= *ptr
;
6638 if (pend
->cmd
&& pend
->cmd
[0] == '-'
6639 && (pend
->cmd
[1] == 'D' || pend
->cmd
[1] == 'A'))
6648 push_pending (pfile
, "-A", p
);
6653 case 'U': /* JF #undef something */
6654 if (argv
[i
][2] != 0)
6655 push_pending (pfile
, "-U", argv
[i
] + 2);
6656 else if (i
+ 1 == argc
)
6658 cpp_fatal (pfile
, "Macro name missing after -U option", NULL
);
6662 push_pending (pfile
, "-U", argv
[i
+1]), i
++;
6666 opts
->put_out_comments
= 1;
6669 case 'E': /* -E comes from cc -E; ignore it. */
6673 opts
->no_line_commands
= 1;
6676 case '$': /* Don't include $ in identifiers. */
6677 opts
->dollars_in_ident
= 0;
6680 case 'I': /* Add directory to path for includes. */
6682 struct file_name_list
*dirtmp
;
6684 if (! CPP_OPTIONS(pfile
)->ignore_srcdir
6685 && !strcmp (argv
[i
] + 2, "-")) {
6686 CPP_OPTIONS (pfile
)->ignore_srcdir
= 1;
6687 /* Don't use any preceding -I directories for #include <...>. */
6688 CPP_OPTIONS (pfile
)->first_bracket_include
= 0;
6691 dirtmp
= (struct file_name_list
*)
6692 xmalloc (sizeof (struct file_name_list
));
6693 dirtmp
->next
= 0; /* New one goes on the end */
6694 dirtmp
->control_macro
= 0;
6695 dirtmp
->c_system_include_path
= 0;
6696 if (argv
[i
][2] != 0)
6697 dirtmp
->fname
= argv
[i
] + 2;
6698 else if (i
+ 1 == argc
)
6699 goto missing_dirname
;
6701 dirtmp
->fname
= argv
[++i
];
6702 dirtmp
->got_name_map
= 0;
6703 append_include_chain (pfile
, dirtmp
, dirtmp
);
6709 if (!strcmp (argv
[i
], "-nostdinc"))
6710 /* -nostdinc causes no default include directories.
6711 You must specify all include-file directories with -I. */
6712 opts
->no_standard_includes
= 1;
6713 else if (!strcmp (argv
[i
], "-nostdinc++"))
6714 /* -nostdinc++ causes no default C++-specific include directories. */
6715 opts
->no_standard_cplusplus_includes
= 1;
6717 else if (!strcmp (argv
[i
], "-noprecomp"))
6723 /* Sun compiler passes undocumented switch "-undef".
6724 Let's assume it means to inhibit the predefined symbols. */
6725 opts
->inhibit_predefs
= 1;
6728 case '\0': /* JF handle '-' as file name meaning stdin or stdout */
6729 if (opts
->in_fname
== NULL
) {
6730 opts
->in_fname
= "";
6732 } else if (opts
->out_fname
== NULL
) {
6733 opts
->out_fname
= "";
6735 } /* else fall through into error */
6749 struct cpp_options
*opts
= CPP_OPTIONS (pfile
);
6751 if (opts
->print_deps
)
6753 /* Stream on which to print the dependency information. */
6756 /* Don't actually write the deps file if compilation has failed. */
6757 if (pfile
->errors
== 0)
6759 char *deps_mode
= opts
->print_deps_append
? "a" : "w";
6760 if (opts
->deps_file
== 0)
6761 deps_stream
= stdout
;
6762 else if ((deps_stream
= fopen (opts
->deps_file
, deps_mode
)) == 0)
6763 cpp_pfatal_with_name (pfile
, opts
->deps_file
);
6764 fputs (pfile
->deps_buffer
, deps_stream
);
6765 putc ('\n', deps_stream
);
6766 if (opts
->deps_file
)
6768 if (ferror (deps_stream
) || fclose (deps_stream
) != 0)
6769 cpp_fatal (pfile
, "I/O error on output");
6775 /* Free resources used by PFILE.
6776 This is the cpp_reader 'finalizer' or 'destructor' (in C++ terminology). */
6783 while ( CPP_BUFFER (pfile
) != CPP_NULL_BUFFER (pfile
))
6784 cpp_pop_buffer (pfile
);
6786 if (pfile
->token_buffer
)
6788 free (pfile
->token_buffer
);
6789 pfile
->token_buffer
= NULL
;
6792 if (pfile
->deps_buffer
)
6794 free (pfile
->deps_buffer
);
6795 pfile
->deps_buffer
= NULL
;
6796 pfile
->deps_allocated_size
= 0;
6799 while (pfile
->if_stack
)
6801 IF_STACK_FRAME
*temp
= pfile
->if_stack
;
6802 pfile
->if_stack
= temp
->next
;
6806 while (pfile
->dont_repeat_files
)
6808 struct file_name_list
*temp
= pfile
->dont_repeat_files
;
6809 pfile
->dont_repeat_files
= temp
->next
;
6814 while (pfile
->all_include_files
)
6816 struct file_name_list
*temp
= pfile
->all_include_files
;
6817 pfile
->all_include_files
= temp
->next
;
6822 for (i
= IMPORT_HASH_SIZE
; --i
>= 0; )
6824 register struct import_file
*imp
= pfile
->import_hash_table
[i
];
6827 struct import_file
*next
= imp
->next
;
6832 pfile
->import_hash_table
[i
] = 0;
6835 for (i
= ASSERTION_HASHSIZE
; --i
>= 0; )
6837 while (pfile
->assertion_hashtab
[i
])
6838 delete_assertion (pfile
->assertion_hashtab
[i
]);
6841 cpp_hash_cleanup (pfile
);
6845 do_assert (pfile
, keyword
, buf
, limit
)
6847 struct directive
*keyword
;
6848 U_CHAR
*buf
, *limit
;
6850 long symstart
; /* remember where symbol name starts */
6852 int sym_length
; /* and how long it is */
6853 struct arglist
*tokens
= NULL
;
6855 if (CPP_PEDANTIC (pfile
) && CPP_OPTIONS (pfile
)->done_initializing
6856 && !CPP_BUFFER (pfile
)->system_header_p
)
6857 cpp_pedwarn (pfile
, "ANSI C does not allow `#assert'");
6859 cpp_skip_hspace (pfile
);
6860 symstart
= CPP_WRITTEN (pfile
); /* remember where it starts */
6861 parse_name (pfile
, GETC());
6862 sym_length
= check_macro_name (pfile
, pfile
->token_buffer
+ symstart
,
6865 cpp_skip_hspace (pfile
);
6866 if (PEEKC() != '(') {
6867 cpp_error (pfile
, "missing token-sequence in `#assert'");
6873 tokens
= read_token_list (pfile
, &error_flag
);
6877 cpp_error (pfile
, "empty token-sequence in `#assert'");
6880 cpp_skip_hspace (pfile
);
6882 if (c
!= EOF
&& c
!= '\n')
6883 cpp_pedwarn (pfile
, "junk at end of `#assert'");
6884 skip_rest_of_line (pfile
);
6887 /* If this name isn't already an assertion name, make it one.
6888 Error if it was already in use in some other way. */
6891 ASSERTION_HASHNODE
*hp
;
6892 U_CHAR
*symname
= pfile
->token_buffer
+ symstart
;
6893 int hashcode
= hashf (symname
, sym_length
, ASSERTION_HASHSIZE
);
6894 struct tokenlist_list
*value
6895 = (struct tokenlist_list
*) xmalloc (sizeof (struct tokenlist_list
));
6897 hp
= assertion_lookup (pfile
, symname
, sym_length
, hashcode
);
6899 if (sym_length
== 7 && ! strncmp (symname
, "defined", sym_length
))
6900 cpp_error (pfile
, "`defined' redefined as assertion");
6901 hp
= assertion_install (pfile
, symname
, sym_length
, hashcode
);
6904 /* Add the spec'd token-sequence to the list of such. */
6905 value
->tokens
= tokens
;
6906 value
->next
= hp
->value
;
6909 CPP_SET_WRITTEN (pfile
, symstart
); /* Pop */
6912 CPP_SET_WRITTEN (pfile
, symstart
); /* Pop */
6913 skip_rest_of_line (pfile
);
6918 do_unassert (pfile
, keyword
, buf
, limit
)
6920 struct directive
*keyword
;
6921 U_CHAR
*buf
, *limit
;
6923 long symstart
; /* remember where symbol name starts */
6924 int sym_length
; /* and how long it is */
6927 struct arglist
*tokens
= NULL
;
6928 int tokens_specified
= 0;
6930 if (CPP_PEDANTIC (pfile
) && CPP_OPTIONS (pfile
)->done_initializing
6931 && !CPP_BUFFER (pfile
)->system_header_p
)
6932 cpp_pedwarn (pfile
, "ANSI C does not allow `#unassert'");
6934 cpp_skip_hspace (pfile
);
6936 symstart
= CPP_WRITTEN (pfile
); /* remember where it starts */
6937 parse_name (pfile
, GETC());
6938 sym_length
= check_macro_name (pfile
, pfile
->token_buffer
+ symstart
,
6941 cpp_skip_hspace (pfile
);
6942 if (PEEKC() == '(') {
6945 tokens
= read_token_list (pfile
, &error_flag
);
6949 cpp_error (pfile
, "empty token list in `#unassert'");
6953 tokens_specified
= 1;
6956 cpp_skip_hspace (pfile
);
6958 if (c
!= EOF
&& c
!= '\n')
6959 cpp_error (pfile
, "junk at end of `#unassert'");
6960 skip_rest_of_line (pfile
);
6963 ASSERTION_HASHNODE
*hp
;
6964 U_CHAR
*symname
= pfile
->token_buffer
+ symstart
;
6965 int hashcode
= hashf (symname
, sym_length
, ASSERTION_HASHSIZE
);
6966 struct tokenlist_list
*tail
, *prev
;
6968 hp
= assertion_lookup (pfile
, symname
, sym_length
, hashcode
);
6972 /* If no token list was specified, then eliminate this assertion
6974 if (! tokens_specified
)
6975 delete_assertion (hp
);
6977 /* If a list of tokens was given, then delete any matching list. */
6982 struct tokenlist_list
*next
= tail
->next
;
6983 if (compare_token_lists (tail
->tokens
, tokens
)) {
6987 hp
->value
= tail
->next
;
6988 free_token_list (tail
->tokens
);
6998 CPP_SET_WRITTEN (pfile
, symstart
); /* Pop */
7001 CPP_SET_WRITTEN (pfile
, symstart
); /* Pop */
7002 skip_rest_of_line (pfile
);
7006 /* Test whether there is an assertion named NAME
7007 and optionally whether it has an asserted token list TOKENS.
7008 NAME is not null terminated; its length is SYM_LENGTH.
7009 If TOKENS_SPECIFIED is 0, then don't check for any token list. */
7012 check_assertion (pfile
, name
, sym_length
, tokens_specified
, tokens
)
7016 int tokens_specified
;
7017 struct arglist
*tokens
;
7019 ASSERTION_HASHNODE
*hp
;
7020 int hashcode
= hashf (name
, sym_length
, ASSERTION_HASHSIZE
);
7022 if (CPP_PEDANTIC (pfile
) && !CPP_BUFFER (pfile
)->system_header_p
)
7023 cpp_pedwarn (pfile
, "ANSI C does not allow testing assertions");
7025 hp
= assertion_lookup (pfile
, name
, sym_length
, hashcode
);
7027 /* It is not an assertion; just return false. */
7030 /* If no token list was specified, then value is 1. */
7031 if (! tokens_specified
)
7035 struct tokenlist_list
*tail
;
7039 /* If a list of tokens was given,
7040 then succeed if the assertion records a matching list. */
7043 if (compare_token_lists (tail
->tokens
, tokens
))
7048 /* Fail if the assertion has no matching list. */
7053 /* Compare two lists of tokens for equality including order of tokens. */
7056 compare_token_lists (l1
, l2
)
7057 struct arglist
*l1
, *l2
;
7060 if (l1
->length
!= l2
->length
)
7062 if (strncmp (l1
->name
, l2
->name
, l1
->length
))
7068 /* Succeed if both lists end at the same time. */
7073 reverse_token_list (tokens
)
7074 struct arglist
*tokens
;
7076 register struct arglist
*prev
= 0, *this, *next
;
7077 for (this = tokens
; this; this = next
)
7086 /* Read a space-separated list of tokens ending in a close parenthesis.
7087 Return a list of strings, in the order they were written.
7088 (In case of error, return 0 and store -1 in *ERROR_FLAG.) */
7090 static struct arglist
*
7091 read_token_list (pfile
, error_flag
)
7095 struct arglist
*token_ptrs
= 0;
7100 FORWARD (1); /* Skip '(' */
7102 /* Loop over the assertion value tokens. */
7105 struct arglist
*temp
;
7106 long name_written
= CPP_WRITTEN (pfile
);
7107 int eofp
= 0; int c
;
7109 cpp_skip_hspace (pfile
);
7113 /* Find the end of the token. */
7116 CPP_PUTC (pfile
, c
);
7124 CPP_PUTC (pfile
, c
);
7126 else if (c
== '"' || c
== '\'')
7129 cpp_get_token (pfile
);
7135 while (c
!= EOF
&& ! is_space
[c
] && c
!= '(' && c
!= ')'
7136 && c
!= '"' && c
!= '\'')
7138 CPP_PUTC (pfile
, c
);
7141 if (c
!= EOF
) FORWARD(-1);
7144 length
= CPP_WRITTEN (pfile
) - name_written
;
7145 temp
= (struct arglist
*)
7146 xmalloc (sizeof (struct arglist
) + length
+ 1);
7147 temp
->name
= (U_CHAR
*) (temp
+ 1);
7148 bcopy ((char *) (pfile
->token_buffer
+ name_written
),
7149 (char *) temp
->name
, length
);
7150 temp
->name
[length
] = 0;
7151 temp
->next
= token_ptrs
;
7153 temp
->length
= length
;
7155 CPP_ADJUST_WRITTEN (pfile
, -length
); /* pop */
7157 if (c
== EOF
|| c
== '\n')
7160 "unterminated token sequence following `#' operator");
7165 /* We accumulated the names in reverse order.
7166 Now reverse them to get the proper order. */
7167 return reverse_token_list (token_ptrs
);
7171 free_token_list (tokens
)
7172 struct arglist
*tokens
;
7175 struct arglist
*next
= tokens
->next
;
7176 free (tokens
->name
);
7182 /* Get the file-mode and data size of the file open on FD
7183 and store them in *MODE_POINTER and *SIZE_POINTER. */
7186 file_size_and_mode (fd
, mode_pointer
, size_pointer
)
7189 long int *size_pointer
;
7193 if (fstat (fd
, &sbuf
) < 0) return (-1);
7194 if (mode_pointer
) *mode_pointer
= sbuf
.st_mode
;
7195 if (size_pointer
) *size_pointer
= sbuf
.st_size
;
7199 /* Read LEN bytes at PTR from descriptor DESC, for file FILENAME,
7200 retrying if necessary. If MAX_READ_LEN is defined, read at most
7201 that bytes at a time. Return a negative value if an error occurs,
7202 otherwise return the actual number of bytes read,
7203 which must be LEN unless end-of-file was reached. */
7206 safe_read (desc
, ptr
, len
)
7211 int left
, rcount
, nchars
;
7217 if (rcount
> MAX_READ_LEN
)
7218 rcount
= MAX_READ_LEN
;
7220 nchars
= read (desc
, ptr
, rcount
);
7238 xcalloc (number
, size
)
7239 unsigned number
, size
;
7241 register unsigned total
= number
* size
;
7242 register char *ptr
= (char *) xmalloc (total
);
7251 unsigned size
= strlen (input
);
7252 char *output
= xmalloc (size
+ 1);
7253 strcpy (output
, input
);
7257 /* Initialize PMARK to remember the current position of PFILE. */
7260 parse_set_mark (pmark
, pfile
)
7261 struct parse_marker
*pmark
;
7264 cpp_buffer
*pbuf
= CPP_BUFFER (pfile
);
7265 pmark
->next
= pbuf
->marks
;
7266 pbuf
->marks
= pmark
;
7268 pmark
->position
= pbuf
->cur
- pbuf
->buf
;
7271 /* Cleanup PMARK - we no longer need it. */
7274 parse_clear_mark (pmark
)
7275 struct parse_marker
*pmark
;
7277 struct parse_marker
**pp
= &pmark
->buf
->marks
;
7278 for (; ; pp
= &(*pp
)->next
) {
7279 if (*pp
== NULL
) abort ();
7280 if (*pp
== pmark
) break;
7285 /* Backup the current position of PFILE to that saved in PMARK. */
7288 parse_goto_mark (pmark
, pfile
)
7289 struct parse_marker
*pmark
;
7292 cpp_buffer
*pbuf
= CPP_BUFFER (pfile
);
7293 if (pbuf
!= pmark
->buf
)
7294 cpp_fatal (pfile
, "internal error %s", "parse_goto_mark");
7295 pbuf
->cur
= pbuf
->buf
+ pmark
->position
;
7298 /* Reset PMARK to point to the current position of PFILE. (Same
7299 as parse_clear_mark (PMARK), parse_set_mark (PMARK, PFILE) but faster. */
7302 parse_move_mark (pmark
, pfile
)
7303 struct parse_marker
*pmark
;
7306 cpp_buffer
*pbuf
= CPP_BUFFER (pfile
);
7307 if (pbuf
!= pmark
->buf
)
7308 cpp_fatal (pfile
, "internal error %s", "parse_move_mark");
7309 pmark
->position
= pbuf
->cur
- pbuf
->buf
;
7313 cpp_read_check_assertion (pfile
)
7316 int name_start
= CPP_WRITTEN (pfile
);
7317 int name_length
, name_written
;
7319 FORWARD (1); /* Skip '#' */
7320 cpp_skip_hspace (pfile
);
7321 parse_name (pfile
, GETC ());
7322 name_written
= CPP_WRITTEN (pfile
);
7323 name_length
= name_written
- name_start
;
7324 cpp_skip_hspace (pfile
);
7325 if (CPP_BUF_PEEK (CPP_BUFFER (pfile
)) == '(')
7328 struct arglist
*token_ptrs
= read_token_list (pfile
, &error_flag
);
7329 result
= check_assertion (pfile
,
7330 pfile
->token_buffer
+ name_start
, name_length
,
7334 result
= check_assertion (pfile
,
7335 pfile
->token_buffer
+ name_start
, name_length
,
7337 CPP_ADJUST_WRITTEN (pfile
, - name_length
); /* pop */
7342 cpp_print_file_and_line (pfile
)
7345 cpp_buffer
*ip
= cpp_file_buffer (pfile
);
7350 cpp_buf_line_and_col (ip
, &line
, &col
);
7351 cpp_file_line_for_message (pfile
, ip
->nominal_fname
,
7352 line
, pfile
->show_column
? col
: -1);
7357 cpp_error (pfile
, msg
, arg1
, arg2
, arg3
)
7360 char *arg1
, *arg2
, *arg3
;
7362 cpp_print_containing_files (pfile
);
7363 cpp_print_file_and_line (pfile
);
7364 cpp_message (pfile
, 1, msg
, arg1
, arg2
, arg3
);
7367 /* Print error message but don't count it. */
7370 cpp_warning (pfile
, msg
, arg1
, arg2
, arg3
)
7373 char *arg1
, *arg2
, *arg3
;
7375 if (CPP_OPTIONS (pfile
)->inhibit_warnings
)
7378 if (CPP_OPTIONS (pfile
)->warnings_are_errors
)
7381 cpp_print_containing_files (pfile
);
7382 cpp_print_file_and_line (pfile
);
7383 cpp_message (pfile
, 0, msg
, arg1
, arg2
, arg3
);
7386 /* Print an error message and maybe count it. */
7389 cpp_pedwarn (pfile
, msg
, arg1
, arg2
, arg3
)
7392 char *arg1
, *arg2
, *arg3
;
7394 if (CPP_OPTIONS (pfile
)->pedantic_errors
)
7395 cpp_error (pfile
, msg
, arg1
, arg2
, arg3
);
7397 cpp_warning (pfile
, msg
, arg1
, arg2
, arg3
);
7401 cpp_error_with_line (pfile
, line
, column
, msg
, arg1
, arg2
, arg3
)
7405 char *arg1
, *arg2
, *arg3
;
7408 cpp_buffer
*ip
= cpp_file_buffer (pfile
);
7410 cpp_print_containing_files (pfile
);
7413 cpp_file_line_for_message (pfile
, ip
->nominal_fname
, line
, column
);
7415 cpp_message (pfile
, 1, msg
, arg1
, arg2
, arg3
);
7419 cpp_warning_with_line (pfile
, line
, column
, msg
, arg1
, arg2
, arg3
)
7423 char *arg1
, *arg2
, *arg3
;
7428 if (CPP_OPTIONS (pfile
)->inhibit_warnings
)
7431 if (CPP_OPTIONS (pfile
)->warnings_are_errors
)
7434 cpp_print_containing_files (pfile
);
7436 ip
= cpp_file_buffer (pfile
);
7439 cpp_file_line_for_message (pfile
, ip
->nominal_fname
, line
, column
);
7441 cpp_message (pfile
, 0, msg
, arg1
, arg2
, arg3
);
7445 cpp_pedwarn_with_line (pfile
, line
, column
, msg
, arg1
, arg2
, arg3
)
7449 char *arg1
, *arg2
, *arg3
;
7451 if (CPP_OPTIONS (pfile
)->pedantic_errors
)
7452 cpp_error_with_line (pfile
, column
, line
, msg
, arg1
, arg2
, arg3
);
7454 cpp_warning_with_line (pfile
, line
, column
, msg
, arg1
, arg2
, arg3
);
7457 /* Report a warning (or an error if pedantic_errors)
7458 giving specified file name and line number, not current. */
7461 cpp_pedwarn_with_file_and_line (pfile
, file
, line
, msg
, arg1
, arg2
, arg3
)
7466 char *arg1
, *arg2
, *arg3
;
7468 if (!CPP_OPTIONS (pfile
)->pedantic_errors
7469 && CPP_OPTIONS (pfile
)->inhibit_warnings
)
7472 cpp_file_line_for_message (pfile
, file
, line
, -1);
7473 cpp_message (pfile
, CPP_OPTIONS (pfile
)->pedantic_errors
,
7474 msg
, arg1
, arg2
, arg3
);
7477 /* This defines "errno" properly for VMS, and gives us EACCES. */
7484 #ifndef HAVE_STRERROR
7485 extern int sys_nerr
;
7487 extern const char *const sys_errlist
[];
7489 extern char *sys_errlist
[];
7491 #else /* HAVE_STRERROR */
7495 char *strerror (int,...);
7498 /* my_strerror - return the descriptive text associated with an
7502 my_strerror (errnum
)
7508 #ifndef HAVE_STRERROR
7509 result
= (char *) ((errnum
< sys_nerr
) ? sys_errlist
[errnum
] : 0);
7511 result
= strerror (errnum
);
7514 /* VAXCRTL's strerror() takes an optional second argument, which only
7515 matters when the first argument is EVMSERR. However, it's simplest
7516 just to pass it unconditionally. `vaxc$errno' is declared in
7517 <errno.h>, and maintained by the library in parallel with `errno'.
7518 We assume that caller's `errnum' either matches the last setting of
7519 `errno' by the library or else does not have the value `EVMSERR'. */
7521 result
= strerror (errnum
, vaxc$errno
);
7525 result
= "undocumented I/O error";
7530 /* Error including a message from `errno'. */
7533 cpp_error_from_errno (pfile
, name
)
7538 cpp_buffer
*ip
= cpp_file_buffer (pfile
);
7540 cpp_print_containing_files (pfile
);
7543 cpp_file_line_for_message (pfile
, ip
->nominal_fname
, ip
->lineno
, -1);
7545 cpp_message (pfile
, 1, "%s: %s", name
, my_strerror (errno
));
7549 cpp_perror_with_name (pfile
, name
)
7553 cpp_message (pfile
, 1, "%s: %s: %s", progname
, name
, my_strerror (errno
));
7557 * No pre-compiled header file support.
7559 * Possibly different enum token codes for each C/C++ token.
7561 * Should clean up remaining directives to that do_XXX functions
7562 * only take two arguments and all have command_reads_line.
7564 * Find and cleanup remaining uses of static variables,
7566 * Support for trigraphs.
7568 * Support -dM flag (dump_all_macros).
7570 * Support for_lint flag.