#ifndef WGET_H
#define WGET_H
-#ifndef DEBUG
-# define NDEBUG /* To kill off assertions */
-#endif /* not DEBUG */
+/* Disable assertions when debug support is not compiled in. */
+#ifndef ENABLE_DEBUG
+# define NDEBUG
+#endif
/* Define this if you want primitive but extensive malloc debugging.
It will make Wget extremely slow, so only do it in development
/* No-op version of gettext, used for constant strings. */
#define N_(string) (string)
-/* I18N NOTE: You will notice that none of the DEBUG messages are
+/* I18N NOTE: You will notice that none of the DEBUGP messages are
marked as translatable. This is intentional, for a few reasons:
1) The debug messages are not meant for the users to look at, but
#define DO_NOTHING do {} while (0)
/* Print X if debugging is enabled; a no-op otherwise. */
-#ifdef DEBUG
+#ifdef ENABLE_DEBUG
# define DEBUGP(x) do { if (opt.debug) { debug_logprintf x; } } while (0)
-#else /* not DEBUG */
+#else /* not ENABLE_DEBUG */
# define DEBUGP(x) DO_NOTHING
-#endif /* not DEBUG */
-
-/* Make gcc check for the format of logmsg() and debug_logmsg(). */
-#ifdef __GNUC__
-# define GCC_FORMAT_ATTR(a, b) __attribute__ ((format (printf, a, b)))
-#else /* not __GNUC__ */
-# define GCC_FORMAT_ATTR(a, b)
-#endif /* not __GNUC__ */
-
-/* These are from log.c, but they are used everywhere, so we declare
- them here. */
-enum log_options { LOG_VERBOSE, LOG_NOTQUIET, LOG_NONVERBOSE, LOG_ALWAYS };
-
-#ifdef HAVE_STDARG_H
-void logprintf PARAMS ((enum log_options, const char *, ...))
- GCC_FORMAT_ATTR (2, 3);
-void debug_logprintf PARAMS ((const char *, ...)) GCC_FORMAT_ATTR (1, 2);
-#else /* not HAVE_STDARG_H */
-void logprintf ();
-void debug_logprintf ();
-#endif /* not HAVE_STDARG_H */
-void logputs PARAMS ((enum log_options, const char *));
-void logflush PARAMS ((void));
-void log_set_flush PARAMS ((int));
-int log_set_save_context PARAMS ((int));
-
-/* Defined in `utils.c', but used literally everywhere. */
-#ifndef DEBUG_MALLOC
-
-#define xmalloc xmalloc_real
-#define xrealloc xrealloc_real
-#define xstrdup xstrdup_real
-#define xfree free
-
-void *xmalloc_real PARAMS ((size_t));
-void *xrealloc_real PARAMS ((void *, size_t));
-char *xstrdup_real PARAMS ((const char *));
-
-#else /* DEBUG_MALLOC */
-
-#define xmalloc(s) xmalloc_debug (s, __FILE__, __LINE__)
-#define xfree(p) xfree_debug (p, __FILE__, __LINE__)
-#define xrealloc(p, s) xrealloc_debug (p, s, __FILE__, __LINE__)
-#define xstrdup(p) xstrdup_debug (p, __FILE__, __LINE__)
-
-void *xmalloc_debug PARAMS ((size_t, const char *, int));
-void xfree_debug PARAMS ((void *, const char *, int));
-void *xrealloc_debug PARAMS ((void *, size_t, const char *, int));
-char *xstrdup_debug PARAMS ((const char *, const char *, int));
-
-#endif /* DEBUG_MALLOC */
+#endif /* not ENABLE_DEBUG */
+
+/* Everything uses this, so include them here directly. */
+#include "xmalloc.h"
+
+/* Likewise for logging functions. */
+#include "log.h"
/* #### Find a better place for this. */
/* The log file to which Wget writes to after HUP. */
#define DEFAULT_LOGFILE "wget-log"
-
-#define MD5_HASHLEN 16
\f
/* Useful macros used across the code: */
-/* Is the string a hpyhen-only? */
-#define HYPHENP(x) (*(x) == '-' && !*((x) + 1))
+/* The number of elements in an array. For example:
+ static char a[] = "foo"; -- countof(a) == 4 (for terminating \0)
+ int a[5] = {1, 2}; -- countof(a) == 5
+ char *a[] = { -- countof(a) == 3
+ "foo", "bar", "baz"
+ }; */
+#define countof(array) (sizeof (array) / sizeof ((array)[0]))
-/* The smaller value of the two. */
-#define MINVAL(x, y) ((x) < (y) ? (x) : (y))
+/* Zero out a value. */
+#define xzero(x) memset (&(x), '\0', sizeof ((x)))
/* Convert an ASCII hex digit to the corresponding number between 0
and 15. X should be a hexadecimal digit that satisfies isxdigit;
otherwise, the result is undefined. */
-#define XDIGIT_TO_NUM(x) ((x) < 'A' ? (x) - '0' : TOUPPER (x) - 'A' + 10)
-
-/* Convert a sequence of ASCII hex digits X and Y to a number betewen
- 0 and 255. Uses XDIGIT_TO_NUM for conversion of individual
- digits. */
+#define XDIGIT_TO_NUM(h) ((h) < 'A' ? (h) - '0' : TOUPPER (h) - 'A' + 10)
#define X2DIGITS_TO_NUM(h1, h2) ((XDIGIT_TO_NUM (h1) << 4) + XDIGIT_TO_NUM (h2))
/* The reverse of the above: convert a number in the [0, 16) range to
- its ASCII representation in hex. The A-F characters are in upper
- case. */
-#define XNUM_TO_DIGIT(x) ("0123456789ABCDEF"[x])
-
-/* Like XNUM_TO_DIGIT, but generates lower-case characters. */
-#define XNUM_TO_digit(x) ("0123456789abcdef"[x])
-
-/* Returns the number of elements in an array with fixed
- initialization. For example:
-
- static char a[] = "foo"; -- countof(a) == 4 (for terminating \0)
-
- int a[5] = {1, 2}; -- countof(a) == 5
-
- char *a[3] = { -- countof(a) == 3
- "foo", "bar", "baz"
- };
-
- And, most importantly, it works when the compiler counts the array
- elements for you:
-
- char *a[] = { -- countof(a) == 4
- "foo", "bar", "baz", "qux"
- } */
-#define countof(array) (sizeof (array) / sizeof (*(array)))
+ the ASCII representation of the corresponding hex digit. The `+ 0'
+ is so you don't accidentally use it as an lvalue. */
+#define XNUM_TO_DIGIT(x) ("0123456789ABCDEF"[x] + 0)
+#define XNUM_TO_digit(x) ("0123456789abcdef"[x] + 0)
/* Copy the data delimited with BEG and END to alloca-allocated
storage, and zero-terminate it. Arguments are evaluated only once,
#define STRDUP_ALLOCA(str) (strcpy ((char *)alloca (strlen (str) + 1), str))
This is because some compilers don't handle alloca() as argument to
- function correctly. Gcc under Intel has been reported to offend in
- this case. */
-
-#define STRDUP_ALLOCA(ptr, str) do { \
- (ptr) = (char *)alloca (strlen (str) + 1); \
- strcpy (ptr, str); \
+ function correctly. Gcc on Intel platforms has been reported to
+ offend in this case. */
+
+#define STRDUP_ALLOCA(ptr, str) do { \
+ char **SA_dest = &(ptr); \
+ const char *SA_src = (str); \
+ *SA_dest = (char *)alloca (strlen (SA_src) + 1); \
+ strcpy (*SA_dest, SA_src); \
} while (0)
-#define ALLOCA_ARRAY(type, len) ((type *) alloca ((len) * sizeof (type)))
-
-#define XREALLOC_ARRAY(ptr, type, len) \
- ((void) (ptr = (type *) xrealloc (ptr, (len) * sizeof (type))))
-
/* Generally useful if you want to avoid arbitrary size limits but
don't need a full dynamic array. Assumes that BASEVAR points to a
malloced array of TYPE objects (or possibly a NULL pointer, if
will realloc BASEVAR as necessary so that it can hold at least
NEEDED_SIZE objects. The reallocing is done by doubling, which
ensures constant amortized time per element. */
-#define DO_REALLOC(basevar, sizevar, needed_size, type) do \
-{ \
- /* Avoid side-effectualness. */ \
- long do_realloc_needed_size = (needed_size); \
- long do_realloc_newsize = 0; \
- while ((sizevar) < (do_realloc_needed_size)) { \
- do_realloc_newsize = 2*(sizevar); \
- if (do_realloc_newsize < 32) \
- do_realloc_newsize = 32; \
- (sizevar) = do_realloc_newsize; \
- } \
- if (do_realloc_newsize) \
- XREALLOC_ARRAY (basevar, type, do_realloc_newsize); \
-} while (0)
-
-/* Use this for small stack-allocated memory chunks that might grow.
- The initial array is created using alloca(), and this macro
- requests it to grow. If the needed size is larger than the array,
- this macro will use malloc to allocate it to new size, and copy the
- old contents. After that, successive invocations behave just like
- DO_REALLOC. */
-#define DO_REALLOC_FROM_ALLOCA(basevar, sizevar, needed_size, allocap, type) do \
-{ \
- /* Avoid side-effectualness. */ \
+#define DO_REALLOC(basevar, sizevar, needed_size, type) do { \
+ /* Avoid side effects by prefixing the local vars. */ \
long do_realloc_needed_size = (needed_size); \
- long do_realloc_newsize = (sizevar); \
- while (do_realloc_newsize < do_realloc_needed_size) { \
- do_realloc_newsize <<= 1; \
- if (do_realloc_newsize < 16) \
- do_realloc_newsize = 16; \
+ long do_realloc_newsize = 0; \
+ while ((sizevar) < (do_realloc_needed_size)) { \
+ do_realloc_newsize = 2*(sizevar); \
+ if (do_realloc_newsize < 32) \
+ do_realloc_newsize = 32; \
+ (sizevar) = do_realloc_newsize; \
} \
- if (do_realloc_newsize != (sizevar)) \
- { \
- if (!allocap) \
- XREALLOC_ARRAY (basevar, type, do_realloc_newsize); \
- else \
- { \
- void *drfa_new_basevar = \
- xmalloc (do_realloc_newsize * sizeof (type)); \
- memcpy (drfa_new_basevar, basevar, (sizevar) * sizeof (type)); \
- (basevar) = drfa_new_basevar; \
- allocap = 0; \
- } \
- (sizevar) = do_realloc_newsize; \
- } \
+ if (do_realloc_newsize) \
+ basevar = (type *)xrealloc (basevar, do_realloc_newsize * sizeof (type)); \
} while (0)
/* Free FOO if it is non-NULL. */
-#define FREE_MAYBE(foo) do { if (foo) xfree (foo); } while (0)
+#define FREE_MAYBE(foo) do { if (foo) xfree ((foo)); } while (0)
extern const char *exec_name;
\f
typedef enum
{
NOCONERROR, HOSTERR, CONSOCKERR, CONERROR, CONSSLERR,
- CONREFUSED, NEWLOCATION, NOTENOUGHMEM, CONPORTERR,
+ CONIMPOSSIBLE, NEWLOCATION, NOTENOUGHMEM, CONPORTERR,
BINDERR, BINDOK, LISTENERR, ACCEPTERR, ACCEPTOK,
CONCLOSED, FTPOK, FTPLOGINC, FTPLOGREFUSED, FTPPORTERR,
FTPNSFOD, FTPRETROK, FTPUNKNOWNTYPE, FTPRERR,
SSLERRCERTFILE,SSLERRCERTKEY,SSLERRCTXCREATE
} uerr_t;
+/* These are not used widely. They should either be removed or used
+ consistently. */
typedef unsigned char boolean;
#ifndef FALSE
-#define FALSE 0
+# define FALSE 0
#endif
#ifndef TRUE
-#define TRUE 1
+# define TRUE 1
#endif
-/* So we can say strcmp(a, b) == EQ rather than strcmp(a, b) == 0 or
- the really awful !strcmp(a, b). */
-#define EQ 0
-
-/* For most options, 0 means no limits, but with -p in the picture, that causes
- a problem on the maximum recursion depth variable. To retain backwards
- compatibility we allow users to consider "0" to be synonymous with "inf" for
- -l, but internally infinite recursion is specified by -1 and 0 means to only
- retrieve the requisites of a single document. */
+/* For most options, 0 means no limits, but with -p in the picture,
+ that causes a problem on the maximum recursion depth variable. To
+ retain backwards compatibility we allow users to consider "0" to be
+ synonymous with "inf" for -l, but internally infinite recursion is
+ specified by -1 and 0 means to only retrieve the requisites of a
+ single document. */
#define INFINITE_RECURSION -1
-#define CONNECT_ERROR(x) ((x) == ECONNREFUSED && !opt.retry_connrefused \
- ? CONREFUSED : CONERROR)
+/* In case old systems don't have EAFNOSUPPORT, which we use below. */
+#ifndef EAFNOSUPPORT
+# define EAFNOSUPPORT EINVAL
+#endif
+
+#define CONNECT_ERROR(err) (( (err) == EAFNOSUPPORT \
+ || (err) == EINVAL \
+ || ((err) == ECONNREFUSED \
+ && !opt.retry_connrefused)) \
+ ? CONIMPOSSIBLE : CONERROR)
#endif /* WGET_H */
projects / wget / blobdiff