# define _(string) string
#endif /* not HAVE_NLS */
+/* 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
marked as translatable. This is intentional, for a few reasons:
/* The smaller value of the two. */
#define MINVAL(x, y) ((x) < (y) ? (x) : (y))
-/* Convert the ASCII character that represents a hexadecimal digit to
- the number in range [0, 16) that corresponds to the digit. X
- should be between '0' and '9', or between 'A' and 'F', or between
- 'a' and 'f'. 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))
+/* 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 X2DIGITS_TO_NUM(h1, h2) ((XDIGIT_TO_NUM (h1) << 4) + XDIGIT_TO_NUM (h2))
-/* The reverse of the above: convert a digit number in the [0, 16)
- range to an ASCII character. The A-F characters are in upper
+/* 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 XDIGIT_TO_XCHAR(x) ("0123456789ABCDEF"[x])
+#define XNUM_TO_DIGIT(x) ("0123456789ABCDEF"[x])
-/* Like XDIGIT_TO_XCHAR, but generates lower-case characters. */
-#define XDIGIT_TO_xchar(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:
} */
#define countof(array) (sizeof (array) / sizeof (*(array)))
-#define ARRAY_SIZE(array) countof (array)
-
/* 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
strcpy (ptr, str); \
} 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 \
+#define DO_REALLOC(basevar, sizevar, needed_size, 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; \
+ 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. */
/* 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 */
ADDED_HTML_EXTENSION = 0x0020 /* added ".html" extension due to -E */
};
-/* 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
{
NOCONERROR, HOSTERR, CONSOCKERR, CONERROR, CONSSLERR,
projects / wget / blobdiff