/* Protoize program - Original version by Ron Guilmette (rfg@segfault.us.com).
Copyright (C) 1989, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
- 1999, 2000, 2001, 2002, 2003 Free Software Foundation, Inc.
+ 1999, 2000, 2001, 2002, 2003, 2004 Free Software Foundation, Inc.
This file is part of GCC.
static void aux_info_corrupted (void) ATTRIBUTE_NORETURN;
static void declare_source_confusing (const char *) ATTRIBUTE_NORETURN;
static const char *shortpath (const char *, const char *);
-extern void fancy_abort (void) ATTRIBUTE_NORETURN;
static void notice (const char *, ...) ATTRIBUTE_PRINTF_1;
static char *savestring (const char *, unsigned int);
static char *dupnstr (const char *, size_t);
-static const char *substr (const char *, const char * const);
static int safe_read (int, void *, int);
static void safe_write (int, void *, int, const char *);
static void save_pointers (void);
static char *
savestring (const char *input, unsigned int size)
{
- char *output = (char *) xmalloc (size + 1);
+ char *output = xmalloc (size + 1);
strcpy (output, input);
return output;
}
-/* More 'friendly' abort that prints the line and file.
- config.h can #define abort fancy_abort if you like that sort of thing. */
-
-void
-fancy_abort (void)
-{
- notice ("%s: internal abort\n", pname);
- exit (FATAL_EXIT_CODE);
-}
\f
/* Make a duplicate of the first N bytes of a given string in a newly
allocated area. */
static char *
dupnstr (const char *s, size_t n)
{
- char *ret_val = (char *) xmalloc (n + 1);
+ char *ret_val = xmalloc (n + 1);
strncpy (ret_val, s, n);
ret_val[n] = '\0';
return ret_val;
}
-
-/* Return a pointer to the first occurrence of s2 within s1 or NULL if s2
- does not occur within s1. Assume neither s1 nor s2 are null pointers. */
-
-static const char *
-substr (const char *s1, const char *const s2)
-{
- for (; *s1 ; s1++)
- {
- const char *p1;
- const char *p2;
- int c;
-
- for (p1 = s1, p2 = s2; (c = *p2); p1++, p2++)
- if (*p1 != c)
- goto outer;
- return s1;
-outer:
- ;
- }
- return 0;
-}
\f
/* Read LEN bytes at PTR from descriptor DESC, for file FILENAME,
retrying if necessary. Return the actual number of bytes read. */
if (errno_val == EINTR)
continue;
#endif
- notice ("%s: error writing file `%s': %s\n",
+ notice ("%s: error writing file '%s': %s\n",
pname, shortpath (NULL, out_fname), xstrerror (errno_val));
return;
}
static int
file_could_be_converted (const char *path)
{
- char *const dir_name = (char *) alloca (strlen (path) + 1);
+ char *const dir_name = alloca (strlen (path) + 1);
if (access (path, R_OK))
return 0;
if (access (path, R_OK))
{
if (!quiet_flag)
- notice ("%s: warning: no read access for file `%s'\n",
+ notice ("%s: warning: no read access for file '%s'\n",
pname, shortpath (NULL, path));
return 0;
}
if (access (path, W_OK))
{
if (!quiet_flag)
- notice ("%s: warning: no write access for file `%s'\n",
+ notice ("%s: warning: no write access for file '%s'\n",
pname, shortpath (NULL, path));
return 0;
}
if (access (dir_name, W_OK))
{
if (!quiet_flag)
- notice ("%s: warning: no write access for dir containing `%s'\n",
+ notice ("%s: warning: no write access for dir containing '%s'\n",
pname, shortpath (NULL, path));
return 0;
}
static struct string_list *
string_list_cons (const char *string, struct string_list *rest)
{
- struct string_list *temp
- = (struct string_list *) xmalloc (sizeof (struct string_list));
+ struct string_list *temp = xmalloc (sizeof (struct string_list));
temp->next = rest;
temp->name = string;
if (!strcmp (p->symbol, search_symbol))
return p;
}
- p->hash_next = (hash_table_entry *) xmalloc (sizeof (hash_table_entry));
+ p->hash_next = xmalloc (sizeof (hash_table_entry));
p = p->hash_next;
return add_symbol (p, search_symbol);
}
free (p);
}
-/* Unexpand as many macro symbol as we can find.
+/* Unexpand as many macro symbols as we can find.
If the given line must be unexpanded, make a copy of it in the heap and
return a pointer to the unexpanded copy. Otherwise return NULL. */
if (line_buf == 0)
{
line_buf_size = 1024;
- line_buf = (char *) xmalloc (line_buf_size);
+ line_buf = xmalloc (line_buf_size);
}
copy_p = line_buf;
int offset = copy_p - line_buf;
line_buf_size *= 2;
line_buf_size += size;
- line_buf = (char *) xrealloc (line_buf, line_buf_size);
+ line_buf = xrealloc (line_buf, line_buf_size);
copy_p = line_buf + offset;
}
strcpy (copy_p, unexp_p->contracted);
{
int offset = copy_p - line_buf;
line_buf_size *= 2;
- line_buf = (char *) xrealloc (line_buf, line_buf_size);
+ line_buf = xrealloc (line_buf, line_buf_size);
copy_p = line_buf + offset;
}
*copy_p++ = *s++;
{
int offset = copy_p - line_buf;
line_buf_size *= 2;
- line_buf = (char *) xrealloc (line_buf, line_buf_size);
+ line_buf = xrealloc (line_buf, line_buf_size);
copy_p = line_buf + offset;
}
*copy_p++ = '\n';
{
/* Setup the current working directory as needed. */
const char *const cwd2 = (cwd) ? cwd : cwd_buffer;
- char *const abs_buffer
- = (char *) alloca (strlen (cwd2) + strlen (rel_filename) + 2);
+ char *const abs_buffer = alloca (strlen (cwd2) + strlen (rel_filename) + 2);
char *endp = abs_buffer;
char *outp, *inp;
size_t filename_len = strlen (filename);
path_p = abspath (cwd, filename);
- rel_buf_p = rel_buffer = (char *) xmalloc (filename_len);
+ rel_buf_p = rel_buffer = xmalloc (filename_len);
while (*cwd_p && IS_SAME_PATH_CHAR (*cwd_p, *path_p))
{
else
{
struct stat stat_buf;
- file_info *file_p = (file_info *) xmalloc (sizeof (file_info));
+ file_info *file_p = xmalloc (sizeof (file_info));
/* If we cannot get status on any given source file, give a warning
and then just set its time of last modification to infinity. */
#endif
)
p++;
- filename = (char *) alloca ((size_t) (p - filename_start) + 1);
+ filename = alloca ((size_t) (p - filename_start) + 1);
strncpy (filename, filename_start, (size_t) (p - filename_start));
filename[p-filename_start] = '\0';
}
{
const char *p;
const char *semicolon_p;
- def_dec_info *def_dec_p = (def_dec_info *) xmalloc (sizeof (def_dec_info));
+ def_dec_info *def_dec_p = xmalloc (sizeof (def_dec_info));
#ifndef UNPROTOIZE
def_dec_p->written = 0;
#endif
)
p++;
- filename = (char *) alloca ((size_t) (p - filename_start) + 1);
+ filename = alloca ((size_t) (p - filename_start) + 1);
strncpy (filename, filename_start, (size_t) (p - filename_start));
filename[p-filename_start] = '\0';
const char *left_paren_p = find_corresponding_lparen (p);
#ifndef UNPROTOIZE
{
- f_list_chain_item *cip
- = (f_list_chain_item *) xmalloc (sizeof (f_list_chain_item));
+ f_list_chain_item *cip = xmalloc (sizeof (f_list_chain_item));
cip->formals_list
= dupnstr (left_paren_p + 1, (size_t) (p - (left_paren_p+1)));
/* p now points to the leftmost character of the function name. */
{
- char *fn_string = (char *) alloca (past_fn - p + 1);
+ char *fn_string = alloca (past_fn - p + 1);
strncpy (fn_string, p, (size_t) (past_fn - p));
fn_string[past_fn-p] = '\0';
{
if (strcmp (def_dec_p->ansi_decl, other->ansi_decl))
{
- notice ("%s:%d: declaration of function `%s' takes different forms\n",
+ notice ("%s:%d: declaration of function '%s' takes different forms\n",
def_dec_p->file->hash_entry->symbol,
def_dec_p->line,
def_dec_p->hash_entry->symbol);
/* Build up the contents in a temporary vector
that is so big that to has to be big enough. */
const char **temp_params
- = (const char **) alloca ((strlen (params_list) + 8) * sizeof (char *));
+ = alloca ((strlen (params_list) + 8) * sizeof (char *));
int param_count = 0;
const char *param;
struct stat st;
/* Make a copy of the compile_params in heap space. */
- compile_params
- = (const char **) xmalloc (sizeof (char *) * (param_count+1));
+ compile_params = xmalloc (sizeof (char *) * (param_count+1));
memcpy (compile_params, temp_params, sizeof (char *) * param_count);
}
concat (compile_params[input_file_name_index], aux_info_suffix, NULL);
if (!quiet_flag)
- notice ("%s: compiling `%s'\n",
+ notice ("%s: compiling '%s'\n",
pname, compile_params[input_file_name_index]);
{
int is_syscalls)
{
size_t base_len = strlen (base_source_filename);
- char * aux_info_filename
- = (char *) alloca (base_len + strlen (aux_info_suffix) + 1);
+ char * aux_info_filename = alloca (base_len + strlen (aux_info_suffix) + 1);
char *aux_info_base;
char *aux_info_limit;
char *aux_info_relocated_name;
{
if (is_syscalls)
{
- notice ("%s: warning: missing SYSCALLS file `%s'\n",
+ notice ("%s: warning: missing SYSCALLS file '%s'\n",
pname, aux_info_filename);
return;
}
else
{
int errno_val = errno;
- notice ("%s: can't read aux info file `%s': %s\n",
+ notice ("%s: can't read aux info file '%s': %s\n",
pname, shortpath (NULL, aux_info_filename),
xstrerror (errno_val));
errors++;
if (access (aux_info_filename, R_OK) == -1)
{
int errno_val = errno;
- notice ("%s: can't read aux info file `%s': %s\n",
+ notice ("%s: can't read aux info file '%s': %s\n",
pname, shortpath (NULL, aux_info_filename),
xstrerror (errno_val));
errors++;
if (stat (aux_info_filename, &stat_buf) == -1)
{
int errno_val = errno;
- notice ("%s: can't get status of aux info file `%s': %s\n",
+ notice ("%s: can't get status of aux info file '%s': %s\n",
pname, shortpath (NULL, aux_info_filename),
xstrerror (errno_val));
errors++;
if (stat (base_source_filename, &stat_buf) == -1)
{
int errno_val = errno;
- notice ("%s: can't get status of aux info file `%s': %s\n",
+ notice ("%s: can't get status of aux info file '%s': %s\n",
pname, shortpath (NULL, base_source_filename),
xstrerror (errno_val));
errors++;
if ((aux_info_file = open (aux_info_filename, fd_flags, 0444 )) == -1)
{
int errno_val = errno;
- notice ("%s: can't open aux info file `%s' for reading: %s\n",
+ notice ("%s: can't open aux info file '%s' for reading: %s\n",
pname, shortpath (NULL, aux_info_filename),
xstrerror (errno_val));
return;
(int) aux_info_size)
{
int errno_val = errno;
- notice ("%s: error reading aux info file `%s': %s\n",
+ notice ("%s: error reading aux info file '%s': %s\n",
pname, shortpath (NULL, aux_info_filename),
xstrerror (errno_val));
free (aux_info_base);
if (close (aux_info_file))
{
int errno_val = errno;
- notice ("%s: error closing aux info file `%s': %s\n",
+ notice ("%s: error closing aux info file '%s': %s\n",
pname, shortpath (NULL, aux_info_filename),
xstrerror (errno_val));
free (aux_info_base);
if (unlink (aux_info_filename) == -1)
{
int errno_val = errno;
- notice ("%s: can't delete aux info file `%s': %s\n",
+ notice ("%s: can't delete aux info file '%s': %s\n",
pname, shortpath (NULL, aux_info_filename),
xstrerror (errno_val));
}
if (keep_it && unlink (aux_info_filename) == -1)
{
int errno_val = errno;
- notice ("%s: can't delete file `%s': %s\n",
+ notice ("%s: can't delete file '%s': %s\n",
pname, shortpath (NULL, aux_info_filename),
xstrerror (errno_val));
return;
{
const char *filename = hp->symbol;
int last_char_index = strlen (filename) - 1;
- char *const new_filename = (char *) alloca (strlen (filename)
- + strlen (cplus_suffix) + 1);
+ char *const new_filename = alloca (strlen (filename)
+ + strlen (cplus_suffix) + 1);
/* Note that we don't care here if the given file was converted or not. It
is possible that the given file was *not* converted, simply because there
if (rename (filename, new_filename) == -1)
{
int errno_val = errno;
- notice ("%s: warning: can't rename file `%s' to `%s': %s\n",
+ notice ("%s: warning: can't rename file '%s' to '%s': %s\n",
pname, shortpath (NULL, filename),
shortpath (NULL, new_filename), xstrerror (errno_val));
errors++;
{
extern_def_p = dd_p; /* save a pointer to the definition */
if (!quiet_flag)
- notice ("%s: warning: using formals list from %s(%d) for function `%s'\n",
+ notice ("%s: warning: using formals list from %s(%d) for function '%s'\n",
pname,
shortpath (NULL, dd_p->file->hash_entry->symbol),
dd_p->line, dd_p->hash_entry->symbol);
{
/* Why copy this string into `needed' at all?
Why not just use user->ansi_decl without copying? */
- char *needed = (char *) alloca (strlen (user->ansi_decl) + 1);
+ char *needed = alloca (strlen (user->ansi_decl) + 1);
char *p;
strcpy (needed, user->ansi_decl);
- p = (NONCONST char *) substr (needed, user->hash_entry->symbol)
+ p = strstr (needed, user->hash_entry->symbol)
+ strlen (user->hash_entry->symbol) + 2;
/* Avoid having ??? in the string. */
*p++ = '?';
*p++ = '?';
strcpy (p, ");");
- notice ("%s: %d: `%s' used but missing from SYSCALLS\n",
+ notice ("%s: %d: '%s' used but missing from SYSCALLS\n",
shortpath (NULL, file), user->line,
needed+7); /* Don't print "extern " */
}
#if 0
else
- notice ("%s: %d: warning: no extern definition for `%s'\n",
+ notice ("%s: %d: warning: no extern definition for '%s'\n",
shortpath (NULL, file), user->line,
user->hash_entry->symbol);
#endif
if (num_static_defs == 0)
{
if (!quiet_flag)
- notice ("%s: warning: no static definition for `%s' in file `%s'\n",
+ notice ("%s: warning: no static definition for '%s' in file '%s'\n",
pname, head->hash_entry->symbol,
shortpath (NULL, user->file->hash_entry->symbol));
}
else if (num_static_defs > 1)
{
- notice ("%s: multiple static defs of `%s' in file `%s'\n",
+ notice ("%s: multiple static defs of '%s' in file '%s'\n",
pname, head->hash_entry->symbol,
shortpath (NULL, user->file->hash_entry->symbol));
return NULL;
if ((repl_write_ptr + 1) + len >= repl_text_limit)
{
size_t new_size = (repl_text_limit - repl_text_base) << 1;
- char *new_buf = (char *) xrealloc (repl_text_base, new_size);
+ char *new_buf = xrealloc (repl_text_base, new_size);
repl_write_ptr = new_buf + (repl_write_ptr - repl_text_base);
repl_text_base = new_buf;
/* See if we have a stdarg function, or a function which has stdarg style
parameters or a stdarg style return type. */
- return substr (ansi_header, "...") != 0;
+ return strstr (ansi_header, "...") != 0;
#else /* !defined (UNPROTOIZE) */
{
const char *candidate;
- if ((candidate = substr (p, varargs_style_indicator)) == 0)
+ if ((candidate = strstr (p, varargs_style_indicator)) == 0)
return 0;
else
if (!is_id_char (candidate[-1]) && !is_id_char (candidate[len]))
if (setjmp (source_confusion_recovery))
{
restore_pointers ();
- notice ("%s: declaration of function `%s' not converted\n",
+ notice ("%s: declaration of function '%s' not converted\n",
pname, function_to_edit);
return;
}
else
{
if (!quiet_flag)
- notice ("%s: warning: too many parameter lists in declaration of `%s'\n",
+ notice ("%s: warning: too many parameter lists in declaration of '%s'\n",
pname, def_dec_p->hash_entry->symbol);
check_source (0, end_formals); /* leave the declaration intact */
}
if (this_f_list_chain_item)
{
if (!quiet_flag)
- notice ("\n%s: warning: too few parameter lists in declaration of `%s'\n",
+ notice ("\n%s: warning: too few parameter lists in declaration of '%s'\n",
pname, def_dec_p->hash_entry->symbol);
check_source (0, start_formals); /* leave the decl intact */
}
if (func_name_len != strlen (expected)
|| strncmp (func_name_start, expected, func_name_len))
{
- notice ("%s: %d: warning: found `%s' but expected `%s'\n",
+ notice ("%s: %d: warning: found '%s' but expected '%s'\n",
shortpath (NULL, def_dec_p->file->hash_entry->symbol),
identify_lineno (func_name_start),
dupnstr (func_name_start, func_name_len),
if (setjmp (source_confusion_recovery))
{
restore_pointers ();
- notice ("%s: local declaration for function `%s' not inserted\n",
+ notice ("%s: local declaration for function '%s' not inserted\n",
pname, function_to_edit);
return;
}
if (*start_of_block != '{')
{
if (!quiet_flag)
- notice ("\n%s: %d: warning: can't add declaration of `%s' into macro call\n",
+ notice ("\n%s: %d: warning: can't add declaration of '%s' into macro call\n",
def_dec_p->file->hash_entry->symbol, def_dec_p->line,
def_dec_p->hash_entry->symbol);
return;
if (setjmp (source_confusion_recovery))
{
restore_pointers ();
- notice ("%s: global declarations for file `%s' not inserted\n",
+ notice ("%s: global declarations for file '%s' not inserted\n",
pname, shortpath (NULL, file_p->hash_entry->symbol));
return;
}
if (setjmp (source_confusion_recovery))
{
restore_pointers ();
- notice ("%s: definition of function `%s' not converted\n",
+ notice ("%s: definition of function '%s' not converted\n",
pname, function_to_edit);
return;
}
if (edit_formals_lists (end_formals, def_dec_p->f_list_count, def_dec_p))
{
restore_pointers ();
- notice ("%s: definition of function `%s' not converted\n",
+ notice ("%s: definition of function '%s' not converted\n",
pname, function_to_edit);
return;
}
goto not_missed;
{
- char *func_name = (char *) alloca (id_length + 1);
+ char *func_name = alloca (id_length + 1);
static const char * const stmt_keywords[]
= { "if", "else", "do", "while", "for", "switch", "case", "return", 0 };
const char * const *stmt_keyword;
goto not_missed;
#if 0
- notice ("%s: found definition of `%s' at %s(%d)\n",
+ notice ("%s: found definition of '%s' at %s(%d)\n",
pname,
func_name,
shortpath (NULL, file_p->hash_entry->symbol),
/* If we make it here, then we did not know about this
function definition. */
- notice ("%s: %d: warning: `%s' excluded by preprocessing\n",
+ notice ("%s: %d: warning: '%s' excluded by preprocessing\n",
shortpath (NULL, file_p->hash_entry->symbol),
identify_lineno (id_start), func_name);
notice ("%s: function definition not converted\n",
&& !in_system_include_dir (convert_filename)
#endif /* defined (UNPROTOIZE) */
)
- notice ("%s: `%s' not converted\n",
+ notice ("%s: '%s' not converted\n",
pname, shortpath (NULL, convert_filename));
return;
}
/* Let the user know what we are up to. */
if (nochange_flag)
- notice ("%s: would convert file `%s'\n",
+ notice ("%s: would convert file '%s'\n",
pname, shortpath (NULL, convert_filename));
else
- notice ("%s: converting file `%s'\n",
+ notice ("%s: converting file '%s'\n",
pname, shortpath (NULL, convert_filename));
fflush (stderr);
if (stat (convert_filename, &stat_buf) == -1)
{
int errno_val = errno;
- notice ("%s: can't get status for file `%s': %s\n",
+ notice ("%s: can't get status for file '%s': %s\n",
pname, shortpath (NULL, convert_filename),
xstrerror (errno_val));
return;
/* Allocate a buffer to hold the original text. */
- orig_text_base = new_orig_text_base = (char *) xmalloc (orig_size + 2);
+ orig_text_base = new_orig_text_base = xmalloc (orig_size + 2);
orig_text_limit = new_orig_text_limit = new_orig_text_base + orig_size;
/* Allocate a buffer to hold the cleaned-up version of the original text. */
- clean_text_base = new_clean_text_base = (char *) xmalloc (orig_size + 2);
+ clean_text_base = new_clean_text_base = xmalloc (orig_size + 2);
clean_text_limit = new_clean_text_limit = new_clean_text_base + orig_size;
clean_read_ptr = clean_text_base - 1;
buffer can be expanded later as needed. */
repl_size = orig_size + (orig_size >> 2) + 4096;
- repl_text_base = (char *) xmalloc (repl_size + 2);
+ repl_text_base = xmalloc (repl_size + 2);
repl_text_limit = repl_text_base + repl_size - 1;
repl_write_ptr = repl_text_base - 1;
if ((input_file = open (convert_filename, fd_flags, 0444)) == -1)
{
int errno_val = errno;
- notice ("%s: can't open file `%s' for reading: %s\n",
+ notice ("%s: can't open file '%s' for reading: %s\n",
pname, shortpath (NULL, convert_filename),
xstrerror (errno_val));
return;
{
int errno_val = errno;
close (input_file);
- notice ("\n%s: error reading input file `%s': %s\n",
+ notice ("\n%s: error reading input file '%s': %s\n",
pname, shortpath (NULL, convert_filename),
xstrerror (errno_val));
return;
{
int clean_file;
size_t clean_size = orig_text_limit - orig_text_base;
- char *const clean_filename = (char *) alloca (strlen (convert_filename) + 6 + 1);
+ char *const clean_filename = alloca (strlen (convert_filename) + 6 + 1);
/* Open (and create) the clean file. */
if ((clean_file = creat (clean_filename, 0666)) == -1)
{
int errno_val = errno;
- notice ("%s: can't create/open clean file `%s': %s\n",
+ notice ("%s: can't create/open clean file '%s': %s\n",
pname, shortpath (NULL, clean_filename),
xstrerror (errno_val));
return;
if (!nosave_flag)
{
char *new_filename
- = (char *) xmalloc (strlen (convert_filename) + strlen (save_suffix) + 2);
+ = xmalloc (strlen (convert_filename) + strlen (save_suffix) + 2);
strcpy (new_filename, convert_filename);
#ifdef __MSDOS__
if (access (new_filename, F_OK) == 0)
{
if (!quiet_flag)
- notice ("%s: warning: file `%s' already saved in `%s'\n",
+ notice ("%s: warning: file '%s' already saved in '%s'\n",
pname,
shortpath (NULL, convert_filename),
shortpath (NULL, new_filename));
else if (rename (convert_filename, new_filename) == -1)
{
int errno_val = errno;
- notice ("%s: can't link file `%s' to `%s': %s\n",
+ notice ("%s: can't link file '%s' to '%s': %s\n",
pname,
shortpath (NULL, convert_filename),
shortpath (NULL, new_filename),
/* The file may have already been renamed. */
if (errno_val != ENOENT)
{
- notice ("%s: can't delete file `%s': %s\n",
+ notice ("%s: can't delete file '%s': %s\n",
pname, shortpath (NULL, convert_filename),
xstrerror (errno_val));
return;
if ((output_file = creat (convert_filename, 0666)) == -1)
{
int errno_val = errno;
- notice ("%s: can't create/open output file `%s': %s\n",
+ notice ("%s: can't create/open output file '%s': %s\n",
pname, shortpath (NULL, convert_filename),
xstrerror (errno_val));
return;
if (chmod (convert_filename, stat_buf.st_mode) == -1)
{
int errno_val = errno;
- notice ("%s: can't change mode of file `%s': %s\n",
+ notice ("%s: can't change mode of file '%s': %s\n",
pname, shortpath (NULL, convert_filename),
xstrerror (errno_val));
}
if (nondefault_syscalls_dir)
{
syscalls_absolute_filename
- = (char *) xmalloc (strlen (nondefault_syscalls_dir) + 1
- + sizeof (syscalls_filename));
+ = xmalloc (strlen (nondefault_syscalls_dir) + 1
+ + sizeof (syscalls_filename));
strcpy (syscalls_absolute_filename, nondefault_syscalls_dir);
}
else
default_syscalls_dir = standard_exec_prefix;
}
syscalls_absolute_filename
- = (char *) xmalloc (strlen (default_syscalls_dir) + 0
- + strlen (target_machine) + 1
- + strlen (target_version) + 1
- + sizeof (syscalls_filename));
+ = xmalloc (strlen (default_syscalls_dir) + 0
+ + strlen (target_machine) + 1
+ + strlen (target_version) + 1
+ + sizeof (syscalls_filename));
strcpy (syscalls_absolute_filename, default_syscalls_dir);
strcat (syscalls_absolute_filename, target_machine);
strcat (syscalls_absolute_filename, "/");
/* Now actually make a list of the base source filenames. */
base_source_filenames
- = (const char **) xmalloc ((n_base_source_files + 1) * sizeof (char *));
+ = xmalloc ((n_base_source_files + 1) * sizeof (char *));
n_base_source_files = 0;
for (; optind < argc; optind++)
{