X-Git-Url: http://sjero.net/git/?p=wget;a=blobdiff_plain;f=src%2Fwget.h;h=16269bf387d94286f98589cb3cf6b8a44ee5d594;hp=e9191387a561dff2f6d217810eae0982ed1a4c2d;hb=2f6aa1d7417df1dfc58597777686fbd77179b9fd;hpb=562ab4ae8af558352a00f1ad7ed55cae1cf2b26a

diff --git a/src/wget.h b/src/wget.h
index e9191387..16269bf3 100644
--- a/src/wget.h
+++ b/src/wget.h
@@ -1,11 +1,13 @@
 /* Miscellaneous declarations.
-   Copyright (C) 1995, 1996, 1997, 1998 Free Software Foundation, Inc.
+   Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004,
+   2005, 2006, 2007, 2008, 2009, 2010, 2011 Free Software Foundation,
+   Inc.
 
 This file is part of GNU Wget.
 
 GNU Wget is free software; you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
+the Free Software Foundation; either version 3 of the License, or
 (at your option) any later version.
 
 GNU Wget is distributed in the hope that it will be useful,
@@ -14,45 +16,76 @@ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.
 
 You should have received a copy of the GNU General Public License
-along with Wget; if not, write to the Free Software
-Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
+along with Wget.  If not, see <http://www.gnu.org/licenses/>.
 
-/* This file contains some declarations that don't fit anywhere else.
-   It also contains some useful includes, like the obnoxious TIME_H
-   inclusion.  */
+Additional permission under GNU GPL version 3 section 7
+
+If you modify this program, or any covered work, by linking or
+combining it with the OpenSSL project's OpenSSL library (or a
+modified version of that library), containing parts covered by the
+terms of the OpenSSL or SSLeay licenses, the Free Software Foundation
+grants you additional permission to convey the resulting work.
+Corresponding Source for a non-source form of such a combination
+shall include the source code for the parts of OpenSSL used as well
+as that of the covered work.  */
+
+/* This file contains declarations that are universally useful and
+   those that don't fit elsewhere.  It also includes sysdep.h which
+   includes some often-needed system includes, like the obnoxious
+   <time.h> inclusion.  */
 
 #ifndef WGET_H
 #define WGET_H
 
-#ifndef DEBUG
-# define NDEBUG /* To kill off assertions */
-#endif /* not DEBUG */
+#include "config.h"
 
-/* Define this if you want primitive but extensive malloc debugging.
-   It will make Wget extremely slow, so only do it in development
-   builds.  */
-#undef DEBUG_MALLOC
+#if ((defined _WIN32 || defined __WIN32__) && !defined __CYGWIN__)
+# define WINDOWS
+#endif
 
-#ifndef PARAMS
-# if PROTOTYPES
-#  define PARAMS(args) args
-# else
-#  define PARAMS(args) ()
-# endif
+/* Include these, so random files need not include them.  */
+#include "sysdep.h"
+
+/* Disable assertions when debug support is not compiled in. */
+#ifndef ENABLE_DEBUG
+# define NDEBUG
+#endif
+
+/* Is OpenSSL or GNUTLS available? */
+#if defined HAVE_LIBSSL || defined HAVE_LIBGNUTLS
+# define HAVE_SSL
 #endif
 
 /* `gettext (FOO)' is long to write, so we use `_(FOO)'.  If NLS is
    unavailable, _(STRING) simply returns STRING.  */
-#ifdef HAVE_NLS
-# define _(string) gettext (string)
-# ifdef HAVE_LIBINTL_H
-#  include <libintl.h>
-# endif /* HAVE_LIBINTL_H */
-#else  /* not HAVE_NLS */
-# define _(string) string
-#endif /* not HAVE_NLS */
-
-/* I18N NOTE: You will notice that none of the DEBUG messages are
+#include "gettext.h"
+#define _(string)   gettext (string)
+
+/* A pseudo function call that serves as a marker for the automated
+   extraction of messages, but does not call gettext().  The run-time
+   translation is done at a different place in the code.  The purpose
+   of the N_("...") call is to make the message snarfer aware that the
+   "..." string needs to be translated.  STRING should be a string
+   literal.  Concatenated strings and other string expressions won't
+   work.  The macro's expansion is not parenthesized, so that it is
+   suitable as initializer for static 'char[]' or 'const char[]'
+   variables.  -- explanation partly taken from GNU make.  */
+#define N_(string) string
+
+#if ! ENABLE_NLS
+# undef HAVE_WCHAR_H
+# undef HAVE_WCWIDTH
+# undef HAVE_MBTOWC
+#endif /* not ENABLE_NLS */
+
+#if HAVE_WCWIDTH && HAVE_MBTOWC
+# define USE_NLS_PROGRESS_BAR 1
+#else
+/* Just to be a little paranoid about it. */
+# undef  USE_NLS_PROGRESS_BAR
+#endif
+
+/* 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
@@ -67,146 +100,193 @@ Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
    debug problems with Wget.  If I get them in a language I don't
    understand, debugging will become a new challenge of its own!  */
 
