+2005-06-20 Hrvoje Niksic <hniksic@xemacs.org>
+
+ * configure.in: Don't check for the return type of signal
+ handlers; C89 requires it to be void.
+
2005-06-19 Hrvoje Niksic <hniksic@xemacs.org>
* aclocal.m4: Remove support for K&R compilers.
AC_TYPE_SIZE_T
AC_TYPE_PID_T
AC_CHECK_TYPES(uint32_t)
-AC_TYPE_SIGNAL
AC_CHECK_TYPES(sig_atomic_t, [], [], [
#include <stdio.h>
#include <sys/types.h>
+2005-06-20 Hrvoje Niksic <hniksic@xemacs.org>
+
+ * all: Return type of signal handlers is `void'. Include signal.h
+ unconditionally.
+
+ * all: Don't explicitly cast values returned by malloc. We no
+ longer support ancient compilers that don't declare malloc, and we
+ never supported C++ builds.
+
2005-06-19 Hrvoje Niksic <hniksic@xemacs.org>
* all: Don't declare errno. Include both time.h and sys/time.h,
}
/* Construct LINK as explained above. */
- link = (char *)xmalloc (3 * basedirs + strlen (linkfile) + 1);
+ link = xmalloc (3 * basedirs + strlen (linkfile) + 1);
for (i = 0; i < basedirs; i++)
memcpy (link + 3 * i, "../", 3);
strcpy (link + 3 * i, linkfile);
else if (*s == ' ')
i += 4; /* #32; */
}
- res = (char *)xmalloc (i + 1);
+ res = xmalloc (i + 1);
s = b;
for (p = res; *s; s++)
{
default -F output. I believe these cases are very
rare. */
fnlen = strlen (tok); /* re-calculate `fnlen' */
- cur.name = (char *)xmalloc (fnlen + 1);
+ cur.name = xmalloc (fnlen + 1);
memcpy (cur.name, tok, fnlen + 1);
if (fnlen)
{
/* And put everything into the linked list */
if (!dir)
{
- l = dir = (struct fileinfo *)xmalloc (sizeof (struct fileinfo));
+ l = dir = xnew (struct fileinfo);
memcpy (l, &cur, sizeof (cur));
l->prev = l->next = NULL;
}
else
{
cur.prev = l;
- l->next = (struct fileinfo *)xmalloc (sizeof (struct fileinfo));
+ l->next = xnew (struct fileinfo);
l = l->next;
memcpy (l, &cur, sizeof (cur));
l->next = NULL;
/* Hash tables.
- Copyright (C) 2000, 2001 Free Software Foundation, Inc.
+ Copyright (C) 2000-2003 Free Software Foundation, Inc.
This file is part of GNU Wget.
/* Make do without them. */
# define xnew(x) xmalloc (sizeof (x))
# define xnew_array(type, x) xmalloc (sizeof (type) * (x))
-# define xmalloc malloc /* or something that exits
- if not enough memory */
+# define xmalloc malloc
# define xfree free
# define countof(x) (sizeof (x) / sizeof ((x)[0]))
# define TOLOWER(x) ('A' <= (x) && (x) <= 'Z' ? (x) - 32 : (x))
if (ga_newsize != (sizevar)) \
{ \
if (resized) \
- basevar = (type *)xrealloc (basevar, ga_newsize * sizeof (type)); \
+ basevar = xrealloc (basevar, ga_newsize * sizeof (type)); \
else \
{ \
void *ga_new = xmalloc (ga_newsize * sizeof (type)); \
int main ()
{
int size = 256;
- char *x = (char *)xmalloc (size);
+ char *x = xmalloc (size);
int length = 0;
int read_count;
int tag_counter = 0;
{
length += read_count;
size <<= 1;
- x = (char *)xrealloc (x, size);
+ x = xrealloc (x, size);
}
map_html_tags (x, length, test_mapper, &tag_counter, 0, NULL, NULL);
gen_md5_finish (ctx, hash);
dump_hash (response_digest, hash);
- res = (char*) xmalloc (strlen (user)
- + strlen (user)
- + strlen (realm)
- + strlen (nonce)
- + strlen (path)
- + 2 * MD5_HASHLEN /*strlen (response_digest)*/
- + (opaque ? strlen (opaque) : 0)
- + 128);
+ res = xmalloc (strlen (user)
+ + strlen (user)
+ + strlen (realm)
+ + strlen (nonce)
+ + strlen (path)
+ + 2 * MD5_HASHLEN /*strlen (response_digest)*/
+ + (opaque ? strlen (opaque) : 0)
+ + 128);
sprintf (res, "Digest \
username=\"%s\", realm=\"%s\", nonce=\"%s\", uri=\"%s\", response=\"%s\"",
user, realm, nonce, path, response_digest);
{
/* Allocate memory and concatenate the old and the new
contents. */
- ln->malloced_line = (char *)xmalloc (old_len + len + 1);
+ ln->malloced_line = xmalloc (old_len + len + 1);
memcpy (ln->malloced_line, ln->static_line,
old_len);
memcpy (ln->malloced_line + old_len, start, len);
# include <unistd.h>
#endif /* HAVE_UNISTD_H */
#include <string.h>
-#ifdef HAVE_SIGNAL_H
-# include <signal.h>
-#endif
+#include <signal.h>
#ifdef HAVE_NLS
#ifdef HAVE_LOCALE_H
# include <locale.h>
extern struct cookie_jar *wget_cookie_jar;
-static RETSIGTYPE redirect_output_signal (int);
+static void redirect_output_signal (int);
const char *exec_name;
\f
#ifdef HAVE_SIGNAL
/* Hangup signal handler. When wget receives SIGHUP or SIGUSR1, it
will proceed operation as usual, trying to write into a log file.
- If that is impossible, the output will be turned off.
-
- #### It is unsafe to do call libc functions from a signal handler.
- What we should do is, set a global variable, and have the code in
- log.c pick it up. */
+ If that is impossible, the output will be turned off. */
-static RETSIGTYPE
+static void
redirect_output_signal (int sig)
{
const char *signal_name = (sig == SIGHUP ? "SIGHUP" :
{
xfree_null (title_buf);
xfree_null (curr_url);
- title_buf = (char *)xmalloc (strlen (url) + 20);
+ title_buf = xmalloc (strlen (url) + 20);
curr_url = xstrdup (url);
old_percentage = -1;
sprintf (title_buf, "Wget %s", curr_url);
{
int length = 0;
int bufsize = 81;
- char *line = (char *)xmalloc (bufsize);
+ char *line = xmalloc (bufsize);
while (fgets (line + length, bufsize - length, fp))
{
}
/* Allocate a new acc_t structure. */
- a = (acc_t *)xmalloc (sizeof (acc_t));
+ a = xmalloc (sizeof (acc_t));
}
/* Zero the structure, so that it is ready to use. */
#ifdef HAVE_UNISTD_H
# include <unistd.h>
#endif
-#ifdef HAVE_SIGNAL_H
-# include <signal.h>
-#endif
+#include <signal.h>
#include "wget.h"
#include "progress.h"
}
#ifdef SIGWINCH
-RETSIGTYPE
+void
progress_handle_sigwinch (int sig)
{
received_sigwinch = 1;
void progress_update (void *, wgint, double);
void progress_finish (void *, double);
-RETSIGTYPE progress_handle_sigwinch (int);
+void progress_handle_sigwinch (int);
#endif /* PROGRESS_H */
return allow_passthrough ? (char *)s : xstrdup (s);
newlen = (p1 - s) + addition;
- newstr = (char *)xmalloc (newlen + 1);
+ newstr = xmalloc (newlen + 1);
p1 = s;
p2 = newstr;
url_full_path (const struct url *url)
{
int length = full_path_length (url);
- char *full_path = (char *) xmalloc (length + 1);
+ char *full_path = xmalloc (length + 1);
full_path_write (url, full_path);
full_path[length] = '\0';
start_insert = base;
span = start_insert - base;
- merge = (char *)xmalloc (span + linklength + 1);
+ merge = xmalloc (span + linklength + 1);
if (span)
memcpy (merge, base, span);
memcpy (merge + span, link, linklength);
start_insert = slash;
span = start_insert - base;
- merge = (char *)xmalloc (span + linklength + 1);
+ merge = xmalloc (span + linklength + 1);
if (span)
memcpy (merge, base, span);
memcpy (merge + span, link, linklength);
}
span = start_insert - base;
- merge = (char *)xmalloc (span + linklength + 1);
+ merge = xmalloc (span + linklength + 1);
if (span)
memcpy (merge, base, span);
if (need_explicit_slash)
#ifdef HAVE_PWD_H
# include <pwd.h>
#endif
-#ifdef HAVE_LIMITS_H
-# include <limits.h>
-#endif
#ifdef HAVE_UTIME_H
# include <utime.h>
#endif
#endif
/* Needed for run_with_timeout. */
-#undef USE_SIGNAL_TIMEOUT
-#ifdef HAVE_SIGNAL_H
-# include <signal.h>
-#endif
+#include <signal.h>
#ifdef HAVE_SETJMP_H
# include <setjmp.h>
#endif
# endif
#endif
+#undef USE_SIGNAL_TIMEOUT
#ifdef HAVE_SIGNAL
-# ifdef HAVE_SIGSETJMP
-# define USE_SIGNAL_TIMEOUT
-# endif
-# ifdef HAVE_SIGBLOCK
+# if defined(HAVE_SIGSETJMP) || defined(HAVE_SIGBLOCK)
# define USE_SIGNAL_TIMEOUT
# endif
#endif
char *
strdupdelim (const char *beg, const char *end)
{
- char *res = (char *)xmalloc (end - beg + 1);
+ char *res = xmalloc (end - beg + 1);
memcpy (res, beg, end - beg);
res[end - beg] = '\0';
return res;
{
if (*s == ',')
{
- res = (char **)xrealloc (res, (i + 2) * sizeof (char *));
+ res = xrealloc (res, (i + 2) * sizeof (char *));
res[i] = strdupdelim (p, s);
res[++i] = NULL;
++s;
else
++s;
}
- res = (char **)xrealloc (res, (i + 2) * sizeof (char *));
+ res = xrealloc (res, (i + 2) * sizeof (char *));
res[i] = strdupdelim (p, s);
res[i + 1] = NULL;
return res;
if (!cut)
return xstrdup (file);
- result = (char *)xmalloc (cut - base + 1 + strlen (file) + 1);
+ result = xmalloc (cut - base + 1 + strlen (file) + 1);
memcpy (result, base, cut - base);
result[cut - base] = '/';
strcpy (result + (cut - base) + 1, file);
{
int length = 0;
int bufsize = 82;
- char *line = (char *)xmalloc (bufsize);
+ char *line = xmalloc (bufsize);
while (fgets (line + length, bufsize - length, fp))
{
/* Count v2. */
for (j = 0; v2[j]; j++);
/* Reallocate v1. */
- v1 = (char **)xrealloc (v1, (i + j + 1) * sizeof (char **));
+ v1 = xrealloc (v1, (i + j + 1) * sizeof (char **));
memcpy (v1 + i, v2, (j + 1) * sizeof (char *));
xfree (v2);
return v1;
static sigjmp_buf run_with_timeout_env;
-static RETSIGTYPE
+static void
abort_run_with_timeout (int sig)
{
assert (sig == SIGALRM);
static jmp_buf run_with_timeout_env;
-static RETSIGTYPE
+static void
abort_run_with_timeout (int sig)
{
assert (sig == SIGALRM);
(sizevar) = DR_newsize; \
} \
if (DR_newsize) \
- basevar = (type *)xrealloc (basevar, DR_newsize * sizeof (type)); \
+ basevar = xrealloc (basevar, DR_newsize * sizeof (type)); \
} while (0)
/* Used to print pointers (usually for debugging). Print pointers
necessary in standard C, but Wget performs them anyway for the sake
of pre-standard environments and possibly C++. */
-#define xnew(type) ((type *) xmalloc (sizeof (type)))
-#define xnew0(type) ((type *) xmalloc0 (sizeof (type)))
-#define xnew_array(type, len) ((type *) xmalloc ((len) * sizeof (type)))
-#define xnew0_array(type, len) ((type *) xmalloc0 ((len) * sizeof (type)))
+#define xnew(type) (xmalloc (sizeof (type)))
+#define xnew0(type) (xmalloc0 (sizeof (type)))
+#define xnew_array(type, len) (xmalloc ((len) * sizeof (type)))
+#define xnew0_array(type, len) (xmalloc0 ((len) * sizeof (type)))
#define alloca_array(type, size) ((type *) alloca ((size) * sizeof (type)))