* lib/argp-help.c: Use NULL, not 0, to denote a null pointer.
* lib/argp-parse.c: Likewise.
* lib/backup-find.c (get_version): Likewise.
* lib/bitset/list.c: Likewise.
* lib/bitset/stats.c (bitset_stats_init): Likewise.
* lib/bitset/table.c: Likewise.
* lib/bitsetv.c (bitsetv_alloc): Likewise.
* lib/error.c (print_errno_message): Likewise.
* lib/exclude.c (new_exclude_segment): Likewise.
* lib/getopt.c (GETOPT_ENTRY): Likewise.
* lib/human.c (block_size_args): Likewise.
* lib/obstack.c (_obstack_begin_worker, _obstack_newchunk,
_obstack_allocated_p, _obstack_free, _obstack_memory_used): Likewise.
* lib/quotearg.c (quoting_style_args, quotearg_buffer_restyled,
quotearg_alloc_mem): Likewise.
* lib/readutmp.c (read_utmp_from_file): Likewise.
* lib/savedir.c (comparison_function_table): Likewise.
* lib/settime.c (settime): Likewise.
* tests/nap.h (nap_works): Likewise.
* tests/test-fts.c (argv, fts_dealloc, remove_tree, main): Likewise.
* tests/test-getaddrinfo.c (simple): Likewise.
* tests/test-nstrftime.h (posixtm_test, TZ, quarter_test, errno_test,
locales_test): Likewise.
* tests/test-parse-datetime.c (main): Likewise.
* tests/test-regex.c (main): Likewise.
+2024-11-14 Bruno Haible <bruno@clisp.org>
+
+ Eliminate gcc -Wzero-as-null-pointer-constant warnings.
+ * lib/argp-help.c: Use NULL, not 0, to denote a null pointer.
+ * lib/argp-parse.c: Likewise.
+ * lib/backup-find.c (get_version): Likewise.
+ * lib/bitset/list.c: Likewise.
+ * lib/bitset/stats.c (bitset_stats_init): Likewise.
+ * lib/bitset/table.c: Likewise.
+ * lib/bitsetv.c (bitsetv_alloc): Likewise.
+ * lib/error.c (print_errno_message): Likewise.
+ * lib/exclude.c (new_exclude_segment): Likewise.
+ * lib/getopt.c (GETOPT_ENTRY): Likewise.
+ * lib/human.c (block_size_args): Likewise.
+ * lib/obstack.c (_obstack_begin_worker, _obstack_newchunk,
+ _obstack_allocated_p, _obstack_free, _obstack_memory_used): Likewise.
+ * lib/quotearg.c (quoting_style_args, quotearg_buffer_restyled,
+ quotearg_alloc_mem): Likewise.
+ * lib/readutmp.c (read_utmp_from_file): Likewise.
+ * lib/savedir.c (comparison_function_table): Likewise.
+ * lib/settime.c (settime): Likewise.
+ * tests/nap.h (nap_works): Likewise.
+ * tests/test-fts.c (argv, fts_dealloc, remove_tree, main): Likewise.
+ * tests/test-getaddrinfo.c (simple): Likewise.
+ * tests/test-nstrftime.h (posixtm_test, TZ, quarter_test, errno_test,
+ locales_test): Likewise.
+ * tests/test-parse-datetime.c (main): Likewise.
+ * tests/test-regex.c (main): Likewise.
+
2024-11-14 Bruno Haible <bruno@clisp.org>
ftruncate, ftello: Make them work again for large files on MSVC.
hol_entry_first_short (const struct hol_entry *entry)
{
return hol_entry_short_iterate (entry, until_short,
- entry->argp->argp_domain, 0);
+ entry->argp->argp_domain, NULL);
}
/* Returns the first valid long option in ENTRY, or NULL if there is none. */
{
unsigned num;
struct hol_entry *entry;
- struct hol_help_state hhstate = { 0, 0, 0 };
+ struct hol_help_state hhstate = { NULL, 0, 0 };
for (entry = hol->entries, num = hol->num_entries; num > 0; entry++, num--)
hol_entry_help (entry, state, stream, &hhstate);
Mandatory or optional arguments to long options are also mandatory or \
optional for any corresponding short options.");
const char *fstr = filter_doc (tstr, ARGP_KEY_HELP_DUP_ARGS_NOTE,
- state ? state->root_argp : 0, state);
+ state ? state->root_argp : NULL, state);
if (fstr && *fstr)
{
__argp_fmtstream_putc (stream, '\n');
if (doc)
{
char *vt = strchr (doc, '\v');
- inp_text = post ? (vt ? vt + 1 : 0) : doc;
+ inp_text = post ? (vt ? vt + 1 : NULL) : doc;
inp_text_limit = (!post && vt) ? (vt - doc) : 0;
}
else
- inp_text = 0;
+ inp_text = NULL;
if (argp->help_filter)
/* We have to filter the doc strings. */
if (post && argp->help_filter)
/* Now see if we have to output a ARGP_KEY_HELP_EXTRA text. */
{
- text = (*argp->help_filter) (ARGP_KEY_HELP_EXTRA, 0, input);
+ text = (*argp->help_filter) (ARGP_KEY_HELP_EXTRA, NULL, input);
if (text)
{
if (anything || pre_blank)
if (flags & (ARGP_HELP_USAGE | ARGP_HELP_SHORT_USAGE | ARGP_HELP_LONG))
{
- hol = argp_hol (argp, 0);
+ hol = argp_hol (argp, NULL);
/* If present, these options always come last. */
hol_set_group (hol, "help", -1);
void __argp_help (const struct argp *argp, FILE *stream,
unsigned flags, char *name)
{
- _help (argp, 0, stream, flags, name);
+ _help (argp, NULL, stream, flags, name);
}
#ifdef weak_alias
weak_alias (__argp_help, argp_help)
if (state && (state->flags & ARGP_LONG_ONLY))
flags |= ARGP_HELP_LONG_ONLY;
- _help (state ? state->root_argp : 0, state, stream, flags,
+ _help (state ? state->root_argp : NULL, state, stream, flags,
state ? state->name : __argp_short_program_name ());
if (!state || ! (state->flags & ARGP_NO_EXIT))
static const struct argp_option argp_default_options[] =
{
- {"help", '?', 0, 0, N_("give this help list"), -1},
- {"usage", OPT_USAGE, 0, 0, N_("give a short usage message"), 0},
+ {"help", '?', NULL, 0, N_("give this help list"), -1},
+ {"usage", OPT_USAGE, NULL, 0, N_("give a short usage message"), 0},
{"program-name",OPT_PROGNAME, N_("NAME"), OPTION_HIDDEN,
N_("set the program name"), 0},
{"HANG", OPT_HANG, N_("SECS"), OPTION_ARG_OPTIONAL | OPTION_HIDDEN,
N_("hang for SECS seconds (default 3600)"), 0},
- {NULL, 0, 0, 0, NULL, 0}
+ {NULL, 0, NULL, 0, NULL, 0}
};
static error_t
\f
static const struct argp_option argp_version_options[] =
{
- {"version", 'V', 0, 0, N_("print program version"), -1},
- {NULL, 0, 0, 0, NULL, 0}
+ {"version", 'V', NULL, 0, N_("print program version"), -1},
+ {NULL, 0, NULL, 0, NULL, 0}
};
static error_t
? optional_argument
: required_argument)
: no_argument);
- cvt->long_end->flag = 0;
+ cvt->long_end->flag = NULL;
/* we add a disambiguating code to all the user's
values (which is removed before we actually call
the function to parse the value); this means that
parser->argp = argp;
if (argp)
- parser->egroup = convert_options (argp, 0, 0, parser->groups, &cvt);
+ parser->egroup = convert_options (argp, NULL, 0, parser->groups, &cvt);
else
parser->egroup = parser->groups; /* No parsers at all! */
}
makes very simple wrapper argps more convenient). */
group->child_inputs[0] = group->input;
- err = group_parse (group, &parser->state, ARGP_KEY_INIT, 0);
+ err = group_parse (group, &parser->state, ARGP_KEY_INIT, NULL);
}
if (err == EBADKEY)
err = 0; /* Some parser didn't understand. */
group < parser->egroup && (!err || err==EBADKEY);
group++)
if (group->args_processed == 0)
- err = group_parse (group, &parser->state, ARGP_KEY_NO_ARGS, 0);
+ err = group_parse (group, &parser->state, ARGP_KEY_NO_ARGS, NULL);
for (group = parser->egroup - 1;
group >= parser->groups && (!err || err==EBADKEY);
group--)
- err = group_parse (group, &parser->state, ARGP_KEY_END, 0);
+ err = group_parse (group, &parser->state, ARGP_KEY_END, NULL);
if (err == EBADKEY)
err = 0; /* Some parser didn't understand. */
/* Since we didn't exit, give each parser an error indication. */
for (group = parser->groups; group < parser->egroup; group++)
- group_parse (group, &parser->state, ARGP_KEY_ERROR, 0);
+ group_parse (group, &parser->state, ARGP_KEY_ERROR, NULL);
}
else
/* Notify parsers of success, and propagate back values from parsers. */
for (group = parser->egroup - 1
; group >= parser->groups && (!err || err == EBADKEY)
; group--)
- err = group_parse (group, &parser->state, ARGP_KEY_SUCCESS, 0);
+ err = group_parse (group, &parser->state, ARGP_KEY_SUCCESS, NULL);
if (err == EBADKEY)
err = 0; /* Some parser didn't understand. */
}
/* Call parsers once more, to do any final cleanup. Errors are ignored. */
for (group = parser->egroup - 1; group >= parser->groups; group--)
- group_parse (group, &parser->state, ARGP_KEY_FINI, 0);
+ group_parse (group, &parser->state, ARGP_KEY_FINI, NULL);
if (err == EBADKEY)
err = EINVAL;
{
parser->state.next--; /* For ARGP_KEY_ARGS, put back the arg. */
key = ARGP_KEY_ARGS;
- err = group_parse (group, &parser->state, key, 0);
+ err = group_parse (group, &parser->state, key, NULL);
}
}
parser->opt_data.optopt = KEY_END;
if (parser->state.flags & ARGP_LONG_ONLY)
opt = _getopt_long_only_r (parser->state.argc, parser->state.argv,
- parser->short_opts, parser->long_opts, 0,
+ parser->short_opts, parser->long_opts, NULL,
&parser->opt_data);
else
opt = _getopt_long_r (parser->state.argc, parser->state.argv,
- parser->short_opts, parser->long_opts, 0,
+ parser->short_opts, parser->long_opts, NULL,
&parser->opt_data);
/* And see what getopt did. */
parser->state.next = parser->opt_data.optind;
enum backup_type
get_version (char const *context, char const *version)
{
- if (version == 0 || *version == 0)
+ if (version == NULL || *version == 0)
return numbered_existing_backups;
else
return XARGMATCH (context, version, backup_args, backup_types);
{
lbitset_elt *elt;
- if (lbitset_free_list != 0)
+ if (lbitset_free_list != NULL)
{
elt = lbitset_free_list;
lbitset_free_list = elt->next;
else
{
bset->b.csize = 0;
- bset->b.cdata = 0;
+ bset->b.cdata = NULL;
}
}
LBITSET_TAIL (bset) = elt->prev;
bset->b.cdata = elt->prev->words;
bset->b.cindex = elt->prev->index;
- elt->prev->next = 0;
+ elt->prev->next = NULL;
}
else
{
- LBITSET_HEAD (bset) = 0;
- LBITSET_TAIL (bset) = 0;
- bset->b.cdata = 0;
+ LBITSET_HEAD (bset) = NULL;
+ LBITSET_TAIL (bset) = NULL;
+ bset->b.cdata = NULL;
bset->b.csize = 0;
}
lbitset_elt *current = bset->b.csize ? LBITSET_CURRENT (bset) : LBITSET_HEAD (bset);
/* If this is the first and only element, add it in. */
- if (LBITSET_HEAD (bset) == 0)
+ if (LBITSET_HEAD (bset) == NULL)
{
- elt->next = elt->prev = 0;
+ elt->next = elt->prev = NULL;
LBITSET_HEAD (bset) = elt;
LBITSET_TAIL (bset) = elt;
}
abort ();
case LBITSET_FIND:
- return 0;
+ return NULL;
case LBITSET_CREATE:
windex -= windex % LBITSET_ELT_WORDS;
if (!head)
return;
- lbitset_elt *prev = 0;
+ lbitset_elt *prev = NULL;
lbitset_elt *tmp;
lbitset_elt *elt = head;
do
tmp = lbitset_elt_alloc ();
tmp->index = elt->index;
tmp->prev = prev;
- tmp->next = 0;
+ tmp->next = NULL;
if (prev)
prev->next = tmp;
else
if (!LBITSET_HEAD (dst))
{
lbitset_copy (dst, src);
- return LBITSET_HEAD (src) != 0;
+ return LBITSET_HEAD (src) != NULL;
}
if (lbitset_equal_p (dst, src))
lbitset_elt *delt = LBITSET_HEAD (dst);
bool changed = false;
- LBITSET_HEAD (dst) = 0;
+ LBITSET_HEAD (dst) = NULL;
dst->b.csize = 0;
bitset_windex windex1 = (selt1) ? selt1->index : BITSET_WINDEX_MAX;
void
lbitset_release_memory (void)
{
- lbitset_free_list = 0;
+ lbitset_free_list = NULL;
if (lbitset_obstack_init)
{
lbitset_obstack_init = false;
/* Disable cache. */
bset->b.cindex = 0;
bset->b.csize = 0;
- bset->b.cdata = 0;
+ bset->b.cdata = NULL;
BITSET_NBITS_ (bset) = n_bits;
/* Disable bitset cache and mark BSET as being zero. */
#define TBITSET_ZERO_SET(BSET) ((BSET)->b.cindex = BITSET_WINDEX_MAX, \
- (BSET)->b.cdata = 0)
+ (BSET)->b.cdata = NULL)
#define TBITSET_CACHE_DISABLE(BSET) ((BSET)->b.cindex = BITSET_WINDEX_MAX)
/* A conservative estimate of whether the bitset is zero.
This is non-zero only if we know for sure that the bitset is zero. */
-#define TBITSET_ZERO_P(BSET) ((BSET)->b.cdata == 0)
+#define TBITSET_ZERO_P(BSET) ((BSET)->b.cdata == NULL)
/* Enable cache to point to element with table index EINDEX.
The element must exist. */
{
tbitset_elt *elt;
- if (tbitset_free_list != 0)
+ if (tbitset_free_list != NULL)
{
elt = tbitset_free_list;
tbitset_free_list = TBITSET_NEXT (elt);
tbitset_elts *elts = TBITSET_ELTS (bset);
tbitset_elt *elt = elts[eindex];
- elts[eindex] = 0;
+ elts[eindex] = NULL;
tbitset_elt_free (elt);
}
for (bitset_windex j = 0; j < ssize; j++)
{
- tbitset_elt *selt = j < ssize ? selts[j] : 0;
- tbitset_elt *delt = j < dsize ? delts[j] : 0;
+ tbitset_elt *selt = j < ssize ? selts[j] : NULL;
+ tbitset_elt *delt = j < dsize ? delts[j] : NULL;
if (!selt && !delt)
continue;
for (bitset_windex j = 0; j < ssize; j++)
{
- tbitset_elt *selt = j < ssize ? selts[j] : 0;
- tbitset_elt *delt = j < dsize ? delts[j] : 0;
+ tbitset_elt *selt = j < ssize ? selts[j] : NULL;
+ tbitset_elt *delt = j < dsize ? delts[j] : NULL;
if (!selt || !delt)
continue;
bitset_windex j = 0;
for (j = 0; j < size; j++)
{
- tbitset_elt *selt1 = j < ssize1 ? selts1[j] : 0;
- tbitset_elt *selt2 = j < ssize2 ? selts2[j] : 0;
- tbitset_elt *delt = j < dsize ? delts[j] : 0;
+ tbitset_elt *selt1 = j < ssize1 ? selts1[j] : NULL;
+ tbitset_elt *selt2 = j < ssize2 ? selts2[j] : NULL;
+ tbitset_elt *delt = j < dsize ? delts[j] : NULL;
if (!selt1 && !selt2)
{
if (!delt)
delt = tbitset_elt_calloc ();
else
- delts[j] = 0;
+ delts[j] = NULL;
bitset_word *srcp1 = TBITSET_WORDS (selt1);
bitset_word *srcp2 = TBITSET_WORDS (selt2);
TBITSET_ZERO_SET (bset);
TBITSET_ASIZE (bset) = 0;
- TBITSET_ELTS (bset) = 0;
+ TBITSET_ELTS (bset) = NULL;
tbitset_resize (bset, n_bits);
return bset;
void
tbitset_release_memory (void)
{
- tbitset_free_list = 0;
+ tbitset_free_list = NULL;
if (tbitset_obstack_init)
{
tbitset_obstack_init = false;
}
/* Null terminate table. */
- bsetv[i] = 0;
+ bsetv[i] = NULL;
return bsetv;
}
if (__strerror_r (errnum, errbuf, sizeof errbuf) == 0)
s = errbuf;
else
- s = 0;
+ s = NULL;
# endif
#else
s = strerror (errnum);
switch (type)
{
case exclude_pattern:
- sp->v.pat = (struct exclude_pattern) {0};
+ sp->v.pat = (struct exclude_pattern) { NULL, 0, 0 };
break;
case exclude_hash:
NAME (int argc, char *const *argv, const char *optstring) \
{ \
return _getopt_internal (argc, (char **)argv, optstring, \
- 0, 0, 0, POSIXLY_CORRECT); \
+ NULL, NULL, 0, POSIXLY_CORRECT); \
}
#ifdef _LIBC
# define DEFAULT_BLOCK_SIZE 1024
#endif
-static char const *const block_size_args[] = { "human-readable", "si", 0 };
+static char const *const block_size_args[] = { "human-readable", "si", NULL };
static int const block_size_opts[] =
{
human_autoscale + human_SI + human_base_1024,
h->next_free = h->object_base = __PTR_ALIGN ((char *) chunk, chunk->contents,
alignment - 1);
h->chunk_limit = chunk->limit = (char *) chunk + h->chunk_size;
- chunk->prev = 0;
+ chunk->prev = NULL;
/* The initial chunk now contains no empty object. */
h->maybe_empty_object = 0;
h->alloc_failed = 0;
_obstack_newchunk (struct obstack *h, _OBSTACK_SIZE_T length)
{
struct _obstack_chunk *old_chunk = h->chunk;
- struct _obstack_chunk *new_chunk = 0;
+ struct _obstack_chunk *new_chunk = NULL;
size_t obj_size = h->next_free - h->object_base;
char *object_base;
/* We use >= rather than > since the object cannot be exactly at
the beginning of the chunk but might be an empty object exactly
at the end of an adjacent chunk. */
- while (lp != 0 && ((void *) lp >= obj || (void *) (lp)->limit < obj))
+ while (lp != NULL && ((void *) lp >= obj || (void *) (lp)->limit < obj))
{
plp = lp->prev;
lp = plp;
}
- return lp != 0;
+ return lp != NULL;
}
/* Free objects in obstack H, including OBJ and everything allocate
/* We use >= because there cannot be an object at the beginning of a chunk.
But there can be an empty object at that address
at the end of another chunk. */
- while (lp != 0 && ((void *) lp >= obj || (void *) (lp)->limit < obj))
+ while (lp != NULL && ((void *) lp >= obj || (void *) (lp)->limit < obj))
{
plp = lp->prev;
call_freefun (h, lp);
h->chunk_limit = lp->limit;
h->chunk = lp;
}
- else if (obj != 0)
+ else if (obj != NULL)
/* obj is not in any of the chunks! */
abort ();
}
struct _obstack_chunk *lp;
_OBSTACK_SIZE_T nbytes = 0;
- for (lp = h->chunk; lp != 0; lp = lp->prev)
+ for (lp = h->chunk; lp != NULL; lp = lp->prev)
{
nbytes += lp->limit - (char *) lp;
}
"escape",
"locale",
"clocale",
- 0
+ NULL
};
/* Correspondences to quoting style names. */
size_t i;
size_t len = 0;
size_t orig_buffersize = 0;
- char const *quote_string = 0;
+ char const *quote_string = NULL;
size_t quote_string_len = 0;
bool backslash_escapes = false;
bool unibyte_locale = MB_CUR_MAX == 1;
int e = errno;
/* Elide embedded null bytes if we can't return a size. */
int flags = p->flags | (size ? 0 : QA_ELIDE_NULL_BYTES);
- size_t bufsize = quotearg_buffer_restyled (0, 0, arg, argsize, p->style,
+ size_t bufsize = quotearg_buffer_restyled (NULL, 0, arg, argsize, p->style,
flags, p->quote_these_too,
p->left_quote,
p->right_quote) + 1;
return 0;
}
- struct utmp_alloc a = {0};
+ struct utmp_alloc a = { NULL, 0, 0, 0 };
# if READUTMP_USE_SYSTEMD || HAVE_UTMPX_H || HAVE_UTMP_H
static comparison_function const comparison_function_table[] =
{
- 0,
+ NULL,
direntry_cmp_name
#if D_INO_IN_DIRENT
, direntry_cmp_inode
{
struct timeval tv = { .tv_sec = ts->tv_sec,
.tv_usec = ts->tv_nsec / 1000 };
- return settimeofday (&tv, 0);
+ return settimeofday (&tv, NULL);
}
#elif HAVE_STIME
/* This fails to compile on OSF1 V5.1, due to stime requiring
struct timespec delay_spec;
delay_spec.tv_sec = delay / 1000000000;
delay_spec.tv_nsec = delay % 1000000000;
- ASSERT (nanosleep (&delay_spec, 0) == 0);
+ ASSERT (nanosleep (&delay_spec, NULL) == 0);
nap_get_stat (&st, 1);
if (diff_timespec (get_stat_mtime (&st), get_stat_mtime (&old_st)))
#define BASE "t-fts.tmp"
static char base[] = BASE; /* Not const, since argv needs non-const. */
static char const base_d[] = BASE "/d";
-static char *const argv[2] = { base, 0 };
+static char *const argv[2] = { base, NULL };
static void
perror_exit (char const *message, int status)
fts_dealloc (void)
{
static char dir[] = "./";
- static char *const curr_dir[2] = { dir, 0 };
- FTS *ftsp = fts_open (curr_dir, FTS_NOSTAT | FTS_PHYSICAL | FTS_CWDFD, 0);
+ static char *const curr_dir[2] = { dir, NULL };
+ FTS *ftsp = fts_open (curr_dir, FTS_NOSTAT | FTS_PHYSICAL | FTS_CWDFD, NULL);
if (ftsp)
{
if (fts_close (ftsp) != 0)
remove_tree (void)
{
FTSENT *e;
- FTS *ftsp = fts_open (argv, FTS_NOSTAT | FTS_PHYSICAL | FTS_CWDFD, 0);
+ FTS *ftsp = fts_open (argv, FTS_NOSTAT | FTS_PHYSICAL | FTS_CWDFD, NULL);
if (ftsp)
{
while ((e = fts_read (ftsp)))
}
/* Use fts to look for the needles. */
- ftsp = fts_open (argv, FTS_SEEDOT | FTS_NOSTAT | FTS_PHYSICAL | FTS_CWDFD, 0);
+ ftsp = fts_open (argv, FTS_SEEDOT | FTS_NOSTAT | FTS_PHYSICAL | FTS_CWDFD,
+ NULL);
if (!ftsp)
perror_exit (base, 6);
while ((e = fts_read (ftsp)))
hints.ai_family = AF_UNSPEC;
hints.ai_socktype = SOCK_STREAM;
- res = getaddrinfo (host, service, 0, &ai0);
+ res = getaddrinfo (host, service, NULL, &ai0);
err = errno;
dbgprintf ("res %d: %s\n", res, gai_strerror (res));
ASSERT (tm);
- n = FUNC_CHECKED (buf, sizeof buf, T[i].fmt, tm, 0, T[i].in_ns);
+ n = FUNC_CHECKED (buf, sizeof buf, T[i].fmt, tm, NULL, T[i].in_ns);
if (n == 0)
{
fail = 1;
{
#define Pacific 0
#if defined _WIN32 && !defined __CYGWIN__
- { 0, "PST8PDT" },
+ { NULL, "PST8PDT" },
#else
- { 0, "PST8PDT,M3.2.0,M11.1.0" },
+ { NULL, "PST8PDT,M3.2.0,M11.1.0" },
#endif
#define Arizona 1
- { 0, "MST7" },
+ { NULL, "MST7" },
#define UTC 2
- { 0, 0 },
+ { NULL, NULL },
#define CentEur 3
#if defined _WIN32 && !defined __CYGWIN__
- { 0, "CET-1CEST" },
+ { NULL, "CET-1CEST" },
#else
- { 0, "CET-1CEST,M3.5.0,M10.5.0/3" },
+ { NULL, "CET-1CEST,M3.5.0,M10.5.0/3" },
#endif
#define Japan 4
- { 0, "JST-9" },
+ { NULL, "JST-9" },
#define NZ 5
#if defined _WIN32 && !defined __CYGWIN__
- { 0, "NST-13NDT" },
+ { NULL, "NST-13NDT" },
#else
- { 0, "NZST-12NZDT,M9.5.0,M4.1.0/3" },
+ { NULL, "NZST-12NZDT,M9.5.0,M4.1.0/3" },
#endif
#define Unknown 6
- { 0, "<-00>0" },
+ { NULL, "<-00>0" },
- { 0 }
+ { NULL, NULL }
};
struct localtime_rz_test
{ TZ+Unknown, 500000001, "1985-11-05 00:53:21 -0000 (-00)", 0 },
{ TZ+Unknown, 1000000002, "2001-09-09 01:46:42 -0000 (-00)", 0 },
#endif
- { 0 }
+ { NULL }
};
static int
struct tm qtm = { .tm_mon = mon - 1 };
char fmt[3] = {'%','q','\0'};
- size_t r = FUNC_CHECKED (out, sizeof (out), fmt, &qtm, 0, 0);
+ size_t r = FUNC_CHECKED (out, sizeof (out), fmt, &qtm, NULL, 0);
if (r == 0)
{
printf ("%s(\"%%q\") failed\n", FUNC_NAME);
int bigyear = LLONG_MAX - 1900 < INT_MAX ? LLONG_MAX - 1900 : INT_MAX;
errno = 0;
- n = FUNC_CHECKED (buf, 0, "%m", &tm, 0, 0);
+ n = FUNC_CHECKED (buf, 0, "%m", &tm, NULL, 0);
if (! (n == 0 && errno == ERANGE))
{
fail = 1;
}
errno = 0;
- n = FUNC_CHECKED (buf, sizeof buf, "", &tm, 0, 0);
+ n = FUNC_CHECKED (buf, sizeof buf, "", &tm, NULL, 0);
if (! (n == 0 && errno == 0))
{
fail = 1;
tm.tm_year = bigyear;
errno = 0;
- n = FUNC_CHECKED (buf, sizeof buf, "%s", &tm, 0, 0);
+ n = FUNC_CHECKED (buf, sizeof buf, "%s", &tm, NULL, 0);
if (n == 0)
{
if (errno != EOVERFLOW)
fflush (stdout);
}
- if (mktime_z (0, &tm) != (time_t) -1)
+ if (mktime_z (NULL, &tm) != (time_t) -1)
{
fail = 1;
printf ("%s %%s failed but mktime_z worked for tm_year=%d\n",
else
{
char buf1[sizeof buf];
- size_t n1 = FUNC_CHECKED (buf1, sizeof buf1, "%s", tmp, 0, 0);
+ size_t n1 = FUNC_CHECKED (buf1, sizeof buf1, "%s", tmp, NULL, 0);
buf1[n1] = '\0';
if (! STREQ (buf, buf1))
{
char buf[100];
size_t n;
- n = FUNC_CHECKED (buf, sizeof buf, "%+4Y-%m-%d %H:%M:%S.%N", tm, 0, ns);
+ n = FUNC_CHECKED (buf, sizeof buf, "%+4Y-%m-%d %H:%M:%S.%N", tm, NULL, ns);
ASSERT (n > 0);
printf ("Format as ISO 8601: %s\n", buf);
fflush (stdout);
/* Exercise various POSIX format directives. */
- n = FUNC_CHECKED (buf, sizeof buf, "%a", tm, 0, ns);
+ n = FUNC_CHECKED (buf, sizeof buf, "%a", tm, NULL, ns);
ASSERT (n > 0);
printf ("%%a directive: %s\n", buf);
fflush (stdout);
break;
}
- n = FUNC_CHECKED (buf, sizeof buf, "%A", tm, 0, ns);
+ n = FUNC_CHECKED (buf, sizeof buf, "%A", tm, NULL, ns);
ASSERT (n > 0);
printf ("%%A directive: %s\n", buf);
fflush (stdout);
break;
}
- n = FUNC_CHECKED (buf, sizeof buf, "%b", tm, 0, ns);
+ n = FUNC_CHECKED (buf, sizeof buf, "%b", tm, NULL, ns);
ASSERT (n > 0);
printf ("%%b directive: %s\n", buf);
fflush (stdout);
break;
}
- n = FUNC_CHECKED (buf, sizeof buf, "%B", tm, 0, ns);
+ n = FUNC_CHECKED (buf, sizeof buf, "%B", tm, NULL, ns);
ASSERT (n > 0);
printf ("%%B directive: %s\n", buf);
fflush (stdout);
break;
}
- n = FUNC_CHECKED (buf, sizeof buf, "%c", tm, 0, ns);
+ n = FUNC_CHECKED (buf, sizeof buf, "%c", tm, NULL, ns);
ASSERT (n > 0);
printf ("%%c directive: %s\n", buf);
fflush (stdout);
break;
}
- n = FUNC_CHECKED (buf, sizeof buf, "%C", tm, 0, ns);
+ n = FUNC_CHECKED (buf, sizeof buf, "%C", tm, NULL, ns);
ASSERT (n > 0);
printf ("%%C directive: %s\n", buf);
fflush (stdout);
ASSERT (STREQ (buf, "20"));
- n = FUNC_CHECKED (buf, sizeof buf, "%d", tm, 0, ns);
+ n = FUNC_CHECKED (buf, sizeof buf, "%d", tm, NULL, ns);
ASSERT (n > 0);
printf ("%%d directive: %s\n", buf);
fflush (stdout);
ASSERT (STREQ (buf, "26"));
- n = FUNC_CHECKED (buf, sizeof buf, "%D", tm, 0, ns);
+ n = FUNC_CHECKED (buf, sizeof buf, "%D", tm, NULL, ns);
ASSERT (n > 0);
printf ("%%D directive: %s\n", buf);
fflush (stdout);
ASSERT (STREQ (buf, "10/26/17"));
- n = FUNC_CHECKED (buf, sizeof buf, "%e", tm, 0, ns);
+ n = FUNC_CHECKED (buf, sizeof buf, "%e", tm, NULL, ns);
ASSERT (n > 0);
printf ("%%e directive: %s\n", buf);
fflush (stdout);
ASSERT (STREQ (buf, "26"));
- n = FUNC_CHECKED (buf, sizeof buf, "%F", tm, 0, ns);
+ n = FUNC_CHECKED (buf, sizeof buf, "%F", tm, NULL, ns);
ASSERT (n > 0);
printf ("%%F directive: %s\n", buf);
fflush (stdout);
ASSERT (STREQ (buf, "2017-10-26"));
- n = FUNC_CHECKED (buf, sizeof buf, "%g", tm, 0, ns);
+ n = FUNC_CHECKED (buf, sizeof buf, "%g", tm, NULL, ns);
ASSERT (n > 0);
printf ("%%g directive: %s\n", buf);
fflush (stdout);
ASSERT (STREQ (buf, "17"));
- n = FUNC_CHECKED (buf, sizeof buf, "%G", tm, 0, ns);
+ n = FUNC_CHECKED (buf, sizeof buf, "%G", tm, NULL, ns);
ASSERT (n > 0);
printf ("%%G directive: %s\n", buf);
fflush (stdout);
ASSERT (STREQ (buf, "2017"));
- n = FUNC_CHECKED (buf, sizeof buf, "%h", tm, 0, ns);
+ n = FUNC_CHECKED (buf, sizeof buf, "%h", tm, NULL, ns);
ASSERT (n > 0);
printf ("%%h directive: %s\n", buf);
fflush (stdout);
break;
}
- n = FUNC_CHECKED (buf, sizeof buf, "%H", tm, 0, ns);
+ n = FUNC_CHECKED (buf, sizeof buf, "%H", tm, NULL, ns);
ASSERT (n > 0);
printf ("%%H directive: %s\n", buf);
fflush (stdout);
ASSERT (STREQ (buf, "06"));
- n = FUNC_CHECKED (buf, sizeof buf, "%I", tm, 0, ns);
+ n = FUNC_CHECKED (buf, sizeof buf, "%I", tm, NULL, ns);
ASSERT (n > 0);
printf ("%%I directive: %s\n", buf);
fflush (stdout);
ASSERT (STREQ (buf, "06"));
- n = FUNC_CHECKED (buf, sizeof buf, "%j", tm, 0, ns);
+ n = FUNC_CHECKED (buf, sizeof buf, "%j", tm, NULL, ns);
ASSERT (n > 0);
printf ("%%j directive: %s\n", buf);
fflush (stdout);
ASSERT (STREQ (buf, "299"));
- n = FUNC_CHECKED (buf, sizeof buf, "%m", tm, 0, ns);
+ n = FUNC_CHECKED (buf, sizeof buf, "%m", tm, NULL, ns);
ASSERT (n > 0);
printf ("%%m directive: %s\n", buf);
fflush (stdout);
ASSERT (STREQ (buf, "10"));
- n = FUNC_CHECKED (buf, sizeof buf, "%M", tm, 0, ns);
+ n = FUNC_CHECKED (buf, sizeof buf, "%M", tm, NULL, ns);
ASSERT (n > 0);
printf ("%%M directive: %s\n", buf);
fflush (stdout);
ASSERT (STREQ (buf, "40"));
- n = FUNC_CHECKED (buf, sizeof buf, "%n", tm, 0, ns);
+ n = FUNC_CHECKED (buf, sizeof buf, "%n", tm, NULL, ns);
ASSERT (n > 0);
printf ("%%n directive: %s\n", buf);
fflush (stdout);
ASSERT (STREQ (buf, "\n"));
- n = FUNC_CHECKED (buf, sizeof buf, "%p", tm, 0, ns);
+ n = FUNC_CHECKED (buf, sizeof buf, "%p", tm, NULL, ns);
switch (language)
{
case english:
break;
}
- n = FUNC_CHECKED (buf, sizeof buf, "%r", tm, 0, ns);
+ n = FUNC_CHECKED (buf, sizeof buf, "%r", tm, NULL, ns);
ASSERT (n > 0);
printf ("%%r directive: %s\n", buf);
fflush (stdout);
break;
}
- n = FUNC_CHECKED (buf, sizeof buf, "%R", tm, 0, ns);
+ n = FUNC_CHECKED (buf, sizeof buf, "%R", tm, NULL, ns);
ASSERT (n > 0);
printf ("%%R directive: %s\n", buf);
fflush (stdout);
ASSERT (STREQ (buf, "06:40"));
- n = FUNC_CHECKED (buf, sizeof buf, "%S", tm, 0, ns);
+ n = FUNC_CHECKED (buf, sizeof buf, "%S", tm, NULL, ns);
ASSERT (n > 0);
printf ("%%S directive: %s\n", buf);
fflush (stdout);
ASSERT (STREQ (buf, "03"));
- n = FUNC_CHECKED (buf, sizeof buf, "%t", tm, 0, ns);
+ n = FUNC_CHECKED (buf, sizeof buf, "%t", tm, NULL, ns);
ASSERT (n > 0);
printf ("%%t directive: %s\n", buf);
fflush (stdout);
ASSERT (STREQ (buf, "\t"));
- n = FUNC_CHECKED (buf, sizeof buf, "%T", tm, 0, ns);
+ n = FUNC_CHECKED (buf, sizeof buf, "%T", tm, NULL, ns);
ASSERT (n > 0);
printf ("%%T directive: %s\n", buf);
fflush (stdout);
ASSERT (STREQ (buf, "06:40:03"));
- n = FUNC_CHECKED (buf, sizeof buf, "%u", tm, 0, ns);
+ n = FUNC_CHECKED (buf, sizeof buf, "%u", tm, NULL, ns);
ASSERT (n > 0);
printf ("%%u directive: %s\n", buf);
fflush (stdout);
ASSERT (STREQ (buf, "4"));
- n = FUNC_CHECKED (buf, sizeof buf, "%U", tm, 0, ns);
+ n = FUNC_CHECKED (buf, sizeof buf, "%U", tm, NULL, ns);
ASSERT (n > 0);
printf ("%%U directive: %s\n", buf);
fflush (stdout);
ASSERT (STREQ (buf, "43"));
- n = FUNC_CHECKED (buf, sizeof buf, "%V", tm, 0, ns);
+ n = FUNC_CHECKED (buf, sizeof buf, "%V", tm, NULL, ns);
ASSERT (n > 0);
printf ("%%V directive: %s\n", buf);
fflush (stdout);
ASSERT (STREQ (buf, "43"));
- n = FUNC_CHECKED (buf, sizeof buf, "%w", tm, 0, ns);
+ n = FUNC_CHECKED (buf, sizeof buf, "%w", tm, NULL, ns);
ASSERT (n > 0);
printf ("%%w directive: %s\n", buf);
fflush (stdout);
ASSERT (STREQ (buf, "4"));
- n = FUNC_CHECKED (buf, sizeof buf, "%W", tm, 0, ns);
+ n = FUNC_CHECKED (buf, sizeof buf, "%W", tm, NULL, ns);
ASSERT (n > 0);
printf ("%%W directive: %s\n", buf);
fflush (stdout);
ASSERT (STREQ (buf, "43"));
- n = FUNC_CHECKED (buf, sizeof buf, "%x", tm, 0, ns);
+ n = FUNC_CHECKED (buf, sizeof buf, "%x", tm, NULL, ns);
ASSERT (n > 0);
printf ("%%x directive: %s\n", buf);
fflush (stdout);
break;
}
- n = FUNC_CHECKED (buf, sizeof buf, "%X", tm, 0, ns);
+ n = FUNC_CHECKED (buf, sizeof buf, "%X", tm, NULL, ns);
ASSERT (n > 0);
printf ("%%X directive: %s\n", buf);
fflush (stdout);
ASSERT (STREQ (buf, "06:40:03"));
- n = FUNC_CHECKED (buf, sizeof buf, "%y", tm, 0, ns);
+ n = FUNC_CHECKED (buf, sizeof buf, "%y", tm, NULL, ns);
ASSERT (n > 0);
printf ("%%y directive: %s\n", buf);
fflush (stdout);
ASSERT (STREQ (buf, "17"));
- n = FUNC_CHECKED (buf, sizeof buf, "%Y", tm, 0, ns);
+ n = FUNC_CHECKED (buf, sizeof buf, "%Y", tm, NULL, ns);
ASSERT (n > 0);
printf ("%%Y directive: %s\n", buf);
fflush (stdout);
ASSERT (STREQ (buf, "2017"));
- n = FUNC_CHECKED (buf, sizeof buf, "%z", tm, 0, ns);
+ n = FUNC_CHECKED (buf, sizeof buf, "%z", tm, NULL, ns);
ASSERT (n > 0);
printf ("%%z directive: %s\n", buf);
fflush (stdout);
ASSERT (STREQ (buf, "+0000"));
- n = FUNC_CHECKED (buf, sizeof buf, "%Z", tm, 0, ns);
+ n = FUNC_CHECKED (buf, sizeof buf, "%Z", tm, NULL, ns);
ASSERT (n > 0);
printf ("%%Z directive: %s\n", buf);
fflush (stdout);
ASSERT (STREQ (buf, "GMT") /* glibc, NetBSD, OpenBSD, AIX, Solaris, Cygwin, Android */
|| STREQ (buf, "UTC") /* musl, macOS, FreeBSD */);
- n = FUNC_CHECKED (buf, sizeof buf, "%%", tm, 0, ns);
+ n = FUNC_CHECKED (buf, sizeof buf, "%%", tm, NULL, ns);
ASSERT (n > 0);
printf ("%%%% directive: %s\n", buf);
fflush (stdout);
/* Exercise various GNU extensions from glibc. */
- n = FUNC_CHECKED (buf, sizeof buf, "%k", tm, 0, ns);
+ n = FUNC_CHECKED (buf, sizeof buf, "%k", tm, NULL, ns);
ASSERT (n > 0);
printf ("%%k directive: %s\n", buf);
fflush (stdout);
ASSERT (STREQ (buf, " 6"));
- n = FUNC_CHECKED (buf, sizeof buf, "%l", tm, 0, ns);
+ n = FUNC_CHECKED (buf, sizeof buf, "%l", tm, NULL, ns);
ASSERT (n > 0);
printf ("%%l directive: %s\n", buf);
fflush (stdout);
ASSERT (STREQ (buf, " 6"));
- n = FUNC_CHECKED (buf, sizeof buf, "%P", tm, 0, ns);
+ n = FUNC_CHECKED (buf, sizeof buf, "%P", tm, NULL, ns);
switch (language)
{
case english:
break;
}
- n = FUNC_CHECKED (buf, sizeof buf, "%s", tm, 0, ns);
+ n = FUNC_CHECKED (buf, sizeof buf, "%s", tm, NULL, ns);
ASSERT (n > 0);
printf ("%%s directive: %s\n", buf);
fflush (stdout);
/* Exercise various GNU extensions from gnulib. */
- n = FUNC_CHECKED (buf, sizeof buf, "%N", tm, 0, ns);
+ n = FUNC_CHECKED (buf, sizeof buf, "%N", tm, NULL, ns);
ASSERT (n > 0);
printf ("%%N directive: %s\n", buf);
fflush (stdout);
p = "2011-05-01T11:55:18";
expected.tv_sec = ref_time - gmtoff;
expected.tv_nsec = 0;
- ASSERT (parse_datetime (&result, p, 0));
+ ASSERT (parse_datetime (&result, p, NULL));
LOG (p, expected, result);
ASSERT (expected.tv_sec == result.tv_sec
&& expected.tv_nsec == result.tv_nsec);
p = "2011-05-01 11:55:18";
expected.tv_sec = ref_time - gmtoff;
expected.tv_nsec = 0;
- ASSERT (parse_datetime (&result, p, 0));
+ ASSERT (parse_datetime (&result, p, NULL));
LOG (p, expected, result);
ASSERT (expected.tv_sec == result.tv_sec
&& expected.tv_nsec == result.tv_nsec);
p = "2011-05-01 11:55:18J";
expected.tv_sec = ref_time - gmtoff;
expected.tv_nsec = 0;
- ASSERT (parse_datetime (&result, p, 0));
+ ASSERT (parse_datetime (&result, p, NULL));
LOG (p, expected, result);
ASSERT (expected.tv_sec == result.tv_sec
&& expected.tv_nsec == result.tv_nsec);
p = "2011-05-01T11:55:18Z";
expected.tv_sec = ref_time;
expected.tv_nsec = 0;
- ASSERT (parse_datetime (&result, p, 0));
+ ASSERT (parse_datetime (&result, p, NULL));
LOG (p, expected, result);
ASSERT (expected.tv_sec == result.tv_sec
&& expected.tv_nsec == result.tv_nsec);
p = "2011-05-01 11:55:18Z";
expected.tv_sec = ref_time;
expected.tv_nsec = 0;
- ASSERT (parse_datetime (&result, p, 0));
+ ASSERT (parse_datetime (&result, p, NULL));
LOG (p, expected, result);
ASSERT (expected.tv_sec == result.tv_sec
&& expected.tv_nsec == result.tv_nsec);
p = "2011-05-01T11:55:18-07:00";
expected.tv_sec = 1304276118;
expected.tv_nsec = 0;
- ASSERT (parse_datetime (&result, p, 0));
+ ASSERT (parse_datetime (&result, p, NULL));
LOG (p, expected, result);
ASSERT (expected.tv_sec == result.tv_sec
&& expected.tv_nsec == result.tv_nsec);
p = "2011-05-01 11:55:18-07:00";
expected.tv_sec = 1304276118;
expected.tv_nsec = 0;
- ASSERT (parse_datetime (&result, p, 0));
+ ASSERT (parse_datetime (&result, p, NULL));
LOG (p, expected, result);
ASSERT (expected.tv_sec == result.tv_sec
&& expected.tv_nsec == result.tv_nsec);
p = "2011-05-01T11:55:18-07";
expected.tv_sec = 1304276118;
expected.tv_nsec = 0;
- ASSERT (parse_datetime (&result, p, 0));
+ ASSERT (parse_datetime (&result, p, NULL));
LOG (p, expected, result);
ASSERT (expected.tv_sec == result.tv_sec
&& expected.tv_nsec == result.tv_nsec);
p = "2011-05-01 11:55:18-07";
expected.tv_sec = 1304276118;
expected.tv_nsec = 0;
- ASSERT (parse_datetime (&result, p, 0));
+ ASSERT (parse_datetime (&result, p, NULL));
LOG (p, expected, result);
ASSERT (expected.tv_sec == result.tv_sec
&& expected.tv_nsec == result.tv_nsec);
{
memset (®s, 0, sizeof regs);
i = re_search (®ex, data, sizeof data - 1,
- 0, sizeof data - 1, 0);
+ 0, sizeof data - 1, NULL);
if (i != 0 && i != 21)
report_error ("re_search '%s' on '%s' returned %d",
pat, data, i);
memset (®ex, 0, sizeof regex);
static char const pat_b_a[] = "a[b-a]";
s = re_compile_pattern (pat_b_a, sizeof pat_b_a - 1, ®ex);
- if (s == 0)
+ if (s == NULL)
{
report_error ("re_compile_pattern: failed to reject '%s'", pat_b_a);
regfree (®ex);