mirror of
https://git.FreeBSD.org/src.git
synced 2024-12-16 10:20:30 +00:00
11144 lines
298 KiB
C
11144 lines
298 KiB
C
/* C Compatible Compiler Preprocessor (CCCP)
|
||
Copyright (C) 1986, 1987, 1989, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
|
||
1999, 2000 Free Software Foundation, Inc.
|
||
Written by Paul Rubin, June 1986
|
||
Adapted to ANSI C, Richard Stallman, Jan 1987
|
||
|
||
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, 59 Temple Place - Suite 330,
|
||
Boston, MA 02111-1307, USA. */
|
||
|
||
/* $FreeBSD$ */
|
||
|
||
|
||
#include "config.h"
|
||
|
||
#include "system.h"
|
||
#include <signal.h>
|
||
|
||
#ifdef HAVE_SYS_RESOURCE_H
|
||
# include <sys/resource.h>
|
||
#endif
|
||
|
||
typedef unsigned char U_CHAR;
|
||
|
||
#include "pcp.h"
|
||
#include "intl.h"
|
||
#include "prefix.h"
|
||
|
||
#ifdef MULTIBYTE_CHARS
|
||
#include "mbchar.h"
|
||
#include <locale.h>
|
||
#endif /* MULTIBYTE_CHARS */
|
||
|
||
#ifndef GET_ENV_PATH_LIST
|
||
#define GET_ENV_PATH_LIST(VAR,NAME) do { (VAR) = getenv (NAME); } while (0)
|
||
#endif
|
||
|
||
#ifndef STANDARD_INCLUDE_DIR
|
||
# define STANDARD_INCLUDE_DIR "/usr/include"
|
||
#endif
|
||
|
||
/* By default, colon separates directories in a path. */
|
||
#ifndef PATH_SEPARATOR
|
||
# define PATH_SEPARATOR ':'
|
||
#endif
|
||
|
||
/* By default, a slash separates directory names. */
|
||
#ifndef DIR_SEPARATOR
|
||
# define DIR_SEPARATOR '/'
|
||
#endif
|
||
|
||
/* By default, the suffix for object files is ".o". */
|
||
#ifdef OBJECT_SUFFIX
|
||
# define HAVE_OBJECT_SUFFIX
|
||
#else
|
||
# define OBJECT_SUFFIX ".o"
|
||
#endif
|
||
|
||
/* VMS-specific definitions */
|
||
#ifdef VMS
|
||
#include <descrip.h>
|
||
#include <ssdef.h>
|
||
#include <syidef.h>
|
||
#define open(fname,mode,prot) VMS_open (fname,mode,prot)
|
||
#define fopen(fname,mode) VMS_fopen (fname,mode)
|
||
#define freopen(fname,mode,ofile) VMS_freopen (fname,mode,ofile)
|
||
#define fstat(fd,stbuf) VMS_fstat (fd,stbuf)
|
||
static int VMS_fstat (), VMS_stat ();
|
||
static int VMS_open ();
|
||
static FILE *VMS_fopen ();
|
||
static FILE *VMS_freopen ();
|
||
static int hack_vms_include_specification ();
|
||
#define INO_T_EQ(a, b) (!bcmp((char *) &(a), (char *) &(b), sizeof (a)))
|
||
#define INO_T_HASH(a) 0
|
||
#define INCLUDE_LEN_FUDGE 12 /* leave room for VMS syntax conversion */
|
||
#endif /* VMS */
|
||
|
||
/* Windows does not natively support inodes, and neither does MSDOS. */
|
||
#if (defined (_WIN32) && ! defined (__CYGWIN__) && ! defined (_UWIN)) \
|
||
|| defined (__MSDOS__)
|
||
#define INO_T_EQ(a, b) 0
|
||
#endif
|
||
|
||
#ifndef INO_T_EQ
|
||
#define INO_T_EQ(a, b) ((a) == (b))
|
||
#endif
|
||
|
||
#ifndef INO_T_HASH
|
||
#define INO_T_HASH(a) (a)
|
||
#endif
|
||
|
||
#ifndef INCLUDE_LEN_FUDGE
|
||
#define INCLUDE_LEN_FUDGE 0
|
||
#endif
|
||
|
||
/* External declarations. */
|
||
|
||
extern char *version_string;
|
||
HOST_WIDEST_INT parse_escape PROTO((char **, HOST_WIDEST_INT));
|
||
HOST_WIDEST_INT parse_c_expression PROTO((char *, int));
|
||
|
||
/* Name under which this program was invoked. */
|
||
|
||
static char *progname;
|
||
|
||
/* Nonzero means use extra default include directories for C++. */
|
||
|
||
static int cplusplus;
|
||
|
||
/* Nonzero means handle cplusplus style comments */
|
||
|
||
static int cplusplus_comments;
|
||
|
||
/* Nonzero means handle #import, for objective C. */
|
||
|
||
static int objc;
|
||
|
||
/* Nonzero means this is an assembly file, and allow
|
||
unknown directives, which could be comments. */
|
||
|
||
static int lang_asm;
|
||
|
||
/* Current maximum length of directory names in the search path
|
||
for include files. (Altered as we get more of them.) */
|
||
|
||
static int max_include_len;
|
||
|
||
/* Nonzero means turn NOTREACHED into #pragma NOTREACHED etc */
|
||
|
||
static int for_lint = 0;
|
||
|
||
/* Nonzero means copy comments into the output file. */
|
||
|
||
static int put_out_comments = 0;
|
||
|
||
/* Nonzero means don't process the ANSI trigraph sequences. */
|
||
|
||
static int no_trigraphs = 0;
|
||
|
||
/* Nonzero means print the names of included files rather than
|
||
the preprocessed output. 1 means just the #include "...",
|
||
2 means #include <...> as well. */
|
||
|
||
static int print_deps = 0;
|
||
|
||
/* Nonzero if missing .h files in -M output are assumed to be generated
|
||
files and not errors. */
|
||
|
||
static int print_deps_missing_files = 0;
|
||
|
||
/* Nonzero means print names of header files (-H). */
|
||
|
||
static int print_include_names = 0;
|
||
|
||
/* Nonzero means don't output line number information. */
|
||
|
||
static int no_line_directives;
|
||
|
||
/* Nonzero means output the text in failing conditionals,
|
||
inside #failed ... #endfailed. */
|
||
|
||
static int output_conditionals;
|
||
|
||
/* 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
|
||
*/
|
||
|
||
static enum {dump_none, dump_only, dump_names, dump_definitions}
|
||
dump_macros = dump_none;
|
||
|
||
/* 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. */
|
||
static int debug_output = 0;
|
||
|
||
/* Nonzero means pass #include lines through to the output,
|
||
even if they are ifdefed out. */
|
||
static int dump_includes;
|
||
|
||
/* Nonzero indicates special processing used by the pcp program. The
|
||
special effects of this mode are:
|
||
|
||
Inhibit all macro expansion, except those inside #if directives.
|
||
|
||
Process #define directives normally, and output their contents
|
||
to the output file.
|
||
|
||
Output preconditions to pcp_outfile indicating all the relevant
|
||
preconditions for use of this file in a later cpp run.
|
||
*/
|
||
static FILE *pcp_outfile;
|
||
|
||
/* 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. */
|
||
static int pcp_inside_if;
|
||
|
||
/* Nonzero means never to include precompiled files.
|
||
This is 1 since there's no way now to make precompiled files,
|
||
so it's not worth testing for them. */
|
||
static int no_precomp = 1;
|
||
|
||
/* Nonzero means give all the error messages the ANSI standard requires. */
|
||
|
||
int pedantic;
|
||
|
||
/* Nonzero means try to make failure to fit ANSI C an error. */
|
||
|
||
static int pedantic_errors;
|
||
|
||
/* Nonzero means don't print warning messages. -w. */
|
||
|
||
static int inhibit_warnings = 0;
|
||
|
||
/* Nonzero means warn if slash-star appears in a slash-star comment,
|
||
or if newline-backslash appears in a slash-slash comment. */
|
||
|
||
static int warn_comments;
|
||
|
||
/* Nonzero means warn if a macro argument is (or would be)
|
||
stringified with -traditional. */
|
||
|
||
static int warn_stringify;
|
||
|
||
/* Nonzero means warn if there are any trigraphs. */
|
||
|
||
static int warn_trigraphs;
|
||
|
||
/* Nonzero means warn if undefined identifiers are evaluated in an #if. */
|
||
|
||
static int warn_undef;
|
||
|
||
/* Nonzero means warn if #import is used. */
|
||
|
||
static int warn_import = 1;
|
||
|
||
/* Nonzero means turn warnings into errors. */
|
||
|
||
static int warnings_are_errors;
|
||
|
||
/* Nonzero means try to imitate old fashioned non-ANSI preprocessor. */
|
||
|
||
int traditional;
|
||
|
||
/* Nonzero for the 1989 C Standard, including corrigenda and amendments. */
|
||
|
||
int c89;
|
||
|
||
/* Nonzero for the 199x C Standard. */
|
||
|
||
int c9x;
|
||
|
||
/* Nonzero causes output not to be done,
|
||
but directives such as #define that have side effects
|
||
are still obeyed. */
|
||
|
||
static int no_output;
|
||
|
||
/* Nonzero means we should look for header.gcc files that remap file names. */
|
||
static int remap;
|
||
|
||
/* Nonzero means this file was included with a -imacros or -include
|
||
command line and should not be recorded as an include file. */
|
||
|
||
static int no_record_file;
|
||
|
||
/* Nonzero means that we have finished processing the command line options.
|
||
This flag is used to decide whether or not to issue certain errors
|
||
and/or warnings. */
|
||
|
||
static int done_initializing = 0;
|
||
|
||
/* Line where a newline was first seen in a string constant. */
|
||
|
||
static int multiline_string_line = 0;
|
||
|
||
/* I/O buffer structure.
|
||
The `fname' field is nonzero for source files and #include files
|
||
and for the dummy text used for -D and -U.
|
||
It is zero for rescanning results of macro expansion
|
||
and for expanding macro arguments. */
|
||
#define INPUT_STACK_MAX 400
|
||
static struct file_buf {
|
||
char *fname;
|
||
/* Filename specified with #line directive. */
|
||
char *nominal_fname;
|
||
/* The length of nominal_fname, which may contain embedded NULs. */
|
||
size_t nominal_fname_len;
|
||
/* Include file description. */
|
||
struct include_file *inc;
|
||
/* Record where in the search path this file was found.
|
||
For #include_next. */
|
||
struct file_name_list *dir;
|
||
int lineno;
|
||
int length;
|
||
U_CHAR *buf;
|
||
U_CHAR *bufp;
|
||
/* Macro that this level is the expansion of.
|
||
Included so that we can reenable the macro
|
||
at the end of this level. */
|
||
struct hashnode *macro;
|
||
/* Value of if_stack at start of this file.
|
||
Used to prohibit unmatched #endif (etc) in an include file. */
|
||
struct if_stack *if_stack;
|
||
/* Object to be freed at end of input at this level. */
|
||
U_CHAR *free_ptr;
|
||
/* True if this is a system header file; see is_system_include. */
|
||
char system_header_p;
|
||
} instack[INPUT_STACK_MAX];
|
||
|
||
static int last_error_tick; /* Incremented each time we print it. */
|
||
static int input_file_stack_tick; /* Incremented when the status changes. */
|
||
|
||
/* Current nesting level of input sources.
|
||
`instack[indepth]' is the level currently being read. */
|
||
static int indepth = -1;
|
||
#define CHECK_DEPTH(code) \
|
||
if (indepth >= (INPUT_STACK_MAX - 1)) \
|
||
{ \
|
||
error_with_line (line_for_error (instack[indepth].lineno), \
|
||
"macro or `#include' recursion too deep"); \
|
||
code; \
|
||
}
|
||
|
||
/* Current depth in #include directives that use <...>. */
|
||
static int system_include_depth = 0;
|
||
|
||
typedef struct file_buf FILE_BUF;
|
||
|
||
/* The output buffer. Its LENGTH field is the amount of room allocated
|
||
for the buffer, not the number of chars actually present. To get
|
||
that, subtract outbuf.buf from outbuf.bufp. */
|
||
|
||
#define OUTBUF_SIZE 10 /* initial size of output buffer */
|
||
static FILE_BUF outbuf;
|
||
|
||
/* Grow output buffer OBUF points at
|
||
so it can hold at least NEEDED more chars. */
|
||
|
||
#define check_expand(OBUF, NEEDED) \
|
||
(((OBUF)->length - ((OBUF)->bufp - (OBUF)->buf) <= (NEEDED)) \
|
||
? grow_outbuf ((OBUF), (NEEDED)) : 0)
|
||
|
||
struct file_name_list
|
||
{
|
||
struct file_name_list *next;
|
||
/* If the following is 1, it is a C-language system include
|
||
directory. */
|
||
int c_system_include_path;
|
||
/* Mapping of file names for this directory. */
|
||
struct file_name_map *name_map;
|
||
/* Non-zero if name_map is valid. */
|
||
int got_name_map;
|
||
/* The include directory status. */
|
||
struct stat st;
|
||
/* The include prefix: "" denotes the working directory,
|
||
otherwise fname must end in '/'.
|
||
The actual size is dynamically allocated. */
|
||
char fname[1];
|
||
};
|
||
|
||
/* #include "file" looks in source file dir, then stack. */
|
||
/* #include <file> just looks in the stack. */
|
||
/* -I directories are added to the end, then the defaults are added. */
|
||
/* The */
|
||
static struct default_include {
|
||
char *fname; /* The name of the directory. */
|
||
char *component; /* The component containing the directory */
|
||
int cplusplus; /* Only look here if we're compiling C++. */
|
||
int cxx_aware; /* Includes in this directory don't need to
|
||
be wrapped in extern "C" when compiling
|
||
C++. */
|
||
int included; /* Set if the directory is acceptable. */
|
||
} include_defaults_array[]
|
||
#ifdef INCLUDE_DEFAULTS
|
||
= INCLUDE_DEFAULTS;
|
||
#else
|
||
= {
|
||
/* Pick up GNU C++ specific include files. */
|
||
{ GPLUSPLUS_INCLUDE_DIR, "G++", 1, 1, 0 },
|
||
#ifdef CROSS_COMPILE
|
||
/* This is the dir for fixincludes. Put it just before
|
||
the files that we fix. */
|
||
{ GCC_INCLUDE_DIR, "GCC", 0, 0, 0 },
|
||
/* For cross-compilation, this dir name is generated
|
||
automatically in Makefile.in. */
|
||
{ CROSS_INCLUDE_DIR, "GCC", 0, 0, 0 },
|
||
#ifdef TOOL_INCLUDE_DIR
|
||
/* This is another place that the target system's headers might be. */
|
||
{ TOOL_INCLUDE_DIR, "BINUTILS", 0, 0, 0 },
|
||
#endif
|
||
#else /* not CROSS_COMPILE */
|
||
#ifdef LOCAL_INCLUDE_DIR
|
||
/* This should be /usr/local/include and should come before
|
||
the fixincludes-fixed header files. */
|
||
{ LOCAL_INCLUDE_DIR, 0, 0, 1, 0 },
|
||
#endif
|
||
#ifdef TOOL_INCLUDE_DIR
|
||
/* This is here ahead of GCC_INCLUDE_DIR because assert.h goes here.
|
||
Likewise, behind LOCAL_INCLUDE_DIR, where glibc puts its assert.h. */
|
||
{ TOOL_INCLUDE_DIR, "BINUTILS", 0, 0, 0 },
|
||
#endif
|
||
/* This is the dir for fixincludes. Put it just before
|
||
the files that we fix. */
|
||
{ GCC_INCLUDE_DIR, "GCC", 0, 0, 0 },
|
||
/* Some systems have an extra dir of include files. */
|
||
#ifdef SYSTEM_INCLUDE_DIR
|
||
{ SYSTEM_INCLUDE_DIR, 0, 0, 0, 0 },
|
||
#endif
|
||
#ifndef STANDARD_INCLUDE_COMPONENT
|
||
#define STANDARD_INCLUDE_COMPONENT 0
|
||
#endif
|
||
{ STANDARD_INCLUDE_DIR, STANDARD_INCLUDE_COMPONENT, 0, 0, 0 },
|
||
#endif /* not CROSS_COMPILE */
|
||
{ 0, 0, 0, 0, 0 }
|
||
};
|
||
#endif /* no INCLUDE_DEFAULTS */
|
||
|
||
/* The code looks at the defaults through this pointer, rather than through
|
||
the constant structure above. This pointer gets changed if an environment
|
||
variable specifies other defaults. */
|
||
static struct default_include *include_defaults = include_defaults_array;
|
||
|
||
static struct file_name_list *include = 0; /* 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. */
|
||
static struct file_name_list *first_bracket_include = 0;
|
||
/* This is the first element in the chain that corresponds to
|
||
a directory of system header files. */
|
||
static struct file_name_list *first_system_include = 0;
|
||
static struct file_name_list *last_include = 0; /* Last in chain */
|
||
|
||
/* Chain of include directories to put at the end of the other chain. */
|
||
static struct file_name_list *after_include = 0;
|
||
static struct file_name_list *last_after_include = 0; /* Last in chain */
|
||
|
||
/* Chain to put at the start of the system include files. */
|
||
static struct file_name_list *before_system = 0;
|
||
static struct file_name_list *last_before_system = 0; /* Last in chain */
|
||
|
||
/* Directory prefix that should replace `/usr' in the standard
|
||
include file directories. */
|
||
static char *include_prefix;
|
||
|
||
/* Maintain and search list of included files. */
|
||
|
||
struct include_file {
|
||
struct include_file *next; /* for include_hashtab */
|
||
struct include_file *next_ino; /* for include_ino_hashtab */
|
||
char *fname;
|
||
/* If the following is the empty string, it means #pragma once
|
||
was seen in this include file, or #import was applied to the file.
|
||
Otherwise, if it is nonzero, it is a macro name.
|
||
Don't include the file again if that macro is defined. */
|
||
U_CHAR *control_macro;
|
||
/* Nonzero if the dependency on this include file has been output. */
|
||
int deps_output;
|
||
struct stat st;
|
||
};
|
||
|
||
/* Hash tables of files already included with #include or #import.
|
||
include_hashtab is by full name; include_ino_hashtab is by inode number. */
|
||
|
||
#define INCLUDE_HASHSIZE 61
|
||
static struct include_file *include_hashtab[INCLUDE_HASHSIZE];
|
||
static struct include_file *include_ino_hashtab[INCLUDE_HASHSIZE];
|
||
|
||
/* Global list of strings read in from precompiled files. This list
|
||
is kept in the order the strings are read in, with new strings being
|
||
added at the end through stringlist_tailp. We use this list to output
|
||
the strings at the end of the run.
|
||
*/
|
||
static STRINGDEF *stringlist;
|
||
static STRINGDEF **stringlist_tailp = &stringlist;
|
||
|
||
|
||
/* Structure returned by create_definition */
|
||
typedef struct macrodef MACRODEF;
|
||
struct macrodef
|
||
{
|
||
struct definition *defn;
|
||
U_CHAR *symnam;
|
||
int symlen;
|
||
};
|
||
|
||
enum sharp_token_type {
|
||
NO_SHARP_TOKEN = 0, /* token not present */
|
||
|
||
SHARP_TOKEN = '#', /* token spelled with # only */
|
||
WHITE_SHARP_TOKEN, /* token spelled with # and white space */
|
||
|
||
PERCENT_COLON_TOKEN = '%', /* token spelled with %: only */
|
||
WHITE_PERCENT_COLON_TOKEN /* token spelled with %: and white space */
|
||
};
|
||
|
||
/* 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). */
|
||
|
||
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 */
|
||
U_CHAR *expansion;
|
||
int line; /* Line number of definition */
|
||
char *file; /* File of definition */
|
||
size_t file_len; /* Length of file (which can contain NULs) */
|
||
char rest_args; /* Nonzero if last arg. absorbs the rest */
|
||
struct reflist {
|
||
struct reflist *next;
|
||
|
||
enum sharp_token_type stringify; /* set if a # operator before arg */
|
||
enum sharp_token_type raw_before; /* set if a ## operator before arg */
|
||
enum sharp_token_type raw_after; /* set 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) */
|
||
} *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. */
|
||
U_CHAR *argnames;
|
||
} args;
|
||
};
|
||
|
||
/* different kinds of things that can appear in the value field
|
||
of a hash node. Actually, this may be useless now. */
|
||
union hashval {
|
||
char *cpval;
|
||
DEFINITION *defn;
|
||
KEYDEF *keydef;
|
||
};
|
||
|
||
/*
|
||
* special extension string that can be added to the last macro argument to
|
||
* allow it to absorb the "rest" of the arguments when expanded. Ex:
|
||
* #define wow(a, b...) process (b, a, b)
|
||
* { wow (1, 2, 3); } -> { process (2, 3, 1, 2, 3); }
|
||
* { wow (one, two); } -> { process (two, one, two); }
|
||
* if this "rest_arg" is used with the concat token '##' and if it is not
|
||
* supplied then the token attached to with ## will not be outputted. Ex:
|
||
* #define wow (a, b...) process (b ## , a, ## b)
|
||
* { wow (1, 2); } -> { process (2, 1, 2); }
|
||
* { wow (one); } -> { process (one); {
|
||
*/
|
||
static char rest_extension[] = "...";
|
||
#define REST_EXTENSION_LENGTH (sizeof (rest_extension) - 1)
|
||
|
||
/* This is the implicit parameter name when using variable number of
|
||
parameters for macros using the ISO C 9x extension. */
|
||
static char va_args_name[] = "__VA_ARGS__";
|
||
#define VA_ARGS_NAME_LENGTH (sizeof (va_args_name) - 1)
|
||
|
||
/* The structure of a node in the hash table. The hash table
|
||
has entries for all tokens defined by #define directives (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_IMMEDIATE_PREFIX_TYPE, /* `__IMMEDIATE_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. */
|
||
};
|
||
|
||
struct hashnode {
|
||
struct hashnode *next; /* double links for easy deletion */
|
||
struct hashnode *prev;
|
||
struct hashnode **bucket_hdr; /* also, a back pointer to this node's hash
|
||
chain is kept, in case the node is the head
|
||
of the chain and gets deleted. */
|
||
enum node_type type; /* type of special token */
|
||
int length; /* length of token, for quick comparison */
|
||
U_CHAR *name; /* the actual name */
|
||
union hashval value; /* pointer to expansion, or whatever */
|
||
};
|
||
|
||
typedef struct hashnode HASHNODE;
|
||
|
||
/* Some definitions for the hash table. The hash function MUST be
|
||
computed as shown in hashf () below. That is because the rescan
|
||
loop computes the hash value `on the fly' for most tokens,
|
||
in order to avoid the overhead of a lot of procedure calls to
|
||
the hashf () function. Hashf () only exists for the sake of
|
||
politeness, for use when speed isn't so important. */
|
||
|
||
#define HASHSIZE 1403
|
||
static HASHNODE *hashtab[HASHSIZE];
|
||
#define HASHSTEP(old, c) ((old << 2) + c)
|
||
#define MAKE_POS(v) (v & 0x7fffffff) /* make number positive */
|
||
|
||
|
||
/* We let tm.h override the types used here, to handle trivial differences
|
||
such as the choice of unsigned int or long unsigned int for size_t.
|
||
When machines start needing nontrivial differences in the size type,
|
||
it would be best to do something here to figure out automatically
|
||
from other information what type to use. */
|
||
|
||
/* The string value for __SIZE_TYPE__. */
|
||
|
||
#ifndef SIZE_TYPE
|
||
#define SIZE_TYPE "long unsigned int"
|
||
#endif
|
||
|
||
/* The string value for __PTRDIFF_TYPE__. */
|
||
|
||
#ifndef PTRDIFF_TYPE
|
||
#define PTRDIFF_TYPE "long int"
|
||
#endif
|
||
|
||
/* The string value for __WCHAR_TYPE__. */
|
||
|
||
#ifndef WCHAR_TYPE
|
||
#define WCHAR_TYPE "int"
|
||
#endif
|
||
char * wchar_type = WCHAR_TYPE;
|
||
#undef WCHAR_TYPE
|
||
|
||
/* The string value for __USER_LABEL_PREFIX__ */
|
||
|
||
#ifndef USER_LABEL_PREFIX
|
||
#define USER_LABEL_PREFIX ""
|
||
#endif
|
||
char * user_label_prefix = USER_LABEL_PREFIX;
|
||
#undef USER_LABEL_PREFIX
|
||
|
||
/* The string value for __REGISTER_PREFIX__ */
|
||
|
||
#ifndef REGISTER_PREFIX
|
||
#define REGISTER_PREFIX ""
|
||
#endif
|
||
|
||
/* The string value for __IMMEDIATE_PREFIX__ */
|
||
|
||
#ifndef IMMEDIATE_PREFIX
|
||
#define IMMEDIATE_PREFIX ""
|
||
#endif
|
||
|
||
/* In the definition of a #assert name, this structure forms
|
||
a list of the individual values asserted.
|
||
Each value is itself a list of "tokens".
|
||
These are strings that are compared by name. */
|
||
|
||
struct tokenlist_list {
|
||
struct tokenlist_list *next;
|
||
struct arglist *tokens;
|
||
};
|
||
|
||
struct assertion_hashnode {
|
||
struct assertion_hashnode *next; /* double links for easy deletion */
|
||
struct assertion_hashnode *prev;
|
||
/* also, a back pointer to this node's hash
|
||
chain is kept, in case the node is the head
|
||
of the chain and gets deleted. */
|
||
struct assertion_hashnode **bucket_hdr;
|
||
int length; /* length of token, for quick comparison */
|
||
U_CHAR *name; /* the actual name */
|
||
/* List of token-sequences. */
|
||
struct tokenlist_list *value;
|
||
};
|
||
|
||
typedef struct assertion_hashnode ASSERTION_HASHNODE;
|
||
|
||
/* Some definitions for the hash table. The hash function MUST be
|
||
computed as shown in hashf below. That is because the rescan
|
||
loop computes the hash value `on the fly' for most tokens,
|
||
in order to avoid the overhead of a lot of procedure calls to
|
||
the hashf function. hashf only exists for the sake of
|
||
politeness, for use when speed isn't so important. */
|
||
|
||
#define ASSERTION_HASHSIZE 37
|
||
static ASSERTION_HASHNODE *assertion_hashtab[ASSERTION_HASHSIZE];
|
||
|
||
/* Nonzero means inhibit macroexpansion of what seem to be
|
||
assertion tests, in rescan. For #if. */
|
||
static int assertions_flag;
|
||
|
||
/* `struct directive' defines one #-directive, including how to handle it. */
|
||
|
||
#define DO_PROTO PROTO((U_CHAR *, U_CHAR *, FILE_BUF *, struct directive *))
|
||
|
||
struct directive {
|
||
int length; /* Length of name */
|
||
int (*func) DO_PROTO; /* Function to handle directive */
|
||
char *name; /* Name of directive */
|
||
enum node_type type; /* Code which describes which directive. */
|
||
};
|
||
|
||
#define IS_INCLUDE_DIRECTIVE_TYPE(t) \
|
||
((int) T_INCLUDE <= (int) (t) && (int) (t) <= (int) T_IMPORT)
|
||
|
||
/* These functions are declared to return int instead of void since they
|
||
are going to be placed in the table and some old compilers have trouble with
|
||
pointers to functions returning void. */
|
||
|
||
static int do_assert DO_PROTO;
|
||
static int do_define DO_PROTO;
|
||
static int do_elif DO_PROTO;
|
||
static int do_else DO_PROTO;
|
||
static int do_endif DO_PROTO;
|
||
static int do_error DO_PROTO;
|
||
static int do_ident DO_PROTO;
|
||
static int do_if DO_PROTO;
|
||
static int do_include DO_PROTO;
|
||
static int do_line DO_PROTO;
|
||
static int do_pragma DO_PROTO;
|
||
#ifdef SCCS_DIRECTIVE
|
||
static int do_sccs DO_PROTO;
|
||
#endif
|
||
static int do_unassert DO_PROTO;
|
||
static int do_undef DO_PROTO;
|
||
static int do_warning DO_PROTO;
|
||
static int do_xifdef DO_PROTO;
|
||
|
||
/* Here is the actual list of #-directives, most-often-used first. */
|
||
|
||
static struct directive directive_table[] = {
|
||
{ 6, do_define, "define", T_DEFINE},
|
||
{ 2, do_if, "if", T_IF},
|
||
{ 5, do_xifdef, "ifdef", T_IFDEF},
|
||
{ 6, do_xifdef, "ifndef", T_IFNDEF},
|
||
{ 5, do_endif, "endif", T_ENDIF},
|
||
{ 4, do_else, "else", T_ELSE},
|
||
{ 4, do_elif, "elif", T_ELIF},
|
||
{ 4, do_line, "line", T_LINE},
|
||
{ 7, do_include, "include", T_INCLUDE},
|
||
{ 12, do_include, "include_next", T_INCLUDE_NEXT},
|
||
{ 6, do_include, "import", T_IMPORT},
|
||
{ 5, do_undef, "undef", T_UNDEF},
|
||
{ 5, do_error, "error", T_ERROR},
|
||
{ 7, do_warning, "warning", T_WARNING},
|
||
#ifdef SCCS_DIRECTIVE
|
||
{ 4, do_sccs, "sccs", T_SCCS},
|
||
#endif
|
||
{ 6, do_pragma, "pragma", T_PRAGMA},
|
||
{ 5, do_ident, "ident", T_IDENT},
|
||
{ 6, do_assert, "assert", T_ASSERT},
|
||
{ 8, do_unassert, "unassert", T_UNASSERT},
|
||
{ -1, 0, "", T_UNUSED},
|
||
};
|
||
|
||
/* When a directive handler is called,
|
||
this points to the # (or the : of the %:) that started the directive. */
|
||
U_CHAR *directive_start;
|
||
|
||
/* table to tell if char can be part of a C identifier. */
|
||
U_CHAR is_idchar[256];
|
||
/* table to tell if char can be first char of a c identifier. */
|
||
U_CHAR is_idstart[256];
|
||
/* table to tell if c is horizontal space. */
|
||
static U_CHAR is_hor_space[256];
|
||
/* table to tell if c is horizontal or vertical space. */
|
||
U_CHAR is_space[256];
|
||
|
||
#define SKIP_WHITE_SPACE(p) do { while (is_hor_space[*p]) p++; } while (0)
|
||
#define SKIP_ALL_WHITE_SPACE(p) do { while (is_space[*p]) p++; } while (0)
|
||
|
||
static int errors = 0; /* Error counter for exit code */
|
||
|
||
/* Name of output file, for error messages. */
|
||
static char *out_fname;
|
||
|
||
/* Nonzero to ignore \ in string constants. Use to treat #line 1 "A:\file.h
|
||
as a non-form feed. If you want it to be a form feed, you must use
|
||
# 1 "\f". */
|
||
static int ignore_escape_flag = 1;
|
||
|
||
/* 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 */
|
||
char *fname; /* copied from input when frame is made */
|
||
size_t fname_len; /* similarly */
|
||
int lineno; /* similarly */
|
||
int if_succeeded; /* true if a leg of this if-group
|
||
has been passed through rescan */
|
||
U_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;
|
||
static IF_STACK_FRAME *if_stack = NULL;
|
||
|
||
/* Buffer of -M output. */
|
||
static char *deps_buffer;
|
||
|
||
/* Number of bytes allocated in above. */
|
||
static int deps_allocated_size;
|
||
|
||
/* Number of bytes used. */
|
||
static int deps_size;
|
||
|
||
/* Number of bytes since the last newline. */
|
||
static int deps_column;
|
||
|
||
/* Nonzero means -I- has been seen,
|
||
so don't look for #include "foo" the source-file directory. */
|
||
static int ignore_srcdir;
|
||
|
||
static int safe_read PROTO((int, char *, int));
|
||
static void safe_write PROTO((int, char *, int));
|
||
static void eprint_string PROTO((const char *, size_t));
|
||
|
||
int main PROTO((int, char **));
|
||
|
||
static void path_include PROTO((char *));
|
||
|
||
static U_CHAR *index0 PROTO((U_CHAR *, int, size_t));
|
||
|
||
static void trigraph_pcp PROTO((FILE_BUF *));
|
||
|
||
static void newline_fix PROTO((U_CHAR *));
|
||
static void name_newline_fix PROTO((U_CHAR *));
|
||
|
||
static char *get_lintcmd PROTO((U_CHAR *, U_CHAR *, U_CHAR **, int *, int *));
|
||
|
||
static void rescan PROTO((FILE_BUF *, int));
|
||
|
||
static FILE_BUF expand_to_temp_buffer PROTO((U_CHAR *, U_CHAR *, int, int));
|
||
|
||
static int handle_directive PROTO((FILE_BUF *, FILE_BUF *));
|
||
|
||
static struct tm *timestamp PROTO((void));
|
||
static void special_symbol PROTO((HASHNODE *, FILE_BUF *));
|
||
|
||
static int is_system_include PROTO((char *));
|
||
static char *base_name PROTO((char *));
|
||
static int absolute_filename PROTO((char *));
|
||
static size_t simplify_filename PROTO((char *));
|
||
|
||
static char *read_filename_string PROTO((int, FILE *));
|
||
static struct file_name_map *read_name_map PROTO((char *));
|
||
static int open_include_file PROTO((char *, struct file_name_list *, U_CHAR *, struct include_file **));
|
||
static char *remap_include_file PROTO((char *, struct file_name_list *));
|
||
static int lookup_ino_include PROTO((struct include_file *));
|
||
|
||
static void finclude PROTO((int, struct include_file *, FILE_BUF *, int, struct file_name_list *));
|
||
static void record_control_macro PROTO((struct include_file *, U_CHAR *));
|
||
|
||
static char *check_precompiled PROTO((int, struct stat *, char *, char **));
|
||
static int check_preconditions PROTO((char *));
|
||
static void pcfinclude PROTO((U_CHAR *, U_CHAR *, FILE_BUF *));
|
||
static void pcstring_used PROTO((HASHNODE *));
|
||
static void write_output PROTO((void));
|
||
static void pass_thru_directive PROTO((U_CHAR *, U_CHAR *, FILE_BUF *, struct directive *));
|
||
|
||
static MACRODEF create_definition PROTO((U_CHAR *, U_CHAR *, FILE_BUF *));
|
||
|
||
static int check_macro_name PROTO((U_CHAR *, int));
|
||
static int compare_defs PROTO((DEFINITION *, DEFINITION *));
|
||
static int comp_def_part PROTO((int, U_CHAR *, int, U_CHAR *, int, int));
|
||
|
||
static DEFINITION *collect_expansion PROTO((U_CHAR *, U_CHAR *, int, struct arglist *));
|
||
|
||
int check_assertion PROTO((U_CHAR *, int, int, struct arglist *));
|
||
static int compare_token_lists PROTO((struct arglist *, struct arglist *));
|
||
|
||
static struct arglist *read_token_list PROTO((U_CHAR **, U_CHAR *, int *));
|
||
static void free_token_list PROTO((struct arglist *));
|
||
|
||
static ASSERTION_HASHNODE *assertion_install PROTO((U_CHAR *, int, int));
|
||
static ASSERTION_HASHNODE *assertion_lookup PROTO((U_CHAR *, int, int));
|
||
static void delete_assertion PROTO((ASSERTION_HASHNODE *));
|
||
|
||
static void do_once PROTO((void));
|
||
|
||
static HOST_WIDEST_INT eval_if_expression PROTO((U_CHAR *, int));
|
||
static void conditional_skip PROTO((FILE_BUF *, int, enum node_type, U_CHAR *, FILE_BUF *));
|
||
static void skip_if_group PROTO((FILE_BUF *, int, FILE_BUF *));
|
||
static void validate_else PROTO((U_CHAR *, U_CHAR *));
|
||
|
||
static U_CHAR *skip_to_end_of_comment PROTO((FILE_BUF *, int *, int));
|
||
static U_CHAR *skip_quoted_string PROTO((U_CHAR *, U_CHAR *, int, int *, int *, int *));
|
||
static char *quote_string PROTO((char *, char *, size_t));
|
||
static U_CHAR *skip_paren_group PROTO((FILE_BUF *));
|
||
|
||
/* Last arg to output_line_directive. */
|
||
enum file_change_code {same_file, enter_file, leave_file};
|
||
static void output_line_directive PROTO((FILE_BUF *, FILE_BUF *, int, enum file_change_code));
|
||
|
||
static void macroexpand PROTO((HASHNODE *, FILE_BUF *));
|
||
|
||
struct argdata;
|
||
static int macarg PROTO((struct argdata *, int));
|
||
|
||
static U_CHAR *macarg1 PROTO((U_CHAR *, U_CHAR *, struct hashnode *, int *, int *, int *, int));
|
||
|
||
static int discard_comments PROTO((U_CHAR *, int, int));
|
||
|
||
static int change_newlines PROTO((U_CHAR *, int));
|
||
|
||
static char *my_strerror PROTO((int));
|
||
static void notice PVPROTO((const char *, ...)) ATTRIBUTE_PRINTF_1;
|
||
static void vnotice PROTO((const char *, va_list));
|
||
void error PVPROTO((const char *, ...)) ATTRIBUTE_PRINTF_1;
|
||
void verror PROTO((const char *, va_list));
|
||
static void error_from_errno PROTO((char *));
|
||
void warning PVPROTO((const char *, ...)) ATTRIBUTE_PRINTF_1;
|
||
static void vwarning PROTO((const char *, va_list));
|
||
static void error_with_line PVPROTO((int, const char *, ...)) ATTRIBUTE_PRINTF_2;
|
||
static void verror_with_line PROTO((int, const char *, va_list));
|
||
static void vwarning_with_line PROTO((int, const char *, va_list));
|
||
static void warning_with_line PVPROTO((int, const char *, ...)) ATTRIBUTE_PRINTF_2;
|
||
void pedwarn PVPROTO((const char *, ...)) ATTRIBUTE_PRINTF_1;
|
||
void pedwarn_with_line PVPROTO((int, const char *, ...)) ATTRIBUTE_PRINTF_2;
|
||
static void pedwarn_with_file_and_line PVPROTO((const char *, size_t, int, const char *, ...)) ATTRIBUTE_PRINTF_4;
|
||
static void pedwarn_strange_white_space PROTO((int));
|
||
|
||
static void print_containing_files PROTO((void));
|
||
|
||
static int line_for_error PROTO((int));
|
||
static int grow_outbuf PROTO((FILE_BUF *, int));
|
||
|
||
static HASHNODE *install PROTO((U_CHAR *, int, enum node_type, char *, int));
|
||
HASHNODE *lookup PROTO((U_CHAR *, int, int));
|
||
static void delete_macro PROTO((HASHNODE *));
|
||
static int hashf PROTO((U_CHAR *, int, int));
|
||
|
||
static void dump_single_macro PROTO((HASHNODE *, FILE *));
|
||
static void dump_all_macros PROTO((void));
|
||
static void dump_defn_1 PROTO((U_CHAR *, int, int, FILE *));
|
||
static void dump_arg_n PROTO((DEFINITION *, int, FILE *));
|
||
|
||
static void initialize_char_syntax PROTO((void));
|
||
static void initialize_builtins PROTO((FILE_BUF *, FILE_BUF *));
|
||
|
||
static void make_definition PROTO((char *));
|
||
static void make_undef PROTO((char *, FILE_BUF *));
|
||
|
||
static void make_assertion PROTO((const char *, const char *));
|
||
|
||
static struct file_name_list *new_include_prefix PROTO((struct file_name_list *, const char *, const char *, const char *));
|
||
static void append_include_chain PROTO((struct file_name_list *, struct file_name_list *));
|
||
|
||
static int quote_string_for_make PROTO((char *, const char *));
|
||
static void deps_output PROTO((const char *, int));
|
||
|
||
void fatal PVPROTO((const char *, ...)) ATTRIBUTE_PRINTF_1 ATTRIBUTE_NORETURN;
|
||
void fancy_abort PROTO((void)) ATTRIBUTE_NORETURN;
|
||
static void perror_with_name PROTO((char *));
|
||
static void pfatal_with_name PROTO((char *)) ATTRIBUTE_NORETURN;
|
||
static void pipe_closed PROTO((int)) ATTRIBUTE_NORETURN;
|
||
|
||
static void memory_full PROTO((void)) ATTRIBUTE_NORETURN;
|
||
static void print_help PROTO((void));
|
||
|
||
/* Read LEN bytes at PTR from descriptor DESC, for file FILENAME,
|
||
retrying if necessary. If MAX_READ_LEN is defined, read at most
|
||
that bytes at a time. Return a negative value if an error occurs,
|
||
otherwise return the actual number of bytes read,
|
||
which must be LEN unless end-of-file was reached. */
|
||
|
||
static int
|
||
safe_read (desc, ptr, len)
|
||
int desc;
|
||
char *ptr;
|
||
int len;
|
||
{
|
||
int left, rcount, nchars;
|
||
|
||
left = len;
|
||
while (left > 0) {
|
||
rcount = left;
|
||
#ifdef MAX_READ_LEN
|
||
if (rcount > MAX_READ_LEN)
|
||
rcount = MAX_READ_LEN;
|
||
#endif
|
||
nchars = read (desc, ptr, rcount);
|
||
if (nchars < 0)
|
||
{
|
||
#ifdef EINTR
|
||
if (errno == EINTR)
|
||
continue;
|
||
#endif
|
||
return nchars;
|
||
}
|
||
if (nchars == 0)
|
||
break;
|
||
ptr += nchars;
|
||
left -= nchars;
|
||
}
|
||
return len - left;
|
||
}
|
||
|
||
/* Write LEN bytes at PTR to descriptor DESC,
|
||
retrying if necessary, and treating any real error as fatal.
|
||
If MAX_WRITE_LEN is defined, write at most that many bytes at a time. */
|
||
|
||
static void
|
||
safe_write (desc, ptr, len)
|
||
int desc;
|
||
char *ptr;
|
||
int len;
|
||
{
|
||
int wcount, written;
|
||
|
||
while (len > 0) {
|
||
wcount = len;
|
||
#ifdef MAX_WRITE_LEN
|
||
if (wcount > MAX_WRITE_LEN)
|
||
wcount = MAX_WRITE_LEN;
|
||
#endif
|
||
written = write (desc, ptr, wcount);
|
||
if (written < 0)
|
||
{
|
||
#ifdef EINTR
|
||
if (errno == EINTR)
|
||
continue;
|
||
#endif
|
||
pfatal_with_name (out_fname);
|
||
}
|
||
ptr += written;
|
||
len -= written;
|
||
}
|
||
}
|
||
|
||
/* Print a string to stderr, with extra handling in case it contains
|
||
embedded NUL characters. Any present are written as is.
|
||
|
||
Using fwrite for this purpose produces undesireable results on VMS
|
||
when stderr happens to be a record oriented file, such as a batch log
|
||
file, rather than a stream oriented one. */
|
||
|
||
static void
|
||
eprint_string (string, length)
|
||
const char *string;
|
||
size_t length;
|
||
{
|
||
size_t segment_length;
|
||
|
||
do {
|
||
fprintf(stderr, "%s", string);
|
||
length -= (segment_length = strlen(string));
|
||
if (length > 0)
|
||
{
|
||
fputc('\0', stderr);
|
||
length -= 1;
|
||
/* Advance past the portion which has already been printed. */
|
||
string += segment_length + 1;
|
||
}
|
||
} while (length > 0);
|
||
}
|
||
|
||
|
||
static void
|
||
print_help ()
|
||
{
|
||
printf ("Usage: %s [switches] input output\n", progname);
|
||
printf ("Switches:\n");
|
||
printf (" -include <file> Include the contents of <file> before other files\n");
|
||
printf (" -imacros <file> Accept definition of marcos in <file>\n");
|
||
printf (" -iprefix <path> Specify <path> as a prefix for next two options\n");
|
||
printf (" -iwithprefix <dir> Add <dir> to the end of the system include paths\n");
|
||
printf (" -iwithprefixbefore <dir> Add <dir> to the end of the main include paths\n");
|
||
printf (" -isystem <dir> Add <dir> to the start of the system include paths\n");
|
||
printf (" -idirafter <dir> Add <dir> to the end of the system include paths\n");
|
||
printf (" -I <dir> Add <dir> to the end of the main include paths\n");
|
||
printf (" -nostdinc Do not search the system include directories\n");
|
||
printf (" -nostdinc++ Do not search the system include directories for C++\n");
|
||
printf (" -o <file> Put output into <file>\n");
|
||
printf (" -pedantic Issue all warnings demanded by strict ANSI C\n");
|
||
printf (" -traditional Follow K&R pre-processor behaviour\n");
|
||
printf (" -trigraphs Support ANSI C trigraphs\n");
|
||
printf (" -lang-c Assume that the input sources are in C\n");
|
||
printf (" -lang-c89 Assume that the input is C89; depricated\n");
|
||
printf (" -lang-c++ Assume that the input sources are in C++\n");
|
||
printf (" -lang-objc Assume that the input sources are in ObjectiveC\n");
|
||
printf (" -lang-objc++ Assume that the input sources are in ObjectiveC++\n");
|
||
printf (" -lang-asm Assume that the input sources are in assembler\n");
|
||
printf (" -lang-chill Assume that the input sources are in Chill\n");
|
||
printf (" -std=<std name> Specify the conformance standard; one of:\n");
|
||
printf (" gnu89, gnu9x, c89, c9x, iso9899:1990,\n");
|
||
printf (" iso9899:199409, iso9899:199x\n");
|
||
printf (" -+ Allow parsing of C++ style features\n");
|
||
printf (" -w Inhibit warning messages\n");
|
||
printf (" -Wtrigraphs Warn if trigraphs are encountered\n");
|
||
printf (" -Wno-trigraphs Do not warn about trigraphs\n");
|
||
printf (" -Wcomment{s} Warn if one comment starts inside another\n");
|
||
printf (" -Wno-comment{s} Do not warn about comments\n");
|
||
printf (" -Wtraditional Warn if a macro argument is/would be turned into\n");
|
||
printf (" a string if -traditional is specified\n");
|
||
printf (" -Wno-traditional Do not warn about stringification\n");
|
||
printf (" -Wundef Warn if an undefined macro is used by #if\n");
|
||
printf (" -Wno-undef Do not warn about testing undefined macros\n");
|
||
printf (" -Wimport Warn about the use of the #import directive\n");
|
||
printf (" -Wno-import Do not warn about the use of #import\n");
|
||
printf (" -Werror Treat all warnings as errors\n");
|
||
printf (" -Wno-error Do not treat warnings as errors\n");
|
||
printf (" -Wall Enable all preprocessor warnings\n");
|
||
printf (" -M Generate make dependencies\n");
|
||
printf (" -MM As -M, but ignore system header files\n");
|
||
printf (" -MD As -M, but put output in a .d file\n");
|
||
printf (" -MMD As -MD, but ignore system header files\n");
|
||
printf (" -MG Treat missing header file as generated files\n");
|
||
printf (" -g Include #define and #undef directives in the output\n");
|
||
printf (" -D<macro> Define a <macro> with string '1' as its value\n");
|
||
printf (" -D<macro>=<val> Define a <macro> with <val> as its value\n");
|
||
printf (" -A<question> (<answer>) Assert the <answer> to <question>\n");
|
||
printf (" -U<macro> Undefine <macro> \n");
|
||
printf (" -u or -undef Do not predefine any macros\n");
|
||
printf (" -v Display the version number\n");
|
||
printf (" -H Print the name of header files as they are used\n");
|
||
printf (" -C Do not discard comments\n");
|
||
printf (" -dM Display a list of macro definitions active at end\n");
|
||
printf (" -dD Preserve macro definitions in output\n");
|
||
printf (" -dN As -dD except that only the names are preserved\n");
|
||
printf (" -dI Include #include directives in the output\n");
|
||
printf (" -ifoutput Describe skipped code blocks in output \n");
|
||
printf (" -P Do not generate #line directives\n");
|
||
printf (" -$ Do not include '$' in identifiers\n");
|
||
printf (" -remap Remap file names when including files.\n");
|
||
printf (" -h or --help Display this information\n");
|
||
}
|
||
|
||
int
|
||
main (argc, argv)
|
||
int argc;
|
||
char **argv;
|
||
{
|
||
struct stat st;
|
||
char *in_fname;
|
||
char *cp;
|
||
int f, i;
|
||
FILE_BUF *fp;
|
||
|
||
char **pend_files;
|
||
char **pend_defs;
|
||
char **pend_undefs;
|
||
char **pend_assertions;
|
||
char **pend_includes;
|
||
|
||
/* Record the option used with each element of pend_assertions.
|
||
This is preparation for supporting more than one option for making
|
||
an assertion. */
|
||
char **pend_assertion_options;
|
||
int no_standard_includes = 0;
|
||
int no_standard_cplusplus_includes = 0;
|
||
int missing_newline = 0;
|
||
|
||
/* Non-0 means don't output the preprocessed program. */
|
||
int inhibit_output = 0;
|
||
/* Non-0 means -v, so print the full set of include dirs. */
|
||
int verbose = 0;
|
||
|
||
/* File name which deps are being written to.
|
||
This is 0 if deps are being written to stdout. */
|
||
char *deps_file = 0;
|
||
/* Fopen file mode to open deps_file with. */
|
||
char *deps_mode = "a";
|
||
/* Stream on which to print the dependency information. */
|
||
FILE *deps_stream = 0;
|
||
/* Target-name to write with the dependency information. */
|
||
char *deps_target = 0;
|
||
|
||
#if defined (RLIMIT_STACK) && defined (HAVE_GETRLIMIT) && defined (HAVE_SETRLIMIT)
|
||
/* Get rid of any avoidable limit on stack size. */
|
||
{
|
||
struct rlimit rlim;
|
||
|
||
/* Set the stack limit huge so that alloca (particularly stringtab
|
||
in dbxread.c) does not fail. */
|
||
getrlimit (RLIMIT_STACK, &rlim);
|
||
rlim.rlim_cur = rlim.rlim_max;
|
||
setrlimit (RLIMIT_STACK, &rlim);
|
||
}
|
||
#endif
|
||
|
||
#ifdef SIGPIPE
|
||
signal (SIGPIPE, pipe_closed);
|
||
#endif
|
||
|
||
#ifdef HAVE_LC_MESSAGES
|
||
setlocale (LC_MESSAGES, "");
|
||
#endif
|
||
(void) bindtextdomain (PACKAGE, localedir);
|
||
(void) textdomain (PACKAGE);
|
||
|
||
progname = base_name (argv[0]);
|
||
|
||
#ifdef VMS
|
||
{
|
||
/* Remove extension from PROGNAME. */
|
||
char *p;
|
||
char *s = progname = xstrdup (progname);
|
||
|
||
if ((p = rindex (s, ';')) != 0) *p = '\0'; /* strip version number */
|
||
if ((p = rindex (s, '.')) != 0 /* strip type iff ".exe" */
|
||
&& (p[1] == 'e' || p[1] == 'E')
|
||
&& (p[2] == 'x' || p[2] == 'X')
|
||
&& (p[3] == 'e' || p[3] == 'E')
|
||
&& !p[4])
|
||
*p = '\0';
|
||
}
|
||
#endif
|
||
|
||
/* Do not invoke xmalloc before this point, since locale and
|
||
progname need to be set first, in case a diagnostic is issued. */
|
||
|
||
pend_files = (char **) xmalloc (argc * sizeof (char *));
|
||
pend_defs = (char **) xmalloc (argc * sizeof (char *));
|
||
pend_undefs = (char **) xmalloc (argc * sizeof (char *));
|
||
pend_assertions = (char **) xmalloc (argc * sizeof (char *));
|
||
pend_includes = (char **) xmalloc (argc * sizeof (char *));
|
||
pend_assertion_options = (char **) xmalloc (argc * sizeof (char *));
|
||
|
||
in_fname = NULL;
|
||
out_fname = NULL;
|
||
|
||
/* Initialize is_idchar. */
|
||
initialize_char_syntax ();
|
||
|
||
no_line_directives = 0;
|
||
no_trigraphs = 1;
|
||
dump_macros = dump_none;
|
||
no_output = 0;
|
||
cplusplus = 0;
|
||
cplusplus_comments = 1;
|
||
|
||
bzero ((char *) pend_files, argc * sizeof (char *));
|
||
bzero ((char *) pend_defs, argc * sizeof (char *));
|
||
bzero ((char *) pend_undefs, argc * sizeof (char *));
|
||
bzero ((char *) pend_assertions, argc * sizeof (char *));
|
||
bzero ((char *) pend_includes, argc * sizeof (char *));
|
||
|
||
#ifdef MULTIBYTE_CHARS
|
||
/* Change to the native locale for multibyte conversions. */
|
||
setlocale (LC_CTYPE, "");
|
||
literal_codeset = getenv ("LANG");
|
||
#endif
|
||
|
||
/* Process switches and find input file name. */
|
||
|
||
for (i = 1; i < argc; i++) {
|
||
if (argv[i][0] != '-') {
|
||
if (out_fname != NULL)
|
||
{
|
||
print_help ();
|
||
fatal ("Too many arguments");
|
||
}
|
||
else if (in_fname != NULL)
|
||
out_fname = argv[i];
|
||
else
|
||
in_fname = argv[i];
|
||
} else {
|
||
switch (argv[i][1]) {
|
||
|
||
case 'i':
|
||
if (!strcmp (argv[i], "-include")) {
|
||
int temp = i;
|
||
|
||
if (i + 1 == argc)
|
||
fatal ("Filename missing after `-include' option");
|
||
else
|
||
simplify_filename (pend_includes[temp] = argv[++i]);
|
||
}
|
||
if (!strcmp (argv[i], "-imacros")) {
|
||
int temp = i;
|
||
|
||
if (i + 1 == argc)
|
||
fatal ("Filename missing after `-imacros' option");
|
||
else
|
||
simplify_filename (pend_files[temp] = argv[++i]);
|
||
}
|
||
if (!strcmp (argv[i], "-iprefix")) {
|
||
if (i + 1 == argc)
|
||
fatal ("Filename missing after `-iprefix' option");
|
||
else
|
||
include_prefix = argv[++i];
|
||
}
|
||
if (!strcmp (argv[i], "-ifoutput")) {
|
||
output_conditionals = 1;
|
||
}
|
||
if (!strcmp (argv[i], "-isystem")) {
|
||
struct file_name_list *dirtmp;
|
||
|
||
if (! (dirtmp = new_include_prefix (NULL_PTR, NULL_PTR,
|
||
"", argv[++i])))
|
||
break;
|
||
dirtmp->c_system_include_path = 1;
|
||
|
||
if (before_system == 0)
|
||
before_system = dirtmp;
|
||
else
|
||
last_before_system->next = dirtmp;
|
||
last_before_system = dirtmp; /* Tail follows the last one */
|
||
}
|
||
/* Add directory to end of path for includes,
|
||
with the default prefix at the front of its name. */
|
||
if (!strcmp (argv[i], "-iwithprefix")) {
|
||
struct file_name_list *dirtmp;
|
||
char *prefix;
|
||
|
||
if (include_prefix != 0)
|
||
prefix = include_prefix;
|
||
else {
|
||
prefix = xstrdup (GCC_INCLUDE_DIR);
|
||
/* Remove the `include' from /usr/local/lib/gcc.../include. */
|
||
if (!strcmp (prefix + strlen (prefix) - 8, "/include"))
|
||
prefix[strlen (prefix) - 7] = 0;
|
||
}
|
||
|
||
if (! (dirtmp = new_include_prefix (NULL_PTR, NULL_PTR,
|
||
prefix, argv[++i])))
|
||
break;
|
||
|
||
if (after_include == 0)
|
||
after_include = dirtmp;
|
||
else
|
||
last_after_include->next = dirtmp;
|
||
last_after_include = dirtmp; /* Tail follows the last one */
|
||
}
|
||
/* Add directory to main path for includes,
|
||
with the default prefix at the front of its name. */
|
||
if (!strcmp (argv[i], "-iwithprefixbefore")) {
|
||
struct file_name_list *dirtmp;
|
||
char *prefix;
|
||
|
||
if (include_prefix != 0)
|
||
prefix = include_prefix;
|
||
else {
|
||
prefix = xstrdup (GCC_INCLUDE_DIR);
|
||
/* Remove the `include' from /usr/local/lib/gcc.../include. */
|
||
if (!strcmp (prefix + strlen (prefix) - 8, "/include"))
|
||
prefix[strlen (prefix) - 7] = 0;
|
||
}
|
||
|
||
dirtmp = new_include_prefix (NULL_PTR, NULL_PTR, prefix, argv[++i]);
|
||
append_include_chain (dirtmp, dirtmp);
|
||
}
|
||
/* Add directory to end of path for includes. */
|
||
if (!strcmp (argv[i], "-idirafter")) {
|
||
struct file_name_list *dirtmp;
|
||
|
||
if (! (dirtmp = new_include_prefix (NULL_PTR, NULL_PTR,
|
||
"", argv[++i])))
|
||
break;
|
||
|
||
if (after_include == 0)
|
||
after_include = dirtmp;
|
||
else
|
||
last_after_include->next = dirtmp;
|
||
last_after_include = dirtmp; /* Tail follows the last one */
|
||
}
|
||
break;
|
||
|
||
case 'o':
|
||
if (out_fname != NULL)
|
||
fatal ("Output filename specified twice");
|
||
if (i + 1 == argc)
|
||
fatal ("Filename missing after -o option");
|
||
out_fname = argv[++i];
|
||
if (!strcmp (out_fname, "-"))
|
||
out_fname = "";
|
||
break;
|
||
|
||
case 'p':
|
||
if (!strcmp (argv[i], "-pedantic"))
|
||
pedantic = 1;
|
||
else if (!strcmp (argv[i], "-pedantic-errors")) {
|
||
pedantic = 1;
|
||
pedantic_errors = 1;
|
||
} else if (!strcmp (argv[i], "-pcp")) {
|
||
char *pcp_fname;
|
||
if (i + 1 == argc)
|
||
fatal ("Filename missing after -pcp option");
|
||
pcp_fname = argv[++i];
|
||
pcp_outfile
|
||
= ((pcp_fname[0] != '-' || pcp_fname[1] != '\0')
|
||
? fopen (pcp_fname, "w")
|
||
: stdout);
|
||
if (pcp_outfile == 0)
|
||
pfatal_with_name (pcp_fname);
|
||
no_precomp = 1;
|
||
}
|
||
break;
|
||
|
||
case 't':
|
||
if (!strcmp (argv[i], "-traditional")) {
|
||
traditional = 1;
|
||
cplusplus_comments = 0;
|
||
} else if (!strcmp (argv[i], "-trigraphs")) {
|
||
no_trigraphs = 0;
|
||
}
|
||
break;
|
||
|
||
case 'l':
|
||
if (! strcmp (argv[i], "-lang-c"))
|
||
cplusplus = 0, cplusplus_comments = 1, c89 = 0, c9x = 1, objc = 0;
|
||
else if (! strcmp (argv[i], "-lang-c89"))
|
||
cplusplus = 0, cplusplus_comments = 0, c89 = 1, c9x = 0, objc = 0;
|
||
else if (! strcmp (argv[i], "-lang-c++"))
|
||
cplusplus = 1, cplusplus_comments = 1, c89 = 0, c9x = 0, objc = 0;
|
||
else if (! strcmp (argv[i], "-lang-objc"))
|
||
cplusplus = 0, cplusplus_comments = 1, c89 = 0, c9x = 0, objc = 1;
|
||
else if (! strcmp (argv[i], "-lang-objc++"))
|
||
cplusplus = 1, cplusplus_comments = 1, c89 = 0, c9x = 0, objc = 1;
|
||
else if (! strcmp (argv[i], "-lang-asm"))
|
||
lang_asm = 1;
|
||
else if (! strcmp (argv[i], "-lint"))
|
||
for_lint = 1;
|
||
break;
|
||
|
||
case '+':
|
||
cplusplus = 1, cplusplus_comments = 1;
|
||
break;
|
||
|
||
case 's':
|
||
if (!strcmp (argv[i], "-std=iso9899:1990")
|
||
|| !strcmp (argv[i], "-std=iso9899:199409")
|
||
|| !strcmp (argv[i], "-std=c89")
|
||
|| !strcmp (argv[i], "-std=gnu89"))
|
||
cplusplus = 0, cplusplus_comments = 0, c89 = 1, c9x = 0, objc = 0;
|
||
else if (!strcmp (argv[i], "-std=iso9899:199x")
|
||
|| !strcmp (argv[i], "-std=c9x")
|
||
|| !strcmp (argv[i], "-std=gnu9x"))
|
||
cplusplus = 0, cplusplus_comments = 1, c89 = 0, c9x = 1, objc = 0;
|
||
break;
|
||
|
||
case 'w':
|
||
inhibit_warnings = 1;
|
||
break;
|
||
|
||
case 'W':
|
||
if (!strcmp (argv[i], "-Wtrigraphs"))
|
||
warn_trigraphs = 1;
|
||
else if (!strcmp (argv[i], "-Wno-trigraphs"))
|
||
warn_trigraphs = 0;
|
||
else if (!strcmp (argv[i], "-Wcomment"))
|
||
warn_comments = 1;
|
||
else if (!strcmp (argv[i], "-Wno-comment"))
|
||
warn_comments = 0;
|
||
else if (!strcmp (argv[i], "-Wcomments"))
|
||
warn_comments = 1;
|
||
else if (!strcmp (argv[i], "-Wno-comments"))
|
||
warn_comments = 0;
|
||
else if (!strcmp (argv[i], "-Wtraditional"))
|
||
warn_stringify = 1;
|
||
else if (!strcmp (argv[i], "-Wno-traditional"))
|
||
warn_stringify = 0;
|
||
else if (!strcmp (argv[i], "-Wundef"))
|
||
warn_undef = 1;
|
||
else if (!strcmp (argv[i], "-Wno-undef"))
|
||
warn_undef = 0;
|
||
else if (!strcmp (argv[i], "-Wimport"))
|
||
warn_import = 1;
|
||
else if (!strcmp (argv[i], "-Wno-import"))
|
||
warn_import = 0;
|
||
else if (!strcmp (argv[i], "-Werror"))
|
||
warnings_are_errors = 1;
|
||
else if (!strcmp (argv[i], "-Wno-error"))
|
||
warnings_are_errors = 0;
|
||
else if (!strcmp (argv[i], "-Wall"))
|
||
{
|
||
warn_trigraphs = 1;
|
||
warn_comments = 1;
|
||
}
|
||
break;
|
||
|
||
case 'f':
|
||
if (!strcmp (argv[i], "-fleading-underscore"))
|
||
user_label_prefix = "_";
|
||
else if (!strcmp (argv[i], "-fno-leading-underscore"))
|
||
user_label_prefix = "";
|
||
break;
|
||
|
||
case 'M':
|
||
/* The style of the choices here is a bit mixed.
|
||
The chosen scheme is a hybrid of keeping all options in one string
|
||
and specifying each option in a separate argument:
|
||
-M|-MM|-MD file|-MMD file [-MG]. An alternative is:
|
||
-M|-MM|-MD file|-MMD file|-MG|-MMG; or more concisely:
|
||
-M[M][G][D file]. This is awkward to handle in specs, and is not
|
||
as extensible. */
|
||
/* ??? -MG must be specified in addition to one of -M or -MM.
|
||
This can be relaxed in the future without breaking anything.
|
||
The converse isn't true. */
|
||
|
||
/* -MG isn't valid with -MD or -MMD. This is checked for later. */
|
||
if (!strcmp (argv[i], "-MG"))
|
||
{
|
||
print_deps_missing_files = 1;
|
||
break;
|
||
}
|
||
if (!strcmp (argv[i], "-M"))
|
||
print_deps = 2;
|
||
else if (!strcmp (argv[i], "-MM"))
|
||
print_deps = 1;
|
||
else if (!strcmp (argv[i], "-MD"))
|
||
print_deps = 2;
|
||
else if (!strcmp (argv[i], "-MMD"))
|
||
print_deps = 1;
|
||
/* For -MD and -MMD options, write deps on file named by next arg. */
|
||
if (!strcmp (argv[i], "-MD")
|
||
|| !strcmp (argv[i], "-MMD")) {
|
||
if (i + 1 == argc)
|
||
fatal ("Filename missing after %s option", argv[i]);
|
||
i++;
|
||
deps_file = argv[i];
|
||
deps_mode = "w";
|
||
} else {
|
||
/* For -M and -MM, write deps on standard output
|
||
and suppress the usual output. */
|
||
deps_stream = stdout;
|
||
inhibit_output = 1;
|
||
}
|
||
break;
|
||
|
||
case 'd':
|
||
{
|
||
char *p = argv[i] + 2;
|
||
char c;
|
||
while ((c = *p++)) {
|
||
/* Arg to -d specifies what parts of macros to dump */
|
||
switch (c) {
|
||
case 'M':
|
||
dump_macros = dump_only;
|
||
no_output = 1;
|
||
break;
|
||
case 'N':
|
||
dump_macros = dump_names;
|
||
break;
|
||
case 'D':
|
||
dump_macros = dump_definitions;
|
||
break;
|
||
case 'I':
|
||
dump_includes = 1;
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
break;
|
||
|
||
case 'g':
|
||
if (argv[i][2] == '3')
|
||
debug_output = 1;
|
||
break;
|
||
|
||
case '-':
|
||
if (strcmp (argv[i], "--help") != 0)
|
||
return i;
|
||
print_help ();
|
||
exit (0);
|
||
break;
|
||
|
||
case 'v':
|
||
notice ("GNU CPP version %s", version_string);
|
||
#ifdef TARGET_VERSION
|
||
TARGET_VERSION;
|
||
#endif
|
||
fprintf (stderr, "\n");
|
||
verbose = 1;
|
||
break;
|
||
|
||
case 'H':
|
||
print_include_names = 1;
|
||
break;
|
||
|
||
case 'D':
|
||
if (argv[i][2] != 0)
|
||
pend_defs[i] = argv[i] + 2;
|
||
else if (i + 1 == argc)
|
||
fatal ("Macro name missing after -D option");
|
||
else
|
||
i++, pend_defs[i] = argv[i];
|
||
break;
|
||
|
||
case 'A':
|
||
{
|
||
char *p;
|
||
|
||
if (argv[i][2] != 0)
|
||
p = argv[i] + 2;
|
||
else if (i + 1 == argc)
|
||
fatal ("Assertion missing after -A option");
|
||
else
|
||
p = argv[++i];
|
||
|
||
if (!strcmp (p, "-")) {
|
||
/* -A- eliminates all predefined macros and assertions.
|
||
Let's include also any that were specified earlier
|
||
on the command line. That way we can get rid of any
|
||
that were passed automatically in from GCC. */
|
||
int j;
|
||
for (j = 0; j < i; j++)
|
||
pend_defs[j] = pend_assertions[j] = 0;
|
||
} else {
|
||
pend_assertions[i] = p;
|
||
pend_assertion_options[i] = "-A";
|
||
}
|
||
}
|
||
break;
|
||
|
||
case 'U': /* JF #undef something */
|
||
if (argv[i][2] != 0)
|
||
pend_undefs[i] = argv[i] + 2;
|
||
else if (i + 1 == argc)
|
||
fatal ("Macro name missing after -U option");
|
||
else
|
||
pend_undefs[i] = argv[i+1], i++;
|
||
break;
|
||
|
||
case 'C':
|
||
put_out_comments = 1;
|
||
break;
|
||
|
||
case 'E': /* -E comes from cc -E; ignore it. */
|
||
break;
|
||
|
||
case 'P':
|
||
no_line_directives = 1;
|
||
break;
|
||
|
||
case '$': /* Don't include $ in identifiers. */
|
||
is_idchar['$'] = is_idstart['$'] = 0;
|
||
break;
|
||
|
||
case 'I': /* Add directory to path for includes. */
|
||
{
|
||
struct file_name_list *dirtmp;
|
||
|
||
if (! ignore_srcdir && !strcmp (argv[i] + 2, "-")) {
|
||
ignore_srcdir = 1;
|
||
/* Don't use any preceding -I directories for #include <...>. */
|
||
first_bracket_include = 0;
|
||
}
|
||
else {
|
||
dirtmp = new_include_prefix (last_include, NULL_PTR, "",
|
||
argv[i][2] ? argv[i] + 2 : argv[++i]);
|
||
append_include_chain (dirtmp, dirtmp);
|
||
}
|
||
}
|
||
break;
|
||
|
||
case 'n':
|
||
if (!strcmp (argv[i], "-nostdinc"))
|
||
/* -nostdinc causes no default include directories.
|
||
You must specify all include-file directories with -I. */
|
||
no_standard_includes = 1;
|
||
else if (!strcmp (argv[i], "-nostdinc++"))
|
||
/* -nostdinc++ causes no default C++-specific include directories. */
|
||
no_standard_cplusplus_includes = 1;
|
||
else if (!strcmp (argv[i], "-noprecomp"))
|
||
no_precomp = 1;
|
||
break;
|
||
|
||
case 'r':
|
||
if (!strcmp (argv[i], "-remap"))
|
||
remap = 1;
|
||
break;
|
||
|
||
case '\0': /* JF handle '-' as file name meaning stdin or stdout */
|
||
if (in_fname == NULL) {
|
||
in_fname = "";
|
||
break;
|
||
} else if (out_fname == NULL) {
|
||
out_fname = "";
|
||
break;
|
||
} /* else fall through into error */
|
||
|
||
default:
|
||
fatal ("Invalid option `%s'", argv[i]);
|
||
}
|
||
}
|
||
}
|
||
|
||
/* Add dirs from CPATH after dirs from -I. */
|
||
/* There seems to be confusion about what CPATH should do,
|
||
so for the moment it is not documented. */
|
||
/* Some people say that CPATH should replace the standard include dirs,
|
||
but that seems pointless: it comes before them, so it overrides them
|
||
anyway. */
|
||
GET_ENV_PATH_LIST (cp, "CPATH");
|
||
if (cp && ! no_standard_includes)
|
||
path_include (cp);
|
||
|
||
/* Initialize output buffer */
|
||
|
||
outbuf.buf = (U_CHAR *) xmalloc (OUTBUF_SIZE);
|
||
outbuf.bufp = outbuf.buf;
|
||
outbuf.length = OUTBUF_SIZE;
|
||
|
||
/* Do partial setup of input buffer for the sake of generating
|
||
early #line directives (when -g is in effect). */
|
||
|
||
fp = &instack[++indepth];
|
||
if (in_fname == NULL)
|
||
in_fname = "";
|
||
fp->nominal_fname = fp->fname = in_fname;
|
||
fp->nominal_fname_len = strlen (in_fname);
|
||
fp->lineno = 0;
|
||
|
||
/* In C++, wchar_t is a distinct basic type, and we can expect
|
||
__wchar_t to be defined by cc1plus. */
|
||
if (cplusplus)
|
||
wchar_type = "__wchar_t";
|
||
|
||
/* Install __LINE__, etc. Must follow initialize_char_syntax
|
||
and option processing. */
|
||
initialize_builtins (fp, &outbuf);
|
||
|
||
/* Now handle the command line options. */
|
||
|
||
/* Do -U's, -D's and -A's in the order they were seen. */
|
||
for (i = 1; i < argc; i++) {
|
||
if (pend_undefs[i]) {
|
||
if (debug_output)
|
||
output_line_directive (fp, &outbuf, 0, same_file);
|
||
make_undef (pend_undefs[i], &outbuf);
|
||
}
|
||
if (pend_defs[i]) {
|
||
if (debug_output)
|
||
output_line_directive (fp, &outbuf, 0, same_file);
|
||
make_definition (pend_defs[i]);
|
||
}
|
||
if (pend_assertions[i])
|
||
make_assertion (pend_assertion_options[i], pend_assertions[i]);
|
||
}
|
||
|
||
done_initializing = 1;
|
||
|
||
{ /* Read the appropriate environment variable and if it exists
|
||
replace include_defaults with the listed path. */
|
||
char *epath = 0;
|
||
switch ((objc << 1) + cplusplus)
|
||
{
|
||
case 0:
|
||
GET_ENV_PATH_LIST (epath, "C_INCLUDE_PATH");
|
||
break;
|
||
case 1:
|
||
GET_ENV_PATH_LIST (epath, "CPLUS_INCLUDE_PATH");
|
||
break;
|
||
case 2:
|
||
GET_ENV_PATH_LIST (epath, "OBJC_INCLUDE_PATH");
|
||
break;
|
||
case 3:
|
||
GET_ENV_PATH_LIST (epath, "OBJCPLUS_INCLUDE_PATH");
|
||
break;
|
||
}
|
||
/* If the environment var for this language is set,
|
||
add to the default list of include directories. */
|
||
if (epath) {
|
||
int num_dirs;
|
||
char *startp, *endp;
|
||
|
||
for (num_dirs = 1, startp = epath; *startp; startp++)
|
||
if (*startp == PATH_SEPARATOR)
|
||
num_dirs++;
|
||
include_defaults
|
||
= (struct default_include *) xmalloc ((num_dirs
|
||
* sizeof (struct default_include))
|
||
+ sizeof (include_defaults_array));
|
||
startp = endp = epath;
|
||
num_dirs = 0;
|
||
while (1) {
|
||
char c = *endp++;
|
||
if (c == PATH_SEPARATOR || !c) {
|
||
endp[-1] = 0;
|
||
include_defaults[num_dirs].fname
|
||
= startp == endp ? "." : xstrdup (startp);
|
||
endp[-1] = c;
|
||
include_defaults[num_dirs].component = 0;
|
||
include_defaults[num_dirs].cplusplus = cplusplus;
|
||
include_defaults[num_dirs].cxx_aware = 1;
|
||
num_dirs++;
|
||
if (!c)
|
||
break;
|
||
startp = endp;
|
||
}
|
||
}
|
||
/* Put the usual defaults back in at the end. */
|
||
bcopy ((char *) include_defaults_array,
|
||
(char *) &include_defaults[num_dirs],
|
||
sizeof (include_defaults_array));
|
||
}
|
||
}
|
||
|
||
append_include_chain (before_system, last_before_system);
|
||
first_system_include = before_system;
|
||
|
||
/* Unless -fnostdinc,
|
||
tack on the standard include file dirs to the specified list */
|
||
if (!no_standard_includes) {
|
||
struct default_include *p = include_defaults;
|
||
char *specd_prefix = include_prefix;
|
||
char *default_prefix = xstrdup (GCC_INCLUDE_DIR);
|
||
int default_len = 0;
|
||
/* Remove the `include' from /usr/local/lib/gcc.../include. */
|
||
if (!strcmp (default_prefix + strlen (default_prefix) - 8, "/include")) {
|
||
default_len = strlen (default_prefix) - 7;
|
||
default_prefix[default_len] = 0;
|
||
}
|
||
/* Search "translated" versions of GNU directories.
|
||
These have /usr/local/lib/gcc... replaced by specd_prefix. */
|
||
if (specd_prefix != 0 && default_len != 0)
|
||
for (p = include_defaults; p->fname; p++) {
|
||
/* Some standard dirs are only for C++. */
|
||
if (!p->cplusplus || (cplusplus && !no_standard_cplusplus_includes)) {
|
||
/* Does this dir start with the prefix? */
|
||
if (!strncmp (p->fname, default_prefix, default_len)) {
|
||
/* Yes; change prefix and add to search list. */
|
||
struct file_name_list *new
|
||
= new_include_prefix (NULL_PTR, NULL_PTR, specd_prefix,
|
||
p->fname + default_len);
|
||
if (new) {
|
||
new->c_system_include_path = !p->cxx_aware;
|
||
append_include_chain (new, new);
|
||
if (first_system_include == 0)
|
||
first_system_include = new;
|
||
p->included = 1;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
/* Search ordinary names for GNU include directories. */
|
||
for (p = include_defaults; p->fname; p++) {
|
||
/* Some standard dirs are only for C++. */
|
||
if (!p->cplusplus || (cplusplus && !no_standard_cplusplus_includes)) {
|
||
struct file_name_list *new
|
||
= new_include_prefix (NULL_PTR, p->component, "", p->fname);
|
||
if (new) {
|
||
new->c_system_include_path = !p->cxx_aware;
|
||
append_include_chain (new, new);
|
||
if (first_system_include == 0)
|
||
first_system_include = new;
|
||
p->included = 1;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
/* Tack the after_include chain at the end of the include chain. */
|
||
append_include_chain (after_include, last_after_include);
|
||
if (first_system_include == 0)
|
||
first_system_include = after_include;
|
||
|
||
/* With -v, print the list of dirs to search. */
|
||
if (verbose) {
|
||
struct file_name_list *p;
|
||
notice ("#include \"...\" search starts here:\n");
|
||
for (p = include; p; p = p->next) {
|
||
if (p == first_bracket_include)
|
||
notice ("#include <...> search starts here:\n");
|
||
if (!p->fname[0])
|
||
fprintf (stderr, " .\n");
|
||
else if (!strcmp (p->fname, "/") || !strcmp (p->fname, "//"))
|
||
fprintf (stderr, " %s\n", p->fname);
|
||
else
|
||
/* Omit trailing '/'. */
|
||
fprintf (stderr, " %.*s\n", (int) strlen (p->fname) - 1, p->fname);
|
||
}
|
||
notice ("End of search list.\n");
|
||
{
|
||
struct default_include * d;
|
||
notice ("The following default directories have been omitted from the search path:\n");
|
||
for (d = include_defaults; d->fname; d++)
|
||
if (! d->included)
|
||
fprintf (stderr, " %s\n", d->fname);
|
||
notice ("End of omitted list.\n");
|
||
}
|
||
}
|
||
|
||
/* -MG doesn't select the form of output and must be specified with one of
|
||
-M or -MM. -MG doesn't make sense with -MD or -MMD since they don't
|
||
inhibit compilation. */
|
||
if (print_deps_missing_files && (print_deps == 0 || !inhibit_output))
|
||
fatal ("-MG must be specified with one of -M or -MM");
|
||
|
||
/* Either of two environment variables can specify output of deps.
|
||
Its value is either "OUTPUT_FILE" or "OUTPUT_FILE DEPS_TARGET",
|
||
where OUTPUT_FILE is the file to write deps info to
|
||
and DEPS_TARGET is the target to mention in the deps. */
|
||
|
||
if (print_deps == 0
|
||
&& (getenv ("SUNPRO_DEPENDENCIES") != 0
|
||
|| getenv ("DEPENDENCIES_OUTPUT") != 0)) {
|
||
char *spec = getenv ("DEPENDENCIES_OUTPUT");
|
||
char *s;
|
||
char *output_file;
|
||
|
||
if (spec == 0) {
|
||
spec = getenv ("SUNPRO_DEPENDENCIES");
|
||
print_deps = 2;
|
||
}
|
||
else
|
||
print_deps = 1;
|
||
|
||
s = spec;
|
||
/* Find the space before the DEPS_TARGET, if there is one. */
|
||
/* This should use index. (mrs) */
|
||
while (*s != 0 && *s != ' ') s++;
|
||
if (*s != 0) {
|
||
deps_target = s + 1;
|
||
output_file = xmalloc (s - spec + 1);
|
||
bcopy (spec, output_file, s - spec);
|
||
output_file[s - spec] = 0;
|
||
}
|
||
else {
|
||
deps_target = 0;
|
||
output_file = spec;
|
||
}
|
||
|
||
deps_file = output_file;
|
||
deps_mode = "a";
|
||
}
|
||
|
||
/* For -M, print the expected object file name
|
||
as the target of this Make-rule. */
|
||
if (print_deps) {
|
||
deps_allocated_size = 200;
|
||
deps_buffer = xmalloc (deps_allocated_size);
|
||
deps_buffer[0] = 0;
|
||
deps_size = 0;
|
||
deps_column = 0;
|
||
|
||
if (deps_target) {
|
||
deps_output (deps_target, ':');
|
||
} else if (*in_fname == 0) {
|
||
deps_output ("-", ':');
|
||
} else {
|
||
char *p, *q;
|
||
int len;
|
||
|
||
q = base_name (in_fname);
|
||
|
||
/* Copy remainder to mungable area. */
|
||
p = (char *) alloca (strlen(q) + 8);
|
||
strcpy (p, q);
|
||
|
||
/* Output P, but remove known suffixes. */
|
||
len = strlen (p);
|
||
q = p + len;
|
||
if (len >= 2
|
||
&& p[len - 2] == '.'
|
||
&& index("cCsSm", p[len - 1]))
|
||
q = p + (len - 2);
|
||
else if (len >= 3
|
||
&& p[len - 3] == '.'
|
||
&& p[len - 2] == 'c'
|
||
&& p[len - 1] == 'c')
|
||
q = p + (len - 3);
|
||
else if (len >= 4
|
||
&& p[len - 4] == '.'
|
||
&& p[len - 3] == 'c'
|
||
&& p[len - 2] == 'x'
|
||
&& p[len - 1] == 'x')
|
||
q = p + (len - 4);
|
||
else if (len >= 4
|
||
&& p[len - 4] == '.'
|
||
&& p[len - 3] == 'c'
|
||
&& p[len - 2] == 'p'
|
||
&& p[len - 1] == 'p')
|
||
q = p + (len - 4);
|
||
|
||
/* Supply our own suffix. */
|
||
strcpy (q, OBJECT_SUFFIX);
|
||
|
||
deps_output (p, ':');
|
||
deps_output (in_fname, ' ');
|
||
}
|
||
}
|
||
|
||
/* Scan the -imacros files before the main input.
|
||
Much like #including them, but with no_output set
|
||
so that only their macro definitions matter. */
|
||
|
||
no_output++; no_record_file++;
|
||
for (i = 1; i < argc; i++)
|
||
if (pend_files[i]) {
|
||
struct include_file *inc;
|
||
int fd = open_include_file (pend_files[i], NULL_PTR, NULL_PTR, &inc);
|
||
if (fd < 0) {
|
||
perror_with_name (pend_files[i]);
|
||
return FATAL_EXIT_CODE;
|
||
}
|
||
finclude (fd, inc, &outbuf, 0, NULL_PTR);
|
||
}
|
||
no_output--; no_record_file--;
|
||
|
||
/* Copy the entire contents of the main input file into
|
||
the stacked input buffer previously allocated for it. */
|
||
|
||
/* JF check for stdin */
|
||
if (in_fname == NULL || *in_fname == 0) {
|
||
in_fname = "";
|
||
f = 0;
|
||
} else if ((f = open (in_fname, O_RDONLY, 0666)) < 0)
|
||
goto perror;
|
||
|
||
if (fstat (f, &st) != 0)
|
||
pfatal_with_name (in_fname);
|
||
fp->nominal_fname = fp->fname = in_fname;
|
||
fp->nominal_fname_len = strlen (in_fname);
|
||
fp->lineno = 1;
|
||
fp->system_header_p = 0;
|
||
/* JF all this is mine about reading pipes and ttys */
|
||
if (! S_ISREG (st.st_mode)) {
|
||
/* Read input from a file that is not a normal disk file.
|
||
We cannot preallocate a buffer with the correct size,
|
||
so we must read in the file a piece at the time and make it bigger. */
|
||
int size;
|
||
int bsize;
|
||
int cnt;
|
||
|
||
if (S_ISDIR (st.st_mode))
|
||
fatal ("Input file `%s' is a directory", in_fname);
|
||
|
||
bsize = 2000;
|
||
size = 0;
|
||
fp->buf = (U_CHAR *) xmalloc (bsize + 2);
|
||
for (;;) {
|
||
cnt = safe_read (f, (char *) fp->buf + size, bsize - size);
|
||
if (cnt < 0) goto perror; /* error! */
|
||
size += cnt;
|
||
if (size != bsize) break; /* End of file */
|
||
bsize *= 2;
|
||
fp->buf = (U_CHAR *) xrealloc (fp->buf, bsize + 2);
|
||
}
|
||
fp->length = size;
|
||
} else {
|
||
/* Read a file whose size we can determine in advance.
|
||
For the sake of VMS, st.st_size is just an upper bound. */
|
||
size_t s = (size_t) st.st_size;
|
||
if (s != st.st_size || s + 2 < s)
|
||
memory_full ();
|
||
fp->buf = (U_CHAR *) xmalloc (s + 2);
|
||
fp->length = safe_read (f, (char *) fp->buf, s);
|
||
if (fp->length < 0) goto perror;
|
||
}
|
||
fp->bufp = fp->buf;
|
||
fp->if_stack = if_stack;
|
||
|
||
/* Make sure data ends with a newline. And put a null after it. */
|
||
|
||
if ((fp->length > 0 && fp->buf[fp->length - 1] != '\n')
|
||
/* Backslash-newline at end is not good enough. */
|
||
|| (fp->length > 1 && fp->buf[fp->length - 2] == '\\')) {
|
||
fp->buf[fp->length++] = '\n';
|
||
missing_newline = 1;
|
||
}
|
||
fp->buf[fp->length] = '\0';
|
||
|
||
/* Unless inhibited, convert trigraphs in the input. */
|
||
|
||
if (!no_trigraphs)
|
||
trigraph_pcp (fp);
|
||
|
||
/* Now that we know the input file is valid, open the output. */
|
||
|
||
if (!out_fname || !strcmp (out_fname, ""))
|
||
out_fname = "stdout";
|
||
else if (! freopen (out_fname, "w", stdout))
|
||
pfatal_with_name (out_fname);
|
||
|
||
output_line_directive (fp, &outbuf, 0, same_file);
|
||
|
||
/* Scan the -include files before the main input. */
|
||
|
||
no_record_file++;
|
||
for (i = 1; i < argc; i++)
|
||
if (pend_includes[i]) {
|
||
struct include_file *inc;
|
||
int fd = open_include_file (pend_includes[i], NULL_PTR, NULL_PTR, &inc);
|
||
if (fd < 0) {
|
||
perror_with_name (pend_includes[i]);
|
||
return FATAL_EXIT_CODE;
|
||
}
|
||
finclude (fd, inc, &outbuf, 0, NULL_PTR);
|
||
}
|
||
no_record_file--;
|
||
|
||
/* Scan the input, processing macros and directives. */
|
||
|
||
rescan (&outbuf, 0);
|
||
|
||
if (missing_newline)
|
||
fp->lineno--;
|
||
|
||
if (pedantic && missing_newline)
|
||
pedwarn ("file does not end in newline");
|
||
|
||
/* Now we have processed the entire input
|
||
Write whichever kind of output has been requested. */
|
||
|
||
if (dump_macros == dump_only)
|
||
dump_all_macros ();
|
||
else if (! inhibit_output) {
|
||
write_output ();
|
||
}
|
||
|
||
if (print_deps) {
|
||
/* Don't actually write the deps file if compilation has failed. */
|
||
if (errors == 0) {
|
||
if (deps_file && ! (deps_stream = fopen (deps_file, deps_mode)))
|
||
pfatal_with_name (deps_file);
|
||
fputs (deps_buffer, deps_stream);
|
||
putc ('\n', deps_stream);
|
||
if (deps_file) {
|
||
if (ferror (deps_stream) || fclose (deps_stream) != 0)
|
||
fatal ("I/O error on output");
|
||
}
|
||
}
|
||
}
|
||
|
||
if (pcp_outfile && pcp_outfile != stdout
|
||
&& (ferror (pcp_outfile) || fclose (pcp_outfile) != 0))
|
||
fatal ("I/O error on `-pcp' output");
|
||
|
||
if (ferror (stdout) || fclose (stdout) != 0)
|
||
fatal ("I/O error on output");
|
||
|
||
if (errors)
|
||
exit (FATAL_EXIT_CODE);
|
||
exit (SUCCESS_EXIT_CODE);
|
||
|
||
perror:
|
||
pfatal_with_name (in_fname);
|
||
return 0;
|
||
}
|
||
|
||
/* Given a colon-separated list of file names PATH,
|
||
add all the names to the search path for include files. */
|
||
|
||
static void
|
||
path_include (path)
|
||
char *path;
|
||
{
|
||
char *p;
|
||
|
||
p = path;
|
||
|
||
if (*p)
|
||
while (1) {
|
||
char *q = p;
|
||
char c;
|
||
struct file_name_list *dirtmp;
|
||
|
||
/* Find the end of this name. */
|
||
while ((c = *q++) != PATH_SEPARATOR && c)
|
||
continue;
|
||
|
||
q[-1] = 0;
|
||
dirtmp = new_include_prefix (last_include, NULL_PTR,
|
||
"", p == q ? "." : p);
|
||
q[-1] = c;
|
||
append_include_chain (dirtmp, dirtmp);
|
||
|
||
/* Advance past this name. */
|
||
p = q;
|
||
if (! c)
|
||
break;
|
||
}
|
||
}
|
||
|
||
/* Return the address of the first character in S that equals C.
|
||
S is an array of length N, possibly containing '\0's, and followed by '\0'.
|
||
Return 0 if there is no such character. Assume that C itself is not '\0'.
|
||
If we knew we could use memchr, we could just invoke memchr (S, C, N),
|
||
but unfortunately memchr isn't autoconfigured yet. */
|
||
|
||
static U_CHAR *
|
||
index0 (s, c, n)
|
||
U_CHAR *s;
|
||
int c;
|
||
size_t n;
|
||
{
|
||
char *p = (char *) s;
|
||
for (;;) {
|
||
char *q = index (p, c);
|
||
if (q)
|
||
return (U_CHAR *) q;
|
||
else {
|
||
size_t l = strlen (p);
|
||
if (l == n)
|
||
return 0;
|
||
l++;
|
||
p += l;
|
||
n -= l;
|
||
}
|
||
}
|
||
}
|
||
|
||
/* Pre-C-Preprocessor to translate ANSI trigraph idiocy in BUF
|
||
before main CCCP processing. Name `pcp' is also in honor of the
|
||
drugs the trigraph designers must have been on.
|
||
|
||
Using an extra pass through the buffer takes a little extra time,
|
||
but is infinitely less hairy than trying to handle trigraphs inside
|
||
strings, etc. everywhere, and also makes sure that trigraphs are
|
||
only translated in the top level of processing. */
|
||
|
||
static void
|
||
trigraph_pcp (buf)
|
||
FILE_BUF *buf;
|
||
{
|
||
register U_CHAR c, *fptr, *bptr, *sptr, *lptr;
|
||
int len;
|
||
|
||
fptr = bptr = sptr = buf->buf;
|
||
lptr = fptr + buf->length;
|
||
while ((sptr = index0 (sptr, '?', (size_t) (lptr - sptr))) != NULL) {
|
||
if (*++sptr != '?')
|
||
continue;
|
||
switch (*++sptr) {
|
||
case '=':
|
||
c = '#';
|
||
break;
|
||
case '(':
|
||
c = '[';
|
||
break;
|
||
case '/':
|
||
c = '\\';
|
||
break;
|
||
case ')':
|
||
c = ']';
|
||
break;
|
||
case '\'':
|
||
c = '^';
|
||
break;
|
||
case '<':
|
||
c = '{';
|
||
break;
|
||
case '!':
|
||
c = '|';
|
||
break;
|
||
case '>':
|
||
c = '}';
|
||
break;
|
||
case '-':
|
||
c = '~';
|
||
break;
|
||
case '?':
|
||
sptr--;
|
||
continue;
|
||
default:
|
||
continue;
|
||
}
|
||
len = sptr - fptr - 2;
|
||
|
||
/* BSD doc says bcopy () works right for overlapping strings. In ANSI
|
||
C, this will be memmove (). */
|
||
if (bptr != fptr && len > 0)
|
||
bcopy ((char *) fptr, (char *) bptr, len);
|
||
|
||
bptr += len;
|
||
*bptr++ = c;
|
||
fptr = ++sptr;
|
||
}
|
||
len = buf->length - (fptr - buf->buf);
|
||
if (bptr != fptr && len > 0)
|
||
bcopy ((char *) fptr, (char *) bptr, len);
|
||
buf->length -= fptr - bptr;
|
||
buf->buf[buf->length] = '\0';
|
||
if (warn_trigraphs && fptr != bptr)
|
||
warning_with_line (0, "%lu trigraph(s) encountered",
|
||
(unsigned long) (fptr - bptr) / 2);
|
||
}
|
||
|
||
/* Move all backslash-newline pairs out of embarrassing places.
|
||
Exchange all such pairs following BP
|
||
with any potentially-embarrassing characters that follow them.
|
||
Potentially-embarrassing characters are / and *
|
||
(because a backslash-newline inside a comment delimiter
|
||
would cause it not to be recognized). */
|
||
|
||
static void
|
||
newline_fix (bp)
|
||
U_CHAR *bp;
|
||
{
|
||
register U_CHAR *p = bp;
|
||
|
||
/* First count the backslash-newline pairs here. */
|
||
|
||
while (p[0] == '\\' && p[1] == '\n')
|
||
p += 2;
|
||
|
||
/* What follows the backslash-newlines is not embarrassing. */
|
||
|
||
if (*p != '/' && *p != '*')
|
||
return;
|
||
|
||
/* Copy all potentially embarrassing characters
|
||
that follow the backslash-newline pairs
|
||
down to where the pairs originally started. */
|
||
|
||
while (*p == '*' || *p == '/')
|
||
*bp++ = *p++;
|
||
|
||
/* Now write the same number of pairs after the embarrassing chars. */
|
||
while (bp < p) {
|
||
*bp++ = '\\';
|
||
*bp++ = '\n';
|
||
}
|
||
}
|
||
|
||
/* Like newline_fix but for use within a directive-name.
|
||
Move any backslash-newlines up past any following symbol constituents. */
|
||
|
||
static void
|
||
name_newline_fix (bp)
|
||
U_CHAR *bp;
|
||
{
|
||
register U_CHAR *p = bp;
|
||
|
||
/* First count the backslash-newline pairs here. */
|
||
while (p[0] == '\\' && p[1] == '\n')
|
||
p += 2;
|
||
|
||
/* What follows the backslash-newlines is not embarrassing. */
|
||
|
||
if (!is_idchar[*p])
|
||
return;
|
||
|
||
/* Copy all potentially embarrassing characters
|
||
that follow the backslash-newline pairs
|
||
down to where the pairs originally started. */
|
||
|
||
while (is_idchar[*p])
|
||
*bp++ = *p++;
|
||
|
||
/* Now write the same number of pairs after the embarrassing chars. */
|
||
while (bp < p) {
|
||
*bp++ = '\\';
|
||
*bp++ = '\n';
|
||
}
|
||
}
|
||
|
||
/* Look for lint commands in comments.
|
||
|
||
When we come in here, ibp points into a comment. Limit is as one expects.
|
||
scan within the comment -- it should start, after lwsp, with a lint command.
|
||
If so that command is returned as a (constant) string.
|
||
|
||
Upon return, any arg will be pointed to with argstart and will be
|
||
arglen long. Note that we don't parse that arg since it will just
|
||
be printed out again. */
|
||
|
||
static char *
|
||
get_lintcmd (ibp, limit, argstart, arglen, cmdlen)
|
||
register U_CHAR *ibp;
|
||
register U_CHAR *limit;
|
||
U_CHAR **argstart; /* point to command arg */
|
||
int *arglen, *cmdlen; /* how long they are */
|
||
{
|
||
HOST_WIDEST_INT linsize;
|
||
register U_CHAR *numptr; /* temp for arg parsing */
|
||
|
||
*arglen = 0;
|
||
|
||
SKIP_WHITE_SPACE (ibp);
|
||
|
||
if (ibp >= limit) return NULL;
|
||
|
||
linsize = limit - ibp;
|
||
|
||
/* Oh, I wish C had lexical functions... hell, I'll just open-code the set */
|
||
if ((linsize >= 10) && !bcmp (ibp, "NOTREACHED", 10)) {
|
||
*cmdlen = 10;
|
||
return "NOTREACHED";
|
||
}
|
||
if ((linsize >= 8) && !bcmp (ibp, "ARGSUSED", 8)) {
|
||
*cmdlen = 8;
|
||
return "ARGSUSED";
|
||
}
|
||
if ((linsize >= 11) && !bcmp (ibp, "LINTLIBRARY", 11)) {
|
||
*cmdlen = 11;
|
||
return "LINTLIBRARY";
|
||
}
|
||
if ((linsize >= 7) && !bcmp (ibp, "VARARGS", 7)) {
|
||
*cmdlen = 7;
|
||
ibp += 7; linsize -= 7;
|
||
if ((linsize == 0) || ! ISDIGIT (*ibp)) return "VARARGS";
|
||
|
||
/* OK, read a number */
|
||
for (numptr = *argstart = ibp; (numptr < limit) && ISDIGIT (*numptr);
|
||
numptr++);
|
||
*arglen = numptr - *argstart;
|
||
return "VARARGS";
|
||
}
|
||
return NULL;
|
||
}
|
||
|
||
/*
|
||
* The main loop of the program.
|
||
*
|
||
* Read characters from the input stack, transferring them to the
|
||
* output buffer OP.
|
||
*
|
||
* Macros are expanded and push levels on the input stack.
|
||
* At the end of such a level it is popped off and we keep reading.
|
||
* At the end of any other kind of level, we return.
|
||
* #-directives are handled, except within macros.
|
||
*
|
||
* If OUTPUT_MARKS is nonzero, keep Newline markers found in the input
|
||
* and insert them when appropriate. This is set while scanning macro
|
||
* arguments before substitution. It is zero when scanning for final output.
|
||
* There are three types of Newline markers:
|
||
* * Newline - follows a macro name that was not expanded
|
||
* because it appeared inside an expansion of the same macro.
|
||
* This marker prevents future expansion of that identifier.
|
||
* When the input is rescanned into the final output, these are deleted.
|
||
* These are also deleted by ## concatenation.
|
||
* * Newline Space (or Newline and any other whitespace character)
|
||
* stands for a place that tokens must be separated or whitespace
|
||
* is otherwise desirable, but where the ANSI standard specifies there
|
||
* is no whitespace. This marker turns into a Space (or whichever other
|
||
* whitespace char appears in the marker) in the final output,
|
||
* but it turns into nothing in an argument that is stringified with #.
|
||
* Such stringified arguments are the only place where the ANSI standard
|
||
* specifies with precision that whitespace may not appear.
|
||
*
|
||
* During this function, IP->bufp is kept cached in IBP for speed of access.
|
||
* Likewise, OP->bufp is kept in OBP. Before calling a subroutine
|
||
* IBP, IP and OBP must be copied back to memory. IP and IBP are
|
||
* copied back with the RECACHE macro. OBP must be copied back from OP->bufp
|
||
* explicitly, and before RECACHE, since RECACHE uses OBP.
|
||
*/
|
||
|
||
static void
|
||
rescan (op, output_marks)
|
||
FILE_BUF *op;
|
||
int output_marks;
|
||
{
|
||
/* Character being scanned in main loop. */
|
||
register U_CHAR c;
|
||
|
||
/* Length of pending accumulated identifier. */
|
||
register int ident_length = 0;
|
||
|
||
/* Hash code of pending accumulated identifier. */
|
||
register int hash = 0;
|
||
|
||
/* Current input level (&instack[indepth]). */
|
||
FILE_BUF *ip;
|
||
|
||
/* Pointer for scanning input. */
|
||
register U_CHAR *ibp;
|
||
|
||
/* Pointer to end of input. End of scan is controlled by LIMIT. */
|
||
register U_CHAR *limit;
|
||
|
||
/* Pointer for storing output. */
|
||
register U_CHAR *obp;
|
||
|
||
/* REDO_CHAR is nonzero if we are processing an identifier
|
||
after backing up over the terminating character.
|
||
Sometimes we process an identifier without backing up over
|
||
the terminating character, if the terminating character
|
||
is not special. Backing up is done so that the terminating character
|
||
will be dispatched on again once the identifier is dealt with. */
|
||
int redo_char = 0;
|
||
|
||
/* 1 if within an identifier inside of which a concatenation
|
||
marker (Newline -) has been seen. */
|
||
int concatenated = 0;
|
||
|
||
/* While scanning a comment or a string constant,
|
||
this records the line it started on, for error messages. */
|
||
int start_line;
|
||
|
||
/* Record position of last `real' newline. */
|
||
U_CHAR *beg_of_line;
|
||
|
||
/* Pop the innermost input stack level, assuming it is a macro expansion. */
|
||
|
||
#define POPMACRO \
|
||
do { ip->macro->type = T_MACRO; \
|
||
if (ip->free_ptr) free (ip->free_ptr); \
|
||
--indepth; } while (0)
|
||
|
||
/* Reload `rescan's local variables that describe the current
|
||
level of the input stack. */
|
||
|
||
#define RECACHE \
|
||
do { ip = &instack[indepth]; \
|
||
ibp = ip->bufp; \
|
||
limit = ip->buf + ip->length; \
|
||
op->bufp = obp; \
|
||
check_expand (op, limit - ibp); \
|
||
beg_of_line = 0; \
|
||
obp = op->bufp; } while (0)
|
||
|
||
if (no_output && instack[indepth].fname != 0)
|
||
skip_if_group (&instack[indepth], 1, NULL);
|
||
|
||
obp = op->bufp;
|
||
RECACHE;
|
||
|
||
beg_of_line = ibp;
|
||
|
||
/* Our caller must always put a null after the end of
|
||
the input at each input stack level. */
|
||
if (*limit != 0)
|
||
abort ();
|
||
|
||
while (1) {
|
||
c = *ibp++;
|
||
*obp++ = c;
|
||
|
||
switch (c) {
|
||
case '\\':
|
||
if (*ibp == '\n' && !ip->macro) {
|
||
/* At the top level, always merge lines ending with backslash-newline,
|
||
even in middle of identifier. But do not merge lines in a macro,
|
||
since backslash might be followed by a newline-space marker. */
|
||
++ibp;
|
||
++ip->lineno;
|
||
--obp; /* remove backslash from obuf */
|
||
break;
|
||
}
|
||
/* If ANSI, backslash is just another character outside a string. */
|
||
if (!traditional)
|
||
goto randomchar;
|
||
/* Otherwise, backslash suppresses specialness of following char,
|
||
so copy it here to prevent the switch from seeing it.
|
||
But first get any pending identifier processed. */
|
||
if (ident_length > 0)
|
||
goto specialchar;
|
||
if (ibp < limit)
|
||
*obp++ = *ibp++;
|
||
break;
|
||
|
||
case '%':
|
||
if (ident_length || ip->macro || traditional)
|
||
goto randomchar;
|
||
while (*ibp == '\\' && ibp[1] == '\n') {
|
||
ibp += 2;
|
||
++ip->lineno;
|
||
}
|
||
if (*ibp != ':')
|
||
break;
|
||
/* Treat this %: digraph as if it were #. */
|
||
/* Fall through. */
|
||
|
||
case '#':
|
||
if (assertions_flag) {
|
||
if (ident_length)
|
||
goto specialchar;
|
||
/* Copy #foo (bar lose) without macro expansion. */
|
||
obp[-1] = '#'; /* In case it was '%'. */
|
||
SKIP_WHITE_SPACE (ibp);
|
||
while (is_idchar[*ibp])
|
||
*obp++ = *ibp++;
|
||
SKIP_WHITE_SPACE (ibp);
|
||
if (*ibp == '(') {
|
||
ip->bufp = ibp;
|
||
skip_paren_group (ip);
|
||
bcopy ((char *) ibp, (char *) obp, ip->bufp - ibp);
|
||
obp += ip->bufp - ibp;
|
||
ibp = ip->bufp;
|
||
}
|
||
break;
|
||
}
|
||
|
||
/* If this is expanding a macro definition, don't recognize
|
||
preprocessing directives. */
|
||
if (ip->macro != 0)
|
||
goto randomchar;
|
||
/* If this is expand_into_temp_buffer,
|
||
don't recognize them either. Warn about them
|
||
only after an actual newline at this level,
|
||
not at the beginning of the input level. */
|
||
if (! ip->fname) {
|
||
if (ip->buf != beg_of_line)
|
||
warning ("preprocessing directive not recognized within macro arg");
|
||
goto randomchar;
|
||
}
|
||
if (ident_length)
|
||
goto specialchar;
|
||
|
||
|
||
/* # keyword: a # must be first nonblank char on the line */
|
||
if (beg_of_line == 0)
|
||
goto randomchar;
|
||
{
|
||
U_CHAR *bp;
|
||
|
||
/* Scan from start of line, skipping whitespace, comments
|
||
and backslash-newlines, and see if we reach this #.
|
||
If not, this # is not special. */
|
||
bp = beg_of_line;
|
||
/* If -traditional, require # to be at beginning of line. */
|
||
if (!traditional) {
|
||
while (1) {
|
||
if (is_hor_space[*bp])
|
||
bp++;
|
||
else if (*bp == '\\' && bp[1] == '\n')
|
||
bp += 2;
|
||
else if (*bp == '/' && bp[1] == '*') {
|
||
bp += 2;
|
||
while (1)
|
||
{
|
||
if (*bp == '*')
|
||
{
|
||
if (bp[1] == '/')
|
||
{
|
||
bp += 2;
|
||
break;
|
||
}
|
||
}
|
||
else
|
||
{
|
||
#ifdef MULTIBYTE_CHARS
|
||
int length;
|
||
length = local_mblen (bp, limit - bp);
|
||
if (length > 1)
|
||
bp += (length - 1);
|
||
#endif
|
||
}
|
||
bp++;
|
||
}
|
||
}
|
||
/* There is no point in trying to deal with C++ // comments here,
|
||
because if there is one, then this # must be part of the
|
||
comment and we would never reach here. */
|
||
else break;
|
||
}
|
||
if (c == '%') {
|
||
if (bp[0] != '%')
|
||
break;
|
||
while (bp[1] == '\\' && bp[2] == '\n')
|
||
bp += 2;
|
||
if (bp + 1 != ibp)
|
||
break;
|
||
/* %: appears at start of line; skip past the ':' too. */
|
||
bp++;
|
||
ibp++;
|
||
}
|
||
}
|
||
if (bp + 1 != ibp)
|
||
goto randomchar;
|
||
}
|
||
|
||
/* This # can start a directive. */
|
||
|
||
--obp; /* Don't copy the '#' */
|
||
|
||
ip->bufp = ibp;
|
||
op->bufp = obp;
|
||
if (! handle_directive (ip, op)) {
|
||
#ifdef USE_C_ALLOCA
|
||
alloca (0);
|
||
#endif
|
||
/* Not a known directive: treat it as ordinary text.
|
||
IP, OP, IBP, etc. have not been changed. */
|
||
if (no_output && instack[indepth].fname) {
|
||
/* If not generating expanded output,
|
||
what we do with ordinary text is skip it.
|
||
Discard everything until next # directive. */
|
||
skip_if_group (&instack[indepth], 1, 0);
|
||
RECACHE;
|
||
beg_of_line = ibp;
|
||
break;
|
||
}
|
||
*obp++ = '#'; /* Copy # (even if it was originally %:). */
|
||
/* Don't expand an identifier that could be a macro directive.
|
||
(Section 3.8.3 of the ANSI C standard) */
|
||
SKIP_WHITE_SPACE (ibp);
|
||
if (is_idstart[*ibp])
|
||
{
|
||
*obp++ = *ibp++;
|
||
while (is_idchar[*ibp])
|
||
*obp++ = *ibp++;
|
||
}
|
||
goto randomchar;
|
||
}
|
||
#ifdef USE_C_ALLOCA
|
||
alloca (0);
|
||
#endif
|
||
/* A # directive has been successfully processed. */
|
||
/* If not generating expanded output, ignore everything until
|
||
next # directive. */
|
||
if (no_output && instack[indepth].fname)
|
||
skip_if_group (&instack[indepth], 1, 0);
|
||
obp = op->bufp;
|
||
RECACHE;
|
||
beg_of_line = ibp;
|
||
break;
|
||
|
||
case '\"': /* skip quoted string */
|
||
case '\'':
|
||
/* A single quoted string is treated like a double -- some
|
||
programs (e.g., troff) are perverse this way */
|
||
|
||
/* Handle any pending identifier;
|
||
but the L in L'...' or L"..." is not an identifier. */
|
||
if (ident_length) {
|
||
if (! (ident_length == 1 && hash == HASHSTEP (0, 'L')))
|
||
goto specialchar;
|
||
ident_length = hash = 0;
|
||
}
|
||
|
||
start_line = ip->lineno;
|
||
|
||
/* Skip ahead to a matching quote. */
|
||
|
||
while (1) {
|
||
if (ibp >= limit) {
|
||
if (ip->macro != 0) {
|
||
/* try harder: this string crosses a macro expansion boundary.
|
||
This can happen naturally if -traditional.
|
||
Otherwise, only -D can make a macro with an unmatched quote. */
|
||
POPMACRO;
|
||
RECACHE;
|
||
continue;
|
||
}
|
||
if (!traditional) {
|
||
error_with_line (line_for_error (start_line),
|
||
"unterminated string or character constant");
|
||
if (multiline_string_line) {
|
||
error_with_line (multiline_string_line,
|
||
"possible real start of unterminated constant");
|
||
multiline_string_line = 0;
|
||
}
|
||
}
|
||
break;
|
||
}
|
||
*obp++ = *ibp;
|
||
switch (*ibp++) {
|
||
case '\n':
|
||
++ip->lineno;
|
||
++op->lineno;
|
||
/* Traditionally, end of line ends a string constant with no error.
|
||
So exit the loop and record the new line. */
|
||
if (traditional) {
|
||
beg_of_line = ibp;
|
||
goto while2end;
|
||
}
|
||
if (c == '\'') {
|
||
error_with_line (line_for_error (start_line),
|
||
"unterminated character constant");
|
||
goto while2end;
|
||
}
|
||
if (multiline_string_line == 0) {
|
||
if (pedantic)
|
||
pedwarn_with_line (line_for_error (start_line),
|
||
"string constant runs past end of line");
|
||
multiline_string_line = ip->lineno - 1;
|
||
}
|
||
break;
|
||
|
||
case '\\':
|
||
if (*ibp == '\n') {
|
||
/* Backslash newline is replaced by nothing at all, but
|
||
keep the line counts correct. But if we are reading
|
||
from a macro, keep the backslash newline, since backslash
|
||
newlines have already been processed. */
|
||
if (ip->macro)
|
||
*obp++ = '\n';
|
||
else
|
||
--obp;
|
||
++ibp;
|
||
++ip->lineno;
|
||
} else {
|
||
/* ANSI stupidly requires that in \\ the second \
|
||
is *not* prevented from combining with a newline. */
|
||
if (!ip->macro) {
|
||
while (*ibp == '\\' && ibp[1] == '\n') {
|
||
ibp += 2;
|
||
++ip->lineno;
|
||
}
|
||
}
|
||
*obp++ = *ibp++;
|
||
}
|
||
break;
|
||
|
||
case '\"':
|
||
case '\'':
|
||
if (ibp[-1] == c)
|
||
goto while2end;
|
||
break;
|
||
#ifdef MULTIBYTE_CHARS
|
||
default:
|
||
{
|
||
int length;
|
||
--ibp;
|
||
length = local_mblen (ibp, limit - ibp);
|
||
if (length > 0)
|
||
{
|
||
--obp;
|
||
bcopy (ibp, obp, length);
|
||
obp += length;
|
||
ibp += length;
|
||
}
|
||
else
|
||
++ibp;
|
||
}
|
||
break;
|
||
#endif
|
||
}
|
||
}
|
||
while2end:
|
||
break;
|
||
|
||
case '/':
|
||
if (ip->macro != 0)
|
||
goto randomchar;
|
||
if (*ibp == '\\' && ibp[1] == '\n')
|
||
newline_fix (ibp);
|
||
if (*ibp != '*'
|
||
&& !(cplusplus_comments && *ibp == '/'))
|
||
goto randomchar;
|
||
if (ident_length)
|
||
goto specialchar;
|
||
|
||
if (*ibp == '/') {
|
||
/* C++ style comment... */
|
||
start_line = ip->lineno;
|
||
|
||
/* Comments are equivalent to spaces. */
|
||
if (! put_out_comments)
|
||
obp[-1] = ' ';
|
||
|
||
{
|
||
U_CHAR *before_bp = ibp;
|
||
|
||
while (++ibp < limit) {
|
||
if (*ibp == '\n')
|
||
{
|
||
if (put_out_comments) {
|
||
bcopy ((char *) before_bp, (char *) obp, ibp - before_bp);
|
||
obp += ibp - before_bp;
|
||
}
|
||
break;
|
||
}
|
||
if (*ibp == '\\')
|
||
{
|
||
if (ibp + 1 < limit && ibp[1] == '\n')
|
||
{
|
||
if (warn_comments)
|
||
warning ("multiline `//' comment");
|
||
++ip->lineno;
|
||
/* Copy the newline into the output buffer, in order to
|
||
avoid the pain of a #line every time a multiline comment
|
||
is seen. */
|
||
if (!put_out_comments)
|
||
*obp++ = '\n';
|
||
++op->lineno;
|
||
++ibp;
|
||
}
|
||
}
|
||
else
|
||
{
|
||
#ifdef MULTIBYTE_CHARS
|
||
int length;
|
||
length = local_mblen (ibp, limit - ibp);
|
||
if (length > 1)
|
||
ibp += (length - 1);
|
||
#endif
|
||
}
|
||
}
|
||
break;
|
||
}
|
||
}
|
||
|
||
/* Ordinary C comment. Skip it, optionally copying it to output. */
|
||
|
||
start_line = ip->lineno;
|
||
|
||
++ibp; /* Skip the star. */
|
||
|
||
/* If this cpp is for lint, we peek inside the comments: */
|
||
if (for_lint) {
|
||
U_CHAR *argbp;
|
||
int cmdlen, arglen;
|
||
char *lintcmd = get_lintcmd (ibp, limit, &argbp, &arglen, &cmdlen);
|
||
|
||
if (lintcmd != NULL) {
|
||
op->bufp = obp;
|
||
check_expand (op, cmdlen + arglen + 14);
|
||
obp = op->bufp;
|
||
/* I believe it is always safe to emit this newline: */
|
||
obp[-1] = '\n';
|
||
bcopy ("#pragma lint ", (char *) obp, 13);
|
||
obp += 13;
|
||
bcopy (lintcmd, (char *) obp, cmdlen);
|
||
obp += cmdlen;
|
||
|
||
if (arglen != 0) {
|
||
*(obp++) = ' ';
|
||
bcopy (argbp, (char *) obp, arglen);
|
||
obp += arglen;
|
||
}
|
||
|
||
/* OK, now bring us back to the state we were in before we entered
|
||
this branch. We need #line because the #pragma's newline always
|
||
messes up the line count. */
|
||
op->bufp = obp;
|
||
output_line_directive (ip, op, 0, same_file);
|
||
check_expand (op, limit - ibp + 2);
|
||
obp = op->bufp;
|
||
*(obp++) = '/';
|
||
}
|
||
}
|
||
|
||
/* Comments are equivalent to spaces.
|
||
Note that we already output the slash; we might not want it.
|
||
For -traditional, a comment is equivalent to nothing. */
|
||
if (! put_out_comments) {
|
||
if (traditional)
|
||
obp--;
|
||
else
|
||
obp[-1] = ' ';
|
||
}
|
||
else
|
||
*obp++ = '*';
|
||
|
||
{
|
||
U_CHAR *before_bp = ibp;
|
||
|
||
for (;;) {
|
||
switch (*ibp++) {
|
||
case '*':
|
||
if (ibp[-2] == '/' && warn_comments)
|
||
warning ("`/*' within comment");
|
||
if (*ibp == '\\' && ibp[1] == '\n')
|
||
newline_fix (ibp);
|
||
if (*ibp == '/')
|
||
goto comment_end;
|
||
break;
|
||
|
||
case '\n':
|
||
++ip->lineno;
|
||
/* Copy the newline into the output buffer, in order to
|
||
avoid the pain of a #line every time a multiline comment
|
||
is seen. */
|
||
if (!put_out_comments)
|
||
*obp++ = '\n';
|
||
++op->lineno;
|
||
break;
|
||
|
||
case 0:
|
||
if (limit < ibp) {
|
||
error_with_line (line_for_error (start_line),
|
||
"unterminated comment");
|
||
goto limit_reached;
|
||
}
|
||
break;
|
||
#ifdef MULTIBYTE_CHARS
|
||
default:
|
||
{
|
||
int length;
|
||
length = local_mblen (ibp, limit - ibp);
|
||
if (length > 1)
|
||
ibp += (length - 1);
|
||
}
|
||
break;
|
||
#endif
|
||
}
|
||
}
|
||
comment_end:
|
||
|
||
ibp++;
|
||
if (put_out_comments) {
|
||
bcopy ((char *) before_bp, (char *) obp, ibp - before_bp);
|
||
obp += ibp - before_bp;
|
||
}
|
||
}
|
||
break;
|
||
|
||
case '$':
|
||
if (! is_idchar['$'])
|
||
goto randomchar;
|
||
if (pedantic)
|
||
pedwarn ("`$' in identifier");
|
||
goto letter;
|
||
|
||
case '0': case '1': case '2': case '3': case '4':
|
||
case '5': case '6': case '7': case '8': case '9':
|
||
/* If digit is not part of identifier, it starts a number,
|
||
which means that following letters are not an identifier.
|
||
"0x5" does not refer to an identifier "x5".
|
||
So copy all alphanumerics that follow without accumulating
|
||
as an identifier. Periods also, for sake of "3.e7". */
|
||
|
||
if (ident_length == 0) {
|
||
for (;;) {
|
||
if (!ip->macro) {
|
||
while (ibp[0] == '\\' && ibp[1] == '\n') {
|
||
++ip->lineno;
|
||
ibp += 2;
|
||
}
|
||
}
|
||
c = *ibp++;
|
||
if (!is_idchar[c] && c != '.') {
|
||
--ibp;
|
||
break;
|
||
}
|
||
*obp++ = c;
|
||
/* A sign can be part of a preprocessing number
|
||
if it follows an `e' or `p'. */
|
||
if (c == 'e' || c == 'E' || c == 'p' || c == 'P') {
|
||
if (!ip->macro) {
|
||
while (ibp[0] == '\\' && ibp[1] == '\n') {
|
||
++ip->lineno;
|
||
ibp += 2;
|
||
}
|
||
}
|
||
if (*ibp == '+' || *ibp == '-') {
|
||
*obp++ = *ibp++;
|
||
/* But traditional C does not let the token go past the sign,
|
||
and C89 does not allow `p'. */
|
||
if (traditional || (c89 && (c == 'p' || c == 'P')))
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
break;
|
||
}
|
||
/* fall through */
|
||
|
||
case '_':
|
||
case 'a': case 'b': case 'c': case 'd': case 'e': case 'f':
|
||
case 'g': case 'h': case 'i': case 'j': case 'k': case 'l':
|
||
case 'm': case 'n': case 'o': case 'p': case 'q': case 'r':
|
||
case 's': case 't': case 'u': case 'v': case 'w': case 'x':
|
||
case 'y': case 'z':
|
||
case 'A': case 'B': case 'C': case 'D': case 'E': case 'F':
|
||
case 'G': case 'H': case 'I': case 'J': case 'K': case 'L':
|
||
case 'M': case 'N': case 'O': case 'P': case 'Q': case 'R':
|
||
case 'S': case 'T': case 'U': case 'V': case 'W': case 'X':
|
||
case 'Y': case 'Z':
|
||
letter:
|
||
ident_length++;
|
||
/* Compute step of hash function, to avoid a proc call on every token */
|
||
hash = HASHSTEP (hash, c);
|
||
break;
|
||
|
||
case '\n':
|
||
if (ip->fname == 0 && *ibp == '-') {
|
||
/* Newline - inhibits expansion of preceding token.
|
||
If expanding a macro arg, we keep the newline -.
|
||
In final output, it is deleted.
|
||
We recognize Newline - in macro bodies and macro args. */
|
||
if (! concatenated) {
|
||
ident_length = 0;
|
||
hash = 0;
|
||
}
|
||
ibp++;
|
||
if (!output_marks) {
|
||
obp--;
|
||
} else {
|
||
/* If expanding a macro arg, keep the newline -. */
|
||
*obp++ = '-';
|
||
}
|
||
break;
|
||
}
|
||
|
||
/* If reprocessing a macro expansion, newline is a special marker. */
|
||
else if (ip->macro != 0) {
|
||
/* Newline White is a "funny space" to separate tokens that are
|
||
supposed to be separate but without space between.
|
||
Here White means any whitespace character.
|
||
Newline - marks a recursive macro use that is not
|
||
supposed to be expandable. */
|
||
|
||
if (is_space[*ibp]) {
|
||
/* Newline Space does not prevent expansion of preceding token
|
||
so expand the preceding token and then come back. */
|
||
if (ident_length > 0)
|
||
goto specialchar;
|
||
|
||
/* If generating final output, newline space makes a space. */
|
||
if (!output_marks) {
|
||
obp[-1] = *ibp++;
|
||
/* And Newline Newline makes a newline, so count it. */
|
||
if (obp[-1] == '\n')
|
||
op->lineno++;
|
||
} else {
|
||
/* If expanding a macro arg, keep the newline space.
|
||
If the arg gets stringified, newline space makes nothing. */
|
||
*obp++ = *ibp++;
|
||
}
|
||
} else abort (); /* Newline followed by something random? */
|
||
break;
|
||
}
|
||
|
||
/* If there is a pending identifier, handle it and come back here. */
|
||
if (ident_length > 0)
|
||
goto specialchar;
|
||
|
||
beg_of_line = ibp;
|
||
|
||
/* Update the line counts and output a #line if necessary. */
|
||
++ip->lineno;
|
||
++op->lineno;
|
||
if (ip->lineno != op->lineno) {
|
||
op->bufp = obp;
|
||
output_line_directive (ip, op, 1, same_file);
|
||
check_expand (op, limit - ibp);
|
||
obp = op->bufp;
|
||
}
|
||
break;
|
||
|
||
/* Come here either after (1) a null character that is part of the input
|
||
or (2) at the end of the input, because there is a null there. */
|
||
case 0:
|
||
if (ibp <= limit)
|
||
/* Our input really contains a null character. */
|
||
goto randomchar;
|
||
|
||
limit_reached:
|
||
/* At end of a macro-expansion level, pop it and read next level. */
|
||
if (ip->macro != 0) {
|
||
obp--;
|
||
ibp--;
|
||
/* If traditional, and we have an identifier that ends here,
|
||
process it now, so we get the right error for recursion. */
|
||
if (traditional && ident_length
|
||
&& ! is_idchar[*instack[indepth - 1].bufp]) {
|
||
redo_char = 1;
|
||
goto randomchar;
|
||
}
|
||
POPMACRO;
|
||
RECACHE;
|
||
break;
|
||
}
|
||
|
||
/* If we don't have a pending identifier,
|
||
return at end of input. */
|
||
if (ident_length == 0) {
|
||
obp--;
|
||
ibp--;
|
||
op->bufp = obp;
|
||
ip->bufp = ibp;
|
||
goto ending;
|
||
}
|
||
|
||
/* If we do have a pending identifier, just consider this null
|
||
a special character and arrange to dispatch on it again.
|
||
The second time, IDENT_LENGTH will be zero so we will return. */
|
||
|
||
/* Fall through */
|
||
|
||
specialchar:
|
||
|
||
/* Handle the case of a character such as /, ', " or null
|
||
seen following an identifier. Back over it so that
|
||
after the identifier is processed the special char
|
||
will be dispatched on again. */
|
||
|
||
ibp--;
|
||
obp--;
|
||
redo_char = 1;
|
||
|
||
default:
|
||
|
||
randomchar:
|
||
|
||
if (ident_length > 0) {
|
||
register HASHNODE *hp;
|
||
|
||
/* We have just seen an identifier end. If it's a macro, expand it.
|
||
|
||
IDENT_LENGTH is the length of the identifier
|
||
and HASH is its hash code.
|
||
|
||
The identifier has already been copied to the output,
|
||
so if it is a macro we must remove it.
|
||
|
||
If REDO_CHAR is 0, the char that terminated the identifier
|
||
has been skipped in the output and the input.
|
||
OBP-IDENT_LENGTH-1 points to the identifier.
|
||
If the identifier is a macro, we must back over the terminator.
|
||
|
||
If REDO_CHAR is 1, the terminating char has already been
|
||
backed over. OBP-IDENT_LENGTH points to the identifier. */
|
||
|
||
if (!pcp_outfile || pcp_inside_if) {
|
||
for (hp = hashtab[MAKE_POS (hash) % HASHSIZE]; hp != NULL;
|
||
hp = hp->next) {
|
||
|
||
if (hp->length == ident_length) {
|
||
int obufp_before_macroname;
|
||
int op_lineno_before_macroname;
|
||
register int i = ident_length;
|
||
register U_CHAR *p = hp->name;
|
||
register U_CHAR *q = obp - i;
|
||
int disabled;
|
||
|
||
if (! redo_char)
|
||
q--;
|
||
|
||
do { /* All this to avoid a strncmp () */
|
||
if (*p++ != *q++)
|
||
goto hashcollision;
|
||
} while (--i);
|
||
|
||
/* We found a use of a macro name.
|
||
see if the context shows it is a macro call. */
|
||
|
||
/* Back up over terminating character if not already done. */
|
||
if (! redo_char) {
|
||
ibp--;
|
||
obp--;
|
||
}
|
||
|
||
/* Save this as a displacement from the beginning of the output
|
||
buffer. We can not save this as a position in the output
|
||
buffer, because it may get realloc'ed by RECACHE. */
|
||
obufp_before_macroname = (obp - op->buf) - ident_length;
|
||
op_lineno_before_macroname = op->lineno;
|
||
|
||
if (hp->type == T_PCSTRING) {
|
||
pcstring_used (hp); /* Mark the definition of this key
|
||
as needed, ensuring that it
|
||
will be output. */
|
||
break; /* Exit loop, since the key cannot have a
|
||
definition any longer. */
|
||
}
|
||
|
||
/* Record whether the macro is disabled. */
|
||
disabled = hp->type == T_DISABLED;
|
||
|
||
/* This looks like a macro ref, but if the macro was disabled,
|
||
just copy its name and put in a marker if requested. */
|
||
|
||
if (disabled) {
|
||
#if 0
|
||
/* This error check caught useful cases such as
|
||
#define foo(x,y) bar (x (y,0), y)
|
||
foo (foo, baz) */
|
||
if (traditional)
|
||
error ("recursive use of macro `%s'", hp->name);
|
||
#endif
|
||
|
||
if (output_marks) {
|
||
op->bufp = obp;
|
||
check_expand (op, limit - ibp + 2);
|
||
obp = op->bufp;
|
||
*obp++ = '\n';
|
||
*obp++ = '-';
|
||
}
|
||
break;
|
||
}
|
||
|
||
/* If macro wants an arglist, verify that a '(' follows.
|
||
first skip all whitespace, copying it to the output
|
||
after the macro name. Then, if there is no '(',
|
||
decide this is not a macro call and leave things that way. */
|
||
if ((hp->type == T_MACRO || hp->type == T_DISABLED)
|
||
&& hp->value.defn->nargs >= 0)
|
||
{
|
||
U_CHAR *old_ibp = ibp;
|
||
U_CHAR *old_obp = obp;
|
||
int old_iln = ip->lineno;
|
||
int old_oln = op->lineno;
|
||
|
||
while (1) {
|
||
/* Scan forward over whitespace, copying it to the output. */
|
||
if (ibp == limit && ip->macro != 0) {
|
||
POPMACRO;
|
||
RECACHE;
|
||
old_ibp = ibp;
|
||
old_obp = obp;
|
||
old_iln = ip->lineno;
|
||
old_oln = op->lineno;
|
||
}
|
||
else if (is_space[*ibp]) {
|
||
*obp++ = *ibp++;
|
||
if (ibp[-1] == '\n') {
|
||
if (ip->macro == 0) {
|
||
/* Newline in a file. Count it. */
|
||
++ip->lineno;
|
||
++op->lineno;
|
||
} else if (!output_marks) {
|
||
/* A newline mark, and we don't want marks
|
||
in the output. If it is newline-hyphen,
|
||
discard it entirely. Otherwise, it is
|
||
newline-whitechar, so keep the whitechar. */
|
||
obp--;
|
||
if (*ibp == '-')
|
||
ibp++;
|
||
else {
|
||
if (*ibp == '\n')
|
||
++op->lineno;
|
||
*obp++ = *ibp++;
|
||
}
|
||
} else {
|
||
/* A newline mark; copy both chars to the output. */
|
||
*obp++ = *ibp++;
|
||
}
|
||
}
|
||
}
|
||
else if (ip->macro)
|
||
break;
|
||
else if (*ibp == '/') {
|
||
/* If a comment, copy it unchanged or discard it. */
|
||
if (ibp[1] == '\\' && ibp[2] == '\n')
|
||
newline_fix (ibp + 1);
|
||
if (ibp[1] == '*') {
|
||
if (put_out_comments) {
|
||
*obp++ = '/';
|
||
*obp++ = '*';
|
||
} else if (! traditional) {
|
||
*obp++ = ' ';
|
||
}
|
||
for (ibp += 2; ibp < limit; ibp++) {
|
||
/* We need not worry about newline-marks,
|
||
since they are never found in comments. */
|
||
if (ibp[0] == '*') {
|
||
if (ibp[1] == '\\' && ibp[2] == '\n')
|
||
newline_fix (ibp + 1);
|
||
if (ibp[1] == '/') {
|
||
ibp += 2;
|
||
if (put_out_comments) {
|
||
*obp++ = '*';
|
||
*obp++ = '/';
|
||
}
|
||
break;
|
||
}
|
||
}
|
||
else if (*ibp == '\n') {
|
||
/* Newline in a file. Count it. */
|
||
++ip->lineno;
|
||
++op->lineno;
|
||
}
|
||
else
|
||
{
|
||
#ifdef MULTIBYTE_CHARS
|
||
int length;
|
||
length = local_mblen (ibp, limit - ibp);
|
||
if (length > 1)
|
||
{
|
||
if (put_out_comments)
|
||
{
|
||
bcopy (ibp, obp, length - 1);
|
||
obp += length - 1;
|
||
}
|
||
ibp += (length - 1);
|
||
}
|
||
#endif
|
||
}
|
||
if (put_out_comments)
|
||
*obp++ = *ibp;
|
||
}
|
||
} else if (ibp[1] == '/' && cplusplus_comments) {
|
||
if (put_out_comments) {
|
||
*obp++ = '/';
|
||
*obp++ = '/';
|
||
} else if (! traditional) {
|
||
*obp++ = ' ';
|
||
}
|
||
for (ibp += 2; ; ibp++)
|
||
{
|
||
if (*ibp == '\n')
|
||
break;
|
||
if (*ibp == '\\' && ibp[1] == '\n')
|
||
{
|
||
if (put_out_comments)
|
||
*obp++ = *ibp++;
|
||
}
|
||
else
|
||
{
|
||
#ifdef MULTIBYTE_CHARS
|
||
int length;
|
||
length = local_mblen (ibp, limit - ibp);
|
||
if (length > 1)
|
||
{
|
||
if (put_out_comments)
|
||
{
|
||
bcopy (ibp, obp, length - 1);
|
||
obp += length - 1;
|
||
}
|
||
ibp += (length - 1);
|
||
}
|
||
#endif
|
||
}
|
||
if (put_out_comments)
|
||
*obp++ = *ibp;
|
||
}
|
||
} else
|
||
break;
|
||
}
|
||
else if (ibp[0] == '\\' && ibp[1] == '\n') {
|
||
ibp += 2;
|
||
++ip->lineno;
|
||
}
|
||
else break;
|
||
}
|
||
if (*ibp != '(') {
|
||
/* It isn't a macro call.
|
||
Put back the space that we just skipped. */
|
||
ibp = old_ibp;
|
||
obp = old_obp;
|
||
ip->lineno = old_iln;
|
||
op->lineno = old_oln;
|
||
/* Exit the for loop. */
|
||
break;
|
||
}
|
||
}
|
||
|
||
/* This is now known to be a macro call.
|
||
Discard the macro name from the output,
|
||
along with any following whitespace just copied,
|
||
but preserve newlines if not outputting marks since this
|
||
is more likely to do the right thing with line numbers. */
|
||
obp = op->buf + obufp_before_macroname;
|
||
if (output_marks)
|
||
op->lineno = op_lineno_before_macroname;
|
||
else {
|
||
int newlines = op->lineno - op_lineno_before_macroname;
|
||
while (0 < newlines--)
|
||
*obp++ = '\n';
|
||
}
|
||
|
||
/* Prevent accidental token-pasting with a character
|
||
before the macro call. */
|
||
if (!traditional && obp != op->buf) {
|
||
switch (obp[-1]) {
|
||
case '!': case '%': case '&': case '*':
|
||
case '+': case '-': case '.': case '/':
|
||
case ':': case '<': case '=': case '>':
|
||
case '^': case '|':
|
||
/* If we are expanding a macro arg, make a newline marker
|
||
to separate the tokens. If we are making real output,
|
||
a plain space will do. */
|
||
if (output_marks)
|
||
*obp++ = '\n';
|
||
*obp++ = ' ';
|
||
}
|
||
}
|
||
|
||
/* Expand the macro, reading arguments as needed,
|
||
and push the expansion on the input stack. */
|
||
ip->bufp = ibp;
|
||
op->bufp = obp;
|
||
macroexpand (hp, op);
|
||
|
||
/* Reexamine input stack, since macroexpand has pushed
|
||
a new level on it. */
|
||
obp = op->bufp;
|
||
RECACHE;
|
||
break;
|
||
}
|
||
hashcollision:
|
||
;
|
||
} /* End hash-table-search loop */
|
||
}
|
||
ident_length = hash = 0; /* Stop collecting identifier */
|
||
redo_char = 0;
|
||
concatenated = 0;
|
||
} /* End if (ident_length > 0) */
|
||
} /* End switch */
|
||
} /* End per-char loop */
|
||
|
||
/* Come here to return -- but first give an error message
|
||
if there was an unterminated successful conditional. */
|
||
ending:
|
||
if (if_stack != ip->if_stack)
|
||
{
|
||
char *str;
|
||
|
||
switch (if_stack->type)
|
||
{
|
||
case T_IF:
|
||
str = "if";
|
||
break;
|
||
case T_IFDEF:
|
||
str = "ifdef";
|
||
break;
|
||
case T_IFNDEF:
|
||
str = "ifndef";
|
||
break;
|
||
case T_ELSE:
|
||
str = "else";
|
||
break;
|
||
case T_ELIF:
|
||
str = "elif";
|
||
break;
|
||
default:
|
||
abort ();
|
||
}
|
||
|
||
error_with_line (line_for_error (if_stack->lineno),
|
||
"unterminated `#%s' conditional", str);
|
||
}
|
||
if_stack = ip->if_stack;
|
||
}
|
||
|
||
/*
|
||
* Rescan a string into a temporary buffer and return the result
|
||
* as a FILE_BUF. Note this function returns a struct, not a pointer.
|
||
*
|
||
* OUTPUT_MARKS nonzero means keep Newline markers found in the input
|
||
* and insert such markers when appropriate. See `rescan' for details.
|
||
* OUTPUT_MARKS is 1 for macroexpanding a macro argument separately
|
||
* before substitution; it is 0 for other uses.
|
||
*/
|
||
static FILE_BUF
|
||
expand_to_temp_buffer (buf, limit, output_marks, assertions)
|
||
U_CHAR *buf, *limit;
|
||
int output_marks, assertions;
|
||
{
|
||
register FILE_BUF *ip;
|
||
FILE_BUF obuf;
|
||
int length = limit - buf;
|
||
U_CHAR *buf1;
|
||
int odepth = indepth;
|
||
int save_assertions_flag = assertions_flag;
|
||
|
||
assertions_flag = assertions;
|
||
|
||
if (length < 0)
|
||
abort ();
|
||
|
||
/* Set up the input on the input stack. */
|
||
|
||
buf1 = (U_CHAR *) alloca (length + 1);
|
||
{
|
||
register U_CHAR *p1 = buf;
|
||
register U_CHAR *p2 = buf1;
|
||
|
||
while (p1 != limit)
|
||
*p2++ = *p1++;
|
||
}
|
||
buf1[length] = 0;
|
||
|
||
/* Set up to receive the output. */
|
||
|
||
obuf.length = length * 2 + 100; /* Usually enough. Why be stingy? */
|
||
obuf.bufp = obuf.buf = (U_CHAR *) xmalloc (obuf.length);
|
||
obuf.nominal_fname = 0;
|
||
obuf.inc = 0;
|
||
obuf.dir = 0;
|
||
obuf.fname = 0;
|
||
obuf.macro = 0;
|
||
obuf.if_stack = 0;
|
||
obuf.free_ptr = 0;
|
||
obuf.system_header_p = 0;
|
||
|
||
CHECK_DEPTH ({return obuf;});
|
||
|
||
++indepth;
|
||
|
||
ip = &instack[indepth];
|
||
ip->fname = 0;
|
||
ip->nominal_fname = 0;
|
||
ip->nominal_fname_len = 0;
|
||
ip->inc = 0;
|
||
ip->system_header_p = 0;
|
||
ip->macro = 0;
|
||
ip->free_ptr = 0;
|
||
ip->length = length;
|
||
ip->buf = ip->bufp = buf1;
|
||
ip->if_stack = if_stack;
|
||
|
||
ip->lineno = obuf.lineno = 1;
|
||
|
||
/* Scan the input, create the output. */
|
||
rescan (&obuf, output_marks);
|
||
|
||
/* Pop input stack to original state. */
|
||
--indepth;
|
||
|
||
if (indepth != odepth)
|
||
abort ();
|
||
|
||
/* Record the output. */
|
||
obuf.length = obuf.bufp - obuf.buf;
|
||
|
||
assertions_flag = save_assertions_flag;
|
||
return obuf;
|
||
}
|
||
|
||
/*
|
||
* Process a # directive. Expects IP->bufp to point after the '#', as in
|
||
* `#define foo bar'. Passes to the directive handler
|
||
* (do_define, do_include, etc.): the addresses of the 1st and
|
||
* last chars of the directive (starting immediately after the #
|
||
* keyword), plus op and the keyword table pointer. If the directive
|
||
* contains comments it is copied into a temporary buffer sans comments
|
||
* and the temporary buffer is passed to the directive handler instead.
|
||
* Likewise for backslash-newlines.
|
||
*
|
||
* Returns nonzero if this was a known # directive.
|
||
* Otherwise, returns zero, without advancing the input pointer.
|
||
*/
|
||
|
||
static int
|
||
handle_directive (ip, op)
|
||
FILE_BUF *ip, *op;
|
||
{
|
||
register U_CHAR *bp, *cp;
|
||
register struct directive *kt;
|
||
register int ident_length;
|
||
U_CHAR *resume_p;
|
||
|
||
/* Nonzero means we must copy the entire directive
|
||
to get rid of comments or backslash-newlines. */
|
||
int copy_directive = 0;
|
||
|
||
U_CHAR *ident, *after_ident;
|
||
|
||
bp = ip->bufp;
|
||
|
||
/* Record where the directive started. do_xifdef needs this. */
|
||
directive_start = bp - 1;
|
||
|
||
ignore_escape_flag = 1;
|
||
|
||
/* Skip whitespace and \-newline. */
|
||
while (1) {
|
||
if (is_hor_space[*bp]) {
|
||
if (*bp != ' ' && *bp != '\t' && pedantic)
|
||
pedwarn_strange_white_space (*bp);
|
||
bp++;
|
||
} else if (*bp == '/') {
|
||
if (bp[1] == '\\' && bp[2] == '\n')
|
||
newline_fix (bp + 1);
|
||
if (! (bp[1] == '*' || (cplusplus_comments && bp[1] == '/')))
|
||
break;
|
||
ip->bufp = bp + 2;
|
||
skip_to_end_of_comment (ip, &ip->lineno, 0);
|
||
bp = ip->bufp;
|
||
} else if (*bp == '\\' && bp[1] == '\n') {
|
||
bp += 2; ip->lineno++;
|
||
} else break;
|
||
}
|
||
|
||
/* Now find end of directive name.
|
||
If we encounter a backslash-newline, exchange it with any following
|
||
symbol-constituents so that we end up with a contiguous name. */
|
||
|
||
cp = bp;
|
||
while (1) {
|
||
if (is_idchar[*cp])
|
||
cp++;
|
||
else {
|
||
if (*cp == '\\' && cp[1] == '\n')
|
||
name_newline_fix (cp);
|
||
if (is_idchar[*cp])
|
||
cp++;
|
||
else break;
|
||
}
|
||
}
|
||
ident_length = cp - bp;
|
||
ident = bp;
|
||
after_ident = cp;
|
||
|
||
/* A line of just `#' becomes blank. */
|
||
|
||
if (ident_length == 0 && *after_ident == '\n') {
|
||
ip->bufp = after_ident;
|
||
return 1;
|
||
}
|
||
|
||
if (ident_length == 0 || !is_idstart[*ident]) {
|
||
U_CHAR *p = ident;
|
||
while (is_idchar[*p]) {
|
||
if (*p < '0' || *p > '9')
|
||
break;
|
||
p++;
|
||
}
|
||
/* Handle # followed by a line number. */
|
||
if (p != ident && !is_idchar[*p]) {
|
||
static struct directive line_directive_table[] = {
|
||
{ 4, do_line, "line", T_LINE},
|
||
};
|
||
if (pedantic)
|
||
pedwarn ("`#' followed by integer");
|
||
after_ident = ident;
|
||
kt = line_directive_table;
|
||
ignore_escape_flag = 0;
|
||
goto old_linenum;
|
||
}
|
||
|
||
/* Avoid error for `###' and similar cases unless -pedantic. */
|
||
if (p == ident) {
|
||
while (*p == '#' || is_hor_space[*p]) p++;
|
||
if (*p == '\n') {
|
||
if (pedantic && !lang_asm)
|
||
warning ("invalid preprocessing directive");
|
||
return 0;
|
||
}
|
||
}
|
||
|
||
if (!lang_asm)
|
||
error ("invalid preprocessing directive name");
|
||
|
||
return 0;
|
||
}
|
||
|
||
/*
|
||
* Decode the keyword and call the appropriate expansion
|
||
* routine, after moving the input pointer up to the next line.
|
||
*/
|
||
for (kt = directive_table; kt->length > 0; kt++) {
|
||
if (kt->length == ident_length && !bcmp (kt->name, ident, ident_length)) {
|
||
register U_CHAR *buf;
|
||
register U_CHAR *limit;
|
||
int unterminated;
|
||
int junk;
|
||
int *already_output;
|
||
|
||
/* Nonzero means do not delete comments within the directive.
|
||
#define needs this when -traditional. */
|
||
int keep_comments;
|
||
|
||
old_linenum:
|
||
|
||
limit = ip->buf + ip->length;
|
||
unterminated = 0;
|
||
already_output = 0;
|
||
keep_comments = traditional && kt->type == T_DEFINE;
|
||
/* #import is defined only in Objective C, or when on the NeXT. */
|
||
if (kt->type == T_IMPORT
|
||
&& !(objc || lookup ((U_CHAR *) "__NeXT__", -1, -1)))
|
||
break;
|
||
|
||
/* Find the end of this directive (first newline not backslashed
|
||
and not in a string or comment).
|
||
Set COPY_DIRECTIVE if the directive must be copied
|
||
(it contains a backslash-newline or a comment). */
|
||
|
||
buf = bp = after_ident;
|
||
while (bp < limit) {
|
||
register U_CHAR c = *bp++;
|
||
switch (c) {
|
||
case '\\':
|
||
if (bp < limit) {
|
||
if (*bp == '\n') {
|
||
ip->lineno++;
|
||
copy_directive = 1;
|
||
bp++;
|
||
} else if (traditional)
|
||
bp++;
|
||
}
|
||
break;
|
||
|
||
case '"':
|
||
/* "..." is special for #include. */
|
||
if (IS_INCLUDE_DIRECTIVE_TYPE (kt->type)) {
|
||
while (bp < limit && *bp != '\n') {
|
||
if (*bp == '"') {
|
||
bp++;
|
||
break;
|
||
}
|
||
if (*bp == '\\' && bp[1] == '\n') {
|
||
ip->lineno++;
|
||
copy_directive = 1;
|
||
bp++;
|
||
}
|
||
bp++;
|
||
}
|
||
break;
|
||
}
|
||
/* Fall through. */
|
||
case '\'':
|
||
bp = skip_quoted_string (bp - 1, limit, ip->lineno, &ip->lineno, ©_directive, &unterminated);
|
||
/* Don't bother calling the directive if we already got an error
|
||
message due to unterminated string. Skip everything and pretend
|
||
we called the directive. */
|
||
if (unterminated) {
|
||
if (traditional) {
|
||
/* Traditional preprocessing permits unterminated strings. */
|
||
ip->bufp = bp;
|
||
goto endloop1;
|
||
}
|
||
ip->bufp = bp;
|
||
return 1;
|
||
}
|
||
break;
|
||
|
||
/* <...> is special for #include. */
|
||
case '<':
|
||
if (! IS_INCLUDE_DIRECTIVE_TYPE (kt->type))
|
||
break;
|
||
while (bp < limit && *bp != '>' && *bp != '\n') {
|
||
if (*bp == '\\' && bp[1] == '\n') {
|
||
ip->lineno++;
|
||
copy_directive = 1;
|
||
bp++;
|
||
}
|
||
bp++;
|
||
}
|
||
break;
|
||
|
||
case '/':
|
||
if (*bp == '\\' && bp[1] == '\n')
|
||
newline_fix (bp);
|
||
if (*bp == '*'
|
||
|| (cplusplus_comments && *bp == '/')) {
|
||
U_CHAR *obp = bp - 1;
|
||
ip->bufp = bp + 1;
|
||
skip_to_end_of_comment (ip, &ip->lineno, 0);
|
||
bp = ip->bufp;
|
||
/* No need to copy the directive because of a comment at the end;
|
||
just don't include the comment in the directive. */
|
||
if (!put_out_comments) {
|
||
U_CHAR *p;
|
||
for (p = bp; *p == ' ' || *p == '\t'; p++)
|
||
continue;
|
||
if (*p == '\n') {
|
||
bp = obp;
|
||
goto endloop1;
|
||
}
|
||
}
|
||
/* Don't remove the comments if -traditional. */
|
||
if (! keep_comments)
|
||
copy_directive++;
|
||
}
|
||
break;
|
||
|
||
case '\f':
|
||
case '\r':
|
||
case '\v':
|
||
if (pedantic)
|
||
pedwarn_strange_white_space (c);
|
||
break;
|
||
|
||
case '\n':
|
||
--bp; /* Point to the newline */
|
||
ip->bufp = bp;
|
||
goto endloop1;
|
||
}
|
||
}
|
||
ip->bufp = bp;
|
||
|
||
endloop1:
|
||
resume_p = ip->bufp;
|
||
/* BP is the end of the directive.
|
||
RESUME_P is the next interesting data after the directive.
|
||
A comment may come between. */
|
||
|
||
/* If a directive should be copied through, and -C was given,
|
||
pass it through before removing comments. */
|
||
if (!no_output && put_out_comments
|
||
&& ((kt->type == T_DEFINE || kt->type == T_UNDEF)
|
||
? dump_macros == dump_definitions
|
||
: IS_INCLUDE_DIRECTIVE_TYPE (kt->type) ? dump_includes
|
||
: kt->type == T_PRAGMA)) {
|
||
int len;
|
||
|
||
/* Output directive name. */
|
||
check_expand (op, kt->length + 2);
|
||
/* Make sure # is at the start of a line */
|
||
if (op->bufp > op->buf && op->bufp[-1] != '\n') {
|
||
op->lineno++;
|
||
*op->bufp++ = '\n';
|
||
}
|
||
*op->bufp++ = '#';
|
||
bcopy (kt->name, op->bufp, kt->length);
|
||
op->bufp += kt->length;
|
||
|
||
/* Output arguments. */
|
||
len = (bp - buf);
|
||
check_expand (op, len);
|
||
bcopy (buf, (char *) op->bufp, len);
|
||
op->bufp += len;
|
||
/* Take account of any (escaped) newlines just output. */
|
||
while (--len >= 0)
|
||
if (buf[len] == '\n')
|
||
op->lineno++;
|
||
|
||
already_output = &junk;
|
||
} /* Don't we need a newline or #line? */
|
||
|
||
if (copy_directive) {
|
||
register U_CHAR *xp = buf;
|
||
/* Need to copy entire directive into temp buffer before dispatching */
|
||
|
||
cp = (U_CHAR *) alloca (bp - buf + 5); /* room for directive plus
|
||
some slop */
|
||
buf = cp;
|
||
|
||
/* Copy to the new buffer, deleting comments
|
||
and backslash-newlines (and whitespace surrounding the latter). */
|
||
|
||
while (xp < bp) {
|
||
register U_CHAR c = *xp++;
|
||
*cp++ = c;
|
||
|
||
switch (c) {
|
||
case '\n':
|
||
abort (); /* A bare newline should never part of the line. */
|
||
break;
|
||
|
||
/* <...> is special for #include. */
|
||
case '<':
|
||
if (! IS_INCLUDE_DIRECTIVE_TYPE (kt->type))
|
||
break;
|
||
while (xp < bp && c != '>') {
|
||
c = *xp++;
|
||
if (c == '\\' && xp < bp && *xp == '\n')
|
||
xp++;
|
||
else
|
||
*cp++ = c;
|
||
}
|
||
break;
|
||
|
||
case '\\':
|
||
if (*xp == '\n') {
|
||
xp++;
|
||
cp--;
|
||
if (cp != buf && is_hor_space[cp[-1]]) {
|
||
while (cp - 1 != buf && is_hor_space[cp[-2]])
|
||
cp--;
|
||
SKIP_WHITE_SPACE (xp);
|
||
} else if (is_hor_space[*xp]) {
|
||
*cp++ = *xp++;
|
||
SKIP_WHITE_SPACE (xp);
|
||
}
|
||
} else if (traditional && xp < bp) {
|
||
*cp++ = *xp++;
|
||
}
|
||
break;
|
||
|
||
case '\'':
|
||
case '\"':
|
||
{
|
||
int backslash_newlines_p = 0;
|
||
|
||
register U_CHAR *bp1
|
||
= skip_quoted_string (xp - 1, bp, ip->lineno,
|
||
NULL_PTR, &backslash_newlines_p,
|
||
NULL_PTR);
|
||
if (backslash_newlines_p)
|
||
while (xp != bp1)
|
||
{
|
||
/* With something like:
|
||
|
||
#define X "a\
|
||
b"
|
||
|
||
we should still remove the backslash-newline
|
||
pair as part of phase two. */
|
||
if (xp[0] == '\\' && xp[1] == '\n')
|
||
xp += 2;
|
||
else
|
||
*cp++ = *xp++;
|
||
}
|
||
else
|
||
/* This is the same as the loop above, but taking
|
||
advantage of the fact that we know there are no
|
||
backslash-newline pairs. */
|
||
while (xp != bp1)
|
||
*cp++ = *xp++;
|
||
}
|
||
break;
|
||
|
||
case '/':
|
||
if (*xp == '*'
|
||
|| (cplusplus_comments && *xp == '/')) {
|
||
ip->bufp = xp + 1;
|
||
/* If we already copied the directive through,
|
||
already_output != 0 prevents outputting comment now. */
|
||
skip_to_end_of_comment (ip, already_output, 0);
|
||
if (keep_comments)
|
||
while (xp != ip->bufp)
|
||
*cp++ = *xp++;
|
||
/* Delete or replace the slash. */
|
||
else if (traditional)
|
||
cp--;
|
||
else
|
||
cp[-1] = ' ';
|
||
xp = ip->bufp;
|
||
}
|
||
}
|
||
}
|
||
|
||
/* Null-terminate the copy. */
|
||
|
||
*cp = 0;
|
||
} else
|
||
cp = bp;
|
||
|
||
ip->bufp = resume_p;
|
||
|
||
/* Some directives should be written out for cc1 to process,
|
||
just as if they were not defined. And sometimes we're copying
|
||
directives through. */
|
||
|
||
if (!no_output && already_output == 0
|
||
&& (kt->type == T_DEFINE ? (int) dump_names <= (int) dump_macros
|
||
: IS_INCLUDE_DIRECTIVE_TYPE (kt->type) ? dump_includes
|
||
: kt->type == T_PRAGMA)) {
|
||
int len;
|
||
|
||
/* Output directive name. */
|
||
check_expand (op, kt->length + 1);
|
||
*op->bufp++ = '#';
|
||
bcopy (kt->name, (char *) op->bufp, kt->length);
|
||
op->bufp += kt->length;
|
||
|
||
if (kt->type == T_DEFINE && dump_macros == dump_names) {
|
||
/* Output `#define name' only. */
|
||
U_CHAR *xp = buf;
|
||
U_CHAR *yp;
|
||
SKIP_WHITE_SPACE (xp);
|
||
yp = xp;
|
||
while (is_idchar[*xp]) xp++;
|
||
len = (xp - yp);
|
||
check_expand (op, len + 1);
|
||
*op->bufp++ = ' ';
|
||
bcopy (yp, (char *) op->bufp, len);
|
||
} else {
|
||
/* Output entire directive. */
|
||
len = (cp - buf);
|
||
check_expand (op, len);
|
||
bcopy (buf, (char *) op->bufp, len);
|
||
}
|
||
op->bufp += len;
|
||
} /* Don't we need a newline or #line? */
|
||
|
||
/* Call the appropriate directive handler. buf now points to
|
||
either the appropriate place in the input buffer, or to
|
||
the temp buffer if it was necessary to make one. cp
|
||
points to the first char after the contents of the (possibly
|
||
copied) directive, in either case. */
|
||
(*kt->func) (buf, cp, op, kt);
|
||
check_expand (op, ip->length - (ip->bufp - ip->buf));
|
||
|
||
return 1;
|
||
}
|
||
}
|
||
|
||
/* It is deliberate that we don't warn about undefined directives.
|
||
That is the responsibility of cc1. */
|
||
return 0;
|
||
}
|
||
|
||
static struct tm *
|
||
timestamp ()
|
||
{
|
||
static struct tm *timebuf;
|
||
if (!timebuf) {
|
||
time_t t = time ((time_t *) 0);
|
||
timebuf = localtime (&t);
|
||
}
|
||
return timebuf;
|
||
}
|
||
|
||
static char *monthnames[] = {"Jan", "Feb", "Mar", "Apr", "May", "Jun",
|
||
"Jul", "Aug", "Sep", "Oct", "Nov", "Dec",
|
||
};
|
||
|
||
/*
|
||
* expand things like __FILE__. Place the expansion into the output
|
||
* buffer *without* rescanning.
|
||
*/
|
||
|
||
static void
|
||
special_symbol (hp, op)
|
||
HASHNODE *hp;
|
||
FILE_BUF *op;
|
||
{
|
||
char *buf;
|
||
int i, len;
|
||
int true_indepth;
|
||
FILE_BUF *ip = NULL;
|
||
struct tm *timebuf;
|
||
|
||
int paren = 0; /* For special `defined' keyword */
|
||
|
||
if (pcp_outfile && pcp_inside_if
|
||
&& hp->type != T_SPEC_DEFINED && hp->type != T_CONST)
|
||
error ("Predefined macro `%s' used inside `#if' during precompilation",
|
||
hp->name);
|
||
|
||
for (i = indepth; i >= 0; i--)
|
||
if (instack[i].fname != NULL) {
|
||
ip = &instack[i];
|
||
break;
|
||
}
|
||
if (ip == NULL) {
|
||
error ("cccp error: not in any file?!");
|
||
return; /* the show must go on */
|
||
}
|
||
|
||
switch (hp->type) {
|
||
case T_FILE:
|
||
case T_BASE_FILE:
|
||
{
|
||
FILE_BUF *p = hp->type == T_FILE ? ip : &instack[0];
|
||
char *string = p->nominal_fname;
|
||
|
||
if (string)
|
||
{
|
||
size_t string_len = p->nominal_fname_len;
|
||
buf = (char *) alloca (3 + 4 * string_len);
|
||
quote_string (buf, string, string_len);
|
||
}
|
||
else
|
||
buf = "\"\"";
|
||
|
||
break;
|
||
}
|
||
|
||
case T_INCLUDE_LEVEL:
|
||
true_indepth = 0;
|
||
for (i = indepth; i >= 0; i--)
|
||
if (instack[i].fname != NULL)
|
||
true_indepth++;
|
||
|
||
buf = (char *) alloca (8); /* Eight bytes ought to be more than enough */
|
||
sprintf (buf, "%d", true_indepth - 1);
|
||
break;
|
||
|
||
case T_VERSION:
|
||
buf = (char *) alloca (3 + strlen (version_string));
|
||
sprintf (buf, "\"%s\"", version_string);
|
||
break;
|
||
|
||
#ifndef NO_BUILTIN_SIZE_TYPE
|
||
case T_SIZE_TYPE:
|
||
buf = SIZE_TYPE;
|
||
break;
|
||
#endif
|
||
|
||
#ifndef NO_BUILTIN_PTRDIFF_TYPE
|
||
case T_PTRDIFF_TYPE:
|
||
buf = PTRDIFF_TYPE;
|
||
break;
|
||
#endif
|
||
|
||
case T_WCHAR_TYPE:
|
||
buf = wchar_type;
|
||
break;
|
||
|
||
case T_USER_LABEL_PREFIX_TYPE:
|
||
buf = user_label_prefix;
|
||
break;
|
||
|
||
case T_REGISTER_PREFIX_TYPE:
|
||
buf = REGISTER_PREFIX;
|
||
break;
|
||
|
||
case T_IMMEDIATE_PREFIX_TYPE:
|
||
buf = IMMEDIATE_PREFIX;
|
||
break;
|
||
|
||
case T_CONST:
|
||
buf = hp->value.cpval;
|
||
#ifdef STDC_0_IN_SYSTEM_HEADERS
|
||
if (ip->system_header_p
|
||
&& hp->length == 8 && bcmp (hp->name, "__STDC__", 8) == 0
|
||
&& !lookup ((U_CHAR *) "__STRICT_ANSI__", -1, -1))
|
||
buf = "0";
|
||
#endif
|
||
if (pcp_inside_if && pcp_outfile)
|
||
/* Output a precondition for this macro use */
|
||
fprintf (pcp_outfile, "#define %s %s\n", hp->name, buf);
|
||
break;
|
||
|
||
case T_SPECLINE:
|
||
buf = (char *) alloca (10);
|
||
sprintf (buf, "%d", ip->lineno);
|
||
break;
|
||
|
||
case T_DATE:
|
||
case T_TIME:
|
||
buf = (char *) alloca (20);
|
||
timebuf = timestamp ();
|
||
if (hp->type == T_DATE)
|
||
sprintf (buf, "\"%s %2d %4d\"", monthnames[timebuf->tm_mon],
|
||
timebuf->tm_mday, timebuf->tm_year + 1900);
|
||
else
|
||
sprintf (buf, "\"%02d:%02d:%02d\"", timebuf->tm_hour, timebuf->tm_min,
|
||
timebuf->tm_sec);
|
||
break;
|
||
|
||
case T_SPEC_DEFINED:
|
||
buf = " 0 "; /* Assume symbol is not defined */
|
||
ip = &instack[indepth];
|
||
SKIP_WHITE_SPACE (ip->bufp);
|
||
if (*ip->bufp == '(') {
|
||
paren++;
|
||
ip->bufp++; /* Skip over the paren */
|
||
SKIP_WHITE_SPACE (ip->bufp);
|
||
}
|
||
|
||
if (!is_idstart[*ip->bufp])
|
||
goto oops;
|
||
if (ip->bufp[0] == 'L' && (ip->bufp[1] == '\'' || ip->bufp[1] == '"'))
|
||
goto oops;
|
||
if ((hp = lookup (ip->bufp, -1, -1))) {
|
||
if (pcp_outfile && pcp_inside_if
|
||
&& (hp->type == T_CONST
|
||
|| (hp->type == T_MACRO && hp->value.defn->predefined)))
|
||
/* Output a precondition for this macro use. */
|
||
fprintf (pcp_outfile, "#define %s\n", hp->name);
|
||
buf = " 1 ";
|
||
}
|
||
else
|
||
if (pcp_outfile && pcp_inside_if) {
|
||
/* Output a precondition for this macro use */
|
||
U_CHAR *cp = ip->bufp;
|
||
fprintf (pcp_outfile, "#undef ");
|
||
while (is_idchar[*cp]) /* Ick! */
|
||
fputc (*cp++, pcp_outfile);
|
||
putc ('\n', pcp_outfile);
|
||
}
|
||
while (is_idchar[*ip->bufp])
|
||
++ip->bufp;
|
||
SKIP_WHITE_SPACE (ip->bufp);
|
||
if (paren) {
|
||
if (*ip->bufp != ')')
|
||
goto oops;
|
||
++ip->bufp;
|
||
}
|
||
break;
|
||
|
||
oops:
|
||
|
||
error ("`defined' without an identifier");
|
||
break;
|
||
|
||
default:
|
||
error ("cccp error: invalid special hash type"); /* time for gdb */
|
||
abort ();
|
||
}
|
||
len = strlen (buf);
|
||
check_expand (op, len);
|
||
bcopy (buf, (char *) op->bufp, len);
|
||
op->bufp += len;
|
||
|
||
return;
|
||
}
|
||
|
||
|
||
/* Routines to handle #directives */
|
||
|
||
/* Handle #include and #import.
|
||
This function expects to see "fname" or <fname> on the input. */
|
||
|
||
static int
|
||
do_include (buf, limit, op, keyword)
|
||
U_CHAR *buf, *limit;
|
||
FILE_BUF *op;
|
||
struct directive *keyword;
|
||
{
|
||
U_CHAR *importing = keyword->type == T_IMPORT ? (U_CHAR *) "" : (U_CHAR *) 0;
|
||
int skip_dirs = (keyword->type == T_INCLUDE_NEXT);
|
||
static int import_warning = 0;
|
||
char *fname; /* Dynamically allocated fname buffer */
|
||
char *pcftry;
|
||
char *pcfname;
|
||
char *fbeg, *fend; /* Beginning and end of fname */
|
||
U_CHAR *fin;
|
||
|
||
struct file_name_list *search_start = include; /* Chain of dirs to search */
|
||
struct file_name_list *dsp; /* First in chain, if #include "..." */
|
||
struct file_name_list *searchptr = 0;
|
||
size_t flen;
|
||
|
||
int f = -3; /* file number */
|
||
struct include_file *inc = 0;
|
||
|
||
int retried = 0; /* Have already tried macro
|
||
expanding the include line*/
|
||
int angle_brackets = 0; /* 0 for "...", 1 for <...> */
|
||
#ifdef VMS
|
||
int vaxc_include = 0; /* 1 for token without punctuation */
|
||
#endif
|
||
int pcf = -1;
|
||
char *pcfbuf;
|
||
char *pcfbuflimit;
|
||
int pcfnum;
|
||
|
||
if (pedantic && !instack[indepth].system_header_p)
|
||
{
|
||
if (importing)
|
||
pedwarn ("ANSI C does not allow `#import'");
|
||
if (skip_dirs)
|
||
pedwarn ("ANSI C does not allow `#include_next'");
|
||
}
|
||
|
||
if (importing && warn_import && !inhibit_warnings
|
||
&& !instack[indepth].system_header_p && !import_warning) {
|
||
import_warning = 1;
|
||
warning ("using `#import' is not recommended");
|
||
notice ("The fact that a certain header file need not be processed more than once\n\
|
||
should be indicated in the header file, not where it is used.\n\
|
||
The best way to do this is with a conditional of this form:\n\
|
||
\n\
|
||
#ifndef _FOO_H_INCLUDED\n\
|
||
#define _FOO_H_INCLUDED\n\
|
||
... <real contents of file> ...\n\
|
||
#endif /* Not _FOO_H_INCLUDED */\n\
|
||
\n\
|
||
Then users can use `#include' any number of times.\n\
|
||
GNU C automatically avoids processing the file more than once\n\
|
||
when it is equipped with such a conditional.\n");
|
||
}
|
||
|
||
get_filename:
|
||
|
||
fin = buf;
|
||
SKIP_WHITE_SPACE (fin);
|
||
/* Discard trailing whitespace so we can easily see
|
||
if we have parsed all the significant chars we were given. */
|
||
while (limit != fin && is_hor_space[limit[-1]]) limit--;
|
||
fbeg = fend = (char *) alloca (limit - fin);
|
||
|
||
switch (*fin++) {
|
||
case '\"':
|
||
{
|
||
FILE_BUF *fp;
|
||
/* Copy the operand text, concatenating the strings. */
|
||
{
|
||
for (;;) {
|
||
for (;;) {
|
||
if (fin == limit)
|
||
goto invalid_include_file_name;
|
||
*fend = *fin++;
|
||
if (*fend == '"')
|
||
break;
|
||
fend++;
|
||
}
|
||
if (fin == limit)
|
||
break;
|
||
/* If not at the end, there had better be another string. */
|
||
/* Skip just horiz space, and don't go past limit. */
|
||
while (fin != limit && is_hor_space[*fin]) fin++;
|
||
if (fin != limit && *fin == '\"')
|
||
fin++;
|
||
else
|
||
goto fail;
|
||
}
|
||
}
|
||
|
||
/* We have "filename". Figure out directory this source
|
||
file is coming from and put it on the front of the list. */
|
||
|
||
/* If -I- was specified, don't search current dir, only spec'd ones. */
|
||
if (ignore_srcdir) break;
|
||
|
||
for (fp = &instack[indepth]; fp >= instack; fp--)
|
||
{
|
||
int n;
|
||
char *nam;
|
||
|
||
if ((nam = fp->nominal_fname) != NULL) {
|
||
/* Found a named file. Figure out dir of the file,
|
||
and put it in front of the search list. */
|
||
dsp = ((struct file_name_list *)
|
||
alloca (sizeof (struct file_name_list)
|
||
+ fp->nominal_fname_len));
|
||
strcpy (dsp->fname, nam);
|
||
simplify_filename (dsp->fname);
|
||
nam = base_name (dsp->fname);
|
||
*nam = 0;
|
||
#ifdef VMS
|
||
/* for hack_vms_include_specification(), a local
|
||
dir specification must start with "./" on VMS. */
|
||
if (nam == dsp->fname)
|
||
{
|
||
*nam++ = '.';
|
||
*nam++ = '/';
|
||
*nam = 0;
|
||
}
|
||
#endif
|
||
/* But for efficiency's sake, do not insert the dir
|
||
if it matches the search list's first dir. */
|
||
dsp->next = search_start;
|
||
if (!search_start || strcmp (dsp->fname, search_start->fname)) {
|
||
search_start = dsp;
|
||
n = nam - dsp->fname;
|
||
if (n + INCLUDE_LEN_FUDGE > max_include_len)
|
||
max_include_len = n + INCLUDE_LEN_FUDGE;
|
||
}
|
||
dsp[0].got_name_map = 0;
|
||
break;
|
||
}
|
||
}
|
||
break;
|
||
}
|
||
|
||
case '<':
|
||
while (fin != limit && *fin != '>')
|
||
*fend++ = *fin++;
|
||
if (*fin == '>' && fin + 1 == limit) {
|
||
angle_brackets = 1;
|
||
/* If -I-, start with the first -I dir after the -I-. */
|
||
search_start = first_bracket_include;
|
||
break;
|
||
}
|
||
goto fail;
|
||
|
||
default:
|
||
#ifdef VMS
|
||
/*
|
||
* Support '#include xyz' like VAX-C to allow for easy use of all the
|
||
* decwindow include files. It defaults to '#include <xyz.h>' (so the
|
||
* code from case '<' is repeated here) and generates a warning.
|
||
* (Note: macro expansion of `xyz' takes precedence.)
|
||
*/
|
||
/* Note: The argument of ISALPHA() can be evaluated twice, so do
|
||
the pre-decrement outside of the macro. */
|
||
if (retried && (--fin, ISALPHA(*(U_CHAR *) (fin)))) {
|
||
while (fin != limit && (!ISSPACE(*fin)))
|
||
*fend++ = *fin++;
|
||
warning ("VAX-C-style include specification found, use '#include <filename.h>' !");
|
||
vaxc_include = 1;
|
||
if (fin == limit) {
|
||
angle_brackets = 1;
|
||
/* If -I-, start with the first -I dir after the -I-. */
|
||
search_start = first_bracket_include;
|
||
break;
|
||
}
|
||
}
|
||
#endif
|
||
|
||
fail:
|
||
if (! retried) {
|
||
/* Expand buffer and then remove any newline markers.
|
||
We can't just tell expand_to_temp_buffer to omit the markers,
|
||
since it would put extra spaces in include file names. */
|
||
FILE_BUF trybuf;
|
||
U_CHAR *src;
|
||
int errors_before_expansion = errors;
|
||
trybuf = expand_to_temp_buffer (buf, limit, 1, 0);
|
||
if (errors != errors_before_expansion) {
|
||
free (trybuf.buf);
|
||
goto invalid_include_file_name;
|
||
}
|
||
src = trybuf.buf;
|
||
buf = (U_CHAR *) alloca (trybuf.bufp - trybuf.buf + 1);
|
||
limit = buf;
|
||
while (src != trybuf.bufp) {
|
||
switch ((*limit++ = *src++)) {
|
||
case '\n':
|
||
limit--;
|
||
src++;
|
||
break;
|
||
|
||
case '\'':
|
||
case '\"':
|
||
{
|
||
U_CHAR *src1 = skip_quoted_string (src - 1, trybuf.bufp, 0,
|
||
NULL_PTR, NULL_PTR, NULL_PTR);
|
||
while (src != src1)
|
||
*limit++ = *src++;
|
||
}
|
||
break;
|
||
}
|
||
}
|
||
*limit = 0;
|
||
free (trybuf.buf);
|
||
retried = 1;
|
||
goto get_filename;
|
||
}
|
||
|
||
invalid_include_file_name:
|
||
error ("`#%s' expects \"FILENAME\" or <FILENAME>", keyword->name);
|
||
return 0;
|
||
}
|
||
|
||
/* For #include_next, skip in the search path
|
||
past the dir in which the containing file was found. */
|
||
if (skip_dirs) {
|
||
FILE_BUF *fp;
|
||
for (fp = &instack[indepth]; fp >= instack; fp--)
|
||
if (fp->fname != NULL) {
|
||
/* fp->dir is null if the containing file was specified
|
||
with an absolute file name. In that case, don't skip anything. */
|
||
if (fp->dir)
|
||
search_start = fp->dir->next;
|
||
break;
|
||
}
|
||
}
|
||
|
||
*fend = 0;
|
||
flen = simplify_filename (fbeg);
|
||
|
||
if (flen == 0)
|
||
{
|
||
error ("empty file name in `#%s'", keyword->name);
|
||
return 0;
|
||
}
|
||
|
||
/* Allocate this permanently, because it gets stored in the definitions
|
||
of macros. */
|
||
fname = xmalloc (max_include_len + flen + 1);
|
||
/* + 1 above for terminating null. */
|
||
|
||
system_include_depth += angle_brackets;
|
||
|
||
/* If specified file name is absolute, just open it. */
|
||
|
||
if (absolute_filename (fbeg)) {
|
||
strcpy (fname, fbeg);
|
||
f = open_include_file (fname, NULL_PTR, importing, &inc);
|
||
} else {
|
||
|
||
struct bypass_dir {
|
||
struct bypass_dir *next;
|
||
char *fname;
|
||
struct file_name_list *searchptr;
|
||
} **bypass_slot = 0;
|
||
|
||
/* Search directory path, trying to open the file.
|
||
Copy each filename tried into FNAME. */
|
||
|
||
for (searchptr = search_start; searchptr; searchptr = searchptr->next) {
|
||
|
||
if (searchptr == first_bracket_include) {
|
||
/* Go to bypass directory if we know we've seen this file before. */
|
||
static struct bypass_dir *bypass_hashtab[INCLUDE_HASHSIZE];
|
||
struct bypass_dir *p;
|
||
bypass_slot = &bypass_hashtab[hashf ((U_CHAR *) fbeg, flen,
|
||
INCLUDE_HASHSIZE)];
|
||
for (p = *bypass_slot; p; p = p->next)
|
||
if (!strcmp (fbeg, p->fname)) {
|
||
searchptr = p->searchptr;
|
||
bypass_slot = 0;
|
||
break;
|
||
}
|
||
}
|
||
|
||
#ifdef VMS
|
||
/* Change this 1/2 Unix 1/2 VMS file specification into a
|
||
full VMS file specification */
|
||
if (searchptr->fname[0])
|
||
{
|
||
strcpy (fname, searchptr->fname);
|
||
if (fname[strlen (fname) - 1] == ':')
|
||
{
|
||
char *slashp;
|
||
slashp = strchr (fbeg, '/');
|
||
|
||
/* start at root-dir of logical device if no path given. */
|
||
if (slashp == 0)
|
||
strcat (fname, "[000000]");
|
||
}
|
||
strcat (fname, fbeg);
|
||
|
||
/* Fix up the filename */
|
||
hack_vms_include_specification (fname, vaxc_include);
|
||
}
|
||
else
|
||
{
|
||
/* This is a normal VMS filespec, so use it unchanged. */
|
||
strcpy (fname, fbeg);
|
||
/* if it's '#include filename', add the missing .h */
|
||
if (vaxc_include && index(fname,'.')==NULL)
|
||
strcat (fname, ".h");
|
||
}
|
||
#else
|
||
strcpy (fname, searchptr->fname);
|
||
strcat (fname, fbeg);
|
||
#endif /* VMS */
|
||
f = open_include_file (fname, searchptr, importing, &inc);
|
||
if (f != -1) {
|
||
if (bypass_slot && searchptr != first_bracket_include) {
|
||
/* This is the first time we found this include file,
|
||
and we found it after first_bracket_include.
|
||
Record its location so that we can bypass to here next time. */
|
||
struct bypass_dir *p
|
||
= (struct bypass_dir *) xmalloc (sizeof (struct bypass_dir));
|
||
p->next = *bypass_slot;
|
||
p->fname = fname + strlen (searchptr->fname);
|
||
p->searchptr = searchptr;
|
||
*bypass_slot = p;
|
||
}
|
||
break;
|
||
}
|
||
#ifdef VMS
|
||
/* Our VMS hacks can produce invalid filespecs, so don't worry
|
||
about errors other than EACCES. */
|
||
if (errno == EACCES)
|
||
break;
|
||
#else
|
||
if (errno != ENOENT && errno != ENOTDIR)
|
||
break;
|
||
#endif
|
||
}
|
||
}
|
||
|
||
|
||
if (f < 0) {
|
||
|
||
if (f == -2) {
|
||
/* The file was already included. */
|
||
|
||
/* If generating dependencies and -MG was specified, we assume missing
|
||
files are leaf files, living in the same directory as the source file
|
||
or other similar place; these missing files may be generated from
|
||
other files and may not exist yet (eg: y.tab.h). */
|
||
} else if (print_deps_missing_files
|
||
&& (system_include_depth != 0) < print_deps)
|
||
{
|
||
/* If it was requested as a system header file,
|
||
then assume it belongs in the first place to look for such. */
|
||
if (angle_brackets)
|
||
{
|
||
if (search_start) {
|
||
char *p = (char *) alloca (strlen (search_start->fname)
|
||
+ strlen (fbeg) + 1);
|
||
strcpy (p, search_start->fname);
|
||
strcat (p, fbeg);
|
||
deps_output (p, ' ');
|
||
}
|
||
}
|
||
else
|
||
{
|
||
/* Otherwise, omit the directory, as if the file existed
|
||
in the directory with the source. */
|
||
deps_output (fbeg, ' ');
|
||
}
|
||
}
|
||
/* If -M was specified, and this header file won't be added to the
|
||
dependency list, then don't count this as an error, because we can
|
||
still produce correct output. Otherwise, we can't produce correct
|
||
output, because there may be dependencies we need inside the missing
|
||
file, and we don't know what directory this missing file exists in. */
|
||
else if (0 < print_deps && print_deps <= (system_include_depth != 0))
|
||
warning ("No include path in which to find %s", fbeg);
|
||
else if (f != -3)
|
||
error_from_errno (fbeg);
|
||
else
|
||
error ("No include path in which to find %s", fbeg);
|
||
|
||
} else {
|
||
|
||
/* Actually process the file. */
|
||
|
||
pcftry = (char *) alloca (strlen (fname) + 30);
|
||
pcfbuf = 0;
|
||
pcfnum = 0;
|
||
|
||
if (!no_precomp)
|
||
{
|
||
do {
|
||
sprintf (pcftry, "%s%d", fname, pcfnum++);
|
||
|
||
pcf = open (pcftry, O_RDONLY, 0666);
|
||
if (pcf != -1)
|
||
{
|
||
struct stat s;
|
||
|
||
if (fstat (pcf, &s) != 0)
|
||
pfatal_with_name (pcftry);
|
||
if (! INO_T_EQ (inc->st.st_ino, s.st_ino)
|
||
|| inc->st.st_dev != s.st_dev)
|
||
{
|
||
pcfbuf = check_precompiled (pcf, &s, fname, &pcfbuflimit);
|
||
/* Don't need it any more. */
|
||
close (pcf);
|
||
}
|
||
else
|
||
{
|
||
/* Don't need it at all. */
|
||
close (pcf);
|
||
break;
|
||
}
|
||
}
|
||
} while (pcf != -1 && !pcfbuf);
|
||
}
|
||
|
||
/* Actually process the file */
|
||
if (pcfbuf) {
|
||
pcfname = xmalloc (strlen (pcftry) + 1);
|
||
strcpy (pcfname, pcftry);
|
||
pcfinclude ((U_CHAR *) pcfbuf, (U_CHAR *) fname, op);
|
||
}
|
||
else
|
||
finclude (f, inc, op, is_system_include (fname), searchptr);
|
||
}
|
||
|
||
system_include_depth -= angle_brackets;
|
||
|
||
return 0;
|
||
}
|
||
|
||
/* Return nonzero if the given FILENAME is an absolute pathname which
|
||
designates a file within one of the known "system" include file
|
||
directories. We assume here that if the given FILENAME looks like
|
||
it is the name of a file which resides either directly in a "system"
|
||
include file directory, or within any subdirectory thereof, then the
|
||
given file must be a "system" include file. This function tells us
|
||
if we should suppress pedantic errors/warnings for the given FILENAME.
|
||
|
||
The value is 2 if the file is a C-language system header file
|
||
for which C++ should (on most systems) assume `extern "C"'. */
|
||
|
||
static int
|
||
is_system_include (filename)
|
||
register char *filename;
|
||
{
|
||
struct file_name_list *searchptr;
|
||
|
||
for (searchptr = first_system_include; searchptr;
|
||
searchptr = searchptr->next)
|
||
if (! strncmp (searchptr->fname, filename, strlen (searchptr->fname)))
|
||
return searchptr->c_system_include_path + 1;
|
||
return 0;
|
||
}
|
||
|
||
/* Yield the non-directory suffix of a file name. */
|
||
|
||
static char *
|
||
base_name (fname)
|
||
char *fname;
|
||
{
|
||
char *s = fname;
|
||
char *p;
|
||
#if defined (__MSDOS__) || defined (_WIN32)
|
||
if (ISALPHA (s[0]) && s[1] == ':') s += 2;
|
||
#endif
|
||
#ifdef VMS
|
||
if ((p = rindex (s, ':'))) s = p + 1; /* Skip device. */
|
||
if ((p = rindex (s, ']'))) s = p + 1; /* Skip directory. */
|
||
if ((p = rindex (s, '>'))) s = p + 1; /* Skip alternate (int'n'l) dir. */
|
||
if (s != fname)
|
||
return s;
|
||
#endif
|
||
if ((p = rindex (s, '/'))) s = p + 1;
|
||
#ifdef DIR_SEPARATOR
|
||
if ((p = rindex (s, DIR_SEPARATOR))) s = p + 1;
|
||
#endif
|
||
return s;
|
||
}
|
||
|
||
/* Yield nonzero if FILENAME is absolute (i.e. not relative). */
|
||
|
||
static int
|
||
absolute_filename (filename)
|
||
char *filename;
|
||
{
|
||
#if defined (__MSDOS__) \
|
||
|| (defined (_WIN32) && !defined (__CYGWIN__) && !defined (_UWIN))
|
||
if (ISALPHA (filename[0]) && filename[1] == ':') filename += 2;
|
||
#endif
|
||
#if defined (__CYGWIN__)
|
||
/* At present, any path that begins with a drive spec is absolute. */
|
||
if (ISALPHA (filename[0]) && filename[1] == ':') return 1;
|
||
#endif
|
||
#ifdef VMS
|
||
if (index (filename, ':') != 0) return 1;
|
||
#endif
|
||
if (filename[0] == '/') return 1;
|
||
#ifdef DIR_SEPARATOR
|
||
if (filename[0] == DIR_SEPARATOR) return 1;
|
||
#endif
|
||
return 0;
|
||
}
|
||
|
||
/* Returns whether or not a given character is a directory separator.
|
||
Used by simplify_filename. */
|
||
static inline
|
||
int
|
||
is_dir_separator(ch)
|
||
char ch;
|
||
{
|
||
return (ch == DIR_SEPARATOR)
|
||
#if defined (DIR_SEPARATOR_2)
|
||
|| (ch == DIR_SEPARATOR_2)
|
||
#endif
|
||
;
|
||
}
|
||
|
||
/* Remove unnecessary characters from FILENAME in place,
|
||
to avoid unnecessary filename aliasing.
|
||
Return the length of the resulting string.
|
||
|
||
Do only the simplifications allowed by Posix.
|
||
It is OK to miss simplifications on non-Posix hosts,
|
||
since this merely leads to suboptimal results. */
|
||
|
||
static size_t
|
||
simplify_filename (filename)
|
||
char *filename;
|
||
{
|
||
register char *from = filename;
|
||
register char *to = filename;
|
||
char *to0;
|
||
|
||
/* Remove redundant initial /s. */
|
||
if (is_dir_separator (*from))
|
||
{
|
||
*to++ = DIR_SEPARATOR;
|
||
if (is_dir_separator (*++from))
|
||
{
|
||
if (is_dir_separator (*++from))
|
||
{
|
||
/* 3 or more initial /s are equivalent to 1 /. */
|
||
while (is_dir_separator (*++from))
|
||
continue;
|
||
}
|
||
else
|
||
{
|
||
/* On some hosts // differs from /; Posix allows this. */
|
||
*to++ = DIR_SEPARATOR;
|
||
}
|
||
}
|
||
}
|
||
|
||
to0 = to;
|
||
|
||
for (;;)
|
||
{
|
||
#ifndef VMS
|
||
if (from[0] == '.' && from[1] == '/')
|
||
from += 2;
|
||
else
|
||
#endif
|
||
{
|
||
/* Copy this component and trailing DIR_SEPARATOR, if any. */
|
||
while (!is_dir_separator (*to++ = *from++))
|
||
{
|
||
if (!to[-1])
|
||
{
|
||
/* Trim . component at end of nonempty name. */
|
||
to -= filename <= to - 3 && to[-3] == DIR_SEPARATOR && to[-2] == '.';
|
||
|
||
/* Trim unnecessary trailing /s. */
|
||
while (to0 < --to && to[-1] == DIR_SEPARATOR)
|
||
continue;
|
||
|
||
*to = 0;
|
||
return to - filename;
|
||
}
|
||
}
|
||
#if defined(DIR_SEPARATOR_2)
|
||
/* Simplify to one directory separator. */
|
||
to[-1] = DIR_SEPARATOR;
|
||
#endif
|
||
}
|
||
|
||
/* Skip /s after a /. */
|
||
while (is_dir_separator (*from))
|
||
from++;
|
||
}
|
||
}
|
||
|
||
/* The file_name_map structure holds a mapping of file names for a
|
||
particular directory. This mapping is read from the file named
|
||
FILE_NAME_MAP_FILE in that directory. Such a file can be used to
|
||
map filenames on a file system with severe filename restrictions,
|
||
such as DOS. The format of the file name map file is just a series
|
||
of lines with two tokens on each line. The first token is the name
|
||
to map, and the second token is the actual name to use. */
|
||
|
||
struct file_name_map
|
||
{
|
||
struct file_name_map *map_next;
|
||
char *map_from;
|
||
char *map_to;
|
||
};
|
||
|
||
#define FILE_NAME_MAP_FILE "header.gcc"
|
||
|
||
/* Read a space delimited string of unlimited length from a stdio
|
||
file. */
|
||
|
||
static char *
|
||
read_filename_string (ch, f)
|
||
int ch;
|
||
FILE *f;
|
||
{
|
||
char *alloc, *set;
|
||
int len;
|
||
|
||
len = 20;
|
||
set = alloc = xmalloc (len + 1);
|
||
if (! is_space[ch])
|
||
{
|
||
*set++ = ch;
|
||
while ((ch = getc (f)) != EOF && ! is_space[ch])
|
||
{
|
||
if (set - alloc == len)
|
||
{
|
||
len *= 2;
|
||
alloc = xrealloc (alloc, len + 1);
|
||
set = alloc + len / 2;
|
||
}
|
||
*set++ = ch;
|
||
}
|
||
}
|
||
*set = '\0';
|
||
ungetc (ch, f);
|
||
return alloc;
|
||
}
|
||
|
||
/* Read the file name map file for DIRNAME.
|
||
If DIRNAME is empty, read the map file for the working directory;
|
||
otherwise DIRNAME must end in '/'. */
|
||
|
||
static struct file_name_map *
|
||
read_name_map (dirname)
|
||
char *dirname;
|
||
{
|
||
/* This structure holds a linked list of file name maps, one per
|
||
directory. */
|
||
struct file_name_map_list
|
||
{
|
||
struct file_name_map_list *map_list_next;
|
||
char *map_list_name;
|
||
struct file_name_map *map_list_map;
|
||
};
|
||
static struct file_name_map_list *map_list;
|
||
register struct file_name_map_list *map_list_ptr;
|
||
char *name;
|
||
FILE *f;
|
||
size_t dirlen;
|
||
|
||
for (map_list_ptr = map_list; map_list_ptr;
|
||
map_list_ptr = map_list_ptr->map_list_next)
|
||
if (! strcmp (map_list_ptr->map_list_name, dirname))
|
||
return map_list_ptr->map_list_map;
|
||
|
||
map_list_ptr = ((struct file_name_map_list *)
|
||
xmalloc (sizeof (struct file_name_map_list)));
|
||
map_list_ptr->map_list_name = xstrdup (dirname);
|
||
map_list_ptr->map_list_map = NULL;
|
||
|
||
dirlen = strlen (dirname);
|
||
name = (char *) alloca (dirlen + strlen (FILE_NAME_MAP_FILE) + 1);
|
||
strcpy (name, dirname);
|
||
strcat (name, FILE_NAME_MAP_FILE);
|
||
f = fopen (name, "r");
|
||
if (!f)
|
||
map_list_ptr->map_list_map = NULL;
|
||
else
|
||
{
|
||
int ch;
|
||
|
||
while ((ch = getc (f)) != EOF)
|
||
{
|
||
char *from, *to;
|
||
struct file_name_map *ptr;
|
||
size_t tolen;
|
||
|
||
if (is_space[ch])
|
||
continue;
|
||
from = read_filename_string (ch, f);
|
||
while ((ch = getc (f)) != EOF && is_hor_space[ch])
|
||
;
|
||
to = read_filename_string (ch, f);
|
||
|
||
simplify_filename (from);
|
||
tolen = simplify_filename (to);
|
||
|
||
ptr = ((struct file_name_map *)
|
||
xmalloc (sizeof (struct file_name_map)));
|
||
ptr->map_from = from;
|
||
|
||
/* Make the real filename absolute. */
|
||
if (absolute_filename (to))
|
||
ptr->map_to = to;
|
||
else
|
||
{
|
||
ptr->map_to = xmalloc (dirlen + tolen + 1);
|
||
strcpy (ptr->map_to, dirname);
|
||
strcat (ptr->map_to, to);
|
||
free (to);
|
||
}
|
||
|
||
ptr->map_next = map_list_ptr->map_list_map;
|
||
map_list_ptr->map_list_map = ptr;
|
||
|
||
while ((ch = getc (f)) != '\n')
|
||
if (ch == EOF)
|
||
break;
|
||
}
|
||
fclose (f);
|
||
}
|
||
|
||
map_list_ptr->map_list_next = map_list;
|
||
map_list = map_list_ptr;
|
||
|
||
return map_list_ptr->map_list_map;
|
||
}
|
||
|
||
/* Try to open include file FILENAME. SEARCHPTR is the directory
|
||
being tried from the include file search path.
|
||
IMPORTING is "" if we are importing, null otherwise.
|
||
Return -2 if found, either a matching name or a matching inode.
|
||
Otherwise, open the file and return a file descriptor if successful
|
||
or -1 if unsuccessful.
|
||
Unless unsuccessful, put a descriptor of the included file into *PINC.
|
||
This function maps filenames on file systems based on information read by
|
||
read_name_map. */
|
||
|
||
static int
|
||
open_include_file (filename, searchptr, importing, pinc)
|
||
char *filename;
|
||
struct file_name_list *searchptr;
|
||
U_CHAR *importing;
|
||
struct include_file **pinc;
|
||
{
|
||
char *fname = remap ? remap_include_file (filename, searchptr) : filename;
|
||
int fd = -2;
|
||
|
||
/* Look up FNAME in include_hashtab. */
|
||
struct include_file **phead = &include_hashtab[hashf ((U_CHAR *) fname,
|
||
strlen (fname),
|
||
INCLUDE_HASHSIZE)];
|
||
struct include_file *inc, *head = *phead;
|
||
for (inc = head; inc; inc = inc->next)
|
||
if (!strcmp (fname, inc->fname))
|
||
break;
|
||
|
||
if (!inc
|
||
|| ! inc->control_macro
|
||
|| (inc->control_macro[0] && ! lookup (inc->control_macro, -1, -1))) {
|
||
|
||
fd = open (fname, O_RDONLY, 0);
|
||
|
||
if (fd < 0)
|
||
{
|
||
#ifdef VMS
|
||
/* if #include <dir/file> fails, try again with hacked spec. */
|
||
if (!hack_vms_include_specification (fname, 0))
|
||
return fd;
|
||
fd = open (fname, O_RDONLY, 0);
|
||
if (fd < 0)
|
||
#endif
|
||
return fd;
|
||
}
|
||
|
||
if (!inc) {
|
||
/* FNAME was not in include_hashtab; insert a new entry. */
|
||
inc = (struct include_file *) xmalloc (sizeof (struct include_file));
|
||
inc->next = head;
|
||
inc->fname = fname;
|
||
inc->control_macro = 0;
|
||
inc->deps_output = 0;
|
||
if (fstat (fd, &inc->st) != 0)
|
||
pfatal_with_name (fname);
|
||
*phead = inc;
|
||
|
||
/* Look for another file with the same inode and device. */
|
||
if (lookup_ino_include (inc)
|
||
&& inc->control_macro
|
||
&& (!inc->control_macro[0] || lookup (inc->control_macro, -1, -1))) {
|
||
close (fd);
|
||
fd = -2;
|
||
}
|
||
}
|
||
|
||
/* For -M, add this file to the dependencies. */
|
||
if (! inc->deps_output && (system_include_depth != 0) < print_deps) {
|
||
inc->deps_output = 1;
|
||
deps_output (fname, ' ');
|
||
}
|
||
|
||
/* Handle -H option. */
|
||
if (print_include_names)
|
||
fprintf (stderr, "%*s%s\n", indepth, "", fname);
|
||
}
|
||
|
||
if (importing)
|
||
inc->control_macro = importing;
|
||
|
||
*pinc = inc;
|
||
return fd;
|
||
}
|
||
|
||
/* Return the remapped name of the include file FILENAME.
|
||
SEARCHPTR is the directory being tried from the include file path. */
|
||
|
||
static char *
|
||
remap_include_file (filename, searchptr)
|
||
char *filename;
|
||
struct file_name_list *searchptr;
|
||
{
|
||
register struct file_name_map *map;
|
||
register char *from;
|
||
|
||
#ifndef FREEBSD_NATIVE
|
||
if (searchptr)
|
||
{
|
||
if (! searchptr->got_name_map)
|
||
{
|
||
searchptr->name_map = read_name_map (searchptr->fname);
|
||
searchptr->got_name_map = 1;
|
||
}
|
||
|
||
/* Check the mapping for the directory we are using. */
|
||
from = filename + strlen (searchptr->fname);
|
||
for (map = searchptr->name_map; map; map = map->map_next)
|
||
if (! strcmp (map->map_from, from))
|
||
return map->map_to;
|
||
}
|
||
#endif
|
||
|
||
from = base_name (filename);
|
||
|
||
if (from != filename || !searchptr)
|
||
{
|
||
/* Try to find a mapping file for the particular directory we are
|
||
looking in. Thus #include <sys/types.h> will look up sys/types.h
|
||
in /usr/include/header.gcc and look up types.h in
|
||
/usr/include/sys/header.gcc. */
|
||
|
||
char *dir = (char *) alloca (from - filename + 1);
|
||
bcopy (filename, dir, from - filename);
|
||
dir[from - filename] = '\0';
|
||
|
||
#ifndef FREEBSD_NATIVE
|
||
for (map = read_name_map (dir); map; map = map->map_next)
|
||
if (! strcmp (map->map_from, from))
|
||
return map->map_to;
|
||
#endif
|
||
}
|
||
|
||
return filename;
|
||
}
|
||
|
||
/* Insert INC into the include file table, hashed by device and inode number.
|
||
If a file with different name but same dev+ino was already in the table,
|
||
return 1 and set INC's control macro to the already-known macro. */
|
||
|
||
static int
|
||
lookup_ino_include (inc)
|
||
struct include_file *inc;
|
||
{
|
||
int hash = ((unsigned) (inc->st.st_dev + INO_T_HASH (inc->st.st_ino))
|
||
% INCLUDE_HASHSIZE);
|
||
struct include_file *i = include_ino_hashtab[hash];
|
||
inc->next_ino = i;
|
||
include_ino_hashtab[hash] = inc;
|
||
|
||
for (; i; i = i->next_ino)
|
||
if (INO_T_EQ (inc->st.st_ino, i->st.st_ino)
|
||
&& inc->st.st_dev == i->st.st_dev) {
|
||
inc->control_macro = i->control_macro;
|
||
return 1;
|
||
}
|
||
|
||
return 0;
|
||
}
|
||
|
||
/* Process file descriptor F, which corresponds to include file INC,
|
||
with output to OP.
|
||
SYSTEM_HEADER_P is 1 if this file resides in any one of the known
|
||
"system" include directories (as decided by the `is_system_include'
|
||
function above).
|
||
DIRPTR is the link in the dir path through which this file was found,
|
||
or 0 if the file name was absolute. */
|
||
|
||
static void
|
||
finclude (f, inc, op, system_header_p, dirptr)
|
||
int f;
|
||
struct include_file *inc;
|
||
FILE_BUF *op;
|
||
int system_header_p;
|
||
struct file_name_list *dirptr;
|
||
{
|
||
char *fname = inc->fname;
|
||
int i;
|
||
FILE_BUF *fp; /* For input stack frame */
|
||
int missing_newline = 0;
|
||
|
||
CHECK_DEPTH (return;);
|
||
|
||
fp = &instack[indepth + 1];
|
||
bzero ((char *) fp, sizeof (FILE_BUF));
|
||
fp->nominal_fname = fp->fname = fname;
|
||
fp->nominal_fname_len = strlen (fname);
|
||
fp->inc = inc;
|
||
fp->length = 0;
|
||
fp->lineno = 1;
|
||
fp->if_stack = if_stack;
|
||
fp->system_header_p = system_header_p;
|
||
fp->dir = dirptr;
|
||
|
||
if (S_ISREG (inc->st.st_mode)) {
|
||
size_t s = (size_t) inc->st.st_size;
|
||
if (s != inc->st.st_size || s + 2 < s)
|
||
memory_full ();
|
||
fp->buf = (U_CHAR *) xmalloc (s + 2);
|
||
fp->bufp = fp->buf;
|
||
|
||
/* Read the file contents, knowing that s is an upper bound
|
||
on the number of bytes we can read. */
|
||
fp->length = safe_read (f, (char *) fp->buf, s);
|
||
if (fp->length < 0) goto nope;
|
||
}
|
||
else if (S_ISDIR (inc->st.st_mode)) {
|
||
error ("directory `%s' specified in #include", fname);
|
||
close (f);
|
||
return;
|
||
} else {
|
||
/* Cannot count its file size before reading.
|
||
First read the entire file into heap and
|
||
copy them into buffer on stack. */
|
||
|
||
int bsize = 2000;
|
||
int st_size = 0;
|
||
|
||
fp->buf = (U_CHAR *) xmalloc (bsize + 2);
|
||
|
||
for (;;) {
|
||
i = safe_read (f, (char *) fp->buf + st_size, bsize - st_size);
|
||
if (i < 0)
|
||
goto nope; /* error! */
|
||
st_size += i;
|
||
if (st_size != bsize)
|
||
break; /* End of file */
|
||
bsize *= 2;
|
||
fp->buf = (U_CHAR *) xrealloc (fp->buf, bsize + 2);
|
||
}
|
||
fp->bufp = fp->buf;
|
||
fp->length = st_size;
|
||
}
|
||
|
||
if ((fp->length > 0 && fp->buf[fp->length - 1] != '\n')
|
||
/* Backslash-newline at end is not good enough. */
|
||
|| (fp->length > 1 && fp->buf[fp->length - 2] == '\\')) {
|
||
fp->buf[fp->length++] = '\n';
|
||
missing_newline = 1;
|
||
}
|
||
fp->buf[fp->length] = '\0';
|
||
|
||
/* Close descriptor now, so nesting does not use lots of descriptors. */
|
||
close (f);
|
||
|
||
/* Must do this before calling trigraph_pcp, so that the correct file name
|
||
will be printed in warning messages. */
|
||
|
||
indepth++;
|
||
input_file_stack_tick++;
|
||
|
||
if (!no_trigraphs)
|
||
trigraph_pcp (fp);
|
||
|
||
output_line_directive (fp, op, 0, enter_file);
|
||
rescan (op, 0);
|
||
|
||
if (missing_newline)
|
||
fp->lineno--;
|
||
|
||
if (pedantic && missing_newline)
|
||
pedwarn ("file does not end in newline");
|
||
|
||
indepth--;
|
||
input_file_stack_tick++;
|
||
output_line_directive (&instack[indepth], op, 0, leave_file);
|
||
free (fp->buf);
|
||
return;
|
||
|
||
nope:
|
||
|
||
perror_with_name (fname);
|
||
close (f);
|
||
free (fp->buf);
|
||
}
|
||
|
||
/* Record that inclusion of the include file INC
|
||
should be controlled by the macro named MACRO_NAME.
|
||
This means that trying to include the file again
|
||
will do something if that macro is defined. */
|
||
|
||
static void
|
||
record_control_macro (inc, macro_name)
|
||
struct include_file *inc;
|
||
U_CHAR *macro_name;
|
||
{
|
||
if (!inc->control_macro || inc->control_macro[0])
|
||
inc->control_macro = macro_name;
|
||
}
|
||
|
||
/* Load the specified precompiled header into core, and verify its
|
||
preconditions. PCF indicates the file descriptor to read, which must
|
||
be a regular file. *ST is its file status.
|
||
FNAME indicates the file name of the original header.
|
||
*LIMIT will be set to an address one past the end of the file.
|
||
If the preconditions of the file are not satisfied, the buffer is
|
||
freed and we return 0. If the preconditions are satisfied, return
|
||
the address of the buffer following the preconditions. The buffer, in
|
||
this case, should never be freed because various pieces of it will
|
||
be referred to until all precompiled strings are output at the end of
|
||
the run. */
|
||
|
||
static char *
|
||
check_precompiled (pcf, st, fname, limit)
|
||
int pcf;
|
||
struct stat *st;
|
||
char *fname ATTRIBUTE_UNUSED;
|
||
char **limit;
|
||
{
|
||
int length = 0;
|
||
char *buf;
|
||
char *cp;
|
||
|
||
if (pcp_outfile)
|
||
return 0;
|
||
|
||
if (S_ISREG (st->st_mode))
|
||
{
|
||
size_t s = (size_t) st->st_size;
|
||
if (s != st->st_size || s + 2 < s)
|
||
memory_full ();
|
||
buf = xmalloc (s + 2);
|
||
length = safe_read (pcf, buf, s);
|
||
if (length < 0)
|
||
goto nope;
|
||
}
|
||
else
|
||
abort ();
|
||
|
||
if (length > 0 && buf[length-1] != '\n')
|
||
buf[length++] = '\n';
|
||
buf[length] = '\0';
|
||
|
||
*limit = buf + length;
|
||
|
||
/* File is in core. Check the preconditions. */
|
||
if (!check_preconditions (buf))
|
||
goto nope;
|
||
for (cp = buf; *cp; cp++)
|
||
;
|
||
#ifdef DEBUG_PCP
|
||
fprintf (stderr, "Using preinclude %s\n", fname);
|
||
#endif
|
||
return cp + 1;
|
||
|
||
nope:
|
||
#ifdef DEBUG_PCP
|
||
fprintf (stderr, "Cannot use preinclude %s\n", fname);
|
||
#endif
|
||
free (buf);
|
||
return 0;
|
||
}
|
||
|
||
/* PREC (null terminated) points to the preconditions of a
|
||
precompiled header. These are a series of #define and #undef
|
||
lines which must match the current contents of the hash
|
||
table. */
|
||
|
||
static int
|
||
check_preconditions (prec)
|
||
char *prec;
|
||
{
|
||
MACRODEF mdef;
|
||
char *lineend;
|
||
|
||
while (*prec) {
|
||
lineend = index (prec, '\n');
|
||
|
||
if (*prec++ != '#') {
|
||
error ("Bad format encountered while reading precompiled file");
|
||
return 0;
|
||
}
|
||
if (!strncmp (prec, "define", 6)) {
|
||
HASHNODE *hp;
|
||
|
||
prec += 6;
|
||
mdef = create_definition ((U_CHAR *) prec, (U_CHAR *) lineend, NULL_PTR);
|
||
|
||
if (mdef.defn == 0)
|
||
abort ();
|
||
|
||
if ((hp = lookup (mdef.symnam, mdef.symlen, -1)) == NULL
|
||
|| (hp->type != T_MACRO && hp->type != T_CONST)
|
||
|| (hp->type == T_MACRO
|
||
&& !compare_defs (mdef.defn, hp->value.defn)
|
||
&& (mdef.defn->length != 2
|
||
|| mdef.defn->expansion[0] != '\n'
|
||
|| mdef.defn->expansion[1] != ' ')))
|
||
return 0;
|
||
} else if (!strncmp (prec, "undef", 5)) {
|
||
char *name;
|
||
int len;
|
||
|
||
prec += 5;
|
||
while (is_hor_space[(U_CHAR) *prec])
|
||
prec++;
|
||
name = prec;
|
||
while (is_idchar[(U_CHAR) *prec])
|
||
prec++;
|
||
len = prec - name;
|
||
|
||
if (lookup ((U_CHAR *) name, len, -1))
|
||
return 0;
|
||
} else {
|
||
error ("Bad format encountered while reading precompiled file");
|
||
return 0;
|
||
}
|
||
prec = lineend + 1;
|
||
}
|
||
/* They all passed successfully */
|
||
return 1;
|
||
}
|
||
|
||
/* Process the main body of a precompiled file. BUF points to the
|
||
string section of the file, following the preconditions. LIMIT is one
|
||
character past the end. NAME is the name of the file being read
|
||
in. OP is the main output buffer. */
|
||
|
||
static void
|
||
pcfinclude (buf, name, op)
|
||
U_CHAR *buf, *name;
|
||
FILE_BUF *op;
|
||
{
|
||
FILE_BUF tmpbuf;
|
||
int nstrings;
|
||
U_CHAR *cp = buf;
|
||
|
||
/* First in the file comes 4 bytes indicating the number of strings, */
|
||
/* in network byte order. (MSB first). */
|
||
nstrings = *cp++;
|
||
nstrings = (nstrings << 8) | *cp++;
|
||
nstrings = (nstrings << 8) | *cp++;
|
||
nstrings = (nstrings << 8) | *cp++;
|
||
|
||
/* Looping over each string... */
|
||
while (nstrings--) {
|
||
U_CHAR *string_start;
|
||
U_CHAR *endofthiskey;
|
||
STRINGDEF *str;
|
||
int nkeys;
|
||
|
||
/* Each string starts with a STRINGDEF structure (str), followed */
|
||
/* by the text of the string (string_start) */
|
||
|
||
/* First skip to a longword boundary */
|
||
/* ??? Why a 4-byte boundary? On all machines? */
|
||
/* NOTE: This works correctly even if size_t
|
||
is narrower than a pointer.
|
||
Do not try risky measures here to get another type to use!
|
||
Do not include stddef.h--it will fail! */
|
||
if ((size_t) cp & 3)
|
||
cp += 4 - ((size_t) cp & 3);
|
||
|
||
/* Now get the string. */
|
||
str = (STRINGDEF *) (GENERIC_PTR) cp;
|
||
string_start = cp += sizeof (STRINGDEF);
|
||
|
||
for (; *cp; cp++) /* skip the string */
|
||
;
|
||
|
||
/* We need to macro expand the string here to ensure that the
|
||
proper definition environment is in place. If it were only
|
||
expanded when we find out it is needed, macros necessary for
|
||
its proper expansion might have had their definitions changed. */
|
||
tmpbuf = expand_to_temp_buffer (string_start, cp++, 0, 0);
|
||
/* Lineno is already set in the precompiled file */
|
||
str->contents = tmpbuf.buf;
|
||
str->len = tmpbuf.length;
|
||
str->writeflag = 0;
|
||
str->filename = name;
|
||
str->output_mark = outbuf.bufp - outbuf.buf;
|
||
|
||
str->chain = 0;
|
||
*stringlist_tailp = str;
|
||
stringlist_tailp = &str->chain;
|
||
|
||
/* Next comes a fourbyte number indicating the number of keys
|
||
for this string. */
|
||
nkeys = *cp++;
|
||
nkeys = (nkeys << 8) | *cp++;
|
||
nkeys = (nkeys << 8) | *cp++;
|
||
nkeys = (nkeys << 8) | *cp++;
|
||
|
||
/* If this number is -1, then the string is mandatory. */
|
||
if (nkeys == -1)
|
||
str->writeflag = 1;
|
||
else
|
||
/* Otherwise, for each key, */
|
||
for (; nkeys--; free (tmpbuf.buf), cp = endofthiskey + 1) {
|
||
KEYDEF *kp = (KEYDEF *) (GENERIC_PTR) cp;
|
||
HASHNODE *hp;
|
||
|
||
/* It starts with a KEYDEF structure */
|
||
cp += sizeof (KEYDEF);
|
||
|
||
/* Find the end of the key. At the end of this for loop we
|
||
advance CP to the start of the next key using this variable. */
|
||
endofthiskey = cp + strlen ((char *) cp);
|
||
kp->str = str;
|
||
|
||
/* Expand the key, and enter it into the hash table. */
|
||
tmpbuf = expand_to_temp_buffer (cp, endofthiskey, 0, 0);
|
||
tmpbuf.bufp = tmpbuf.buf;
|
||
|
||
while (is_hor_space[*tmpbuf.bufp])
|
||
tmpbuf.bufp++;
|
||
if (!is_idstart[*tmpbuf.bufp]
|
||
|| tmpbuf.bufp == tmpbuf.buf + tmpbuf.length) {
|
||
str->writeflag = 1;
|
||
continue;
|
||
}
|
||
|
||
hp = lookup (tmpbuf.bufp, -1, -1);
|
||
if (hp == NULL) {
|
||
kp->chain = 0;
|
||
install (tmpbuf.bufp, -1, T_PCSTRING, (char *) kp, -1);
|
||
}
|
||
else if (hp->type == T_PCSTRING) {
|
||
kp->chain = hp->value.keydef;
|
||
hp->value.keydef = kp;
|
||
}
|
||
else
|
||
str->writeflag = 1;
|
||
}
|
||
}
|
||
/* This output_line_directive serves to switch us back to the current
|
||
input file in case some of these strings get output (which will
|
||
result in line directives for the header file being output). */
|
||
output_line_directive (&instack[indepth], op, 0, enter_file);
|
||
}
|
||
|
||
/* Called from rescan when it hits a key for strings. Mark them all
|
||
used and clean up. */
|
||
|
||
static void
|
||
pcstring_used (hp)
|
||
HASHNODE *hp;
|
||
{
|
||
KEYDEF *kp;
|
||
|
||
for (kp = hp->value.keydef; kp; kp = kp->chain)
|
||
kp->str->writeflag = 1;
|
||
delete_macro (hp);
|
||
}
|
||
|
||
/* Write the output, interspersing precompiled strings in their
|
||
appropriate places. */
|
||
|
||
static void
|
||
write_output ()
|
||
{
|
||
STRINGDEF *next_string;
|
||
U_CHAR *cur_buf_loc;
|
||
int line_directive_len = 80;
|
||
char *line_directive = xmalloc (line_directive_len);
|
||
int len;
|
||
|
||
/* In each run through the loop, either cur_buf_loc ==
|
||
next_string_loc, in which case we print a series of strings, or
|
||
it is less than next_string_loc, in which case we write some of
|
||
the buffer. */
|
||
cur_buf_loc = outbuf.buf;
|
||
next_string = stringlist;
|
||
|
||
while (cur_buf_loc < outbuf.bufp || next_string) {
|
||
if (next_string
|
||
&& cur_buf_loc - outbuf.buf == next_string->output_mark) {
|
||
if (next_string->writeflag) {
|
||
len = 4 * strlen ((char *) next_string->filename) + 32;
|
||
while (len > line_directive_len)
|
||
line_directive = xrealloc (line_directive,
|
||
line_directive_len *= 2);
|
||
sprintf (line_directive, "\n# %d ", next_string->lineno);
|
||
strcpy (quote_string (line_directive + strlen (line_directive),
|
||
(char *) next_string->filename,
|
||
strlen ((char *) next_string->filename)),
|
||
"\n");
|
||
safe_write (fileno (stdout), line_directive, strlen (line_directive));
|
||
safe_write (fileno (stdout),
|
||
(char *) next_string->contents, next_string->len);
|
||
}
|
||
next_string = next_string->chain;
|
||
}
|
||
else {
|
||
len = (next_string
|
||
? (next_string->output_mark
|
||
- (cur_buf_loc - outbuf.buf))
|
||
: outbuf.bufp - cur_buf_loc);
|
||
|
||
safe_write (fileno (stdout), (char *) cur_buf_loc, len);
|
||
cur_buf_loc += len;
|
||
}
|
||
}
|
||
free (line_directive);
|
||
}
|
||
|
||
/* Pass a directive through to the output file.
|
||
BUF points to the contents of the directive, as a contiguous string.
|
||
LIMIT points to the first character past the end of the directive.
|
||
KEYWORD is the keyword-table entry for the directive. */
|
||
|
||
static void
|
||
pass_thru_directive (buf, limit, op, keyword)
|
||
U_CHAR *buf, *limit;
|
||
FILE_BUF *op;
|
||
struct directive *keyword;
|
||
{
|
||
register int keyword_length = keyword->length;
|
||
|
||
check_expand (op, 1 + keyword_length + (limit - buf));
|
||
*op->bufp++ = '#';
|
||
bcopy (keyword->name, (char *) op->bufp, keyword_length);
|
||
op->bufp += keyword_length;
|
||
if (limit != buf && buf[0] != ' ')
|
||
*op->bufp++ = ' ';
|
||
bcopy ((char *) buf, (char *) op->bufp, limit - buf);
|
||
op->bufp += (limit - buf);
|
||
#if 0
|
||
*op->bufp++ = '\n';
|
||
/* Count the line we have just made in the output,
|
||
to get in sync properly. */
|
||
op->lineno++;
|
||
#endif
|
||
}
|
||
|
||
/* The arglist structure is built by do_define to tell
|
||
collect_definition where the argument names begin. That
|
||
is, for a define like "#define f(x,y,z) foo+x-bar*y", the arglist
|
||
would contain pointers to the strings x, y, and z.
|
||
Collect_definition would then build a DEFINITION node,
|
||
with reflist nodes pointing to the places x, y, and z had
|
||
appeared. So the arglist is just convenience data passed
|
||
between these two routines. It is not kept around after
|
||
the current #define has been processed and entered into the
|
||
hash table. */
|
||
|
||
struct arglist {
|
||
struct arglist *next;
|
||
U_CHAR *name;
|
||
int length;
|
||
int argno;
|
||
char rest_args;
|
||
};
|
||
|
||
/* Create a DEFINITION node from a #define directive. Arguments are
|
||
as for do_define. */
|
||
|
||
static MACRODEF
|
||
create_definition (buf, limit, op)
|
||
U_CHAR *buf, *limit;
|
||
FILE_BUF *op;
|
||
{
|
||
U_CHAR *bp; /* temp ptr into input buffer */
|
||
U_CHAR *symname; /* remember where symbol name starts */
|
||
int sym_length; /* and how long it is */
|
||
int line = instack[indepth].lineno;
|
||
char *file = instack[indepth].nominal_fname;
|
||
size_t file_len = instack[indepth].nominal_fname_len;
|
||
int rest_args = 0;
|
||
|
||
DEFINITION *defn;
|
||
int arglengths = 0; /* Accumulate lengths of arg names
|
||
plus number of args. */
|
||
MACRODEF mdef;
|
||
|
||
bp = buf;
|
||
|
||
while (is_hor_space[*bp])
|
||
bp++;
|
||
|
||
symname = bp; /* remember where it starts */
|
||
sym_length = check_macro_name (bp, 0);
|
||
bp += sym_length;
|
||
|
||
/* Lossage will occur if identifiers or control keywords are broken
|
||
across lines using backslash. This is not the right place to take
|
||
care of that. */
|
||
|
||
if (*bp == '(') {
|
||
struct arglist *arg_ptrs = NULL;
|
||
int argno = 0;
|
||
|
||
bp++; /* skip '(' */
|
||
SKIP_WHITE_SPACE (bp);
|
||
|
||
/* Loop over macro argument names. */
|
||
while (*bp != ')') {
|
||
struct arglist *temp;
|
||
|
||
temp = (struct arglist *) alloca (sizeof (struct arglist));
|
||
temp->name = bp;
|
||
temp->next = arg_ptrs;
|
||
temp->argno = argno++;
|
||
temp->rest_args = 0;
|
||
arg_ptrs = temp;
|
||
|
||
if (rest_args)
|
||
pedwarn ("another parameter follows `%s'",
|
||
rest_extension);
|
||
|
||
if (!is_idstart[*bp])
|
||
{
|
||
if (c9x && limit - bp > (long) REST_EXTENSION_LENGTH
|
||
&& bcmp (rest_extension, bp, REST_EXTENSION_LENGTH) == 0)
|
||
{
|
||
/* This is the ISO C 9x way to write macros with variable
|
||
number of arguments. */
|
||
rest_args = 1;
|
||
temp->rest_args = 1;
|
||
}
|
||
else
|
||
pedwarn ("invalid character in macro parameter name");
|
||
}
|
||
|
||
/* Find the end of the arg name. */
|
||
while (is_idchar[*bp]) {
|
||
bp++;
|
||
/* do we have a "special" rest-args extension here? */
|
||
if (limit - bp > (long) REST_EXTENSION_LENGTH
|
||
&& bcmp (rest_extension, bp, REST_EXTENSION_LENGTH) == 0) {
|
||
if (pedantic && !instack[indepth].system_header_p)
|
||
pedwarn ("ANSI C does not allow macro with variable arguments");
|
||
rest_args = 1;
|
||
temp->rest_args = 1;
|
||
break;
|
||
}
|
||
}
|
||
if (bp == temp->name && rest_args == 1)
|
||
{
|
||
/* This is the ISO C 9x style. */
|
||
temp->name = (U_CHAR *) va_args_name;
|
||
temp->length = VA_ARGS_NAME_LENGTH;
|
||
}
|
||
else
|
||
temp->length = bp - temp->name;
|
||
if (rest_args == 1)
|
||
bp += REST_EXTENSION_LENGTH;
|
||
arglengths += temp->length + 2;
|
||
SKIP_WHITE_SPACE (bp);
|
||
if (temp->length == 0 || (*bp != ',' && *bp != ')')) {
|
||
error ("badly punctuated parameter list in `#define'");
|
||
goto nope;
|
||
}
|
||
if (*bp == ',') {
|
||
bp++;
|
||
SKIP_WHITE_SPACE (bp);
|
||
/* A comma at this point can only be followed by an identifier. */
|
||
if (!is_idstart[*bp]
|
||
&& !(c9x && limit - bp > (long) REST_EXTENSION_LENGTH
|
||
&& bcmp (rest_extension, bp, REST_EXTENSION_LENGTH) == 0)) {
|
||
error ("badly punctuated parameter list in `#define'");
|
||
goto nope;
|
||
}
|
||
}
|
||
if (bp >= limit) {
|
||
error ("unterminated parameter list in `#define'");
|
||
goto nope;
|
||
}
|
||
{
|
||
struct arglist *otemp;
|
||
|
||
for (otemp = temp->next; otemp != NULL; otemp = otemp->next)
|
||
if (temp->length == otemp->length
|
||
&& bcmp (temp->name, otemp->name, temp->length) == 0)
|
||
{
|
||
error ("duplicate argument name `%.*s' in `#define'",
|
||
temp->length, temp->name);
|
||
goto nope;
|
||
}
|
||
if (rest_args == 0 && temp->length == VA_ARGS_NAME_LENGTH
|
||
&& bcmp (temp->name, va_args_name, VA_ARGS_NAME_LENGTH) == 0)
|
||
{
|
||
error ("\
|
||
reserved name `%s' used as argument name in `#define'", va_args_name);
|
||
goto nope;
|
||
}
|
||
}
|
||
}
|
||
|
||
++bp; /* skip paren */
|
||
SKIP_WHITE_SPACE (bp);
|
||
/* now everything from bp before limit is the definition. */
|
||
defn = collect_expansion (bp, limit, argno, arg_ptrs);
|
||
defn->rest_args = rest_args;
|
||
|
||
/* Now set defn->args.argnames to the result of concatenating
|
||
the argument names in reverse order
|
||
with comma-space between them. */
|
||
defn->args.argnames = (U_CHAR *) xmalloc (arglengths + 1);
|
||
{
|
||
struct arglist *temp;
|
||
int i = 0;
|
||
for (temp = arg_ptrs; temp; temp = temp->next) {
|
||
bcopy (temp->name, &defn->args.argnames[i], temp->length);
|
||
i += temp->length;
|
||
if (temp->next != 0) {
|
||
defn->args.argnames[i++] = ',';
|
||
defn->args.argnames[i++] = ' ';
|
||
}
|
||
}
|
||
defn->args.argnames[i] = 0;
|
||
}
|
||
} else {
|
||
/* Simple expansion or empty definition. */
|
||
|
||
if (bp < limit)
|
||
{
|
||
if (is_hor_space[*bp]) {
|
||
bp++;
|
||
SKIP_WHITE_SPACE (bp);
|
||
} else if (sym_length) {
|
||
switch (*bp) {
|
||
case '!': case '"': case '#': case '%': case '&': case '\'':
|
||
case ')': case '*': case '+': case ',': case '-': case '.':
|
||
case '/': case ':': case ';': case '<': case '=': case '>':
|
||
case '?': case '[': case '\\': case ']': case '^': case '{':
|
||
case '|': case '}': case '~':
|
||
warning ("missing white space after `#define %.*s'",
|
||
sym_length, symname);
|
||
break;
|
||
|
||
default:
|
||
pedwarn ("missing white space after `#define %.*s'",
|
||
sym_length, symname);
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
/* Now everything from bp before limit is the definition. */
|
||
defn = collect_expansion (bp, limit, -1, NULL_PTR);
|
||
defn->args.argnames = (U_CHAR *) "";
|
||
}
|
||
|
||
defn->line = line;
|
||
defn->file = file;
|
||
defn->file_len = file_len;
|
||
|
||
/* OP is null if this is a predefinition */
|
||
defn->predefined = !op;
|
||
mdef.defn = defn;
|
||
mdef.symnam = symname;
|
||
mdef.symlen = sym_length;
|
||
|
||
return mdef;
|
||
|
||
nope:
|
||
mdef.defn = 0;
|
||
return mdef;
|
||
}
|
||
|
||
/* Process a #define directive.
|
||
BUF points to the contents of the #define directive, as a contiguous string.
|
||
LIMIT points to the first character past the end of the definition.
|
||
KEYWORD is the keyword-table entry for #define. */
|
||
|
||
static int
|
||
do_define (buf, limit, op, keyword)
|
||
U_CHAR *buf, *limit;
|
||
FILE_BUF *op;
|
||
struct directive *keyword;
|
||
{
|
||
int hashcode;
|
||
MACRODEF mdef;
|
||
|
||
/* If this is a precompiler run (with -pcp) pass thru #define directives. */
|
||
if (pcp_outfile && op)
|
||
pass_thru_directive (buf, limit, op, keyword);
|
||
|
||
mdef = create_definition (buf, limit, op);
|
||
if (mdef.defn == 0)
|
||
goto nope;
|
||
|
||
hashcode = hashf (mdef.symnam, mdef.symlen, HASHSIZE);
|
||
|
||
{
|
||
HASHNODE *hp;
|
||
if ((hp = lookup (mdef.symnam, mdef.symlen, hashcode)) != NULL) {
|
||
int ok = 0;
|
||
/* Redefining a precompiled key is ok. */
|
||
if (hp->type == T_PCSTRING)
|
||
ok = 1;
|
||
/* Redefining a macro is ok if the definitions are the same. */
|
||
else if (hp->type == T_MACRO)
|
||
ok = ! compare_defs (mdef.defn, hp->value.defn);
|
||
/* Redefining a constant is ok with -D. */
|
||
else if (hp->type == T_CONST)
|
||
ok = ! done_initializing;
|
||
/* Print the warning if it's not ok. */
|
||
if (!ok) {
|
||
/* If we are passing through #define and #undef directives, do
|
||
that for this re-definition now. */
|
||
if (debug_output && op)
|
||
pass_thru_directive (buf, limit, op, keyword);
|
||
|
||
pedwarn ("`%.*s' redefined", mdef.symlen, mdef.symnam);
|
||
if (hp->type == T_MACRO)
|
||
pedwarn_with_file_and_line (hp->value.defn->file,
|
||
hp->value.defn->file_len,
|
||
hp->value.defn->line,
|
||
"this is the location of the previous definition");
|
||
}
|
||
/* Replace the old definition. */
|
||
hp->type = T_MACRO;
|
||
hp->value.defn = mdef.defn;
|
||
} else {
|
||
/* If we are passing through #define and #undef directives, do
|
||
that for this new definition now. */
|
||
if (debug_output && op)
|
||
pass_thru_directive (buf, limit, op, keyword);
|
||
install (mdef.symnam, mdef.symlen, T_MACRO,
|
||
(char *) mdef.defn, hashcode);
|
||
}
|
||
}
|
||
|
||
return 0;
|
||
|
||
nope:
|
||
|
||
return 1;
|
||
}
|
||
|
||
/* Check a purported macro name SYMNAME, and yield its length.
|
||
ASSERTION is nonzero if this is really for an assertion name. */
|
||
|
||
static int
|
||
check_macro_name (symname, assertion)
|
||
U_CHAR *symname;
|
||
int assertion;
|
||
{
|
||
U_CHAR *p;
|
||
int sym_length;
|
||
|
||
for (p = symname; is_idchar[*p]; p++)
|
||
;
|
||
sym_length = p - symname;
|
||
if (sym_length == 0
|
||
|| (sym_length == 1 && *symname == 'L' && (*p == '\'' || *p == '"')))
|
||
error (assertion ? "invalid assertion name" : "invalid macro name");
|
||
else if (!is_idstart[*symname]
|
||
|| (sym_length == 7 && ! bcmp (symname, "defined", 7)))
|
||
error ((assertion
|
||
? "invalid assertion name `%.*s'"
|
||
: "invalid macro name `%.*s'"),
|
||
sym_length, symname);
|
||
return sym_length;
|
||
}
|
||
|
||
/* Return zero if two DEFINITIONs are isomorphic. */
|
||
|
||
static int
|
||
compare_defs (d1, d2)
|
||
DEFINITION *d1, *d2;
|
||
{
|
||
register struct reflist *a1, *a2;
|
||
register U_CHAR *p1 = d1->expansion;
|
||
register U_CHAR *p2 = d2->expansion;
|
||
int first = 1;
|
||
|
||
if (d1->nargs != d2->nargs)
|
||
return 1;
|
||
if (pedantic
|
||
&& strcmp ((char *)d1->args.argnames, (char *)d2->args.argnames))
|
||
return 1;
|
||
for (a1 = d1->pattern, a2 = d2->pattern; a1 && a2;
|
||
a1 = a1->next, a2 = a2->next) {
|
||
if (!((a1->nchars == a2->nchars && ! bcmp (p1, p2, a1->nchars))
|
||
|| ! comp_def_part (first, p1, a1->nchars, p2, a2->nchars, 0))
|
||
|| a1->argno != a2->argno
|
||
|| a1->stringify != a2->stringify
|
||
|| a1->raw_before != a2->raw_before
|
||
|| a1->raw_after != a2->raw_after)
|
||
return 1;
|
||
first = 0;
|
||
p1 += a1->nchars;
|
||
p2 += a2->nchars;
|
||
}
|
||
if (a1 != a2)
|
||
return 1;
|
||
if (comp_def_part (first, p1, d1->length - (p1 - d1->expansion),
|
||
p2, d2->length - (p2 - d2->expansion), 1))
|
||
return 1;
|
||
return 0;
|
||
}
|
||
|
||
/* Return 1 if two parts of two macro definitions are effectively different.
|
||
One of the parts starts at BEG1 and has LEN1 chars;
|
||
the other has LEN2 chars at BEG2.
|
||
Any sequence of whitespace matches any other sequence of whitespace.
|
||
FIRST means these parts are the first of a macro definition;
|
||
so ignore leading whitespace entirely.
|
||
LAST means these parts are the last of a macro definition;
|
||
so ignore trailing whitespace entirely. */
|
||
|
||
static int
|
||
comp_def_part (first, beg1, len1, beg2, len2, last)
|
||
int first;
|
||
U_CHAR *beg1, *beg2;
|
||
int len1, len2;
|
||
int last;
|
||
{
|
||
register U_CHAR *end1 = beg1 + len1;
|
||
register U_CHAR *end2 = beg2 + len2;
|
||
if (first) {
|
||
while (beg1 != end1 && is_space[*beg1]) beg1++;
|
||
while (beg2 != end2 && is_space[*beg2]) beg2++;
|
||
}
|
||
if (last) {
|
||
while (beg1 != end1 && is_space[end1[-1]]) end1--;
|
||
while (beg2 != end2 && is_space[end2[-1]]) end2--;
|
||
}
|
||
while (beg1 != end1 && beg2 != end2) {
|
||
if (is_space[*beg1] && is_space[*beg2]) {
|
||
while (beg1 != end1 && is_space[*beg1]) beg1++;
|
||
while (beg2 != end2 && is_space[*beg2]) beg2++;
|
||
} else if (*beg1 == *beg2) {
|
||
beg1++; beg2++;
|
||
} else break;
|
||
}
|
||
return (beg1 != end1) || (beg2 != end2);
|
||
}
|
||
|
||
/* Read a replacement list for a macro with parameters.
|
||
Build the DEFINITION structure.
|
||
Reads characters of text starting at BUF until END.
|
||
ARGLIST specifies the formal parameters to look for
|
||
in the text of the definition; NARGS is the number of args
|
||
in that list, or -1 for a macro name that wants no argument list.
|
||
MACRONAME is the macro name itself (so we can avoid recursive expansion)
|
||
and NAMELEN is its length in characters.
|
||
|
||
Note that comments, backslash-newlines, and leading white space
|
||
have already been deleted from the argument. */
|
||
|
||
/* If there is no trailing whitespace, a Newline Space is added at the end
|
||
to prevent concatenation that would be contrary to the standard. */
|
||
|
||
static DEFINITION *
|
||
collect_expansion (buf, end, nargs, arglist)
|
||
U_CHAR *buf, *end;
|
||
int nargs;
|
||
struct arglist *arglist;
|
||
{
|
||
DEFINITION *defn;
|
||
register U_CHAR *p, *limit, *lastp, *exp_p;
|
||
struct reflist *endpat = NULL;
|
||
/* Pointer to first nonspace after last ## seen. */
|
||
U_CHAR *concat = 0;
|
||
/* Pointer to first nonspace after last single-# seen. */
|
||
U_CHAR *stringify = 0;
|
||
/* How those tokens were spelled. */
|
||
enum sharp_token_type concat_sharp_token_type = NO_SHARP_TOKEN;
|
||
enum sharp_token_type stringify_sharp_token_type = NO_SHARP_TOKEN;
|
||
int maxsize;
|
||
int expected_delimiter = '\0';
|
||
|
||
/* Scan thru the replacement list, ignoring comments and quoted
|
||
strings, picking up on the macro calls. It does a linear search
|
||
thru the arg list on every potential symbol. Profiling might say
|
||
that something smarter should happen. */
|
||
|
||
if (end < buf)
|
||
abort ();
|
||
|
||
/* Find the beginning of the trailing whitespace. */
|
||
limit = end;
|
||
p = buf;
|
||
while (p < limit && is_space[limit[-1]]) limit--;
|
||
|
||
/* Allocate space for the text in the macro definition.
|
||
Each input char may or may not need 1 byte,
|
||
so this is an upper bound.
|
||
The extra 3 are for invented trailing newline-marker and final null. */
|
||
maxsize = (sizeof (DEFINITION)
|
||
+ (limit - p) + 3);
|
||
defn = (DEFINITION *) xcalloc (1, maxsize);
|
||
|
||
defn->nargs = nargs;
|
||
exp_p = defn->expansion = (U_CHAR *) defn + sizeof (DEFINITION);
|
||
lastp = exp_p;
|
||
|
||
if (p[0] == '#'
|
||
? p[1] == '#'
|
||
: p[0] == '%' && p[1] == ':' && p[2] == '%' && p[3] == ':') {
|
||
error ("`##' at start of macro definition");
|
||
p += p[0] == '#' ? 2 : 4;
|
||
}
|
||
|
||
/* Process the main body of the definition. */
|
||
while (p < limit) {
|
||
int skipped_arg = 0;
|
||
register U_CHAR c = *p++;
|
||
|
||
*exp_p++ = c;
|
||
|
||
if (!traditional) {
|
||
switch (c) {
|
||
case '\'':
|
||
case '\"':
|
||
if (expected_delimiter != '\0') {
|
||
if (c == expected_delimiter)
|
||
expected_delimiter = '\0';
|
||
} else
|
||
expected_delimiter = c;
|
||
break;
|
||
|
||
case '\\':
|
||
if (p < limit && expected_delimiter) {
|
||
/* In a string, backslash goes through
|
||
and makes next char ordinary. */
|
||
*exp_p++ = *p++;
|
||
}
|
||
break;
|
||
|
||
case '%':
|
||
if (!expected_delimiter && *p == ':') {
|
||
/* %: is not a digraph if preceded by an odd number of '<'s. */
|
||
U_CHAR *p0 = p - 1;
|
||
while (buf < p0 && p0[-1] == '<')
|
||
p0--;
|
||
if ((p - p0) & 1) {
|
||
/* Treat %:%: as ## and %: as #. */
|
||
if (p[1] == '%' && p[2] == ':') {
|
||
p += 2;
|
||
goto sharp_sharp_token;
|
||
}
|
||
if (nargs >= 0) {
|
||
p++;
|
||
goto sharp_token;
|
||
}
|
||
}
|
||
}
|
||
break;
|
||
|
||
case '#':
|
||
/* # is ordinary inside a string. */
|
||
if (expected_delimiter)
|
||
break;
|
||
if (*p == '#') {
|
||
sharp_sharp_token:
|
||
/* ##: concatenate preceding and following tokens. */
|
||
/* Take out the first #, discard preceding whitespace. */
|
||
exp_p--;
|
||
while (exp_p > lastp && is_hor_space[exp_p[-1]])
|
||
--exp_p;
|
||
/* Skip the second #. */
|
||
p++;
|
||
concat_sharp_token_type = c;
|
||
if (is_hor_space[*p]) {
|
||
concat_sharp_token_type = c + 1;
|
||
p++;
|
||
SKIP_WHITE_SPACE (p);
|
||
}
|
||
concat = p;
|
||
if (p == limit)
|
||
error ("`##' at end of macro definition");
|
||
} else if (nargs >= 0) {
|
||
/* Single #: stringify following argument ref.
|
||
Don't leave the # in the expansion. */
|
||
sharp_token:
|
||
exp_p--;
|
||
stringify_sharp_token_type = c;
|
||
if (is_hor_space[*p]) {
|
||
stringify_sharp_token_type = c + 1;
|
||
p++;
|
||
SKIP_WHITE_SPACE (p);
|
||
}
|
||
if (! is_idstart[*p] || nargs == 0
|
||
|| (*p == 'L' && (p[1] == '\'' || p[1] == '"')))
|
||
error ("`#' operator is not followed by a macro argument name");
|
||
else
|
||
stringify = p;
|
||
}
|
||
break;
|
||
}
|
||
} else {
|
||
/* In -traditional mode, recognize arguments inside strings and
|
||
character constants, and ignore special properties of #.
|
||
Arguments inside strings are considered "stringified", but no
|
||
extra quote marks are supplied. */
|
||
switch (c) {
|
||
case '\'':
|
||
case '\"':
|
||
if (expected_delimiter != '\0') {
|
||
if (c == expected_delimiter)
|
||
expected_delimiter = '\0';
|
||
} else
|
||
expected_delimiter = c;
|
||
break;
|
||
|
||
case '\\':
|
||
/* Backslash quotes delimiters and itself, but not macro args. */
|
||
if (expected_delimiter != 0 && p < limit
|
||
&& (*p == expected_delimiter || *p == '\\')) {
|
||
*exp_p++ = *p++;
|
||
continue;
|
||
}
|
||
break;
|
||
|
||
case '/':
|
||
if (expected_delimiter != '\0') /* No comments inside strings. */
|
||
break;
|
||
if (*p == '*') {
|
||
/* If we find a comment that wasn't removed by handle_directive,
|
||
this must be -traditional. So replace the comment with
|
||
nothing at all. */
|
||
exp_p--;
|
||
while (++p < limit) {
|
||
if (p[0] == '*' && p[1] == '/') {
|
||
p += 2;
|
||
break;
|
||
}
|
||
}
|
||
#if 0
|
||
/* Mark this as a concatenation-point, as if it had been ##. */
|
||
concat = p;
|
||
#endif
|
||
}
|
||
break;
|
||
}
|
||
}
|
||
|
||
#ifdef MULTIBYTE_CHARS
|
||
/* Handle multibyte characters inside string and character literals. */
|
||
if (expected_delimiter != '\0')
|
||
{
|
||
int length;
|
||
--p;
|
||
length = local_mblen (p, limit - p);
|
||
if (length > 1)
|
||
{
|
||
--exp_p;
|
||
bcopy (p, exp_p, length);
|
||
p += length;
|
||
exp_p += length;
|
||
continue;
|
||
}
|
||
++p;
|
||
}
|
||
#endif
|
||
|
||
/* Handle the start of a symbol. */
|
||
if (is_idchar[c] && nargs > 0) {
|
||
U_CHAR *id_beg = p - 1;
|
||
int id_len;
|
||
|
||
--exp_p;
|
||
while (p != limit && is_idchar[*p]) p++;
|
||
id_len = p - id_beg;
|
||
|
||
if (is_idstart[c]
|
||
&& ! (id_len == 1 && c == 'L' && (*p == '\'' || *p == '"'))) {
|
||
register struct arglist *arg;
|
||
|
||
for (arg = arglist; arg != NULL; arg = arg->next) {
|
||
struct reflist *tpat;
|
||
|
||
if (arg->name[0] == c
|
||
&& arg->length == id_len
|
||
&& bcmp (arg->name, id_beg, id_len) == 0) {
|
||
enum sharp_token_type tpat_stringify;
|
||
if (expected_delimiter) {
|
||
if (warn_stringify) {
|
||
if (traditional) {
|
||
warning ("macro argument `%.*s' is stringified.",
|
||
id_len, arg->name);
|
||
} else {
|
||
warning ("macro arg `%.*s' would be stringified with -traditional.",
|
||
id_len, arg->name);
|
||
}
|
||
}
|
||
/* If ANSI, don't actually substitute inside a string. */
|
||
if (!traditional)
|
||
break;
|
||
tpat_stringify = SHARP_TOKEN;
|
||
} else {
|
||
tpat_stringify
|
||
= (stringify == id_beg
|
||
? stringify_sharp_token_type : NO_SHARP_TOKEN);
|
||
}
|
||
/* make a pat node for this arg and append it to the end of
|
||
the pat list */
|
||
tpat = (struct reflist *) xmalloc (sizeof (struct reflist));
|
||
tpat->next = NULL;
|
||
tpat->raw_before
|
||
= concat == id_beg ? concat_sharp_token_type : NO_SHARP_TOKEN;
|
||
tpat->raw_after = NO_SHARP_TOKEN;
|
||
tpat->rest_args = arg->rest_args;
|
||
tpat->stringify = tpat_stringify;
|
||
|
||
if (endpat == NULL)
|
||
defn->pattern = tpat;
|
||
else
|
||
endpat->next = tpat;
|
||
endpat = tpat;
|
||
|
||
tpat->argno = arg->argno;
|
||
tpat->nchars = exp_p - lastp;
|
||
{
|
||
register U_CHAR *p1 = p;
|
||
SKIP_WHITE_SPACE (p1);
|
||
if (p1[0]=='#'
|
||
? p1[1]=='#'
|
||
: p1[0]=='%' && p1[1]==':' && p1[2]=='%' && p1[3]==':')
|
||
tpat->raw_after = p1[0] + (p != p1);
|
||
}
|
||
lastp = exp_p; /* place to start copying from next time */
|
||
skipped_arg = 1;
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
|
||
/* If this was not a macro arg, copy it into the expansion. */
|
||
if (! skipped_arg) {
|
||
register U_CHAR *lim1 = p;
|
||
p = id_beg;
|
||
while (p != lim1)
|
||
*exp_p++ = *p++;
|
||
if (stringify == id_beg)
|
||
error ("`#' operator should be followed by a macro argument name");
|
||
}
|
||
}
|
||
}
|
||
|
||
if (!traditional && expected_delimiter == 0) {
|
||
/* If ANSI, put in a newline-space marker to prevent token pasting.
|
||
But not if "inside a string" (which in ANSI mode happens only for
|
||
-D option). */
|
||
*exp_p++ = '\n';
|
||
*exp_p++ = ' ';
|
||
}
|
||
|
||
*exp_p = '\0';
|
||
|
||
defn->length = exp_p - defn->expansion;
|
||
|
||
/* Crash now if we overrun the allocated size. */
|
||
if (defn->length + 1 > maxsize)
|
||
abort ();
|
||
|
||
#if 0
|
||
/* This isn't worth the time it takes. */
|
||
/* give back excess storage */
|
||
defn->expansion = (U_CHAR *) xrealloc (defn->expansion, defn->length + 1);
|
||
#endif
|
||
|
||
return defn;
|
||
}
|
||
|
||
static int
|
||
do_assert (buf, limit, op, keyword)
|
||
U_CHAR *buf, *limit;
|
||
FILE_BUF *op ATTRIBUTE_UNUSED;
|
||
struct directive *keyword ATTRIBUTE_UNUSED;
|
||
{
|
||
U_CHAR *bp; /* temp ptr into input buffer */
|
||
U_CHAR *symname; /* remember where symbol name starts */
|
||
int sym_length; /* and how long it is */
|
||
struct arglist *tokens = NULL;
|
||
|
||
if (pedantic && done_initializing && !instack[indepth].system_header_p)
|
||
pedwarn ("ANSI C does not allow `#assert'");
|
||
|
||
bp = buf;
|
||
|
||
while (is_hor_space[*bp])
|
||
bp++;
|
||
|
||
symname = bp; /* remember where it starts */
|
||
sym_length = check_macro_name (bp, 1);
|
||
bp += sym_length;
|
||
/* #define doesn't do this, but we should. */
|
||
SKIP_WHITE_SPACE (bp);
|
||
|
||
/* Lossage will occur if identifiers or control tokens are broken
|
||
across lines using backslash. This is not the right place to take
|
||
care of that. */
|
||
|
||
if (*bp != '(') {
|
||
error ("missing token-sequence in `#assert'");
|
||
return 1;
|
||
}
|
||
|
||
{
|
||
int error_flag = 0;
|
||
|
||
bp++; /* skip '(' */
|
||
SKIP_WHITE_SPACE (bp);
|
||
|
||
tokens = read_token_list (&bp, limit, &error_flag);
|
||
if (error_flag)
|
||
return 1;
|
||
if (tokens == 0) {
|
||
error ("empty token-sequence in `#assert'");
|
||
return 1;
|
||
}
|
||
|
||
++bp; /* skip paren */
|
||
SKIP_WHITE_SPACE (bp);
|
||
}
|
||
|
||
/* If this name isn't already an assertion name, make it one.
|
||
Error if it was already in use in some other way. */
|
||
|
||
{
|
||
ASSERTION_HASHNODE *hp;
|
||
int hashcode = hashf (symname, sym_length, ASSERTION_HASHSIZE);
|
||
struct tokenlist_list *value
|
||
= (struct tokenlist_list *) xmalloc (sizeof (struct tokenlist_list));
|
||
|
||
hp = assertion_lookup (symname, sym_length, hashcode);
|
||
if (hp == NULL) {
|
||
if (sym_length == 7 && ! bcmp (symname, "defined", 7))
|
||
error ("`defined' redefined as assertion");
|
||
hp = assertion_install (symname, sym_length, hashcode);
|
||
}
|
||
|
||
/* Add the spec'd token-sequence to the list of such. */
|
||
value->tokens = tokens;
|
||
value->next = hp->value;
|
||
hp->value = value;
|
||
}
|
||
|
||
return 0;
|
||
}
|
||
|
||
static int
|
||
do_unassert (buf, limit, op, keyword)
|
||
U_CHAR *buf, *limit;
|
||
FILE_BUF *op ATTRIBUTE_UNUSED;
|
||
struct directive *keyword ATTRIBUTE_UNUSED;
|
||
{
|
||
U_CHAR *bp; /* temp ptr into input buffer */
|
||
U_CHAR *symname; /* remember where symbol name starts */
|
||
int sym_length; /* and how long it is */
|
||
|
||
struct arglist *tokens = NULL;
|
||
int tokens_specified = 0;
|
||
|
||
if (pedantic && done_initializing && !instack[indepth].system_header_p)
|
||
pedwarn ("ANSI C does not allow `#unassert'");
|
||
|
||
bp = buf;
|
||
|
||
while (is_hor_space[*bp])
|
||
bp++;
|
||
|
||
symname = bp; /* remember where it starts */
|
||
sym_length = check_macro_name (bp, 1);
|
||
bp += sym_length;
|
||
/* #define doesn't do this, but we should. */
|
||
SKIP_WHITE_SPACE (bp);
|
||
|
||
/* Lossage will occur if identifiers or control tokens are broken
|
||
across lines using backslash. This is not the right place to take
|
||
care of that. */
|
||
|
||
if (*bp == '(') {
|
||
int error_flag = 0;
|
||
|
||
bp++; /* skip '(' */
|
||
SKIP_WHITE_SPACE (bp);
|
||
|
||
tokens = read_token_list (&bp, limit, &error_flag);
|
||
if (error_flag)
|
||
return 1;
|
||
if (tokens == 0) {
|
||
error ("empty token list in `#unassert'");
|
||
return 1;
|
||
}
|
||
|
||
tokens_specified = 1;
|
||
|
||
++bp; /* skip paren */
|
||
SKIP_WHITE_SPACE (bp);
|
||
}
|
||
|
||
{
|
||
ASSERTION_HASHNODE *hp;
|
||
int hashcode = hashf (symname, sym_length, ASSERTION_HASHSIZE);
|
||
struct tokenlist_list *tail, *prev;
|
||
|
||
hp = assertion_lookup (symname, sym_length, hashcode);
|
||
if (hp == NULL)
|
||
return 1;
|
||
|
||
/* If no token list was specified, then eliminate this assertion
|
||
entirely. */
|
||
if (! tokens_specified) {
|
||
struct tokenlist_list *next;
|
||
for (tail = hp->value; tail; tail = next) {
|
||
next = tail->next;
|
||
free_token_list (tail->tokens);
|
||
free (tail);
|
||
}
|
||
delete_assertion (hp);
|
||
} else {
|
||
/* If a list of tokens was given, then delete any matching list. */
|
||
|
||
tail = hp->value;
|
||
prev = 0;
|
||
while (tail) {
|
||
struct tokenlist_list *next = tail->next;
|
||
if (compare_token_lists (tail->tokens, tokens)) {
|
||
if (prev)
|
||
prev->next = next;
|
||
else
|
||
hp->value = tail->next;
|
||
free_token_list (tail->tokens);
|
||
free (tail);
|
||
} else {
|
||
prev = tail;
|
||
}
|
||
tail = next;
|
||
}
|
||
}
|
||
}
|
||
|
||
return 0;
|
||
}
|
||
|
||
/* Test whether there is an assertion named NAME
|
||
and optionally whether it has an asserted token list TOKENS.
|
||
NAME is not null terminated; its length is SYM_LENGTH.
|
||
If TOKENS_SPECIFIED is 0, then don't check for any token list. */
|
||
|
||
int
|
||
check_assertion (name, sym_length, tokens_specified, tokens)
|
||
U_CHAR *name;
|
||
int sym_length;
|
||
int tokens_specified;
|
||
struct arglist *tokens;
|
||
{
|
||
ASSERTION_HASHNODE *hp;
|
||
int hashcode = hashf (name, sym_length, ASSERTION_HASHSIZE);
|
||
|
||
if (pedantic && !instack[indepth].system_header_p)
|
||
pedwarn ("ANSI C does not allow testing assertions");
|
||
|
||
hp = assertion_lookup (name, sym_length, hashcode);
|
||
if (hp == NULL)
|
||
/* It is not an assertion; just return false. */
|
||
return 0;
|
||
|
||
/* If no token list was specified, then value is 1. */
|
||
if (! tokens_specified)
|
||
return 1;
|
||
|
||
{
|
||
struct tokenlist_list *tail;
|
||
|
||
tail = hp->value;
|
||
|
||
/* If a list of tokens was given,
|
||
then succeed if the assertion records a matching list. */
|
||
|
||
while (tail) {
|
||
if (compare_token_lists (tail->tokens, tokens))
|
||
return 1;
|
||
tail = tail->next;
|
||
}
|
||
|
||
/* Fail if the assertion has no matching list. */
|
||
return 0;
|
||
}
|
||
}
|
||
|
||
/* Compare two lists of tokens for equality including order of tokens. */
|
||
|
||
static int
|
||
compare_token_lists (l1, l2)
|
||
struct arglist *l1, *l2;
|
||
{
|
||
while (l1 && l2) {
|
||
if (l1->length != l2->length)
|
||
return 0;
|
||
if (bcmp (l1->name, l2->name, l1->length))
|
||
return 0;
|
||
l1 = l1->next;
|
||
l2 = l2->next;
|
||
}
|
||
|
||
/* Succeed if both lists end at the same time. */
|
||
return l1 == l2;
|
||
}
|
||
|
||
/* Read a space-separated list of tokens ending in a close parenthesis.
|
||
Return a list of strings, in the order they were written.
|
||
(In case of error, return 0 and store -1 in *ERROR_FLAG.)
|
||
Parse the text starting at *BPP, and update *BPP.
|
||
Don't parse beyond LIMIT. */
|
||
|
||
static struct arglist *
|
||
read_token_list (bpp, limit, error_flag)
|
||
U_CHAR **bpp;
|
||
U_CHAR *limit;
|
||
int *error_flag;
|
||
{
|
||
struct arglist *token_ptrs = 0;
|
||
U_CHAR *bp = *bpp;
|
||
int depth = 1;
|
||
|
||
*error_flag = 0;
|
||
|
||
/* Loop over the assertion value tokens. */
|
||
while (depth > 0) {
|
||
struct arglist *temp;
|
||
int eofp = 0;
|
||
U_CHAR *beg = bp;
|
||
|
||
/* Find the end of the token. */
|
||
if (*bp == '(') {
|
||
bp++;
|
||
depth++;
|
||
} else if (*bp == ')') {
|
||
depth--;
|
||
if (depth == 0)
|
||
break;
|
||
bp++;
|
||
} else if (*bp == '"' || *bp == '\'')
|
||
bp = skip_quoted_string (bp, limit, 0, NULL_PTR, NULL_PTR, &eofp);
|
||
else
|
||
while (! is_hor_space[*bp] && *bp != '(' && *bp != ')'
|
||
&& *bp != '"' && *bp != '\'' && bp != limit)
|
||
bp++;
|
||
|
||
temp = (struct arglist *) xmalloc (sizeof (struct arglist));
|
||
temp->name = (U_CHAR *) xmalloc (bp - beg + 1);
|
||
bcopy ((char *) beg, (char *) temp->name, bp - beg);
|
||
temp->name[bp - beg] = 0;
|
||
temp->next = token_ptrs;
|
||
token_ptrs = temp;
|
||
temp->length = bp - beg;
|
||
|
||
SKIP_WHITE_SPACE (bp);
|
||
|
||
if (bp >= limit) {
|
||
error ("unterminated token sequence in `#assert' or `#unassert'");
|
||
*error_flag = -1;
|
||
return 0;
|
||
}
|
||
}
|
||
*bpp = bp;
|
||
|
||
/* We accumulated the names in reverse order.
|
||
Now reverse them to get the proper order. */
|
||
{
|
||
register struct arglist *prev = 0, *this, *next;
|
||
for (this = token_ptrs; this; this = next) {
|
||
next = this->next;
|
||
this->next = prev;
|
||
prev = this;
|
||
}
|
||
return prev;
|
||
}
|
||
}
|
||
|
||
static void
|
||
free_token_list (tokens)
|
||
struct arglist *tokens;
|
||
{
|
||
while (tokens) {
|
||
struct arglist *next = tokens->next;
|
||
free (tokens->name);
|
||
free (tokens);
|
||
tokens = next;
|
||
}
|
||
}
|
||
|
||
/* Install a name in the assertion hash table.
|
||
|
||
If LEN is >= 0, it is the length of the name.
|
||
Otherwise, compute the length by scanning the entire name.
|
||
|
||
If HASH is >= 0, it is the precomputed hash code.
|
||
Otherwise, compute the hash code. */
|
||
|
||
static ASSERTION_HASHNODE *
|
||
assertion_install (name, len, hash)
|
||
U_CHAR *name;
|
||
int len;
|
||
int hash;
|
||
{
|
||
register ASSERTION_HASHNODE *hp;
|
||
register int i, bucket;
|
||
register U_CHAR *p, *q;
|
||
|
||
i = sizeof (ASSERTION_HASHNODE) + len + 1;
|
||
hp = (ASSERTION_HASHNODE *) xmalloc (i);
|
||
bucket = hash;
|
||
hp->bucket_hdr = &assertion_hashtab[bucket];
|
||
hp->next = assertion_hashtab[bucket];
|
||
assertion_hashtab[bucket] = hp;
|
||
hp->prev = NULL;
|
||
if (hp->next != NULL)
|
||
hp->next->prev = hp;
|
||
hp->length = len;
|
||
hp->value = 0;
|
||
hp->name = ((U_CHAR *) hp) + sizeof (ASSERTION_HASHNODE);
|
||
p = hp->name;
|
||
q = name;
|
||
for (i = 0; i < len; i++)
|
||
*p++ = *q++;
|
||
hp->name[len] = 0;
|
||
return hp;
|
||
}
|
||
|
||
/* Find the most recent hash node for name "name" (ending with first
|
||
non-identifier char) installed by install
|
||
|
||
If LEN is >= 0, it is the length of the name.
|
||
Otherwise, compute the length by scanning the entire name.
|
||
|
||
If HASH is >= 0, it is the precomputed hash code.
|
||
Otherwise, compute the hash code. */
|
||
|
||
static ASSERTION_HASHNODE *
|
||
assertion_lookup (name, len, hash)
|
||
U_CHAR *name;
|
||
int len;
|
||
int hash;
|
||
{
|
||
register ASSERTION_HASHNODE *bucket;
|
||
|
||
bucket = assertion_hashtab[hash];
|
||
while (bucket) {
|
||
if (bucket->length == len && bcmp (bucket->name, name, len) == 0)
|
||
return bucket;
|
||
bucket = bucket->next;
|
||
}
|
||
return NULL;
|
||
}
|
||
|
||
static void
|
||
delete_assertion (hp)
|
||
ASSERTION_HASHNODE *hp;
|
||
{
|
||
|
||
if (hp->prev != NULL)
|
||
hp->prev->next = hp->next;
|
||
if (hp->next != NULL)
|
||
hp->next->prev = hp->prev;
|
||
|
||
/* Make sure that the bucket chain header that the deleted guy was
|
||
on points to the right thing afterwards. */
|
||
if (hp == *hp->bucket_hdr)
|
||
*hp->bucket_hdr = hp->next;
|
||
|
||
free (hp);
|
||
}
|
||
|
||
/*
|
||
* interpret #line directive. Remembers previously seen fnames
|
||
* in its very own hash table.
|
||
*/
|
||
#define FNAME_HASHSIZE 37
|
||
|
||
static int
|
||
do_line (buf, limit, op, keyword)
|
||
U_CHAR *buf, *limit;
|
||
FILE_BUF *op;
|
||
struct directive *keyword ATTRIBUTE_UNUSED;
|
||
{
|
||
register U_CHAR *bp;
|
||
FILE_BUF *ip = &instack[indepth];
|
||
FILE_BUF tem;
|
||
int new_lineno;
|
||
enum file_change_code file_change = same_file;
|
||
|
||
/* Expand any macros. */
|
||
tem = expand_to_temp_buffer (buf, limit, 0, 0);
|
||
|
||
/* Point to macroexpanded line, which is null-terminated now. */
|
||
bp = tem.buf;
|
||
SKIP_WHITE_SPACE (bp);
|
||
|
||
if (!ISDIGIT (*bp)) {
|
||
error ("invalid format `#line' directive");
|
||
return 0;
|
||
}
|
||
|
||
/* The Newline at the end of this line remains to be processed.
|
||
To put the next line at the specified line number,
|
||
we must store a line number now that is one less. */
|
||
new_lineno = atoi ((char *) bp) - 1;
|
||
|
||
/* NEW_LINENO is one less than the actual line number here. */
|
||
if (pedantic && new_lineno < 0)
|
||
pedwarn ("line number out of range in `#line' directive");
|
||
|
||
/* skip over the line number. */
|
||
while (ISDIGIT (*bp))
|
||
bp++;
|
||
|
||
#if 0 /* #line 10"foo.c" is supposed to be allowed. */
|
||
if (*bp && !is_space[*bp]) {
|
||
error ("invalid format `#line' directive");
|
||
return;
|
||
}
|
||
#endif
|
||
|
||
SKIP_WHITE_SPACE (bp);
|
||
|
||
if (*bp == '\"') {
|
||
static HASHNODE *fname_table[FNAME_HASHSIZE];
|
||
HASHNODE *hp, **hash_bucket;
|
||
U_CHAR *fname, *p;
|
||
int fname_length;
|
||
|
||
fname = ++bp;
|
||
|
||
/* Turn the file name, which is a character string literal,
|
||
into a null-terminated string. Do this in place. */
|
||
p = bp;
|
||
for (;;)
|
||
switch ((*p++ = *bp++)) {
|
||
case '\0':
|
||
error ("invalid format `#line' directive");
|
||
return 0;
|
||
|
||
case '\\':
|
||
if (! ignore_escape_flag)
|
||
{
|
||
char *bpc = (char *) bp;
|
||
HOST_WIDEST_INT c = parse_escape (&bpc, (HOST_WIDEST_INT) (U_CHAR) (-1));
|
||
bp = (U_CHAR *) bpc;
|
||
if (c < 0)
|
||
p--;
|
||
else
|
||
p[-1] = c;
|
||
}
|
||
break;
|
||
|
||
case '\"':
|
||
*--p = 0;
|
||
goto fname_done;
|
||
}
|
||
fname_done:
|
||
fname_length = p - fname;
|
||
|
||
SKIP_WHITE_SPACE (bp);
|
||
if (*bp) {
|
||
if (pedantic)
|
||
pedwarn ("garbage at end of `#line' directive");
|
||
if (*bp == '1')
|
||
file_change = enter_file;
|
||
else if (*bp == '2')
|
||
file_change = leave_file;
|
||
else if (*bp == '3')
|
||
ip->system_header_p = 1;
|
||
else if (*bp == '4')
|
||
ip->system_header_p = 2;
|
||
else {
|
||
error ("invalid format `#line' directive");
|
||
return 0;
|
||
}
|
||
|
||
bp++;
|
||
SKIP_WHITE_SPACE (bp);
|
||
if (*bp == '3') {
|
||
ip->system_header_p = 1;
|
||
bp++;
|
||
SKIP_WHITE_SPACE (bp);
|
||
}
|
||
if (*bp == '4') {
|
||
ip->system_header_p = 2;
|
||
bp++;
|
||
SKIP_WHITE_SPACE (bp);
|
||
}
|
||
if (*bp) {
|
||
error ("invalid format `#line' directive");
|
||
return 0;
|
||
}
|
||
}
|
||
|
||
hash_bucket = &fname_table[hashf (fname, fname_length, FNAME_HASHSIZE)];
|
||
for (hp = *hash_bucket; hp != NULL; hp = hp->next)
|
||
if (hp->length == fname_length &&
|
||
bcmp (hp->value.cpval, fname, fname_length) == 0) {
|
||
ip->nominal_fname = hp->value.cpval;
|
||
ip->nominal_fname_len = fname_length;
|
||
break;
|
||
}
|
||
if (hp == 0) {
|
||
/* Didn't find it; cons up a new one. */
|
||
hp = (HASHNODE *) xcalloc (1, sizeof (HASHNODE) + fname_length + 1);
|
||
hp->next = *hash_bucket;
|
||
*hash_bucket = hp;
|
||
|
||
ip->nominal_fname = hp->value.cpval = ((char *) hp) + sizeof (HASHNODE);
|
||
ip->nominal_fname_len = hp->length = fname_length;
|
||
bcopy (fname, hp->value.cpval, fname_length + 1);
|
||
}
|
||
} else if (*bp) {
|
||
error ("invalid format `#line' directive");
|
||
return 0;
|
||
}
|
||
|
||
ip->lineno = new_lineno;
|
||
output_line_directive (ip, op, 0, file_change);
|
||
check_expand (op, ip->length - (ip->bufp - ip->buf));
|
||
return 0;
|
||
}
|
||
|
||
/* Remove the definition of a symbol from the symbol table.
|
||
according to un*x /lib/cpp, it is not an error to undef
|
||
something that has no definitions, so it isn't one here either. */
|
||
|
||
static int
|
||
do_undef (buf, limit, op, keyword)
|
||
U_CHAR *buf, *limit;
|
||
FILE_BUF *op;
|
||
struct directive *keyword;
|
||
{
|
||
int sym_length;
|
||
HASHNODE *hp;
|
||
U_CHAR *orig_buf = buf;
|
||
|
||
/* If this is a precompiler run (with -pcp) pass thru #undef directives. */
|
||
if (pcp_outfile && op)
|
||
pass_thru_directive (buf, limit, op, keyword);
|
||
|
||
SKIP_WHITE_SPACE (buf);
|
||
sym_length = check_macro_name (buf, 0);
|
||
|
||
while ((hp = lookup (buf, sym_length, -1)) != NULL) {
|
||
/* If we are generating additional info for debugging (with -g) we
|
||
need to pass through all effective #undef directives. */
|
||
if (debug_output && op)
|
||
pass_thru_directive (orig_buf, limit, op, keyword);
|
||
if (hp->type != T_MACRO)
|
||
warning ("undefining `%s'", hp->name);
|
||
delete_macro (hp);
|
||
}
|
||
|
||
if (pedantic) {
|
||
buf += sym_length;
|
||
SKIP_WHITE_SPACE (buf);
|
||
if (buf != limit)
|
||
pedwarn ("garbage after `#undef' directive");
|
||
}
|
||
return 0;
|
||
}
|
||
|
||
/* Report an error detected by the program we are processing.
|
||
Use the text of the line in the error message.
|
||
(We use error because it prints the filename & line#.) */
|
||
|
||
static int
|
||
do_error (buf, limit, op, keyword)
|
||
U_CHAR *buf, *limit;
|
||
FILE_BUF *op ATTRIBUTE_UNUSED;
|
||
struct directive *keyword ATTRIBUTE_UNUSED;
|
||
{
|
||
int length = limit - buf;
|
||
U_CHAR *copy = (U_CHAR *) alloca (length + 1);
|
||
bcopy ((char *) buf, (char *) copy, length);
|
||
copy[length] = 0;
|
||
SKIP_WHITE_SPACE (copy);
|
||
error ("#error %s", copy);
|
||
return 0;
|
||
}
|
||
|
||
/* Report a warning detected by the program we are processing.
|
||
Use the text of the line in the warning message, then continue.
|
||
(We use error because it prints the filename & line#.) */
|
||
|
||
static int
|
||
do_warning (buf, limit, op, keyword)
|
||
U_CHAR *buf, *limit;
|
||
FILE_BUF *op ATTRIBUTE_UNUSED;
|
||
struct directive *keyword ATTRIBUTE_UNUSED;
|
||
{
|
||
int length = limit - buf;
|
||
U_CHAR *copy = (U_CHAR *) alloca (length + 1);
|
||
bcopy ((char *) buf, (char *) copy, length);
|
||
copy[length] = 0;
|
||
SKIP_WHITE_SPACE (copy);
|
||
|
||
if (pedantic && !instack[indepth].system_header_p)
|
||
pedwarn ("ANSI C does not allow `#warning'");
|
||
|
||
/* Use `pedwarn' not `warning', because #warning isn't in the C Standard;
|
||
if -pedantic-errors is given, #warning should cause an error. */
|
||
pedwarn ("#warning %s", copy);
|
||
return 0;
|
||
}
|
||
|
||
/* Remember the name of the current file being read from so that we can
|
||
avoid ever including it again. */
|
||
|
||
static void
|
||
do_once ()
|
||
{
|
||
int i;
|
||
|
||
for (i = indepth; i >= 0; i--)
|
||
if (instack[i].inc) {
|
||
record_control_macro (instack[i].inc, (U_CHAR *) "");
|
||
break;
|
||
}
|
||
}
|
||
|
||
/* Report program identification. */
|
||
|
||
static int
|
||
do_ident (buf, limit, op, keyword)
|
||
U_CHAR *buf, *limit;
|
||
FILE_BUF *op;
|
||
struct directive *keyword ATTRIBUTE_UNUSED;
|
||
{
|
||
FILE_BUF trybuf;
|
||
int len;
|
||
|
||
/* Allow #ident in system headers, since that's not user's fault. */
|
||
if (pedantic && !instack[indepth].system_header_p)
|
||
pedwarn ("ANSI C does not allow `#ident'");
|
||
|
||
trybuf = expand_to_temp_buffer (buf, limit, 0, 0);
|
||
buf = trybuf.buf;
|
||
len = trybuf.bufp - buf;
|
||
|
||
/* Output expanded directive. */
|
||
check_expand (op, 7 + len);
|
||
bcopy ("#ident ", (char *) op->bufp, 7);
|
||
op->bufp += 7;
|
||
bcopy ((char *) buf, (char *) op->bufp, len);
|
||
op->bufp += len;
|
||
|
||
free (buf);
|
||
return 0;
|
||
}
|
||
|
||
/* #pragma and its argument line have already been copied to the output file.
|
||
Just check for some recognized pragmas that need validation here. */
|
||
|
||
static int
|
||
do_pragma (buf, limit, op, keyword)
|
||
U_CHAR *buf, *limit ATTRIBUTE_UNUSED;
|
||
FILE_BUF *op ATTRIBUTE_UNUSED;
|
||
struct directive *keyword ATTRIBUTE_UNUSED;
|
||
{
|
||
SKIP_WHITE_SPACE (buf);
|
||
if (!strncmp ((char *) buf, "once", 4)) {
|
||
/* Allow #pragma once in system headers, since that's not the user's
|
||
fault. */
|
||
if (!instack[indepth].system_header_p)
|
||
warning ("`#pragma once' is obsolete");
|
||
do_once ();
|
||
}
|
||
|
||
if (!strncmp ((char *) buf, "implementation", 14)) {
|
||
/* Be quiet about `#pragma implementation' for a file only if it hasn't
|
||
been included yet. */
|
||
|
||
int h;
|
||
U_CHAR *p = buf + 14, *fname;
|
||
SKIP_WHITE_SPACE (p);
|
||
if (*p != '\"')
|
||
return 0;
|
||
|
||
fname = p + 1;
|
||
if ((p = (U_CHAR *) index ((char *) fname, '\"')))
|
||
*p = '\0';
|
||
|
||
for (h = 0; h < INCLUDE_HASHSIZE; h++) {
|
||
struct include_file *inc;
|
||
for (inc = include_hashtab[h]; inc; inc = inc->next) {
|
||
if (!strcmp (base_name (inc->fname), (char *) fname)) {
|
||
warning ("`#pragma implementation' for \"%s\" appears after its #include",fname);
|
||
return 0;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
return 0;
|
||
}
|
||
|
||
#if 0
|
||
/* This was a fun hack, but #pragma seems to start to be useful.
|
||
By failing to recognize it, we pass it through unchanged to cc1. */
|
||
|
||
/* The behavior of the #pragma directive is implementation defined.
|
||
this implementation defines it as follows. */
|
||
|
||
static int
|
||
do_pragma ()
|
||
{
|
||
close (0);
|
||
if (open ("/dev/tty", O_RDONLY, 0666) != 0)
|
||
goto nope;
|
||
close (1);
|
||
if (open ("/dev/tty", O_WRONLY, 0666) != 1)
|
||
goto nope;
|
||
execl ("/usr/games/hack", "#pragma", 0);
|
||
execl ("/usr/games/rogue", "#pragma", 0);
|
||
execl ("/usr/new/emacs", "-f", "hanoi", "9", "-kill", 0);
|
||
execl ("/usr/local/emacs", "-f", "hanoi", "9", "-kill", 0);
|
||
nope:
|
||
fatal ("You are in a maze of twisty compiler features, all different");
|
||
}
|
||
#endif
|
||
|
||
#ifdef SCCS_DIRECTIVE
|
||
|
||
/* Just ignore #sccs, on systems where we define it at all. */
|
||
|
||
static int
|
||
do_sccs (buf, limit, op, keyword)
|
||
U_CHAR *buf ATTRIBUTE_UNUSED, *limit ATTRIBUTE_UNUSED;
|
||
FILE_BUF *op ATTRIBUTE_UNUSED;
|
||
struct directive *keyword ATTRIBUTE_UNUSED;
|
||
{
|
||
if (pedantic)
|
||
pedwarn ("ANSI C does not allow `#sccs'");
|
||
return 0;
|
||
}
|
||
|
||
#endif /* defined (SCCS_DIRECTIVE) */
|
||
|
||
/* Handle #if directive by
|
||
1) inserting special `defined' keyword into the hash table
|
||
that gets turned into 0 or 1 by special_symbol (thus,
|
||
if the luser has a symbol called `defined' already, it won't
|
||
work inside the #if directive)
|
||
2) rescan the input into a temporary output buffer
|
||
3) pass the output buffer to the yacc parser and collect a value
|
||
4) clean up the mess left from steps 1 and 2.
|
||
5) call conditional_skip to skip til the next #endif (etc.),
|
||
or not, depending on the value from step 3. */
|
||
|
||
static int
|
||
do_if (buf, limit, op, keyword)
|
||
U_CHAR *buf, *limit;
|
||
FILE_BUF *op;
|
||
struct directive *keyword ATTRIBUTE_UNUSED;
|
||
{
|
||
HOST_WIDEST_INT value;
|
||
FILE_BUF *ip = &instack[indepth];
|
||
|
||
value = eval_if_expression (buf, limit - buf);
|
||
conditional_skip (ip, value == 0, T_IF, NULL_PTR, op);
|
||
return 0;
|
||
}
|
||
|
||
/* Handle a #elif directive by not changing if_stack either.
|
||
see the comment above do_else. */
|
||
|
||
static int
|
||
do_elif (buf, limit, op, keyword)
|
||
U_CHAR *buf, *limit;
|
||
FILE_BUF *op;
|
||
struct directive *keyword ATTRIBUTE_UNUSED;
|
||
{
|
||
HOST_WIDEST_INT value;
|
||
FILE_BUF *ip = &instack[indepth];
|
||
|
||
if (if_stack == instack[indepth].if_stack) {
|
||
error ("`#elif' not within a conditional");
|
||
return 0;
|
||
} else {
|
||
if (if_stack->type != T_IF && if_stack->type != T_ELIF) {
|
||
error ("`#elif' after `#else'");
|
||
fprintf (stderr, " (matches line %d", if_stack->lineno);
|
||
if (! (if_stack->fname_len == ip->nominal_fname_len
|
||
&& !bcmp (if_stack->fname, ip->nominal_fname,
|
||
if_stack->fname_len))) {
|
||
fprintf (stderr, ", file ");
|
||
eprint_string (if_stack->fname, if_stack->fname_len);
|
||
}
|
||
fprintf (stderr, ")\n");
|
||
}
|
||
if_stack->type = T_ELIF;
|
||
}
|
||
|
||
if (if_stack->if_succeeded)
|
||
skip_if_group (ip, 0, op);
|
||
else {
|
||
value = eval_if_expression (buf, limit - buf);
|
||
if (value == 0)
|
||
skip_if_group (ip, 0, op);
|
||
else {
|
||
++if_stack->if_succeeded; /* continue processing input */
|
||
output_line_directive (ip, op, 1, same_file);
|
||
}
|
||
}
|
||
return 0;
|
||
}
|
||
|
||
/* Evaluate a #if expression in BUF, of length LENGTH, then parse the
|
||
result as a C expression and return the value as an int. */
|
||
|
||
static HOST_WIDEST_INT
|
||
eval_if_expression (buf, length)
|
||
U_CHAR *buf;
|
||
int length;
|
||
{
|
||
FILE_BUF temp_obuf;
|
||
HASHNODE *save_defined;
|
||
HOST_WIDEST_INT value;
|
||
|
||
save_defined = install ((U_CHAR *) "defined", -1, T_SPEC_DEFINED,
|
||
NULL_PTR, -1);
|
||
pcp_inside_if = 1;
|
||
temp_obuf = expand_to_temp_buffer (buf, buf + length, 0, 1);
|
||
pcp_inside_if = 0;
|
||
delete_macro (save_defined); /* clean up special symbol */
|
||
|
||
temp_obuf.buf[temp_obuf.length] = '\n';
|
||
value = parse_c_expression ((char *) temp_obuf.buf,
|
||
warn_undef && !instack[indepth].system_header_p);
|
||
|
||
free (temp_obuf.buf);
|
||
|
||
return value;
|
||
}
|
||
|
||
/* routine to handle ifdef/ifndef. Try to look up the symbol, then do
|
||
or don't skip to the #endif/#else/#elif depending on what directive
|
||
is actually being processed. */
|
||
|
||
static int
|
||
do_xifdef (buf, limit, op, keyword)
|
||
U_CHAR *buf, *limit;
|
||
FILE_BUF *op;
|
||
struct directive *keyword;
|
||
{
|
||
int skip;
|
||
FILE_BUF *ip = &instack[indepth];
|
||
U_CHAR *end;
|
||
int start_of_file = 0;
|
||
U_CHAR *control_macro = 0;
|
||
|
||
/* Detect a #ifndef at start of file (not counting comments). */
|
||
if (ip->fname != 0 && keyword->type == T_IFNDEF) {
|
||
U_CHAR *p = ip->buf;
|
||
while (p != directive_start) {
|
||
U_CHAR c = *p++;
|
||
if (is_space[c])
|
||
;
|
||
/* Make no special provision for backslash-newline here; this is
|
||
slower if backslash-newlines are present, but it's correct,
|
||
and it's not worth it to tune for the rare backslash-newline. */
|
||
else if (c == '/'
|
||
&& (*p == '*' || (cplusplus_comments && *p == '/'))) {
|
||
/* Skip this comment. */
|
||
int junk = 0;
|
||
U_CHAR *save_bufp = ip->bufp;
|
||
ip->bufp = p + 1;
|
||
p = skip_to_end_of_comment (ip, &junk, 1);
|
||
ip->bufp = save_bufp;
|
||
} else {
|
||
goto fail;
|
||
}
|
||
}
|
||
/* If we get here, this conditional is the beginning of the file. */
|
||
start_of_file = 1;
|
||
fail: ;
|
||
}
|
||
|
||
/* Discard leading and trailing whitespace. */
|
||
SKIP_WHITE_SPACE (buf);
|
||
while (limit != buf && is_hor_space[limit[-1]]) limit--;
|
||
|
||
/* Find the end of the identifier at the beginning. */
|
||
for (end = buf; is_idchar[*end]; end++);
|
||
|
||
if (end == buf) {
|
||
skip = (keyword->type == T_IFDEF);
|
||
if (! traditional)
|
||
pedwarn (end == limit ? "`#%s' with no argument"
|
||
: "`#%s' argument starts with punctuation",
|
||
keyword->name);
|
||
} else {
|
||
HASHNODE *hp;
|
||
|
||
if (! traditional) {
|
||
if (ISDIGIT (buf[0]))
|
||
pedwarn ("`#%s' argument starts with a digit", keyword->name);
|
||
else if (end != limit)
|
||
pedwarn ("garbage at end of `#%s' argument", keyword->name);
|
||
}
|
||
|
||
hp = lookup (buf, end-buf, -1);
|
||
|
||
if (pcp_outfile) {
|
||
/* Output a precondition for this macro. */
|
||
if (hp
|
||
&& (hp->type == T_CONST
|
||
|| (hp->type == T_MACRO && hp->value.defn->predefined)))
|
||
fprintf (pcp_outfile, "#define %s\n", hp->name);
|
||
else {
|
||
U_CHAR *cp = buf;
|
||
fprintf (pcp_outfile, "#undef ");
|
||
while (is_idchar[*cp]) /* Ick! */
|
||
fputc (*cp++, pcp_outfile);
|
||
putc ('\n', pcp_outfile);
|
||
}
|
||
}
|
||
|
||
skip = (hp == NULL) ^ (keyword->type == T_IFNDEF);
|
||
if (start_of_file && !skip) {
|
||
control_macro = (U_CHAR *) xmalloc (end - buf + 1);
|
||
bcopy ((char *) buf, (char *) control_macro, end - buf);
|
||
control_macro[end - buf] = 0;
|
||
}
|
||
}
|
||
|
||
conditional_skip (ip, skip, T_IF, control_macro, op);
|
||
return 0;
|
||
}
|
||
|
||
/* Push TYPE on stack; then, if SKIP is nonzero, skip ahead.
|
||
If this is a #ifndef starting at the beginning of a file,
|
||
CONTROL_MACRO is the macro name tested by the #ifndef.
|
||
Otherwise, CONTROL_MACRO is 0. */
|
||
|
||
static void
|
||
conditional_skip (ip, skip, type, control_macro, op)
|
||
FILE_BUF *ip;
|
||
int skip;
|
||
enum node_type type;
|
||
U_CHAR *control_macro;
|
||
FILE_BUF *op;
|
||
{
|
||
IF_STACK_FRAME *temp;
|
||
|
||
temp = (IF_STACK_FRAME *) xcalloc (1, sizeof (IF_STACK_FRAME));
|
||
temp->fname = ip->nominal_fname;
|
||
temp->fname_len = ip->nominal_fname_len;
|
||
temp->lineno = ip->lineno;
|
||
temp->next = if_stack;
|
||
temp->control_macro = control_macro;
|
||
if_stack = temp;
|
||
|
||
if_stack->type = type;
|
||
|
||
if (skip != 0) {
|
||
skip_if_group (ip, 0, op);
|
||
return;
|
||
} else {
|
||
++if_stack->if_succeeded;
|
||
output_line_directive (ip, &outbuf, 1, same_file);
|
||
}
|
||
}
|
||
|
||
/* Skip to #endif, #else, or #elif. adjust line numbers, etc.
|
||
Leaves input ptr at the sharp sign found.
|
||
If ANY is nonzero, return at next directive of any sort. */
|
||
|
||
static void
|
||
skip_if_group (ip, any, op)
|
||
FILE_BUF *ip;
|
||
int any;
|
||
FILE_BUF *op;
|
||
{
|
||
register U_CHAR *bp = ip->bufp, *cp;
|
||
register U_CHAR *endb = ip->buf + ip->length;
|
||
struct directive *kt;
|
||
IF_STACK_FRAME *save_if_stack = if_stack; /* don't pop past here */
|
||
U_CHAR *beg_of_line = bp;
|
||
register int ident_length;
|
||
U_CHAR *ident, *after_ident;
|
||
/* Save info about where the group starts. */
|
||
U_CHAR *beg_of_group = bp;
|
||
int beg_lineno = ip->lineno;
|
||
int skipping_include_directive = 0;
|
||
|
||
if (output_conditionals && op != 0) {
|
||
char *ptr = "#failed\n";
|
||
int len = strlen (ptr);
|
||
|
||
if (op->bufp > op->buf && op->bufp[-1] != '\n')
|
||
{
|
||
*op->bufp++ = '\n';
|
||
op->lineno++;
|
||
}
|
||
check_expand (op, len);
|
||
bcopy (ptr, (char *) op->bufp, len);
|
||
op->bufp += len;
|
||
op->lineno++;
|
||
output_line_directive (ip, op, 1, 0);
|
||
}
|
||
|
||
while (bp < endb) {
|
||
switch (*bp++) {
|
||
case '/': /* possible comment */
|
||
if (*bp == '\\' && bp[1] == '\n')
|
||
newline_fix (bp);
|
||
if (*bp == '*'
|
||
|| (cplusplus_comments && *bp == '/')) {
|
||
ip->bufp = ++bp;
|
||
bp = skip_to_end_of_comment (ip, &ip->lineno, 0);
|
||
}
|
||
break;
|
||
case '<':
|
||
if (skipping_include_directive) {
|
||
while (bp < endb && *bp != '>' && *bp != '\n') {
|
||
if (*bp == '\\' && bp[1] == '\n') {
|
||
ip->lineno++;
|
||
bp++;
|
||
}
|
||
bp++;
|
||
}
|
||
}
|
||
break;
|
||
case '\"':
|
||
if (skipping_include_directive) {
|
||
while (bp < endb && *bp != '\n') {
|
||
if (*bp == '"') {
|
||
bp++;
|
||
break;
|
||
}
|
||
if (*bp == '\\' && bp[1] == '\n') {
|
||
ip->lineno++;
|
||
bp++;
|
||
}
|
||
bp++;
|
||
}
|
||
break;
|
||
}
|
||
/* Fall through. */
|
||
case '\'':
|
||
bp = skip_quoted_string (bp - 1, endb, ip->lineno, &ip->lineno,
|
||
NULL_PTR, NULL_PTR);
|
||
break;
|
||
case '\\':
|
||
/* Char after backslash loses its special meaning in some cases. */
|
||
if (*bp == '\n') {
|
||
++ip->lineno;
|
||
bp++;
|
||
} else if (traditional && bp < endb)
|
||
bp++;
|
||
break;
|
||
case '\n':
|
||
++ip->lineno;
|
||
beg_of_line = bp;
|
||
skipping_include_directive = 0;
|
||
break;
|
||
case '%':
|
||
if (beg_of_line == 0 || traditional)
|
||
break;
|
||
ip->bufp = bp - 1;
|
||
while (bp[0] == '\\' && bp[1] == '\n')
|
||
bp += 2;
|
||
if (*bp == ':')
|
||
goto sharp_token;
|
||
break;
|
||
case '#':
|
||
/* # keyword: a # must be first nonblank char on the line */
|
||
if (beg_of_line == 0)
|
||
break;
|
||
ip->bufp = bp - 1;
|
||
sharp_token:
|
||
/* Scan from start of line, skipping whitespace, comments
|
||
and backslash-newlines, and see if we reach this #.
|
||
If not, this # is not special. */
|
||
bp = beg_of_line;
|
||
/* If -traditional, require # to be at beginning of line. */
|
||
if (!traditional) {
|
||
while (1) {
|
||
if (is_hor_space[*bp])
|
||
bp++;
|
||
else if (*bp == '\\' && bp[1] == '\n')
|
||
bp += 2;
|
||
else if (*bp == '/' && bp[1] == '*') {
|
||
bp += 2;
|
||
while (1)
|
||
{
|
||
if (*bp == '*')
|
||
{
|
||
if (bp[1] == '/')
|
||
{
|
||
bp += 2;
|
||
break;
|
||
}
|
||
}
|
||
else
|
||
{
|
||
#ifdef MULTIBYTE_CHARS
|
||
int length;
|
||
length = local_mblen (bp, endb - bp);
|
||
if (length > 1)
|
||
bp += (length - 1);
|
||
#endif
|
||
}
|
||
bp++;
|
||
}
|
||
}
|
||
/* There is no point in trying to deal with C++ // comments here,
|
||
because if there is one, then this # must be part of the
|
||
comment and we would never reach here. */
|
||
else break;
|
||
}
|
||
}
|
||
if (bp != ip->bufp) {
|
||
bp = ip->bufp + 1; /* Reset bp to after the #. */
|
||
break;
|
||
}
|
||
|
||
bp = ip->bufp + 1; /* Point after the '#' */
|
||
if (ip->bufp[0] == '%') {
|
||
/* Skip past the ':' again. */
|
||
while (*bp == '\\') {
|
||
ip->lineno++;
|
||
bp += 2;
|
||
}
|
||
bp++;
|
||
}
|
||
|
||
/* Skip whitespace and \-newline. */
|
||
while (1) {
|
||
if (is_hor_space[*bp])
|
||
bp++;
|
||
else if (*bp == '\\' && bp[1] == '\n')
|
||
bp += 2;
|
||
else if (*bp == '/') {
|
||
if (bp[1] == '\\' && bp[2] == '\n')
|
||
newline_fix (bp + 1);
|
||
if (bp[1] == '*') {
|
||
for (bp += 2; ; bp++) {
|
||
if (*bp == '\n')
|
||
ip->lineno++;
|
||
else if (*bp == '*') {
|
||
if (bp[-1] == '/' && warn_comments)
|
||
warning ("`/*' within comment");
|
||
if (bp[1] == '\\' && bp[2] == '\n')
|
||
newline_fix (bp + 1);
|
||
if (bp[1] == '/')
|
||
break;
|
||
}
|
||
else
|
||
{
|
||
#ifdef MULTIBYTE_CHARS
|
||
int length;
|
||
length = local_mblen (bp, endb - bp);
|
||
if (length > 1)
|
||
bp += (length - 1);
|
||
#endif
|
||
}
|
||
}
|
||
bp += 2;
|
||
} else if (bp[1] == '/' && cplusplus_comments) {
|
||
for (bp += 2; ; bp++) {
|
||
if (*bp == '\n')
|
||
break;
|
||
if (*bp == '\\' && bp[1] == '\n')
|
||
{
|
||
if (warn_comments)
|
||
warning ("multiline `//' comment");
|
||
ip->lineno++;
|
||
bp++;
|
||
}
|
||
else
|
||
{
|
||
#ifdef MULTIBYTE_CHARS
|
||
int length;
|
||
length = local_mblen (bp, endb - bp);
|
||
if (length > 1)
|
||
bp += (length - 1);
|
||
#endif
|
||
}
|
||
}
|
||
} else
|
||
break;
|
||
} else
|
||
break;
|
||
}
|
||
|
||
cp = bp;
|
||
|
||
/* Now find end of directive name.
|
||
If we encounter a backslash-newline, exchange it with any following
|
||
symbol-constituents so that we end up with a contiguous name. */
|
||
|
||
while (1) {
|
||
if (is_idchar[*bp])
|
||
bp++;
|
||
else {
|
||
if (*bp == '\\' && bp[1] == '\n')
|
||
name_newline_fix (bp);
|
||
if (is_idchar[*bp])
|
||
bp++;
|
||
else break;
|
||
}
|
||
}
|
||
ident_length = bp - cp;
|
||
ident = cp;
|
||
after_ident = bp;
|
||
|
||
/* A line of just `#' becomes blank. */
|
||
|
||
if (ident_length == 0 && *after_ident == '\n') {
|
||
continue;
|
||
}
|
||
|
||
if (ident_length == 0 || !is_idstart[*ident]) {
|
||
U_CHAR *p = ident;
|
||
while (is_idchar[*p]) {
|
||
if (*p < '0' || *p > '9')
|
||
break;
|
||
p++;
|
||
}
|
||
/* Handle # followed by a line number. */
|
||
if (p != ident && !is_idchar[*p]) {
|
||
if (pedantic)
|
||
pedwarn ("`#' followed by integer");
|
||
continue;
|
||
}
|
||
|
||
/* Avoid error for `###' and similar cases unless -pedantic. */
|
||
if (p == ident) {
|
||
while (*p == '#' || is_hor_space[*p]) p++;
|
||
if (*p == '\n') {
|
||
if (pedantic && !lang_asm)
|
||
pedwarn ("invalid preprocessing directive");
|
||
continue;
|
||
}
|
||
}
|
||
|
||
if (!lang_asm && pedantic)
|
||
pedwarn ("invalid preprocessing directive name");
|
||
continue;
|
||
}
|
||
|
||
for (kt = directive_table; kt->length >= 0; kt++) {
|
||
IF_STACK_FRAME *temp;
|
||
if (ident_length == kt->length
|
||
&& bcmp (cp, kt->name, kt->length) == 0) {
|
||
/* If we are asked to return on next directive, do so now. */
|
||
if (any)
|
||
goto done;
|
||
|
||
switch (kt->type) {
|
||
case T_IF:
|
||
case T_IFDEF:
|
||
case T_IFNDEF:
|
||
temp = (IF_STACK_FRAME *) xcalloc (1, sizeof (IF_STACK_FRAME));
|
||
temp->next = if_stack;
|
||
if_stack = temp;
|
||
temp->lineno = ip->lineno;
|
||
temp->fname = ip->nominal_fname;
|
||
temp->fname_len = ip->nominal_fname_len;
|
||
temp->type = kt->type;
|
||
break;
|
||
case T_ELSE:
|
||
case T_ENDIF:
|
||
if (pedantic && if_stack != save_if_stack)
|
||
validate_else (bp, endb);
|
||
case T_ELIF:
|
||
if (if_stack == instack[indepth].if_stack) {
|
||
error ("`#%s' not within a conditional", kt->name);
|
||
break;
|
||
}
|
||
else if (if_stack == save_if_stack)
|
||
goto done; /* found what we came for */
|
||
|
||
if (kt->type != T_ENDIF) {
|
||
if (if_stack->type == T_ELSE)
|
||
error ("`#else' or `#elif' after `#else'");
|
||
if_stack->type = kt->type;
|
||
break;
|
||
}
|
||
|
||
temp = if_stack;
|
||
if_stack = if_stack->next;
|
||
free (temp);
|
||
break;
|
||
|
||
case T_INCLUDE:
|
||
case T_INCLUDE_NEXT:
|
||
case T_IMPORT:
|
||
skipping_include_directive = 1;
|
||
break;
|
||
|
||
default:
|
||
break;
|
||
}
|
||
break;
|
||
}
|
||
}
|
||
/* Don't let erroneous code go by. */
|
||
if (kt->length < 0 && !lang_asm && pedantic)
|
||
pedwarn ("invalid preprocessing directive name");
|
||
}
|
||
}
|
||
|
||
ip->bufp = bp;
|
||
/* after this returns, rescan will exit because ip->bufp
|
||
now points to the end of the buffer.
|
||
rescan is responsible for the error message also. */
|
||
|
||
done:
|
||
if (output_conditionals && op != 0) {
|
||
char *ptr = "#endfailed\n";
|
||
int len = strlen (ptr);
|
||
|
||
if (op->bufp > op->buf && op->bufp[-1] != '\n')
|
||
{
|
||
*op->bufp++ = '\n';
|
||
op->lineno++;
|
||
}
|
||
check_expand (op, beg_of_line - beg_of_group);
|
||
bcopy ((char *) beg_of_group, (char *) op->bufp,
|
||
beg_of_line - beg_of_group);
|
||
op->bufp += beg_of_line - beg_of_group;
|
||
op->lineno += ip->lineno - beg_lineno;
|
||
check_expand (op, len);
|
||
bcopy (ptr, (char *) op->bufp, len);
|
||
op->bufp += len;
|
||
op->lineno++;
|
||
}
|
||
}
|
||
|
||
/* Handle a #else directive. Do this by just continuing processing
|
||
without changing if_stack ; this is so that the error message
|
||
for missing #endif's etc. will point to the original #if. It
|
||
is possible that something different would be better. */
|
||
|
||
static int
|
||
do_else (buf, limit, op, keyword)
|
||
U_CHAR *buf, *limit;
|
||
FILE_BUF *op;
|
||
struct directive *keyword ATTRIBUTE_UNUSED;
|
||
{
|
||
FILE_BUF *ip = &instack[indepth];
|
||
|
||
if (pedantic) {
|
||
SKIP_WHITE_SPACE (buf);
|
||
if (buf != limit)
|
||
pedwarn ("text following `#else' violates ANSI standard");
|
||
}
|
||
|
||
if (if_stack == instack[indepth].if_stack) {
|
||
error ("`#else' not within a conditional");
|
||
return 0;
|
||
} else {
|
||
/* #ifndef can't have its special treatment for containing the whole file
|
||
if it has a #else clause. */
|
||
if_stack->control_macro = 0;
|
||
|
||
if (if_stack->type != T_IF && if_stack->type != T_ELIF) {
|
||
error ("`#else' after `#else'");
|
||
fprintf (stderr, " (matches line %d", if_stack->lineno);
|
||
if (! (if_stack->fname_len == ip->nominal_fname_len
|
||
&& !bcmp (if_stack->fname, ip->nominal_fname,
|
||
if_stack->fname_len))) {
|
||
fprintf (stderr, ", file ");
|
||
eprint_string (if_stack->fname, if_stack->fname_len);
|
||
}
|
||
fprintf (stderr, ")\n");
|
||
}
|
||
if_stack->type = T_ELSE;
|
||
}
|
||
|
||
if (if_stack->if_succeeded)
|
||
skip_if_group (ip, 0, op);
|
||
else {
|
||
++if_stack->if_succeeded; /* continue processing input */
|
||
output_line_directive (ip, op, 1, same_file);
|
||
}
|
||
return 0;
|
||
}
|
||
|
||
/* Unstack after #endif directive. */
|
||
|
||
static int
|
||
do_endif (buf, limit, op, keyword)
|
||
U_CHAR *buf, *limit;
|
||
FILE_BUF *op;
|
||
struct directive *keyword ATTRIBUTE_UNUSED;
|
||
{
|
||
if (pedantic) {
|
||
SKIP_WHITE_SPACE (buf);
|
||
if (buf != limit)
|
||
pedwarn ("text following `#endif' violates ANSI standard");
|
||
}
|
||
|
||
if (if_stack == instack[indepth].if_stack)
|
||
error ("unbalanced `#endif'");
|
||
else {
|
||
IF_STACK_FRAME *temp = if_stack;
|
||
if_stack = if_stack->next;
|
||
if (temp->control_macro != 0) {
|
||
/* This #endif matched a #ifndef at the start of the file.
|
||
See if it is at the end of the file. */
|
||
FILE_BUF *ip = &instack[indepth];
|
||
U_CHAR *p = ip->bufp;
|
||
U_CHAR *ep = ip->buf + ip->length;
|
||
|
||
while (p != ep) {
|
||
U_CHAR c = *p++;
|
||
if (!is_space[c]) {
|
||
if (c == '/'
|
||
&& (*p == '*' || (cplusplus_comments && *p == '/'))) {
|
||
/* Skip this comment. */
|
||
int junk = 0;
|
||
U_CHAR *save_bufp = ip->bufp;
|
||
ip->bufp = p + 1;
|
||
p = skip_to_end_of_comment (ip, &junk, 1);
|
||
ip->bufp = save_bufp;
|
||
} else
|
||
goto fail;
|
||
}
|
||
}
|
||
/* If we get here, this #endif ends a #ifndef
|
||
that contains all of the file (aside from whitespace).
|
||
Arrange not to include the file again
|
||
if the macro that was tested is defined.
|
||
|
||
Do not do this for the top-level file in a -include or any
|
||
file in a -imacros. */
|
||
if (indepth != 0
|
||
&& ! (indepth == 1 && no_record_file)
|
||
&& ! (no_record_file && no_output))
|
||
record_control_macro (ip->inc, temp->control_macro);
|
||
fail: ;
|
||
}
|
||
free (temp);
|
||
output_line_directive (&instack[indepth], op, 1, same_file);
|
||
}
|
||
return 0;
|
||
}
|
||
|
||
/* When an #else or #endif is found while skipping failed conditional,
|
||
if -pedantic was specified, this is called to warn about text after
|
||
the directive name. P points to the first char after the directive
|
||
name. */
|
||
|
||
static void
|
||
validate_else (p, limit)
|
||
register U_CHAR *p;
|
||
register U_CHAR *limit;
|
||
{
|
||
/* Advance P over whitespace and comments. */
|
||
while (1) {
|
||
while (*p == '\\' && p[1] == '\n')
|
||
p += 2;
|
||
if (is_hor_space[*p])
|
||
p++;
|
||
else if (*p == '/') {
|
||
while (p[1] == '\\' && p[2] == '\n')
|
||
p += 2;
|
||
if (p[1] == '*') {
|
||
/* Don't bother warning about unterminated comments
|
||
since that will happen later. Just be sure to exit. */
|
||
for (p += 2; ; p++) {
|
||
if (p == limit)
|
||
return;
|
||
if (*p == '*') {
|
||
while (p[1] == '\\' && p[2] == '\n')
|
||
p += 2;
|
||
if (p[1] == '/') {
|
||
p += 2;
|
||
break;
|
||
}
|
||
}
|
||
else
|
||
{
|
||
#ifdef MULTIBYTE_CHARS
|
||
int length;
|
||
length = local_mblen (p, limit - p);
|
||
if (length > 1)
|
||
p += (length - 1);
|
||
#endif
|
||
}
|
||
}
|
||
}
|
||
else if (cplusplus_comments && p[1] == '/')
|
||
return;
|
||
else break;
|
||
} else break;
|
||
}
|
||
if (*p != '\n')
|
||
pedwarn ("text following `#else' or `#endif' violates ANSI standard");
|
||
}
|
||
|
||
/* Skip a comment, assuming the input ptr immediately follows the
|
||
initial slash-star. Bump *LINE_COUNTER for each newline.
|
||
(The canonical line counter is &ip->lineno.)
|
||
Don't use this routine (or the next one) if bumping the line
|
||
counter is not sufficient to deal with newlines in the string.
|
||
|
||
If NOWARN is nonzero, don't warn about slash-star inside a comment.
|
||
This feature is useful when processing a comment that is going to
|
||
be processed or was processed at another point in the preprocessor,
|
||
to avoid a duplicate warning. Likewise for unterminated comment
|
||
errors. */
|
||
|
||
static U_CHAR *
|
||
skip_to_end_of_comment (ip, line_counter, nowarn)
|
||
register FILE_BUF *ip;
|
||
int *line_counter; /* place to remember newlines, or NULL */
|
||
int nowarn;
|
||
{
|
||
register U_CHAR *limit = ip->buf + ip->length;
|
||
register U_CHAR *bp = ip->bufp;
|
||
FILE_BUF *op = put_out_comments && !line_counter ? &outbuf : (FILE_BUF *) 0;
|
||
int start_line = line_counter ? *line_counter : 0;
|
||
|
||
/* JF this line_counter stuff is a crock to make sure the
|
||
comment is only put out once, no matter how many times
|
||
the comment is skipped. It almost works */
|
||
if (op) {
|
||
*op->bufp++ = '/';
|
||
*op->bufp++ = bp[-1];
|
||
}
|
||
if (cplusplus_comments && bp[-1] == '/') {
|
||
for (; bp < limit; bp++) {
|
||
if (*bp == '\n')
|
||
break;
|
||
if (*bp == '\\' && bp + 1 < limit && bp[1] == '\n')
|
||
{
|
||
if (!nowarn && warn_comments)
|
||
warning ("multiline `//' comment");
|
||
if (line_counter)
|
||
++*line_counter;
|
||
if (op)
|
||
{
|
||
++op->lineno;
|
||
*op->bufp++ = *bp;
|
||
}
|
||
++bp;
|
||
}
|
||
else
|
||
{
|
||
#ifdef MULTIBYTE_CHARS
|
||
int length;
|
||
length = local_mblen (bp, limit - bp);
|
||
if (length > 1)
|
||
{
|
||
if (op)
|
||
{
|
||
bcopy (bp, op->bufp, length - 1);
|
||
op->bufp += (length - 1);
|
||
}
|
||
bp += (length - 1);
|
||
}
|
||
#endif
|
||
}
|
||
if (op)
|
||
*op->bufp++ = *bp;
|
||
}
|
||
ip->bufp = bp;
|
||
return bp;
|
||
}
|
||
while (bp < limit) {
|
||
if (op)
|
||
*op->bufp++ = *bp;
|
||
switch (*bp++) {
|
||
case '\n':
|
||
/* If this is the end of the file, we have an unterminated comment.
|
||
Don't swallow the newline. We are guaranteed that there will be a
|
||
trailing newline and various pieces assume it's there. */
|
||
if (bp == limit)
|
||
{
|
||
--bp;
|
||
--limit;
|
||
break;
|
||
}
|
||
if (line_counter != NULL)
|
||
++*line_counter;
|
||
if (op)
|
||
++op->lineno;
|
||
break;
|
||
case '*':
|
||
if (bp[-2] == '/' && !nowarn && warn_comments)
|
||
warning ("`/*' within comment");
|
||
if (*bp == '\\' && bp[1] == '\n')
|
||
newline_fix (bp);
|
||
if (*bp == '/') {
|
||
if (op)
|
||
*op->bufp++ = '/';
|
||
ip->bufp = ++bp;
|
||
return bp;
|
||
}
|
||
break;
|
||
#ifdef MULTIBYTE_CHARS
|
||
default:
|
||
{
|
||
int length;
|
||
bp--;
|
||
length = local_mblen (bp, limit - bp);
|
||
if (length <= 0)
|
||
length = 1;
|
||
if (op)
|
||
{
|
||
op->bufp--;
|
||
bcopy (bp, op->bufp, length);
|
||
op->bufp += length;
|
||
}
|
||
bp += length;
|
||
}
|
||
#endif
|
||
}
|
||
}
|
||
|
||
if (!nowarn)
|
||
error_with_line (line_for_error (start_line), "unterminated comment");
|
||
ip->bufp = bp;
|
||
return bp;
|
||
}
|
||
|
||
/* Skip over a quoted string. BP points to the opening quote.
|
||
Returns a pointer after the closing quote. Don't go past LIMIT.
|
||
START_LINE is the line number of the starting point (but it need
|
||
not be valid if the starting point is inside a macro expansion).
|
||
|
||
The input stack state is not changed.
|
||
|
||
If COUNT_NEWLINES is nonzero, it points to an int to increment
|
||
for each newline passed.
|
||
|
||
If BACKSLASH_NEWLINES_P is nonzero, store 1 thru it
|
||
if we pass a backslash-newline.
|
||
|
||
If EOFP is nonzero, set *EOFP to 1 if the string is unterminated. */
|
||
|
||
static U_CHAR *
|
||
skip_quoted_string (bp, limit, start_line, count_newlines, backslash_newlines_p, eofp)
|
||
register U_CHAR *bp;
|
||
register U_CHAR *limit;
|
||
int start_line;
|
||
int *count_newlines;
|
||
int *backslash_newlines_p;
|
||
int *eofp;
|
||
{
|
||
register U_CHAR c, match;
|
||
|
||
match = *bp++;
|
||
while (1) {
|
||
if (bp >= limit) {
|
||
error_with_line (line_for_error (start_line),
|
||
"unterminated string or character constant");
|
||
error_with_line (multiline_string_line,
|
||
"possible real start of unterminated constant");
|
||
multiline_string_line = 0;
|
||
if (eofp)
|
||
*eofp = 1;
|
||
break;
|
||
}
|
||
c = *bp++;
|
||
if (c == '\\') {
|
||
while (*bp == '\\' && bp[1] == '\n') {
|
||
if (backslash_newlines_p)
|
||
*backslash_newlines_p = 1;
|
||
if (count_newlines)
|
||
++*count_newlines;
|
||
bp += 2;
|
||
}
|
||
if (*bp == '\n') {
|
||
if (backslash_newlines_p)
|
||
*backslash_newlines_p = 1;
|
||
if (count_newlines)
|
||
++*count_newlines;
|
||
}
|
||
bp++;
|
||
} else if (c == '\n') {
|
||
if (traditional) {
|
||
/* Unterminated strings and character constants are 'valid'. */
|
||
bp--; /* Don't consume the newline. */
|
||
if (eofp)
|
||
*eofp = 1;
|
||
break;
|
||
}
|
||
if (match == '\'') {
|
||
error_with_line (line_for_error (start_line),
|
||
"unterminated string or character constant");
|
||
bp--;
|
||
if (eofp)
|
||
*eofp = 1;
|
||
break;
|
||
}
|
||
/* If not traditional, then allow newlines inside strings. */
|
||
if (count_newlines)
|
||
++*count_newlines;
|
||
if (multiline_string_line == 0) {
|
||
if (pedantic)
|
||
pedwarn_with_line (line_for_error (start_line),
|
||
"string constant runs past end of line");
|
||
multiline_string_line = start_line;
|
||
}
|
||
} else if (c == match)
|
||
break;
|
||
#ifdef MULTIBYTE_CHARS
|
||
{
|
||
int length;
|
||
--bp;
|
||
length = local_mblen (bp, limit - bp);
|
||
if (length <= 0)
|
||
length = 1;
|
||
bp += length;
|
||
}
|
||
#endif
|
||
}
|
||
return bp;
|
||
}
|
||
|
||
/* Place into DST a quoted string representing the string SRC.
|
||
SRCLEN is the length of SRC; SRC may contain null bytes.
|
||
Return the address of DST's terminating null. */
|
||
|
||
static char *
|
||
quote_string (dst, src, srclen)
|
||
char *dst, *src;
|
||
size_t srclen;
|
||
{
|
||
U_CHAR c;
|
||
char *srclim = src + srclen;
|
||
|
||
*dst++ = '\"';
|
||
while (src != srclim)
|
||
switch ((c = *src++))
|
||
{
|
||
default:
|
||
if (ISPRINT (c))
|
||
*dst++ = c;
|
||
else
|
||
{
|
||
sprintf (dst, "\\%03o", c);
|
||
dst += 4;
|
||
}
|
||
break;
|
||
|
||
case '\"':
|
||
case '\\':
|
||
*dst++ = '\\';
|
||
*dst++ = c;
|
||
break;
|
||
}
|
||
|
||
*dst++ = '\"';
|
||
*dst = '\0';
|
||
return dst;
|
||
}
|
||
|
||
/* Skip across a group of balanced parens, starting from IP->bufp.
|
||
IP->bufp is updated. Use this with IP->bufp pointing at an open-paren.
|
||
|
||
This does not handle newlines, because it's used for the arg of #if,
|
||
where there aren't any newlines. Also, backslash-newline can't appear. */
|
||
|
||
static U_CHAR *
|
||
skip_paren_group (ip)
|
||
register FILE_BUF *ip;
|
||
{
|
||
U_CHAR *limit = ip->buf + ip->length;
|
||
U_CHAR *p = ip->bufp;
|
||
int depth = 0;
|
||
int lines_dummy = 0;
|
||
|
||
while (p != limit) {
|
||
int c = *p++;
|
||
switch (c) {
|
||
case '(':
|
||
depth++;
|
||
break;
|
||
|
||
case ')':
|
||
depth--;
|
||
if (depth == 0)
|
||
return ip->bufp = p;
|
||
break;
|
||
|
||
case '/':
|
||
if (*p == '*') {
|
||
ip->bufp = p;
|
||
p = skip_to_end_of_comment (ip, &lines_dummy, 0);
|
||
p = ip->bufp;
|
||
}
|
||
|
||
case '"':
|
||
case '\'':
|
||
{
|
||
int eofp = 0;
|
||
p = skip_quoted_string (p - 1, limit, 0, NULL_PTR, NULL_PTR, &eofp);
|
||
if (eofp)
|
||
return ip->bufp = p;
|
||
}
|
||
break;
|
||
}
|
||
}
|
||
|
||
ip->bufp = p;
|
||
return p;
|
||
}
|
||
|
||
/* Write out a #line directive, for instance, after an #include file.
|
||
If CONDITIONAL is nonzero, we can omit the #line if it would
|
||
appear to be a no-op, and we can output a few newlines instead
|
||
if we want to increase the line number by a small amount.
|
||
FILE_CHANGE says whether we are entering a file, leaving, or neither. */
|
||
|
||
static void
|
||
output_line_directive (ip, op, conditional, file_change)
|
||
FILE_BUF *ip, *op;
|
||
int conditional;
|
||
enum file_change_code file_change;
|
||
{
|
||
int len;
|
||
char *line_directive_buf, *line_end;
|
||
|
||
if (no_line_directives
|
||
|| ip->fname == NULL
|
||
|| no_output) {
|
||
op->lineno = ip->lineno;
|
||
return;
|
||
}
|
||
|
||
if (conditional) {
|
||
if (ip->lineno == op->lineno)
|
||
return;
|
||
|
||
/* If the inherited line number is a little too small,
|
||
output some newlines instead of a #line directive. */
|
||
if (ip->lineno > op->lineno && ip->lineno < op->lineno + 8) {
|
||
check_expand (op, 10);
|
||
while (ip->lineno > op->lineno) {
|
||
*op->bufp++ = '\n';
|
||
op->lineno++;
|
||
}
|
||
return;
|
||
}
|
||
}
|
||
|
||
/* Output a positive line number if possible. */
|
||
while (ip->lineno <= 0 && ip->bufp - ip->buf < ip->length
|
||
&& *ip->bufp == '\n') {
|
||
ip->lineno++;
|
||
ip->bufp++;
|
||
}
|
||
|
||
line_directive_buf = (char *) alloca (4 * ip->nominal_fname_len + 100);
|
||
sprintf (line_directive_buf, "# %d ", ip->lineno);
|
||
line_end = quote_string (line_directive_buf + strlen (line_directive_buf),
|
||
ip->nominal_fname, ip->nominal_fname_len);
|
||
if (file_change != same_file) {
|
||
*line_end++ = ' ';
|
||
*line_end++ = file_change == enter_file ? '1' : '2';
|
||
}
|
||
/* Tell cc1 if following text comes from a system header file. */
|
||
if (ip->system_header_p) {
|
||
*line_end++ = ' ';
|
||
*line_end++ = '3';
|
||
}
|
||
#ifndef NO_IMPLICIT_EXTERN_C
|
||
/* Tell cc1plus if following text should be treated as C. */
|
||
if (ip->system_header_p == 2 && cplusplus) {
|
||
*line_end++ = ' ';
|
||
*line_end++ = '4';
|
||
}
|
||
#endif
|
||
*line_end++ = '\n';
|
||
len = line_end - line_directive_buf;
|
||
check_expand (op, len + 1);
|
||
if (op->bufp > op->buf && op->bufp[-1] != '\n')
|
||
*op->bufp++ = '\n';
|
||
bcopy ((char *) line_directive_buf, (char *) op->bufp, len);
|
||
op->bufp += len;
|
||
op->lineno = ip->lineno;
|
||
}
|
||
|
||
/* This structure represents one parsed argument in a macro call.
|
||
`raw' points to the argument text as written (`raw_length' is its length).
|
||
`expanded' points to the argument's macro-expansion
|
||
(its length is `expand_length').
|
||
`stringified_length' is the length the argument would have
|
||
if stringified.
|
||
`use_count' is the number of times this macro arg is substituted
|
||
into the macro. If the actual use count exceeds 10,
|
||
the value stored is 10.
|
||
`free1' and `free2', if nonzero, point to blocks to be freed
|
||
when the macro argument data is no longer needed. */
|
||
|
||
struct argdata {
|
||
U_CHAR *raw, *expanded;
|
||
int raw_length, expand_length;
|
||
int stringified_length;
|
||
U_CHAR *free1, *free2;
|
||
char newlines;
|
||
char use_count;
|
||
};
|
||
|
||
/* Expand a macro call.
|
||
HP points to the symbol that is the macro being called.
|
||
Put the result of expansion onto the input stack
|
||
so that subsequent input by our caller will use it.
|
||
|
||
If macro wants arguments, caller has already verified that
|
||
an argument list follows; arguments come from the input stack. */
|
||
|
||
static void
|
||
macroexpand (hp, op)
|
||
HASHNODE *hp;
|
||
FILE_BUF *op;
|
||
{
|
||
int nargs;
|
||
DEFINITION *defn = hp->value.defn;
|
||
register U_CHAR *xbuf;
|
||
int xbuf_len;
|
||
int start_line = instack[indepth].lineno;
|
||
int rest_args, rest_zero;
|
||
|
||
CHECK_DEPTH (return;);
|
||
|
||
/* it might not actually be a macro. */
|
||
if (hp->type != T_MACRO) {
|
||
special_symbol (hp, op);
|
||
return;
|
||
}
|
||
|
||
/* This macro is being used inside a #if, which means it must be */
|
||
/* recorded as a precondition. */
|
||
if (pcp_inside_if && pcp_outfile && defn->predefined)
|
||
dump_single_macro (hp, pcp_outfile);
|
||
|
||
nargs = defn->nargs;
|
||
|
||
if (nargs >= 0) {
|
||
register int i;
|
||
struct argdata *args;
|
||
int parse_error = 0;
|
||
|
||
args = (struct argdata *) alloca ((nargs + 1) * sizeof (struct argdata));
|
||
|
||
for (i = 0; i < nargs; i++) {
|
||
args[i].raw = (U_CHAR *) "";
|
||
args[i].expanded = 0;
|
||
args[i].raw_length = args[i].expand_length
|
||
= args[i].stringified_length = 0;
|
||
args[i].free1 = args[i].free2 = 0;
|
||
args[i].use_count = 0;
|
||
}
|
||
|
||
/* Parse all the macro args that are supplied. I counts them.
|
||
The first NARGS args are stored in ARGS.
|
||
The rest are discarded.
|
||
If rest_args is set then we assume macarg absorbed the rest of the args.
|
||
*/
|
||
i = 0;
|
||
rest_args = 0;
|
||
do {
|
||
/* Discard the open-parenthesis or comma before the next arg. */
|
||
++instack[indepth].bufp;
|
||
if (rest_args)
|
||
continue;
|
||
if (i < nargs || (nargs == 0 && i == 0)) {
|
||
/* If we are working on last arg which absorbs rest of args... */
|
||
if (i == nargs - 1 && defn->rest_args)
|
||
rest_args = 1;
|
||
parse_error = macarg (&args[i], rest_args);
|
||
}
|
||
else
|
||
parse_error = macarg (NULL_PTR, 0);
|
||
if (parse_error) {
|
||
error_with_line (line_for_error (start_line),
|
||
"unterminated macro call");
|
||
break;
|
||
}
|
||
i++;
|
||
} while (*instack[indepth].bufp != ')');
|
||
|
||
/* If we got one arg but it was just whitespace, call that 0 args. */
|
||
if (i == 1) {
|
||
register U_CHAR *bp = args[0].raw;
|
||
register U_CHAR *lim = bp + args[0].raw_length;
|
||
/* cpp.texi says for foo ( ) we provide one argument.
|
||
However, if foo wants just 0 arguments, treat this as 0. */
|
||
if (nargs == 0)
|
||
while (bp != lim && is_space[*bp]) bp++;
|
||
if (bp == lim)
|
||
i = 0;
|
||
}
|
||
|
||
/* Don't output an error message if we have already output one for
|
||
a parse error above. */
|
||
rest_zero = 0;
|
||
if (nargs == 0 && i > 0) {
|
||
if (! parse_error)
|
||
error ("arguments given to macro `%s'", hp->name);
|
||
} else if (i < nargs) {
|
||
/* traditional C allows foo() if foo wants one argument. */
|
||
if (nargs == 1 && i == 0 && traditional)
|
||
;
|
||
/* the rest args token is allowed to absorb 0 tokens */
|
||
else if (i == nargs - 1 && defn->rest_args)
|
||
rest_zero = 1;
|
||
else if (parse_error)
|
||
;
|
||
else if (i == 0)
|
||
error ("macro `%s' used without args", hp->name);
|
||
else if (i == 1)
|
||
error ("macro `%s' used with just one arg", hp->name);
|
||
else
|
||
error ("macro `%s' used with only %d args", hp->name, i);
|
||
} else if (i > nargs) {
|
||
if (! parse_error)
|
||
error ("macro `%s' used with too many (%d) args", hp->name, i);
|
||
}
|
||
|
||
/* Swallow the closeparen. */
|
||
++instack[indepth].bufp;
|
||
|
||
/* If macro wants zero args, we parsed the arglist for checking only.
|
||
Read directly from the macro definition. */
|
||
if (nargs == 0) {
|
||
xbuf = defn->expansion;
|
||
xbuf_len = defn->length;
|
||
} else {
|
||
register U_CHAR *exp = defn->expansion;
|
||
register int offset; /* offset in expansion,
|
||
copied a piece at a time */
|
||
register int totlen; /* total amount of exp buffer filled so far */
|
||
|
||
register struct reflist *ap, *last_ap;
|
||
|
||
/* Macro really takes args. Compute the expansion of this call. */
|
||
|
||
/* Compute length in characters of the macro's expansion.
|
||
Also count number of times each arg is used. */
|
||
xbuf_len = defn->length;
|
||
for (ap = defn->pattern; ap != NULL; ap = ap->next) {
|
||
if (ap->stringify)
|
||
xbuf_len += args[ap->argno].stringified_length;
|
||
else if (ap->raw_before != 0 || ap->raw_after != 0 || traditional)
|
||
/* Add 4 for two newline-space markers to prevent
|
||
token concatenation. */
|
||
xbuf_len += args[ap->argno].raw_length + 4;
|
||
else {
|
||
/* We have an ordinary (expanded) occurrence of the arg.
|
||
So compute its expansion, if we have not already. */
|
||
if (args[ap->argno].expanded == 0) {
|
||
FILE_BUF obuf;
|
||
obuf = expand_to_temp_buffer (args[ap->argno].raw,
|
||
args[ap->argno].raw + args[ap->argno].raw_length,
|
||
1, 0);
|
||
|
||
args[ap->argno].expanded = obuf.buf;
|
||
args[ap->argno].expand_length = obuf.length;
|
||
args[ap->argno].free2 = obuf.buf;
|
||
}
|
||
|
||
/* Add 4 for two newline-space markers to prevent
|
||
token concatenation. */
|
||
xbuf_len += args[ap->argno].expand_length + 4;
|
||
}
|
||
if (args[ap->argno].use_count < 10)
|
||
args[ap->argno].use_count++;
|
||
}
|
||
|
||
xbuf = (U_CHAR *) xmalloc (xbuf_len + 1);
|
||
|
||
/* Generate in XBUF the complete expansion
|
||
with arguments substituted in.
|
||
TOTLEN is the total size generated so far.
|
||
OFFSET is the index in the definition
|
||
of where we are copying from. */
|
||
offset = totlen = 0;
|
||
for (last_ap = NULL, ap = defn->pattern; ap != NULL;
|
||
last_ap = ap, ap = ap->next) {
|
||
register struct argdata *arg = &args[ap->argno];
|
||
int count_before = totlen;
|
||
|
||
/* Add chars to XBUF. */
|
||
for (i = 0; i < ap->nchars; i++, offset++)
|
||
xbuf[totlen++] = exp[offset];
|
||
|
||
/* If followed by an empty rest arg with concatenation,
|
||
delete the last run of nonwhite chars. */
|
||
if (rest_zero && totlen > count_before
|
||
&& ((ap->rest_args && ap->raw_before != 0)
|
||
|| (last_ap != NULL && last_ap->rest_args
|
||
&& last_ap->raw_after != 0))) {
|
||
/* Delete final whitespace. */
|
||
while (totlen > count_before && is_space[xbuf[totlen - 1]]) {
|
||
totlen--;
|
||
}
|
||
|
||
/* Delete the nonwhites before them. */
|
||
while (totlen > count_before && ! is_space[xbuf[totlen - 1]]) {
|
||
totlen--;
|
||
}
|
||
}
|
||
|
||
if (ap->stringify != 0) {
|
||
int arglen = arg->raw_length;
|
||
int escaped = 0;
|
||
int in_string = 0;
|
||
int c;
|
||
i = 0;
|
||
while (i < arglen
|
||
&& (c = arg->raw[i], is_space[c]))
|
||
i++;
|
||
while (i < arglen
|
||
&& (c = arg->raw[arglen - 1], is_space[c]))
|
||
arglen--;
|
||
if (!traditional)
|
||
xbuf[totlen++] = '\"'; /* insert beginning quote */
|
||
for (; i < arglen; i++) {
|
||
c = arg->raw[i];
|
||
|
||
if (! in_string) {
|
||
/* Special markers Newline Space
|
||
generate nothing for a stringified argument. */
|
||
if (c == '\n' && arg->raw[i+1] != '\n') {
|
||
i++;
|
||
continue;
|
||
}
|
||
|
||
/* Internal sequences of whitespace are replaced by one space
|
||
except within an string or char token. */
|
||
if (c == '\n' ? arg->raw[i+1] == '\n' : is_space[c]) {
|
||
while (1) {
|
||
/* Note that Newline Space does occur within whitespace
|
||
sequences; consider it part of the sequence. */
|
||
if (c == '\n' && is_space[arg->raw[i+1]])
|
||
i += 2;
|
||
else if (c != '\n' && is_space[c])
|
||
i++;
|
||
else break;
|
||
c = arg->raw[i];
|
||
}
|
||
i--;
|
||
c = ' ';
|
||
}
|
||
}
|
||
|
||
if (escaped)
|
||
escaped = 0;
|
||
else {
|
||
if (c == '\\')
|
||
escaped = 1;
|
||
else if (in_string) {
|
||
if (c == in_string)
|
||
in_string = 0;
|
||
else
|
||
{
|
||
#ifdef MULTIBYTE_CHARS
|
||
int length;
|
||
length = local_mblen (arg->raw + i, arglen - i);
|
||
if (length > 1)
|
||
{
|
||
bcopy (arg->raw + i, xbuf + totlen, length);
|
||
i += length - 1;
|
||
totlen += length;
|
||
continue;
|
||
}
|
||
#endif
|
||
}
|
||
} else if (c == '\"' || c == '\'')
|
||
in_string = c;
|
||
}
|
||
|
||
/* Escape these chars */
|
||
if (c == '\"' || (in_string && c == '\\'))
|
||
xbuf[totlen++] = '\\';
|
||
/* We used to output e.g. \008 for control characters here,
|
||
but this doesn't conform to the C Standard.
|
||
Just output the characters as-is. */
|
||
xbuf[totlen++] = c;
|
||
}
|
||
if (!traditional)
|
||
xbuf[totlen++] = '\"'; /* insert ending quote */
|
||
} else if (ap->raw_before != 0 || ap->raw_after != 0 || traditional) {
|
||
U_CHAR *p1 = arg->raw;
|
||
U_CHAR *l1 = p1 + arg->raw_length;
|
||
if (ap->raw_before != 0) {
|
||
while (p1 != l1 && is_space[*p1]) p1++;
|
||
while (p1 != l1 && is_idchar[*p1])
|
||
xbuf[totlen++] = *p1++;
|
||
/* Delete any no-reexpansion marker that follows
|
||
an identifier at the beginning of the argument
|
||
if the argument is concatenated with what precedes it. */
|
||
if (p1[0] == '\n' && p1[1] == '-')
|
||
p1 += 2;
|
||
} else if (!traditional) {
|
||
/* Ordinary expanded use of the argument.
|
||
Put in newline-space markers to prevent token pasting. */
|
||
xbuf[totlen++] = '\n';
|
||
xbuf[totlen++] = ' ';
|
||
}
|
||
if (ap->raw_after != 0) {
|
||
/* Arg is concatenated after: delete trailing whitespace,
|
||
whitespace markers, and no-reexpansion markers. */
|
||
while (p1 != l1) {
|
||
if (is_space[l1[-1]]) l1--;
|
||
else if (l1[-1] == '-') {
|
||
U_CHAR *p2 = l1 - 1;
|
||
/* If a `-' is preceded by an odd number of newlines then it
|
||
and the last newline are a no-reexpansion marker. */
|
||
while (p2 != p1 && p2[-1] == '\n') p2--;
|
||
if ((l1 - 1 - p2) & 1) {
|
||
l1 -= 2;
|
||
}
|
||
else break;
|
||
}
|
||
else break;
|
||
}
|
||
}
|
||
|
||
bcopy ((char *) p1, (char *) (xbuf + totlen), l1 - p1);
|
||
totlen += l1 - p1;
|
||
if (!traditional && ap->raw_after == 0) {
|
||
/* Ordinary expanded use of the argument.
|
||
Put in newline-space markers to prevent token pasting. */
|
||
xbuf[totlen++] = '\n';
|
||
xbuf[totlen++] = ' ';
|
||
}
|
||
} else {
|
||
/* Ordinary expanded use of the argument.
|
||
Put in newline-space markers to prevent token pasting. */
|
||
if (!traditional) {
|
||
xbuf[totlen++] = '\n';
|
||
xbuf[totlen++] = ' ';
|
||
}
|
||
bcopy ((char *) arg->expanded, (char *) (xbuf + totlen),
|
||
arg->expand_length);
|
||
totlen += arg->expand_length;
|
||
if (!traditional) {
|
||
xbuf[totlen++] = '\n';
|
||
xbuf[totlen++] = ' ';
|
||
}
|
||
/* If a macro argument with newlines is used multiple times,
|
||
then only expand the newlines once. This avoids creating output
|
||
lines which don't correspond to any input line, which confuses
|
||
gdb and gcov. */
|
||
if (arg->use_count > 1 && arg->newlines > 0) {
|
||
/* Don't bother doing change_newlines for subsequent
|
||
uses of arg. */
|
||
arg->use_count = 1;
|
||
arg->expand_length
|
||
= change_newlines (arg->expanded, arg->expand_length);
|
||
}
|
||
}
|
||
|
||
if (totlen > xbuf_len)
|
||
abort ();
|
||
}
|
||
|
||
/* If there is anything left of the definition after handling
|
||
the arg list, copy that in too. */
|
||
|
||
for (i = offset; i < defn->length; i++) {
|
||
/* if we've reached the end of the macro */
|
||
if (exp[i] == ')')
|
||
rest_zero = 0;
|
||
if (! (rest_zero && last_ap != NULL && last_ap->rest_args
|
||
&& last_ap->raw_after != 0))
|
||
xbuf[totlen++] = exp[i];
|
||
}
|
||
|
||
xbuf[totlen] = 0;
|
||
xbuf_len = totlen;
|
||
|
||
for (i = 0; i < nargs; i++) {
|
||
if (args[i].free1 != 0)
|
||
free (args[i].free1);
|
||
if (args[i].free2 != 0)
|
||
free (args[i].free2);
|
||
}
|
||
}
|
||
} else {
|
||
xbuf = defn->expansion;
|
||
xbuf_len = defn->length;
|
||
}
|
||
|
||
/* Now put the expansion on the input stack
|
||
so our caller will commence reading from it. */
|
||
{
|
||
register FILE_BUF *ip2;
|
||
|
||
ip2 = &instack[++indepth];
|
||
|
||
ip2->fname = 0;
|
||
ip2->nominal_fname = 0;
|
||
ip2->nominal_fname_len = 0;
|
||
ip2->inc = 0;
|
||
/* This may not be exactly correct, but will give much better error
|
||
messages for nested macro calls than using a line number of zero. */
|
||
ip2->lineno = start_line;
|
||
ip2->buf = xbuf;
|
||
ip2->length = xbuf_len;
|
||
ip2->bufp = xbuf;
|
||
ip2->free_ptr = (nargs > 0) ? xbuf : 0;
|
||
ip2->macro = hp;
|
||
ip2->if_stack = if_stack;
|
||
ip2->system_header_p = 0;
|
||
|
||
/* Recursive macro use sometimes works traditionally.
|
||
#define foo(x,y) bar (x (y,0), y)
|
||
foo (foo, baz) */
|
||
|
||
if (!traditional)
|
||
hp->type = T_DISABLED;
|
||
}
|
||
}
|
||
|
||
/* Parse a macro argument and store the info on it into *ARGPTR.
|
||
REST_ARGS is passed to macarg1 to make it absorb the rest of the args.
|
||
Return nonzero to indicate a syntax error. */
|
||
|
||
static int
|
||
macarg (argptr, rest_args)
|
||
register struct argdata *argptr;
|
||
int rest_args;
|
||
{
|
||
FILE_BUF *ip = &instack[indepth];
|
||
int paren = 0;
|
||
int newlines = 0;
|
||
int comments = 0;
|
||
int result = 0;
|
||
|
||
/* Try to parse as much of the argument as exists at this
|
||
input stack level. */
|
||
U_CHAR *bp = macarg1 (ip->bufp, ip->buf + ip->length, ip->macro,
|
||
&paren, &newlines, &comments, rest_args);
|
||
|
||
/* If we find the end of the argument at this level,
|
||
set up *ARGPTR to point at it in the input stack. */
|
||
if (!(ip->fname != 0 && (newlines != 0 || comments != 0))
|
||
&& bp != ip->buf + ip->length) {
|
||
if (argptr != 0) {
|
||
argptr->raw = ip->bufp;
|
||
argptr->raw_length = bp - ip->bufp;
|
||
argptr->newlines = newlines;
|
||
}
|
||
ip->bufp = bp;
|
||
} else {
|
||
/* This input stack level ends before the macro argument does.
|
||
We must pop levels and keep parsing.
|
||
Therefore, we must allocate a temporary buffer and copy
|
||
the macro argument into it. */
|
||
int bufsize = bp - ip->bufp;
|
||
int extra = newlines;
|
||
U_CHAR *buffer = (U_CHAR *) xmalloc (bufsize + extra + 1);
|
||
int final_start = 0;
|
||
|
||
bcopy ((char *) ip->bufp, (char *) buffer, bufsize);
|
||
ip->bufp = bp;
|
||
ip->lineno += newlines;
|
||
|
||
while (bp == ip->buf + ip->length) {
|
||
if (instack[indepth].macro == 0) {
|
||
result = 1;
|
||
break;
|
||
}
|
||
ip->macro->type = T_MACRO;
|
||
if (ip->free_ptr)
|
||
free (ip->free_ptr);
|
||
ip = &instack[--indepth];
|
||
newlines = 0;
|
||
comments = 0;
|
||
bp = macarg1 (ip->bufp, ip->buf + ip->length, ip->macro, &paren,
|
||
&newlines, &comments, rest_args);
|
||
final_start = bufsize;
|
||
bufsize += bp - ip->bufp;
|
||
extra += newlines;
|
||
buffer = (U_CHAR *) xrealloc (buffer, bufsize + extra + 1);
|
||
bcopy ((char *) ip->bufp, (char *) (buffer + bufsize - (bp - ip->bufp)),
|
||
bp - ip->bufp);
|
||
ip->bufp = bp;
|
||
ip->lineno += newlines;
|
||
}
|
||
|
||
/* Now, if arg is actually wanted, record its raw form,
|
||
discarding comments and duplicating newlines in whatever
|
||
part of it did not come from a macro expansion.
|
||
EXTRA space has been preallocated for duplicating the newlines.
|
||
FINAL_START is the index of the start of that part. */
|
||
if (argptr != 0) {
|
||
argptr->raw = buffer;
|
||
argptr->raw_length = bufsize;
|
||
argptr->free1 = buffer;
|
||
argptr->newlines = newlines;
|
||
if ((newlines || comments) && ip->fname != 0)
|
||
argptr->raw_length
|
||
= final_start +
|
||
discard_comments (argptr->raw + final_start,
|
||
argptr->raw_length - final_start,
|
||
newlines);
|
||
argptr->raw[argptr->raw_length] = 0;
|
||
if (argptr->raw_length > bufsize + extra)
|
||
abort ();
|
||
}
|
||
}
|
||
|
||
/* If we are not discarding this argument,
|
||
macroexpand it and compute its length as stringified.
|
||
All this info goes into *ARGPTR. */
|
||
|
||
if (argptr != 0) {
|
||
register U_CHAR *buf, *lim;
|
||
register int totlen;
|
||
|
||
buf = argptr->raw;
|
||
lim = buf + argptr->raw_length;
|
||
|
||
while (buf != lim && is_space[*buf])
|
||
buf++;
|
||
while (buf != lim && is_space[lim[-1]])
|
||
lim--;
|
||
totlen = traditional ? 0 : 2; /* Count opening and closing quote. */
|
||
while (buf != lim) {
|
||
register U_CHAR c = *buf++;
|
||
totlen++;
|
||
/* Internal sequences of whitespace are replaced by one space
|
||
in most cases, but not always. So count all the whitespace
|
||
in case we need to keep it all. */
|
||
#if 0
|
||
if (is_space[c])
|
||
SKIP_ALL_WHITE_SPACE (buf);
|
||
else
|
||
#endif
|
||
if (c == '\"' || c == '\\') /* escape these chars */
|
||
totlen++;
|
||
}
|
||
argptr->stringified_length = totlen;
|
||
}
|
||
return result;
|
||
}
|
||
|
||
/* Scan text from START (inclusive) up to LIMIT (exclusive),
|
||
taken from the expansion of MACRO,
|
||
counting parens in *DEPTHPTR,
|
||
and return if reach LIMIT
|
||
or before a `)' that would make *DEPTHPTR negative
|
||
or before a comma when *DEPTHPTR is zero.
|
||
Single and double quotes are matched and termination
|
||
is inhibited within them. Comments also inhibit it.
|
||
Value returned is pointer to stopping place.
|
||
|
||
Increment *NEWLINES each time a newline is passed.
|
||
REST_ARGS notifies macarg1 that it should absorb the rest of the args.
|
||
Set *COMMENTS to 1 if a comment is seen. */
|
||
|
||
static U_CHAR *
|
||
macarg1 (start, limit, macro, depthptr, newlines, comments, rest_args)
|
||
U_CHAR *start;
|
||
register U_CHAR *limit;
|
||
struct hashnode *macro;
|
||
int *depthptr, *newlines, *comments;
|
||
int rest_args;
|
||
{
|
||
register U_CHAR *bp = start;
|
||
|
||
while (bp < limit) {
|
||
switch (*bp) {
|
||
case '(':
|
||
(*depthptr)++;
|
||
break;
|
||
case ')':
|
||
if (--(*depthptr) < 0)
|
||
return bp;
|
||
break;
|
||
case '\\':
|
||
/* Traditionally, backslash makes following char not special. */
|
||
if (traditional && bp + 1 < limit && bp[1] != '\n')
|
||
bp++;
|
||
break;
|
||
case '\n':
|
||
++*newlines;
|
||
break;
|
||
case '/':
|
||
if (macro)
|
||
break;
|
||
if (bp[1] == '\\' && bp[2] == '\n')
|
||
newline_fix (bp + 1);
|
||
if (bp[1] == '*') {
|
||
*comments = 1;
|
||
for (bp += 2; bp < limit; bp++) {
|
||
if (*bp == '\n')
|
||
++*newlines;
|
||
else if (*bp == '*') {
|
||
if (bp[-1] == '/' && warn_comments)
|
||
warning ("`/*' within comment");
|
||
if (bp[1] == '\\' && bp[2] == '\n')
|
||
newline_fix (bp + 1);
|
||
if (bp[1] == '/') {
|
||
bp++;
|
||
break;
|
||
}
|
||
}
|
||
else
|
||
{
|
||
#ifdef MULTIBYTE_CHARS
|
||
int length;
|
||
length = local_mblen (bp, limit - bp);
|
||
if (length > 1)
|
||
bp += (length - 1);
|
||
#endif
|
||
}
|
||
}
|
||
} else if (bp[1] == '/' && cplusplus_comments) {
|
||
*comments = 1;
|
||
for (bp += 2; bp < limit; bp++) {
|
||
if (*bp == '\n') {
|
||
++*newlines;
|
||
break;
|
||
}
|
||
if (*bp == '\\' && bp + 1 < limit && bp[1] == '\n')
|
||
{
|
||
++*newlines;
|
||
if (warn_comments)
|
||
warning ("multiline `//' comment");
|
||
++bp;
|
||
}
|
||
else
|
||
{
|
||
#ifdef MULTIBYTE_CHARS
|
||
int length;
|
||
length = local_mblen (bp, limit - bp);
|
||
if (length > 1)
|
||
bp += (length - 1);
|
||
#endif
|
||
}
|
||
}
|
||
}
|
||
break;
|
||
case '\'':
|
||
case '\"':
|
||
{
|
||
int quotec;
|
||
for (quotec = *bp++; bp + 1 < limit && *bp != quotec; bp++) {
|
||
if (*bp == '\\') {
|
||
bp++;
|
||
if (*bp == '\n')
|
||
++*newlines;
|
||
if (!macro) {
|
||
while (*bp == '\\' && bp[1] == '\n') {
|
||
bp += 2;
|
||
++*newlines;
|
||
}
|
||
}
|
||
} else if (*bp == '\n') {
|
||
++*newlines;
|
||
if (quotec == '\'')
|
||
break;
|
||
}
|
||
else
|
||
{
|
||
#ifdef MULTIBYTE_CHARS
|
||
int length;
|
||
length = local_mblen (bp, limit - bp);
|
||
if (length > 1)
|
||
bp += (length - 1);
|
||
#endif
|
||
}
|
||
}
|
||
}
|
||
break;
|
||
case ',':
|
||
/* if we've returned to lowest level and we aren't absorbing all args */
|
||
if ((*depthptr) == 0 && rest_args == 0)
|
||
return bp;
|
||
break;
|
||
}
|
||
bp++;
|
||
}
|
||
|
||
return bp;
|
||
}
|
||
|
||
/* Discard comments and duplicate newlines
|
||
in the string of length LENGTH at START,
|
||
except inside of string constants.
|
||
The string is copied into itself with its beginning staying fixed.
|
||
|
||
NEWLINES is the number of newlines that must be duplicated.
|
||
We assume that that much extra space is available past the end
|
||
of the string. */
|
||
|
||
static int
|
||
discard_comments (start, length, newlines)
|
||
U_CHAR *start;
|
||
int length;
|
||
int newlines;
|
||
{
|
||
register U_CHAR *ibp;
|
||
register U_CHAR *obp;
|
||
register U_CHAR *limit;
|
||
register int c;
|
||
|
||
/* If we have newlines to duplicate, copy everything
|
||
that many characters up. Then, in the second part,
|
||
we will have room to insert the newlines
|
||
while copying down.
|
||
NEWLINES may actually be too large, because it counts
|
||
newlines in string constants, and we don't duplicate those.
|
||
But that does no harm. */
|
||
if (newlines > 0) {
|
||
ibp = start + length;
|
||
obp = ibp + newlines;
|
||
limit = start;
|
||
while (limit != ibp)
|
||
*--obp = *--ibp;
|
||
}
|
||
|
||
ibp = start + newlines;
|
||
limit = start + length + newlines;
|
||
obp = start;
|
||
|
||
while (ibp < limit) {
|
||
*obp++ = c = *ibp++;
|
||
switch (c) {
|
||
case '\n':
|
||
/* Duplicate the newline. */
|
||
*obp++ = '\n';
|
||
break;
|
||
|
||
case '\\':
|
||
if (*ibp == '\n') {
|
||
obp--;
|
||
ibp++;
|
||
}
|
||
break;
|
||
|
||
case '/':
|
||
if (*ibp == '\\' && ibp[1] == '\n')
|
||
newline_fix (ibp);
|
||
/* Delete any comment. */
|
||
if (cplusplus_comments && ibp[0] == '/') {
|
||
/* Comments are equivalent to spaces. */
|
||
obp[-1] = ' ';
|
||
ibp++;
|
||
while (ibp < limit)
|
||
{
|
||
if (*ibp == '\n')
|
||
break;
|
||
if (*ibp == '\\' && ibp + 1 < limit && ibp[1] == '\n')
|
||
ibp++;
|
||
else
|
||
{
|
||
#ifdef MULTIBYTE_CHARS
|
||
int length = local_mblen (ibp, limit - ibp);
|
||
if (length > 1)
|
||
ibp += (length - 1);
|
||
#endif
|
||
}
|
||
ibp++;
|
||
}
|
||
break;
|
||
}
|
||
if (ibp[0] != '*' || ibp + 1 >= limit)
|
||
break;
|
||
/* Comments are equivalent to spaces.
|
||
For -traditional, a comment is equivalent to nothing. */
|
||
if (traditional)
|
||
obp--;
|
||
else
|
||
obp[-1] = ' ';
|
||
while (++ibp < limit) {
|
||
if (ibp[0] == '*') {
|
||
if (ibp[1] == '\\' && ibp[2] == '\n')
|
||
newline_fix (ibp + 1);
|
||
if (ibp[1] == '/') {
|
||
ibp += 2;
|
||
break;
|
||
}
|
||
}
|
||
else
|
||
{
|
||
#ifdef MULTIBYTE_CHARS
|
||
int length = local_mblen (ibp, limit - ibp);
|
||
if (length > 1)
|
||
ibp += (length - 1);
|
||
#endif
|
||
}
|
||
}
|
||
break;
|
||
|
||
case '\'':
|
||
case '\"':
|
||
/* Notice and skip strings, so that we don't
|
||
think that comments start inside them,
|
||
and so we don't duplicate newlines in them. */
|
||
{
|
||
int quotec = c;
|
||
while (ibp < limit) {
|
||
*obp++ = c = *ibp++;
|
||
if (c == quotec)
|
||
break;
|
||
if (c == '\n')
|
||
{
|
||
if (quotec == '\'')
|
||
break;
|
||
}
|
||
else if (c == '\\') {
|
||
if (ibp < limit && *ibp == '\n') {
|
||
ibp++;
|
||
obp--;
|
||
} else {
|
||
while (*ibp == '\\' && ibp[1] == '\n')
|
||
ibp += 2;
|
||
if (ibp < limit)
|
||
*obp++ = *ibp++;
|
||
}
|
||
}
|
||
else
|
||
{
|
||
#ifdef MULTIBYTE_CHARS
|
||
int length;
|
||
ibp--;
|
||
length = local_mblen (ibp, limit - ibp);
|
||
if (length > 1)
|
||
{
|
||
obp--;
|
||
bcopy (ibp, obp, length);
|
||
ibp += length;
|
||
obp += length;
|
||
}
|
||
else
|
||
ibp++;
|
||
#endif
|
||
}
|
||
}
|
||
}
|
||
break;
|
||
}
|
||
}
|
||
|
||
return obp - start;
|
||
}
|
||
|
||
/* Turn newlines to spaces in the string of length LENGTH at START,
|
||
except inside of string constants.
|
||
The string is copied into itself with its beginning staying fixed. */
|
||
|
||
static int
|
||
change_newlines (start, length)
|
||
U_CHAR *start;
|
||
int length;
|
||
{
|
||
register U_CHAR *ibp;
|
||
register U_CHAR *obp;
|
||
register U_CHAR *limit;
|
||
register int c;
|
||
|
||
ibp = start;
|
||
limit = start + length;
|
||
obp = start;
|
||
|
||
while (ibp < limit) {
|
||
*obp++ = c = *ibp++;
|
||
switch (c) {
|
||
case '\n':
|
||
/* If this is a NEWLINE NEWLINE, then this is a real newline in the
|
||
string. Skip past the newline and its duplicate.
|
||
Put a space in the output. */
|
||
if (*ibp == '\n')
|
||
{
|
||
ibp++;
|
||
obp--;
|
||
*obp++ = ' ';
|
||
}
|
||
break;
|
||
|
||
case '\'':
|
||
case '\"':
|
||
/* Notice and skip strings, so that we don't delete newlines in them. */
|
||
{
|
||
int quotec = c;
|
||
while (ibp < limit) {
|
||
*obp++ = c = *ibp++;
|
||
if (c == quotec)
|
||
break;
|
||
else if (c == '\\' && ibp < limit && *ibp == '\n')
|
||
*obp++ = *ibp++;
|
||
else if (c == '\n')
|
||
{
|
||
if (quotec == '\'')
|
||
break;
|
||
}
|
||
else
|
||
{
|
||
#ifdef MULTIBYTE_CHARS
|
||
int length;
|
||
ibp--;
|
||
length = local_mblen (ibp, limit - ibp);
|
||
if (length > 1)
|
||
{
|
||
obp--;
|
||
bcopy (ibp, obp, length);
|
||
ibp += length;
|
||
obp += length;
|
||
}
|
||
else
|
||
ibp++;
|
||
#endif
|
||
}
|
||
}
|
||
}
|
||
break;
|
||
}
|
||
}
|
||
|
||
return obp - start;
|
||
}
|
||
|
||
/* my_strerror - return the descriptive text associated with an
|
||
`errno' code. */
|
||
|
||
static char *
|
||
my_strerror (errnum)
|
||
int errnum;
|
||
{
|
||
char *result;
|
||
|
||
#ifndef VMS
|
||
#ifndef HAVE_STRERROR
|
||
result = (char *) ((errnum < sys_nerr) ? sys_errlist[errnum] : 0);
|
||
#else
|
||
result = strerror (errnum);
|
||
#endif
|
||
#else /* VMS */
|
||
/* VAXCRTL's strerror() takes an optional second argument, which only
|
||
matters when the first argument is EVMSERR. However, it's simplest
|
||
just to pass it unconditionally. `vaxc$errno' is declared in
|
||
<errno.h>, and maintained by the library in parallel with `errno'.
|
||
We assume that caller's `errnum' either matches the last setting of
|
||
`errno' by the library or else does not have the value `EVMSERR'. */
|
||
|
||
result = strerror (errnum, vaxc$errno);
|
||
#endif
|
||
|
||
if (!result)
|
||
result = "errno = ?";
|
||
|
||
return result;
|
||
}
|
||
|
||
/* notice - output message to stderr */
|
||
|
||
static void
|
||
notice VPROTO ((const char * msgid, ...))
|
||
{
|
||
#ifndef ANSI_PROTOTYPES
|
||
const char * msgid;
|
||
#endif
|
||
va_list args;
|
||
|
||
VA_START (args, msgid);
|
||
|
||
#ifndef ANSI_PROTOTYPES
|
||
msgid = va_arg (args, const char *);
|
||
#endif
|
||
|
||
vnotice (msgid, args);
|
||
va_end (args);
|
||
}
|
||
|
||
static void
|
||
vnotice (msgid, args)
|
||
const char *msgid;
|
||
va_list args;
|
||
{
|
||
vfprintf (stderr, _(msgid), args);
|
||
}
|
||
|
||
/* error - print error message and increment count of errors. */
|
||
|
||
void
|
||
error VPROTO ((const char * msgid, ...))
|
||
{
|
||
#ifndef ANSI_PROTOTYPES
|
||
const char * msgid;
|
||
#endif
|
||
va_list args;
|
||
|
||
VA_START (args, msgid);
|
||
|
||
#ifndef ANSI_PROTOTYPES
|
||
msgid = va_arg (args, const char *);
|
||
#endif
|
||
|
||
verror (msgid, args);
|
||
va_end (args);
|
||
}
|
||
|
||
void
|
||
verror (msgid, args)
|
||
const char *msgid;
|
||
va_list args;
|
||
{
|
||
int i;
|
||
FILE_BUF *ip = NULL;
|
||
|
||
print_containing_files ();
|
||
|
||
for (i = indepth; i >= 0; i--)
|
||
if (instack[i].fname != NULL) {
|
||
ip = &instack[i];
|
||
break;
|
||
}
|
||
|
||
if (ip != NULL) {
|
||
eprint_string (ip->nominal_fname, ip->nominal_fname_len);
|
||
fprintf (stderr, ":%d: ", ip->lineno);
|
||
}
|
||
vnotice (msgid, args);
|
||
fprintf (stderr, "\n");
|
||
errors++;
|
||
}
|
||
|
||
/* Error including a message from `errno'. */
|
||
|
||
static void
|
||
error_from_errno (name)
|
||
char *name;
|
||
{
|
||
int e = errno;
|
||
int i;
|
||
FILE_BUF *ip = NULL;
|
||
|
||
print_containing_files ();
|
||
|
||
for (i = indepth; i >= 0; i--)
|
||
if (instack[i].fname != NULL) {
|
||
ip = &instack[i];
|
||
break;
|
||
}
|
||
|
||
if (ip != NULL) {
|
||
eprint_string (ip->nominal_fname, ip->nominal_fname_len);
|
||
fprintf (stderr, ":%d: ", ip->lineno);
|
||
}
|
||
|
||
fprintf (stderr, "%s: %s\n", name, my_strerror (e));
|
||
|
||
errors++;
|
||
}
|
||
|
||
/* Print error message but don't count it. */
|
||
|
||
void
|
||
warning VPROTO ((const char * msgid, ...))
|
||
{
|
||
#ifndef ANSI_PROTOTYPES
|
||
const char * msgid;
|
||
#endif
|
||
va_list args;
|
||
|
||
VA_START (args, msgid);
|
||
|
||
#ifndef ANSI_PROTOTYPES
|
||
msgid = va_arg (args, const char *);
|
||
#endif
|
||
|
||
vwarning (msgid, args);
|
||
va_end (args);
|
||
}
|
||
|
||
static void
|
||
vwarning (msgid, args)
|
||
const char *msgid;
|
||
va_list args;
|
||
{
|
||
int i;
|
||
FILE_BUF *ip = NULL;
|
||
|
||
if (inhibit_warnings)
|
||
return;
|
||
|
||
if (warnings_are_errors)
|
||
errors++;
|
||
|
||
print_containing_files ();
|
||
|
||
for (i = indepth; i >= 0; i--)
|
||
if (instack[i].fname != NULL) {
|
||
ip = &instack[i];
|
||
break;
|
||
}
|
||
|
||
if (ip != NULL) {
|
||
eprint_string (ip->nominal_fname, ip->nominal_fname_len);
|
||
fprintf (stderr, ":%d: ", ip->lineno);
|
||
}
|
||
notice ("warning: ");
|
||
vnotice (msgid, args);
|
||
fprintf (stderr, "\n");
|
||
}
|
||
|
||
static void
|
||
error_with_line VPROTO ((int line, const char * msgid, ...))
|
||
{
|
||
#ifndef ANSI_PROTOTYPES
|
||
int line;
|
||
const char * msgid;
|
||
#endif
|
||
va_list args;
|
||
|
||
VA_START (args, msgid);
|
||
|
||
#ifndef ANSI_PROTOTYPES
|
||
line = va_arg (args, int);
|
||
msgid = va_arg (args, const char *);
|
||
#endif
|
||
|
||
verror_with_line (line, msgid, args);
|
||
va_end (args);
|
||
}
|
||
|
||
|
||
static void
|
||
verror_with_line (line, msgid, args)
|
||
int line;
|
||
const char *msgid;
|
||
va_list args;
|
||
{
|
||
int i;
|
||
FILE_BUF *ip = NULL;
|
||
|
||
print_containing_files ();
|
||
|
||
for (i = indepth; i >= 0; i--)
|
||
if (instack[i].fname != NULL) {
|
||
ip = &instack[i];
|
||
break;
|
||
}
|
||
|
||
if (ip != NULL) {
|
||
eprint_string (ip->nominal_fname, ip->nominal_fname_len);
|
||
fprintf (stderr, ":%d: ", line);
|
||
}
|
||
vnotice (msgid, args);
|
||
fprintf (stderr, "\n");
|
||
errors++;
|
||
}
|
||
|
||
static void
|
||
warning_with_line VPROTO ((int line, const char * msgid, ...))
|
||
{
|
||
#ifndef ANSI_PROTOTYPES
|
||
int line;
|
||
const char * msgid;
|
||
#endif
|
||
va_list args;
|
||
|
||
VA_START (args, msgid);
|
||
|
||
#ifndef ANSI_PROTOTYPES
|
||
line = va_arg (args, int);
|
||
msgid = va_arg (args, const char *);
|
||
#endif
|
||
|
||
vwarning_with_line (line, msgid, args);
|
||
va_end (args);
|
||
}
|
||
|
||
static void
|
||
vwarning_with_line (line, msgid, args)
|
||
int line;
|
||
const char *msgid;
|
||
va_list args;
|
||
{
|
||
int i;
|
||
FILE_BUF *ip = NULL;
|
||
|
||
if (inhibit_warnings)
|
||
return;
|
||
|
||
if (warnings_are_errors)
|
||
errors++;
|
||
|
||
print_containing_files ();
|
||
|
||
for (i = indepth; i >= 0; i--)
|
||
if (instack[i].fname != NULL) {
|
||
ip = &instack[i];
|
||
break;
|
||
}
|
||
|
||
if (ip != NULL) {
|
||
eprint_string (ip->nominal_fname, ip->nominal_fname_len);
|
||
fprintf (stderr, line ? ":%d: " : ": ", line);
|
||
}
|
||
notice ("warning: ");
|
||
vnotice (msgid, args);
|
||
fprintf (stderr, "\n");
|
||
}
|
||
|
||
/* Print an error message and maybe count it. */
|
||
|
||
void
|
||
pedwarn VPROTO ((const char * msgid, ...))
|
||
{
|
||
#ifndef ANSI_PROTOTYPES
|
||
const char * msgid;
|
||
#endif
|
||
va_list args;
|
||
|
||
VA_START (args, msgid);
|
||
|
||
#ifndef ANSI_PROTOTYPES
|
||
msgid = va_arg (args, const char *);
|
||
#endif
|
||
|
||
if (pedantic_errors)
|
||
verror (msgid, args);
|
||
else
|
||
vwarning (msgid, args);
|
||
va_end (args);
|
||
}
|
||
|
||
void
|
||
pedwarn_with_line VPROTO ((int line, const char * msgid, ...))
|
||
{
|
||
#ifndef ANSI_PROTOTYPES
|
||
int line;
|
||
const char * msgid;
|
||
#endif
|
||
va_list args;
|
||
|
||
VA_START (args, msgid);
|
||
|
||
#ifndef ANSI_PROTOTYPES
|
||
line = va_arg (args, int);
|
||
msgid = va_arg (args, const char *);
|
||
#endif
|
||
|
||
if (pedantic_errors)
|
||
verror_with_line (line, msgid, args);
|
||
else
|
||
vwarning_with_line (line, msgid, args);
|
||
va_end (args);
|
||
}
|
||
|
||
/* Report a warning (or an error if pedantic_errors)
|
||
giving specified file name and line number, not current. */
|
||
|
||
static void
|
||
pedwarn_with_file_and_line VPROTO ((const char *file, size_t file_len, int line,
|
||
const char * msgid, ...))
|
||
{
|
||
#ifndef ANSI_PROTOTYPES
|
||
const char *file;
|
||
size_t file_len;
|
||
int line;
|
||
const char * msgid;
|
||
#endif
|
||
va_list args;
|
||
|
||
if (!pedantic_errors && inhibit_warnings)
|
||
return;
|
||
|
||
VA_START (args, msgid);
|
||
|
||
#ifndef ANSI_PROTOTYPES
|
||
file = va_arg (args, const char *);
|
||
file_len = va_arg (args, size_t);
|
||
line = va_arg (args, int);
|
||
msgid = va_arg (args, const char *);
|
||
#endif
|
||
|
||
if (file) {
|
||
eprint_string (file, file_len);
|
||
fprintf (stderr, ":%d: ", line);
|
||
}
|
||
if (pedantic_errors)
|
||
errors++;
|
||
if (!pedantic_errors)
|
||
notice ("warning: ");
|
||
vnotice (msgid, args);
|
||
va_end (args);
|
||
fprintf (stderr, "\n");
|
||
}
|
||
|
||
static void
|
||
pedwarn_strange_white_space (ch)
|
||
int ch;
|
||
{
|
||
switch (ch)
|
||
{
|
||
case '\f': pedwarn ("formfeed in preprocessing directive"); break;
|
||
case '\r': pedwarn ("carriage return in preprocessing directive"); break;
|
||
case '\v': pedwarn ("vertical tab in preprocessing directive"); break;
|
||
default: abort ();
|
||
}
|
||
}
|
||
|
||
/* Print the file names and line numbers of the #include
|
||
directives which led to the current file. */
|
||
|
||
static void
|
||
print_containing_files ()
|
||
{
|
||
FILE_BUF *ip = NULL;
|
||
int i;
|
||
int first = 1;
|
||
|
||
/* If stack of files hasn't changed since we last printed
|
||
this info, don't repeat it. */
|
||
if (last_error_tick == input_file_stack_tick)
|
||
return;
|
||
|
||
for (i = indepth; i >= 0; i--)
|
||
if (instack[i].fname != NULL) {
|
||
ip = &instack[i];
|
||
break;
|
||
}
|
||
|
||
/* Give up if we don't find a source file. */
|
||
if (ip == NULL)
|
||
return;
|
||
|
||
/* Find the other, outer source files. */
|
||
for (i--; i >= 0; i--)
|
||
if (instack[i].fname != NULL) {
|
||
ip = &instack[i];
|
||
if (first) {
|
||
first = 0;
|
||
notice ( "In file included from ");
|
||
} else {
|
||
notice (",\n from ");
|
||
}
|
||
|
||
eprint_string (ip->nominal_fname, ip->nominal_fname_len);
|
||
fprintf (stderr, ":%d", ip->lineno);
|
||
}
|
||
if (! first)
|
||
fprintf (stderr, ":\n");
|
||
|
||
/* Record we have printed the status as of this time. */
|
||
last_error_tick = input_file_stack_tick;
|
||
}
|
||
|
||
/* Return the line at which an error occurred.
|
||
The error is not necessarily associated with the current spot
|
||
in the input stack, so LINE says where. LINE will have been
|
||
copied from ip->lineno for the current input level.
|
||
If the current level is for a file, we return LINE.
|
||
But if the current level is not for a file, LINE is meaningless.
|
||
In that case, we return the lineno of the innermost file. */
|
||
|
||
static int
|
||
line_for_error (line)
|
||
int line;
|
||
{
|
||
int i;
|
||
int line1 = line;
|
||
|
||
for (i = indepth; i >= 0; ) {
|
||
if (instack[i].fname != 0)
|
||
return line1;
|
||
i--;
|
||
if (i < 0)
|
||
return 0;
|
||
line1 = instack[i].lineno;
|
||
}
|
||
abort ();
|
||
/*NOTREACHED*/
|
||
return 0;
|
||
}
|
||
|
||
/*
|
||
* If OBUF doesn't have NEEDED bytes after OPTR, make it bigger.
|
||
*
|
||
* As things stand, nothing is ever placed in the output buffer to be
|
||
* removed again except when it's KNOWN to be part of an identifier,
|
||
* so flushing and moving down everything left, instead of expanding,
|
||
* should work ok.
|
||
*/
|
||
|
||
/* You might think void was cleaner for the return type,
|
||
but that would get type mismatch in check_expand in strict ANSI. */
|
||
|
||
static int
|
||
grow_outbuf (obuf, needed)
|
||
register FILE_BUF *obuf;
|
||
register int needed;
|
||
{
|
||
register U_CHAR *p;
|
||
int minsize;
|
||
|
||
if (obuf->length - (obuf->bufp - obuf->buf) > needed)
|
||
return 0;
|
||
|
||
/* Make it at least twice as big as it is now. */
|
||
obuf->length *= 2;
|
||
/* Make it have at least 150% of the free space we will need. */
|
||
minsize = (3 * needed) / 2 + (obuf->bufp - obuf->buf);
|
||
if (minsize > obuf->length)
|
||
obuf->length = minsize;
|
||
|
||
if ((p = (U_CHAR *) xrealloc (obuf->buf, obuf->length)) == NULL)
|
||
memory_full ();
|
||
|
||
obuf->bufp = p + (obuf->bufp - obuf->buf);
|
||
obuf->buf = p;
|
||
|
||
return 0;
|
||
}
|
||
|
||
/* Symbol table for macro names and special symbols */
|
||
|
||
/*
|
||
* install a name in the main hash table, even if it is already there.
|
||
* name stops with first non alphanumeric, except leading '#'.
|
||
* caller must check against redefinition if that is desired.
|
||
* delete_macro () removes things installed by install () in fifo order.
|
||
* this is important because of the `defined' special symbol used
|
||
* in #if, and also if pushdef/popdef directives are ever implemented.
|
||
*
|
||
* If LEN is >= 0, it is the length of the name.
|
||
* Otherwise, compute the length by scanning the entire name.
|
||
*
|
||
* If HASH is >= 0, it is the precomputed hash code.
|
||
* Otherwise, compute the hash code.
|
||
*/
|
||
|
||
static HASHNODE *
|
||
install (name, len, type, value, hash)
|
||
U_CHAR *name;
|
||
int len;
|
||
enum node_type type;
|
||
char *value;
|
||
int hash;
|
||
{
|
||
register HASHNODE *hp;
|
||
register int i, bucket;
|
||
register U_CHAR *p, *q;
|
||
|
||
if (len < 0) {
|
||
p = name;
|
||
while (is_idchar[*p])
|
||
p++;
|
||
len = p - name;
|
||
}
|
||
|
||
if (hash < 0)
|
||
hash = hashf (name, len, HASHSIZE);
|
||
|
||
i = sizeof (HASHNODE) + len + 1;
|
||
hp = (HASHNODE *) xmalloc (i);
|
||
bucket = hash;
|
||
hp->bucket_hdr = &hashtab[bucket];
|
||
hp->next = hashtab[bucket];
|
||
hashtab[bucket] = hp;
|
||
hp->prev = NULL;
|
||
if (hp->next != NULL)
|
||
hp->next->prev = hp;
|
||
hp->type = type;
|
||
hp->length = len;
|
||
hp->value.cpval = value;
|
||
hp->name = ((U_CHAR *) hp) + sizeof (HASHNODE);
|
||
p = hp->name;
|
||
q = name;
|
||
for (i = 0; i < len; i++)
|
||
*p++ = *q++;
|
||
hp->name[len] = 0;
|
||
return hp;
|
||
}
|
||
|
||
/*
|
||
* find the most recent hash node for name "name" (ending with first
|
||
* non-identifier char) installed by install
|
||
*
|
||
* If LEN is >= 0, it is the length of the name.
|
||
* Otherwise, compute the length by scanning the entire name.
|
||
*
|
||
* If HASH is >= 0, it is the precomputed hash code.
|
||
* Otherwise, compute the hash code.
|
||
*/
|
||
|
||
HASHNODE *
|
||
lookup (name, len, hash)
|
||
U_CHAR *name;
|
||
int len;
|
||
int hash;
|
||
{
|
||
register U_CHAR *bp;
|
||
register HASHNODE *bucket;
|
||
|
||
if (len < 0) {
|
||
for (bp = name; is_idchar[*bp]; bp++) ;
|
||
len = bp - name;
|
||
}
|
||
|
||
if (hash < 0)
|
||
hash = hashf (name, len, HASHSIZE);
|
||
|
||
bucket = hashtab[hash];
|
||
while (bucket) {
|
||
if (bucket->length == len && bcmp (bucket->name, name, len) == 0)
|
||
return bucket;
|
||
bucket = bucket->next;
|
||
}
|
||
return NULL;
|
||
}
|
||
|
||
/*
|
||
* Delete a hash node. Some weirdness to free junk from macros.
|
||
* More such weirdness will have to be added if you define more hash
|
||
* types that need it.
|
||
*/
|
||
|
||
/* Note that the DEFINITION of a macro is removed from the hash table
|
||
but its storage is not freed. This would be a storage leak
|
||
except that it is not reasonable to keep undefining and redefining
|
||
large numbers of macros many times.
|
||
In any case, this is necessary, because a macro can be #undef'd
|
||
in the middle of reading the arguments to a call to it.
|
||
If #undef freed the DEFINITION, that would crash. */
|
||
|
||
static void
|
||
delete_macro (hp)
|
||
HASHNODE *hp;
|
||
{
|
||
|
||
if (hp->prev != NULL)
|
||
hp->prev->next = hp->next;
|
||
if (hp->next != NULL)
|
||
hp->next->prev = hp->prev;
|
||
|
||
/* Make sure that the bucket chain header that the deleted guy was
|
||
on points to the right thing afterwards. */
|
||
if (hp == *hp->bucket_hdr)
|
||
*hp->bucket_hdr = hp->next;
|
||
|
||
#if 0
|
||
if (hp->type == T_MACRO) {
|
||
DEFINITION *d = hp->value.defn;
|
||
struct reflist *ap, *nextap;
|
||
|
||
for (ap = d->pattern; ap != NULL; ap = nextap) {
|
||
nextap = ap->next;
|
||
free (ap);
|
||
}
|
||
free (d);
|
||
}
|
||
#endif
|
||
free (hp);
|
||
}
|
||
|
||
/*
|
||
* return hash function on name. must be compatible with the one
|
||
* computed a step at a time, elsewhere
|
||
*/
|
||
|
||
static int
|
||
hashf (name, len, hashsize)
|
||
register U_CHAR *name;
|
||
register int len;
|
||
int hashsize;
|
||
{
|
||
register int r = 0;
|
||
|
||
while (len--)
|
||
r = HASHSTEP (r, *name++);
|
||
|
||
return MAKE_POS (r) % hashsize;
|
||
}
|
||
|
||
|
||
/* Dump the definition of a single macro HP to OF. */
|
||
|
||
static void
|
||
dump_single_macro (hp, of)
|
||
register HASHNODE *hp;
|
||
FILE *of;
|
||
{
|
||
register DEFINITION *defn = hp->value.defn;
|
||
struct reflist *ap;
|
||
int offset;
|
||
int concat;
|
||
|
||
|
||
/* Print the definition of the macro HP. */
|
||
|
||
fprintf (of, "#define %s", hp->name);
|
||
|
||
if (defn->nargs >= 0) {
|
||
int i;
|
||
|
||
fprintf (of, "(");
|
||
for (i = 0; i < defn->nargs; i++) {
|
||
dump_arg_n (defn, i, of);
|
||
if (i + 1 < defn->nargs)
|
||
fprintf (of, ", ");
|
||
}
|
||
fprintf (of, ")");
|
||
}
|
||
|
||
fprintf (of, " ");
|
||
|
||
offset = 0;
|
||
concat = 0;
|
||
for (ap = defn->pattern; ap != NULL; ap = ap->next) {
|
||
dump_defn_1 (defn->expansion, offset, ap->nchars, of);
|
||
offset += ap->nchars;
|
||
if (!traditional) {
|
||
if (ap->nchars != 0)
|
||
concat = 0;
|
||
if (ap->stringify) {
|
||
switch (ap->stringify) {
|
||
case SHARP_TOKEN: fprintf (of, "#"); break;
|
||
case WHITE_SHARP_TOKEN: fprintf (of, "# "); break;
|
||
case PERCENT_COLON_TOKEN: fprintf (of, "%%:"); break;
|
||
case WHITE_PERCENT_COLON_TOKEN: fprintf (of, "%%: "); break;
|
||
default: abort ();
|
||
}
|
||
}
|
||
if (ap->raw_before != 0) {
|
||
if (concat) {
|
||
switch (ap->raw_before) {
|
||
case WHITE_SHARP_TOKEN:
|
||
case WHITE_PERCENT_COLON_TOKEN:
|
||
fprintf (of, " ");
|
||
break;
|
||
default:
|
||
break;
|
||
}
|
||
} else {
|
||
switch (ap->raw_before) {
|
||
case SHARP_TOKEN: fprintf (of, "##"); break;
|
||
case WHITE_SHARP_TOKEN: fprintf (of, "## "); break;
|
||
case PERCENT_COLON_TOKEN: fprintf (of, "%%:%%:"); break;
|
||
case WHITE_PERCENT_COLON_TOKEN: fprintf (of, "%%:%%: "); break;
|
||
default: abort ();
|
||
}
|
||
}
|
||
}
|
||
concat = 0;
|
||
}
|
||
dump_arg_n (defn, ap->argno, of);
|
||
if (!traditional && ap->raw_after != 0) {
|
||
switch (ap->raw_after) {
|
||
case SHARP_TOKEN: fprintf (of, "##"); break;
|
||
case WHITE_SHARP_TOKEN: fprintf (of, " ##"); break;
|
||
case PERCENT_COLON_TOKEN: fprintf (of, "%%:%%:"); break;
|
||
case WHITE_PERCENT_COLON_TOKEN: fprintf (of, " %%:%%:"); break;
|
||
default: abort ();
|
||
}
|
||
concat = 1;
|
||
}
|
||
}
|
||
dump_defn_1 (defn->expansion, offset, defn->length - offset, of);
|
||
fprintf (of, "\n");
|
||
}
|
||
|
||
/* Dump all macro definitions as #defines to stdout. */
|
||
|
||
static void
|
||
dump_all_macros ()
|
||
{
|
||
int bucket;
|
||
|
||
for (bucket = 0; bucket < HASHSIZE; bucket++) {
|
||
register HASHNODE *hp;
|
||
|
||
for (hp = hashtab[bucket]; hp; hp= hp->next) {
|
||
if (hp->type == T_MACRO)
|
||
dump_single_macro (hp, stdout);
|
||
}
|
||
}
|
||
}
|
||
|
||
/* Output to OF a substring of a macro definition.
|
||
BASE is the beginning of the definition.
|
||
Output characters START thru LENGTH.
|
||
Unless traditional, discard newlines outside of strings, thus
|
||
converting funny-space markers to ordinary spaces. */
|
||
|
||
static void
|
||
dump_defn_1 (base, start, length, of)
|
||
U_CHAR *base;
|
||
int start;
|
||
int length;
|
||
FILE *of;
|
||
{
|
||
U_CHAR *p = base + start;
|
||
U_CHAR *limit = base + start + length;
|
||
|
||
if (traditional)
|
||
fwrite (p, sizeof (*p), length, of);
|
||
else {
|
||
while (p < limit) {
|
||
if (*p == '\"' || *p =='\'') {
|
||
U_CHAR *p1 = skip_quoted_string (p, limit, 0, NULL_PTR,
|
||
NULL_PTR, NULL_PTR);
|
||
fwrite (p, sizeof (*p), p1 - p, of);
|
||
p = p1;
|
||
} else {
|
||
if (*p != '\n')
|
||
putc (*p, of);
|
||
p++;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
/* Print the name of argument number ARGNUM of macro definition DEFN
|
||
to OF.
|
||
Recall that DEFN->args.argnames contains all the arg names
|
||
concatenated in reverse order with comma-space in between. */
|
||
|
||
static void
|
||
dump_arg_n (defn, argnum, of)
|
||
DEFINITION *defn;
|
||
int argnum;
|
||
FILE *of;
|
||
{
|
||
register U_CHAR *p = defn->args.argnames;
|
||
while (argnum + 1 < defn->nargs) {
|
||
p = (U_CHAR *) index ((char *) p, ' ') + 1;
|
||
argnum++;
|
||
}
|
||
|
||
while (*p && *p != ',') {
|
||
putc (*p, of);
|
||
p++;
|
||
}
|
||
}
|
||
|
||
/* Initialize syntactic classifications of characters. */
|
||
|
||
static void
|
||
initialize_char_syntax ()
|
||
{
|
||
register int i;
|
||
|
||
/*
|
||
* Set up is_idchar and is_idstart tables. These should be
|
||
* faster than saying (is_alpha (c) || c == '_'), etc.
|
||
* Set up these things before calling any routines tthat
|
||
* refer to them.
|
||
*/
|
||
for (i = 'a'; i <= 'z'; i++) {
|
||
is_idchar[i - 'a' + 'A'] = 1;
|
||
is_idchar[i] = 1;
|
||
is_idstart[i - 'a' + 'A'] = 1;
|
||
is_idstart[i] = 1;
|
||
}
|
||
for (i = '0'; i <= '9'; i++)
|
||
is_idchar[i] = 1;
|
||
is_idchar['_'] = 1;
|
||
is_idstart['_'] = 1;
|
||
is_idchar['$'] = 1;
|
||
is_idstart['$'] = 1;
|
||
|
||
/* horizontal space table */
|
||
is_hor_space[' '] = 1;
|
||
is_hor_space['\t'] = 1;
|
||
is_hor_space['\v'] = 1;
|
||
is_hor_space['\f'] = 1;
|
||
is_hor_space['\r'] = 1;
|
||
|
||
is_space[' '] = 1;
|
||
is_space['\t'] = 1;
|
||
is_space['\v'] = 1;
|
||
is_space['\f'] = 1;
|
||
is_space['\n'] = 1;
|
||
is_space['\r'] = 1;
|
||
}
|
||
|
||
/* Initialize the built-in macros. */
|
||
|
||
static void
|
||
initialize_builtins (inp, outp)
|
||
FILE_BUF *inp;
|
||
FILE_BUF *outp;
|
||
{
|
||
install ((U_CHAR *) "__LINE__", -1, T_SPECLINE, NULL_PTR, -1);
|
||
install ((U_CHAR *) "__DATE__", -1, T_DATE, NULL_PTR, -1);
|
||
install ((U_CHAR *) "__FILE__", -1, T_FILE, NULL_PTR, -1);
|
||
install ((U_CHAR *) "__BASE_FILE__", -1, T_BASE_FILE, NULL_PTR, -1);
|
||
install ((U_CHAR *) "__INCLUDE_LEVEL__", -1, T_INCLUDE_LEVEL, NULL_PTR, -1);
|
||
install ((U_CHAR *) "__VERSION__", -1, T_VERSION, NULL_PTR, -1);
|
||
#ifndef NO_BUILTIN_SIZE_TYPE
|
||
install ((U_CHAR *) "__SIZE_TYPE__", -1, T_SIZE_TYPE, NULL_PTR, -1);
|
||
#endif
|
||
#ifndef NO_BUILTIN_PTRDIFF_TYPE
|
||
install ((U_CHAR *) "__PTRDIFF_TYPE__ ", -1, T_PTRDIFF_TYPE, NULL_PTR, -1);
|
||
#endif
|
||
install ((U_CHAR *) "__WCHAR_TYPE__", -1, T_WCHAR_TYPE, NULL_PTR, -1);
|
||
install ((U_CHAR *) "__USER_LABEL_PREFIX__", -1, T_USER_LABEL_PREFIX_TYPE,
|
||
NULL_PTR, -1);
|
||
install ((U_CHAR *) "__REGISTER_PREFIX__", -1, T_REGISTER_PREFIX_TYPE,
|
||
NULL_PTR, -1);
|
||
install ((U_CHAR *) "__IMMEDIATE_PREFIX__", -1, T_IMMEDIATE_PREFIX_TYPE,
|
||
NULL_PTR, -1);
|
||
install ((U_CHAR *) "__TIME__", -1, T_TIME, NULL_PTR, -1);
|
||
if (!traditional) {
|
||
install ((U_CHAR *) "__STDC__", -1, T_CONST, "1", -1);
|
||
install ((U_CHAR *) "__STDC_VERSION__", -1, T_CONST, "199409L", -1);
|
||
}
|
||
/* This is supplied using a -D by the compiler driver
|
||
so that it is present only when truly compiling with GNU C. */
|
||
/* install ((U_CHAR *) "__GNUC__", -1, T_CONST, "2", -1); */
|
||
install ((U_CHAR *) "__HAVE_BUILTIN_SETJMP__", -1, T_CONST, "1", -1);
|
||
|
||
if (debug_output)
|
||
{
|
||
char directive[2048];
|
||
U_CHAR *udirective = (U_CHAR *) directive;
|
||
register struct directive *dp = &directive_table[0];
|
||
struct tm *timebuf = timestamp ();
|
||
|
||
sprintf (directive, " __BASE_FILE__ \"%s\"\n",
|
||
instack[0].nominal_fname);
|
||
output_line_directive (inp, outp, 0, same_file);
|
||
pass_thru_directive (udirective, &udirective[strlen (directive)],
|
||
outp, dp);
|
||
|
||
sprintf (directive, " __VERSION__ \"%s\"\n", version_string);
|
||
output_line_directive (inp, outp, 0, same_file);
|
||
pass_thru_directive (udirective, &udirective[strlen (directive)],
|
||
outp, dp);
|
||
|
||
#ifndef NO_BUILTIN_SIZE_TYPE
|
||
sprintf (directive, " __SIZE_TYPE__ %s\n", SIZE_TYPE);
|
||
output_line_directive (inp, outp, 0, same_file);
|
||
pass_thru_directive (udirective, &udirective[strlen (directive)],
|
||
outp, dp);
|
||
#endif
|
||
|
||
#ifndef NO_BUILTIN_PTRDIFF_TYPE
|
||
sprintf (directive, " __PTRDIFF_TYPE__ %s\n", PTRDIFF_TYPE);
|
||
output_line_directive (inp, outp, 0, same_file);
|
||
pass_thru_directive (udirective, &udirective[strlen (directive)],
|
||
outp, dp);
|
||
#endif
|
||
|
||
sprintf (directive, " __WCHAR_TYPE__ %s\n", wchar_type);
|
||
output_line_directive (inp, outp, 0, same_file);
|
||
pass_thru_directive (udirective, &udirective[strlen (directive)],
|
||
outp, dp);
|
||
|
||
sprintf (directive, " __DATE__ \"%s %2d %4d\"\n",
|
||
monthnames[timebuf->tm_mon],
|
||
timebuf->tm_mday, timebuf->tm_year + 1900);
|
||
output_line_directive (inp, outp, 0, same_file);
|
||
pass_thru_directive (udirective, &udirective[strlen (directive)],
|
||
outp, dp);
|
||
|
||
sprintf (directive, " __TIME__ \"%02d:%02d:%02d\"\n",
|
||
timebuf->tm_hour, timebuf->tm_min, timebuf->tm_sec);
|
||
output_line_directive (inp, outp, 0, same_file);
|
||
pass_thru_directive (udirective, &udirective[strlen (directive)],
|
||
outp, dp);
|
||
|
||
if (!traditional)
|
||
{
|
||
sprintf (directive, " __STDC__ 1");
|
||
output_line_directive (inp, outp, 0, same_file);
|
||
pass_thru_directive (udirective, &udirective[strlen (directive)],
|
||
outp, dp);
|
||
}
|
||
if (objc)
|
||
{
|
||
sprintf (directive, " __OBJC__ 1");
|
||
output_line_directive (inp, outp, 0, same_file);
|
||
pass_thru_directive (udirective, &udirective[strlen (directive)],
|
||
outp, dp);
|
||
}
|
||
}
|
||
}
|
||
|
||
/*
|
||
* process a given definition string, for initialization
|
||
* If STR is just an identifier, define it with value 1.
|
||
* If STR has anything after the identifier, then it should
|
||
* be identifier=definition.
|
||
*/
|
||
|
||
static void
|
||
make_definition (str)
|
||
char *str;
|
||
{
|
||
FILE_BUF *ip;
|
||
struct directive *kt;
|
||
U_CHAR *buf, *p;
|
||
|
||
p = buf = (U_CHAR *) str;
|
||
if (!is_idstart[*p]) {
|
||
error ("malformed option `-D %s'", str);
|
||
return;
|
||
}
|
||
while (is_idchar[*++p])
|
||
;
|
||
if (*p == '(') {
|
||
while (is_idchar[*++p] || *p == ',' || is_hor_space[*p])
|
||
;
|
||
if (*p++ != ')')
|
||
p = (U_CHAR *) str; /* Error */
|
||
}
|
||
if (*p == 0) {
|
||
buf = (U_CHAR *) alloca (p - buf + 4);
|
||
strcpy ((char *)buf, str);
|
||
strcat ((char *)buf, " 1");
|
||
} else if (*p != '=') {
|
||
error ("malformed option `-D %s'", str);
|
||
return;
|
||
} else {
|
||
U_CHAR *q;
|
||
/* Copy the entire option so we can modify it. */
|
||
buf = (U_CHAR *) alloca (2 * strlen (str) + 1);
|
||
strncpy ((char *) buf, str, p - (U_CHAR *) str);
|
||
/* Change the = to a space. */
|
||
buf[p - (U_CHAR *) str] = ' ';
|
||
/* Scan for any backslash-newline and remove it. */
|
||
p++;
|
||
q = &buf[p - (U_CHAR *) str];
|
||
while (*p) {
|
||
if (*p == '\"' || *p == '\'') {
|
||
int unterminated = 0;
|
||
U_CHAR *p1 = skip_quoted_string (p, p + strlen ((char *) p), 0,
|
||
NULL_PTR, NULL_PTR, &unterminated);
|
||
if (unterminated)
|
||
return;
|
||
while (p != p1)
|
||
*q++ = *p++;
|
||
} else if (*p == '\\' && p[1] == '\n')
|
||
p += 2;
|
||
/* Change newline chars into newline-markers. */
|
||
else if (*p == '\n')
|
||
{
|
||
*q++ = '\n';
|
||
*q++ = '\n';
|
||
p++;
|
||
}
|
||
else
|
||
*q++ = *p++;
|
||
}
|
||
*q = 0;
|
||
}
|
||
|
||
ip = &instack[++indepth];
|
||
ip->nominal_fname = ip->fname = "*Initialization*";
|
||
ip->nominal_fname_len = strlen (ip->nominal_fname);
|
||
|
||
ip->buf = ip->bufp = buf;
|
||
ip->length = strlen ((char *) buf);
|
||
ip->lineno = 1;
|
||
ip->macro = 0;
|
||
ip->free_ptr = 0;
|
||
ip->if_stack = if_stack;
|
||
ip->system_header_p = 0;
|
||
|
||
for (kt = directive_table; kt->type != T_DEFINE; kt++)
|
||
;
|
||
|
||
/* Pass NULL instead of OP, since this is a "predefined" macro. */
|
||
do_define (buf, buf + strlen ((char *) buf), NULL_PTR, kt);
|
||
--indepth;
|
||
}
|
||
|
||
/* JF, this does the work for the -U option */
|
||
|
||
static void
|
||
make_undef (str, op)
|
||
char *str;
|
||
FILE_BUF *op;
|
||
{
|
||
FILE_BUF *ip;
|
||
struct directive *kt;
|
||
|
||
ip = &instack[++indepth];
|
||
ip->nominal_fname = ip->fname = "*undef*";
|
||
ip->nominal_fname_len = strlen (ip->nominal_fname);
|
||
|
||
ip->buf = ip->bufp = (U_CHAR *) str;
|
||
ip->length = strlen (str);
|
||
ip->lineno = 1;
|
||
ip->macro = 0;
|
||
ip->free_ptr = 0;
|
||
ip->if_stack = if_stack;
|
||
ip->system_header_p = 0;
|
||
|
||
for (kt = directive_table; kt->type != T_UNDEF; kt++)
|
||
;
|
||
|
||
do_undef ((U_CHAR *) str, (U_CHAR *) str + strlen (str), op, kt);
|
||
--indepth;
|
||
}
|
||
|
||
/* Process the string STR as if it appeared as the body of a #assert.
|
||
OPTION is the option name for which STR was the argument. */
|
||
|
||
static void
|
||
make_assertion (option, str)
|
||
const char *option;
|
||
const char *str;
|
||
{
|
||
FILE_BUF *ip;
|
||
struct directive *kt;
|
||
U_CHAR *buf, *p, *q;
|
||
|
||
/* Copy the entire option so we can modify it. */
|
||
buf = (U_CHAR *) alloca (strlen (str) + 1);
|
||
strcpy ((char *) buf, str);
|
||
/* Scan for any backslash-newline and remove it. */
|
||
p = q = buf;
|
||
while (*p) {
|
||
if (*p == '\\' && p[1] == '\n')
|
||
p += 2;
|
||
else
|
||
*q++ = *p++;
|
||
}
|
||
*q = 0;
|
||
|
||
p = buf;
|
||
if (!is_idstart[*p]) {
|
||
error ("malformed option `%s %s'", option, str);
|
||
return;
|
||
}
|
||
while (is_idchar[*++p])
|
||
;
|
||
SKIP_WHITE_SPACE (p);
|
||
if (! (*p == 0 || *p == '(')) {
|
||
error ("malformed option `%s %s'", option, str);
|
||
return;
|
||
}
|
||
|
||
ip = &instack[++indepth];
|
||
ip->nominal_fname = ip->fname = "*Initialization*";
|
||
ip->nominal_fname_len = strlen (ip->nominal_fname);
|
||
|
||
ip->buf = ip->bufp = buf;
|
||
ip->length = strlen ((char *) buf);
|
||
ip->lineno = 1;
|
||
ip->macro = 0;
|
||
ip->free_ptr = 0;
|
||
ip->if_stack = if_stack;
|
||
ip->system_header_p = 0;
|
||
|
||
for (kt = directive_table; kt->type != T_ASSERT; kt++)
|
||
;
|
||
|
||
/* Pass NULL as output ptr to do_define since we KNOW it never does
|
||
any output.... */
|
||
do_assert (buf, buf + strlen ((char *) buf) , NULL_PTR, kt);
|
||
--indepth;
|
||
}
|
||
|
||
/* The previous include prefix, if any, is PREV_FILE_NAME.
|
||
Translate any pathnames with COMPONENT.
|
||
Allocate a new include prefix whose name is the
|
||
simplified concatenation of PREFIX and NAME,
|
||
with a trailing / added if needed.
|
||
But return 0 if the include prefix should be ignored,
|
||
e.g. because it is a duplicate of PREV_FILE_NAME. */
|
||
|
||
static struct file_name_list *
|
||
new_include_prefix (prev_file_name, component, prefix, name)
|
||
struct file_name_list *prev_file_name;
|
||
const char *component;
|
||
const char *prefix;
|
||
const char *name;
|
||
{
|
||
if (name == 0)
|
||
fatal ("Directory name missing after command line option");
|
||
|
||
if (*name == 0)
|
||
/* Ignore the empty string. */
|
||
return 0;
|
||
|
||
prefix = update_path (prefix, component);
|
||
name = update_path (name, component);
|
||
|
||
{
|
||
struct file_name_list *dir
|
||
= ((struct file_name_list *)
|
||
xmalloc (sizeof (struct file_name_list)
|
||
+ strlen (prefix) + strlen (name) + 2));
|
||
size_t len;
|
||
strcpy (dir->fname, prefix);
|
||
strcat (dir->fname, name);
|
||
len = simplify_filename (dir->fname);
|
||
|
||
/* Convert directory name to a prefix. */
|
||
if (len && dir->fname[len - 1] != DIR_SEPARATOR) {
|
||
if (len == 1 && dir->fname[len - 1] == '.')
|
||
len = 0;
|
||
else
|
||
#ifdef VMS
|
||
/* must be '/', hack_vms_include_specification triggers on it. */
|
||
dir->fname[len++] = '/';
|
||
#else
|
||
dir->fname[len++] = DIR_SEPARATOR;
|
||
#endif
|
||
dir->fname[len] = 0;
|
||
}
|
||
|
||
/* Ignore a directory whose name matches the previous one. */
|
||
if (prev_file_name && !strcmp (prev_file_name->fname, dir->fname)) {
|
||
/* But treat `-Idir -I- -Idir' as `-I- -Idir'. */
|
||
if (!first_bracket_include)
|
||
first_bracket_include = prev_file_name;
|
||
free (dir);
|
||
return 0;
|
||
}
|
||
|
||
#ifndef VMS
|
||
/* VMS can't stat dir prefixes, so skip these optimizations in VMS. */
|
||
|
||
/* Add a trailing "." if there is a filename. This increases the number
|
||
of systems that can stat directories. We remove it below. */
|
||
if (len != 0)
|
||
{
|
||
dir->fname[len] = '.';
|
||
dir->fname[len + 1] = 0;
|
||
}
|
||
|
||
/* Ignore a nonexistent directory. */
|
||
if (stat (len ? dir->fname : ".", &dir->st) != 0) {
|
||
if (errno != ENOENT && errno != ENOTDIR)
|
||
error_from_errno (dir->fname);
|
||
free (dir);
|
||
return 0;
|
||
}
|
||
|
||
if (len != 0)
|
||
dir->fname[len] = 0;
|
||
|
||
/* Ignore a directory whose identity matches the previous one. */
|
||
if (prev_file_name
|
||
&& INO_T_EQ (prev_file_name->st.st_ino, dir->st.st_ino)
|
||
&& prev_file_name->st.st_dev == dir->st.st_dev) {
|
||
/* But treat `-Idir -I- -Idir' as `-I- -Idir'. */
|
||
if (!first_bracket_include)
|
||
first_bracket_include = prev_file_name;
|
||
free (dir);
|
||
return 0;
|
||
}
|
||
#endif /* ! VMS */
|
||
|
||
dir->next = 0;
|
||
dir->c_system_include_path = 0;
|
||
dir->got_name_map = 0;
|
||
|
||
return dir;
|
||
}
|
||
}
|
||
|
||
/* Append a chain of `struct file_name_list's
|
||
to the end of the main include chain.
|
||
FIRST is the beginning of the chain to append, and LAST is the end. */
|
||
|
||
static void
|
||
append_include_chain (first, last)
|
||
struct file_name_list *first, *last;
|
||
{
|
||
struct file_name_list *dir;
|
||
|
||
if (!first || !last)
|
||
return;
|
||
|
||
if (include == 0)
|
||
include = first;
|
||
else
|
||
last_include->next = first;
|
||
|
||
if (first_bracket_include == 0)
|
||
first_bracket_include = first;
|
||
|
||
for (dir = first; ; dir = dir->next) {
|
||
int len = strlen (dir->fname) + INCLUDE_LEN_FUDGE;
|
||
if (len > max_include_len)
|
||
max_include_len = len;
|
||
if (dir == last)
|
||
break;
|
||
}
|
||
|
||
last->next = NULL;
|
||
last_include = last;
|
||
}
|
||
|
||
/* Place into DST a representation of the file named SRC that is suitable
|
||
for `make'. Do not null-terminate DST. Return its length. */
|
||
static int
|
||
quote_string_for_make (dst, src)
|
||
char *dst;
|
||
const char *src;
|
||
{
|
||
const char *p = src;
|
||
int i = 0;
|
||
for (;;)
|
||
{
|
||
char c = *p++;
|
||
switch (c)
|
||
{
|
||
case '\0':
|
||
case ' ':
|
||
case '\t':
|
||
{
|
||
/* GNU make uses a weird quoting scheme for white space.
|
||
A space or tab preceded by 2N+1 backslashes represents
|
||
N backslashes followed by space; a space or tab
|
||
preceded by 2N backslashes represents N backslashes at
|
||
the end of a file name; and backslashes in other
|
||
contexts should not be doubled. */
|
||
const char *q;
|
||
for (q = p - 1; src < q && q[-1] == '\\'; q--)
|
||
{
|
||
if (dst)
|
||
dst[i] = '\\';
|
||
i++;
|
||
}
|
||
}
|
||
if (!c)
|
||
return i;
|
||
if (dst)
|
||
dst[i] = '\\';
|
||
i++;
|
||
goto ordinary_char;
|
||
|
||
case '$':
|
||
if (dst)
|
||
dst[i] = c;
|
||
i++;
|
||
/* Fall through. This can mishandle things like "$(" but
|
||
there's no easy fix. */
|
||
default:
|
||
ordinary_char:
|
||
/* This can mishandle characters in the string "\0\n%*?[\\~";
|
||
exactly which chars are mishandled depends on the `make' version.
|
||
We know of no portable solution for this;
|
||
even GNU make 3.76.1 doesn't solve the problem entirely.
|
||
(Also, '\0' is mishandled due to our calling conventions.) */
|
||
if (dst)
|
||
dst[i] = c;
|
||
i++;
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
|
||
|
||
/* Add output to `deps_buffer' for the -M switch.
|
||
STRING points to the text to be output.
|
||
SPACER is ':' for targets, ' ' for dependencies. */
|
||
|
||
static void
|
||
deps_output (string, spacer)
|
||
const char *string;
|
||
int spacer;
|
||
{
|
||
int size = quote_string_for_make ((char *) 0, string);
|
||
|
||
if (size == 0)
|
||
return;
|
||
|
||
#ifndef MAX_OUTPUT_COLUMNS
|
||
#define MAX_OUTPUT_COLUMNS 72
|
||
#endif
|
||
if (MAX_OUTPUT_COLUMNS - 1 /*spacer*/ - 2 /*` \'*/ < deps_column + size
|
||
&& 1 < deps_column) {
|
||
bcopy (" \\\n ", &deps_buffer[deps_size], 4);
|
||
deps_size += 4;
|
||
deps_column = 1;
|
||
if (spacer == ' ')
|
||
spacer = 0;
|
||
}
|
||
|
||
if (deps_size + 2 * size + 8 > deps_allocated_size) {
|
||
deps_allocated_size = (deps_size + 2 * size + 50) * 2;
|
||
deps_buffer = xrealloc (deps_buffer, deps_allocated_size);
|
||
}
|
||
if (spacer == ' ') {
|
||
deps_buffer[deps_size++] = ' ';
|
||
deps_column++;
|
||
}
|
||
quote_string_for_make (&deps_buffer[deps_size], string);
|
||
deps_size += size;
|
||
deps_column += size;
|
||
if (spacer == ':') {
|
||
deps_buffer[deps_size++] = ':';
|
||
deps_column++;
|
||
}
|
||
deps_buffer[deps_size] = 0;
|
||
}
|
||
|
||
void
|
||
fatal VPROTO ((const char * msgid, ...))
|
||
{
|
||
#ifndef ANSI_PROTOTYPES
|
||
const char * msgid;
|
||
#endif
|
||
va_list args;
|
||
|
||
fprintf (stderr, "%s: ", progname);
|
||
VA_START (args, msgid);
|
||
|
||
#ifndef ANSI_PROTOTYPES
|
||
msgid = va_arg (args, const char *);
|
||
#endif
|
||
vnotice (msgid, args);
|
||
va_end (args);
|
||
fprintf (stderr, "\n");
|
||
exit (FATAL_EXIT_CODE);
|
||
}
|
||
|
||
/* More 'friendly' abort that prints the line and file.
|
||
config.h can #define abort fancy_abort if you like that sort of thing. */
|
||
|
||
void
|
||
fancy_abort ()
|
||
{
|
||
fatal ("Internal gcc abort.");
|
||
}
|
||
|
||
static void
|
||
perror_with_name (name)
|
||
char *name;
|
||
{
|
||
fprintf (stderr, "%s: %s: %s\n", progname, name, my_strerror (errno));
|
||
errors++;
|
||
}
|
||
|
||
static void
|
||
pfatal_with_name (name)
|
||
char *name;
|
||
{
|
||
perror_with_name (name);
|
||
#ifdef VMS
|
||
exit (vaxc$errno);
|
||
#else
|
||
exit (FATAL_EXIT_CODE);
|
||
#endif
|
||
}
|
||
|
||
/* Handler for SIGPIPE. */
|
||
|
||
static void
|
||
pipe_closed (signo)
|
||
/* If this is missing, some compilers complain. */
|
||
int signo ATTRIBUTE_UNUSED;
|
||
{
|
||
fatal ("output pipe has been closed");
|
||
}
|
||
|
||
static void
|
||
memory_full ()
|
||
{
|
||
fatal ("Memory exhausted.");
|
||
}
|
||
|
||
PTR
|
||
xmalloc (size)
|
||
size_t size;
|
||
{
|
||
register PTR ptr = (PTR) malloc (size);
|
||
if (!ptr)
|
||
memory_full ();
|
||
return ptr;
|
||
}
|
||
|
||
PTR
|
||
xrealloc (old, size)
|
||
PTR old;
|
||
size_t size;
|
||
{
|
||
register PTR ptr;
|
||
if (old)
|
||
ptr = (PTR) realloc (old, size);
|
||
else
|
||
ptr = (PTR) malloc (size);
|
||
if (!ptr)
|
||
memory_full ();
|
||
return ptr;
|
||
}
|
||
|
||
PTR
|
||
xcalloc (number, size)
|
||
size_t number, size;
|
||
{
|
||
register size_t total = number * size;
|
||
register PTR ptr = (PTR) malloc (total);
|
||
if (!ptr)
|
||
memory_full ();
|
||
bzero (ptr, total);
|
||
return ptr;
|
||
}
|
||
|
||
char *
|
||
xstrdup (input)
|
||
const char *input;
|
||
{
|
||
register size_t len = strlen (input) + 1;
|
||
register char *output = xmalloc (len);
|
||
memcpy (output, input, len);
|
||
return output;
|
||
}
|
||
|
||
#ifdef VMS
|
||
|
||
/* Under VMS we need to fix up the "include" specification filename.
|
||
|
||
Rules for possible conversions
|
||
|
||
fullname tried paths
|
||
|
||
name name
|
||
./dir/name [.dir]name
|
||
/dir/name dir:name
|
||
/name [000000]name, name
|
||
dir/name dir:[000000]name, dir:name, dir/name
|
||
dir1/dir2/name dir1:[dir2]name, dir1:[000000.dir2]name
|
||
path:/name path:[000000]name, path:name
|
||
path:/dir/name path:[000000.dir]name, path:[dir]name
|
||
path:dir/name path:[dir]name
|
||
[path]:[dir]name [path.dir]name
|
||
path/[dir]name [path.dir]name
|
||
|
||
The path:/name input is constructed when expanding <> includes.
|
||
|
||
return 1 if name was changed, 0 else. */
|
||
|
||
static int
|
||
hack_vms_include_specification (fullname, vaxc_include)
|
||
char *fullname;
|
||
int vaxc_include;
|
||
{
|
||
register char *basename, *unixname, *local_ptr, *first_slash;
|
||
int f, check_filename_before_returning, must_revert;
|
||
char Local[512];
|
||
|
||
check_filename_before_returning = 0;
|
||
must_revert = 0;
|
||
/* See if we can find a 1st slash. If not, there's no path information. */
|
||
first_slash = index (fullname, '/');
|
||
if (first_slash == 0)
|
||
return 0; /* Nothing to do!!! */
|
||
|
||
/* construct device spec if none given. */
|
||
|
||
if (index (fullname, ':') == 0)
|
||
{
|
||
|
||
/* If fullname has a slash, take it as device spec. */
|
||
|
||
if (first_slash == fullname)
|
||
{
|
||
first_slash = index (fullname+1, '/'); /* 2nd slash ? */
|
||
if (first_slash)
|
||
*first_slash = ':'; /* make device spec */
|
||
for (basename = fullname; *basename != 0; basename++)
|
||
*basename = *(basename+1); /* remove leading slash */
|
||
}
|
||
else if ((first_slash[-1] != '.') /* keep ':/', './' */
|
||
&& (first_slash[-1] != ':')
|
||
&& (first_slash[-1] != ']')) /* or a vms path */
|
||
{
|
||
*first_slash = ':';
|
||
}
|
||
else if ((first_slash[1] == '[') /* skip './' in './[dir' */
|
||
&& (first_slash[-1] == '.'))
|
||
fullname += 2;
|
||
}
|
||
|
||
/* Get part after first ':' (basename[-1] == ':')
|
||
or last '/' (basename[-1] == '/'). */
|
||
|
||
basename = base_name (fullname);
|
||
|
||
/*
|
||
* Check if we have a vax-c style '#include filename'
|
||
* and add the missing .h
|
||
*/
|
||
|
||
if (vaxc_include && !index (basename,'.'))
|
||
strcat (basename, ".h");
|
||
|
||
local_ptr = Local; /* initialize */
|
||
|
||
/* We are trying to do a number of things here. First of all, we are
|
||
trying to hammer the filenames into a standard format, such that later
|
||
processing can handle them.
|
||
|
||
If the file name contains something like [dir.], then it recognizes this
|
||
as a root, and strips the ".]". Later processing will add whatever is
|
||
needed to get things working properly.
|
||
|
||
If no device is specified, then the first directory name is taken to be
|
||
a device name (or a rooted logical). */
|
||
|
||
/* Point to the UNIX filename part (which needs to be fixed!)
|
||
but skip vms path information.
|
||
[basename != fullname since first_slash != 0]. */
|
||
|
||
if ((basename[-1] == ':') /* vms path spec. */
|
||
|| (basename[-1] == ']')
|
||
|| (basename[-1] == '>'))
|
||
unixname = basename;
|
||
else
|
||
unixname = fullname;
|
||
|
||
if (*unixname == '/')
|
||
unixname++;
|
||
|
||
/* If the directory spec is not rooted, we can just copy
|
||
the UNIX filename part and we are done. */
|
||
|
||
if (((basename - fullname) > 1)
|
||
&& ( (basename[-1] == ']')
|
||
|| (basename[-1] == '>')))
|
||
{
|
||
if (basename[-2] != '.')
|
||
{
|
||
|
||
/* The VMS part ends in a `]', and the preceding character is not a `.'.
|
||
-> PATH]:/name (basename = '/name', unixname = 'name')
|
||
We strip the `]', and then splice the two parts of the name in the
|
||
usual way. Given the default locations for include files in cccp.c,
|
||
we will only use this code if the user specifies alternate locations
|
||
with the /include (-I) switch on the command line. */
|
||
|
||
basename -= 1; /* Strip "]" */
|
||
unixname--; /* backspace */
|
||
}
|
||
else
|
||
{
|
||
|
||
/* The VMS part has a ".]" at the end, and this will not do. Later
|
||
processing will add a second directory spec, and this would be a syntax
|
||
error. Thus we strip the ".]", and thus merge the directory specs.
|
||
We also backspace unixname, so that it points to a '/'. This inhibits the
|
||
generation of the 000000 root directory spec (which does not belong here
|
||
in this case). */
|
||
|
||
basename -= 2; /* Strip ".]" */
|
||
unixname--; /* backspace */
|
||
}
|
||
}
|
||
|
||
else
|
||
|
||
{
|
||
|
||
/* We drop in here if there is no VMS style directory specification yet.
|
||
If there is no device specification either, we make the first dir a
|
||
device and try that. If we do not do this, then we will be essentially
|
||
searching the users default directory (as if they did a #include "asdf.h").
|
||
|
||
Then all we need to do is to push a '[' into the output string. Later
|
||
processing will fill this in, and close the bracket. */
|
||
|
||
if ((unixname != fullname) /* vms path spec found. */
|
||
&& (basename[-1] != ':'))
|
||
*local_ptr++ = ':'; /* dev not in spec. take first dir */
|
||
|
||
*local_ptr++ = '['; /* Open the directory specification */
|
||
}
|
||
|
||
if (unixname == fullname) /* no vms dir spec. */
|
||
{
|
||
must_revert = 1;
|
||
if ((first_slash != 0) /* unix dir spec. */
|
||
&& (*unixname != '/') /* not beginning with '/' */
|
||
&& (*unixname != '.')) /* or './' or '../' */
|
||
*local_ptr++ = '.'; /* dir is local ! */
|
||
}
|
||
|
||
/* at this point we assume that we have the device spec, and (at least
|
||
the opening "[" for a directory specification. We may have directories
|
||
specified already.
|
||
|
||
If there are no other slashes then the filename will be
|
||
in the "root" directory. Otherwise, we need to add
|
||
directory specifications. */
|
||
|
||
if (index (unixname, '/') == 0)
|
||
{
|
||
/* if no directories specified yet and none are following. */
|
||
if (local_ptr[-1] == '[')
|
||
{
|
||
/* Just add "000000]" as the directory string */
|
||
strcpy (local_ptr, "000000]");
|
||
local_ptr += strlen (local_ptr);
|
||
check_filename_before_returning = 1; /* we might need to fool with this later */
|
||
}
|
||
}
|
||
else
|
||
{
|
||
|
||
/* As long as there are still subdirectories to add, do them. */
|
||
while (index (unixname, '/') != 0)
|
||
{
|
||
/* If this token is "." we can ignore it
|
||
if it's not at the beginning of a path. */
|
||
if ((unixname[0] == '.') && (unixname[1] == '/'))
|
||
{
|
||
/* remove it at beginning of path. */
|
||
if ( ((unixname == fullname) /* no device spec */
|
||
&& (fullname+2 != basename)) /* starts with ./ */
|
||
/* or */
|
||
|| ((basename[-1] == ':') /* device spec */
|
||
&& (unixname-1 == basename))) /* and ./ afterwards */
|
||
*local_ptr++ = '.'; /* make '[.' start of path. */
|
||
unixname += 2;
|
||
continue;
|
||
}
|
||
|
||
/* Add a subdirectory spec. Do not duplicate "." */
|
||
if ( local_ptr[-1] != '.'
|
||
&& local_ptr[-1] != '['
|
||
&& local_ptr[-1] != '<')
|
||
*local_ptr++ = '.';
|
||
|
||
/* If this is ".." then the spec becomes "-" */
|
||
if ( (unixname[0] == '.')
|
||
&& (unixname[1] == '.')
|
||
&& (unixname[2] == '/'))
|
||
{
|
||
/* Add "-" and skip the ".." */
|
||
if ((local_ptr[-1] == '.')
|
||
&& (local_ptr[-2] == '['))
|
||
local_ptr--; /* prevent [.- */
|
||
*local_ptr++ = '-';
|
||
unixname += 3;
|
||
continue;
|
||
}
|
||
|
||
/* Copy the subdirectory */
|
||
while (*unixname != '/')
|
||
*local_ptr++= *unixname++;
|
||
|
||
unixname++; /* Skip the "/" */
|
||
}
|
||
|
||
/* Close the directory specification */
|
||
if (local_ptr[-1] == '.') /* no trailing periods */
|
||
local_ptr--;
|
||
|
||
if (local_ptr[-1] == '[') /* no dir needed */
|
||
local_ptr--;
|
||
else
|
||
*local_ptr++ = ']';
|
||
}
|
||
|
||
/* Now add the filename. */
|
||
|
||
while (*unixname)
|
||
*local_ptr++ = *unixname++;
|
||
*local_ptr = 0;
|
||
|
||
/* Now append it to the original VMS spec. */
|
||
|
||
strcpy ((must_revert==1)?fullname:basename, Local);
|
||
|
||
/* If we put a [000000] in the filename, try to open it first. If this fails,
|
||
remove the [000000], and return that name. This provides flexibility
|
||
to the user in that they can use both rooted and non-rooted logical names
|
||
to point to the location of the file. */
|
||
|
||
if (check_filename_before_returning)
|
||
{
|
||
f = open (fullname, O_RDONLY, 0666);
|
||
if (f >= 0)
|
||
{
|
||
/* The file name is OK as it is, so return it as is. */
|
||
close (f);
|
||
return 1;
|
||
}
|
||
|
||
/* The filename did not work. Try to remove the [000000] from the name,
|
||
and return it. */
|
||
|
||
basename = index (fullname, '[');
|
||
local_ptr = index (fullname, ']') + 1;
|
||
strcpy (basename, local_ptr); /* this gets rid of it */
|
||
|
||
}
|
||
|
||
return 1;
|
||
}
|
||
#endif /* VMS */
|
||
|
||
#ifdef VMS
|
||
|
||
/* The following wrapper functions supply additional arguments to the VMS
|
||
I/O routines to optimize performance with file handling. The arguments
|
||
are:
|
||
"mbc=16" - Set multi-block count to 16 (use a 8192 byte buffer).
|
||
"deq=64" - When extending the file, extend it in chunks of 32Kbytes.
|
||
"fop=tef"- Truncate unused portions of file when closing file.
|
||
"shr=nil"- Disallow file sharing while file is open. */
|
||
|
||
static FILE *
|
||
VMS_freopen (fname, type, oldfile)
|
||
char *fname;
|
||
char *type;
|
||
FILE *oldfile;
|
||
{
|
||
#undef freopen /* Get back the real freopen routine. */
|
||
if (strcmp (type, "w") == 0)
|
||
return freopen (fname, type, oldfile,
|
||
"mbc=16", "deq=64", "fop=tef", "shr=nil");
|
||
return freopen (fname, type, oldfile, "mbc=16");
|
||
}
|
||
|
||
static FILE *
|
||
VMS_fopen (fname, type)
|
||
char *fname;
|
||
char *type;
|
||
{
|
||
#undef fopen /* Get back the real fopen routine. */
|
||
/* The gcc-vms-1.42 distribution's header files prototype fopen with two
|
||
fixed arguments, which matches ANSI's specification but not VAXCRTL's
|
||
pre-ANSI implementation. This hack circumvents the mismatch problem. */
|
||
FILE *(*vmslib_fopen)() = (FILE *(*)()) fopen;
|
||
|
||
if (*type == 'w')
|
||
return (*vmslib_fopen) (fname, type, "mbc=32",
|
||
"deq=64", "fop=tef", "shr=nil");
|
||
else
|
||
return (*vmslib_fopen) (fname, type, "mbc=32");
|
||
}
|
||
|
||
static int
|
||
VMS_open (fname, flags, prot)
|
||
char *fname;
|
||
int flags;
|
||
int prot;
|
||
{
|
||
#undef open /* Get back the real open routine. */
|
||
return open (fname, flags, prot, "mbc=16", "deq=64", "fop=tef");
|
||
}
|
||
|
||
/* more VMS hackery */
|
||
#include <fab.h>
|
||
#include <nam.h>
|
||
|
||
extern unsigned long SYS$PARSE(), SYS$SEARCH();
|
||
|
||
/* Work around another library bug. If a file is located via a searchlist,
|
||
and if the device it's on is not the same device as the one specified
|
||
in the first element of that searchlist, then both stat() and fstat()
|
||
will fail to return info about it. `errno' will be set to EVMSERR, and
|
||
`vaxc$errno' will be set to SS$_NORMAL due yet another bug in stat()!
|
||
We can get around this by fully parsing the filename and then passing
|
||
that absolute name to stat().
|
||
|
||
Without this fix, we can end up failing to find header files, which is
|
||
bad enough, but then compounding the problem by reporting the reason for
|
||
failure as "normal successful completion." */
|
||
|
||
#undef fstat /* Get back to the library version. */
|
||
|
||
static int
|
||
VMS_fstat (fd, statbuf)
|
||
int fd;
|
||
struct stat *statbuf;
|
||
{
|
||
int result = fstat (fd, statbuf);
|
||
|
||
if (result < 0)
|
||
{
|
||
FILE *fp;
|
||
char nambuf[NAM$C_MAXRSS+1];
|
||
|
||
if ((fp = fdopen (fd, "r")) != 0 && fgetname (fp, nambuf) != 0)
|
||
result = VMS_stat (nambuf, statbuf);
|
||
/* No fclose(fp) here; that would close(fd) as well. */
|
||
}
|
||
|
||
return result;
|
||
}
|
||
|
||
static int
|
||
VMS_stat (name, statbuf)
|
||
const char *name;
|
||
struct stat *statbuf;
|
||
{
|
||
int result = stat (name, statbuf);
|
||
|
||
if (result < 0)
|
||
{
|
||
struct FAB fab;
|
||
struct NAM nam;
|
||
char exp_nam[NAM$C_MAXRSS+1], /* expanded name buffer for SYS$PARSE */
|
||
res_nam[NAM$C_MAXRSS+1]; /* resultant name buffer for SYS$SEARCH */
|
||
|
||
fab = cc$rms_fab;
|
||
fab.fab$l_fna = (char *) name;
|
||
fab.fab$b_fns = (unsigned char) strlen (name);
|
||
fab.fab$l_nam = (void *) &nam;
|
||
nam = cc$rms_nam;
|
||
nam.nam$l_esa = exp_nam, nam.nam$b_ess = sizeof exp_nam - 1;
|
||
nam.nam$l_rsa = res_nam, nam.nam$b_rss = sizeof res_nam - 1;
|
||
nam.nam$b_nop = NAM$M_PWD | NAM$M_NOCONCEAL;
|
||
if (SYS$PARSE (&fab) & 1)
|
||
{
|
||
if (SYS$SEARCH (&fab) & 1)
|
||
{
|
||
res_nam[nam.nam$b_rsl] = '\0';
|
||
result = stat (res_nam, statbuf);
|
||
}
|
||
/* Clean up searchlist context cached by the system. */
|
||
nam.nam$b_nop = NAM$M_SYNCHK;
|
||
fab.fab$l_fna = 0, fab.fab$b_fns = 0;
|
||
(void) SYS$PARSE (&fab);
|
||
}
|
||
}
|
||
|
||
return result;
|
||
}
|
||
#endif /* VMS */
|