X-Git-Url: https://git.gag.com/?a=blobdiff_plain;f=support%2Fcpp%2Fcpplib.c;h=5e65415fa603ac083bc68549bcad91b8850cdf03;hb=541d83d9229c4cae95e807891dc56cceba4a5bd5;hp=a7f2c8ac7eeba33e7cd3f12ae54058725bd5f594;hpb=b09af35f2f1cde7649d3ac4a6f5d2af6d97895a0;p=fw%2Fsdcc diff --git a/support/cpp/cpplib.c b/support/cpp/cpplib.c index a7f2c8ac..5e65415f 100644 --- a/support/cpp/cpplib.c +++ b/support/cpp/cpplib.c @@ -22,8 +22,17 @@ Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. You are forbidden to forbid anyone else to use, share and improve what you give them. Help stamp out software-hoarding! */ +#if defined(_MSC_VER) + +#include "..\..\sdcc_vc.h" +#include + +#else + #include "sdccconf.h" +#endif + #ifdef EMACS #define NO_SHORTNAMES #include "../src/config.h" @@ -39,7 +48,7 @@ Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. for the sake of machines with limited C compilers. */ #ifndef EMACS #include "config.h" -#include +#include "newalloc.h" #include #endif /* not EMACS */ #define GCC_INCLUDE_DIR "/usr/local/lib/gcc-lib/i386-unknown-freebsd_1.0/2.5.8/include" @@ -78,17 +87,32 @@ Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. #include #endif + +// PENDING: Straighten this out into configure +#include // all compilers need this +#ifdef __MINGW32__ +#include +#else +#ifdef __BORLANDC__ +#include +#else #ifndef VMS #ifndef USG -#include /* for __DATE__ and __TIME__ */ +#if !defined(_MSC_VER) +// PENDING +#include +#include /* for __DATE__ and __TIME__ */ #include #else -/*#include CYGNUS LOCAL: shebs -noquiet */ +/*#include CYGNUS LOCAL: shebs -noquiet */ // #include #include #include +#endif // _MSC_VER #endif /* USG */ #endif /* not VMS */ +#endif +#endif /* This defines "errno" properly for VMS, and gives us EACCES. */ #include @@ -181,7 +205,7 @@ static char *predefs = ""; #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__ */ @@ -207,14 +231,14 @@ struct tokenlist_list { }; 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; }; @@ -253,34 +277,25 @@ struct cpp_pending { /* 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 (); @@ -292,10 +307,10 @@ static struct arglist *read_token_list (); 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 (); @@ -360,11 +375,11 @@ struct file_name_list /* -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; @@ -405,13 +420,13 @@ static struct default_include { /* `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. @@ -509,24 +524,24 @@ quote_string ( { 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; } } @@ -539,8 +554,7 @@ cpp_grow_buffer ( { 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); } @@ -591,15 +605,15 @@ cpp_define ( 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)); } @@ -613,23 +627,24 @@ make_assertion ( 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]) { @@ -643,7 +658,7 @@ make_assertion ( 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); @@ -714,8 +729,8 @@ deps_output ( 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++] = ' '; @@ -748,20 +763,20 @@ path_include ( /* 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; @@ -771,7 +786,7 @@ path_include ( /* Advance past this name. */ p = q; if (*p == 0) - break; + break; /* Skip the colon. */ p++; } @@ -835,7 +850,7 @@ macro_cleanup ( 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; } @@ -846,46 +861,12 @@ file_cleanup ( { 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 ' '. @@ -897,60 +878,60 @@ skip_comment ( 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 @@ -961,29 +942,29 @@ cpp_skip_hspace ( { 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; } } @@ -1001,39 +982,39 @@ copy_rest_of_line ( 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: ; @@ -1058,7 +1039,7 @@ handle_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); @@ -1069,7 +1050,7 @@ handle_directive ( { /* 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; } @@ -1090,16 +1071,16 @@ handle_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; } } @@ -1116,7 +1097,7 @@ handle_directive ( 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; } @@ -1124,17 +1105,17 @@ handle_directive ( { /* 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 @@ -1148,12 +1129,12 @@ handle_directive ( (*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); @@ -1224,7 +1205,7 @@ struct arglist { 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. */ @@ -1263,12 +1244,12 @@ collect_expansion ( 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); @@ -1302,94 +1283,99 @@ collect_expansion ( 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 - } - break; + } + else if (*p == '/') { + /* A c++ comment. Discard to the end of line */ + exp_p--; + p = limit; + } + break; } } @@ -1403,68 +1389,68 @@ collect_expansion ( 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"); } } } @@ -1489,28 +1475,28 @@ collect_expansion ( #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 ( @@ -1518,15 +1504,15 @@ 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); @@ -1535,7 +1521,7 @@ create_definition ( 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; @@ -1548,7 +1534,7 @@ create_definition ( struct arglist *arg_ptrs = NULL; int argno = 0; - bp++; /* skip '(' */ + bp++; /* skip '(' */ SKIP_WHITE_SPACE (bp); /* Loop over macro argument names. */ @@ -1563,58 +1549,58 @@ create_definition ( 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); @@ -1623,17 +1609,17 @@ create_definition ( /* 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; } @@ -1642,29 +1628,29 @@ create_definition ( 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 *) ""; } @@ -1702,7 +1688,7 @@ check_macro_name ( 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; @@ -1733,11 +1719,11 @@ compare_defs ( 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; @@ -1746,7 +1732,7 @@ compare_defs ( 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; } @@ -1821,32 +1807,32 @@ do_define ( 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; @@ -1854,11 +1840,11 @@ do_define ( 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; @@ -1875,7 +1861,7 @@ nope: `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 */ @@ -1905,7 +1891,7 @@ cpp_push_buffer ( 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; @@ -1915,7 +1901,7 @@ cpp_push_buffer ( buf->underflow = null_underflow; buf->buf = buf->cur = buffer; buf->alimit = buf->rlimit = buffer + length; - + return buf; } @@ -1931,7 +1917,7 @@ cpp_pop_buffer (pfile) 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 } @@ -1948,12 +1934,12 @@ cpp_scan_buffer ( { 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; + } } } @@ -1973,10 +1959,10 @@ cpp_expand_to_buffer ( 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 @@ -2024,9 +2010,9 @@ adjust_position ( { U_CHAR ch = *buf++; if (ch == '\n') - (*linep)++, (*colp) = 1; + (*linep)++, (*colp) = 1; else - (*colp)++; + (*colp)++; } } @@ -2042,7 +2028,7 @@ update_position ( 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); @@ -2093,7 +2079,7 @@ count_newlines ( { U_CHAR ch = *buf++; if (ch == '\n') - count++; + count++; } return count; } @@ -2112,8 +2098,8 @@ output_line_command ( 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); @@ -2138,8 +2124,8 @@ output_line_command ( 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; } @@ -2157,17 +2143,18 @@ output_line_command ( CPP_RESERVE (pfile, 4 * strlen (ip->nominal_fname) + 50); { static char sharp_line[] = "#line "; + 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'); @@ -2200,8 +2187,8 @@ macarg ( 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; @@ -2212,35 +2199,35 @@ macarg ( { 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: @@ -2276,14 +2263,14 @@ change_newlines ( 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; } @@ -2305,8 +2292,8 @@ timestamp ( } 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 @@ -2319,30 +2306,30 @@ special_symbol ( 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) @@ -2350,26 +2337,26 @@ special_symbol ( 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); @@ -2409,19 +2396,19 @@ special_symbol ( 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; @@ -2430,58 +2417,58 @@ special_symbol ( 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: @@ -2539,9 +2526,9 @@ initialize_builtins ( 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); @@ -2566,30 +2553,30 @@ initialize_builtins ( 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); + } } } @@ -2604,18 +2591,18 @@ unsafe_chars ( { 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 '_': @@ -2682,92 +2669,92 @@ macroexpand ( 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. @@ -2780,252 +2767,252 @@ macroexpand ( 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; @@ -3041,11 +3028,11 @@ macroexpand ( /* 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; } @@ -3081,7 +3068,7 @@ push_macro_expansion ( if (xbuf[0] == '@' && xbuf[1] == ' ' && (is_idchar[xbuf[2]] || xbuf[2] == '(' || xbuf[2] == '\'' - || xbuf[2] == '\"')) + || xbuf[2] == '\"')) mbuf->cur += 2; } @@ -3098,19 +3085,19 @@ get_directive_token ( 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; } } } @@ -3131,30 +3118,28 @@ do_include ( { 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 @@ -3184,57 +3169,57 @@ do_include ( 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; -#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; - } - } - } - } + { + 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; + } + } + } + } #ifdef VMS else if (token == CPP_NAME) { @@ -3244,11 +3229,11 @@ do_include ( * code from case '<' is repeated here) and generates a warning. */ cpp_warning (pfile, - "VAX-C-style include specification found, use '#include ' !"); + "VAX-C-style include specification found, use '#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; + search_start = CPP_OPTIONS (pfile)->first_bracket_include; fbeg = pfile->token_buffer + old_written; fend = CPP_PWRITTEN (pfile); } @@ -3256,7 +3241,7 @@ do_include ( else { cpp_error (pfile, - "`#%s' expects \"FILENAME\" or ", keyword->name); + "`#%s' expects \"FILENAME\" or ", keyword->name); CPP_SET_WRITTEN (pfile, old_written); skip_rest_of_line (pfile); return 0; @@ -3269,7 +3254,7 @@ do_include ( { 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 @@ -3278,16 +3263,16 @@ do_include ( { 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); @@ -3302,7 +3287,7 @@ do_include ( /* 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') */ @@ -3318,59 +3303,59 @@ do_include ( 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; } } @@ -3380,57 +3365,57 @@ do_include ( 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. @@ -3440,21 +3425,21 @@ do_include ( 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; @@ -3464,17 +3449,17 @@ do_include ( /* 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) @@ -3492,45 +3477,45 @@ do_include ( #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) @@ -3551,8 +3536,8 @@ redundant_include_p ( 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; } @@ -3582,12 +3567,12 @@ is_system_include ( 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; } @@ -3614,7 +3599,7 @@ assertion_install ( 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]; @@ -3675,7 +3660,7 @@ delete_assertion ( { struct tokenlist_list *next = tail->next; free_token_list (tail->tokens); - free (tail); + Safe_free (tail); tail = next; } @@ -3684,7 +3669,7 @@ delete_assertion ( if (hp == *hp->bucket_hdr) *hp->bucket_hdr = hp->next; - free (hp); + Safe_free (hp); } /* Convert a character string literal into a nul-terminated string. @@ -3707,26 +3692,26 @@ convert_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; @@ -3748,7 +3733,7 @@ do_line ( 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); @@ -3792,8 +3777,8 @@ do_line ( 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; @@ -3803,32 +3788,32 @@ do_line ( 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; } } @@ -3836,13 +3821,13 @@ do_line ( &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; @@ -3892,11 +3877,11 @@ do_undef ( 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); } @@ -3922,7 +3907,7 @@ do_error ( 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); @@ -3943,7 +3928,7 @@ do_warning ( 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); @@ -3964,13 +3949,13 @@ do_once ( 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); @@ -3990,7 +3975,7 @@ do_ident ( 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) @@ -4033,14 +4018,14 @@ do_pragma ( 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); } } @@ -4090,8 +4075,8 @@ do_sccs ( /* * 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 @@ -4132,9 +4117,9 @@ do_elif ( 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; @@ -4147,7 +4132,7 @@ do_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); } } @@ -4173,7 +4158,7 @@ eval_if_expression ( 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 */ @@ -4217,23 +4202,23 @@ do_xifdef ( { 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)) @@ -4241,7 +4226,7 @@ do_xifdef ( 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); @@ -4249,13 +4234,13 @@ do_xifdef ( 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 @@ -4277,7 +4262,7 @@ conditional_skip ( { 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; @@ -4308,14 +4293,13 @@ skip_if_group ( 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); @@ -4349,7 +4333,7 @@ skip_if_group ( pfile->limit = ident; #if 0 if (ident_length == 0) - goto not_a_directive; + goto not_a_directive; /* Handle # followed by a line number. */ @@ -4357,95 +4341,95 @@ skip_if_group ( #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 (); } @@ -4491,7 +4475,7 @@ do_else ( 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; @@ -4500,7 +4484,7 @@ do_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; @@ -4527,54 +4511,54 @@ do_endif ( 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; @@ -4594,19 +4578,19 @@ validate_else ( 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); @@ -4617,629 +4601,629 @@ cpp_get_token ( { 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 '"); - 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 '"); + 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; + } } } @@ -5253,8 +5237,8 @@ cpp_get_non_space_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); } } @@ -5269,20 +5253,20 @@ parse_name ( { 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; @@ -5293,7 +5277,7 @@ parse_name ( /* Hash a file name for import_hash_table. */ -static int +static int import_hash ( char *f) { @@ -5327,7 +5311,7 @@ lookup_import ( 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 */ @@ -5339,16 +5323,16 @@ lookup_import ( 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. */ @@ -5365,8 +5349,8 @@ add_import ( 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; @@ -5403,20 +5387,20 @@ read_filename_string ( 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); @@ -5448,7 +5432,7 @@ read_name_map ( 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; @@ -5466,48 +5450,48 @@ read_name_map ( 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 @@ -5527,8 +5511,8 @@ open_include_file ( 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; } @@ -5537,15 +5521,15 @@ open_include_file ( { 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 @@ -5557,7 +5541,7 @@ open_include_file ( 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. */ @@ -5606,8 +5590,8 @@ finclude ( 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) { @@ -5629,7 +5613,7 @@ finclude ( 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; @@ -5651,17 +5635,17 @@ finclude ( 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; @@ -5702,7 +5686,7 @@ finclude ( indepth--; input_file_stack_tick++; - free (fp->buf); + Safe_free (fp->buf); #endif return 1; @@ -5710,7 +5694,7 @@ finclude ( cpp_perror_with_name (pfile, fname); close (f); - free (fp->buf); + Safe_free (fp->buf); return 1; } @@ -5764,65 +5748,65 @@ push_parse_file ( 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 (); } } } @@ -5836,24 +5820,24 @@ push_parse_file ( 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; @@ -5864,17 +5848,17 @@ push_parse_file ( 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. */ @@ -5884,38 +5868,38 @@ push_parse_file ( 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)); } } @@ -5938,42 +5922,42 @@ push_parse_file ( 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; } } } @@ -5989,7 +5973,7 @@ push_parse_file ( 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"); @@ -6003,17 +5987,17 @@ push_parse_file ( 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--; @@ -6039,15 +6023,15 @@ push_parse_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; @@ -6058,15 +6042,15 @@ push_parse_file ( 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; @@ -6078,73 +6062,73 @@ push_parse_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 @@ -6172,16 +6156,16 @@ push_parse_file ( 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--; @@ -6189,7 +6173,7 @@ push_parse_file ( for (pend = opts->pending; pend; ) { struct cpp_pending *next = pend->next; - free (pend); + Safe_free (pend); pend = next; } opts->pending = NULL; @@ -6219,7 +6203,7 @@ init_parse_file ( 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; @@ -6234,7 +6218,7 @@ init_parse_file ( static struct cpp_pending * nreverse_pending ( struct cpp_pending *list) - + { register struct cpp_pending *prev = 0, *next, *pend; for (pend = list; pend; pend = next) @@ -6253,7 +6237,7 @@ push_pending ( 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; @@ -6271,458 +6255,464 @@ cpp_handle_options ( 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; } } } @@ -6734,7 +6724,7 @@ cpp_finish ( cpp_reader *pfile) { struct cpp_options *opts = CPP_OPTIONS (pfile); - + if (opts->print_deps) { /* Stream on which to print the dependency information. */ @@ -6742,20 +6732,20 @@ cpp_finish ( /* 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"); + } + } } } @@ -6771,13 +6761,13 @@ cpp_cleanup ( 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; } @@ -6786,42 +6776,42 @@ cpp_cleanup ( { 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); @@ -6833,9 +6823,9 @@ do_assert ( 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 @@ -6843,10 +6833,10 @@ do_assert ( 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() != '(') { @@ -6878,12 +6868,12 @@ do_assert ( 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); } @@ -6906,8 +6896,8 @@ do_unassert ( 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; @@ -6919,10 +6909,10 @@ do_unassert ( 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() == '(') { @@ -6965,18 +6955,18 @@ do_unassert ( 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; } } } @@ -7027,7 +7017,7 @@ check_assertion ( while (tail) { if (compare_token_lists (tail->tokens, tokens)) - return 1; + return 1; tail = tail->next; } @@ -7090,49 +7080,49 @@ read_token_list ( { 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; @@ -7142,10 +7132,10 @@ read_token_list ( 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. @@ -7159,8 +7149,8 @@ free_token_list ( { while (tokens) { struct arglist *next = tokens->next; - free (tokens->name); - free (tokens); + Safe_free (tokens->name); + Safe_free (tokens); tokens = next; } } @@ -7199,10 +7189,10 @@ safe_read ( if (nchars < 0) { #ifdef EINTR - if (errno == EINTR) - continue; + if (errno == EINTR) + continue; #endif - return nchars; + return nchars; } if (nchars == 0) break; @@ -7217,7 +7207,7 @@ savestring ( char *input) { unsigned size = strlen (input); - char *output = xmalloc (size + 1); + char *output = Safe_malloc (size + 1); strcpy (output, input); return output; } @@ -7293,13 +7283,13 @@ cpp_read_check_assertion ( 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; } @@ -7315,7 +7305,7 @@ cpp_print_file_and_line (pfile) 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); } } @@ -7370,7 +7360,6 @@ cpp_error_with_line (pfile, line, column, msg, arg1, arg2, arg3) char *msg; char *arg1, *arg2, *arg3; { - int i; cpp_buffer *ip = cpp_file_buffer (pfile); cpp_print_containing_files (pfile); @@ -7388,7 +7377,6 @@ cpp_warning_with_line (pfile, line, column, msg, arg1, arg2, arg3) char *msg; char *arg1, *arg2, *arg3; { - int i; cpp_buffer *ip; if (CPP_OPTIONS (pfile)->inhibit_warnings) @@ -7437,7 +7425,7 @@ cpp_pedwarn_with_file_and_line (pfile, file, line, msg, arg1, arg2, arg3) 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. */ @@ -7456,10 +7444,10 @@ extern const char *const sys_errlist[]; extern char *sys_errlist[]; #endif #endif -#else /* HAVE_STRERROR */ +#else /* HAVE_STRERROR */ char *strerror (); #endif -#else /* VMS */ +#else /* VMS */ char *strerror (int,...); #endif @@ -7479,7 +7467,7 @@ my_strerror (errnum) #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 @@ -7503,9 +7491,6 @@ cpp_error_from_errno ( cpp_reader *pfile, char *name) { - int i; - - cpp_buffer *ip = cpp_file_buffer (pfile); cpp_print_containing_files (pfile); @@ -7513,7 +7498,7 @@ cpp_error_from_errno ( 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