-
-/* Include these, so random files need not include them.  */
-#include "sysdep.h"
-#include "options.h"
 /* locale independent replacement for ctype.h */
-#include "safe-ctype.h"
+#include "c-ctype.h"
 
-#define DO_NOTHING do {} while (0)
+/* Conditionalize the use of GCC's __attribute__((format)) and
+   __builtin_expect features using macros.  */
 
-/* Print X if debugging is enabled; a no-op otherwise.  */
-#ifdef DEBUG
-# define DEBUGP(x) do { if (opt.debug) { debug_logprintf x; } } while (0)
-#else  /* not DEBUG */
-# define DEBUGP(x) DO_NOTHING
-#endif /* not DEBUG */
-
-/* Make gcc check for the format of logmsg() and debug_logmsg().  */
-#ifdef __GNUC__
+#if defined(__GNUC__) && __GNUC__ >= 3
 # define GCC_FORMAT_ATTR(a, b) __attribute__ ((format (printf, a, b)))
-#else  /* not __GNUC__ */
+# define LIKELY(exp)   __builtin_expect (!!(exp), 1)
+# define UNLIKELY(exp) __builtin_expect ((exp), 0)
+#else
 # 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 */
-
-/* #### 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
-
-/* Useful macros used across the code: */
+# define LIKELY(exp)   (exp)
+# define UNLIKELY(exp) (exp)
+#endif
+
+/* Execute the following statement if debugging is both enabled at
+   compile-time and requested at run-time; a no-op otherwise.  */
+
+#ifdef ENABLE_DEBUG
+# define IF_DEBUG if (UNLIKELY (opt.debug))
+#else
+# define IF_DEBUG if (0)
+#endif
+
+/* Print ARGS if debugging is enabled and requested, otherwise do
+   nothing.  This must be called with an extra level of parentheses
+   because it's not possible to pass a variable number of arguments to
+   a macro (in portable C89).  ARGS are like arguments to printf.  */
+
+#define DEBUGP(args) do { IF_DEBUG { debug_logprintf args; } } while (0)
+
+/* Pick an integer type large enough for file sizes, content lengths,
+   and such.  Because today's files can be very large, it should be a
+   signed integer at least 64 bits wide.  This can't be typedeffed to
+   off_t because: a) off_t is always 32-bit on Windows, and b) we
+   don't necessarily want to tie having a 64-bit type for internal
+   calculations to having LFS support.  */
+
+#ifdef WINDOWS
+  /* nothing to do, see mswindows.h */
+#elif SIZEOF_LONG >= 8
+  /* long is large enough, so use it. */
+  typedef long wgint;
+# define SIZEOF_WGINT SIZEOF_LONG
+#elif SIZEOF_LONG_LONG >= 8
+  /* long long is large enough and available, use that */
+  typedef long long wgint;
+# define SIZEOF_WGINT SIZEOF_LONG_LONG
+#elif HAVE_INT64_T
+  typedef int64_t wgint;
+# define SIZEOF_WGINT 8
+#elif SIZEOF_OFF_T >= 8
+  /* In case off_t is typedeffed to a large non-standard type that our
+     tests don't find. */
+  typedef off_t wgint;
+# define SIZEOF_WGINT SIZEOF_OFF_T
+#else
+  /* Fall back to using long, which is always available and in most
+     cases large enough. */
+  typedef long wgint;
+# define SIZEOF_WGINT SIZEOF_LONG
+#endif
 
