for the sake of machines with limited C compilers. */
#ifndef EMACS
#include "config.h"
-#include <malloc.h>
+#include "newalloc.h"
#include <string.h>
#endif /* not EMACS */
#define GCC_INCLUDE_DIR "/usr/local/lib/gcc-lib/i386-unknown-freebsd_1.0/2.5.8/include"
#include <stdlib.h>
#endif
+
+// PENDING: Straighten this out into configure
+#include <time.h> // all compilers need this
#ifdef __MINGW32__
#include <time.h>
#else
#ifndef VMS
#ifndef USG
#if !defined(_MSC_VER)
-#include <sys/time.h> /* for __DATE__ and __TIME__ */
+// PENDING
+#include <time.h>
+#include <sys/time.h> /* for __DATE__ and __TIME__ */
#include <sys/resource.h>
#else
-/*#include <sys/param.h> CYGNUS LOCAL: shebs -noquiet */
+/*#include <sys/param.h> CYGNUS LOCAL: shebs -noquiet */
// #include <sys/times.h>
#include <time.h>
#include <fcntl.h>
#define WCHAR_TYPE "int"
#endif
#define CPP_WCHAR_TYPE(PFILE) \
- (CPP_OPTIONS (PFILE)->cplusplus ? "__wchar_t" : WCHAR_TYPE)
+ (CPP_OPTIONS (PFILE)->cplusplus ? "__wchar_t" : WCHAR_TYPE)
/* The string value for __USER_LABEL_PREFIX__ */
};
struct assertion_hashnode {
- struct assertion_hashnode *next; /* double links for easy deletion */
+ 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 */
+ int length; /* length of token, for quick comparison */
+ U_CHAR *name; /* the actual name */
/* List of token-sequences. */
struct tokenlist_list *value;
};
/* Forward declarations. */
-extern char *xmalloc ();
+//extern char *Safe_malloc ();
static void add_import ();
static void append_include_chain ();
-static void make_undef ();
static void make_assertion ();
static void path_include ();
static void initialize_builtins ();
static void initialize_char_syntax ();
-static void dump_arg_n ();
-static void dump_defn_1 ();
extern void delete_macro ();
-static void trigraph_pcp ();
static int finclude ();
static void validate_else ();
static int comp_def_part ();
extern void fancy_abort ();
-static void pipe_closed ();
-static void print_containing_files ();
static int lookup_import ();
static int redundant_include_p ();
-static is_system_include ();
+static int is_system_include (cpp_reader *, char *);
static struct file_name_map *read_name_map ();
static char *read_filename_string ();
static int open_include_file ();
-static int check_preconditions ();
-static void pcfinclude ();
-static void pcstring_used ();
static int check_macro_name ();
static int compare_defs ();
static int compare_token_lists ();
static void free_token_list ();
static int safe_read ();
static void push_macro_expansion PARAMS ((cpp_reader *,
- U_CHAR*, int, HASHNODE*));
+ U_CHAR*, int, HASHNODE*));
static struct cpp_pending *nreverse_pending PARAMS ((struct cpp_pending*));
-extern char *xrealloc ();
-extern char *xcalloc ();
+//extern char *xrealloc ();
+//extern char *xcalloc ();
static char *savestring ();
static void conditional_skip ();
/* -I directories are added to the end, then the defaults are added. */
/* The */
static struct default_include {
- char *fname; /* The name of 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++. */
+ char *fname; /* The name of 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++. */
} include_defaults_array[]
#ifdef INCLUDE_DEFAULTS
= INCLUDE_DEFAULTS;
/* `struct directive' defines one #-directive, including how to handle it. */
struct directive {
- int length; /* Length of name */
- int (*func)(); /* Function to handle directive */
- char *name; /* Name of directive */
- enum node_type type; /* Code which describes which directive. */
+ int length; /* Length of name */
+ int (*func)(); /* Function to handle directive */
+ char *name; /* Name of directive */
+ enum node_type type; /* Code which describes which directive. */
char command_reads_line; /* One if rest of line is read by func. */
- char traditional_comments; /* Nonzero: keep comments if -traditional. */
- char pass_thru; /* Copy preprocessed directive to output file.*/
+ char traditional_comments; /* Nonzero: keep comments if -traditional. */
+ char pass_thru; /* Copy preprocessed directive to output file.*/
};
/* Here is the actual list of #-directives, most-often-used first.
{
default:
if (isprint (c))
- CPP_PUTC_Q (pfile, c);
- else
- {
- sprintf (CPP_PWRITTEN (pfile), "\\%03o", c);
- CPP_ADJUST_WRITTEN (pfile, 4);
- }
- break;
+ CPP_PUTC_Q (pfile, c);
+ else
+ {
+ sprintf (CPP_PWRITTEN (pfile), "\\%03o", c);
+ CPP_ADJUST_WRITTEN (pfile, 4);
+ }
+ break;
case '\"':
case '\\':
- CPP_PUTC_Q (pfile, '\\');
- CPP_PUTC_Q (pfile, c);
- break;
-
+ CPP_PUTC_Q (pfile, '\\');
+ CPP_PUTC_Q (pfile, c);
+ break;
+
case '\0':
- CPP_PUTC_Q (pfile, '\"');
- CPP_NUL_TERMINATE_Q (pfile);
- return;
+ CPP_PUTC_Q (pfile, '\"');
+ CPP_NUL_TERMINATE_Q (pfile);
+ return;
}
}
{
long old_written = CPP_WRITTEN (pfile);
pfile->token_buffer_size = n + 2 * pfile->token_buffer_size;
- pfile->token_buffer = (U_CHAR*)
- xrealloc(pfile->token_buffer, pfile->token_buffer_size);
+ pfile->token_buffer = (U_CHAR*) Safe_realloc(pfile->token_buffer, pfile->token_buffer_size);
CPP_SET_WRITTEN (pfile, old_written);
}
p++;
q = &buf[p - str];
while (*p)
- {
+ {
if (*p == '\\' && p[1] == '\n')
- p += 2;
+ p += 2;
else
- *q++ = *p++;
+ *q++ = *p++;
}
*q = 0;
}
-
+
do_define (pfile, NULL, buf, buf + strlen (buf));
}
\f
U_CHAR *str)
{
cpp_buffer *ip;
- struct directive *kt;
- U_CHAR *buf, *p, *q;
+/* 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);
+
+#if 0
/* Scan for any backslash-newline and remove it. */
p = q = buf;
while (*p) {
-#if 0
if (*p == '\\' && p[1] == '\n')
p += 2;
else
-#endif
*q++ = *p++;
}
*q = 0;
+#endif
p = buf;
if (!is_idstart[*p]) {
cpp_error (pfile, "malformed option `%s %s'", option, str);
return;
}
-
+
ip = cpp_push_buffer (pfile, buf, strlen (buf));
do_assert (pfile, NULL, NULL, NULL);
cpp_pop_buffer (pfile);
if (pfile->deps_size + size + 8 > pfile->deps_allocated_size)
{
pfile->deps_allocated_size = (pfile->deps_size + size + 50) * 2;
- pfile->deps_buffer = (char *) xrealloc (pfile->deps_buffer,
- pfile->deps_allocated_size);
+ pfile->deps_buffer = (char *) Safe_realloc(pfile->deps_buffer,
+ pfile->deps_allocated_size);
}
if (spacer == ' ' && pfile->deps_column > 0)
pfile->deps_buffer[pfile->deps_size++] = ' ';
/* Find the end of this name. */
while (*q != 0 && *q != PATH_SEPARATOR) q++;
if (p == q) {
- /* An empty name in the path stands for the current directory. */
- name = (char *) xmalloc (2);
- name[0] = '.';
- name[1] = 0;
+ /* An empty name in the path stands for the current directory. */
+ name = (char *) Safe_malloc (2);
+ name[0] = '.';
+ name[1] = 0;
} else {
- /* Otherwise use the directory that is named. */
- name = (char *) xmalloc (q - p + 1);
- bcopy (p, name, q - p);
- name[q - p] = 0;
+ /* Otherwise use the directory that is named. */
+ name = (char *) Safe_malloc (q - p + 1);
+ bcopy (p, name, q - p);
+ name[q - p] = 0;
}
dirtmp = (struct file_name_list *)
- xmalloc (sizeof (struct file_name_list));
- dirtmp->next = 0; /* New one goes on the end */
+ Safe_malloc (sizeof (struct file_name_list));
+ dirtmp->next = 0; /* New one goes on the end */
dirtmp->control_macro = 0;
dirtmp->c_system_include_path = 0;
dirtmp->fname = name;
/* Advance past this name. */
p = q;
if (*p == 0)
- break;
+ break;
/* Skip the colon. */
p++;
}
if (macro->type == T_DISABLED)
macro->type = T_MACRO;
if (macro->type != T_MACRO || pbuf->buf != macro->value.defn->expansion)
- free (pbuf->buf);
+ Safe_free (pbuf->buf);
return 0;
}
{
if (pbuf->buf)
{
- free (pbuf->buf);
+ Safe_free (pbuf->buf);
pbuf->buf = 0;
}
return 0;
}
-static void
-newline_fix (
- cpp_reader *pfile)
-{
-#if 1
- NEWLINE_FIX;
-#else
- 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';
- }
-#endif
-}
-
/* Assuming we have read '/'.
If this is the start of a comment (followed by '*' or '/'),
skip to the end of the comment, and return ' '.
cpp_reader *pfile,
long *linep)
{
- int c;
+ int c = 0;
while (PEEKC() == '\\' && PEEKN(1) == '\n')
{
if (linep)
- (*linep)++;
+ (*linep)++;
FORWARD(2);
}
if (PEEKC() == '*')
{
FORWARD(1);
for (;;)
- {
- int prev_c = c;
- c = GETC ();
- if (c == EOF)
- return EOF;
- while (c == '\\' && PEEKC() == '\n')
- {
- if (linep)
- (*linep)++;
- FORWARD(1), c = GETC();
- }
- if (prev_c == '*' && c == '/')
- return ' ';
- if (c == '\n' && linep)
- (*linep)++;
- }
+ {
+ int prev_c = c;
+ c = GETC ();
+ if (c == EOF)
+ return EOF;
+ while (c == '\\' && PEEKC() == '\n')
+ {
+ if (linep)
+ (*linep)++;
+ FORWARD(1), c = GETC();
+ }
+ if (prev_c == '*' && c == '/')
+ return ' ';
+ if (c == '\n' && linep)
+ (*linep)++;
+ }
}
else if (PEEKC() == '/' && CPP_OPTIONS (pfile)->cplusplus_comments)
{
FORWARD(1);
for (;;)
- {
- c = GETC ();
- if (c == EOF)
- return ' '; /* Allow // to be terminated by EOF. */
- while (c == '\\' && PEEKC() == '\n')
- {
- FORWARD(1);
- c = GETC();
- if (linep)
- (*linep)++;
- }
- if (c == '\n')
- {
- /* Don't consider final '\n' to be part of comment. */
- FORWARD(-1);
- return ' ';
- }
- }
+ {
+ c = GETC ();
+ if (c == EOF)
+ return ' '; /* Allow // to be terminated by EOF. */
+ while (c == '\\' && PEEKC() == '\n')
+ {
+ FORWARD(1);
+ c = GETC();
+ if (linep)
+ (*linep)++;
+ }
+ if (c == '\n')
+ {
+ /* Don't consider final '\n' to be part of comment. */
+ FORWARD(-1);
+ return ' ';
+ }
+ }
}
else
return '/';
-}
+}
/* Skip whitespace \-newline and comments. Does not macro-expand. */
void
{
int c = PEEKC();
if (c == EOF)
- return; /* FIXME */
+ return; /* FIXME */
if (is_hor_space[c])
- {
- if ((c == '\f' || c == '\v') && CPP_PEDANTIC (pfile))
- cpp_pedwarn (pfile, "%s in preprocessing directive",
- c == '\f' ? "formfeed" : "vertical tab");
- FORWARD(1);
- }
+ {
+ if ((c == '\f' || c == '\v') && CPP_PEDANTIC (pfile))
+ cpp_pedwarn (pfile, "%s in preprocessing directive",
+ c == '\f' ? "formfeed" : "vertical tab");
+ FORWARD(1);
+ }
else if (c == '/')
- {
- FORWARD (1);
- c = skip_comment (pfile, NULL);
- if (c == '/')
- FORWARD(-1);
- if (c == EOF || c == '/')
- return;
- }
+ {
+ FORWARD (1);
+ c = skip_comment (pfile, NULL);
+ if (c == '/')
+ FORWARD(-1);
+ if (c == EOF || c == '/')
+ return;
+ }
else if (c == '\\' && PEEKN(1) == '\n') {
- FORWARD(2);
+ FORWARD(2);
}
else if (c == '@' && CPP_BUFFER (pfile)->has_escapes
- && is_hor_space[PEEKN(1)])
- FORWARD(2);
+ && is_hor_space[PEEKN(1)])
+ FORWARD(2);
else return;
}
}
int c = GETC();
int nextc;
switch (c)
- {
- case EOF:
- goto end_directive;
- case '\\':
- if (PEEKC() == '\n')
- {
- FORWARD (1);
- continue;
- }
- case '\'':
- case '\"':
- goto scan_directive_token;
- break;
- case '/':
- nextc = PEEKC();
- if (nextc == '*' || (opts->cplusplus_comments && nextc == '/'))
- goto scan_directive_token;
- break;
- case '\f':
- case '\v':
- if (CPP_PEDANTIC (pfile))
- cpp_pedwarn (pfile, "%s in preprocessing directive",
- c == '\f' ? "formfeed" : "vertical tab");
- break;
-
- case '\n':
- FORWARD(-1);
- goto end_directive;
- scan_directive_token:
- FORWARD(-1);
- cpp_get_token (pfile);
- continue;
- }
+ {
+ case EOF:
+ goto end_directive;
+ case '\\':
+ if (PEEKC() == '\n')
+ {
+ FORWARD (1);
+ continue;
+ }
+ case '\'':
+ case '\"':
+ goto scan_directive_token;
+ break;
+ case '/':
+ nextc = PEEKC();
+ if (nextc == '*' || (opts->cplusplus_comments && nextc == '/'))
+ goto scan_directive_token;
+ break;
+ case '\f':
+ case '\v':
+ if (CPP_PEDANTIC (pfile))
+ cpp_pedwarn (pfile, "%s in preprocessing directive",
+ c == '\f' ? "formfeed" : "vertical tab");
+ break;
+
+ case '\n':
+ FORWARD(-1);
+ goto end_directive;
+ scan_directive_token:
+ FORWARD(-1);
+ cpp_get_token (pfile);
+ continue;
+ }
CPP_PUTC (pfile, c);
}
end_directive: ;
{ int c;
register struct directive *kt;
int ident_length;
- long after_ident;
+ long after_ident = 0;
U_CHAR *ident, *line_end;
long old_written = CPP_WRITTEN (pfile);
{
/* Handle # followed by a line number. */
if (CPP_PEDANTIC (pfile))
- cpp_pedwarn (pfile, "`#' followed by integer");
+ cpp_pedwarn (pfile, "`#' followed by integer");
do_line (pfile, NULL);
goto done_a_directive;
}
U_CHAR *p = ident;
while (is_idchar[*p]) {
if (*p < '0' || *p > '9')
- break;
+ break;
p++;
}
/* 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)
- cpp_warning (pfile, "invalid preprocessor directive");
- return 0;
+ if (pedantic && !lang_asm)
+ cpp_warning (pfile, "invalid preprocessor directive");
+ return 0;
}
}
for (kt = directive_table; ; kt++) {
if (kt->length <= 0)
goto not_a_directive;
- if (kt->length == ident_length && !strncmp (kt->name, ident, ident_length))
+ if (kt->length == ident_length && !strncmp (kt->name, ident, ident_length))
break;
}
{
/* Nonzero means do not delete comments within the directive.
#define needs this when -traditional. */
- int comments = CPP_TRADITIONAL (pfile) && kt->traditional_comments;
- int save_put_out_comments = CPP_OPTIONS (pfile)->put_out_comments;
- CPP_OPTIONS (pfile)->put_out_comments = comments;
- after_ident = CPP_WRITTEN (pfile);
- copy_rest_of_line (pfile);
- CPP_OPTIONS (pfile)->put_out_comments = save_put_out_comments;
+ int comments = CPP_TRADITIONAL (pfile) && kt->traditional_comments;
+ int save_put_out_comments = CPP_OPTIONS (pfile)->put_out_comments;
+ CPP_OPTIONS (pfile)->put_out_comments = comments;
+ after_ident = CPP_WRITTEN (pfile);
+ copy_rest_of_line (pfile);
+ CPP_OPTIONS (pfile)->put_out_comments = save_put_out_comments;
}
/* For #pragma and #define, we may want to pass through the directive.
Other directives may create output, but we don't want the directive
- itself out, so we pop it now. For example #include may write a
+ itself out, so we pop it now. For example #include may write a
command (see comment in do_include), and conditionals may emit
#failed ... #endfailed stuff. But note that popping the buffer
means the parameters to kt->func may point after pfile->limit
(*kt->func) (pfile, kt, pfile->token_buffer + after_ident, line_end);
if (kt->pass_thru
|| (kt->type == T_DEFINE
- && CPP_OPTIONS (pfile)->dump_macros == dump_definitions))
+ && CPP_OPTIONS (pfile)->dump_macros == dump_definitions))
{
/* Just leave the entire #define in the output stack. */
}
else if (kt->type == T_DEFINE
- && CPP_OPTIONS (pfile)->dump_macros == dump_names)
+ && CPP_OPTIONS (pfile)->dump_macros == dump_names)
{
U_CHAR *p = pfile->token_buffer + old_written + 7; /* Skip "#define". */
SKIP_WHITE_SPACE (p);
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. */
so this is an upper bound. The extra 5 are for invented
leading and trailing newline-marker and final null. */
maxsize = (sizeof (DEFINITION)
- + (limit - p) + 5);
+ + (limit - p) + 5);
/* Occurrences of '@' get doubled, so allocate extra space for them. */
while (p < limit)
if (*p++ == '@')
maxsize++;
- defn = (DEFINITION *) xcalloc (1, maxsize);
+ defn = (DEFINITION *) Safe_calloc(1,maxsize);
defn->nargs = nargs;
exp_p = defn->expansion = (U_CHAR *) defn + sizeof (DEFINITION);
expected_delimiter = '\0';
} else
expected_delimiter = c;
- break;
+ break;
case '\\':
- if (p < limit && expected_delimiter) {
- /* In a string, backslash goes through
- and makes next char ordinary. */
- *exp_p++ = *p++;
- }
- break;
+ if (p < limit && expected_delimiter) {
+ /* In a string, backslash goes through
+ and makes next char ordinary. */
+ *exp_p++ = *p++;
+ }
+ break;
case '@':
- /* An '@' in a string or character constant stands for itself,
- and does not need to be escaped. */
- if (!expected_delimiter)
- *exp_p++ = c;
- break;
+ /* An '@' in a string or character constant stands for itself,
+ and does not need to be escaped. */
+ if (!expected_delimiter)
+ *exp_p++ = c;
+ break;
case '#':
- /* # is ordinary inside a string. */
- if (expected_delimiter)
- break;
- if (p < limit && *p == '#') {
- /* ##: 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++;
- /* Discard following whitespace. */
- SKIP_WHITE_SPACE (p);
- concat = p;
- if (p == limit)
- cpp_error (pfile, "`##' at end of macro definition");
- } else if (nargs >= 0) {
- /* Single #: stringify following argument ref.
- Don't leave the # in the expansion. */
- exp_p--;
- SKIP_WHITE_SPACE (p);
- if (p == limit || ! is_idstart[*p])
- cpp_error (pfile,
- "`#' operator is not followed by a macro argument name");
- else
- stringify = p;
- }
- break;
+ /* # is ordinary inside a string. */
+ if (expected_delimiter)
+ break;
+ if (p < limit && *p == '#') {
+ /* ##: 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++;
+ /* Discard following whitespace. */
+ SKIP_WHITE_SPACE (p);
+ concat = p;
+ if (p == limit)
+ cpp_error (pfile, "`##' at end of macro definition");
+ } else if (nargs >= 0) {
+ /* Single #: stringify following argument ref.
+ Don't leave the # in the expansion. */
+ exp_p--;
+ SKIP_WHITE_SPACE (p);
+ if (p == limit || ! is_idstart[*p])
+ cpp_error (pfile,
+ "`#' operator is not followed by a macro argument name");
+ else
+ stringify = p;
+ }
+ break;
}
} else {
/* In -traditional mode, recognize arguments inside strings and
- and character constants, and ignore special properties of #.
- Arguments inside strings are considered "stringified", but no
- extra quote marks are supplied. */
+ 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;
+ 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;
+ /* 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--;
- p += 1;
- while (p < limit && !(p[-2] == '*' && p[-1] == '/'))
- p++;
+ 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--;
+ p += 1;
+ while (p < limit && !(p[-2] == '*' && p[-1] == '/'))
+ p++;
#if 0
- /* Mark this as a concatenation-point, as if it had been ##. */
- concat = p;
+ /* Mark this as a concatenation-point, as if it had been ##. */
+ concat = p;
#endif
- }
- else if (*p == '/') {
- /* A c++ comment. Discard to the end of line */
- exp_p--;
- p = limit;
- }
- break;
+ }
+ else if (*p == '/') {
+ /* A c++ comment. Discard to the end of line */
+ exp_p--;
+ p = limit;
+ }
+ break;
}
}
id_len = p - id_beg;
if (is_idstart[c]) {
- register struct arglist *arg;
-
- for (arg = arglist; arg != NULL; arg = arg->next) {
- struct reflist *tpat;
-
- if (arg->name[0] == c
- && arg->length == id_len
- && strncmp (arg->name, id_beg, id_len) == 0) {
- if (expected_delimiter && CPP_OPTIONS (pfile)->warn_stringify) {
- if (CPP_TRADITIONAL (pfile)) {
- cpp_warning (pfile, "macro argument `%.*s' is stringified.",
- id_len, arg->name);
- } else {
- cpp_warning (pfile,
- "macro arg `%.*s' would be stringified with -traditional.",
- id_len, arg->name);
- }
- }
- /* If ANSI, don't actually substitute inside a string. */
- if (!CPP_TRADITIONAL (pfile) && expected_delimiter)
- break;
- /* 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;
- tpat->raw_after = 0;
- tpat->rest_args = arg->rest_args;
- tpat->stringify = (CPP_TRADITIONAL (pfile)
- ? expected_delimiter != '\0'
- : stringify == id_beg);
-
- 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 + 2 <= limit && p1[0] == '#' && p1[1] == '#')
- tpat->raw_after = 1;
- }
- lastp = exp_p; /* place to start copying from next time */
- skipped_arg = 1;
- break;
- }
- }
+ register struct arglist *arg;
+
+ for (arg = arglist; arg != NULL; arg = arg->next) {
+ struct reflist *tpat;
+
+ if (arg->name[0] == c
+ && arg->length == id_len
+ && strncmp (arg->name, id_beg, id_len) == 0) {
+ if (expected_delimiter && CPP_OPTIONS (pfile)->warn_stringify) {
+ if (CPP_TRADITIONAL (pfile)) {
+ cpp_warning (pfile, "macro argument `%.*s' is stringified.",
+ id_len, arg->name);
+ } else {
+ cpp_warning (pfile,
+ "macro arg `%.*s' would be stringified with -traditional.",
+ id_len, arg->name);
+ }
+ }
+ /* If ANSI, don't actually substitute inside a string. */
+ if (!CPP_TRADITIONAL (pfile) && expected_delimiter)
+ break;
+ /* make a pat node for this arg and append it to the end of
+ the pat list */
+ tpat = (struct reflist *) Safe_malloc (sizeof (struct reflist));
+ tpat->next = NULL;
+ tpat->raw_before = concat == id_beg;
+ tpat->raw_after = 0;
+ tpat->rest_args = arg->rest_args;
+ tpat->stringify = (CPP_TRADITIONAL (pfile)
+ ? expected_delimiter != '\0'
+ : stringify == id_beg);
+
+ 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 + 2 <= limit && p1[0] == '#' && p1[1] == '#')
+ tpat->raw_after = 1;
+ }
+ 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)
- cpp_error (pfile,
- "`#' operator should be followed by a macro argument name");
+ register U_CHAR *lim1 = p;
+ p = id_beg;
+ while (p != lim1)
+ *exp_p++ = *p++;
+ if (stringify == id_beg)
+ cpp_error (pfile,
+ "`#' operator should be followed by a macro argument name");
}
}
}
#if 0
/* This isn't worth the time it takes. */
/* give back excess storage */
- defn->expansion = (U_CHAR *) xrealloc (defn->expansion, defn->length + 1);
+ defn->expansion = (U_CHAR *) Safe_realloc(defn->expansion, defn->length + 1);
#endif
return defn;
}
/*
- * special extension string that can be added to the last macro argument to
+ * 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); }
+ * #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); {
+ * #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)
+#define REST_EXTENSION_LENGTH (sizeof (rest_extension) - 1)
-/* Create a DEFINITION node from a #define directive. Arguments are
+/* Create a DEFINITION node from a #define directive. Arguments are
as for do_define. */
static MACRODEF
create_definition (
cpp_reader *pfile,
int predefinition)
{
- U_CHAR *bp; /* temp ptr into input buffer */
- U_CHAR *symname; /* remember where symbol name starts */
- int sym_length; /* and how long it is */
+ 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 rest_args = 0;
long line, col;
char *file = CPP_BUFFER (pfile) ? CPP_BUFFER (pfile)->nominal_fname : "";
DEFINITION *defn;
- int arglengths = 0; /* Accumulate lengths of arg names
- plus number of args. */
+ int arglengths = 0; /* Accumulate lengths of arg names
+ plus number of args. */
MACRODEF mdef;
cpp_buf_line_and_col (CPP_BUFFER (pfile), &line, &col);
while (is_hor_space[*bp])
bp++;
- symname = bp; /* remember where it starts */
+ symname = bp; /* remember where it starts */
sym_length = check_macro_name (pfile, bp, "macro");
bp += sym_length;
struct arglist *arg_ptrs = NULL;
int argno = 0;
- bp++; /* skip '(' */
+ bp++; /* skip '(' */
SKIP_WHITE_SPACE (bp);
/* Loop over macro argument names. */
arg_ptrs = temp;
if (rest_args)
- cpp_pedwarn (pfile, "another parameter follows `%s'", rest_extension);
+ cpp_pedwarn (pfile, "another parameter follows `%s'", rest_extension);
if (!is_idstart[*bp])
- cpp_pedwarn (pfile, "invalid character in macro parameter name");
-
+ cpp_pedwarn (pfile, "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 > REST_EXTENSION_LENGTH &&
- strncmp (rest_extension, bp, REST_EXTENSION_LENGTH) == 0) {
- rest_args = 1;
- temp->rest_args = 1;
- break;
- }
+ bp++;
+ /* do we have a "special" rest-args extension here? */
+ if (limit - bp > REST_EXTENSION_LENGTH &&
+ strncmp (rest_extension, bp, REST_EXTENSION_LENGTH) == 0) {
+ rest_args = 1;
+ temp->rest_args = 1;
+ break;
+ }
}
temp->length = bp - temp->name;
if (rest_args == 1)
- bp += REST_EXTENSION_LENGTH;
+ bp += REST_EXTENSION_LENGTH;
arglengths += temp->length + 2;
SKIP_WHITE_SPACE (bp);
if (temp->length == 0 || (*bp != ',' && *bp != ')')) {
- cpp_error (pfile, "badly punctuated parameter list in `#define'");
- goto nope;
+ cpp_error (pfile, "badly punctuated parameter list in `#define'");
+ goto nope;
}
if (*bp == ',') {
- bp++;
- SKIP_WHITE_SPACE (bp);
+ bp++;
+ SKIP_WHITE_SPACE (bp);
}
if (bp >= limit) {
- cpp_error (pfile, "unterminated parameter list in `#define'");
- goto nope;
+ cpp_error (pfile, "unterminated parameter list in `#define'");
+ goto nope;
}
{
- struct arglist *otemp;
-
- for (otemp = temp->next; otemp != NULL; otemp = otemp->next)
- if (temp->length == otemp->length &&
- strncmp (temp->name, otemp->name, temp->length) == 0) {
- U_CHAR *name;
-
- name = (U_CHAR *) alloca (temp->length + 1);
- (void) strncpy (name, temp->name, temp->length);
- name[temp->length] = '\0';
- cpp_error (pfile,
- "duplicate argument name `%s' in `#define'", name);
- goto nope;
- }
+ struct arglist *otemp;
+
+ for (otemp = temp->next; otemp != NULL; otemp = otemp->next)
+ if (temp->length == otemp->length &&
+ strncmp (temp->name, otemp->name, temp->length) == 0) {
+ U_CHAR *name;
+
+ name = (U_CHAR *) alloca (temp->length + 1);
+ (void) strncpy (name, temp->name, temp->length);
+ name[temp->length] = '\0';
+ cpp_error (pfile,
+ "duplicate argument name `%s' in `#define'", name);
+ goto nope;
+ }
}
}
- ++bp; /* skip paren */
+ ++bp; /* skip paren */
SKIP_WHITE_SPACE (bp);
/* now everything from bp before limit is the definition. */
defn = collect_expansion (pfile, bp, limit, argno, arg_ptrs);
/* 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);
+ defn->args.argnames = (U_CHAR *) Safe_malloc (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++] = ' ';
- }
+ 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;
}
if (bp < limit)
{
- if (is_hor_space[*bp]) {
- bp++;
- SKIP_WHITE_SPACE (bp);
- } else {
- 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 '~':
- cpp_warning (pfile, "missing white space after `#define %.*s'",
- sym_length, symname);
- break;
-
- default:
- cpp_pedwarn (pfile, "missing white space after `#define %.*s'",
- sym_length, symname);
- break;
- }
- }
+ if (is_hor_space[*bp]) {
+ bp++;
+ SKIP_WHITE_SPACE (bp);
+ } else {
+ 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 '~':
+ cpp_warning (pfile, "missing white space after `#define %.*s'",
+ sym_length, symname);
+ break;
+
+ default:
+ cpp_pedwarn (pfile, "missing white space after `#define %.*s'",
+ sym_length, symname);
+ break;
+ }
+ }
}
/* now everything from bp before limit is the definition. */
- defn = collect_expansion (pfile, bp, limit, -1, NULL_PTR);
+ defn = collect_expansion (pfile, bp, limit, -1,(struct arglist *) NULL_PTR);
defn->args.argnames = (U_CHAR *) "";
}
if (sym_length == 0)
cpp_error (pfile, "invalid %s name", usage);
else if (!is_idstart[*symname]) {
- U_CHAR *msg; /* what pain... */
+ U_CHAR *msg; /* what pain... */
msg = (U_CHAR *) alloca (sym_length + 1);
bcopy (symname, msg, sym_length);
msg[sym_length] = 0;
for (a1 = d1->pattern, a2 = d2->pattern; a1 && a2;
a1 = a1->next, a2 = a2->next) {
if (!((a1->nchars == a2->nchars && ! strncmp (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)
+ || ! 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;
if (a1 != a2)
return 1;
if (comp_def_part (first, p1, d1->length - (p1 - d1->expansion),
- p2, d2->length - (p2 - d2->expansion), 1))
+ p2, d2->length - (p2 - d2->expansion), 1))
return 1;
return 0;
}
int ok = 0;
/* Redefining a precompiled key is ok. */
if (hp->type == T_PCSTRING)
- ok = 1;
+ 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);
+ ok = ! compare_defs (mdef.defn, hp->value.defn);
/* Redefining a constant is ok with -D. */
else if (hp->type == T_CONST)
ok = ! CPP_OPTIONS (pfile)->done_initializing;
/* Print the warning if it's not ok. */
if (!ok)
- {
- U_CHAR *msg; /* what pain... */
-
- /* If we are passing through #define and #undef directives, do
- that for this re-definition now. */
- if (CPP_OPTIONS (pfile)->debug_output && keyword)
- pass_thru_directive (buf, limit, pfile, keyword);
-
- msg = (U_CHAR *) alloca (mdef.symlen + 22);
- *msg = '`';
- bcopy (mdef.symnam, msg + 1, mdef.symlen);
- strcpy ((char *) (msg + mdef.symlen + 1), "' redefined");
- cpp_pedwarn (pfile, msg);
- if (hp->type == T_MACRO)
- cpp_pedwarn_with_file_and_line (pfile, hp->value.defn->file, hp->value.defn->line,
- "this is the location of the previous definition");
- }
+ {
+ U_CHAR *msg; /* what pain... */
+
+ /* If we are passing through #define and #undef directives, do
+ that for this re-definition now. */
+ if (CPP_OPTIONS (pfile)->debug_output && keyword)
+ pass_thru_directive (buf, limit, pfile, keyword);
+
+ msg = (U_CHAR *) alloca (mdef.symlen + 22);
+ *msg = '`';
+ bcopy (mdef.symnam, msg + 1, mdef.symlen);
+ strcpy ((char *) (msg + mdef.symlen + 1), "' redefined");
+ cpp_pedwarn (pfile, msg);
+ if (hp->type == T_MACRO)
+ cpp_pedwarn_with_file_and_line (pfile, hp->value.defn->file, 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. */
+ that for this new definition now. */
if (CPP_OPTIONS (pfile)->debug_output && keyword)
- pass_thru_directive (buf, limit, pfile, keyword);
+ pass_thru_directive (buf, limit, pfile, keyword);
install (mdef.symnam, mdef.symlen, T_MACRO, 0,
- (char *) mdef.defn, hashcode);
+ (char *) mdef.defn, hashcode);
}
return 0;
`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,
+ into the macro. If the actual use count exceeds 10,
the value stored is 10. */
/* raw and expanded are relative to ARG_BASE */
bzero ((char *) buf, sizeof (cpp_buffer));
CPP_BUFFER (pfile) = buf;
#else
- register cpp_buffer *buf = (cpp_buffer*) xmalloc (sizeof(cpp_buffer));
+ register cpp_buffer *buf = (cpp_buffer*) Safe_malloc (sizeof(cpp_buffer));
bzero ((char *) buf, sizeof (cpp_buffer));
CPP_PREV_BUFFER (buf) = CPP_BUFFER (pfile);
CPP_BUFFER (pfile) = buf;
buf->underflow = null_underflow;
buf->buf = buf->cur = buffer;
buf->alimit = buf->rlimit = buffer + length;
-
+
return buf;
}
cpp_buffer *next_buf = CPP_PREV_BUFFER (buf);
(*buf->cleanup) (buf, pfile);
CPP_BUFFER (pfile) = next_buf;
- free (buf);
+ Safe_free (buf);
return next_buf;
#endif
}
{
enum cpp_token token = cpp_get_token (pfile);
if (token == CPP_EOF) /* Should not happen ... */
- break;
+ break;
if (token == CPP_POP && CPP_BUFFER (pfile) == buffer)
- {
- cpp_pop_buffer (pfile);
- break;
- }
+ {
+ cpp_pop_buffer (pfile);
+ break;
+ }
}
}
int length)
{
register cpp_buffer *ip;
- cpp_buffer obuf;
U_CHAR *limit = buf + length;
U_CHAR *buf1;
#if 0
+ cpp_buffer obuf;
int odepth = indepth;
#endif
{
U_CHAR ch = *buf++;
if (ch == '\n')
- (*linep)++, (*colp) = 1;
+ (*linep)++, (*colp) = 1;
else
- (*colp)++;
+ (*colp)++;
}
}
for (mark = pbuf->marks; mark != NULL; mark = mark->next)
{
if (pbuf->buf + mark->position < new_pos)
- new_pos = pbuf->buf + mark->position;
+ new_pos = pbuf->buf + mark->position;
}
pbuf->line_base += new_pos - old_pos;
adjust_position (old_pos, new_pos, &pbuf->lineno, &pbuf->colno);
{
U_CHAR ch = *buf++;
if (ch == '\n')
- count++;
+ count++;
}
return count;
}
int conditional,
enum file_change_code file_change)
{
- int len;
- char *line_cmd_buf, *line_end;
+/* int len;*/
+/* char *line_cmd_buf, *line_end;*/
long line, col;
cpp_buffer *ip = CPP_BUFFER (pfile);
if (line > pfile->lineno && line < pfile->lineno + 8) {
CPP_RESERVE (pfile, 20);
while (line > pfile->lineno) {
- CPP_PUTC_Q (pfile, '\n');
- pfile->lineno++;
+ CPP_PUTC_Q (pfile, '\n');
+ pfile->lineno++;
}
return;
}
CPP_PUTS_Q (pfile, sharp_line, sizeof(sharp_line)-1);
}
- sprintf (CPP_PWRITTEN (pfile), "%d ", line+2);
+ sprintf (CPP_PWRITTEN (pfile), "%ld ", line+2);
CPP_ADJUST_WRITTEN (pfile, strlen (CPP_PWRITTEN (pfile)));
// modification for SDC51
if (*ip->nominal_fname == '\0')
- quote_string (pfile,"standard input");
+ quote_string (pfile,"standard input");
else
- quote_string (pfile, ip->nominal_fname);
+ quote_string (pfile, ip->nominal_fname);
if (file_change != same_file) {
CPP_PUTC_Q (pfile, ' ');
CPP_PUTC_Q (pfile, file_change == enter_file ? '1' : '2');
int rest_args)
{
int paren = 0;
- enum cpp_token token;
- long arg_start = CPP_WRITTEN (pfile);
+ enum cpp_token token = CPP_EOF;
+ /* long arg_start = CPP_WRITTEN (pfile); */
char save_put_out_comments = CPP_OPTIONS (pfile)->put_out_comments;
CPP_OPTIONS (pfile)->put_out_comments = 0;
{
token = cpp_get_token (pfile);
switch (token)
- {
- case CPP_EOF:
- goto done;
- case CPP_POP:
- /* If we've hit end of file, it's an error (reported by caller).
- Ditto if it's the end of cpp_expand_to_buffer text.
- If we've hit end of macro, just continue. */
- if (! CPP_IS_MACRO_BUFFER (CPP_BUFFER (pfile)))
- goto done;
- break;
- case CPP_LPAREN:
- paren++;
- break;
- case CPP_RPAREN:
- if (--paren < 0)
- goto found;
- break;
- case CPP_COMMA:
- /* if we've returned to lowest level and
- we aren't absorbing all args */
- if (paren == 0 && rest_args == 0)
- goto found;
- break;
- found:
- /* Remove ',' or ')' from argument buffer. */
- CPP_ADJUST_WRITTEN (pfile, -1);
- goto done;
+ {
+ case CPP_EOF:
+ goto done;
+ case CPP_POP:
+ /* If we've hit end of file, it's an error (reported by caller).
+ Ditto if it's the end of cpp_expand_to_buffer text.
+ If we've hit end of macro, just continue. */
+ if (! CPP_IS_MACRO_BUFFER (CPP_BUFFER (pfile)))
+ goto done;
+ break;
+ case CPP_LPAREN:
+ paren++;
+ break;
+ case CPP_RPAREN:
+ if (--paren < 0)
+ goto found;
+ break;
+ case CPP_COMMA:
+ /* if we've returned to lowest level and
+ we aren't absorbing all args */
+ if (paren == 0 && rest_args == 0)
+ goto found;
+ break;
+ found:
+ /* Remove ',' or ')' from argument buffer. */
+ CPP_ADJUST_WRITTEN (pfile, -1);
+ goto done;
default: ;
- }
+ }
}
done:
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;
- if (c == '\n' && quotec == '\'')
- break;
- }
+ int quotec = c;
+ while (ibp < limit) {
+ *obp++ = c = *ibp++;
+ if (c == quotec)
+ break;
+ if (c == '\n' && quotec == '\'')
+ break;
+ }
}
break;
}
}
static char *monthnames[] = {"Jan", "Feb", "Mar", "Apr", "May", "Jun",
- "Jul", "Aug", "Sep", "Oct", "Nov", "Dec",
- };
+ "Jul", "Aug", "Sep", "Oct", "Nov", "Dec",
+ };
/*
* expand things like __FILE__. Place the expansion into the output
cpp_reader *pfile)
{
char *buf;
- int i, len;
+ int /* i, */ len;
int true_indepth;
cpp_buffer *ip = NULL;
struct tm *timebuf;
- int paren = 0; /* For special `defined' keyword */
+ int paren = 0; /* For special `defined' keyword */
#if 0
if (pcp_outfile && pcp_inside_if
&& hp->type != T_SPEC_DEFINED && hp->type != T_CONST)
cpp_error (pfile,
- "Predefined macro `%s' used inside `#if' during precompilation",
- hp->name);
+ "Predefined macro `%s' used inside `#if' during precompilation",
+ hp->name);
#endif
-
+
for (ip = CPP_BUFFER (pfile); ; ip = CPP_PREV_BUFFER (ip))
{
if (ip == NULL)
- {
- cpp_error (pfile, "cccp error: not in any file?!");
- return; /* the show must go on */
- }
+ {
+ cpp_error (pfile, "cccp error: not in any file?!");
+ return; /* the show must go on */
+ }
if (ip->fname != NULL)
- break;
+ break;
}
switch (hp->type)
case T_FILE:
case T_BASE_FILE:
{
- char *string;
- if (hp->type == T_BASE_FILE)
- {
- while (CPP_PREV_BUFFER (ip))
- ip = CPP_PREV_BUFFER (ip);
- }
- string = ip->nominal_fname;
-
- if (!string)
- string = "";
- CPP_RESERVE (pfile, 3 + 4 * strlen (string));
- quote_string (pfile, string);
- return;
+ char *string;
+ if (hp->type == T_BASE_FILE)
+ {
+ while (CPP_PREV_BUFFER (ip))
+ ip = CPP_PREV_BUFFER (ip);
+ }
+ string = ip->nominal_fname;
+
+ if (!string)
+ string = "";
+ CPP_RESERVE (pfile, 3 + 4 * strlen (string));
+ quote_string (pfile, string);
+ return;
}
case T_INCLUDE_LEVEL:
true_indepth = 0;
for (ip = CPP_BUFFER (pfile); ip != NULL; ip = CPP_PREV_BUFFER (ip))
- if (ip->fname != NULL)
- true_indepth++;
+ if (ip->fname != NULL)
+ true_indepth++;
buf = (char *) alloca (8); /* Eight bytes ought to be more than enough */
sprintf (buf, "%d", true_indepth - 1);
sprintf (buf, "%d", hp->value.ival);
#if 0
if (pcp_inside_if && pcp_outfile)
- /* Output a precondition for this macro use */
- fprintf (pcp_outfile, "#define %s %d\n", hp->name, hp->value.ival);
+ /* Output a precondition for this macro use */
+ fprintf (pcp_outfile, "#define %s %d\n", hp->name, hp->value.ival);
#endif
break;
case T_SPECLINE:
{
- long line = ip->lineno;
- long col = ip->colno;
- adjust_position (CPP_LINE_BASE (ip), ip->cur, &line, &col);
+ long line = ip->lineno;
+ long col = ip->colno;
+ adjust_position (CPP_LINE_BASE (ip), ip->cur, &line, &col);
- buf = (char *) alloca (10);
- sprintf (buf, "%d", line);
+ buf = (char *) alloca (10);
+ sprintf (buf, "%ld", line);
}
break;
buf = (char *) alloca (20);
timebuf = timestamp (pfile);
if (hp->type == T_DATE)
- sprintf (buf, "\"%s %2d %4d\"", monthnames[timebuf->tm_mon],
- timebuf->tm_mday, timebuf->tm_year + 1900);
+ 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);
+ 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 */
+ buf = " 0 "; /* Assume symbol is not defined */
ip = CPP_BUFFER (pfile);
SKIP_WHITE_SPACE (ip->cur);
if (*ip->cur == '(')
- {
- paren++;
- ip->cur++; /* Skip over the paren */
- SKIP_WHITE_SPACE (ip->cur);
- }
+ {
+ paren++;
+ ip->cur++; /* Skip over the paren */
+ SKIP_WHITE_SPACE (ip->cur);
+ }
if (!is_idstart[*ip->cur])
- goto oops;
- if (hp = cpp_lookup (pfile, ip->cur, -1, -1))
- {
+ goto oops;
+ if ((hp = cpp_lookup (pfile, ip->cur, -1, -1)) != 0)
+ {
#if 0
- 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);
+ 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);
#endif
- buf = " 1 ";
- }
+ buf = " 1 ";
+ }
#if 0
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);
- }
+ 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);
+ }
#endif
while (is_idchar[*ip->cur])
- ++ip->cur;
+ ++ip->cur;
SKIP_WHITE_SPACE (ip->cur);
if (paren)
- {
- if (*ip->cur != ')')
- goto oops;
- ++ip->cur;
- }
+ {
+ if (*ip->cur != ')')
+ goto oops;
+ ++ip->cur;
+ }
break;
oops:
cpp_buffer *pbuffer = CPP_BUFFER (pfile);
while (CPP_PREV_BUFFER (pbuffer))
- pbuffer = CPP_PREV_BUFFER (pbuffer);
+ pbuffer = CPP_PREV_BUFFER (pbuffer);
sprintf (directive, " __BASE_FILE__ \"%s\"\n",
- pbuffer->nominal_fname);
+ pbuffer->nominal_fname);
output_line_command (pfile, 0, same_file);
pass_thru_directive (directive, &directive[strlen (directive)], pfile, dp);
pass_thru_directive (directive, &directive[strlen (directive)], pfile, dp);
sprintf (directive, " __DATE__ \"%s %2d %4d\"\n",
- monthnames[timebuf->tm_mon],
- timebuf->tm_mday, timebuf->tm_year + 1900);
+ monthnames[timebuf->tm_mon],
+ timebuf->tm_mday, timebuf->tm_year + 1900);
output_line_command (pfile, 0, same_file);
pass_thru_directive (directive, &directive[strlen (directive)], pfile, dp);
sprintf (directive, " __TIME__ \"%02d:%02d:%02d\"\n",
- timebuf->tm_hour, timebuf->tm_min, timebuf->tm_sec);
+ timebuf->tm_hour, timebuf->tm_min, timebuf->tm_sec);
output_line_command (pfile, 0, same_file);
pass_thru_directive (directive, &directive[strlen (directive)], pfile, dp);
if (!CPP_TRADITIONAL (pfile))
- {
+ {
sprintf (directive, " __STDC__ 1");
output_line_command (pfile, 0, same_file);
pass_thru_directive (directive, &directive[strlen (directive)],
- pfile, dp);
- }
+ pfile, dp);
+ }
if (CPP_OPTIONS (pfile)->objc)
- {
+ {
sprintf (directive, " __OBJC__ 1");
output_line_command (pfile, 0, same_file);
pass_thru_directive (directive, &directive[strlen (directive)],
- pfile, dp);
- }
+ pfile, dp);
+ }
}
}
\f
{
case '+': case '-':
if (c2 == c1 || c2 == '=')
- return 1;
+ return 1;
goto letter;
case '.':
case '0': case '1': case '2': case '3': case '4':
case '5': case '6': case '7': case '8': case '9':
case 'e': case 'E':
if (c2 == '-' || c2 == '+')
- return 1; /* could extend a pre-processing number */
+ return 1; /* could extend a pre-processing number */
goto letter;
case 'L':
if (c2 == '\'' || c2 == '\"')
- return 1; /* Could turn into L"xxx" or L'xxx'. */
+ return 1; /* Could turn into L"xxx" or L'xxx'. */
goto letter;
letter:
case '_':
if (nargs >= 0)
{
- enum cpp_token token;
+ enum cpp_token token = CPP_EOF;
args = (struct argdata *) alloca ((nargs + 1) * sizeof (struct argdata));
for (i = 0; i < nargs; i++)
- {
- args[i].raw = args[i].expanded = 0;
- args[i].raw_length = 0;
- args[i].expand_length = args[i].stringified_length = -1;
- args[i].use_count = 0;
- }
+ {
+ args[i].raw = args[i].expanded = 0;
+ args[i].raw_length = 0;
+ args[i].expand_length = args[i].stringified_length = -1;
+ 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. */
+ 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;
rest_args = 0;
FORWARD(1); /* Discard the open-parenthesis before the first arg. */
do
- {
- 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;
- args[i].raw = CPP_WRITTEN (pfile);
- token = macarg (pfile, rest_args);
- args[i].raw_length = CPP_WRITTEN (pfile) - args[i].raw;
- args[i].newlines = 0; /* FIXME */
- }
- else
- token = macarg (pfile, 0);
- if (token == CPP_EOF || token == CPP_POP)
- {
- cpp_error_with_line (pfile, start_line, start_column,
- "unterminated macro call");
- return;
- }
- i++;
- } while (token == CPP_COMMA);
+ {
+ 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;
+ args[i].raw = CPP_WRITTEN (pfile);
+ token = macarg (pfile, rest_args);
+ args[i].raw_length = CPP_WRITTEN (pfile) - args[i].raw;
+ args[i].newlines = 0; /* FIXME */
+ }
+ else
+ token = macarg (pfile, 0);
+ if (token == CPP_EOF || token == CPP_POP)
+ {
+ cpp_error_with_line (pfile, start_line, start_column,
+ "unterminated macro call");
+ return;
+ }
+ i++;
+ } while (token == CPP_COMMA);
/* If we got one arg but it was just whitespace, call that 0 args. */
if (i == 1)
- {
- register U_CHAR *bp = ARG_BASE + 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;
- }
+ {
+ register U_CHAR *bp = ARG_BASE + 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. */
+ a parse error above. */
rest_zero = 0;
if (nargs == 0 && i > 0)
- {
- cpp_error (pfile, "arguments given to macro `%s'", hp->name);
- }
+ {
+ cpp_error (pfile, "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 && CPP_TRADITIONAL (pfile))
- ;
- /* the rest args token is allowed to absorb 0 tokens */
- else if (i == nargs - 1 && defn->rest_args)
- rest_zero = 1;
- else if (i == 0)
- cpp_error (pfile, "macro `%s' used without args", hp->name);
- else if (i == 1)
- cpp_error (pfile, "macro `%s' used with just one arg", hp->name);
- else
- cpp_error (pfile, "macro `%s' used with only %d args",
- hp->name, i);
+ {
+ /* traditional C allows foo() if foo wants one argument. */
+ if (nargs == 1 && i == 0 && CPP_TRADITIONAL (pfile))
+ ;
+ /* the rest args token is allowed to absorb 0 tokens */
+ else if (i == nargs - 1 && defn->rest_args)
+ rest_zero = 1;
+ else if (i == 0)
+ cpp_error (pfile, "macro `%s' used without args", hp->name);
+ else if (i == 1)
+ cpp_error (pfile, "macro `%s' used with just one arg", hp->name);
+ else
+ cpp_error (pfile, "macro `%s' used with only %d args",
+ hp->name, i);
}
else if (i > nargs)
- {
- cpp_error (pfile,
- "macro `%s' used with too many (%d) args", hp->name, i);
- }
+ {
+ cpp_error (pfile,
+ "macro `%s' used with too many (%d) args", hp->name, i);
+ }
}
/* If macro wants zero args, we parsed the arglist for checking only.
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 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. */
+ 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)
- {
- register struct argdata *arg = &args[ap->argno];
- /* Stringify it it hasn't already been */
- if (arg->stringified_length < 0)
- {
- int arglen = arg->raw_length;
- int escaped = 0;
- int in_string = 0;
- int c;
- /* Initially need_space is -1. Otherwise, 1 means the
- previous character was a space, but we suppressed it;
- 0 means the previous character was a non-space. */
- int need_space = -1;
- i = 0;
- arg->stringified = CPP_WRITTEN (pfile);
- if (!CPP_TRADITIONAL (pfile))
- CPP_PUTC (pfile, '\"'); /* insert beginning quote */
- for (; i < arglen; i++)
- {
- c = (ARG_BASE + arg->raw)[i];
-
- if (! in_string)
- {
- /* Internal sequences of whitespace are replaced by
- one space except within an string or char token.*/
- if (is_space[c])
- {
- if (CPP_WRITTEN (pfile) > arg->stringified
- && (CPP_PWRITTEN (pfile))[-1] == '@')
- {
- /* "@ " escape markers are removed */
- CPP_ADJUST_WRITTEN (pfile, -1);
- continue;
- }
- if (need_space == 0)
- need_space = 1;
- continue;
- }
- else if (need_space > 0)
- CPP_PUTC (pfile, ' ');
- need_space = 0;
- }
-
- if (escaped)
- escaped = 0;
- else
- {
- if (c == '\\')
- escaped = 1;
- if (in_string)
- {
- if (c == in_string)
- in_string = 0;
- }
- else if (c == '\"' || c == '\'')
- in_string = c;
- }
-
- /* Escape these chars */
- if (c == '\"' || (in_string && c == '\\'))
- CPP_PUTC (pfile, '\\');
- if (isprint (c))
- CPP_PUTC (pfile, c);
- else
- {
- CPP_RESERVE (pfile, 4);
- sprintf (CPP_PWRITTEN (pfile), "\\%03o",
- (unsigned int) c);
- CPP_ADJUST_WRITTEN (pfile, 4);
- }
- }
- if (!CPP_TRADITIONAL (pfile))
- CPP_PUTC (pfile, '\"'); /* insert ending quote */
- arg->stringified_length
- = CPP_WRITTEN (pfile) - arg->stringified;
- }
- xbuf_len += args[ap->argno].stringified_length;
- }
- else if (ap->raw_before || ap->raw_after || CPP_TRADITIONAL (pfile))
- /* 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].expand_length < 0)
- {
- args[ap->argno].expanded = CPP_WRITTEN (pfile);
- cpp_expand_to_buffer (pfile,
- ARG_BASE + args[ap->argno].raw,
- args[ap->argno].raw_length);
-
- args[ap->argno].expand_length
- = CPP_WRITTEN (pfile) - args[ap->argno].expanded;
- }
-
- /* 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);
+ {
+ if (ap->stringify)
+ {
+ register struct argdata *arg = &args[ap->argno];
+ /* Stringify it it hasn't already been */
+ if (arg->stringified_length < 0)
+ {
+ int arglen = arg->raw_length;
+ int escaped = 0;
+ int in_string = 0;
+ int c;
+ /* Initially need_space is -1. Otherwise, 1 means the
+ previous character was a space, but we suppressed it;
+ 0 means the previous character was a non-space. */
+ int need_space = -1;
+ i = 0;
+ arg->stringified = CPP_WRITTEN (pfile);
+ if (!CPP_TRADITIONAL (pfile))
+ CPP_PUTC (pfile, '\"'); /* insert beginning quote */
+ for (; i < arglen; i++)
+ {
+ c = (ARG_BASE + arg->raw)[i];
+
+ if (! in_string)
+ {
+ /* Internal sequences of whitespace are replaced by
+ one space except within an string or char token.*/
+ if (is_space[c])
+ {
+ if (CPP_WRITTEN (pfile) > arg->stringified
+ && (CPP_PWRITTEN (pfile))[-1] == '@')
+ {
+ /* "@ " escape markers are removed */
+ CPP_ADJUST_WRITTEN (pfile, -1);
+ continue;
+ }
+ if (need_space == 0)
+ need_space = 1;
+ continue;
+ }
+ else if (need_space > 0)
+ CPP_PUTC (pfile, ' ');
+ need_space = 0;
+ }
+
+ if (escaped)
+ escaped = 0;
+ else
+ {
+ if (c == '\\')
+ escaped = 1;
+ if (in_string)
+ {
+ if (c == in_string)
+ in_string = 0;
+ }
+ else if (c == '\"' || c == '\'')
+ in_string = c;
+ }
+
+ /* Escape these chars */
+ if (c == '\"' || (in_string && c == '\\'))
+ CPP_PUTC (pfile, '\\');
+ if (isprint (c))
+ CPP_PUTC (pfile, c);
+ else
+ {
+ CPP_RESERVE (pfile, 4);
+ sprintf (CPP_PWRITTEN (pfile), "\\%03o",
+ (unsigned int) c);
+ CPP_ADJUST_WRITTEN (pfile, 4);
+ }
+ }
+ if (!CPP_TRADITIONAL (pfile))
+ CPP_PUTC (pfile, '\"'); /* insert ending quote */
+ arg->stringified_length
+ = CPP_WRITTEN (pfile) - arg->stringified;
+ }
+ xbuf_len += args[ap->argno].stringified_length;
+ }
+ else if (ap->raw_before || ap->raw_after || CPP_TRADITIONAL (pfile))
+ /* 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].expand_length < 0)
+ {
+ args[ap->argno].expanded = CPP_WRITTEN (pfile);
+ cpp_expand_to_buffer (pfile,
+ ARG_BASE + args[ap->argno].raw,
+ args[ap->argno].raw_length);
+
+ args[ap->argno].expand_length
+ = CPP_WRITTEN (pfile) - args[ap->argno].expanded;
+ }
+
+ /* 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 *) Safe_malloc (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. */
+ 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)
- || (last_ap != NULL && last_ap->rest_args
- && last_ap->raw_after)))
- {
- /* 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)
- {
- bcopy (ARG_BASE + arg->stringified,
- xbuf + totlen, arg->stringified_length);
- totlen += arg->stringified_length;
- }
- else if (ap->raw_before || ap->raw_after || CPP_TRADITIONAL (pfile))
- {
- U_CHAR *p1 = ARG_BASE + arg->raw;
- U_CHAR *l1 = p1 + arg->raw_length;
- if (ap->raw_before)
- {
- while (p1 != l1 && is_space[*p1]) p1++;
- while (p1 != l1 && is_idchar[*p1])
- xbuf[totlen++] = *p1++;
- }
- if (ap->raw_after)
- {
- /* 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 (p1, xbuf + totlen, l1 - p1);
- totlen += l1 - p1;
- }
- else
- {
- U_CHAR *expanded = ARG_BASE + arg->expanded;
- if (!ap->raw_before && totlen > 0 && arg->expand_length
- && !CPP_TRADITIONAL(pfile)
- && unsafe_chars (xbuf[totlen-1], expanded[0]))
- {
- xbuf[totlen++] = '@';
- xbuf[totlen++] = ' ';
- }
-
- bcopy (expanded, xbuf + totlen, arg->expand_length);
- totlen += arg->expand_length;
-
- if (!ap->raw_after && totlen > 0 && offset < defn->length
- && !CPP_TRADITIONAL(pfile)
- && unsafe_chars (xbuf[totlen-1], exp[offset]))
- {
- xbuf[totlen++] = '@';
- 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 (expanded, arg->expand_length);
- }
- }
-
- if (totlen > xbuf_len)
- abort ();
+ 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)
+ || (last_ap != NULL && last_ap->rest_args
+ && last_ap->raw_after)))
+ {
+ /* 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)
+ {
+ bcopy (ARG_BASE + arg->stringified,
+ xbuf + totlen, arg->stringified_length);
+ totlen += arg->stringified_length;
+ }
+ else if (ap->raw_before || ap->raw_after || CPP_TRADITIONAL (pfile))
+ {
+ U_CHAR *p1 = ARG_BASE + arg->raw;
+ U_CHAR *l1 = p1 + arg->raw_length;
+ if (ap->raw_before)
+ {
+ while (p1 != l1 && is_space[*p1]) p1++;
+ while (p1 != l1 && is_idchar[*p1])
+ xbuf[totlen++] = *p1++;
+ }
+ if (ap->raw_after)
+ {
+ /* 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 (p1, xbuf + totlen, l1 - p1);
+ totlen += l1 - p1;
+ }
+ else
+ {
+ U_CHAR *expanded = ARG_BASE + arg->expanded;
+ if (!ap->raw_before && totlen > 0 && arg->expand_length
+ && !CPP_TRADITIONAL(pfile)
+ && unsafe_chars (xbuf[totlen-1], expanded[0]))
+ {
+ xbuf[totlen++] = '@';
+ xbuf[totlen++] = ' ';
+ }
+
+ bcopy (expanded, xbuf + totlen, arg->expand_length);
+ totlen += arg->expand_length;
+
+ if (!ap->raw_after && totlen > 0 && offset < defn->length
+ && !CPP_TRADITIONAL(pfile)
+ && unsafe_chars (xbuf[totlen-1], exp[offset]))
+ {
+ xbuf[totlen++] = '@';
+ 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 (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. */
+ 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))
- xbuf[totlen++] = exp[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))
+ xbuf[totlen++] = exp[i];
+ }
xbuf[totlen] = 0;
xbuf_len = totlen;
/* Pop the space we've used in the token_buffer for argument expansion. */
CPP_SET_WRITTEN (pfile, old_written);
-
+
/* Recursive macro use sometimes works traditionally.
#define foo(x,y) bar (x (y,0), y)
foo (foo, baz) */
-
+
if (!CPP_TRADITIONAL (pfile))
hp->type = T_DISABLED;
}
if (xbuf[0] == '@' && xbuf[1] == ' '
&& (is_idchar[xbuf[2]] || xbuf[2] == '(' || xbuf[2] == '\''
- || xbuf[2] == '\"'))
+ || xbuf[2] == '\"'))
mbuf->cur += 2;
}
\f
enum cpp_token token;
cpp_skip_hspace (pfile);
if (PEEKC () == '\n')
- return CPP_VSPACE;
+ return CPP_VSPACE;
token = cpp_get_token (pfile);
switch (token)
{
case CPP_POP:
- if (! CPP_IS_MACRO_BUFFER (CPP_BUFFER (pfile)))
- return token;
- /* ... else fall though ... */
+ if (! CPP_IS_MACRO_BUFFER (CPP_BUFFER (pfile)))
+ return token;
+ /* ... else fall though ... */
case CPP_HSPACE: case CPP_COMMENT:
- CPP_SET_WRITTEN (pfile, old_written);
- break;
+ CPP_SET_WRITTEN (pfile, old_written);
+ break;
default:
- return token;
+ return token;
}
}
}
{
int importing = (keyword->type == T_IMPORT);
int skip_dirs = (keyword->type == T_INCLUDE_NEXT);
- char *fname; /* Dynamically allocated fname buffer */
+ char *fname; /* Dynamically allocated fname buffer */
char *pcftry;
- char *pcfname;
- U_CHAR *fbeg, *fend; /* Beginning and end of fname */
+/* char *pcfname;*/
+ U_CHAR *fbeg, *fend; /* Beginning and end of fname */
enum cpp_token token;
/* Chain of dirs to search */
struct file_name_list *search_start = CPP_OPTIONS (pfile)->include;
- struct file_name_list dsp[1]; /* First in chain, if #include "..." */
+ struct file_name_list dsp[1]; /* First in chain, if #include "..." */
struct file_name_list *searchptr = 0;
long old_written = CPP_WRITTEN (pfile);
int flen;
- int f; /* file number */
+ int f; /* file number */
- int retried = 0; /* Have already tried macro
- expanding the include line*/
- int angle_brackets = 0; /* 0 for "...", 1 for <...> */
- int pcf = -1;
+ int angle_brackets = 0; /* 0 for "...", 1 for <...> */
+ /* int pcf = -1; */
char *pcfbuf;
- char *pcfbuflimit;
+/* char *pcfbuflimit;*/
int pcfnum;
- f= -1; /* JF we iz paranoid! */
+ f= -1; /* JF we iz paranoid! */
if (importing && CPP_OPTIONS (pfile)->warn_import
&& !CPP_OPTIONS (pfile)->inhibit_warnings
fbeg = pfile->token_buffer + old_written + 1;
fend = CPP_PWRITTEN (pfile) - 1;
if (fbeg[-1] == '<')
- {
- angle_brackets = 1;
- /* If -I-, start with the first -I dir after the -I-. */
- if (CPP_OPTIONS (pfile)->first_bracket_include)
- search_start = CPP_OPTIONS (pfile)->first_bracket_include;
- }
+ {
+ angle_brackets = 1;
+ /* If -I-, start with the first -I dir after the -I-. */
+ if (CPP_OPTIONS (pfile)->first_bracket_include)
+ search_start = CPP_OPTIONS (pfile)->first_bracket_include;
+ }
/* If -I- was specified, don't search current dir, only spec'd ones. */
else if (! CPP_OPTIONS (pfile)->ignore_srcdir)
- {
- cpp_buffer *fp;
- /* We have "filename". Figure out directory this source
- file is coming from and put it on the front of the list. */
-
- for (fp = CPP_BUFFER (pfile); fp != NULL; fp = CPP_PREV_BUFFER (fp))
- {
- int n;
- char *ep,*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[0].next = search_start;
- search_start = dsp;
+ {
+ cpp_buffer *fp;
+ /* We have "filename". Figure out directory this source
+ file is coming from and put it on the front of the list. */
+
+ for (fp = CPP_BUFFER (pfile); fp != NULL; fp = CPP_PREV_BUFFER (fp))
+ {
+ int n;
+ char *ep,*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[0].next = search_start;
+ search_start = dsp;
#ifndef VMS
- ep = rindex (nam, '/');
-#else /* VMS */
- ep = rindex (nam, ']');
- if (ep == NULL) ep = rindex (nam, '>');
- if (ep == NULL) ep = rindex (nam, ':');
- if (ep != NULL) ep++;
-#endif /* VMS */
- if (ep != NULL)
- {
- n = ep - nam;
- dsp[0].fname = (char *) alloca (n + 1);
- strncpy (dsp[0].fname, nam, n);
- dsp[0].fname[n] = '\0';
- if (n + INCLUDE_LEN_FUDGE > pfile->max_include_len)
- pfile->max_include_len = n + INCLUDE_LEN_FUDGE;
- }
- else
- {
- dsp[0].fname = 0; /* Current directory */
- }
- dsp[0].got_name_map = 0;
- break;
- }
- }
- }
+ ep = rindex (nam, '/');
+#else /* VMS */
+ ep = rindex (nam, ']');
+ if (ep == NULL) ep = rindex (nam, '>');
+ if (ep == NULL) ep = rindex (nam, ':');
+ if (ep != NULL) ep++;
+#endif /* VMS */
+ if (ep != NULL)
+ {
+ n = ep - nam;
+ dsp[0].fname = (char *) alloca (n + 1);
+ strncpy (dsp[0].fname, nam, n);
+ dsp[0].fname[n] = '\0';
+ if (n + INCLUDE_LEN_FUDGE > pfile->max_include_len)
+ pfile->max_include_len = n + INCLUDE_LEN_FUDGE;
+ }
+ else
+ {
+ dsp[0].fname = 0; /* Current directory */
+ }
+ dsp[0].got_name_map = 0;
+ break;
+ }
+ }
+ }
}
#ifdef VMS
else if (token == CPP_NAME)
* code from case '<' is repeated here) and generates a warning.
*/
cpp_warning (pfile,
- "VAX-C-style include specification found, use '#include <filename.h>' !");
+ "VAX-C-style include specification found, use '#include <filename.h>' !");
angle_brackets = 1;
/* If -I-, start with the first -I dir after the -I-. */
if (CPP_OPTIONS (pfile)->first_bracket_include)
- search_start = CPP_OPTIONS (pfile)->first_bracket_include;
+ search_start = CPP_OPTIONS (pfile)->first_bracket_include;
fbeg = pfile->token_buffer + old_written;
fend = CPP_PWRITTEN (pfile);
}
else
{
cpp_error (pfile,
- "`#%s' expects \"FILENAME\" or <FILENAME>", keyword->name);
+ "`#%s' expects \"FILENAME\" or <FILENAME>", keyword->name);
CPP_SET_WRITTEN (pfile, old_written);
skip_rest_of_line (pfile);
return 0;
{
cpp_error (pfile, "junk at end of `#include'");
while (token != CPP_VSPACE && token != CPP_EOF && token != CPP_POP)
- token = get_directive_token (pfile);
+ token = get_directive_token (pfile);
}
/* For #include_next, skip in the search path
{
cpp_buffer *fp;
for (fp = CPP_BUFFER (pfile); fp != NULL; fp = CPP_PREV_BUFFER (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 == SELF_DIR_DUMMY)
- search_start = CPP_OPTIONS (pfile)->include;
- else if (fp->dir)
- search_start = fp->dir->next;
- break;
- }
+ 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 == SELF_DIR_DUMMY)
+ search_start = CPP_OPTIONS (pfile)->include;
+ else if (fp->dir)
+ search_start = fp->dir->next;
+ break;
+ }
}
CPP_SET_WRITTEN (pfile, old_written);
/* Allocate this permanently, because it gets stored in the definitions
of macros. */
- fname = (char *) xmalloc (pfile->max_include_len + flen + 4);
+ fname = (char *) Safe_malloc (pfile->max_include_len + flen + 4);
/* + 2 above for slash and terminating null. */
/* + 2 added for '.h' on VMS (to support '#include filename') */
else
f = open_include_file (pfile, fname, NULL_PTR);
if (f == -2)
- return 0; /* Already included this file */
+ return 0; /* Already included this file */
} else {
/* Search directory path, trying to open the file.
Copy each filename tried into FNAME. */
for (searchptr = search_start; searchptr; searchptr = searchptr->next) {
if (searchptr->fname) {
- /* The empty string in a search path is ignored.
- This makes it possible to turn off entirely
- a standard piece of the list. */
- if (searchptr->fname[0] == 0)
- continue;
- strcpy (fname, searchptr->fname);
- strcat (fname, "/");
- fname[strlen (fname) + flen] = 0;
+ /* The empty string in a search path is ignored.
+ This makes it possible to turn off entirely
+ a standard piece of the list. */
+ if (searchptr->fname[0] == 0)
+ continue;
+ strcpy (fname, searchptr->fname);
+ strcat (fname, "/");
+ fname[strlen (fname) + flen] = 0;
} else {
- fname[0] = 0;
+ fname[0] = 0;
}
strncat (fname, fbeg, flen);
#ifdef VMS
/* Change this 1/2 Unix 1/2 VMS file specification into a
full VMS file specification */
if (searchptr->fname && (searchptr->fname[0] != 0)) {
- /* Fix up the filename */
- hack_vms_include_specification (fname);
+ /* Fix up the filename */
+ hack_vms_include_specification (fname);
} else {
- /* This is a normal VMS filespec, so use it unchanged. */
- strncpy (fname, fbeg, flen);
- fname[flen] = 0;
- /* if it's '#include filename', add the missing .h */
- if (index(fname,'.')==NULL) {
- strcat (fname, ".h");
- }
+ /* This is a normal VMS filespec, so use it unchanged. */
+ strncpy (fname, fbeg, flen);
+ fname[flen] = 0;
+ /* if it's '#include filename', add the missing .h */
+ if (index(fname,'.')==NULL) {
+ strcat (fname, ".h");
+ }
}
#endif /* VMS */
/* ??? There are currently 3 separate mechanisms for avoiding processing
- of redundant include files: #import, #pragma once, and
- redundant_include_p. It would be nice if they were unified. */
+ of redundant include files: #import, #pragma once, and
+ redundant_include_p. It would be nice if they were unified. */
if (redundant_include_p (pfile, fname))
- return 0;
+ return 0;
if (importing)
- f = lookup_import (pfile, fname, searchptr);
+ f = lookup_import (pfile, fname, searchptr);
else
- f = open_include_file (pfile, fname, searchptr);
+ f = open_include_file (pfile, fname, searchptr);
if (f == -2)
- return 0; /* Already included this file */
+ return 0; /* Already included this file */
#ifdef EACCES
else if (f == -1 && errno == EACCES)
- cpp_warning (pfile, "Header file %s exists, but is not readable",
- fname);
+ cpp_warning (pfile, "Header file %s exists, but is not readable",
+ fname);
#endif
if (f >= 0)
- break;
+ break;
}
}
strncpy (fname, fbeg, flen);
fname[flen] = 0;
/* 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). */
+ 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). */
if (CPP_OPTIONS(pfile)->print_deps_missing_files
- && CPP_PRINT_DEPS (pfile)
- > (angle_brackets || (pfile->system_include_depth > 0)))
- {
- /* If it was requested as a system header file,
- then assume it belongs in the first place to look for such. */
- if (angle_brackets)
- {
- for (searchptr = search_start; searchptr;
- searchptr = searchptr->next)
- {
- if (searchptr->fname)
- {
- char *p;
-
- if (searchptr->fname[0] == 0)
- continue;
- p = (char *) alloca (strlen (searchptr->fname)
- + strlen (fname) + 2);
- strcpy (p, searchptr->fname);
- strcat (p, "/");
- strcat (p, fname);
- deps_output (pfile, p, ' ');
- break;
- }
- }
- }
- else
- {
- /* Otherwise, omit the directory, as if the file existed
- in the directory with the source. */
- deps_output (pfile, fname, ' ');
- }
- }
+ && CPP_PRINT_DEPS (pfile)
+ > (angle_brackets || (pfile->system_include_depth > 0)))
+ {
+ /* If it was requested as a system header file,
+ then assume it belongs in the first place to look for such. */
+ if (angle_brackets)
+ {
+ for (searchptr = search_start; searchptr;
+ searchptr = searchptr->next)
+ {
+ if (searchptr->fname)
+ {
+ char *p;
+
+ if (searchptr->fname[0] == 0)
+ continue;
+ p = (char *) alloca (strlen (searchptr->fname)
+ + strlen (fname) + 2);
+ strcpy (p, searchptr->fname);
+ strcat (p, "/");
+ strcat (p, fname);
+ deps_output (pfile, p, ' ');
+ break;
+ }
+ }
+ }
+ else
+ {
+ /* Otherwise, omit the directory, as if the file existed
+ in the directory with the source. */
+ deps_output (pfile, fname, ' ');
+ }
+ }
/* 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.*/
+ 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 (CPP_PRINT_DEPS (pfile)
- && (CPP_PRINT_DEPS (pfile)
- <= (angle_brackets || (pfile->system_include_depth > 0))))
- cpp_warning (pfile, "No include path in which to find %s", fname);
+ && (CPP_PRINT_DEPS (pfile)
+ <= (angle_brackets || (pfile->system_include_depth > 0))))
+ cpp_warning (pfile, "No include path in which to find %s", fname);
else if (search_start)
- cpp_error_from_errno (pfile, fname);
+ cpp_error_from_errno (pfile, fname);
else
- cpp_error (pfile, "No include path in which to find %s", fname);
+ cpp_error (pfile, "No include path in which to find %s", fname);
}
else {
/* Check to see if this include file is a once-only include file.
for (ptr = pfile->dont_repeat_files; ptr; ptr = ptr->next) {
if (!strcmp (ptr->fname, fname)) {
- close (f);
- return 0; /* This file was once'd. */
+ close (f);
+ return 0; /* This file was once'd. */
}
}
for (ptr = pfile->all_include_files; ptr; ptr = ptr->next) {
if (!strcmp (ptr->fname, fname))
- break; /* This file was included before. */
+ break; /* This file was included before. */
}
if (ptr == 0) {
/* This is the first time for this file. */
/* Add it to list of files included. */
- ptr = (struct file_name_list *) xmalloc (sizeof (struct file_name_list));
+ ptr = (struct file_name_list *) Safe_malloc (sizeof (struct file_name_list));
ptr->control_macro = 0;
ptr->c_system_include_path = 0;
ptr->next = pfile->all_include_files;
/* For -M, add this file to the dependencies. */
if (CPP_PRINT_DEPS (pfile)
- > (angle_brackets || (pfile->system_include_depth > 0)))
- deps_output (pfile, fname, ' ');
- }
+ > (angle_brackets || (pfile->system_include_depth > 0)))
+ deps_output (pfile, fname, ' ');
+ }
/* Handle -H option. */
if (CPP_OPTIONS(pfile)->print_include_names)
{
- cpp_buffer *buf = CPP_BUFFER (pfile);
- while ((buf = CPP_PREV_BUFFER (buf)) != NULL)
- putc ('.', stderr);
- fprintf (stderr, "%s\n", fname);
+ cpp_buffer *buf = CPP_BUFFER (pfile);
+ while ((buf = CPP_PREV_BUFFER (buf)) != NULL)
+ putc ('.', stderr);
+ fprintf (stderr, "%s\n", fname);
}
if (angle_brackets)
#if 0
if (!no_precomp)
{
- struct stat stat_f;
-
- fstat (f, &stat_f);
-
- do {
- sprintf (pcftry, "%s%d", fname, pcfnum++);
-
- pcf = open (pcftry, O_RDONLY, 0666);
- if (pcf != -1)
- {
- struct stat s;
-
- fstat (pcf, &s);
- if (bcmp ((char *) &stat_f.st_ino, (char *) &s.st_ino,
- sizeof (s.st_ino))
- || stat_f.st_dev != s.st_dev)
- {
- pcfbuf = check_precompiled (pcf, fname, &pcfbuflimit);
- /* Don't need it any more. */
- close (pcf);
- }
- else
- {
- /* Don't need it at all. */
- close (pcf);
- break;
- }
- }
- } while (pcf != -1 && !pcfbuf);
+ struct stat stat_f;
+
+ fstat (f, &stat_f);
+
+ do {
+ sprintf (pcftry, "%s%d", fname, pcfnum++);
+
+ pcf = open (pcftry, O_RDONLY, 0666);
+ if (pcf != -1)
+ {
+ struct stat s;
+
+ fstat (pcf, &s);
+ if (bcmp ((char *) &stat_f.st_ino, (char *) &s.st_ino,
+ sizeof (s.st_ino))
+ || stat_f.st_dev != s.st_dev)
+ {
+ pcfbuf = check_precompiled (pcf, fname, &pcfbuflimit);
+ /* Don't need it any more. */
+ close (pcf);
+ }
+ else
+ {
+ /* Don't need it at all. */
+ close (pcf);
+ break;
+ }
+ }
+ } while (pcf != -1 && !pcfbuf);
}
#endif
-
+
/* Actually process the file */
cpp_push_buffer (pfile, NULL, 0);
if (finclude (pfile, f, fname, is_system_include (pfile, fname),
- searchptr != dsp ? searchptr : SELF_DIR_DUMMY))
+ searchptr != dsp ? searchptr : SELF_DIR_DUMMY))
{
- output_line_command (pfile, 0, enter_file);
- pfile->only_seen_white = 2;
+ output_line_command (pfile, 0, enter_file);
+ pfile->only_seen_white = 2;
}
if (angle_brackets)
struct file_name_list *l = pfile->all_include_files;
for (; l; l = l->next)
if (! strcmp (name, l->fname)
- && l->control_macro
- && cpp_lookup (pfile, l->control_macro, -1, -1))
+ && l->control_macro
+ && cpp_lookup (pfile, l->control_macro, -1, -1))
return 1;
return 0;
}
register unsigned length = strlen (sys_dir);
if (! strncmp (sys_dir, filename, length) && filename[length] == '/')
- {
- if (searchptr->c_system_include_path)
- return 2;
- else
- return 1;
- }
+ {
+ if (searchptr->c_system_include_path)
+ return 2;
+ else
+ return 1;
+ }
}
return 0;
}
register U_CHAR *p, *q;
i = sizeof (ASSERTION_HASHNODE) + len + 1;
- hp = (ASSERTION_HASHNODE *) xmalloc (i);
+ hp = (ASSERTION_HASHNODE *) Safe_malloc (i);
bucket = hash;
hp->bucket_hdr = &pfile->assertion_hashtab[bucket];
hp->next = pfile->assertion_hashtab[bucket];
{
struct tokenlist_list *next = tail->next;
free_token_list (tail->tokens);
- free (tail);
+ Safe_free (tail);
tail = next;
}
if (hp == *hp->bucket_hdr)
*hp->bucket_hdr = hp->next;
- free (hp);
+ Safe_free (hp);
}
\f
/* Convert a character string literal into a nul-terminated string.
{
U_CHAR c = *in++;
switch (c)
- {
- case '\0':
- return NULL;
- case '\"':
- limit = in;
- break;
- case '\\':
- if (handle_escapes)
- {
- char *bpc = (char *) in;
- int i = (U_CHAR) cpp_parse_escape (pfile, &bpc);
- in = (U_CHAR *) bpc;
- if (i >= 0)
- *result++ = (U_CHAR)c;
- break;
- }
- /* else fall through */
- default:
- *result++ = c;
- }
+ {
+ case '\0':
+ return NULL;
+ case '\"':
+ limit = in;
+ break;
+ case '\\':
+ if (handle_escapes)
+ {
+ char *bpc = (char *) in;
+ int i = (U_CHAR) cpp_parse_escape (pfile, &bpc);
+ in = (U_CHAR *) bpc;
+ if (i >= 0)
+ *result++ = (U_CHAR)c;
+ break;
+ }
+ /* else fall through */
+ default:
+ *result++ = c;
+ }
}
*result = 0;
return result;
long old_written = CPP_WRITTEN (pfile);
enum file_change_code file_change = same_file;
enum cpp_token token;
- int i;
+/* int i;*/
token = get_directive_token (pfile);
end_name = convert_string (pfile, fname, fname, CPP_PWRITTEN (pfile), 1);
if (end_name == NULL)
{
- cpp_error (pfile, "invalid format `#line' command");
- goto bad_line_directive;
+ cpp_error (pfile, "invalid format `#line' command");
+ goto bad_line_directive;
}
fname_length = end_name - fname;
if (token != CPP_VSPACE && token != CPP_EOF && token != CPP_POP) {
p = pfile->token_buffer + num_start;
if (CPP_PEDANTIC (pfile))
- cpp_pedwarn (pfile, "garbage at end of `#line' command");
+ cpp_pedwarn (pfile, "garbage at end of `#line' command");
if (token != CPP_NUMBER || *p < '0' || *p > '4' || p[1] != '\0')
{
- cpp_error (pfile, "invalid format `#line' command");
- goto bad_line_directive;
+ cpp_error (pfile, "invalid format `#line' command");
+ goto bad_line_directive;
}
if (*p == '1')
- file_change = enter_file;
+ file_change = enter_file;
else if (*p == 2)
- file_change = leave_file;
+ file_change = leave_file;
else if (*p == 3)
- ip->system_header_p = 1;
+ ip->system_header_p = 1;
else /* if (*p == 4) */
- ip->system_header_p = 2;
+ ip->system_header_p = 2;
CPP_SET_WRITTEN (pfile, num_start);
token = get_directive_token (pfile);
p = pfile->token_buffer + num_start;
if (token == CPP_NUMBER && p[1] == '\0' && (*p == '3' || *p== '4')) {
- ip->system_header_p = *p == 3 ? 1 : 2;
- token = get_directive_token (pfile);
+ ip->system_header_p = *p == 3 ? 1 : 2;
+ token = get_directive_token (pfile);
}
if (token != CPP_VSPACE) {
- cpp_error (pfile, "invalid format `#line' command");
- goto bad_line_directive;
+ cpp_error (pfile, "invalid format `#line' command");
+ goto bad_line_directive;
}
}
&fname_table[hashf (fname, fname_length, FNAME_HASHSIZE)];
for (hp = *hash_bucket; hp != NULL; hp = hp->next)
if (hp->length == fname_length &&
- strncmp (hp->value.cpval, fname, fname_length) == 0) {
- ip->nominal_fname = hp->value.cpval;
- break;
+ strncmp (hp->value.cpval, fname, fname_length) == 0) {
+ ip->nominal_fname = hp->value.cpval;
+ break;
}
if (hp == 0) {
/* Didn't find it; cons up a new one. */
- hp = (HASHNODE *) xcalloc (1, sizeof (HASHNODE) + fname_length + 1);
+ hp = (HASHNODE *) Safe_calloc(1,sizeof (HASHNODE) + fname_length + 1);
hp->next = *hash_bucket;
*hash_bucket = hp;
while ((hp = cpp_lookup (pfile, buf, sym_length, -1)) != NULL)
{
/* If we are generating additional info for debugging (with -g) we
- need to pass through all effective #undef commands. */
+ need to pass through all effective #undef commands. */
if (CPP_OPTIONS (pfile)->debug_output && keyword)
- pass_thru_directive (orig_buf, limit, pfile, keyword);
+ pass_thru_directive (orig_buf, limit, pfile, keyword);
if (hp->type != T_MACRO)
- cpp_warning (pfile, "undefining `%s'", hp->name);
+ cpp_warning (pfile, "undefining `%s'", hp->name);
delete_macro (hp);
}
U_CHAR *buf,U_CHAR *limit)
{
int length = limit - buf;
- U_CHAR *copy = (U_CHAR *) xmalloc (length + 1);
+ U_CHAR *copy = (U_CHAR *) Safe_malloc (length + 1);
bcopy (buf, copy, length);
copy[length] = 0;
SKIP_WHITE_SPACE (copy);
U_CHAR *buf,U_CHAR *limit)
{
int length = limit - buf;
- U_CHAR *copy = (U_CHAR *) xmalloc (length + 1);
+ U_CHAR *copy = (U_CHAR *) Safe_malloc (length + 1);
bcopy (buf, copy, length);
copy[length] = 0;
SKIP_WHITE_SPACE (copy);
for (ip = CPP_BUFFER (pfile); ; ip = CPP_PREV_BUFFER (ip))
{
if (ip == NULL)
- return 0;
+ return 0;
if (ip->fname != NULL)
- break;
+ break;
}
-
- new = (struct file_name_list *) xmalloc (sizeof (struct file_name_list));
+
+ new = (struct file_name_list *) Safe_malloc (sizeof (struct file_name_list));
new->next = pfile->dont_repeat_files;
pfile->dont_repeat_files = new;
new->fname = savestring (ip->fname);
U_CHAR *buf, U_CHAR *limit)
{
/* long old_written = CPP_WRITTEN (pfile);*/
- int len;
+/* int len;*/
/* Allow #ident in system headers, since that's not user's fault. */
if (CPP_PEDANTIC (pfile) && !CPP_BUFFER (pfile)->system_header_p)
fname = p + 1;
p = (U_CHAR *) index (fname, '\"');
fname_len = p != NULL ? p - fname : strlen (fname);
-
+
for (ptr = pfile->all_include_files; ptr; ptr = ptr->next) {
inc_fname = (U_CHAR *) rindex (ptr->fname, '/');
inc_fname = inc_fname ? inc_fname + 1 : (U_CHAR *) ptr->fname;
if (inc_fname && !strncmp (inc_fname, fname, fname_len))
- cpp_warning (pfile,
- "`#pragma implementation' for `%s' appears after file is included",
- fname);
+ cpp_warning (pfile,
+ "`#pragma implementation' for `%s' appears after file is included",
+ fname);
}
}
/*
* handle #if command 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
+ * 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 command)
* 2) rescan the input into a temporary output buffer
* 3) pass the output buffer to the yacc parser and collect a value
fprintf (stderr, " (matches line %d", pfile->if_stack->lineno);
#endif
if (pfile->if_stack->fname != NULL && CPP_BUFFER (pfile)->fname != NULL
- && strcmp (pfile->if_stack->fname,
- CPP_BUFFER (pfile)->nominal_fname) != 0)
- fprintf (stderr, ", file %s", pfile->if_stack->fname);
+ && strcmp (pfile->if_stack->fname,
+ CPP_BUFFER (pfile)->nominal_fname) != 0)
+ fprintf (stderr, ", file %s", pfile->if_stack->fname);
fprintf (stderr, ")\n");
}
pfile->if_stack->type = T_ELIF;
if (value == 0)
skip_if_group (pfile, 0);
else {
- ++pfile->if_stack->if_succeeded; /* continue processing input */
+ ++pfile->if_stack->if_succeeded; /* continue processing input */
output_line_command (pfile, 1, same_file);
}
}
value = cpp_parse_expr (pfile);
pfile->pcp_inside_if = 0;
- delete_macro (save_defined); /* clean up special symbol */
+ delete_macro (save_defined); /* clean up special symbol */
CPP_SET_WRITTEN (pfile, old_written); /* Pop */
{
skip = (keyword->type == T_IFDEF);
if (! CPP_TRADITIONAL (pfile))
- cpp_pedwarn (pfile, "`#%s' with no argument", keyword->name);
+ cpp_pedwarn (pfile, "`#%s' with no argument", keyword->name);
}
else if (token == CPP_NAME)
{
HASHNODE *hp = cpp_lookup (pfile, ident, ident_length, -1);
skip = (hp == NULL) ^ (keyword->type == T_IFNDEF);
if (start_of_file && !skip)
- {
- control_macro = (U_CHAR *) xmalloc (ident_length + 1);
- bcopy (ident, control_macro, ident_length + 1);
- }
+ {
+ control_macro = (U_CHAR *) Safe_malloc (ident_length + 1);
+ bcopy (ident, control_macro, ident_length + 1);
+ }
}
else
{
skip = (keyword->type == T_IFDEF);
if (! CPP_TRADITIONAL (pfile))
- cpp_error (pfile, "`#%s' with invalid argument", keyword->name);
+ cpp_error (pfile, "`#%s' with invalid argument", keyword->name);
}
if (!CPP_TRADITIONAL (pfile))
cpp_skip_hspace (pfile);
c = PEEKC ();
if (c != EOF && c != '\n')
- cpp_pedwarn (pfile, "garbage at end of `#%s' argument", keyword->name);
+ cpp_pedwarn (pfile, "garbage at end of `#%s' argument", keyword->name);
}
skip_rest_of_line (pfile);
if (pcp_outfile) {
/* Output a precondition for this macro. */
if (hp && hp->value.defn->predefined)
- fprintf (pcp_outfile, "#define %s\n", hp->name);
+ 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);
+ U_CHAR *cp = buf;
+ fprintf (pcp_outfile, "#undef ");
+ while (is_idchar[*cp]) /* Ick! */
+ fputc (*cp++, pcp_outfile);
+ putc ('\n', pcp_outfile);
}
#endif
{
IF_STACK_FRAME *temp;
- temp = (IF_STACK_FRAME *) xcalloc (1, sizeof (IF_STACK_FRAME));
+ temp = (IF_STACK_FRAME *) Safe_calloc(1,sizeof (IF_STACK_FRAME));
temp->fname = CPP_BUFFER (pfile)->nominal_fname;
#if 0
temp->lineno = CPP_BUFFER (pfile)->lineno;
int any)
{
int c;
- int at_beg_of_line = 1;
struct directive *kt;
IF_STACK_FRAME *save_if_stack = pfile->if_stack; /* don't pop past here */
#if 0
U_CHAR *beg_of_line = bp;
#endif
register int ident_length;
- U_CHAR *ident, *after_ident;
+ U_CHAR *ident /*, *after_ident */ ;
struct parse_marker line_start_mark;
parse_set_mark (&line_start_mark, pfile);
pfile->limit = ident;
#if 0
if (ident_length == 0)
- goto not_a_directive;
+ goto not_a_directive;
/* Handle # followed by a line number. */
#endif
for (kt = directive_table; kt->length >= 0; kt++)
- {
- IF_STACK_FRAME *temp;
- if (ident_length == kt->length
- && strncmp (ident, 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 = pfile->if_stack;
- pfile->if_stack = temp;
+ {
+ IF_STACK_FRAME *temp;
+ if (ident_length == kt->length
+ && strncmp (ident, 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 *) Safe_calloc(1,sizeof (IF_STACK_FRAME));
+ temp->next = pfile->if_stack;
+ pfile->if_stack = temp;
#if 0
- temp->lineno = CPP_BUFFER(pfile)->lineno;
+ temp->lineno = CPP_BUFFER(pfile)->lineno;
#endif
- temp->fname = CPP_BUFFER(pfile)->nominal_fname;
- temp->type = kt->type;
- break;
- case T_ELSE:
- case T_ENDIF:
- if (CPP_PEDANTIC (pfile) && pfile->if_stack != save_if_stack)
- validate_else (pfile,
- kt->type == T_ELSE ? "#else" : "#endif");
- case T_ELIF:
- if (pfile->if_stack == CPP_BUFFER (pfile)->if_stack)
- {
- cpp_error (pfile,
- "`#%s' not within a conditional", kt->name);
- break;
- }
- else if (pfile->if_stack == save_if_stack)
- goto done; /* found what we came for */
-
- if (kt->type != T_ENDIF)
- {
- if (pfile->if_stack->type == T_ELSE)
- cpp_error (pfile, "`#else' or `#elif' after `#else'");
- pfile->if_stack->type = kt->type;
- break;
- }
-
- temp = pfile->if_stack;
- pfile->if_stack = temp->next;
- free (temp);
- break;
- default: ;
- }
- break;
- }
- /* Don't let erroneous code go by. */
- if (kt->length < 0 && !CPP_OPTIONS (pfile)->lang_asm
- && CPP_PEDANTIC (pfile))
- cpp_pedwarn (pfile, "invalid preprocessor directive name");
- }
+ temp->fname = CPP_BUFFER(pfile)->nominal_fname;
+ temp->type = kt->type;
+ break;
+ case T_ELSE:
+ case T_ENDIF:
+ if (CPP_PEDANTIC (pfile) && pfile->if_stack != save_if_stack)
+ validate_else (pfile,
+ kt->type == T_ELSE ? "#else" : "#endif");
+ case T_ELIF:
+ if (pfile->if_stack == CPP_BUFFER (pfile)->if_stack)
+ {
+ cpp_error (pfile,
+ "`#%s' not within a conditional", kt->name);
+ break;
+ }
+ else if (pfile->if_stack == save_if_stack)
+ goto done; /* found what we came for */
+
+ if (kt->type != T_ENDIF)
+ {
+ if (pfile->if_stack->type == T_ELSE)
+ cpp_error (pfile, "`#else' or `#elif' after `#else'");
+ pfile->if_stack->type = kt->type;
+ break;
+ }
+
+ temp = pfile->if_stack;
+ pfile->if_stack = temp->next;
+ Safe_free (temp);
+ break;
+ default: ;
+ }
+ break;
+ }
+ /* Don't let erroneous code go by. */
+ if (kt->length < 0 && !CPP_OPTIONS (pfile)->lang_asm
+ && CPP_PEDANTIC (pfile))
+ cpp_pedwarn (pfile, "invalid preprocessor directive name");
+ }
c = GETC ();
}
/* We're in the middle of a line. Skip the rest of it. */
for (;;) {
switch (c)
{
- long old;
+ long old;
case EOF:
- goto done;
- case '/': /* possible comment */
- c = skip_comment (pfile, NULL);
- if (c == EOF)
- goto done;
- break;
+ goto done;
+ case '/': /* possible comment */
+ c = skip_comment (pfile, NULL);
+ if (c == EOF)
+ goto done;
+ break;
case '\"':
case '\'':
- FORWARD(-1);
- old = CPP_WRITTEN (pfile);
- cpp_get_token (pfile);
- CPP_SET_WRITTEN (pfile, old);
- break;
+ FORWARD(-1);
+ old = CPP_WRITTEN (pfile);
+ cpp_get_token (pfile);
+ CPP_SET_WRITTEN (pfile, old);
+ break;
case '\\':
- /* Char after backslash loses its special meaning. */
- if (PEEKC() == '\n')
- FORWARD (1);
- break;
+ /* Char after backslash loses its special meaning. */
+ if (PEEKC() == '\n')
+ FORWARD (1);
+ break;
case '\n':
- goto beg_of_line;
- break;
+ goto beg_of_line;
+ break;
}
c = GETC ();
}
cpp_error (pfile, "`#else' after `#else'");
fprintf (stderr, " (matches line %d", pfile->if_stack->lineno);
if (strcmp (pfile->if_stack->fname, ip->nominal_fname) != 0)
- fprintf (stderr, ", file %s", pfile->if_stack->fname);
+ fprintf (stderr, ", file %s", pfile->if_stack->fname);
fprintf (stderr, ")\n");
}
pfile->if_stack->type = T_ELSE;
if (pfile->if_stack->if_succeeded)
skip_if_group (pfile, 0);
else {
- ++pfile->if_stack->if_succeeded; /* continue processing input */
+ ++pfile->if_stack->if_succeeded; /* continue processing input */
output_line_command (pfile, 1, same_file);
}
return 0;
IF_STACK_FRAME *temp = pfile->if_stack;
pfile->if_stack = temp->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. */
- struct parse_marker start_mark;
- int c;
-
- parse_set_mark (&start_mark, pfile);
-
- for (;;)
- {
- cpp_skip_hspace (pfile);
- c = GETC ();
- if (c != '\n')
- break;
- }
- parse_goto_mark (&start_mark, pfile);
- parse_clear_mark (&start_mark);
-
- if (c == EOF)
- {
- /* 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. */
+ {
+ /* This #endif matched a #ifndef at the start of the file.
+ See if it is at the end of the file. */
+ struct parse_marker start_mark;
+ int c;
+
+ parse_set_mark (&start_mark, pfile);
+
+ for (;;)
+ {
+ cpp_skip_hspace (pfile);
+ c = GETC ();
+ if (c != '\n')
+ break;
+ }
+ parse_goto_mark (&start_mark, pfile);
+ parse_clear_mark (&start_mark);
+
+ if (c == EOF)
+ {
+ /* 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 0
FIXME!
- if (indepth != 0
- && ! (indepth == 1 && pfile->no_record_file)
- && ! (pfile->no_record_file && no_output))
+ if (indepth != 0
+ && ! (indepth == 1 && pfile->no_record_file)
+ && ! (pfile->no_record_file && no_output))
#endif
- {
- struct file_name_list *ifile = pfile->all_include_files;
-
- for ( ; ifile != NULL; ifile = ifile->next)
- {
- if (!strcmp (ifile->fname, CPP_BUFFER (pfile)->fname))
- {
- ifile->control_macro = temp->control_macro;
- break;
- }
- }
- }
- }
+ {
+ struct file_name_list *ifile = pfile->all_include_files;
+
+ for ( ; ifile != NULL; ifile = ifile->next)
+ {
+ if (!strcmp (ifile->fname, CPP_BUFFER (pfile)->fname))
+ {
+ ifile->control_macro = temp->control_macro;
+ break;
+ }
}
- free (temp);
+ }
+ }
+ }
+ Safe_free (temp);
output_line_command (pfile, 1, same_file);
}
return 0;
c = PEEKC ();
if (c != EOF && c != '\n')
cpp_pedwarn (pfile,
- "text following `%s' violates ANSI standard", directive);
+ "text following `%s' violates ANSI standard", directive);
}
/* Get the next token, and add it to the text in pfile->token_buffer.
Return the kind of token we got. */
-
+
enum cpp_token
cpp_get_token (
cpp_reader *pfile)
{
register int c, c2, c3;
- long old_written;
+ long old_written = 0;
long start_line, start_column;
enum cpp_token token;
struct cpp_options *opts = CPP_OPTIONS (pfile);
{
handle_eof:
if (CPP_BUFFER (pfile)->seen_eof)
- {
- if (cpp_pop_buffer (pfile) != CPP_NULL_BUFFER (pfile))
- goto get_next;
- else
- return CPP_EOF;
- }
+ {
+ if (cpp_pop_buffer (pfile) != CPP_NULL_BUFFER (pfile))
+ goto get_next;
+ else
+ return CPP_EOF;
+ }
else
- {
- cpp_buffer *next_buf
- = CPP_PREV_BUFFER (CPP_BUFFER (pfile));
- CPP_BUFFER (pfile)->seen_eof = 1;
- if (CPP_BUFFER (pfile)->nominal_fname && next_buf != 0)
- {
- /* We're about to return from an #include file.
- Emit #line information now (as part of the CPP_POP) result.
- But the #line refers to the file we will pop to. */
- cpp_buffer *cur_buffer = CPP_BUFFER (pfile);
- CPP_BUFFER (pfile) = next_buf;
- pfile->input_stack_listing_current = 0;
- output_line_command (pfile, 0, leave_file);
- CPP_BUFFER (pfile) = cur_buffer;
- }
- return CPP_POP;
- }
+ {
+ cpp_buffer *next_buf
+ = CPP_PREV_BUFFER (CPP_BUFFER (pfile));
+ CPP_BUFFER (pfile)->seen_eof = 1;
+ if (CPP_BUFFER (pfile)->nominal_fname && next_buf != 0)
+ {
+ /* We're about to return from an #include file.
+ Emit #line information now (as part of the CPP_POP) result.
+ But the #line refers to the file we will pop to. */
+ cpp_buffer *cur_buffer = CPP_BUFFER (pfile);
+ CPP_BUFFER (pfile) = next_buf;
+ pfile->input_stack_listing_current = 0;
+ output_line_command (pfile, 0, leave_file);
+ CPP_BUFFER (pfile) = cur_buffer;
+ }
+ return CPP_POP;
+ }
}
else
{
switch (c)
- {
- long newlines;
- struct parse_marker start_mark;
- case '/':
- if (PEEKC () == '=')
- goto op2;
- if (opts->put_out_comments)
- parse_set_mark (&start_mark, pfile);
- newlines = 0;
- cpp_buf_line_and_col (cpp_file_buffer (pfile),
- &start_line, &start_column);
- c = skip_comment (pfile, &newlines);
- if (opts->put_out_comments && (c == '/' || c == EOF))
- parse_clear_mark (&start_mark);
- if (c == '/')
- goto randomchar;
- if (c == EOF)
- {
- cpp_error_with_line (pfile, start_line, start_column,
- "unterminated comment");
- goto handle_eof;
- }
- c = '/'; /* Initial letter of comment. */
- return_comment:
- /* Comments are equivalent to spaces.
- For -traditional, a comment is equivalent to nothing. */
- if (opts->put_out_comments)
- {
- cpp_buffer *pbuf = CPP_BUFFER (pfile);
- long dummy;
- U_CHAR *start = pbuf->buf + start_mark.position;
- int len = pbuf->cur - start;
- CPP_RESERVE(pfile, 1 + len);
- CPP_PUTC_Q (pfile, c);
- CPP_PUTS_Q (pfile, start, len);
- pfile->lineno += newlines;
- parse_clear_mark (&start_mark);
- return CPP_COMMENT;
- }
- else if (CPP_TRADITIONAL (pfile))
- {
- return CPP_COMMENT;
- }
- else
- {
+ {
+ long newlines;
+ struct parse_marker start_mark;
+ case '/':
+ if (PEEKC () == '=')
+ goto op2;
+ if (opts->put_out_comments)
+ parse_set_mark (&start_mark, pfile);
+ newlines = 0;
+ cpp_buf_line_and_col (cpp_file_buffer (pfile),
+ &start_line, &start_column);
+ c = skip_comment (pfile, &newlines);
+ if (opts->put_out_comments && (c == '/' || c == EOF))
+ parse_clear_mark (&start_mark);
+ if (c == '/')
+ goto randomchar;
+ if (c == EOF)
+ {
+ cpp_error_with_line (pfile, start_line, start_column,
+ "unterminated comment");
+ goto handle_eof;
+ }
+ c = '/'; /* Initial letter of comment. */
+ return_comment:
+ /* Comments are equivalent to spaces.
+ For -traditional, a comment is equivalent to nothing. */
+ if (opts->put_out_comments)
+ {
+ cpp_buffer *pbuf = CPP_BUFFER (pfile);
+ /* long dummy; */
+ U_CHAR *start = pbuf->buf + start_mark.position;
+ int len = pbuf->cur - start;
+ CPP_RESERVE(pfile, 1 + len);
+ CPP_PUTC_Q (pfile, c);
+ CPP_PUTS_Q (pfile, start, len);
+ pfile->lineno += newlines;
+ parse_clear_mark (&start_mark);
+ return CPP_COMMENT;
+ }
+ else if (CPP_TRADITIONAL (pfile))
+ {
+ return CPP_COMMENT;
+ }
+ else
+ {
#if 0
- /* This may not work if cpp_get_token is called recursively,
- since many places look for horizontal space. */
- if (newlines)
- {
- /* Copy the newlines into the output buffer, in order to
- avoid the pain of a #line every time a multiline comment
- is seen. */
- CPP_RESERVE(pfile, newlines);
- while (--newlines >= 0)
- {
- CPP_PUTC_Q (pfile, '\n');
- pfile->lineno++;
- }
- return CPP_VSPACE;
- }
+ /* This may not work if cpp_get_token is called recursively,
+ since many places look for horizontal space. */
+ if (newlines)
+ {
+ /* Copy the newlines into the output buffer, in order to
+ avoid the pain of a #line every time a multiline comment
+ is seen. */
+ CPP_RESERVE(pfile, newlines);
+ while (--newlines >= 0)
+ {
+ CPP_PUTC_Q (pfile, '\n');
+ pfile->lineno++;
+ }
+ return CPP_VSPACE;
+ }
#endif
- CPP_RESERVE(pfile, 1);
- CPP_PUTC_Q (pfile, ' ');
- return CPP_HSPACE;
- }
+ CPP_RESERVE(pfile, 1);
+ CPP_PUTC_Q (pfile, ' ');
+ return CPP_HSPACE;
+ }
#if 0
- if (opts->for_lint) {
- U_CHAR *argbp;
- int cmdlen, arglen;
- char *lintcmd = get_lintcmd (ibp, limit, &argbp, &arglen, &cmdlen);
-
- if (lintcmd != NULL) {
- /* 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 b/c the newline for the pragma
- could fuck things up. */
- output_line_command (pfile, 0, same_file);
- *(obp++) = ' '; /* just in case, if comments are copied thru */
- *(obp++) = '/';
- }
- }
+ if (opts->for_lint) {
+ U_CHAR *argbp;
+ int cmdlen, arglen;
+ char *lintcmd = get_lintcmd (ibp, limit, &argbp, &arglen, &cmdlen);
+
+ if (lintcmd != NULL) {
+ /* 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 b/c the newline for the pragma
+ could fuck things up. */
+ output_line_command (pfile, 0, same_file);
+ *(obp++) = ' '; /* just in case, if comments are copied thru */
+ *(obp++) = '/';
+ }
+ }
#endif
- case '#':
+ case '#':
#if 0
- /* If this is expanding a macro definition, don't recognize
- preprocessor directives. */
- if (ip->macro != 0)
- goto randomchar;
- /* If this is expand_into_temp_buffer, recognize them
- only after an actual newline at this level,
- not at the beginning of the input level. */
- if (ip->fname == 0 && beg_of_line == ip->buf)
- goto randomchar;
- if (ident_length)
- goto specialchar;
+ /* If this is expanding a macro definition, don't recognize
+ preprocessor directives. */
+ if (ip->macro != 0)
+ goto randomchar;
+ /* If this is expand_into_temp_buffer, recognize them
+ only after an actual newline at this level,
+ not at the beginning of the input level. */
+ if (ip->fname == 0 && beg_of_line == ip->buf)
+ goto randomchar;
+ if (ident_length)
+ goto specialchar;
#endif
- if (!pfile->only_seen_white)
- goto randomchar;
- if (handle_directive (pfile))
- return CPP_DIRECTIVE;
- pfile->only_seen_white = 0;
- return CPP_OTHER;
-
- case '\"':
- case '\'':
- /* A single quoted string is treated like a double -- some
- programs (e.g., troff) are perverse this way */
- cpp_buf_line_and_col (cpp_file_buffer (pfile),
- &start_line, &start_column);
- old_written = CPP_WRITTEN (pfile);
- string:
- CPP_PUTC (pfile, c);
- while (1)
- {
- int cc = GETC();
- if (cc == EOF)
- {
- if (CPP_IS_MACRO_BUFFER (CPP_BUFFER (pfile)))
- {
- /* 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. */
- cpp_buffer *next_buf
- = CPP_PREV_BUFFER (CPP_BUFFER (pfile));
- (*CPP_BUFFER (pfile)->cleanup)
- (CPP_BUFFER (pfile), pfile);
- CPP_BUFFER (pfile) = next_buf;
- continue;
- }
- if (!CPP_TRADITIONAL (pfile))
- {
- cpp_error_with_line (pfile, start_line, start_column,
- "unterminated string or character constant");
- if (pfile->multiline_string_line != start_line
- && pfile->multiline_string_line != 0)
- cpp_error_with_line (pfile,
- pfile->multiline_string_line, -1,
- "possible real start of unterminated constant");
- pfile->multiline_string_line = 0;
- }
- break;
- }
- CPP_PUTC (pfile, cc);
- switch (cc)
- {
- case '\n':
- /* Traditionally, end of line ends a string constant with
- no error. So exit the loop and record the new line. */
- if (CPP_TRADITIONAL (pfile))
- goto while2end;
- if (c == '\'')
- {
- cpp_error_with_line (pfile, start_line, start_column,
- "unterminated character constant");
- goto while2end;
- }
- if (CPP_PEDANTIC (pfile)
- && pfile->multiline_string_line == 0)
- {
- cpp_pedwarn_with_line (pfile, start_line, start_column,
- "string constant runs past end of line");
- }
- if (pfile->multiline_string_line == 0)
- pfile->multiline_string_line = start_line;
- break;
-
- case '\\':
- cc = GETC();
- if (cc == '\n')
- {
- /* Backslash newline is replaced by nothing at all. */
- CPP_ADJUST_WRITTEN (pfile, -1);
- pfile->lineno++;
- }
- else
- {
- /* ANSI stupidly requires that in \\ the second \
- is *not* prevented from combining with a newline. */
- NEWLINE_FIX1(cc);
- if (cc != EOF)
- CPP_PUTC (pfile, cc);
- }
- break;
-
- case '\"':
- case '\'':
- if (cc == c)
- goto while2end;
- break;
- }
- }
- while2end:
- pfile->lineno += count_newlines (pfile->token_buffer + old_written,
- CPP_PWRITTEN (pfile));
- pfile->only_seen_white = 0;
- return c == '\'' ? CPP_CHAR : CPP_STRING;
-
- case '$':
- if (!opts->dollars_in_ident)
- goto randomchar;
- goto letter;
-
- case ':':
- if (opts->cplusplus && PEEKC () == ':')
- goto op2;
- goto randomchar;
-
- case '&':
- case '+':
- case '|':
- NEWLINE_FIX;
- c2 = PEEKC ();
- if (c2 == c || c2 == '=')
- goto op2;
- goto randomchar;
-
- case '*':
- case '!':
- case '%':
- case '=':
- case '^':
- NEWLINE_FIX;
- if (PEEKC () == '=')
- goto op2;
- goto randomchar;
-
- case '-':
- NEWLINE_FIX;
- c2 = PEEKC ();
- if (c2 == '-' && opts->chill)
- {
- /* Chill style comment */
- if (opts->put_out_comments)
- parse_set_mark (&start_mark, pfile);
- FORWARD(1); /* Skip second '-'. */
- for (;;)
- {
- c = GETC ();
- if (c == EOF)
- break;
- if (c == '\n')
- {
- /* Don't consider final '\n' to be part of comment. */
- FORWARD(-1);
- break;
- }
- }
- c = '-';
- goto return_comment;
- }
- if (c2 == '-' || c2 == '=' || c2 == '>')
- goto op2;
- goto randomchar;
-
- case '<':
- if (pfile->parsing_include_directive)
- {
- for (;;)
- {
- CPP_PUTC (pfile, c);
- if (c == '>')
- break;
- c = GETC ();
- NEWLINE_FIX1 (c);
- if (c == '\n' || c == EOF)
- {
- cpp_error (pfile,
- "missing '>' in `#include <FILENAME>'");
- break;
- }
- }
- return CPP_STRING;
- }
- /* else fall through */
- case '>':
- NEWLINE_FIX;
- c2 = PEEKC ();
- if (c2 == '=')
- goto op2;
- if (c2 != c)
- goto randomchar;
- FORWARD(1);
- CPP_RESERVE (pfile, 4);
- CPP_PUTC (pfile, c);
- CPP_PUTC (pfile, c2);
- NEWLINE_FIX;
- c3 = PEEKC ();
- if (c3 == '=')
- CPP_PUTC_Q (pfile, GETC ());
- CPP_NUL_TERMINATE_Q (pfile);
- pfile->only_seen_white = 0;
- return CPP_OTHER;
-
- case '@':
- if (CPP_BUFFER (pfile)->has_escapes)
- {
- c = GETC ();
- if (c == '-')
- {
- if (pfile->output_escapes)
- CPP_PUTS (pfile, "@-", 2);
- parse_name (pfile, GETC ());
- return CPP_NAME;
- }
- else if (is_space [c])
- {
- CPP_RESERVE (pfile, 2);
- if (pfile->output_escapes)
- CPP_PUTC_Q (pfile, '@');
- CPP_PUTC_Q (pfile, c);
- return CPP_HSPACE;
- }
- }
- if (pfile->output_escapes)
- {
- CPP_PUTS (pfile, "@@", 2);
- return CPP_OTHER;
- }
- goto randomchar;
-
- case '.':
- NEWLINE_FIX;
- c2 = PEEKC ();
- if (isdigit(c2))
- {
- CPP_RESERVE(pfile, 2);
- CPP_PUTC_Q (pfile, '.');
- c = GETC ();
- goto number;
- }
- /* FIXME - misses the case "..\\\n." */
- if (c2 == '.' && PEEKN(1) == '.')
- {
- CPP_RESERVE(pfile, 4);
- CPP_PUTC_Q (pfile, '.');
- CPP_PUTC_Q (pfile, '.');
- CPP_PUTC_Q (pfile, '.');
- FORWARD (2);
- CPP_NUL_TERMINATE_Q (pfile);
- pfile->only_seen_white = 0;
- return CPP_3DOTS;
- }
- goto randomchar;
-
- op2:
- token = CPP_OTHER;
- pfile->only_seen_white = 0;
+ if (!pfile->only_seen_white)
+ goto randomchar;
+ if (handle_directive (pfile))
+ return CPP_DIRECTIVE;
+ pfile->only_seen_white = 0;
+ return CPP_OTHER;
+
+ case '\"':
+ case '\'':
+ /* A single quoted string is treated like a double -- some
+ programs (e.g., troff) are perverse this way */
+ cpp_buf_line_and_col (cpp_file_buffer (pfile),
+ &start_line, &start_column);
+ old_written = CPP_WRITTEN (pfile);
+ string:
+ CPP_PUTC (pfile, c);
+ while (1)
+ {
+ int cc = GETC();
+ if (cc == EOF)
+ {
+ if (CPP_IS_MACRO_BUFFER (CPP_BUFFER (pfile)))
+ {
+ /* 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. */
+ cpp_buffer *next_buf
+ = CPP_PREV_BUFFER (CPP_BUFFER (pfile));
+ (*CPP_BUFFER (pfile)->cleanup)
+ (CPP_BUFFER (pfile), pfile);
+ CPP_BUFFER (pfile) = next_buf;
+ continue;
+ }
+ if (!CPP_TRADITIONAL (pfile))
+ {
+ cpp_error_with_line (pfile, start_line, start_column,
+ "unterminated string or character constant");
+ if (pfile->multiline_string_line != start_line
+ && pfile->multiline_string_line != 0)
+ cpp_error_with_line (pfile,
+ pfile->multiline_string_line, -1,
+ "possible real start of unterminated constant");
+ pfile->multiline_string_line = 0;
+ }
+ break;
+ }
+ CPP_PUTC (pfile, cc);
+ switch (cc)
+ {
+ case '\n':
+ /* Traditionally, end of line ends a string constant with
+ no error. So exit the loop and record the new line. */
+ if (CPP_TRADITIONAL (pfile))
+ goto while2end;
+ if (c == '\'')
+ {
+ cpp_error_with_line (pfile, start_line, start_column,
+ "unterminated character constant");
+ goto while2end;
+ }
+ if (CPP_PEDANTIC (pfile)
+ && pfile->multiline_string_line == 0)
+ {
+ cpp_pedwarn_with_line (pfile, start_line, start_column,
+ "string constant runs past end of line");
+ }
+ if (pfile->multiline_string_line == 0)
+ pfile->multiline_string_line = start_line;
+ break;
+
+ case '\\':
+ cc = GETC();
+ if (cc == '\n')
+ {
+ /* Backslash newline is replaced by nothing at all. */
+ CPP_ADJUST_WRITTEN (pfile, -1);
+ pfile->lineno++;
+ }
+ else
+ {
+ /* ANSI stupidly requires that in \\ the second \
+ is *not* prevented from combining with a newline. */
+ NEWLINE_FIX1(cc);
+ if (cc != EOF)
+ CPP_PUTC (pfile, cc);
+ }
+ break;
+
+ case '\"':
+ case '\'':
+ if (cc == c)
+ goto while2end;
+ break;
+ }
+ }
+ while2end:
+ pfile->lineno += count_newlines (pfile->token_buffer + old_written,
+ CPP_PWRITTEN (pfile));
+ pfile->only_seen_white = 0;
+ return c == '\'' ? CPP_CHAR : CPP_STRING;
+
+ case '$':
+ if (!opts->dollars_in_ident)
+ goto randomchar;
+ goto letter;
+
+ case ':':
+ if (opts->cplusplus && PEEKC () == ':')
+ goto op2;
+ goto randomchar;
+
+ case '&':
+ case '+':
+ case '|':
+ NEWLINE_FIX;
+ c2 = PEEKC ();
+ if (c2 == c || c2 == '=')
+ goto op2;
+ goto randomchar;
+
+ case '*':
+ case '!':
+ case '%':
+ case '=':
+ case '^':
+ NEWLINE_FIX;
+ if (PEEKC () == '=')
+ goto op2;
+ goto randomchar;
+
+ case '-':
+ NEWLINE_FIX;
+ c2 = PEEKC ();
+ if (c2 == '-' && opts->chill)
+ {
+ /* Chill style comment */
+ if (opts->put_out_comments)
+ parse_set_mark (&start_mark, pfile);
+ FORWARD(1); /* Skip second '-'. */
+ for (;;)
+ {
+ c = GETC ();
+ if (c == EOF)
+ break;
+ if (c == '\n')
+ {
+ /* Don't consider final '\n' to be part of comment. */
+ FORWARD(-1);
+ break;
+ }
+ }
+ c = '-';
+ goto return_comment;
+ }
+ if (c2 == '-' || c2 == '=' || c2 == '>')
+ goto op2;
+ goto randomchar;
+
+ case '<':
+ if (pfile->parsing_include_directive)
+ {
+ for (;;)
+ {
+ CPP_PUTC (pfile, c);
+ if (c == '>')
+ break;
+ c = GETC ();
+ NEWLINE_FIX1 (c);
+ if (c == '\n' || c == EOF)
+ {
+ cpp_error (pfile,
+ "missing '>' in `#include <FILENAME>'");
+ break;
+ }
+ }
+ return CPP_STRING;
+ }
+ /* else fall through */
+ case '>':
+ NEWLINE_FIX;
+ c2 = PEEKC ();
+ if (c2 == '=')
+ goto op2;
+ if (c2 != c)
+ goto randomchar;
+ FORWARD(1);
+ CPP_RESERVE (pfile, 4);
+ CPP_PUTC (pfile, c);
+ CPP_PUTC (pfile, c2);
+ NEWLINE_FIX;
+ c3 = PEEKC ();
+ if (c3 == '=')
+ CPP_PUTC_Q (pfile, GETC ());
+ CPP_NUL_TERMINATE_Q (pfile);
+ pfile->only_seen_white = 0;
+ return CPP_OTHER;
+
+ case '@':
+ if (CPP_BUFFER (pfile)->has_escapes)
+ {
+ c = GETC ();
+ if (c == '-')
+ {
+ if (pfile->output_escapes)
+ CPP_PUTS (pfile, "@-", 2);
+ parse_name (pfile, GETC ());
+ return CPP_NAME;
+ }
+ else if (is_space [c])
+ {
+ CPP_RESERVE (pfile, 2);
+ if (pfile->output_escapes)
+ CPP_PUTC_Q (pfile, '@');
+ CPP_PUTC_Q (pfile, c);
+ return CPP_HSPACE;
+ }
+ }
+ if (pfile->output_escapes)
+ {
+ CPP_PUTS (pfile, "@@", 2);
+ return CPP_OTHER;
+ }
+ goto randomchar;
+
+ case '.':
+ NEWLINE_FIX;
+ c2 = PEEKC ();
+ if (isdigit(c2))
+ {
+ CPP_RESERVE(pfile, 2);
+ CPP_PUTC_Q (pfile, '.');
+ c = GETC ();
+ goto number;
+ }
+ /* FIXME - misses the case "..\\\n." */
+ if (c2 == '.' && PEEKN(1) == '.')
+ {
+ CPP_RESERVE(pfile, 4);
+ CPP_PUTC_Q (pfile, '.');
+ CPP_PUTC_Q (pfile, '.');
+ CPP_PUTC_Q (pfile, '.');
+ FORWARD (2);
+ CPP_NUL_TERMINATE_Q (pfile);
+ pfile->only_seen_white = 0;
+ return CPP_3DOTS;
+ }
+ goto randomchar;
+
+ op2:
+ token = CPP_OTHER;
+ pfile->only_seen_white = 0;
op2any:
- CPP_RESERVE(pfile, 3);
- CPP_PUTC_Q (pfile, c);
- CPP_PUTC_Q (pfile, GETC ());
- CPP_NUL_TERMINATE_Q (pfile);
- return token;
-
- case 'L':
- NEWLINE_FIX;
- c2 = PEEKC ();
- if ((c2 == '\'' || c2 == '\"') && !CPP_TRADITIONAL (pfile))
- {
- CPP_PUTC (pfile, c);
- c = GETC ();
- goto string;
- }
- goto letter;
-
- case '0': case '1': case '2': case '3': case '4':
- case '5': case '6': case '7': case '8': case '9':
- number:
- c2 = '.';
- for (;;)
- {
- CPP_RESERVE (pfile, 2);
- CPP_PUTC_Q (pfile, c);
- NEWLINE_FIX;
- c = PEEKC ();
- if (c == EOF)
- break;
- if (!is_idchar[c] && c != '.'
- && ((c2 != 'e' && c2 != 'E') || (c != '+' && c != '-')))
- break;
- FORWARD(1);
- c2= c;
- }
- CPP_NUL_TERMINATE_Q (pfile);
- pfile->only_seen_white = 0;
- return CPP_NUMBER;
- case 'b': case 'c': case 'd': case 'h': case 'o':
- case 'B': case 'C': case 'D': case 'H': case 'O':
- if (opts->chill && PEEKC () == '\'')
- {
- pfile->only_seen_white = 0;
- CPP_RESERVE (pfile, 2);
- CPP_PUTC_Q (pfile, c);
- CPP_PUTC_Q (pfile, '\'');
- FORWARD(1);
- for (;;)
- {
- c = GETC();
- if (c == EOF)
- goto chill_number_eof;
- if (!is_idchar[c])
- {
- if (c == '\\' && PEEKC() == '\n')
- {
- FORWARD(2);
- continue;
- }
- break;
- }
- CPP_PUTC (pfile, c);
- }
- if (c == '\'')
- {
- CPP_RESERVE (pfile, 2);
- CPP_PUTC_Q (pfile, c);
- CPP_NUL_TERMINATE_Q (pfile);
- return CPP_STRING;
- }
- else
- {
- FORWARD(-1);
- chill_number_eof:
- CPP_NUL_TERMINATE (pfile);
- return CPP_NUMBER;
- }
- }
- else
- goto letter;
- case '_':
- case 'a': case 'e': case 'f': case 'g': case 'i': case 'j':
- case 'k': case 'l': case 'm': case 'n': 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 'E': case 'F': case 'G': case 'I': case 'J':
- case 'K': case 'M': case 'N': case 'P': case 'Q': case 'R':
- case 'S': case 'T': case 'U': case 'V': case 'W': case 'X':
- case 'Y': case 'Z':
+ CPP_RESERVE(pfile, 3);
+ CPP_PUTC_Q (pfile, c);
+ CPP_PUTC_Q (pfile, GETC ());
+ CPP_NUL_TERMINATE_Q (pfile);
+ return token;
+
+ case 'L':
+ NEWLINE_FIX;
+ c2 = PEEKC ();
+ if ((c2 == '\'' || c2 == '\"') && !CPP_TRADITIONAL (pfile))
+ {
+ CPP_PUTC (pfile, c);
+ c = GETC ();
+ goto string;
+ }
+ goto letter;
+
+ case '0': case '1': case '2': case '3': case '4':
+ case '5': case '6': case '7': case '8': case '9':
+ number:
+ c2 = '.';
+ for (;;)
+ {
+ CPP_RESERVE (pfile, 2);
+ CPP_PUTC_Q (pfile, c);
+ NEWLINE_FIX;
+ c = PEEKC ();
+ if (c == EOF)
+ break;
+ if (!is_idchar[c] && c != '.'
+ && ((c2 != 'e' && c2 != 'E') || (c != '+' && c != '-')))
+ break;
+ FORWARD(1);
+ c2= c;
+ }
+ CPP_NUL_TERMINATE_Q (pfile);
+ pfile->only_seen_white = 0;
+ return CPP_NUMBER;
+ case 'b': case 'c': case 'd': case 'h': case 'o':
+ case 'B': case 'C': case 'D': case 'H': case 'O':
+ if (opts->chill && PEEKC () == '\'')
+ {
+ pfile->only_seen_white = 0;
+ CPP_RESERVE (pfile, 2);
+ CPP_PUTC_Q (pfile, c);
+ CPP_PUTC_Q (pfile, '\'');
+ FORWARD(1);
+ for (;;)
+ {
+ c = GETC();
+ if (c == EOF)
+ goto chill_number_eof;
+ if (!is_idchar[c])
+ {
+ if (c == '\\' && PEEKC() == '\n')
+ {
+ FORWARD(2);
+ continue;
+ }
+ break;
+ }
+ CPP_PUTC (pfile, c);
+ }
+ if (c == '\'')
+ {
+ CPP_RESERVE (pfile, 2);
+ CPP_PUTC_Q (pfile, c);
+ CPP_NUL_TERMINATE_Q (pfile);
+ return CPP_STRING;
+ }
+ else
+ {
+ FORWARD(-1);
+ chill_number_eof:
+ CPP_NUL_TERMINATE (pfile);
+ return CPP_NUMBER;
+ }
+ }
+ else
+ goto letter;
+ case '_':
+ case 'a': case 'e': case 'f': case 'g': case 'i': case 'j':
+ case 'k': case 'l': case 'm': case 'n': 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 'E': case 'F': case 'G': case 'I': case 'J':
+ case 'K': case 'M': case 'N': case 'P': case 'Q': case 'R':
+ case 'S': case 'T': case 'U': case 'V': case 'W': case 'X':
+ case 'Y': case 'Z':
letter:
{
- HASHNODE *hp;
- unsigned char *ident;
- int before_name_written = CPP_WRITTEN (pfile);
- int ident_len;
- parse_name (pfile, c);
- pfile->only_seen_white = 0;
- if (pfile->no_macro_expand)
- return CPP_NAME;
- ident = pfile->token_buffer + before_name_written;
- ident_len = CPP_PWRITTEN (pfile) - ident;
- hp = cpp_lookup (pfile, ident, ident_len, -1);
- if (!hp)
- return CPP_NAME;
- if (hp->type == T_DISABLED)
- {
- if (pfile->output_escapes)
- { /* Return "@-IDENT", followed by '\0'. */
- int i;
- CPP_RESERVE (pfile, 3);
- ident = pfile->token_buffer + before_name_written;
- CPP_ADJUST_WRITTEN (pfile, 2);
- for (i = ident_len; i >= 0; i--) ident[i+2] = ident[i];
- ident[0] = '@';
- ident[1] = '-';
- }
- return CPP_NAME;
- }
-
- /* 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->value.defn->nargs >= 0)
- {
- struct parse_marker macro_mark;
- int is_macro_call;
- while (CPP_IS_MACRO_BUFFER (CPP_BUFFER (pfile)))
- {
- cpp_buffer *next_buf;
- cpp_skip_hspace (pfile);
- if (PEEKC () != EOF)
- break;
- next_buf = CPP_PREV_BUFFER (CPP_BUFFER (pfile));
- (*CPP_BUFFER (pfile)->cleanup) (CPP_BUFFER (pfile), pfile);
- CPP_BUFFER (pfile) = next_buf;
- }
- parse_set_mark (¯o_mark, pfile);
- for (;;)
- {
- cpp_skip_hspace (pfile);
- c = PEEKC ();
- is_macro_call = c == '(';
- if (c != '\n')
- break;
- FORWARD (1);
- }
- if (!is_macro_call)
- parse_goto_mark (¯o_mark, pfile);
- parse_clear_mark (¯o_mark);
- if (!is_macro_call)
- return CPP_NAME;
- }
- /* This is now known to be a macro call. */
-
- /* it might not actually be a macro. */
- if (hp->type != T_MACRO) {
- int xbuf_len; U_CHAR *xbuf;
- CPP_SET_WRITTEN (pfile, before_name_written);
- special_symbol (hp, pfile);
- xbuf_len = CPP_WRITTEN (pfile) - before_name_written;
- xbuf = (U_CHAR *) xmalloc (xbuf_len + 1);
- CPP_SET_WRITTEN (pfile, before_name_written);
- bcopy (CPP_PWRITTEN (pfile), xbuf, xbuf_len + 1);
- push_macro_expansion (pfile, xbuf, xbuf_len, hp);
- }
- else
- {
- /* Expand the macro, reading arguments as needed,
- and push the expansion on the input stack. */
- macroexpand (pfile, hp);
- CPP_SET_WRITTEN (pfile, before_name_written);
- }
-
- /* An extra "@ " is added to the end of a macro expansion
- to prevent accidental token pasting. We prefer to avoid
- unneeded extra spaces (for the sake of cpp-using tools like
- imake). Here we remove the space if it is safe to do so. */
- if (pfile->buffer->rlimit - pfile->buffer->cur >= 3
- && pfile->buffer->rlimit[-2] == '@'
- && pfile->buffer->rlimit[-1] == ' ')
- {
- int c1 = pfile->buffer->rlimit[-3];
- int c2 = CPP_BUF_PEEK (CPP_PREV_BUFFER (CPP_BUFFER (pfile)));
- if (c2 == EOF || ! unsafe_chars (c1, c2))
- pfile->buffer->rlimit -= 2;
- }
- }
- goto get_next;
-
- case ' ': case '\t': case '\v': case '\r':
- for (;;)
- {
- CPP_PUTC (pfile, c);
- c = PEEKC ();
- if (c == EOF || !is_hor_space[c])
- break;
- FORWARD(1);
- }
- return CPP_HSPACE;
+ HASHNODE *hp;
+ unsigned char *ident;
+ int before_name_written = CPP_WRITTEN (pfile);
+ int ident_len;
+ parse_name (pfile, c);
+ pfile->only_seen_white = 0;
+ if (pfile->no_macro_expand)
+ return CPP_NAME;
+ ident = pfile->token_buffer + before_name_written;
+ ident_len = CPP_PWRITTEN (pfile) - ident;
+ hp = cpp_lookup (pfile, ident, ident_len, -1);
+ if (!hp)
+ return CPP_NAME;
+ if (hp->type == T_DISABLED)
+ {
+ if (pfile->output_escapes)
+ { /* Return "@-IDENT", followed by '\0'. */
+ int i;
+ CPP_RESERVE (pfile, 3);
+ ident = pfile->token_buffer + before_name_written;
+ CPP_ADJUST_WRITTEN (pfile, 2);
+ for (i = ident_len; i >= 0; i--) ident[i+2] = ident[i];
+ ident[0] = '@';
+ ident[1] = '-';
+ }
+ return CPP_NAME;
+ }
+
+ /* 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->value.defn->nargs >= 0)
+ {
+ struct parse_marker macro_mark;
+ int is_macro_call;
+ while (CPP_IS_MACRO_BUFFER (CPP_BUFFER (pfile)))
+ {
+ cpp_buffer *next_buf;
+ cpp_skip_hspace (pfile);
+ if (PEEKC () != EOF)
+ break;
+ next_buf = CPP_PREV_BUFFER (CPP_BUFFER (pfile));
+ (*CPP_BUFFER (pfile)->cleanup) (CPP_BUFFER (pfile), pfile);
+ CPP_BUFFER (pfile) = next_buf;
+ }
+ parse_set_mark (¯o_mark, pfile);
+ for (;;)
+ {
+ cpp_skip_hspace (pfile);
+ c = PEEKC ();
+ is_macro_call = c == '(';
+ if (c != '\n')
+ break;
+ FORWARD (1);
+ }
+ if (!is_macro_call)
+ parse_goto_mark (¯o_mark, pfile);
+ parse_clear_mark (¯o_mark);
+ if (!is_macro_call)
+ return CPP_NAME;
+ }
+ /* This is now known to be a macro call. */
+
+ /* it might not actually be a macro. */
+ if (hp->type != T_MACRO) {
+ int xbuf_len; U_CHAR *xbuf;
+ CPP_SET_WRITTEN (pfile, before_name_written);
+ special_symbol (hp, pfile);
+ xbuf_len = CPP_WRITTEN (pfile) - before_name_written;
+ xbuf = (U_CHAR *) Safe_malloc (xbuf_len + 1);
+ CPP_SET_WRITTEN (pfile, before_name_written);
+ bcopy (CPP_PWRITTEN (pfile), xbuf, xbuf_len + 1);
+ push_macro_expansion (pfile, xbuf, xbuf_len, hp);
+ }
+ else
+ {
+ /* Expand the macro, reading arguments as needed,
+ and push the expansion on the input stack. */
+ macroexpand (pfile, hp);
+ CPP_SET_WRITTEN (pfile, before_name_written);
+ }
+
+ /* An extra "@ " is added to the end of a macro expansion
+ to prevent accidental token pasting. We prefer to avoid
+ unneeded extra spaces (for the sake of cpp-using tools like
+ imake). Here we remove the space if it is safe to do so. */
+ if (pfile->buffer->rlimit - pfile->buffer->cur >= 3
+ && pfile->buffer->rlimit[-2] == '@'
+ && pfile->buffer->rlimit[-1] == ' ')
+ {
+ int c1 = pfile->buffer->rlimit[-3];
+ int c2 = CPP_BUF_PEEK (CPP_PREV_BUFFER (CPP_BUFFER (pfile)));
+ if (c2 == EOF || ! unsafe_chars (c1, c2))
+ pfile->buffer->rlimit -= 2;
+ }
+ }
+ goto get_next;
+
+ case ' ': case '\t': case '\v': case '\r':
+ for (;;)
+ {
+ CPP_PUTC (pfile, c);
+ c = PEEKC ();
+ if (c == EOF || !is_hor_space[c])
+ break;
+ FORWARD(1);
+ }
+ return CPP_HSPACE;
case '\\':
- c2 = PEEKC ();
- if (c2 != '\n')
- goto randomchar;
- token = CPP_HSPACE;
- goto op2any;
-
- case '\n':
- CPP_PUTC (pfile, c);
- if (pfile->only_seen_white == 0)
- pfile->only_seen_white = 1;
- pfile->lineno++;
- output_line_command (pfile, 1, same_file);
- return CPP_VSPACE;
-
- case '(': token = CPP_LPAREN; goto char1;
- case ')': token = CPP_RPAREN; goto char1;
- case '{': token = CPP_LBRACE; goto char1;
- case '}': token = CPP_RBRACE; goto char1;
- case ',': token = CPP_COMMA; goto char1;
- case ';': token = CPP_SEMICOLON; goto char1;
-
- randomchar:
- default:
- token = CPP_OTHER;
- char1:
- pfile->only_seen_white = 0;
- CPP_PUTC (pfile, c);
- return token;
- }
+ c2 = PEEKC ();
+ if (c2 != '\n')
+ goto randomchar;
+ token = CPP_HSPACE;
+ goto op2any;
+
+ case '\n':
+ CPP_PUTC (pfile, c);
+ if (pfile->only_seen_white == 0)
+ pfile->only_seen_white = 1;
+ pfile->lineno++;
+ output_line_command (pfile, 1, same_file);
+ return CPP_VSPACE;
+
+ case '(': token = CPP_LPAREN; goto char1;
+ case ')': token = CPP_RPAREN; goto char1;
+ case '{': token = CPP_LBRACE; goto char1;
+ case '}': token = CPP_RBRACE; goto char1;
+ case ',': token = CPP_COMMA; goto char1;
+ case ';': token = CPP_SEMICOLON; goto char1;
+
+ randomchar:
+ default:
+ token = CPP_OTHER;
+ char1:
+ pfile->only_seen_white = 0;
+ CPP_PUTC (pfile, c);
+ return token;
+ }
}
}
{
enum cpp_token token = cpp_get_token (pfile);
if (token != CPP_COMMENT && token != CPP_POP
- && token != CPP_HSPACE && token != CPP_VSPACE)
- return token;
+ && token != CPP_HSPACE && token != CPP_VSPACE)
+ return token;
CPP_SET_WRITTEN (pfile, old_written);
}
}
{
if (! is_idchar[c])
{
- if (c == '\\' && PEEKC() == '\n')
- {
- FORWARD(2);
- continue;
- }
- FORWARD (-1);
- break;
+ if (c == '\\' && PEEKC() == '\n')
+ {
+ FORWARD(2);
+ continue;
+ }
+ FORWARD (-1);
+ break;
}
CPP_RESERVE(pfile, 2); /* One more for final NUL. */
CPP_PUTC_Q (pfile, c);
c = GETC();
if (c == EOF)
- break;
+ break;
}
CPP_NUL_TERMINATE_Q (pfile);
return 1;
/* Hash a file name for import_hash_table. */
-static int
+static int
import_hash (
char *f)
{
while (i) {
if (!strcmp (filename, i->name))
- return -2; /* return found */
+ return -2; /* return found */
i = i->next;
}
/* Open it and try a match on inode/dev */
i = pfile->import_hash_table[h];
while (i) {
/* Compare the inode and the device.
- Supposedly on some systems the inode is not a scalar. */
+ Supposedly on some systems the inode is not a scalar. */
if (!bcmp ((char *) &i->inode, (char *) &sb.st_ino, sizeof (sb.st_ino))
- && i->dev == sb.st_dev) {
+ && i->dev == sb.st_dev) {
close (fd);
- return -2; /* return found */
+ return -2; /* return found */
}
i = i->next;
}
}
- return fd; /* Not found, return open file */
+ return fd; /* Not found, return open file */
}
/* Add the file FNAME, open on descriptor FD, to import_hash_table. */
hashval = import_hash (fname);
fstat (fd, &sb);
- i = (struct import_file *)xmalloc (sizeof (struct import_file));
- i->name = (char *)xmalloc (strlen (fname)+1);
+ i = (struct import_file *)Safe_malloc (sizeof (struct import_file));
+ i->name = (char *)Safe_malloc (strlen (fname)+1);
strcpy (i->name, fname);
bcopy ((char *) &sb.st_ino, (char *) &i->inode, sizeof (sb.st_ino));
i->dev = sb.st_dev;
int len;
len = 20;
- set = alloc = xmalloc (len + 1);
+ set = alloc = Safe_malloc (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;
- }
+ {
+ if (set - alloc == len)
+ {
+ len *= 2;
+ alloc = Safe_realloc(alloc, len + 1);
+ set = alloc + len / 2;
+ }
+ *set++ = ch;
+ }
}
*set = '\0';
ungetc (ch, f);
return map_list_ptr->map_list_map;
map_list_ptr = ((struct file_name_map_list *)
- xmalloc (sizeof (struct file_name_map_list)));
+ Safe_malloc (sizeof (struct file_name_map_list)));
map_list_ptr->map_list_name = savestring (dirname);
map_list_ptr->map_list_map = NULL;
int dirlen = strlen (dirname);
while ((ch = getc (f)) != EOF)
- {
- char *from, *to;
- struct file_name_map *ptr;
-
- 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);
-
- ptr = ((struct file_name_map *)
- xmalloc (sizeof (struct file_name_map)));
- ptr->map_from = from;
-
- /* Make the real filename absolute. */
- if (*to == '/')
- ptr->map_to = to;
- else
- {
- ptr->map_to = xmalloc (dirlen + strlen (to) + 2);
- strcpy (ptr->map_to, dirname);
- ptr->map_to[dirlen] = '/';
- strcpy (ptr->map_to + dirlen + 1, 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;
- }
+ {
+ char *from, *to;
+ struct file_name_map *ptr;
+
+ 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);
+
+ ptr = ((struct file_name_map *)
+ Safe_malloc (sizeof (struct file_name_map)));
+ ptr->map_from = from;
+
+ /* Make the real filename absolute. */
+ if (*to == '/')
+ ptr->map_to = to;
+ else
+ {
+ ptr->map_to = Safe_malloc (dirlen + strlen (to) + 2);
+ strcpy (ptr->map_to, dirname);
+ ptr->map_to[dirlen] = '/';
+ strcpy (ptr->map_to + dirlen + 1, to);
+ Safe_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 = CPP_OPTIONS (pfile)->map_list;
CPP_OPTIONS (pfile)->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. This function maps
if (searchptr && ! searchptr->got_name_map)
{
searchptr->name_map = read_name_map (pfile,
- searchptr->fname
- ? searchptr->fname : ".");
+ searchptr->fname
+ ? searchptr->fname : ".");
searchptr->got_name_map = 1;
}
{
from = filename;
if (searchptr->fname)
- from += strlen (searchptr->fname) + 1;
+ from += strlen (searchptr->fname) + 1;
for (map = searchptr->name_map; map; map = map->map_next)
- {
- if (! strcmp (map->map_from, from))
- {
- /* Found a match. */
- return open (map->map_to, O_RDONLY, 0666);
- }
- }
+ {
+ if (! strcmp (map->map_from, from))
+ {
+ /* Found a match. */
+ return open (map->map_to, O_RDONLY, 0666);
+ }
+ }
}
/* Try to find a mapping file for the particular directory we are
p = filename;
if (searchptr
&& searchptr->fname
- && strlen (searchptr->fname) == p - filename
+ && (int) strlen (searchptr->fname) == p - filename
&& ! strncmp (searchptr->fname, filename, p - filename))
{
/* FILENAME is in SEARCHPTR, which we've already checked. */
long st_size;
long i;
int length;
- cpp_buffer *fp; /* For input stack frame */
- int missing_newline = 0;
+ cpp_buffer *fp; /* For input stack frame */
+ /* int missing_newline = 0; # KILL */
if (file_size_and_mode (f, &st_mode, &st_size) < 0)
{
fp->cleanup = file_cleanup;
if (S_ISREG (st_mode)) {
- fp->buf = (U_CHAR *) xmalloc (st_size + 2);
+ fp->buf = (U_CHAR *) Safe_malloc (st_size + 2);
fp->alimit = fp->buf + st_size + 2;
fp->cur = fp->buf;
int bsize = 2000;
st_size = 0;
- fp->buf = (U_CHAR *) xmalloc (bsize + 2);
+ fp->buf = (U_CHAR *) Safe_malloc (bsize + 2);
for (;;) {
i = safe_read (f, fp->buf + st_size, bsize - st_size);
if (i < 0)
- goto nope; /* error! */
+ goto nope; /* error! */
st_size += i;
if (st_size != bsize)
- break; /* End of file */
+ break; /* End of file */
bsize *= 2;
- fp->buf = (U_CHAR *) xrealloc (fp->buf, bsize + 2);
+ fp->buf = (U_CHAR *) Safe_realloc(fp->buf, bsize + 2);
}
fp->cur = fp->buf;
length = st_size;
indepth--;
input_file_stack_tick++;
- free (fp->buf);
+ Safe_free (fp->buf);
#endif
return 1;
cpp_perror_with_name (pfile, fname);
close (f);
- free (fp->buf);
+ Safe_free (fp->buf);
return 1;
}
while (*p) {
char *q;
while (*p == ' ' || *p == '\t')
- p++;
- /* Handle -D options. */
+ p++;
+ /* Handle -D options. */
if (p[0] == '-' && p[1] == 'D') {
- q = &p[2];
- while (*p && *p != ' ' && *p != '\t')
- p++;
- if (*p != 0)
- *p++= 0;
- if (opts->debug_output)
- output_line_command (pfile, 0, same_file);
- cpp_define (pfile, q);
- while (*p == ' ' || *p == '\t')
- p++;
+ q = &p[2];
+ while (*p && *p != ' ' && *p != '\t')
+ p++;
+ if (*p != 0)
+ *p++= 0;
+ if (opts->debug_output)
+ output_line_command (pfile, 0, same_file);
+ cpp_define (pfile, q);
+ while (*p == ' ' || *p == '\t')
+ p++;
} else if (p[0] == '-' && p[1] == 'A') {
- /* Handle -A options (assertions). */
- char *assertion;
- char *past_name;
- char *value;
- char *past_value;
- char *termination;
- int save_char;
-
- assertion = &p[2];
- past_name = assertion;
- /* Locate end of name. */
- while (*past_name && *past_name != ' '
- && *past_name != '\t' && *past_name != '(')
- past_name++;
- /* Locate `(' at start of value. */
- value = past_name;
- while (*value && (*value == ' ' || *value == '\t'))
- value++;
- if (*value++ != '(')
- abort ();
- while (*value && (*value == ' ' || *value == '\t'))
- value++;
- past_value = value;
- /* Locate end of value. */
- while (*past_value && *past_value != ' '
- && *past_value != '\t' && *past_value != ')')
- past_value++;
- termination = past_value;
- while (*termination && (*termination == ' ' || *termination == '\t'))
- termination++;
- if (*termination++ != ')')
- abort ();
- if (*termination && *termination != ' ' && *termination != '\t')
- abort ();
- /* Temporarily null-terminate the value. */
- save_char = *termination;
- *termination = '\0';
- /* Install the assertion. */
- make_assertion (pfile, "-A", assertion);
- *termination = (char) save_char;
- p = termination;
- while (*p == ' ' || *p == '\t')
- p++;
+ /* Handle -A options (assertions). */
+ char *assertion;
+ char *past_name;
+ char *value;
+ char *past_value;
+ char *termination;
+ int save_char;
+
+ assertion = &p[2];
+ past_name = assertion;
+ /* Locate end of name. */
+ while (*past_name && *past_name != ' '
+ && *past_name != '\t' && *past_name != '(')
+ past_name++;
+ /* Locate `(' at start of value. */
+ value = past_name;
+ while (*value && (*value == ' ' || *value == '\t'))
+ value++;
+ if (*value++ != '(')
+ abort ();
+ while (*value && (*value == ' ' || *value == '\t'))
+ value++;
+ past_value = value;
+ /* Locate end of value. */
+ while (*past_value && *past_value != ' '
+ && *past_value != '\t' && *past_value != ')')
+ past_value++;
+ termination = past_value;
+ while (*termination && (*termination == ' ' || *termination == '\t'))
+ termination++;
+ if (*termination++ != ')')
+ abort ();
+ if (*termination && *termination != ' ' && *termination != '\t')
+ abort ();
+ /* Temporarily null-terminate the value. */
+ save_char = *termination;
+ *termination = '\0';
+ /* Install the assertion. */
+ make_assertion (pfile, "-A", assertion);
+ *termination = (char) save_char;
+ p = termination;
+ while (*p == ' ' || *p == '\t')
+ p++;
} else {
- abort ();
+ abort ();
}
}
}
for (pend = opts->pending; pend; pend = pend->next)
{
if (pend->cmd != NULL && pend->cmd[0] == '-')
- {
- switch (pend->cmd[1])
- {
- case 'U':
- if (opts->debug_output)
- output_line_command (pfile, 0, same_file);
- do_undef (pfile, NULL, pend->arg, pend->arg + strlen (pend->arg));
- break;
- case 'D':
- if (opts->debug_output)
- output_line_command (pfile, 0, same_file);
- cpp_define (pfile, pend->arg);
- break;
- case 'A':
- make_assertion (pfile, "-A", pend->arg);
- break;
- }
- }
+ {
+ switch (pend->cmd[1])
+ {
+ case 'U':
+ if (opts->debug_output)
+ output_line_command (pfile, 0, same_file);
+ do_undef (pfile, NULL, pend->arg, pend->arg + strlen (pend->arg));
+ break;
+ case 'D':
+ if (opts->debug_output)
+ output_line_command (pfile, 0, same_file);
+ cpp_define (pfile, pend->arg);
+ break;
+ case 'A':
+ make_assertion (pfile, "-A", pend->arg);
+ break;
+ }
+ }
}
opts->done_initializing = 1;
switch ((opts->objc << 1) + opts->cplusplus)
{
case 0:
- epath = getenv ("C_INCLUDE_PATH");
- break;
+ epath = getenv ("C_INCLUDE_PATH");
+ break;
case 1:
- epath = getenv ("CPLUS_INCLUDE_PATH");
- break;
+ epath = getenv ("CPLUS_INCLUDE_PATH");
+ break;
case 2:
- epath = getenv ("OBJC_INCLUDE_PATH");
- break;
+ epath = getenv ("OBJC_INCLUDE_PATH");
+ break;
case 3:
- epath = getenv ("OBJCPLUS_INCLUDE_PATH");
- break;
+ epath = getenv ("OBJCPLUS_INCLUDE_PATH");
+ break;
}
/* If the environment var for this language is set,
add to the default list of include directories. */
char *startp, *endp;
for (num_dirs = 1, startp = epath; *startp; startp++)
- if (*startp == PATH_SEPARATOR)
- num_dirs++;
+ if (*startp == PATH_SEPARATOR)
+ num_dirs++;
include_defaults
- = (struct default_include *) xmalloc ((num_dirs
- * sizeof (struct default_include))
- + sizeof (include_defaults_array));
+ = (struct default_include *) Safe_malloc ((num_dirs
+ * sizeof (struct default_include))
+ + sizeof (include_defaults_array));
startp = endp = epath;
num_dirs = 0;
while (1) {
/* Handle cases like c:/usr/lib:d:/gcc/lib */
if ((*endp == PATH_SEPARATOR)
|| *endp == 0) {
- strncpy (nstore, startp, endp-startp);
- if (endp == startp)
- strcpy (nstore, ".");
- else
- nstore[endp-startp] = '\0';
-
- include_defaults[num_dirs].fname = savestring (nstore);
- include_defaults[num_dirs].cplusplus = opts->cplusplus;
- include_defaults[num_dirs].cxx_aware = 1;
- num_dirs++;
- if (*endp == '\0')
- break;
- endp = startp = endp + 1;
- } else
- endp++;
+ strncpy (nstore, startp, endp-startp);
+ if (endp == startp)
+ strcpy (nstore, ".");
+ else
+ nstore[endp-startp] = '\0';
+
+ include_defaults[num_dirs].fname = savestring (nstore);
+ include_defaults[num_dirs].cplusplus = opts->cplusplus;
+ include_defaults[num_dirs].cxx_aware = 1;
+ num_dirs++;
+ if (*endp == '\0')
+ break;
+ endp = startp = endp + 1;
+ } else
+ endp++;
}
/* Put the usual defaults back in at the end. */
bcopy ((char *) include_defaults_array,
- (char *) &include_defaults[num_dirs],
- sizeof (include_defaults_array));
+ (char *) &include_defaults[num_dirs],
+ sizeof (include_defaults_array));
}
}
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
- || (opts->cplusplus && !opts->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
- = (struct file_name_list *) xmalloc (sizeof (struct file_name_list));
- int this_len = strlen (specd_prefix) + strlen (p->fname) - default_len;
- char *str = (char *) xmalloc (this_len + 1);
- strcpy (str, specd_prefix);
- strcat (str, p->fname + default_len);
- new->fname = str;
- new->control_macro = 0;
- new->c_system_include_path = !p->cxx_aware;
- new->got_name_map = 0;
- append_include_chain (pfile, new, new);
- if (opts->first_system_include == 0)
- opts->first_system_include = new;
- }
- }
+ /* Some standard dirs are only for C++. */
+ if (!p->cplusplus
+ || (opts->cplusplus && !opts->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
+ = (struct file_name_list *) Safe_malloc (sizeof (struct file_name_list));
+ int this_len = strlen (specd_prefix) + strlen (p->fname) - default_len;
+ char *str = (char *) Safe_malloc (this_len + 1);
+ strcpy (str, specd_prefix);
+ strcat (str, p->fname + default_len);
+ new->fname = str;
+ new->control_macro = 0;
+ new->c_system_include_path = !p->cxx_aware;
+ new->got_name_map = 0;
+ append_include_chain (pfile, new, new);
+ if (opts->first_system_include == 0)
+ opts->first_system_include = new;
+ }
+ }
}
/* Search ordinary names for GNU include directories. */
for (p = include_defaults; p->fname; p++) {
/* Some standard dirs are only for C++. */
if (!p->cplusplus
- || (opts->cplusplus && !opts->no_standard_cplusplus_includes)) {
- struct file_name_list *new
- = (struct file_name_list *) xmalloc (sizeof (struct file_name_list));
- new->control_macro = 0;
- new->c_system_include_path = !p->cxx_aware;
- new->fname = p->fname;
- new->got_name_map = 0;
- append_include_chain (pfile, new, new);
- if (opts->first_system_include == 0)
- opts->first_system_include = new;
+ || (opts->cplusplus && !opts->no_standard_cplusplus_includes)) {
+ struct file_name_list *new
+ = (struct file_name_list *) Safe_malloc (sizeof (struct file_name_list));
+ new->control_macro = 0;
+ new->c_system_include_path = !p->cxx_aware;
+ new->fname = p->fname;
+ new->got_name_map = 0;
+ append_include_chain (pfile, new, new);
+ if (opts->first_system_include == 0)
+ opts->first_system_include = new;
}
}
}
fprintf (stderr, "#include \"...\" search starts here:\n");
for (p = opts->include; p; p = p->next) {
if (p == opts->first_bracket_include)
- fprintf (stderr, "#include <...> search starts here:\n");
+ fprintf (stderr, "#include <...> search starts here:\n");
fprintf (stderr, " %s\n", p->fname);
}
fprintf (stderr, "End of search list.\n");
for (pend = opts->pending; pend; pend = pend->next)
{
if (pend->cmd != NULL && strcmp (pend->cmd, "-imacros") == 0)
- {
- int fd = open (pend->arg, O_RDONLY, 0666);
- if (fd < 0)
- {
- cpp_perror_with_name (pfile, pend->arg);
- return FATAL_EXIT_CODE;
- }
- cpp_push_buffer (pfile, NULL, 0);
- finclude (pfile, fd, pend->arg, 0, NULL_PTR);
- cpp_scan_buffer (pfile);
- }
+ {
+ int fd = open (pend->arg, O_RDONLY, 0666);
+ if (fd < 0)
+ {
+ cpp_perror_with_name (pfile, pend->arg);
+ return FATAL_EXIT_CODE;
+ }
+ cpp_push_buffer (pfile, NULL, 0);
+ finclude (pfile, fd, pend->arg, 0, NULL_PTR);
+ cpp_scan_buffer (pfile);
+ }
}
opts->no_output--; pfile->no_record_file--;
if (opts->print_deps == 0
&& (getenv ("SUNPRO_DEPENDENCIES") != 0
- || getenv ("DEPENDENCIES_OUTPUT") != 0)) {
+ || getenv ("DEPENDENCIES_OUTPUT") != 0)) {
char *spec = getenv ("DEPENDENCIES_OUTPUT");
char *s;
char *output_file;
if (spec == 0)
{
- spec = getenv ("SUNPRO_DEPENDENCIES");
- opts->print_deps = 2;
+ spec = getenv ("SUNPRO_DEPENDENCIES");
+ opts->print_deps = 2;
}
else
opts->print_deps = 1;
while (*s != 0 && *s != ' ') s++;
if (*s != 0)
{
- opts->deps_target = s + 1;
- output_file = (char *) xmalloc (s - spec + 1);
- bcopy (spec, output_file, s - spec);
- output_file[s - spec] = 0;
+ opts->deps_target = s + 1;
+ output_file = (char *) Safe_malloc (s - spec + 1);
+ bcopy (spec, output_file, s - spec);
+ output_file[s - spec] = 0;
}
else
{
- opts->deps_target = 0;
- output_file = spec;
+ opts->deps_target = 0;
+ output_file = spec;
}
opts->deps_file = output_file;
if (opts->print_deps)
{
pfile->deps_allocated_size = 200;
- pfile->deps_buffer = (char *) xmalloc (pfile->deps_allocated_size);
+ pfile->deps_buffer = (char *) Safe_malloc (pfile->deps_allocated_size);
pfile->deps_buffer[0] = 0;
pfile->deps_size = 0;
pfile->deps_column = 0;
if (opts->deps_target)
- deps_output (pfile, opts->deps_target, ':');
+ deps_output (pfile, opts->deps_target, ':');
else if (*opts->in_fname == 0)
- deps_output (pfile, "-", ':');
+ deps_output (pfile, "-", ':');
else
- {
- char *p, *q;
- int len;
+ {
+ char *p, *q;
+ int len;
- /* Discard all directory prefixes from filename. */
- if ((q = rindex (opts->in_fname, '/')) != NULL
+ /* Discard all directory prefixes from filename. */
+ if ((q = rindex (opts->in_fname, '/')) != NULL
#ifdef DIR_SEPARATOR
- && (q = rindex (opts->in_fname, DIR_SEPARATOR)) != NULL
+ && (q = rindex (opts->in_fname, DIR_SEPARATOR)) != NULL
#endif
- )
- ++q;
- else
- q = opts->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. */
+ )
+ ++q;
+ else
+ q = opts->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. */
#ifndef VMS
#ifdef _FORASXXXX_
strcpy (q,".rel");
#else
- strcpy (q, ".o");
+ strcpy (q, ".o");
#endif
#else
- strcpy (q, ".obj");
+ strcpy (q, ".obj");
#endif
- deps_output (pfile, p, ':');
- deps_output (pfile, opts->in_fname, ' ');
- }
+ deps_output (pfile, p, ':');
+ deps_output (pfile, opts->in_fname, ' ');
+ }
}
#if 0
for (pend = opts->pending; pend; pend = pend->next)
{
if (pend->cmd != NULL && strcmp (pend->cmd, "-include") == 0)
- {
- int fd = open (pend->arg, O_RDONLY, 0666);
- if (fd < 0)
- {
- cpp_perror_with_name (pfile, pend->arg);
- return FATAL_EXIT_CODE;
- }
- cpp_push_buffer (pfile, NULL, 0);
- finclude (pfile, fd, pend->arg, 0, NULL_PTR);
- }
+ {
+ int fd = open (pend->arg, O_RDONLY, 0666);
+ if (fd < 0)
+ {
+ cpp_perror_with_name (pfile, pend->arg);
+ return FATAL_EXIT_CODE;
+ }
+ cpp_push_buffer (pfile, NULL, 0);
+ finclude (pfile, fd, pend->arg, 0, NULL_PTR);
+ }
}
pfile->no_record_file--;
for (pend = opts->pending; pend; )
{
struct cpp_pending *next = pend->next;
- free (pend);
+ Safe_free (pend);
pend = next;
}
opts->pending = NULL;
pfile->get_token = cpp_get_token;
pfile->token_buffer_size = 200;
- pfile->token_buffer = (U_CHAR*)xmalloc (pfile->token_buffer_size);
+ pfile->token_buffer = (U_CHAR*)Safe_malloc (pfile->token_buffer_size);
CPP_SET_WRITTEN (pfile, 0);
pfile->system_include_depth = 0;
static struct cpp_pending *
nreverse_pending (
struct cpp_pending *list)
-
+
{
register struct cpp_pending *prev = 0, *next, *pend;
for (pend = list; pend; pend = next)
char *arg)
{
struct cpp_pending *pend
- = (struct cpp_pending*)xmalloc (sizeof (struct cpp_pending));
+ = (struct cpp_pending*)Safe_malloc (sizeof (struct cpp_pending));
pend->cmd = cmd;
pend->arg = arg;
pend->next = CPP_OPTIONS (pfile)->pending;
int argc,
char **argv)
{
- int i;
- struct cpp_options *opts = CPP_OPTIONS (pfile);
- for (i = 0; i < argc; i++) {
- if (argv[i][0] != '-') {
- if (opts->out_fname != NULL)
- fatal ("Usage: %s [switches] input output", argv[0]);
- else if (opts->in_fname != NULL)
- opts->out_fname = argv[i];
- else
- opts->in_fname = argv[i];
- } else {
- switch (argv[i][1]) {
-
- case 'i':
- if (!strcmp (argv[i], "-include")
- || !strcmp (argv[i], "-imacros")) {
- if (i + 1 == argc)
- fatal ("Filename missing after `%s' option", argv[i]);
- else
- push_pending (pfile, argv[i], argv[i+1]), i++;
- }
- if (!strcmp (argv[i], "-iprefix")) {
- if (i + 1 == argc)
- fatal ("Filename missing after `-iprefix' option");
- else
- opts->include_prefix = argv[++i];
- }
- if (!strcmp (argv[i], "-ifoutput")) {
- opts->output_conditionals = 1;
- }
- if (!strcmp (argv[i], "-isystem")) {
- struct file_name_list *dirtmp;
-
- if (i + 1 == argc)
- fatal ("Filename missing after `-isystem' option");
-
- dirtmp = (struct file_name_list *)
- xmalloc (sizeof (struct file_name_list));
- dirtmp->next = 0;
- dirtmp->control_macro = 0;
- dirtmp->c_system_include_path = 1;
- dirtmp->fname = (char *) xmalloc (strlen (argv[i+1]) + 1);
- strcpy (dirtmp->fname, argv[++i]);
- dirtmp->got_name_map = 0;
-
- if (opts->before_system == 0)
- opts->before_system = dirtmp;
- else
- opts->last_before_system->next = dirtmp;
- opts->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 (opts->include_prefix != 0)
- prefix = opts->include_prefix;
- else {
- prefix = savestring (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 = (struct file_name_list *)
- xmalloc (sizeof (struct file_name_list));
- dirtmp->next = 0; /* New one goes on the end */
- dirtmp->control_macro = 0;
- dirtmp->c_system_include_path = 0;
- if (i + 1 == argc)
- fatal ("Directory name missing after `-iwithprefix' option");
-
- dirtmp->fname = (char *) xmalloc (strlen (argv[i+1])
- + strlen (prefix) + 1);
- strcpy (dirtmp->fname, prefix);
- strcat (dirtmp->fname, argv[++i]);
- dirtmp->got_name_map = 0;
-
- if (opts->after_include == 0)
- opts->after_include = dirtmp;
- else
- opts->last_after_include->next = dirtmp;
- opts->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 (opts->include_prefix != 0)
- prefix = opts->include_prefix;
- else {
- prefix = savestring (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 = (struct file_name_list *)
- xmalloc (sizeof (struct file_name_list));
- dirtmp->next = 0; /* New one goes on the end */
- dirtmp->control_macro = 0;
- dirtmp->c_system_include_path = 0;
- if (i + 1 == argc)
- fatal ("Directory name missing after `-iwithprefixbefore' option");
-
- dirtmp->fname = (char *) xmalloc (strlen (argv[i+1])
- + strlen (prefix) + 1);
- strcpy (dirtmp->fname, prefix);
- strcat (dirtmp->fname, argv[++i]);
- dirtmp->got_name_map = 0;
-
- append_include_chain (pfile, dirtmp, dirtmp);
- }
- /* Add directory to end of path for includes. */
- if (!strcmp (argv[i], "-idirafter")) {
- struct file_name_list *dirtmp;
-
- dirtmp = (struct file_name_list *)
- xmalloc (sizeof (struct file_name_list));
- dirtmp->next = 0; /* New one goes on the end */
- dirtmp->control_macro = 0;
- dirtmp->c_system_include_path = 0;
- if (i + 1 == argc)
- fatal ("Directory name missing after `-idirafter' option");
- else
- dirtmp->fname = argv[++i];
- dirtmp->got_name_map = 0;
-
- if (opts->after_include == 0)
- opts->after_include = dirtmp;
- else
- opts->last_after_include->next = dirtmp;
- opts->last_after_include = dirtmp; /* Tail follows the last one */
- }
- break;
-
- case 'o':
- if (opts->out_fname != NULL)
- fatal ("Output filename specified twice");
- if (i + 1 == argc)
- fatal ("Filename missing after -o option");
- opts->out_fname = argv[++i];
- if (!strcmp (opts->out_fname, "-"))
- opts->out_fname = "";
- break;
-
- case 'p':
- if (!strcmp (argv[i], "-pedantic"))
- CPP_PEDANTIC (pfile) = 1;
- else if (!strcmp (argv[i], "-pedantic-errors")) {
- CPP_PEDANTIC (pfile) = 1;
- opts->pedantic_errors = 1;
- }
+ int i;
+ struct cpp_options *opts = CPP_OPTIONS (pfile);
+ for (i = 0; i < argc; i++) {
+ if (argv[i][0] != '-') {
+ if (opts->out_fname != NULL)
+ fatal ("Usage: %s [switches] input output", argv[0]);
+ else if (opts->in_fname != NULL)
+ opts->out_fname = argv[i];
+ else
+ opts->in_fname = argv[i];
+ } else {
+ switch (argv[i][1]) {
+
+ case 'i':
+ if (!strcmp (argv[i], "-include")
+ || !strcmp (argv[i], "-imacros")) {
+ if (i + 1 == argc)
+ fatal ("Filename missing after `%s' option", argv[i]);
+ else
+ push_pending (pfile, argv[i], argv[i+1]), i++;
+ }
+ if (!strcmp (argv[i], "-iprefix")) {
+ if (i + 1 == argc)
+ fatal ("Filename missing after `-iprefix' option");
+ else
+ opts->include_prefix = argv[++i];
+ }
+ if (!strcmp (argv[i], "-ifoutput")) {
+ opts->output_conditionals = 1;
+ }
+ if (!strcmp (argv[i], "-isystem")) {
+ struct file_name_list *dirtmp;
+
+ if (i + 1 == argc)
+ fatal ("Filename missing after `-isystem' option");
+
+ dirtmp = (struct file_name_list *)
+ Safe_malloc (sizeof (struct file_name_list));
+ dirtmp->next = 0;
+ dirtmp->control_macro = 0;
+ dirtmp->c_system_include_path = 1;
+ dirtmp->fname = (char *) Safe_malloc (strlen (argv[i+1]) + 1);
+ strcpy (dirtmp->fname, argv[++i]);
+ dirtmp->got_name_map = 0;
+
+ if (opts->before_system == 0)
+ opts->before_system = dirtmp;
+ else
+ opts->last_before_system->next = dirtmp;
+ opts->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 (opts->include_prefix != 0)
+ prefix = opts->include_prefix;
+ else {
+ prefix = savestring (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 = (struct file_name_list *)
+ Safe_malloc (sizeof (struct file_name_list));
+ dirtmp->next = 0; /* New one goes on the end */
+ dirtmp->control_macro = 0;
+ dirtmp->c_system_include_path = 0;
+ if (i + 1 == argc)
+ fatal ("Directory name missing after `-iwithprefix' option");
+
+ dirtmp->fname = (char *) Safe_malloc (strlen (argv[i+1])
+ + strlen (prefix) + 1);
+ strcpy (dirtmp->fname, prefix);
+ strcat (dirtmp->fname, argv[++i]);
+ dirtmp->got_name_map = 0;
+
+ if (opts->after_include == 0)
+ opts->after_include = dirtmp;
+ else
+ opts->last_after_include->next = dirtmp;
+ opts->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 (opts->include_prefix != 0)
+ prefix = opts->include_prefix;
+ else {
+ prefix = savestring (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 = (struct file_name_list *)
+ Safe_malloc (sizeof (struct file_name_list));
+ dirtmp->next = 0; /* New one goes on the end */
+ dirtmp->control_macro = 0;
+ dirtmp->c_system_include_path = 0;
+ if (i + 1 == argc)
+ fatal ("Directory name missing after `-iwithprefixbefore' option");
+
+ dirtmp->fname = (char *) Safe_malloc (strlen (argv[i+1])
+ + strlen (prefix) + 1);
+ strcpy (dirtmp->fname, prefix);
+ strcat (dirtmp->fname, argv[++i]);
+ dirtmp->got_name_map = 0;
+
+ append_include_chain (pfile, dirtmp, dirtmp);
+ }
+ /* Add directory to end of path for includes. */
+ if (!strcmp (argv[i], "-idirafter")) {
+ struct file_name_list *dirtmp;
+
+ dirtmp = (struct file_name_list *)
+ Safe_malloc (sizeof (struct file_name_list));
+ dirtmp->next = 0; /* New one goes on the end */
+ dirtmp->control_macro = 0;
+ dirtmp->c_system_include_path = 0;
+ if (i + 1 == argc)
+ fatal ("Directory name missing after `-idirafter' option");
+ else
+ dirtmp->fname = argv[++i];
+ dirtmp->got_name_map = 0;
+
+ if (opts->after_include == 0)
+ opts->after_include = dirtmp;
+ else
+ opts->last_after_include->next = dirtmp;
+ opts->last_after_include = dirtmp; /* Tail follows the last one */
+ }
+ break;
+
+ case 'o':
+ if (opts->out_fname != NULL)
+ fatal ("Output filename specified twice");
+ if (i + 1 == argc)
+ fatal ("Filename missing after -o option");
+ opts->out_fname = argv[++i];
+ if (!strcmp (opts->out_fname, "-"))
+ opts->out_fname = "";
+ break;
+
+ case 'p':
+ if (!strcmp (argv[i], "-pedantic"))
+ CPP_PEDANTIC (pfile) = 1;
+ else if (!strcmp (argv[i], "-pedantic-errors")) {
+ CPP_PEDANTIC (pfile) = 1;
+ opts->pedantic_errors = 1;
+ }
#if 0
- else if (!strcmp (argv[i], "-pcp")) {
- char *pcp_fname = argv[++i];
- pcp_outfile =
- ((pcp_fname[0] != '-' || pcp_fname[1] != '\0')
- ? fopen (pcp_fname, "w")
- : fdopen (dup (fileno (stdout)), "w"));
- if (pcp_outfile == 0)
- cpp_pfatal_with_name (pfile, pcp_fname);
- no_precomp = 1;
- }
+ else if (!strcmp (argv[i], "-pcp")) {
+ char *pcp_fname = argv[++i];
+ pcp_outfile =
+ ((pcp_fname[0] != '-' || pcp_fname[1] != '\0')
+ ? fopen (pcp_fname, "w")
+ : fdopen (dup (fileno (stdout)), "w"));
+ if (pcp_outfile == 0)
+ cpp_pfatal_with_name (pfile, pcp_fname);
+ no_precomp = 1;
+ }
#endif
- break;
-
- case 't':
- if (!strcmp (argv[i], "-traditional")) {
- opts->traditional = 1;
- if (opts->dollars_in_ident > 0)
- opts->dollars_in_ident = 1;
- } else if (!strcmp (argv[i], "-trigraphs")) {
- if (!opts->chill)
- opts->no_trigraphs = 0;
- }
- break;
-
- case 'l':
- if (! strcmp (argv[i], "-lang-c"))
- opts->cplusplus = 0, opts->cplusplus_comments = 0, opts->objc = 0;
- if (! strcmp (argv[i], "-lang-c++"))
- opts->cplusplus = 1, opts->cplusplus_comments = 1, opts->objc = 0;
- if (! strcmp (argv[i], "-lang-c-c++-comments"))
- opts->cplusplus = 0, opts->cplusplus_comments = 1, opts->objc = 0;
- if (! strcmp (argv[i], "-lang-objc"))
- opts->objc = 1, opts->cplusplus = 0, opts->cplusplus_comments = 1;
- if (! strcmp (argv[i], "-lang-objc++"))
- opts->objc = 1, opts->cplusplus = 1, opts->cplusplus_comments = 1;
- if (! strcmp (argv[i], "-lang-asm"))
- opts->lang_asm = 1;
- if (! strcmp (argv[i], "-lint"))
- opts->for_lint = 1;
- if (! strcmp (argv[i], "-lang-chill"))
- opts->objc = 0, opts->cplusplus = 0, opts->chill = 1,
- opts->traditional = 1, opts->no_trigraphs = 1;
- break;
-
- case '+':
- opts->cplusplus = 1, opts->cplusplus_comments = 1;
- break;
-
- case 'w':
- opts->inhibit_warnings = 1;
- break;
-
- case 'W':
- if (!strcmp (argv[i], "-Wtrigraphs"))
- opts->warn_trigraphs = 1;
- else if (!strcmp (argv[i], "-Wno-trigraphs"))
- opts->warn_trigraphs = 0;
- else if (!strcmp (argv[i], "-Wcomment"))
- opts->warn_comments = 1;
- else if (!strcmp (argv[i], "-Wno-comment"))
- opts->warn_comments = 0;
- else if (!strcmp (argv[i], "-Wcomments"))
- opts->warn_comments = 1;
- else if (!strcmp (argv[i], "-Wno-comments"))
- opts->warn_comments = 0;
- else if (!strcmp (argv[i], "-Wtraditional"))
- opts->warn_stringify = 1;
- else if (!strcmp (argv[i], "-Wno-traditional"))
- opts->warn_stringify = 0;
- else if (!strcmp (argv[i], "-Wimport"))
- opts->warn_import = 1;
- else if (!strcmp (argv[i], "-Wno-import"))
- opts->warn_import = 0;
- else if (!strcmp (argv[i], "-Werror"))
- opts->warnings_are_errors = 1;
- else if (!strcmp (argv[i], "-Wno-error"))
- opts->warnings_are_errors = 0;
- else if (!strcmp (argv[i], "-Wall"))
- {
- opts->warn_trigraphs = 1;
- opts->warn_comments = 1;
- }
- 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"))
- {
- opts->print_deps_missing_files = 1;
- break;
- }
- if (!strcmp (argv[i], "-M"))
- opts->print_deps = 2;
- else if (!strcmp (argv[i], "-MM"))
- opts->print_deps = 1;
- else if (!strcmp (argv[i], "-MD"))
- opts->print_deps = 2;
- else if (!strcmp (argv[i], "-MMD"))
- opts->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]);
- opts->deps_file = argv[++i];
- }
- else
- {
- /* For -M and -MM, write deps on standard output
- and suppress the usual output. */
- opts->no_output = 1;
- }
- break;
-
- case 'd':
- {
- char *p = argv[i] + 2;
- char c;
- while ((c = *p++) != 0) {
- /* Arg to -d specifies what parts of macros to dump */
- switch (c) {
- case 'M':
- opts->dump_macros = dump_only;
- opts->no_output = 1;
- break;
- case 'N':
- opts->dump_macros = dump_names;
- break;
- case 'D':
- opts->dump_macros = dump_definitions;
- break;
- }
- }
- }
- break;
-
- case 'g':
- if (argv[i][2] == '3')
- opts->debug_output = 1;
- break;
-
- case 'v':
- fprintf (stderr, "GNU CPP version %s", version_string);
+ break;
+
+ case 't':
+ if (!strcmp (argv[i], "-traditional")) {
+ opts->traditional = 1;
+ if (opts->dollars_in_ident > 0)
+ opts->dollars_in_ident = 1;
+ } else if (!strcmp (argv[i], "-trigraphs")) {
+ if (!opts->chill)
+ opts->no_trigraphs = 0;
+ }
+ break;
+
+ case 'l':
+ if (! strcmp (argv[i], "-lang-c"))
+ opts->cplusplus = 0, opts->cplusplus_comments = 0, opts->objc = 0;
+ if (! strcmp (argv[i], "-lang-c++"))
+ opts->cplusplus = 1, opts->cplusplus_comments = 1, opts->objc = 0;
+ if (! strcmp (argv[i], "-lang-c-c++-comments"))
+ opts->cplusplus = 0, opts->cplusplus_comments = 1, opts->objc = 0;
+ if (! strcmp (argv[i], "-lang-objc"))
+ opts->objc = 1, opts->cplusplus = 0, opts->cplusplus_comments = 1;
+ if (! strcmp (argv[i], "-lang-objc++"))
+ opts->objc = 1, opts->cplusplus = 1, opts->cplusplus_comments = 1;
+ if (! strcmp (argv[i], "-lang-asm"))
+ opts->lang_asm = 1;
+ if (! strcmp (argv[i], "-lint"))
+ opts->for_lint = 1;
+ if (! strcmp (argv[i], "-lang-chill"))
+ opts->objc = 0, opts->cplusplus = 0, opts->chill = 1,
+ opts->traditional = 1, opts->no_trigraphs = 1;
+ break;
+
+ case '+':
+ opts->cplusplus = 1, opts->cplusplus_comments = 1;
+ break;
+
+ case 'w':
+ opts->inhibit_warnings = 1;
+ break;
+
+ case 'W':
+ if (!strcmp (argv[i], "-Wtrigraphs"))
+ opts->warn_trigraphs = 1;
+ else if (!strcmp (argv[i], "-Wno-trigraphs"))
+ opts->warn_trigraphs = 0;
+ else if (!strcmp (argv[i], "-Wcomment"))
+ opts->warn_comments = 1;
+ else if (!strcmp (argv[i], "-Wno-comment"))
+ opts->warn_comments = 0;
+ else if (!strcmp (argv[i], "-Wcomments"))
+ opts->warn_comments = 1;
+ else if (!strcmp (argv[i], "-Wno-comments"))
+ opts->warn_comments = 0;
+ else if (!strcmp (argv[i], "-Wtraditional"))
+ opts->warn_stringify = 1;
+ else if (!strcmp (argv[i], "-Wno-traditional"))
+ opts->warn_stringify = 0;
+ else if (!strcmp (argv[i], "-Wimport"))
+ opts->warn_import = 1;
+ else if (!strcmp (argv[i], "-Wno-import"))
+ opts->warn_import = 0;
+ else if (!strcmp (argv[i], "-Werror"))
+ opts->warnings_are_errors = 1;
+ else if (!strcmp (argv[i], "-Wno-error"))
+ opts->warnings_are_errors = 0;
+ else if (!strcmp (argv[i], "-Wall"))
+ {
+ opts->warn_trigraphs = 1;
+ opts->warn_comments = 1;
+ }
+ 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"))
+ {
+ opts->print_deps_missing_files = 1;
+ break;
+ }
+ if (!strcmp (argv[i], "-M"))
+ opts->print_deps = 2;
+ else if (!strcmp (argv[i], "-MM"))
+ opts->print_deps = 1;
+ else if (!strcmp (argv[i], "-MD"))
+ opts->print_deps = 2;
+ else if (!strcmp (argv[i], "-MMD"))
+ opts->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]);
+ opts->deps_file = argv[++i];
+ }
+ else
+ {
+ /* For -M and -MM, write deps on standard output
+ and suppress the usual output. */
+ opts->no_output = 1;
+ }
+ break;
+
+ case 'd':
+ {
+ char *p = argv[i] + 2;
+ char c;
+ while ((c = *p++) != 0) {
+ /* Arg to -d specifies what parts of macros to dump */
+ switch (c) {
+ case 'M':
+ opts->dump_macros = dump_only;
+ opts->no_output = 1;
+ break;
+ case 'N':
+ opts->dump_macros = dump_names;
+ break;
+ case 'D':
+ opts->dump_macros = dump_definitions;
+ break;
+ }
+ }
+ }
+ break;
+
+ case 'g':
+ if (argv[i][2] == '3')
+ opts->debug_output = 1;
+ break;
+
+ case 'v':
+ fprintf (stderr, "GNU CPP version %s", version_string);
#ifdef TARGET_VERSION
- TARGET_VERSION;
+ TARGET_VERSION;
#endif
- fprintf (stderr, "\n");
- // opts->verbose = 1;
- break;
-
- case 'H':
- opts->print_include_names = 1;
- break;
-
- case 'D':
- if (argv[i][2] != 0)
- push_pending (pfile, "-D", argv[i] + 2);
- else if (i + 1 == argc)
- fatal ("Macro name missing after -D option");
- else
- i++, push_pending (pfile, "-D", 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, "-")) {
- struct cpp_pending **ptr;
- /* -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;
- opts->inhibit_predefs = 1;
- for (ptr = &opts->pending; *ptr != NULL; )
- {
- struct cpp_pending *pend = *ptr;
- if (pend->cmd && pend->cmd[0] == '-'
- && (pend->cmd[1] == 'D' || pend->cmd[1] == 'A'))
- {
- *ptr = pend->next;
- free (pend);
- }
- else
- ptr = &pend->next;
- }
- } else {
- push_pending (pfile, "-A", p);
- }
- }
- break;
-
- case 'U': /* JF #undef something */
- if (argv[i][2] != 0)
- push_pending (pfile, "-U", argv[i] + 2);
- else if (i + 1 == argc)
- fatal ("Macro name missing after -U option");
- else
- push_pending (pfile, "-U", argv[i+1]), i++;
- break;
-
- case 'C':
- opts->put_out_comments = 1;
- break;
-
- case 'E': /* -E comes from cc -E; ignore it. */
- break;
-
- case 'P':
- opts->no_line_commands = 1;
- break;
-
- case '$': /* Don't include $ in identifiers. */
- opts->dollars_in_ident = 0;
- break;
-
- case 'I': /* Add directory to path for includes. */
- {
- struct file_name_list *dirtmp;
-
- if (! CPP_OPTIONS(pfile)->ignore_srcdir
- && !strcmp (argv[i] + 2, "-")) {
- CPP_OPTIONS (pfile)->ignore_srcdir = 1;
- /* Don't use any preceding -I directories for #include <...>. */
- CPP_OPTIONS (pfile)->first_bracket_include = 0;
- }
- else {
- dirtmp = (struct file_name_list *)
- xmalloc (sizeof (struct file_name_list));
- dirtmp->next = 0; /* New one goes on the end */
- dirtmp->control_macro = 0;
- dirtmp->c_system_include_path = 0;
- if (argv[i][2] != 0)
- dirtmp->fname = argv[i] + 2;
- else if (i + 1 == argc)
- fatal ("Directory name missing after -I option");
- else
- dirtmp->fname = argv[++i];
- dirtmp->got_name_map = 0;
- append_include_chain (pfile, 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. */
- opts->no_standard_includes = 1;
- else if (!strcmp (argv[i], "-nostdinc++"))
- /* -nostdinc++ causes no default C++-specific include directories. */
- opts->no_standard_cplusplus_includes = 1;
+ fprintf (stderr, "\n");
+ // opts->verbose = 1;
+ break;
+
+ case 'H':
+ opts->print_include_names = 1;
+ break;
+
+ case 'D':
+ if (argv[i][2] != 0)
+ push_pending (pfile, "-D", argv[i] + 2);
+ else if (i + 1 == argc)
+ fatal ("Macro name missing after -D option");
+ else
+ i++, push_pending (pfile, "-D", argv[i]);
+ break;
+
+ case 'A':
+ {
+ char *p;
+
+ if (argv[i][2] != 0)
+ {
+ p = argv[i] + 2;
+ }
+ else
+ {
+ if (++i == argc)
+ {
+ fatal ("Assertion missing after -A option");
+ }
+ p = argv[i];
+ }
+
+ if (!strcmp (p, "-")) {
+ struct cpp_pending **ptr;
+ /* -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; */
+ opts->inhibit_predefs = 1;
+ for (ptr = &opts->pending; *ptr != NULL; )
+ {
+ struct cpp_pending *pend = *ptr;
+ if (pend->cmd && pend->cmd[0] == '-'
+ && (pend->cmd[1] == 'D' || pend->cmd[1] == 'A'))
+ {
+ *ptr = pend->next;
+ Safe_free (pend);
+ }
+ else
+ ptr = &pend->next;
+ }
+ } else {
+ push_pending (pfile, "-A", p);
+ }
+ }
+ break;
+
+ case 'U': /* JF #undef something */
+ if (argv[i][2] != 0)
+ push_pending (pfile, "-U", argv[i] + 2);
+ else if (i + 1 == argc)
+ fatal ("Macro name missing after -U option");
+ else
+ push_pending (pfile, "-U", argv[i+1]), i++;
+ break;
+
+ case 'C':
+ opts->put_out_comments = 1;
+ break;
+
+ case 'E': /* -E comes from cc -E; ignore it. */
+ break;
+
+ case 'P':
+ opts->no_line_commands = 1;
+ break;
+
+ case '$': /* Don't include $ in identifiers. */
+ opts->dollars_in_ident = 0;
+ break;
+
+ case 'I': /* Add directory to path for includes. */
+ {
+ struct file_name_list *dirtmp;
+
+ if (! CPP_OPTIONS(pfile)->ignore_srcdir
+ && !strcmp (argv[i] + 2, "-")) {
+ CPP_OPTIONS (pfile)->ignore_srcdir = 1;
+ /* Don't use any preceding -I directories for #include <...>. */
+ CPP_OPTIONS (pfile)->first_bracket_include = 0;
+ }
+ else {
+ dirtmp = (struct file_name_list *)
+ Safe_malloc (sizeof (struct file_name_list));
+ dirtmp->next = 0; /* New one goes on the end */
+ dirtmp->control_macro = 0;
+ dirtmp->c_system_include_path = 0;
+ if (argv[i][2] != 0)
+ dirtmp->fname = argv[i] + 2;
+ else if (i + 1 == argc)
+ fatal ("Directory name missing after -I option");
+ else
+ dirtmp->fname = argv[++i];
+ dirtmp->got_name_map = 0;
+ append_include_chain (pfile, 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. */
+ opts->no_standard_includes = 1;
+ else if (!strcmp (argv[i], "-nostdinc++"))
+ /* -nostdinc++ causes no default C++-specific include directories. */
+ opts->no_standard_cplusplus_includes = 1;
#if 0
- else if (!strcmp (argv[i], "-noprecomp"))
- no_precomp = 1;
+ else if (!strcmp (argv[i], "-noprecomp"))
+ no_precomp = 1;
#endif
- break;
-
- case 'u':
- /* Sun compiler passes undocumented switch "-undef".
- Let's assume it means to inhibit the predefined symbols. */
- opts->inhibit_predefs = 1;
- break;
-
- case '\0': /* JF handle '-' as file name meaning stdin or stdout */
- if (opts->in_fname == NULL) {
- opts->in_fname = "";
- break;
- } else if (opts->out_fname == NULL) {
- opts->out_fname = "";
- break;
- } /* else fall through into error */
-
- default:
- return i;
+ break;
+
+ case 'u':
+ /* Sun compiler passes undocumented switch "-undef".
+ Let's assume it means to inhibit the predefined symbols. */
+ opts->inhibit_predefs = 1;
+ break;
+
+ case '\0': /* JF handle '-' as file name meaning stdin or stdout */
+ if (opts->in_fname == NULL) {
+ opts->in_fname = "";
+ break;
+ } else if (opts->out_fname == NULL) {
+ opts->out_fname = "";
+ break;
+ } /* else fall through into error */
+
+ default:
+ return i;
}
}
}
cpp_reader *pfile)
{
struct cpp_options *opts = CPP_OPTIONS (pfile);
-
+
if (opts->print_deps)
{
/* Stream on which to print the dependency information. */
/* Don't actually write the deps file if compilation has failed. */
if (pfile->errors == 0)
- {
- char *deps_mode = opts->print_deps_append ? "a" : "w";
- if (opts->deps_file == 0)
- deps_stream = stdout;
- else if ((deps_stream = fopen (opts->deps_file, deps_mode)) == 0)
- cpp_pfatal_with_name (pfile, opts->deps_file);
- fputs (pfile->deps_buffer, deps_stream);
- putc ('\n', deps_stream);
- if (opts->deps_file)
- {
- if (ferror (deps_stream) || fclose (deps_stream) != 0)
- fatal ("I/O error on output");
- }
- }
+ {
+ char *deps_mode = opts->print_deps_append ? "a" : "w";
+ if (opts->deps_file == 0)
+ deps_stream = stdout;
+ else if ((deps_stream = fopen (opts->deps_file, deps_mode)) == 0)
+ cpp_pfatal_with_name (pfile, opts->deps_file);
+ fputs (pfile->deps_buffer, deps_stream);
+ putc ('\n', deps_stream);
+ if (opts->deps_file)
+ {
+ if (ferror (deps_stream) || fclose (deps_stream) != 0)
+ fatal ("I/O error on output");
+ }
+ }
}
}
if (pfile->token_buffer)
{
- free (pfile->token_buffer);
+ Safe_free (pfile->token_buffer);
pfile->token_buffer = NULL;
}
if (pfile->deps_buffer)
{
- free (pfile->deps_buffer);
+ Safe_free (pfile->deps_buffer);
pfile->deps_buffer = NULL;
pfile->deps_allocated_size = 0;
}
{
IF_STACK_FRAME *temp = pfile->if_stack;
pfile->if_stack = temp->next;
- free (temp);
+ Safe_free (temp);
}
while (pfile->dont_repeat_files)
{
struct file_name_list *temp = pfile->dont_repeat_files;
pfile->dont_repeat_files = temp->next;
- free (temp->fname);
- free (temp);
+ Safe_free (temp->fname);
+ Safe_free (temp);
}
while (pfile->all_include_files)
{
struct file_name_list *temp = pfile->all_include_files;
pfile->all_include_files = temp->next;
- free (temp->fname);
- free (temp);
+ Safe_free (temp->fname);
+ Safe_free (temp);
}
for (i = IMPORT_HASH_SIZE; --i >= 0; )
{
register struct import_file *imp = pfile->import_hash_table[i];
while (imp)
- {
- struct import_file *next = imp->next;
- free (imp->name);
- free (imp);
- imp = next;
- }
+ {
+ struct import_file *next = imp->next;
+ Safe_free (imp->name);
+ Safe_free (imp);
+ imp = next;
+ }
pfile->import_hash_table[i] = 0;
}
for (i = ASSERTION_HASHSIZE; --i >= 0; )
{
while (pfile->assertion_hashtab[i])
- delete_assertion (pfile->assertion_hashtab[i]);
+ delete_assertion (pfile->assertion_hashtab[i]);
}
cpp_hash_cleanup (pfile);
struct directive *keyword,
U_CHAR *buf, U_CHAR *limit)
{
- long symstart; /* remember where symbol name starts */
+ long symstart; /* remember where symbol name starts */
int c;
- int sym_length; /* and how long it is */
+ int sym_length; /* and how long it is */
struct arglist *tokens = NULL;
if (CPP_PEDANTIC (pfile) && CPP_OPTIONS (pfile)->done_initializing
cpp_pedwarn (pfile, "ANSI C does not allow `#assert'");
cpp_skip_hspace (pfile);
- symstart = CPP_WRITTEN (pfile); /* remember where it starts */
+ symstart = CPP_WRITTEN (pfile); /* remember where it starts */
parse_name (pfile, GETC());
sym_length = check_macro_name (pfile, pfile->token_buffer + symstart,
- "assertion");
+ "assertion");
cpp_skip_hspace (pfile);
if (PEEKC() != '(') {
U_CHAR *symname = pfile->token_buffer + symstart;
int hashcode = hashf (symname, sym_length, ASSERTION_HASHSIZE);
struct tokenlist_list *value
- = (struct tokenlist_list *) xmalloc (sizeof (struct tokenlist_list));
+ = (struct tokenlist_list *) Safe_malloc (sizeof (struct tokenlist_list));
hp = assertion_lookup (pfile, symname, sym_length, hashcode);
if (hp == NULL) {
if (sym_length == 7 && ! strncmp (symname, "defined", sym_length))
- cpp_error (pfile, "`defined' redefined as assertion");
+ cpp_error (pfile, "`defined' redefined as assertion");
hp = assertion_install (pfile, symname, sym_length, hashcode);
}
struct directive *keyword,
U_CHAR *buf, U_CHAR *limit)
{
- long symstart; /* remember where symbol name starts */
- int sym_length; /* and how long it is */
+ long symstart; /* remember where symbol name starts */
+ int sym_length; /* and how long it is */
int c;
struct arglist *tokens = NULL;
cpp_skip_hspace (pfile);
- symstart = CPP_WRITTEN (pfile); /* remember where it starts */
+ symstart = CPP_WRITTEN (pfile); /* remember where it starts */
parse_name (pfile, GETC());
sym_length = check_macro_name (pfile, pfile->token_buffer + symstart,
- "assertion");
+ "assertion");
cpp_skip_hspace (pfile);
if (PEEKC() == '(') {
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;
+ 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);
+ Safe_free (tail);
+ } else {
+ prev = tail;
+ }
+ tail = next;
}
}
}
while (tail) {
if (compare_token_lists (tail->tokens, tokens))
- return 1;
+ return 1;
tail = tail->next;
}
{
struct arglist *temp;
long name_written = CPP_WRITTEN (pfile);
- int eofp = 0; int c;
+ int c;
cpp_skip_hspace (pfile);
c = GETC ();
-
+
/* Find the end of the token. */
if (c == '(')
{
- CPP_PUTC (pfile, c);
- depth++;
+ CPP_PUTC (pfile, c);
+ depth++;
}
else if (c == ')')
{
- depth--;
- if (depth == 0)
- break;
- CPP_PUTC (pfile, c);
+ depth--;
+ if (depth == 0)
+ break;
+ CPP_PUTC (pfile, c);
}
else if (c == '"' || c == '\'')
{
- FORWARD(-1);
- cpp_get_token (pfile);
+ FORWARD(-1);
+ cpp_get_token (pfile);
}
else if (c == '\n')
- break;
+ break;
else
{
- while (c != EOF && ! is_space[c] && c != '(' && c != ')'
- && c != '"' && c != '\'')
- {
- CPP_PUTC (pfile, c);
- c = GETC();
- }
- if (c != EOF) FORWARD(-1);
+ while (c != EOF && ! is_space[c] && c != '(' && c != ')'
+ && c != '"' && c != '\'')
+ {
+ CPP_PUTC (pfile, c);
+ c = GETC();
+ }
+ if (c != EOF) FORWARD(-1);
}
length = CPP_WRITTEN (pfile) - name_written;
temp = (struct arglist *)
- xmalloc (sizeof (struct arglist) + length + 1);
+ Safe_malloc (sizeof (struct arglist) + length + 1);
temp->name = (U_CHAR *) (temp + 1);
bcopy ((char *) (pfile->token_buffer + name_written),
- (char *) temp->name, length);
+ (char *) temp->name, length);
temp->name[length] = 0;
temp->next = token_ptrs;
token_ptrs = temp;
if (c == EOF || c == '\n')
{ /* FIXME */
- cpp_error (pfile,
- "unterminated token sequence following `#' operator");
- return 0;
- }
+ cpp_error (pfile,
+ "unterminated token sequence following `#' operator");
+ return 0;
+ }
}
/* We accumulated the names in reverse order.
{
while (tokens) {
struct arglist *next = tokens->next;
- free (tokens->name);
- free (tokens);
+ Safe_free (tokens->name);
+ Safe_free (tokens);
tokens = next;
}
}
if (nchars < 0)
{
#ifdef EINTR
- if (errno == EINTR)
- continue;
+ if (errno == EINTR)
+ continue;
#endif
- return nchars;
+ return nchars;
}
if (nchars == 0)
break;
char *input)
{
unsigned size = strlen (input);
- char *output = xmalloc (size + 1);
+ char *output = Safe_malloc (size + 1);
strcpy (output, input);
return output;
}
int error_flag;
struct arglist *token_ptrs = read_token_list (pfile, &error_flag);
result = check_assertion (pfile,
- pfile->token_buffer + name_start, name_length,
- 1, token_ptrs);
+ pfile->token_buffer + name_start, name_length,
+ 1, token_ptrs);
}
else
result = check_assertion (pfile,
- pfile->token_buffer + name_start, name_length,
- 0, NULL_PTR);
+ pfile->token_buffer + name_start, name_length,
+ 0, (struct arglist *)NULL_PTR);
CPP_ADJUST_WRITTEN (pfile, - name_length); /* pop */
return result;
}
long line, col;
cpp_buf_line_and_col (ip, &line, &col);
cpp_file_line_for_message (pfile, ip->nominal_fname,
- line, pfile->show_column ? col : -1);
+ line, pfile->show_column ? col : -1);
}
}
char *msg;
char *arg1, *arg2, *arg3;
{
- int i;
cpp_buffer *ip = cpp_file_buffer (pfile);
cpp_print_containing_files (pfile);
char *msg;
char *arg1, *arg2, *arg3;
{
- int i;
cpp_buffer *ip;
if (CPP_OPTIONS (pfile)->inhibit_warnings)
if (file != NULL)
cpp_file_line_for_message (pfile, file, line, -1);
cpp_message (pfile, CPP_OPTIONS (pfile)->pedantic_errors,
- msg, arg1, arg2, arg3);
+ msg, arg1, arg2, arg3);
}
/* This defines "errno" properly for VMS, and gives us EACCES. */
extern char *sys_errlist[];
#endif
#endif
-#else /* HAVE_STRERROR */
+#else /* HAVE_STRERROR */
char *strerror ();
#endif
-#else /* VMS */
+#else /* VMS */
char *strerror (int,...);
#endif
#else
result = strerror (errnum);
#endif
-#else /* VMS */
+#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
cpp_reader *pfile,
char *name)
{
- int i;
-
-
cpp_buffer *ip = cpp_file_buffer (pfile);
cpp_print_containing_files (pfile);
if (ip != NULL)
cpp_file_line_for_message (pfile, ip->nominal_fname, ip->lineno, -1);
- cpp_message (pfile, 1, "%s: %s", name, my_strerror (errno));
+ cpp_message (pfile, 1, "%s: %s", name, my_strerror (errno),NULL);
}
void
projects / fw / sdcc / blobdiff