+2002-05-22 Kazu Hirata <kazu@cs.umass.edu>
+
+ * cpperror.c: Fix formatting.
+ * cppexp.c: Likewise.
+ * cppfiles.c: Likewise.
+ * cpphash.c: Likewise.
+ * cpphash.h: Likewise.
+ * cppinit.c: Likewise.
+ * cpplex.c: Likewise.
+ * cpplib.c: Likewise.
+ * cppmacro.c: Likewise.
+ * cppmain.c: Likewise.
+ * cppspec.c: Likewise.
+
2002-05-22 Jakub Jelinek <jakub@redhat.com>
* combine.c (force_to_mode): Use gen_int_mode.
else if (CPP_OPTION (pfile, inhibit_warnings))
return 0;
break;
-
+
case DL_ERROR:
if (CPP_OPTION (pfile, inhibit_errors))
return 0;
|| (base == 16 && (c == 'P' || c == 'p')
&& p+1 < end && (p[1] == '+' || p[1] == '-')))
SYNTAX_ERROR ("floating point numbers are not valid in #if");
-
+
/* Determine the suffix. l means long, and u means unsigned.
See the suffix tables, above. */
switch (end - p)
cpp_error (pfile, DL_PEDWARN,
"too many 'l' suffixes in integer constant");
}
-
+
if (base <= largest_digit)
cpp_error (pfile, DL_PEDWARN,
"integer constant contains digits beyond the radix");
top->value = PSH (pfile, v1, unsigned1, v2);
/* Parse and evaluate a C expression, reading from PFILE.
- Returns the truth value of the expression.
+ Returns the truth value of the expression.
The implementation is an operator precedence parser, i.e. a
bottom-up parser, using a stack for not-yet-reduced tokens.
/* Check for and handle stack overflow. */
if (++top == pfile->op_limit)
top = _cpp_expand_op_stack (pfile);
-
+
top->op = op.op;
}
/* Don't reopen an idempotent file. */
if (DO_NOT_REREAD (file))
return file;
-
+
/* Don't reopen one which is already loaded. */
if (file->buffer != NULL)
return file;
/* For DJGPP redirected input is opened in text mode. Change it
to binary mode. */
if (! isatty (file->fd))
- setmode (file->fd, O_BINARY);
+ setmode (file->fd, O_BINARY);
#endif
}
else
nd = splay_tree_lookup (pfile->all_include_files, (splay_tree_key) fname);
return (nd && nd->value);
}
-
+
/* Search directory path for the file. */
name = (char *) alloca (strlen (fname) + pfile->max_include_len + 2);
for (path = CPP_OPTION (pfile, quote_include); path; path = path->next)
const cpp_token *header;
{
struct include_file *inc = find_include_file (pfile, header, 0);
-
+
if (inc == NULL || inc == NO_INCLUDE_PATH)
return -1;
close (inc->fd);
inc->fd = -1;
}
-
+
return inc->st.st_mtime > pfile->buffer->inc->st.st_mtime;
}
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;
}
fclose (f);
}
-
+
/* Add this information to the cache. */
map_list_ptr->map_list_next = CPP_OPTION (pfile, map_list);
CPP_OPTION (pfile, map_list) = map_list_ptr;
return map_list_ptr->map_list_map;
-}
+}
/* Remap an unsimplified path NAME based on the file_name_map (if any)
for LOC. */
if (! loc->name_map)
return name;
}
-
+
/* This works since NAME has not been simplified yet. */
from = name + loc->len + 1;
-
+
for (map = loc->name_map; map; map = map->map_next)
if (!strcmp (map->map_from, from))
return map->map_to;
memcpy (dir, name, p - name);
dir[p - name] = '\0';
from = p + 1;
-
+
for (map = read_name_map (pfile, dir); map; map = map->map_next)
if (! strcmp (map->map_from, from))
return map->map_to;
nonzero if an error occurred when using stat () or lstat (). */
char *
_cpp_simplify_pathname (path)
- char *path;
+ char *path;
{
#ifndef VMS
char *from, *to;
/* Convert all backslashes to slashes. */
for (from = path; *from; from++)
if (*from == '\\') *from = '/';
-
+
/* Skip over leading drive letter if present. */
if (ISALPHA (path[0]) && path[1] == ':')
from = to = &path[2];
#else
from = to = path;
#endif
-
+
/* Remove redundant leading /s. */
if (*from == '/')
{
if (move_base)
base = to;
}
-
+
/* Change the empty string to "." so that it is not treated as stdin.
Null terminate. */
if (to == path)
hash_table *table;
{
cpp_hashnode *node;
-
+
node = (cpp_hashnode *) obstack_alloc (&table->pfile->hash_ob,
sizeof (cpp_hashnode));
memset ((PTR) node, 0, sizeof (cpp_hashnode));
unsigned char poisoned_ok;
/* Nonzero to prevent macro expansion. */
- unsigned char prevent_expansion;
+ unsigned char prevent_expansion;
/* Nonzero when parsing arguments to a function-like macro. */
unsigned char parsing_args;
/* Call backs. */
struct cpp_callbacks cb;
- /* Identifier hash table. */
+ /* Identifier hash table. */
struct ht *hash_table;
/* Expression parser stack. */
for (cur = head; cur; cur = cur->next)
{
for (other = head; other != cur; other = other->next)
- if (INO_T_EQ (cur->ino, other->ino) && cur->dev == other->dev)
+ if (INO_T_EQ (cur->ino, other->ino) && cur->dev == other->dev)
{
if (cur->sysp && !other->sysp)
{
enum c_lang lang;
{
const struct lang_flags *l = &lang_defaults[(int) lang];
-
+
CPP_OPTION (pfile, lang) = lang;
CPP_OPTION (pfile, c99) = l->c99;
if (pfile->next_include_file)
{
struct pending_option *head = *pfile->next_include_file;
-
+
while (head && !push_include (pfile, head))
head = head->next;
CPP_OPTION (pfile, help_only) = 1;
break;
case OPT_target__help:
- /* Print if any target specific options. cpplib has none, but
+ /* Print if any target specific options. cpplib has none, but
make sure help_only gets set. */
CPP_OPTION (pfile, help_only) = 1;
- break;
+ break;
/* --version inhibits compilation, -version doesn't. -v means
verbose and -version. Historical reasons, don't ask. */
CPP_OPTION (pfile, pedantic_errors) = 1;
/* fall through */
case OPT_pedantic:
- CPP_OPTION (pfile, pedantic) = 1;
+ CPP_OPTION (pfile, pedantic) = 1;
CPP_OPTION (pfile, warn_endif_labels) = 1;
break;
case OPT_trigraphs:
- CPP_OPTION (pfile, trigraphs) = 1;
+ CPP_OPTION (pfile, trigraphs) = 1;
break;
case OPT_remap:
CPP_OPTION (pfile, remap) = 1;
/* Args to -d specify what parts of macros to dump.
Silently ignore unrecognised options; they may
be aimed at the compiler proper. */
- {
+ {
char c;
while ((c = *arg++) != '\0')
- switch (c)
- {
- case 'M':
+ switch (c)
+ {
+ case 'M':
CPP_OPTION (pfile, dump_macros) = dump_only;
break;
case 'N':
case OPT_MF:
CPP_OPTION (pfile, deps_file) = arg;
break;
- case OPT_MP:
+ case OPT_MP:
CPP_OPTION (pfile, deps_phony_targets) = 1;
break;
case OPT_MQ:
break;
case OPT_I: /* Add directory to path for includes. */
if (!strcmp (arg, "-"))
- {
+ {
/* -I- means:
Use the preceding -I directories for #include "..."
but not #include <...>.
cpp_error (pfile, DL_FATAL, "-I- specified twice");
return argc;
}
- }
- else
+ }
+ else
append_include_chain (pfile, xstrdup (arg), BRACKET, 0);
break;
case OPT_isystem:
else if (! ignore)
return i;
break;
- }
+ }
}
return i + 1;
}
static int skip_whitespace PARAMS ((cpp_reader *, cppchar_t));
static cpp_hashnode *parse_identifier PARAMS ((cpp_reader *));
static uchar *parse_slow PARAMS ((cpp_reader *, const uchar *, int,
- unsigned int *));
+ unsigned int *));
static void parse_number PARAMS ((cpp_reader *, cpp_string *, int));
static int unescaped_terminator_p PARAMS ((cpp_reader *, const uchar *));
static void parse_string PARAMS ((cpp_reader *, cpp_token *, cppchar_t));
if (__builtin_expect (next == '?' || next == '\\', 0))
next = skip_escaped_newlines (pfile);
- return next;
+ return next;
}
/* Skip a C-style block comment. We find the end of the comment by
if (!is_idchar (string->text[i]))
return 0;
- return 1;
+ return 1;
}
/* Parse an identifier, skipping embedded backslash-newlines. This is
/* Handle normal identifier characters in this loop. */
do
- {
+ {
prevc = c;
- obstack_1grow (stack, c);
+ obstack_1grow (stack, c);
- if (c == '$')
- saw_dollar++;
+ if (c == '$')
+ saw_dollar++;
- c = *buffer->cur++;
- }
+ c = *buffer->cur++;
+ }
while (is_idchar (c));
}
if (char_len == -1)
{
cpp_error (pfile, DL_WARNING,
- "ignoring invalid multibyte character");
+ "ignoring invalid multibyte character");
char_len = 1;
c = *buffer->cur++;
}
{
unsigned char *buffer;
unsigned int len, clen;
-
+
len = pfile->buffer->cur - from + 1; /* + 1 for the initial '/'. */
/* C++ comments probably (not definitely) have moved past a new
clen = (pfile->state.in_directive && type == '/') ? len + 2 : len;
buffer = _cpp_unaligned_alloc (pfile, clen);
-
+
token->type = CPP_COMMENT;
token->val.str.len = clen;
token->val.str.text = buffer;
{
cpp_buffer *buffer = pfile->buffer;
bool more = false;
-
+
buffer->saved_flags = BOL;
if (CPP_OPTION (pfile, traditional))
more = _cpp_read_logical_line_trad (pfile);
case 'L':
/* 'L' may introduce wide characters or strings. */
- {
- const unsigned char *pos = buffer->cur;
+ {
+ const unsigned char *pos = buffer->cur;
- c = get_effective_char (pfile);
- if (c == '\'' || c == '"')
- {
- result->type = (c == '"' ? CPP_WSTRING: CPP_WCHAR);
- parse_string (pfile, result, c);
- break;
- }
- buffer->cur = pos;
- }
- /* Fall through. */
+ c = get_effective_char (pfile);
+ if (c == '\'' || c == '"')
+ {
+ result->type = (c == '"' ? CPP_WSTRING: CPP_WCHAR);
+ parse_string (pfile, result, c);
+ break;
+ }
+ buffer->cur = pos;
+ }
+ /* Fall through. */
start_ident:
case '_':
&& ! buffer->warned_cplusplus_comments)
{
cpp_error (pfile, DL_PEDWARN,
- "C++ style comments are not allowed in ISO C89");
+ "C++ style comments are not allowed in ISO C89");
cpp_error (pfile, DL_PEDWARN,
"(this will be reported only once per input file)");
buffer->warned_cplusplus_comments = 1;
result->type = CPP_AND;
}
break;
-
+
case '|':
c = get_effective_char (pfile);
if (c == '|')
goto spell_ident;
else
spelling = TOKEN_NAME (token);
-
+
while ((c = *spelling++) != '\0')
*buffer++ = c;
}
"non-ISO-standard escape sequence, '\\%c'", (int) c);
c = TARGET_ESC;
break;
-
+
case 'u': case 'U':
unknown = maybe_read_ucs (pfile, &str, limit, &c);
break;
cpp_error (pfile, DL_WARNING,
"the meaning of '\\x' is different in traditional C");
- {
- cppchar_t i = 0, overflow = 0;
- int digits_found = 0;
+ {
+ cppchar_t i = 0, overflow = 0;
+ int digits_found = 0;
- while (str < limit)
- {
- c = *str;
- if (! ISXDIGIT (c))
- break;
- str++;
- overflow |= i ^ (i << 4 >> 4);
- i = (i << 4) + hex_digit_value (c);
- digits_found = 1;
- }
+ while (str < limit)
+ {
+ c = *str;
+ if (! ISXDIGIT (c))
+ break;
+ str++;
+ overflow |= i ^ (i << 4 >> 4);
+ i = (i << 4) + hex_digit_value (c);
+ digits_found = 1;
+ }
- if (!digits_found)
- cpp_error (pfile, DL_ERROR,
+ if (!digits_found)
+ cpp_error (pfile, DL_ERROR,
"\\x used with no following hex digits");
- if (overflow | (i != (i & mask)))
- {
- cpp_error (pfile, DL_PEDWARN,
- "hex escape sequence out of range");
- i &= mask;
- }
- c = i;
- }
+ if (overflow | (i != (i & mask)))
+ {
+ cpp_error (pfile, DL_PEDWARN,
+ "hex escape sequence out of range");
+ i &= mask;
+ }
+ c = i;
+ }
break;
case '0': case '1': case '2': case '3':
if (ISPRINT (c))
c = MAP_CHARACTER (c);
#endif
-
+
chars_seen++;
/* Truncate the character, scale the result and merge the two. */
requested to expand comments into macros, then re-enable
saving of comments. */
if (dir == &dtable[T_DEFINE])
- pfile->state.save_comments =
- ! CPP_OPTION (pfile, discard_comments_in_macro_exp);
+ pfile->state.save_comments =
+ ! CPP_OPTION (pfile, discard_comments_in_macro_exp);
pfile->directive = dir;
(*pfile->directive->handler) (pfile);
do_undef (pfile)
cpp_reader *pfile;
{
- cpp_hashnode *node = lex_macro_node (pfile);
+ cpp_hashnode *node = lex_macro_node (pfile);
/* 6.10.3.5 paragraph 2: [#undef] is ignored if the specified identifier
is not currently defined as a macro name. */
"\"%s\" after #line is not a positive integer",
cpp_token_as_text (pfile, token));
return;
- }
+ }
if (CPP_PEDANTIC (pfile) && (new_lineno == 0 || new_lineno > cap))
cpp_error (pfile, DL_PEDWARN, "line number out of range");
cpp_error (pfile, DL_ERROR, "\"%s\" after # is not a positive integer",
cpp_token_as_text (pfile, token));
return;
- }
+ }
token = cpp_get_token (pfile);
if (token->type == CPP_STRING)
cpp_reader *pfile;
{
cpp_error (pfile, DL_WARNING, "#pragma once is obsolete");
-
+
if (pfile->buffer->prev == NULL)
cpp_error (pfile, DL_WARNING, "#pragma once in main file");
else
{
const cpp_token *header;
int ordering;
-
+
header = parse_include (pfile);
if (!header)
return;
{
struct answer *new_answer;
cpp_hashnode *node;
-
+
node = parse_assertion (pfile, &new_answer, T_ASSERT);
if (node)
{
{
cpp_hashnode *node;
struct answer *answer;
-
+
node = parse_assertion (pfile, &answer, T_UNASSERT);
/* It isn't an error to #unassert something that isn't asserted. */
if (node && node->type == NT_ASSERTION)
char *buf, *p;
size_t count;
- /* Copy the entire option so we can modify it.
+ /* Copy the entire option so we can modify it.
Change the first "=" in the string to a space. If there is none,
tack " 1" on the end. */
const char *str;
{
handle_assertion (pfile, str, T_UNASSERT);
-}
+}
/* Common code for cpp_assert (-A) and cpp_unassert (-A-). */
static void
the invocation at all.
e.g. #define debug(format, args...) something
debug("string");
-
+
This is exactly the same as if there had been an empty rest
argument - debug("string", ). */
if (node->type != NT_MACRO || (result->flags & NO_EXPAND))
break;
-
+
if (!(node->flags & NODE_DISABLED))
{
if (!pfile->state.prevent_expansion
{
unsigned int i, len;
const uchar *p, *q, *limit = string->text + string->len;
-
+
/* Loop over the string. */
for (p = string->text; p < limit; p = q)
{
}
if (i + 1 < macro->paramc)
- /* Don't emit a space after the comma here; we're trying
- to emit a Dwarf-friendly definition, and the Dwarf spec
- forbids spaces in the argument list. */
+ /* Don't emit a space after the comma here; we're trying
+ to emit a Dwarf-friendly definition, and the Dwarf spec
+ forbids spaces in the argument list. */
*buffer++ = ',';
else if (macro->variadic)
*buffer++ = '.', *buffer++ = '.', *buffer++ = '.';
print.printed = 0;
print.prev = 0;
print.map = 0;
-
+
/* Open the output now. We must do so even if no_output is on,
because there may be other output than from the actual
preprocessing (e.g. from -dM). */
size_t to_file_len = strlen (map->to_file);
unsigned char *to_file_quoted = alloca (to_file_len * 4 + 1);
unsigned char *p;
-
+
/* cpp_quote_string does not nul-terminate, so we have to do it
ourselves. */
p = cpp_quote_string (to_file_quoted,
/* Have we seen an input file? */
int seen_input = 0;
-
+
/* Positions to insert -xc, -xassembler-with-cpp, and -o, if necessary.
0 means unnecessary. */
int lang_c_here = 0;
/* Do we need to fix up an input file with an unrecognized suffix? */
int need_fixups = 1;
-
+
int i, j, quote = 0;
const char **new_argv;
int new_argc;
quote = 0;
continue;
}
-
+
if (argv[i][0] == '-')
{
if (argv[i][1] == '\0')
new_argv[j] = NULL;
*in_argc = new_argc;
*in_argv = new_argv;
-}
+}
/* Called before linking. Returns 0 on success and -1 on failure. */
int lang_specific_pre_link ()
projects / thirdparty / gcc.git / commitdiff