-/* Is the string a hpyhen-only?  */
-#define HYPHENP(x) (*(x) == '-' && !*((x) + 1))
+/* Pick a strtol-compatible function that will work with wgint.  The
+   choices are strtol, strtoll, or our own implementation of strtoll
+   in cmpt.c, activated with NEED_STRTOLL.  */
+
+#ifdef WINDOWS
+  /* nothing to do, see mswindows.h */
+#elif SIZEOF_WGINT == SIZEOF_LONG
+# define str_to_wgint strtol
+#elif SIZEOF_WGINT == SIZEOF_LONG_LONG
+# define str_to_wgint strtoll
+# ifndef HAVE_STRTOLL
+#  define NEED_STRTOLL
+#  define strtoll_type long long
+# endif
+#else
+  /* wgint has a strange size; synthesize strtoll and use it. */
+# define str_to_wgint strtoll
+# define NEED_STRTOLL
+# define strtoll_type wgint
+#endif
+
+#define WGINT_MAX TYPE_MAXIMUM (wgint)
+
+/* Declare our strtoll replacement. */
+#ifdef NEED_STRTOLL
+strtoll_type strtoll (const char *, char **, int);
+#endif
+
+/* Now define a large numeric type useful for storing sizes of *sums*
+   of downloads, such as the value of the --quota option.  This should
+   be a type able to hold 2G+ values even on systems without large
+   file support.  (It is useful to limit Wget's download quota to say
+   10G even if a single file cannot be that large.)
+
+   To make sure we get the largest size possible, we use `double' on
+   systems without a 64-bit integral type.  (Since it is used in very
+   few places in Wget, this is acceptable.)  */
+
+#if SIZEOF_WGINT >= 8
+/* just use wgint */
+typedef wgint SUM_SIZE_INT;
+#else
+/* On systems without LFS, use double, which buys us integers up to 2^53. */
+typedef double SUM_SIZE_INT;
+#endif
+
+#include "options.h"
 
-/* The smaller value of the two.  */
-#define MINVAL(x, y) ((x) < (y) ? (x) : (y))
+/* Everything uses this, so include them here directly.  */
+#include <alloca.h>
+#include "xalloc.h"
 
-/* Convert the ASCII character X to a hex-digit.  X should be between
-   '0' and '9', or between 'A' and 'F', or between 'a' and 'f'.  The
-   result is a number between 0 and 15.  If X is not a hexadecimal
-   digit character, the result is undefined.  */
-#define XCHAR_TO_XDIGIT(x)			\
-  (((x) >= '0' && (x) <= '9') ?			\
-   ((x) - '0') : (TOUPPER(x) - 'A' + 10))
+/* Likewise for logging functions.  */
+#include "log.h"
 
-/* The reverse of the above: convert a HEX digit in the [0, 15] range
-   to an ASCII character representing it.  The A-F characters are
-   always in upper case.  */
-#define XDIGIT_TO_XCHAR(x) (((x) < 10) ? ((x) + '0') : ((x) - 10 + 'A'))
+/* Likewise for quoting functions.  */
+#include "quote.h"
+#include "quotearg.h"
 
-/* Like XDIGIT_TO_XCHAR, but produce a lower-case char. */
-#define XDIGIT_TO_xchar(x) (((x) < 10) ? ((x) + '0') : ((x) - 10 + 'a'))
+/* Likewise for struct iri definition */
+#include "iri.h"
 
