+2000-05-03 Zack Weinberg <zack@wolery.cumb.org>
+
+ * cpphash.h (U): New define, to correct type of string constants.
+ (ustrcmp, ustrncmp, ustrlen, uxstrdup, ustrchr): New wrapper
+ routines, to do casts when passing unsigned strings to libc.
+ * cppexp.c, cppfiles.c, cpphash.c, cppinit.c, cpplib.c: Use them.
+
+ * cppfiles.c (_cpp_execute_include): Make filename an U_CHAR *.
+ * cpphash.c (_cpp_quote_string): Make string an U_CHAR *.
+ * cppinit.c (dump_special_to_buffer): Make macro name an U_CHAR *.
+ * cpplex.c (parse_ifdef, parse_include, validate_else): Make
+ second argument an U_CHAR *.
+
+ * cppinit.c (builtin_array): Make name and value U_CHAR *, add
+ length field, clean up initializer.
+ (ISTABLE): Add __extension__ to designated-
+ initializers version.
+ * cpplex.c (CHARTAB): Likewise.
+
+ * mbchar.c: Add dummy external declaration to the !MULTIBYTE_CHARS
+ case so the file won't be empty.
+
Wed May 3 21:01:46 2000 Jason Eckhardt <jle@cygnus.com>
* bb-reorder.c (struct reorder_block_def): Member succ removed.
* rtl.def (define_insn_and_split): New DEF_RTL_EXPR.
* md.texi (Insn Splitting): Document define_insn_and_split.
->>>>>>> 1.6464
Tue May 2 00:20:30 2000 Jason Eckhardt <jle@cygnus.com>
* flow.c (verify_flow_info): Added two more sanity checks. The
/* If char type is signed, sign-extend the constant. */
num_bits = num_chars * width;
- if (cpp_defined (pfile, (const U_CHAR *)"__CHAR_UNSIGNED__",
+ if (cpp_defined (pfile, U"__CHAR_UNSIGNED__",
sizeof ("__CHAR_UNSIGNED__")-1)
|| ((result >> (num_bits - 1)) & 1) == 0)
op.value = result & ((unsigned HOST_WIDEST_INT) ~0
return parse_charconst (pfile, tok_start, tok_end);
case CPP_NAME:
- if (!strncmp (tok_start, "defined", 7))
+ if (!ustrncmp (tok_start, U"defined", 7))
return parse_defined (pfile);
op.op = INT;
const void *x;
const void *y;
{
- const U_CHAR *a = ((const IHASH *)x)->nshort;
- const U_CHAR *b = ((const IHASH *)y)->nshort;
+ const char *a = ((const IHASH *)x)->nshort;
+ const char *b = ((const IHASH *)y)->nshort;
return !strcmp (a, b);
}
return (i->control_macro
&& (i->control_macro[0] == '\0'
|| cpp_defined (pfile, i->control_macro,
- strlen (i->control_macro))))
+ ustrlen (i->control_macro))))
? (IHASH *)-1 : i;
return 0;
{
IHASH dummy, *ptr;
dummy.nshort = fname;
- dummy.hash = _cpp_calc_hash (fname, strlen (fname));
+ dummy.hash = _cpp_calc_hash ((const U_CHAR *)fname, strlen (fname));
ptr = htab_find_with_hash (pfile->all_include_files,
(const void *)&dummy, dummy.hash);
return (ptr != NULL);
char *name;
dummy.nshort = fname;
- dummy.hash = _cpp_calc_hash (fname, strlen (fname));
+ dummy.hash = _cpp_calc_hash ((const U_CHAR *)fname, strlen (fname));
path = (fname[0] == '/') ? ABSOLUTE_PATH : search_start;
slot = (IHASH **) htab_find_slot_with_hash (pfile->all_include_files,
(const void *) &dummy,
IHASH dummy;
dummy.nshort = fname;
- dummy.hash = _cpp_calc_hash (fname, strlen (fname));
+ dummy.hash = _cpp_calc_hash ((const U_CHAR *)fname, strlen (fname));
slot = (IHASH **) htab_find_slot_with_hash (pfile->all_include_files,
(const void *) &dummy,
dummy.hash, INSERT);
void
-_cpp_execute_include (pfile, fname, len, no_reinclude, search_start)
+_cpp_execute_include (pfile, f, len, no_reinclude, search_start)
cpp_reader *pfile;
- char *fname;
+ U_CHAR *f;
unsigned int len;
int no_reinclude;
struct file_name_list *search_start;
{
IHASH *ihash;
+ char *fname = (char *)f;
int fd;
int angle_brackets = fname[0] == '<';
int before;
/* Actually process the file. */
if (no_reinclude)
- ihash->control_macro = (const U_CHAR *) "";
+ ihash->control_macro = U"";
if (read_include_file (pfile, fd, ihash))
{
if (*fname == 0)
dummy.hash = 0;
else
- dummy.hash = _cpp_calc_hash (fname, strlen (fname));
+ dummy.hash = _cpp_calc_hash ((const U_CHAR *)fname, strlen (fname));
slot = (IHASH **) htab_find_slot_with_hash (pfile->all_include_files,
(const void *) &dummy,
dummy.hash, INSERT);
if (length < 0)
goto fail;
if (length == 0)
- ihash->control_macro = (const U_CHAR *) ""; /* never re-include */
+ ihash->control_macro = U""; /* never re-include */
close (fd);
fp->rlimit = fp->buf + length;
const HASHNODE *b = (const HASHNODE *)y;
return (a->length == b->length
- && !strncmp (a->name, b->name, a->length));
+ && !ustrncmp (a->name, b->name, a->length));
}
/* Destroy a HASHNODE. */
break;
for (i = 0; i < argc; i++)
- if (!strncmp (p, argv[i].name, argv[i].len)
+ if (!ustrncmp (p, argv[i].name, argv[i].len)
&& ! is_idchar (p[argv[i].len]))
{
cpp_warning (pfile,
break;
for (i = 0; i < argc; i++)
- if (!strncmp (p, argv[i].name, argv[i].len)
+ if (!ustrncmp (p, argv[i].name, argv[i].len)
&& ! is_idchar (p[argv[i].len]))
{
if (CPP_WTRADITIONAL (pfile))
warn_trad_stringify (pfile, tok, len, argc, argv);
goto norm;
}
-
+
case CPP_NAME:
for (j = 0; j < argc; j++)
if (argv[j].len == len
- && !strncmp (tok, argv[j].name, argv[j].len))
+ && !ustrncmp (tok, argv[j].name, argv[j].len))
goto addref;
/* fall through */
duplicate_arg_p (args, new)
U_CHAR *args, *new;
{
- size_t newlen = strlen (new) + 1;
+ size_t newlen = ustrlen (new) + 1;
size_t oldlen;
while (args < new)
{
- oldlen = strlen (args) + 1;
+ oldlen = ustrlen (args) + 1;
if (!memcmp (args, new, MIN (oldlen, newlen)))
return 1;
args += oldlen;
}
if (CPP_PEDANTIC (pfile) && CPP_OPTION (pfile, c99)
&& len == sizeof "__VA_ARGS__" - 1
- && !strcmp (p, "__VA_ARGS__"))
+ && !ustrcmp (p, U"__VA_ARGS__"))
cpp_pedwarn (pfile,
"C99 does not permit use of __VA_ARGS__ as a macro argument name");
argv[a].len = len;
argv[a].len = sizeof "__VA_ARGS__" - 1;
argv[a].name = p;
argv[a].rest_arg = 1;
- strcpy (p, "__VA_ARGS__");
+ strcpy ((char *)p, "__VA_ARGS__");
}
else
{
ntype = T_EMPTY; /* Empty definition of object-like macro. */
else if (list->tokens_used == 3 && TOK_TYPE (list, 1) == CPP_NAME
&& TOK_LEN (list, 0) == TOK_LEN (list, 1)
- && !strncmp (TOK_NAME (list, 0), TOK_NAME (list, 1),
- TOK_LEN (list, 0)))
+ && !ustrncmp (TOK_NAME (list, 0), TOK_NAME (list, 1),
+ TOK_LEN (list, 0)))
ntype = T_IDENTITY; /* Object like macro defined to itself. */
/* The macro is function-like only if the next character,
case T_MACRO:
ok = (ntype == hp->type
&& odefn->length == hp->value.odefn->length
- && !strncmp (odefn->expansion, hp->value.odefn->expansion,
- odefn->length));
+ && !ustrncmp (odefn->expansion, hp->value.odefn->expansion,
+ odefn->length));
break;
case T_FMACRO:
ok = (ntype == hp->type
void
_cpp_quote_string (pfile, src)
cpp_reader *pfile;
- const char *src;
+ const U_CHAR *src;
{
U_CHAR c;
cpp_reader *pfile;
HASHNODE *hp;
{
- const char *buf;
+ const U_CHAR *buf;
cpp_buffer *ip;
+ size_t len;
switch (hp->type)
{
while (CPP_PREV_BUFFER (ip) != NULL)
ip = CPP_PREV_BUFFER (ip);
- buf = ip->nominal_fname;
- CPP_RESERVE (pfile, 3 + 4 * strlen (buf));
+ buf = (const U_CHAR *) ip->nominal_fname;
+ len = ustrlen (buf);
+ CPP_RESERVE (pfile, 3 + 4 * len);
_cpp_quote_string (pfile, buf);
return;
}
CPP_RESERVE (pfile, 10);
- sprintf (CPP_PWRITTEN (pfile), "%d", true_indepth);
- CPP_ADJUST_WRITTEN (pfile, strlen (CPP_PWRITTEN (pfile)));
+ sprintf ((char *)CPP_PWRITTEN (pfile), "%d", true_indepth);
+ len = ustrlen (CPP_PWRITTEN (pfile));
+ CPP_ADJUST_WRITTEN (pfile, len);
return;
}
if (!buf || *buf == '\0')
return;
- CPP_PUTS (pfile, buf, strlen (buf));
+ len = ustrlen (buf);
+ CPP_PUTS (pfile, buf, len);
return;
case T_SPECLINE:
return;
}
CPP_RESERVE (pfile, 10);
- sprintf (CPP_PWRITTEN (pfile), "%u", CPP_BUF_LINE (ip));
- CPP_ADJUST_WRITTEN (pfile, strlen (CPP_PWRITTEN (pfile)));
+ sprintf ((char *)CPP_PWRITTEN (pfile), "%u", CPP_BUF_LINE (ip));
+ len = ustrlen (CPP_PWRITTEN (pfile));
+ CPP_ADJUST_WRITTEN (pfile, len);
return;
case T_DATE:
{
const U_CHAR *cpval = hp->value.cpval;
if (cpval && *cpval != '\0')
- push_macro_expansion (pfile, cpval, strlen (cpval), hp);
+ push_macro_expansion (pfile, cpval, ustrlen (cpval), hp);
return;
}
if (d1->nargs != d2->nargs)
return 1;
- if (strcmp (d1->expansion, d2->expansion))
+ if (ustrcmp (d1->expansion, d2->expansion))
return 1;
if (CPP_PEDANTIC (pfile)
&& d1->argnames && d2->argnames)
int i = d1->nargs;
while (i--)
{
- len = strlen (arg1) + 1;
- if (strcmp (arg1, arg2))
+ len = ustrlen (arg1) + 1;
+ if (ustrcmp (arg1, arg2))
return 1;
arg1 += len;
arg2 += len;
for (i = 0; i < defn->nargs; i++)
{
argv[i] = x;
- argl[i] = strlen (x);
+ argl[i] = ustrlen (x);
x += argl[i] + 1;
}
{
CPP_RESERVE (pfile, argl[i] + 2);
if (!(i == defn->nargs-1 && defn->rest_args
- && !strcmp (argv[i], "__VA_ARGS__")))
+ && !ustrcmp (argv[i], U"__VA_ARGS__")))
CPP_PUTS_Q (pfile, argv[i], argl[i]);
if (i < defn->nargs-1)
CPP_PUTS_Q (pfile, ", ", 2);
#define __GCC_CPPHASH__
typedef unsigned char U_CHAR;
+#define U (const U_CHAR *) /* Intended use: U"string" */
/* The structure of a node in the hash table. The hash table
has entries for all tokens defined by #define commands (type T_MACRO),
char disabled; /* macro turned off for rescan? */
union {
- const char *cpval; /* some predefined macros */
+ const U_CHAR *cpval; /* some predefined macros */
const struct object_defn *odefn; /* #define foo bar */
const struct funct_defn *fdefn; /* #define foo(x) bar(x) */
struct hashnode *aschain; /* #assert */
extern int _cpp_create_definition PARAMS ((cpp_reader *,
cpp_toklist *, HASHNODE *));
extern void _cpp_dump_definition PARAMS ((cpp_reader *, HASHNODE *));
-extern void _cpp_quote_string PARAMS ((cpp_reader *, const char *));
+extern void _cpp_quote_string PARAMS ((cpp_reader *, const U_CHAR *));
extern void _cpp_macroexpand PARAMS ((cpp_reader *, HASHNODE *));
extern void _cpp_init_macro_hash PARAMS ((cpp_reader *));
extern void _cpp_dump_macro_hash PARAMS ((cpp_reader *));
/* In cppfiles.c */
extern void _cpp_simplify_pathname PARAMS ((char *));
-extern void _cpp_execute_include PARAMS ((cpp_reader *, char *,
+extern void _cpp_execute_include PARAMS ((cpp_reader *, U_CHAR *,
unsigned int, int,
struct file_name_list *));
extern void _cpp_init_include_hash PARAMS ((cpp_reader *));
/* In cpplib.c */
extern int _cpp_handle_directive PARAMS ((cpp_reader *));
extern void _cpp_unwind_if_stack PARAMS ((cpp_reader *, cpp_buffer *));
-extern void _cpp_check_directive PARAMS((cpp_toklist *, cpp_token *));
+extern void _cpp_check_directive PARAMS ((cpp_toklist *, cpp_token *));
+
+/* These are inline functions (if __GNUC__) instead of macros so we
+ can get type checking. */
+#if GCC_VERSION >= 2007 && defined __OPTIMIZE__
+extern inline int ustrcmp (const U_CHAR *, const U_CHAR *);
+extern inline int ustrncmp (const U_CHAR *, const U_CHAR *, size_t);
+extern inline size_t ustrlen (const U_CHAR *);
+extern inline U_CHAR *uxstrdup (const U_CHAR *);
+extern inline U_CHAR *ustrchr (const U_CHAR *, int);
+
+extern inline int
+ustrcmp (const U_CHAR *s1, const U_CHAR *s2)
+{ return strcmp ((const char *)s1, (const char *)s2); }
+
+extern inline int
+ustrncmp (const U_CHAR *s1, const U_CHAR *s2, size_t n)
+{ return strncmp ((const char *)s1, (const char *)s2, n); }
+
+extern inline size_t
+ustrlen (const U_CHAR *s1)
+{ return strlen ((const char *)s1); }
+
+extern inline U_CHAR *
+uxstrdup (const U_CHAR *s1)
+{ return (U_CHAR *) xstrdup ((const char *)s1); }
+
+extern inline U_CHAR *
+ustrchr (const U_CHAR *s1, int c)
+{ return (U_CHAR *) strchr ((const char *)s1, c); }
+
+#else
+#define ustrcmp(s1_, s2_) strcmp((const char *)s1_, (const char *)s2_)
+#define ustrncmp(s1_, s2_, n_) strncmp((const char *)s1_, (const char *)s2_, n_)
+#define ustrlen(s1_) strlen((const char *)s1_)
+#define uxstrdup(s1_) (U_CHAR *) xstrdup((const char *)s1_)
+#define ustrchr(s1_, c_) (U_CHAR *) strchr((const char *)s1_, c_)
+#endif
#endif
char *, int, int));
static void merge_include_chains PARAMS ((cpp_reader *));
-static void dump_special_to_buffer PARAMS ((cpp_reader *, const char *));
+static void dump_special_to_buffer PARAMS ((cpp_reader *, const U_CHAR *,
+ size_t));
static void initialize_dependency_output PARAMS ((cpp_reader *));
static void initialize_standard_includes PARAMS ((cpp_reader *));
static void new_pending_directive PARAMS ((struct cpp_pending *,
/* Fourth argument to append_include_chain: chain to use */
enum { QUOTE = 0, BRACKET, SYSTEM, AFTER };
-/* If we have designated initializers (GCC >2.7, or C99) this table
- can be initialized, constant data. Otherwise, it has to be filled
- in at runtime. */
+/* If we have designated initializers (GCC >2.7) this table can be
+ initialized, constant data. Otherwise, it has to be filled in at
+ runtime. */
-#if (GCC_VERSION >= 2007) || (__STDC_VERSION__ >= 199901L)
+#if (GCC_VERSION >= 2007)
#define init_IStable() /* nothing */
-#define ISTABLE const unsigned char _cpp_IStable[256] = {
+#define ISTABLE __extension__ const unsigned char _cpp_IStable[256] = {
#define END };
#define s(p, v) [p] = v,
#else
to PFILE's token_buffer. */
static void
-dump_special_to_buffer (pfile, macro_name)
+dump_special_to_buffer (pfile, macro_name, macro_len)
cpp_reader *pfile;
- const char *macro_name;
+ const U_CHAR *macro_name;
+ size_t macro_len;
{
static const char define_directive[] = "#define ";
- int macro_name_length = strlen (macro_name);
- CPP_RESERVE (pfile, sizeof(define_directive) + macro_name_length);
+ CPP_RESERVE (pfile, sizeof(define_directive) + macro_len);
CPP_PUTS_Q (pfile, define_directive, sizeof(define_directive)-1);
- CPP_PUTS_Q (pfile, macro_name, macro_name_length);
+ CPP_PUTS_Q (pfile, macro_name, macro_len);
CPP_PUTC_Q (pfile, ' ');
- _cpp_expand_to_buffer (pfile, macro_name, macro_name_length);
+ _cpp_expand_to_buffer (pfile, macro_name, macro_len);
CPP_PUTC (pfile, '\n');
}
struct builtin
{
- const char *name;
- const char *value;
+ const U_CHAR *name;
+ const U_CHAR *value;
unsigned short type;
unsigned short flags;
+ unsigned int len;
};
#define DUMP 0x01
#define VERS 0x02
#define ULP 0x04
+#define B(n, t) { U n, 0, t, 0, sizeof n - 1 }
+#define C(n, v) { U n, U v, T_CONST, DUMP, sizeof n - 1 }
+#define X(n, v, t, f) { U n, U v, t, DUMP|f, sizeof n - 1 }
static const struct builtin builtin_array[] =
{
- { "__TIME__", 0, T_TIME, 0 },
- { "__DATE__", 0, T_DATE, 0 },
- { "__FILE__", 0, T_FILE, 0 },
- { "__BASE_FILE__", 0, T_BASE_FILE, 0 },
- { "__LINE__", 0, T_SPECLINE, 0 },
- { "__INCLUDE_LEVEL__", 0, T_INCLUDE_LEVEL, 0 },
-
- { "__VERSION__", 0, T_XCONST, DUMP|VERS },
- { "__USER_LABEL_PREFIX__", 0, T_CONST, DUMP|ULP },
- { "__STDC__", "1", T_STDC, DUMP },
- { "__REGISTER_PREFIX__", REGISTER_PREFIX, T_CONST, DUMP },
- { "__HAVE_BUILTIN_SETJMP__", "1", T_CONST, DUMP },
+ B("__TIME__", T_TIME),
+ B("__DATE__", T_DATE),
+ B("__FILE__", T_FILE),
+ B("__BASE_FILE__", T_BASE_FILE),
+ B("__LINE__", T_SPECLINE),
+ B("__INCLUDE_LEVEL__", T_INCLUDE_LEVEL),
+
+ X("__VERSION__", 0, T_XCONST, VERS),
+ X("__USER_LABEL_PREFIX__", 0, T_CONST, ULP),
+ X("__STDC__", "1", T_STDC, 0),
+ C("__REGISTER_PREFIX__", REGISTER_PREFIX),
+ C("__HAVE_BUILTIN_SETJMP__", "1"),
#ifndef NO_BUILTIN_SIZE_TYPE
- { "__SIZE_TYPE__", SIZE_TYPE, T_CONST, DUMP },
+ C("__SIZE_TYPE__", SIZE_TYPE),
#endif
#ifndef NO_BUILTIN_PTRDIFF_TYPE
- { "__PTRDIFF_TYPE__", PTRDIFF_TYPE, T_CONST, DUMP },
+ C("__PTRDIFF_TYPE__", PTRDIFF_TYPE),
#endif
#ifndef NO_BUILTIN_WCHAR_TYPE
- { "__WCHAR_TYPE__", WCHAR_TYPE, T_CONST, DUMP },
+ C("__WCHAR_TYPE__", WCHAR_TYPE),
#endif
};
+#undef B
+#undef C
+#undef X
#define builtin_array_end \
builtin_array + sizeof(builtin_array)/sizeof(struct builtin)
initialize_builtins (pfile)
cpp_reader *pfile;
{
- int len;
const struct builtin *b;
- const char *val;
+ const U_CHAR *val;
HASHNODE *hp;
for(b = builtin_array; b < builtin_array_end; b++)
{
continue;
if (b->flags & ULP)
- val = user_label_prefix;
+ val = (const U_CHAR *) user_label_prefix;
else if (b->flags & VERS)
{
- val = xmalloc (strlen (version_string) + 3);
+ val = (const U_CHAR *) xmalloc (strlen (version_string) + 3);
sprintf ((char *)val, "\"%s\"", version_string);
}
else
val = b->value;
- len = strlen (b->name);
- hp = _cpp_lookup (pfile, b->name, len);
+ hp = _cpp_lookup (pfile, b->name, b->len);
hp->value.cpval = val;
hp->type = b->type;
if ((b->flags & DUMP) && CPP_OPTION (pfile, debug_output))
- dump_special_to_buffer (pfile, b->name);
+ dump_special_to_buffer (pfile, b->name, b->len);
}
}
#undef DUMP
#define UCHAR_MAX 255 /* assume 8-bit bytes */
#endif
-#if (GCC_VERSION >= 2007) || (__STDC_VERSION__ >= 199901L)
+#if (GCC_VERSION >= 2007)
#define init_chartab() /* nothing */
-#define CHARTAB static const unsigned char chartab[UCHAR_MAX + 1] = {
+#define CHARTAB __extension__ static const U_CHAR chartab[UCHAR_MAX + 1] = {
#define END };
#define s(p, v) [p] = v,
#else
-#define CHARTAB static unsigned char chartab[UCHAR_MAX + 1] = { 0 }; \
+#define CHARTAB static U_CHAR chartab[UCHAR_MAX + 1] = { 0 }; \
static void init_chartab PARAMS ((void)) { \
unsigned char *x = chartab;
#define END }
struct directive
{
directive_handler func; /* Function to handle directive. */
- const char *name; /* Name of directive. */
+ const U_CHAR *name; /* Name of directive. */
unsigned short length; /* Length of name. */
unsigned short flags; /* Flags describing this directive. */
};
/* Forward declarations. */
-static void validate_else PARAMS ((cpp_reader *, const char *));
-static int parse_ifdef PARAMS ((cpp_reader *, const char *));
-static unsigned int parse_include PARAMS ((cpp_reader *, const char *));
+static void validate_else PARAMS ((cpp_reader *, const U_CHAR *));
+static int parse_ifdef PARAMS ((cpp_reader *, const U_CHAR *));
+static unsigned int parse_include PARAMS ((cpp_reader *, const U_CHAR *));
static int conditional_skip PARAMS ((cpp_reader *, int, int,
U_CHAR *));
static int skip_if_group PARAMS ((cpp_reader *));
/* Don't invoke CONCAT2 with any whitespace or K&R cc will fail. */
#define D(name, t, flags) \
-{ CONCAT2(do_,name), STRINGX(name), sizeof STRINGX(name) - 1, flags },
+{ CONCAT2(do_,name), (const U_CHAR *) STRINGX(name), \
+ sizeof STRINGX(name) - 1, flags },
static const struct directive dtable[] =
{
DIRECTIVE_TABLE
cpp_toklist *list;
cpp_token *token;
{
- const char *name = list->namebuf + token->val.name.offset;
+ const U_CHAR *name = list->namebuf + token->val.name.offset;
size_t len = token->val.name.len;
unsigned int i;
list->dir_flags = 0;
for (i = 0; i < N_DIRECTIVES; i++)
- if (dtable[i].length == len && !strncmp (dtable[i].name, name, len))
+ if (dtable[i].length == len && !ustrncmp (dtable[i].name, name, len))
{
list->dir_handler = dtable[i].func;
list->dir_flags = dtable[i].flags;
for (i = 0; i < N_DIRECTIVES; i++)
{
if (dtable[i].length == len
- && !strncmp (dtable[i].name, ident, len))
+ && !ustrncmp (dtable[i].name, ident, len))
goto real_directive;
}
/* Don't complain about invalid directives in assembly source,
/* That NAME is not allowed to be "defined". (Not clear if the
standard requires this.) */
- if (len == 7 && !strncmp (sym, "defined", 7))
+ if (len == 7 && !ustrncmp (sym, U"defined", 7))
{
cpp_error_with_line (pfile, list->line, TOK_COL (list, 0),
"\"defined\" is not a legal macro name");
static unsigned int
parse_include (pfile, name)
cpp_reader *pfile;
- const char *name;
+ const U_CHAR *name;
{
long old_written = CPP_WRITTEN (pfile);
enum cpp_ttype token;
cpp_reader *pfile;
{
unsigned int len;
- char *token;
+ U_CHAR *token;
len = parse_include (pfile, dtable[T_INCLUDE].name);
if (len == 0)
return 0;
- token = alloca (len + 1);
+ token = (U_CHAR *) alloca (len + 1);
memcpy (token, CPP_PWRITTEN (pfile), len);
token[len] = '\0';
cpp_reader *pfile;
{
unsigned int len;
- char *token;
+ U_CHAR *token;
if (CPP_OPTION (pfile, warn_import)
&& !CPP_BUFFER (pfile)->system_header_p && !pfile->import_warning)
len = parse_include (pfile, dtable[T_IMPORT].name);
if (len == 0)
return 0;
- token = alloca (len + 1);
+ token = (U_CHAR *) alloca (len + 1);
memcpy (token, CPP_PWRITTEN (pfile), len);
token[len] = '\0';
cpp_reader *pfile;
{
unsigned int len;
- char *token;
+ U_CHAR *token;
struct file_name_list *search_start = 0;
len = parse_include (pfile, dtable[T_INCLUDE_NEXT].name);
if (len == 0)
return 0;
- token = alloca (len + 1);
+ token = (U_CHAR *) alloca (len + 1);
memcpy (token, CPP_PWRITTEN (pfile), len);
token[len] = '\0';
}
CPP_PUTC (pfile, '\0'); /* not terminated for us */
- new_lineno = strtoul (pfile->token_buffer + old_written, &x, 10);
+ new_lineno = strtoul ((const char *) (pfile->token_buffer + old_written),
+ &x, 10);
if (x[0] != '\0')
{
cpp_error (pfile, "token after `#line' is not an integer");
*end_name = '\0';
- if (strcmp (fname, ip->nominal_fname))
+ if (strcmp ((const char *)fname, ip->nominal_fname))
{
- if (!strcmp (fname, ip->ihash->name))
+ if (!strcmp ((const char *)fname, ip->ihash->name))
ip->nominal_fname = ip->ihash->name;
else
- ip->nominal_fname = _cpp_fake_ihash (pfile, fname);
+ ip->nominal_fname = _cpp_fake_ihash (pfile, (const char *)fname);
}
}
else if (token != CPP_VSPACE && token != CPP_EOF)
if (CPP_PREV_BUFFER (ip) == NULL)
cpp_warning (pfile, "`#pragma once' outside include file");
else
- ip->ihash->control_macro = (const U_CHAR *) ""; /* never repeat */
+ ip->ihash->control_macro = U""; /* never repeat */
return 1;
}
enum cpp_ttype token;
long written = CPP_WRITTEN (pfile);
U_CHAR *name;
- U_CHAR *copy;
+ char *copy;
size_t len;
token = _cpp_get_directive_token (pfile);
/* Trim the leading and trailing quote marks from the string. */
name = pfile->token_buffer + written + 1;
len = CPP_PWRITTEN (pfile) - name;
- copy = (U_CHAR *) alloca (len);
+ copy = alloca (len);
memcpy (copy, name, len - 1);
copy[len - 1] = '\0';
token = _cpp_get_directive_token (pfile);
if (token != CPP_NAME)
goto restore;
- if (strncmp (pfile->token_buffer + token_offset, "defined", 7))
+ if (ustrncmp (pfile->token_buffer + token_offset, U"defined", 7))
goto restore;
/* ...then an optional '(' and the name, */
static int
parse_ifdef (pfile, name)
cpp_reader *pfile;
- const char *name;
+ const U_CHAR *name;
{
U_CHAR *ident;
unsigned int len;
skip = parse_ifdef (pfile, dtable[T_IFNDEF].name);
if (start_of_file && !skip)
- control_macro = (U_CHAR *) xstrdup (CPP_PWRITTEN (pfile));
+ control_macro = uxstrdup (CPP_PWRITTEN (pfile));
return conditional_skip (pfile, skip, T_IFNDEF, control_macro);
}
for (i = 0; i < N_DIRECTIVES; i++)
{
if (dtable[i].length == len
- && !strncmp (dtable[i].name, pfile->token_buffer + ident, len))
+ && !ustrncmp (dtable[i].name, pfile->token_buffer + ident, len))
goto real_directive;
}
return 0;
static void
validate_else (pfile, directive)
cpp_reader *pfile;
- const char *directive;
+ const U_CHAR *directive;
{
long old_written;
if (! CPP_PEDANTIC (pfile))
goto error;
}
- blen = (U_CHAR *) strchr (sym, '(') - sym;
+ blen = ustrchr (sym, '(') - sym;
base = _cpp_lookup (pfile, sym, blen);
if (base->type == T_VOID)
{
}
else
{
- baselen = (U_CHAR *) strchr (sym, '(') - sym;
+ baselen = ustrchr (sym, '(') - sym;
base = _cpp_lookup (pfile, sym, baselen);
if (base->type == T_VOID) goto out;
this = _cpp_lookup (pfile, sym, thislen);
strcpy (&buf[count-4], " 1\n");
}
- if (cpp_push_buffer (pfile, buf, count - 1) != NULL)
+ if (cpp_push_buffer (pfile, (U_CHAR *)buf, count - 1) != NULL)
{
do_define (pfile);
cpp_pop_buffer (pfile);
memcpy (buf, macro, len);
buf[len] = '\n';
buf[len + 1] = '\0';
- if (cpp_push_buffer (pfile, buf, len + 1) != NULL)
+ if (cpp_push_buffer (pfile, (U_CHAR *)buf, len + 1) != NULL)
{
do_undef (pfile);
cpp_pop_buffer (pfile);
cpp_reader *pfile;
const char *str;
{
- if (cpp_push_buffer (pfile, str, strlen (str)) != NULL)
+ if (cpp_push_buffer (pfile, (const U_CHAR *)str, strlen (str)) != NULL)
{
do_assert (pfile);
cpp_pop_buffer (pfile);
cpp_reader *pfile;
const char *str;
{
- if (cpp_push_buffer (pfile, str, strlen (str)) != NULL)
+ if (cpp_push_buffer (pfile, (const U_CHAR *)str, strlen (str)) != NULL)
{
do_unassert (pfile);
cpp_pop_buffer (pfile);
return 1; /* default */
#endif
}
+#else /* MULTIBYTE_CHARS */
+extern int dummy; /* silence 'ANSI C forbids an empty source file' warning */
#endif /* MULTIBYTE_CHARS */
+2000-05-03 Zack Weinberg <zack@wolery.cumb.org>
+
+ * symcat.h: Remove #endif label.
+
2000-04-28 Kenneth Block <block@zk3.dec.com>
Jason Merrill <jason@casey.cygnus.com>
to "foo". */
#define XSTRING(s) STRINGX(s)
-#endif SYM_CAT_H
+#endif
projects / gcc.git / commitdiff