639 lines
23 KiB
C
639 lines
23 KiB
C
|
|
/* Definitions for CPP library.
|
|
Copyright (C) 1995 Free Software Foundation, Inc.
|
|
Written by Per Bothner, 1994-95.
|
|
|
|
This program is free software; you can redistribute it and/or modify it
|
|
under the terms of the GNU General Public License as published by the
|
|
Free Software Foundation; either version 2, or (at your option) any
|
|
later version.
|
|
|
|
This program is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
GNU General Public License for more details.
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
along with this program; if not, write to the Free Software
|
|
Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
|
|
|
|
In other words, you are welcome to use, share and improve this program.
|
|
You are forbidden to forbid anyone else to use, share and improve
|
|
what you give them. Help stamp out software-hoarding! */
|
|
|
|
#include <stdarg.h>
|
|
#include <sys/types.h>
|
|
#include <sys/stat.h>
|
|
|
|
#ifndef HOST_BITS_PER_WIDE_INT
|
|
|
|
#if HOST_BITS_PER_LONG > HOST_BITS_PER_INT
|
|
#define HOST_BITS_PER_WIDE_INT HOST_BITS_PER_LONG
|
|
#define HOST_WIDE_INT long
|
|
#else
|
|
#define HOST_BITS_PER_WIDE_INT HOST_BITS_PER_INT
|
|
#define HOST_WIDE_INT int
|
|
#endif
|
|
|
|
#endif
|
|
|
|
#define STATIC_BUFFERS
|
|
|
|
typedef struct cpp_reader cpp_reader;
|
|
typedef struct cpp_buffer cpp_buffer;
|
|
typedef struct cpp_options cpp_options;
|
|
|
|
enum cpp_token {
|
|
CPP_EOF = -1,
|
|
CPP_OTHER = 0,
|
|
CPP_COMMENT = 1,
|
|
CPP_HSPACE,
|
|
CPP_VSPACE, /* newlines and #line directives */
|
|
CPP_NAME,
|
|
CPP_NUMBER,
|
|
CPP_CHAR,
|
|
CPP_STRING,
|
|
CPP_DIRECTIVE,
|
|
CPP_LPAREN, /* "(" */
|
|
CPP_RPAREN, /* ")" */
|
|
CPP_LBRACE, /* "{" */
|
|
CPP_RBRACE, /* "}" */
|
|
CPP_COMMA, /* "," */
|
|
CPP_SEMICOLON, /* ";" */
|
|
CPP_3DOTS, /* "..." */
|
|
/* POP_TOKEN is returned when we've popped a cpp_buffer. */
|
|
CPP_POP
|
|
};
|
|
|
|
typedef enum cpp_token (*parse_underflow_t) (cpp_reader *);
|
|
typedef int (*parse_cleanup_t) (cpp_buffer *, cpp_reader *);
|
|
|
|
/* A parse_marker indicates a previous position,
|
|
which we can backtrack to. */
|
|
|
|
struct parse_marker {
|
|
cpp_buffer *buf;
|
|
struct parse_marker *next;
|
|
int position;
|
|
};
|
|
|
|
extern int cpp_handle_options(cpp_reader * pfile, int, char **);
|
|
extern enum cpp_token cpp_get_token(cpp_reader * pfile);
|
|
extern void cpp_skip_hspace(cpp_reader * pfile);
|
|
|
|
/* Maintain and search list of included files, for #import. */
|
|
|
|
#define IMPORT_HASH_SIZE 31
|
|
|
|
struct import_file {
|
|
char *name;
|
|
ino_t inode;
|
|
dev_t dev;
|
|
struct import_file *next;
|
|
};
|
|
|
|
/* If we have a huge buffer, may need to cache more recent counts */
|
|
#define CPP_LINE_BASE(BUF) ((BUF)->buf + (BUF)->line_base)
|
|
|
|
enum dump_type {
|
|
dump_none = 0, dump_only, dump_names, dump_definitions
|
|
};
|
|
|
|
struct cpp_buffer {
|
|
unsigned char *buf;
|
|
unsigned char *cur;
|
|
unsigned char *rlimit; /* end of valid data */
|
|
unsigned char *alimit; /* end of allocated buffer */
|
|
unsigned char *prev; /* start of current token */
|
|
|
|
const char *fname;
|
|
/* Filename specified with #line command. */
|
|
const char *nominal_fname;
|
|
|
|
/* Record where in the search path this file was found.
|
|
* For #include_next. */
|
|
struct file_name_list *dir;
|
|
|
|
long line_base;
|
|
long lineno; /* Line number at CPP_LINE_BASE. */
|
|
long colno; /* Column number at CPP_LINE_BASE. */
|
|
#ifndef STATIC_BUFFERS
|
|
cpp_buffer *chain;
|
|
#endif
|
|
parse_underflow_t underflow;
|
|
parse_cleanup_t cleanup;
|
|
void *data;
|
|
struct parse_marker *marks;
|
|
/* Value of if_stack at start of this file.
|
|
* Used to prohibit unmatched #endif (etc) in an include file. */
|
|
struct if_stack *if_stack;
|
|
|
|
/* True if this is a header file included using <FILENAME>. */
|
|
char system_header_p;
|
|
char seen_eof;
|
|
|
|
/* True if buffer contains escape sequences.
|
|
* Currently there are are only two kind:
|
|
* "@-" means following identifier should not be macro-expanded.
|
|
* "@ " means a token-separator. This turns into " " in final output
|
|
* if not stringizing and needed to separate tokens; otherwise nothing.
|
|
* "@@" means a normal '@'.
|
|
* (An '@' inside a string stands for itself and is never an escape.) */
|
|
char has_escapes;
|
|
};
|
|
|
|
struct cpp_pending; /* Forward declaration - for C++. */
|
|
struct file_name_map_list;
|
|
|
|
typedef struct assertion_hashnode ASSERTION_HASHNODE;
|
|
|
|
#define ASSERTION_HASHSIZE 37
|
|
|
|
#ifdef STATIC_BUFFERS
|
|
/* Maximum nesting of cpp_buffers. We use a static limit, partly for
|
|
efficiency, and partly to limit runaway recursion. */
|
|
#define CPP_STACK_MAX 200
|
|
#endif
|
|
|
|
struct cpp_reader {
|
|
unsigned char *limit;
|
|
parse_underflow_t get_token;
|
|
cpp_buffer *buffer;
|
|
#ifdef STATIC_BUFFERS
|
|
cpp_buffer buffer_stack[CPP_STACK_MAX];
|
|
#endif
|
|
|
|
int errors; /* Error counter for exit code */
|
|
void *data;
|
|
|
|
unsigned char *token_buffer;
|
|
int token_buffer_size;
|
|
|
|
/* Line where a newline was first seen in a string constant. */
|
|
int multiline_string_line;
|
|
|
|
/* Current depth in #include directives that use <...>. */
|
|
int system_include_depth;
|
|
|
|
/* List of included files that contained #pragma once. */
|
|
struct file_name_list *dont_repeat_files;
|
|
|
|
/* List of other included files.
|
|
* If ->control_macro if nonzero, the file had a #ifndef
|
|
* around the entire contents, and ->control_macro gives the macro name. */
|
|
struct file_name_list *all_include_files;
|
|
|
|
/* Current maximum length of directory names in the search path
|
|
* for include files. (Altered as we get more of them.) */
|
|
int max_include_len;
|
|
|
|
/* Hash table of files already included with #include or #import. */
|
|
struct import_file *import_hash_table[IMPORT_HASH_SIZE];
|
|
|
|
struct if_stack *if_stack;
|
|
|
|
/* Nonzero means we are inside an IF during a -pcp run. In this mode
|
|
* macro expansion is done, and preconditions are output for all macro
|
|
* uses requiring them. */
|
|
char pcp_inside_if;
|
|
|
|
/* Nonzero means we have printed (while error reporting) a list of
|
|
* containing files that matches the current status. */
|
|
char input_stack_listing_current;
|
|
|
|
/* If non-zero, macros are not expanded. */
|
|
char no_macro_expand;
|
|
|
|
/* Print column number in error messages. */
|
|
char show_column;
|
|
|
|
/* We're printed a warning recommending against using #import. */
|
|
char import_warning;
|
|
|
|
/* If true, character between '<' and '>' are a single (string) token. */
|
|
char parsing_include_directive;
|
|
|
|
/* True if escape sequences (as described for has_escapes in
|
|
* parse_buffer) should be emitted. */
|
|
char output_escapes;
|
|
|
|
/* 0: Have seen non-white-space on this line.
|
|
* 1: Only seen white space so far on this line.
|
|
* 2: Only seen white space so far in this file. */
|
|
char only_seen_white;
|
|
|
|
/* Nonzero means this file was included with a -imacros or -include
|
|
* command line and should not be recorded as an include file. */
|
|
|
|
int no_record_file;
|
|
|
|
long lineno;
|
|
|
|
struct tm *timebuf;
|
|
|
|
ASSERTION_HASHNODE *assertion_hashtab[ASSERTION_HASHSIZE];
|
|
|
|
/* Buffer of -M output. */
|
|
char *deps_buffer;
|
|
|
|
/* Number of bytes allocated in above. */
|
|
int deps_allocated_size;
|
|
|
|
/* Number of bytes used. */
|
|
int deps_size;
|
|
|
|
/* Number of bytes since the last newline. */
|
|
int deps_column;
|
|
};
|
|
|
|
#define CPP_BUF_PEEK(BUFFER) \
|
|
((BUFFER)->cur < (BUFFER)->rlimit ? *(BUFFER)->cur : EOF)
|
|
#define CPP_BUF_GET(BUFFER) \
|
|
((BUFFER)->cur < (BUFFER)->rlimit ? *(BUFFER)->cur++ : EOF)
|
|
#define CPP_FORWARD(BUFFER, N) ((BUFFER)->cur += (N))
|
|
|
|
/* Number of characters currently in PFILE's output buffer. */
|
|
#define CPP_WRITTEN(PFILE) ((PFILE)->limit - (PFILE)->token_buffer)
|
|
#define CPP_PWRITTEN(PFILE) ((PFILE)->limit)
|
|
|
|
/* Make sure PFILE->token_buffer has space for at least N more characters. */
|
|
#define CPP_RESERVE(PFILE, N) \
|
|
((unsigned int)(CPP_WRITTEN (PFILE) + N) > (unsigned int) (PFILE)->token_buffer_size \
|
|
&& (cpp_grow_buffer (PFILE, N), 0))
|
|
|
|
/* Append string STR (of length N) to PFILE's output buffer.
|
|
Assume there is enough space. */
|
|
#define CPP_PUTS_Q(PFILE, STR, N) \
|
|
(memcpy ((PFILE)->limit, STR, (N)), (PFILE)->limit += (N))
|
|
/* Append string STR (of length N) to PFILE's output buffer. Make space. */
|
|
#define CPP_PUTS(PFILE, STR, N) CPP_RESERVE(PFILE, N), CPP_PUTS_Q(PFILE, STR,N)
|
|
/* Append character CH to PFILE's output buffer. Assume sufficient space. */
|
|
#define CPP_PUTC_Q(PFILE, CH) (*(PFILE)->limit++ = (CH))
|
|
/* Append character CH to PFILE's output buffer. Make space if need be. */
|
|
#define CPP_PUTC(PFILE, CH) (CPP_RESERVE (PFILE, 1), CPP_PUTC_Q (PFILE, CH))
|
|
/* Make sure PFILE->limit is followed by '\0'. */
|
|
#define CPP_NUL_TERMINATE_Q(PFILE) (*(PFILE)->limit = 0)
|
|
#define CPP_NUL_TERMINATE(PFILE) (CPP_RESERVE(PFILE, 1), *(PFILE)->limit = 0)
|
|
#define CPP_ADJUST_WRITTEN(PFILE,DELTA) ((PFILE)->limit += (DELTA))
|
|
#define CPP_SET_WRITTEN(PFILE,N) ((PFILE)->limit = (PFILE)->token_buffer + (N))
|
|
|
|
#define CPP_OPTIONS(PFILE) ((cpp_options*)(PFILE)->data)
|
|
#define CPP_BUFFER(PFILE) ((PFILE)->buffer)
|
|
#ifdef STATIC_BUFFERS
|
|
#define CPP_PREV_BUFFER(BUFFER) ((BUFFER)+1)
|
|
#define CPP_NULL_BUFFER(PFILE) (&(PFILE)->buffer_stack[CPP_STACK_MAX])
|
|
#else
|
|
#define CPP_PREV_BUFFER(BUFFER) ((BUFFER)->chain)
|
|
#define CPP_NULL_BUFFER(PFILE) ((cpp_buffer*)0)
|
|
#endif
|
|
|
|
/* Pointed to by parse_file::data. */
|
|
struct cpp_options {
|
|
const char *in_fname;
|
|
|
|
/* Name of output file, for error messages. */
|
|
const char *out_fname;
|
|
|
|
struct file_name_map_list *map_list;
|
|
|
|
/* Non-0 means -v, so print the full set of include dirs. */
|
|
char verbose;
|
|
|
|
/* Nonzero means use extra default include directories for C++. */
|
|
|
|
char cplusplus;
|
|
|
|
/* Nonzero means handle cplusplus style comments */
|
|
|
|
char cplusplus_comments;
|
|
|
|
/* Nonzero means handle #import, for objective C. */
|
|
|
|
char objc;
|
|
|
|
/* Nonzero means this is an assembly file, and allow
|
|
* unknown directives, which could be comments. */
|
|
|
|
int lang_asm;
|
|
|
|
/* Nonzero means turn NOTREACHED into #pragma NOTREACHED etc */
|
|
|
|
char for_lint;
|
|
|
|
/* Nonzero means handle CHILL comment syntax
|
|
* and output CHILL string delimiter for __DATE___ etc. */
|
|
|
|
char chill;
|
|
|
|
/* Nonzero means copy comments into the output file. */
|
|
|
|
char put_out_comments;
|
|
|
|
/* Nonzero means don't process the ANSI trigraph sequences. */
|
|
|
|
char no_trigraphs;
|
|
|
|
/* Nonzero means print the names of included files rather than
|
|
* the preprocessed output. 1 means just the #include "...",
|
|
* 2 means #include <...> as well. */
|
|
|
|
char print_deps;
|
|
|
|
/* Nonzero if missing .h files in -M output are assumed to be generated
|
|
* files and not errors. */
|
|
|
|
char print_deps_missing_files;
|
|
|
|
/* If true, fopen (deps_file, "a") else fopen (deps_file, "w"). */
|
|
char print_deps_append;
|
|
|
|
/* Nonzero means print names of header files (-H). */
|
|
|
|
char print_include_names;
|
|
|
|
/* Nonzero means try to make failure to fit ANSI C an error. */
|
|
|
|
char pedantic_errors;
|
|
|
|
/* Nonzero means don't print warning messages. -w. */
|
|
|
|
char inhibit_warnings;
|
|
|
|
/* Nonzero means warn if slash-star appears in a comment. */
|
|
|
|
char warn_comments;
|
|
|
|
/* Nonzero means warn if there are any trigraphs. */
|
|
|
|
char warn_trigraphs;
|
|
|
|
/* Nonzero means warn if #import is used. */
|
|
|
|
char warn_import;
|
|
|
|
/* Nonzero means warn if a macro argument is (or would be)
|
|
* stringified with -traditional. */
|
|
|
|
char warn_stringify;
|
|
|
|
/* Nonzero means turn warnings into errors. */
|
|
|
|
char warnings_are_errors;
|
|
|
|
/* Nonzero causes output not to be done,
|
|
* but directives such as #define that have side effects
|
|
* are still obeyed. */
|
|
|
|
char no_output;
|
|
|
|
/* Nonzero means don't output line number information. */
|
|
|
|
char no_line_commands;
|
|
|
|
/* Nonzero means output the text in failing conditionals,
|
|
inside #failed ... #endfailed. */
|
|
|
|
char output_conditionals;
|
|
|
|
/* Nonzero means -I- has been seen,
|
|
* so don't look for #include "foo" the source-file directory. */
|
|
char ignore_srcdir;
|
|
|
|
/* Zero means dollar signs are punctuation.
|
|
-$ stores 0; -traditional may store 1. Default is 1 for VMS, 0 otherwise.
|
|
This must be 0 for correct processing of this ANSI C program:
|
|
#define foo(a) #a
|
|
#define lose(b) foo (b)
|
|
#define test$
|
|
lose (test) */
|
|
char dollars_in_ident;
|
|
#ifndef DOLLARS_IN_IDENTIFIERS
|
|
#define DOLLARS_IN_IDENTIFIERS 1
|
|
#endif
|
|
|
|
/* Nonzero means try to imitate old fashioned non-ANSI preprocessor. */
|
|
char traditional;
|
|
|
|
/* Nonzero means give all the error messages the ANSI standard requires. */
|
|
char pedantic;
|
|
|
|
char done_initializing;
|
|
|
|
struct file_name_list *include; /* First dir to search */
|
|
/* First dir to search for <file> */
|
|
/* This is the first element to use for #include <...>.
|
|
* If it is 0, use the entire chain for such includes. */
|
|
struct file_name_list *first_bracket_include;
|
|
/* This is the first element in the chain that corresponds to
|
|
* a directory of system header files. */
|
|
struct file_name_list *first_system_include;
|
|
struct file_name_list *last_include; /* Last in chain */
|
|
|
|
/* Chain of include directories to put at the end of the other chain. */
|
|
struct file_name_list *after_include;
|
|
struct file_name_list *last_after_include; /* Last in chain */
|
|
|
|
/* Chain to put at the start of the system include files. */
|
|
struct file_name_list *before_system;
|
|
struct file_name_list *last_before_system; /* Last in chain */
|
|
|
|
/* Directory prefix that should replace `/usr' in the standard
|
|
* include file directories. */
|
|
char *include_prefix;
|
|
|
|
char inhibit_predefs;
|
|
char no_standard_includes;
|
|
char no_standard_cplusplus_includes;
|
|
|
|
/* dump_only means inhibit output of the preprocessed text
|
|
and instead output the definitions of all user-defined
|
|
macros in a form suitable for use as input to cccp.
|
|
dump_names means pass #define and the macro name through to output.
|
|
dump_definitions means pass the whole definition (plus #define) through
|
|
*/
|
|
|
|
enum dump_type dump_macros;
|
|
|
|
/* Nonzero means pass all #define and #undef directives which we actually
|
|
process through to the output stream. This feature is used primarily
|
|
to allow cc1 to record the #defines and #undefs for the sake of
|
|
debuggers which understand about preprocessor macros, but it may
|
|
also be useful with -E to figure out how symbols are defined, and
|
|
where they are defined. */
|
|
int debug_output;
|
|
|
|
/* Pending -D, -U and -A options, in reverse order. */
|
|
struct cpp_pending *pending;
|
|
|
|
/* File name which deps are being written to.
|
|
* This is 0 if deps are being written to stdout. */
|
|
char *deps_file;
|
|
|
|
/* Target-name to write with the dependency information. */
|
|
char *deps_target;
|
|
};
|
|
|
|
#define CPP_TRADITIONAL(PFILE) (CPP_OPTIONS(PFILE)-> traditional)
|
|
#define CPP_PEDANTIC(PFILE) (CPP_OPTIONS (PFILE)->pedantic)
|
|
#define CPP_PRINT_DEPS(PFILE) (CPP_OPTIONS (PFILE)->print_deps)
|
|
|
|
/* Name under which this program was invoked. */
|
|
|
|
extern char *progname;
|
|
|
|
/* The structure of a node in the hash table. The hash table
|
|
has entries for all tokens defined by #define commands (type T_MACRO),
|
|
plus some special tokens like __LINE__ (these each have their own
|
|
type, and the appropriate code is run when that type of node is seen.
|
|
It does not contain control words like "#define", which are recognized
|
|
by a separate piece of code. */
|
|
|
|
/* different flavors of hash nodes --- also used in keyword table */
|
|
enum node_type {
|
|
T_DEFINE = 1, /* the `#define' keyword */
|
|
T_INCLUDE, /* the `#include' keyword */
|
|
T_INCLUDE_NEXT, /* the `#include_next' keyword */
|
|
T_IMPORT, /* the `#import' keyword */
|
|
T_IFDEF, /* the `#ifdef' keyword */
|
|
T_IFNDEF, /* the `#ifndef' keyword */
|
|
T_IF, /* the `#if' keyword */
|
|
T_ELSE, /* `#else' */
|
|
T_PRAGMA, /* `#pragma' */
|
|
T_ELIF, /* `#elif' */
|
|
T_UNDEF, /* `#undef' */
|
|
T_LINE, /* `#line' */
|
|
T_ERROR, /* `#error' */
|
|
T_WARNING, /* `#warning' */
|
|
T_ENDIF, /* `#endif' */
|
|
T_SCCS, /* `#sccs', used on system V. */
|
|
T_IDENT, /* `#ident', used on system V. */
|
|
T_ASSERT, /* `#assert', taken from system V. */
|
|
T_UNASSERT, /* `#unassert', taken from system V. */
|
|
T_SPECLINE, /* special symbol `__LINE__' */
|
|
T_DATE, /* `__DATE__' */
|
|
T_FILE, /* `__FILE__' */
|
|
T_BASE_FILE, /* `__BASE_FILE__' */
|
|
T_INCLUDE_LEVEL, /* `__INCLUDE_LEVEL__' */
|
|
T_VERSION, /* `__VERSION__' */
|
|
T_SIZE_TYPE, /* `__SIZE_TYPE__' */
|
|
T_PTRDIFF_TYPE, /* `__PTRDIFF_TYPE__' */
|
|
T_WCHAR_TYPE, /* `__WCHAR_TYPE__' */
|
|
T_USER_LABEL_PREFIX_TYPE, /* `__USER_LABEL_PREFIX__' */
|
|
T_REGISTER_PREFIX_TYPE, /* `__REGISTER_PREFIX__' */
|
|
T_TIME, /* `__TIME__' */
|
|
T_CONST, /* Constant value, used by `__STDC__' */
|
|
T_MACRO, /* macro defined by `#define' */
|
|
T_DISABLED, /* macro temporarily turned off for rescan */
|
|
T_SPEC_DEFINED, /* special `defined' macro for use in #if statements */
|
|
T_PCSTRING, /* precompiled string (hashval is KEYDEF *) */
|
|
T_UNUSED /* Used for something not defined. */
|
|
};
|
|
|
|
/* Structure allocated for every #define. For a simple replacement
|
|
such as
|
|
#define foo bar ,
|
|
nargs = -1, the `pattern' list is null, and the expansion is just
|
|
the replacement text. Nargs = 0 means a functionlike macro with no args,
|
|
e.g.,
|
|
#define getchar() getc (stdin) .
|
|
When there are args, the expansion is the replacement text with the
|
|
args squashed out, and the reflist is a list describing how to
|
|
build the output from the input: e.g., "3 chars, then the 1st arg,
|
|
then 9 chars, then the 3rd arg, then 0 chars, then the 2nd arg".
|
|
The chars here come from the expansion. Whatever is left of the
|
|
expansion after the last arg-occurrence is copied after that arg.
|
|
Note that the reflist can be arbitrarily long---
|
|
its length depends on the number of times the arguments appear in
|
|
the replacement text, not how many args there are. Example:
|
|
#define f(x) x+x+x+x+x+x+x would have replacement text "++++++" and
|
|
pattern list
|
|
{ (0, 1), (1, 1), (1, 1), ..., (1, 1), NULL }
|
|
where (x, y) means (nchars, argno). */
|
|
|
|
struct reflist {
|
|
struct reflist *next;
|
|
char stringify; /* nonzero if this arg was preceded by a
|
|
* # operator. */
|
|
char raw_before; /* Nonzero if a ## operator before arg. */
|
|
char raw_after; /* Nonzero if a ## operator after arg. */
|
|
char rest_args; /* Nonzero if this arg. absorbs the rest */
|
|
int nchars; /* Number of literal chars to copy before
|
|
* this arg occurrence. */
|
|
int argno; /* Number of arg to substitute (origin-0) */
|
|
};
|
|
|
|
typedef struct definition DEFINITION;
|
|
struct definition {
|
|
int nargs;
|
|
int length; /* length of expansion string */
|
|
int predefined; /* True if the macro was builtin or */
|
|
/* came from the command line */
|
|
unsigned char *expansion;
|
|
int line; /* Line number of definition */
|
|
const char *file; /* File of definition */
|
|
char rest_args; /* Nonzero if last arg. absorbs the rest */
|
|
struct reflist *pattern;
|
|
union {
|
|
/* Names of macro args, concatenated in reverse order
|
|
* with comma-space between them.
|
|
* The only use of this is that we warn on redefinition
|
|
* if this differs between the old and new definitions. */
|
|
unsigned char *argnames;
|
|
} args;
|
|
};
|
|
|
|
extern unsigned char is_idchar[256];
|
|
|
|
/* Stack of conditionals currently in progress
|
|
(including both successful and failing conditionals). */
|
|
|
|
struct if_stack {
|
|
struct if_stack *next; /* for chaining to the next stack frame */
|
|
const char *fname; /* copied from input when frame is made */
|
|
int lineno; /* similarly */
|
|
int if_succeeded; /* true if a leg of this if-group
|
|
* has been passed through rescan */
|
|
unsigned char *control_macro; /* For #ifndef at start of file,
|
|
* this is the macro name tested. */
|
|
enum node_type type; /* type of last directive seen in this group */
|
|
};
|
|
typedef struct if_stack IF_STACK_FRAME;
|
|
|
|
extern void cpp_buf_line_and_col(cpp_buffer *, long *, long *);
|
|
extern cpp_buffer *cpp_file_buffer(cpp_reader *);
|
|
extern void cpp_define(cpp_reader *, unsigned char *);
|
|
|
|
extern void cpp_error(cpp_reader * pfile, const char *msg, ...);
|
|
extern void cpp_warning(cpp_reader * pfile, const char *msg, ...);
|
|
extern void cpp_pedwarn(cpp_reader * pfile, const char *msg, ...);
|
|
extern void cpp_fatal(const char *msg, ...);
|
|
extern void cpp_file_line_for_message(cpp_reader * pfile,
|
|
const char *filename, int line,
|
|
int column);
|
|
extern void cpp_perror_with_name(cpp_reader * pfile, const char *name);
|
|
extern void cpp_pfatal_with_name(cpp_reader * pfile, const char *name);
|
|
extern void cpp_message(cpp_reader * pfile, int is_error,
|
|
const char *msg, ...);
|
|
extern void cpp_message_v(cpp_reader * pfile, int is_error,
|
|
const char *msg, va_list args);
|
|
|
|
extern void cpp_grow_buffer(cpp_reader * pfile, long n);
|
|
extern int cpp_parse_escape(cpp_reader * pfile, char **string_ptr);
|
|
|
|
void cpp_print_containing_files(cpp_reader * pfile);
|
|
HOST_WIDE_INT cpp_parse_expr(cpp_reader * pfile);
|
|
void skip_rest_of_line(cpp_reader * pfile);
|
|
void init_parse_file(cpp_reader * pfile);
|
|
void init_parse_options(struct cpp_options *opts);
|
|
int push_parse_file(cpp_reader * pfile, const char *fname);
|
|
void cpp_finish(cpp_reader * pfile);
|
|
int cpp_read_check_assertion(cpp_reader * pfile);
|
|
|
|
void *xmalloc(unsigned size);
|
|
void *xrealloc(void *old, unsigned size);
|
|
void *xcalloc(unsigned number, unsigned size);
|
|
|
|
#ifdef __EMX__
|
|
#define PATH_SEPARATOR ';'
|
|
#endif
|