-#define ARRAY_SIZE(array) (sizeof (array) / sizeof (*(array)))
+/* Useful macros used across the code: */
+
+/* The number of elements in an array.  For example:
+   static char a[] = "foo";     -- countof(a) == 4 (note 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]))
+
+/* 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.  H should be a hexadecimal digit that satisfies isxdigit;
+   otherwise, the result is undefined.  */
+#define XDIGIT_TO_NUM(h) ((h) < 'A' ? (h) - '0' : c_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
+   the ASCII representation of the corresponding hexadecimal digit.
+   `+ 0' is there so you can'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.  BEG and END are evaluated only
-   once, in that order.  */
+   storage, and zero-terminate it.  Arguments are evaluated only once,
+   in the order BEG, END, PLACE.  */
 #define BOUNDED_TO_ALLOCA(beg, end, place) do {	\
-  const char *DTA_beg = (beg);			\
-  int DTA_len = (end) - DTA_beg;		\
-  place = alloca (DTA_len + 1);			\
-  memcpy (place, DTA_beg, DTA_len);		\
-  place[DTA_len] = '\0';			\
+  const char *BTA_beg = (beg);			\
+  int BTA_len = (end) - BTA_beg;		\
+  char **BTA_dest = &(place);			\
+  *BTA_dest = alloca (BTA_len + 1);		\
+  memcpy (*BTA_dest, BTA_beg, BTA_len);		\
+  (*BTA_dest)[BTA_len] = '\0';			\
 } while (0)
 
 /* Return non-zero if string bounded between BEG and END is equal to
    STRING_LITERAL.  The comparison is case-sensitive.  */
-#define BOUNDED_EQUAL(beg, end, string_literal)	\
-  ((end) - (beg) == sizeof (string_literal) - 1	\
-   && !memcmp ((beg), (string_literal),		\
-	       sizeof (string_literal) - 1))
+#define BOUNDED_EQUAL(beg, end, string_literal)				\
+  ((end) - (beg) == sizeof (string_literal) - 1				\
+   && !memcmp (beg, string_literal, sizeof (string_literal) - 1))
 
 /* The same as above, except the comparison is case-insensitive. */
-#define BOUNDED_EQUAL_NO_CASE(beg, end, string_literal)	\
-  ((end) - (beg) == sizeof (string_literal) - 1		\
-   && !strncasecmp ((beg), (string_literal),		\
-	            sizeof (string_literal) - 1))
-
-/* Note that this much more elegant definition cannot be used:
-
-   #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);				\
+#define BOUNDED_EQUAL_NO_CASE(beg, end, string_literal)			\
+  ((end) - (beg) == sizeof (string_literal) - 1				\
+   && !strncasecmp (beg, string_literal, sizeof (string_literal) - 1))
+
+/* Like ptr=strdup(str), but allocates the space for PTR on the stack.
+   This cannot be an expression because this is not portable:
+     #define STRDUP_ALLOCA(str) (strcpy (alloca (strlen (str) + 1), str))
+   The problem is that some compilers can't handle alloca() being an
+   argument to a function.  */
+
+#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
@@ -214,114 +294,96 @@ char *xstrdup_debug PARAMS ((const char *, const char *, int));
    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.  */						\
-  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;							\
-  }										\
-  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;						\
-    }										\
+#define DO_REALLOC(basevar, sizevar, needed_size, type)	do {		\
+  long DR_needed_size = (needed_size);					\
+  long DR_newsize = 0;							\
+  while ((sizevar) < (DR_needed_size)) {				\
+    DR_newsize = sizevar << 1;						\
+    if (DR_newsize < 16)						\
+      DR_newsize = 16;							\
+    (sizevar) = DR_newsize;						\
+  }									\
+  if (DR_newsize)							\
+    basevar = xrealloc (basevar, DR_newsize * sizeof (type));		\
 } while (0)
 
-/* Free FOO if it is non-NULL.  */
-#define FREE_MAYBE(foo) do { if (foo) xfree (foo); } while (0)
+/* Used to print pointers (usually for debugging).  Print pointers
+   using printf ("0x%0*lx", PTR_FORMAT (p)).  (%p is too unpredictable;
+   some implementations prepend 0x, while some don't, and most don't
+   0-pad the address.)  */
+#define PTR_FORMAT(p) (int) (2 * sizeof (void *)), (unsigned long) (p)
 
-/* #### Hack: OPTIONS_DEFINED_HERE is defined in main.c.  */
-/* [Is this weird hack really necessary on any compilers?  No ANSI C compiler
-    should complain about "extern const char *exec_name;" followed by
-    "const char *exec_name;".  Are we doing this for K&R compilers, or...??
-    -- Dan Harkless <wget@harkless.org>] */
-#ifndef OPTIONS_DEFINED_HERE
 extern const char *exec_name;
-#endif
-
 
 /* Document type ("dt") flags */
 enum
 {
-  TEXTHTML             = 0x0001,	/* document is of type text/html */
+  TEXTHTML             = 0x0001,	/* document is of type text/html
+                                           or application/xhtml+xml */
   RETROKF              = 0x0002,	/* retrieval was OK */
   HEAD_ONLY            = 0x0004,	/* only send the HEAD request */
   SEND_NOCACHE         = 0x0008,	/* send Pragma: no-cache directive */
   ACCEPTRANGES         = 0x0010,	/* Accept-ranges header was found */
-  ADDED_HTML_EXTENSION = 0x0020         /* added ".html" extension due to -E */
+  ADDED_HTML_EXTENSION = 0x0020,        /* added ".html" extension due to -E */
+  TEXTCSS              = 0x0040	        /* document is of type text/css */
 };
 
-/* Universal error type -- used almost everywhere.
-   This is, of course, utter crock.  */
+/* Universal error type -- used almost everywhere.  Error reporting of
+   this detail is not generally used or needed and should be
+   simplified.  */
 typedef enum
 {
+  /*  0  */
   NOCONERROR, HOSTERR, CONSOCKERR, CONERROR, CONSSLERR,
-  CONREFUSED, NEWLOCATION, NOTENOUGHMEM, CONPORTERR,
-  BINDERR, BINDOK, LISTENERR, ACCEPTERR, ACCEPTOK,
-  CONCLOSED, FTPOK, FTPLOGINC, FTPLOGREFUSED, FTPPORTERR,
-  FTPNSFOD, FTPRETROK, FTPUNKNOWNTYPE, FTPRERR,
-  FTPREXC, FTPSRVERR, FTPRETRINT, FTPRESTFAIL, URLERROR,
-  FOPENERR, FWRITEERR, HOK, HLEXC, HEOF,
-  HERR, RETROK, RECLEVELEXC, FTPACCDENIED, WRONGCODE,
-  FTPINVPASV, FTPNOPASV,
-  CONTNOTSUPPORTED, RETRUNNEEDED, RETRFINISHED, READERR, TRYLIMEXC,
-  URLBADPATTERN, FILEBADFILE, RANGEERR, RETRBADPATTERN,
-  RETNOTSUP, ROBOTSOK, NOROBOTS, PROXERR, AUTHFAILED,
-  QUOTEXC, WRITEFAILED,
-  SSLERRCERTFILE,SSLERRCERTKEY,SSLERRCTXCREATE
+  CONIMPOSSIBLE, NEWLOCATION, NOTENOUGHMEM /* ! */,
+  CONPORTERR /* ! */, CONCLOSED /* ! */,
+  /* 10  */
+  FTPOK, FTPLOGINC, FTPLOGREFUSED, FTPPORTERR, FTPSYSERR,
+  FTPNSFOD, FTPRETROK /* ! */, FTPUNKNOWNTYPE, FTPRERR, FTPREXC /* ! */,
+  /* 20  */
+  FTPSRVERR, FTPRETRINT, FTPRESTFAIL, URLERROR, FOPENERR,
+  FOPEN_EXCL_ERR, FWRITEERR, HOK /* ! */, HLEXC /* ! */, HEOF,
+  /* 30  */
+  HERR, RETROK, RECLEVELEXC, FTPACCDENIED /* ! */, WRONGCODE,
+  FTPINVPASV, FTPNOPASV, CONTNOTSUPPORTED, RETRUNNEEDED, RETRFINISHED,
+  /* 40  */
+  READERR, TRYLIMEXC, URLBADPATTERN /* ! */, FILEBADFILE /* ! */, RANGEERR,
+  RETRBADPATTERN, RETNOTSUP /* ! */, ROBOTSOK /* ! */, NOROBOTS /* ! */,
+  PROXERR,
+  /* 50  */
+  AUTHFAILED, QUOTEXC, WRITEFAILED, SSLINITFAILED, VERIFCERTERR,
+  UNLINKERR
 } uerr_t;
 
-typedef unsigned char  boolean;
-#ifndef FALSE
-#define FALSE 0
-#endif
-#ifndef TRUE
-#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. */
-#define INFINITE_RECURSION -1
+/* 2005-02-19 SMS.
+   Select an appropriate "orig" suffix and a separator character for
+   adding a unique suffix to a file name.
+
+   A VMS ODS2 file system can not tolerate multiple dots.  An ODS5 file
+   system can, but even there not all dots are equal, and heroic effort
+   would be needed to get ".html^.orig" rather than (the less desirable)
+   "^.html.orig".  It's more satisfactory always to use "_orig" on VMS
+   (rather than including "vms.h", testing "ods5_dest", and acting
+   accordingly).
+
+   Note that code in various places assumes that this string is five
+   characters long.
+*/
+# ifdef __VMS
+#  define ORIG_SFX "_orig"
+# else /* def __VMS */
+#  define ORIG_SFX ".orig"
+# endif /* def __VMS [else] */
+
+/* ".NNN" unique-ifying suffix separator character for unique_name() in
+   url.c (and anywhere else).  Note that on VMS, the file system's
+   version numbers solve the problem that unique_name() is designed to
+   handle, obviating this whole exercise.  Other systems may specify a
+   character different from "." here, if desired.
+*/
+# ifndef __VMS
+#  define UNIQ_SEP '.'
+# endif /* ndef __VMS */
 
 #endif /* WGET_H */