Remove dependency on libsimple since it's not portable

Signed-off-by: Mattias Andrée <m@maandree.se>

9 files changed, 611 insertions, 13 deletions

diff --git a/src/Makefile b/src/Makefile
index 693638c..fabc63e 100644
--- a/src/Makefile
+++ b/src/Makefile
@@ -33,7 +33,7 @@ CPPFLAGS_STRINGS =\
 
 
 all: redshift
-$(OBJ): common.h
+$(OBJ): common.h arg.h
 
 .c.o:
 	$(CC) -c -o $@ $< $(CFLAGS) $(CPPFLAGS) $(CPPFLAGS_STRINGS)
diff --git a/src/arg.h b/src/arg.h
new file mode 100644
index 0000000..6aaffce
--- /dev/null
+++ b/src/arg.h
@@ -0,0 +1,379 @@
+/*-
+ * This file is taken, with some parts remove, from libsimple
+ * 
+ * ISC License
+ * 
+ * © 2017, 2018, 2021, 2022, 2023, 2024, 2025 Mattias Andrée <m@maandree.se>
+ * 
+ * Permission to use, copy, modify, and/or distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ * 
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+
+/**
+ * The zeroth command line argument, the name of the process,
+ * set by the command line parsing macros
+ */
+extern char *argv0;
+
+
+/**
+ * Map from a long option to a short option
+ * 
+ * NB! Long options with optional arguments should
+ * have to map entries, one where `.long_flag` ends
+ * with '=' and `.with_arg` is non-zero, and one
+ * where `.long_flag` does not end with '=' and
+ * `.with_arg` is zero. These *cannot* have the same
+ * `.short_flag`
+ */
+struct longopt {
+	/**
+	 * The long option, if the value must be attached
+	 * to the flag, this must end with '='
+	 */
+	const char *long_flag;
+
+	/**
+	 * The equivalent short option
+	 * 
+	 * The first symbol in the short option
+	 * (normally '-') will be `.long_flag[0]`
+	 */
+	char short_flag;
+
+#if defined(__clang__)
+# pragma clang diagnostic push
+# pragma clang diagnostic ignored "-Wpadded"
+#endif
+
+	/**
+	 * Whether the option takes an argument
+	 */
+	int with_arg;
+
+#if defined(__clang__)
+# pragma clang diagnostic pop
+#endif
+};
+
+
+/**
+ * `ARGBEGIN {} ARGEND;` creates a switch statement
+ * instead a loop that parses the command line arguments
+ * according to the POSIX specification for default
+ * behaviour (extensions of the behaviour is possible)
+ * 
+ * This macro requires that the variables `argc` and
+ * `argv` are defined and that `argv[argc]` is `NULL`,
+ * `argc` shall be a non-negative `int` that tells
+ * how many elements (all non-`NULL`) are available in
+ * `argv`, the list of command line arguments
+ * 
+ * When parsing stops, `argc` and `argv` are updated
+ * shuch that all parsed arguments are removed; the
+ * contents of `argv` will not be modified, rather
+ * the pointer `argv` will be updated to `&argv[n]`
+ * where `n` is the number of parsed elements in `argv`
+ * 
+ * Inside `{}` in `ARGBEGIN {} ARGEND;` there user
+ * shall specify `case` statements for each recognised
+ * command line option, and `default` for unrecognised
+ * option. For example:
+ * 
+ *         ARGBEGIN {
+ *         case 'a':
+ *                 // handle -a
+ *                 break;
+ *         case 'b':
+ *                 // handle -b
+ *                 break;
+ *         case ARGNUM:
+ *                 // handle -0, -1, -2, ..., -9
+ *                 break;
+ *         default:
+ *                 // print usage information for other flags
+ *                 usage();
+ *         } ARGEND;
+ */
+#define ARGBEGIN ARGBEGIN2(1, 0)
+
+/**
+ * `SUBARGBEGIN {} ARGEND;` is similar to
+ * `ARGBEGIN {} ARGEND;`, however, `argv0`
+ * is not set to `argv[0]`, instead `argv[0]`
+ * is handled like any other element in `argv`
+ */
+#define SUBARGBEGIN ARGBEGIN2(0, 0)
+
+/**
+ * Flexible alternative to `ARGBEGIN`
+ * 
+ * @param  WITH_ARGV0     If 0, behave like `SUBARGBEGIN`,
+ *                        otherwise, behave like `ARGBEGIN`
+ * @param  KEEP_DASHDASH  If and only if 0, "--" is not removed
+ *                        `argv` before parsing is stopped when it
+ *                        is encountered
+ */
+#define ARGBEGIN2(WITH_ARGV0, KEEP_DASHDASH)\
+	do {\
+		char flag_, *lflag_, *arg_;\
+		int brk_ = 0, again_;\
+		size_t i_, n_;\
+		if (WITH_ARGV0) {\
+			argv0 = *argv;\
+			argv += !!argv0;\
+			argc -= !!argv0;\
+		}\
+		(void) arg_;\
+		(void) i_;\
+		(void) n_;\
+		for (; argv[0] && argv[0][0] && argv[0][1]; argc--, argv++) {\
+			lflag_ = argv[0];\
+			if (argv[0][0] == '-') {\
+				if (argv[0][1] == '-' && !argv[0][2]) {\
+					if (!(KEEP_DASHDASH))\
+						argv++, argc--;\
+					break;\
+				}\
+				for (argv[0]++; argv[0][0]; argv[0]++) {\
+					flag_ = argv[0][0];\
+					if (flag_ == '-' && &argv[0][-1] != lflag_)\
+						usage();\
+					arg_ = argv[0][1] ? &argv[0][1] : argv[1];\
+					do {\
+						again_ = 0;\
+						switch (flag_) {
+
+/**
+ * Test multiple long options and go to
+ * corresponding short option case
+ * 
+ * If the long option is found (see documentation
+ * for `struct longopt` for details), the keyword
+ * `break` is used to break the `case` (or `default`),
+ * and at the next iteration of the parsing loop, the
+ * case will be `.short_flag` for the entry where the
+ * argument matched `.long_flag` and `.with_arg`
+ * 
+ * @param  LONGOPTS:struct longopt *  The options, list shall end
+ *                                    with `NULL` as `.long_flag`
+ */
+#define ARGMAPLONG(LONGOPTS)\
+						for (i_ = 0; (LONGOPTS)[i_].long_flag; i_++) {\
+							if (TESTLONG((LONGOPTS)[i_].long_flag, (LONGOPTS)[i_].with_arg)) {\
+								flag_ = (LONGOPTS)[i_].short_flag;\
+								again_ = 1;\
+								break;\
+							}\
+						}\
+						if (again_)\
+							break
+
+/**
+ * Allows flags to start with another symbol than '-'
+ * 
+ * Usage example:
+ *         ARGBEGIN {
+ *         case 'a': // handle -a
+ *                 break;
+ *         default:
+ *                 usage();
+ *         } ARGALT('+') {
+ *         case 'a': // handle +a
+ *                 break;
+ *         default:
+ *                 usage();
+ *         } ARGALT('/') {
+ *         case 'a': // handle /a
+ *                 break;
+ *         default:
+ *                 usage();
+ *         } ARGEND;
+ * 
+ * @param  SYMBOL:char  The symbol flags should begin with
+ */
+#define ARGALT(SYMBOL)\
+						}\
+					} while (again_);\
+					if (brk_) {\
+						argc -= arg_ == argv[1];\
+						argv += arg_ == argv[1];\
+						brk_ = 0;\
+						break;\
+					}\
+				}\
+			} else if (argv[0][0] == SYMBOL) {\
+				if (argv[0][1] == SYMBOL && !argv[0][2])\
+					break;\
+				for (argv[0]++; argv[0][0]; argv[0]++) {\
+					flag_ = argv[0][0];\
+					if (flag_ == SYMBOL && &argv[0][-1] != lflag_)\
+						usage();\
+					arg_ = argv[0][1] ? &argv[0][1] : argv[1];\
+					do {\
+						again_ = 0;\
+						switch (flag_) {
+
+/**
+ * Refer to `ARGBEGIN`, `SUBARGBEGIN`, and `ARGBEGIN2`
+ */
+#define ARGEND\
+						}\
+					} while (again_);\
+					if (brk_) {\
+						argc -= arg_ == argv[1];\
+						argv += arg_ == argv[1];\
+						brk_ = 0;\
+						break;\
+					}\
+				}\
+			} else {\
+				break;\
+			}\
+		}\
+	} while (0)
+
+
+/**
+ * `case ARGNUM` creates a switch statement case for each digit
+ */
+#define ARGNUM      '0': case '1': case '2': case '3': case '4':\
+               case '5': case '6': case '7': case '8': case '9'
+
+/**
+ * Get the flag character, for example in `case 'a'`,
+ * 'a' is returned
+ * 
+ * @return  :char  The option's identifying character
+ */
+#define FLAG() (flag_)
+
+/**
+ * Get the entire argument that is being parsed
+ * 
+ * Note that an argument can contain multiple options
+ * and it can contain the last options value but the
+ * value can also be in the next argument
+ * 
+ * @return  :char *  The current command line argument
+ */
+#define LFLAG() (lflag_)
+
+/**
+ * Get the current option's value, if it
+ * does not have a value, call `usage`
+ * (which terminates the process)
+ * 
+ * Using this macro lets the parser knows
+ * that the option has a value
+ * 
+ * @return  :char *  The option's value, never `NULL`
+ */
+#define ARG() (arg_ ? (brk_ = 1, arg_) : (usage(), NULL))
+
+/**
+ * Get the current option's value, if the option
+ * does not have a value, `NULL` is returned
+ * 
+ * Note that the value may appear at the next
+ * argument (next element in `argv`) which in that
+ * case is returned
+ * 
+ * Using this macro lets the parser knows
+ * that the option has a value
+ * 
+ * @return  :char *  The option's value, `NULL` if
+ *                   the option does not have a value
+ */
+#define ARGNULL() (arg_ ? (brk_ = 1, arg_) : NULL)
+
+/**
+ * Get the remaining part of the current command
+ * line argument (element in `argv`) — as well as
+ * the character that specifies the flag — as the
+ * value of the argument
+ * 
+ * Using this macro lets the parser knows
+ * that the option has a value
+ * 
+ * Usage example:
+ * 
+ *     char *arg;
+ *     ARGBEGIN {
+ *     case ARGNUM:
+ *         arg = ARGHERE();
+ *         // `arg` is the number after '-', for example,
+ *         // if the command line contains the argument
+ *         // "-12345", `arg` will be `12345`
+ *         break;
+ *     case 'n':
+ *         arg = &ARGHERE()[1];
+ *         if (*arg) {
+ *             // flag 'n' has a value (`argv`)
+ *         } else {
+ *             // flag 'n' does not have a value
+ *         }
+ *     default:
+ *         usage();
+ *     } ARGEND;
+ * 
+ * @return  :char *  The option's value include the flag
+ *                   character, never `NULL` or ""
+ */
+#define ARGHERE() (brk_ = 1, argv[0])
+
+
+/**
+ * Test if the argument is a specific long option
+ * 
+ * Example:
+ *
+ *     ARGBEGIN {
+ *     case 'x':
+ *     handle_dash_x:
+ *         // handle -x
+ *         break;
+ *     case '-':
+ *         if (TESTLONG("--xdev", 0))
+ *             goto handle_dash_x;
+ *         else
+ *             usage();
+ *         break;
+ *     default:
+ *         usage();
+ *     } ARGEND;
+ * 
+ * @param  FLAG:const char *  The flag, must end with '=' if the
+ *                            value must be attached to the flag,
+ *                            must not have side-effects
+ * @param  WARG:int           Whether the option takes an argument,
+ *                            should not have side-effects
+ */
+#define TESTLONG(FLG, WARG)\
+	((WARG)\
+	 ? ((!strncmp(lflag_, (FLG), (n_ = strlen(FLG), n_ -= ((FLG)[n_ - !!n_] == '='))) && lflag_[n_] == '=')\
+	    ? (lflag_[n_] = '\0',\
+	       (arg_ = &lflag_[n_ + 1]),\
+	       (brk_ = 1))\
+	    : (!strcmp(lflag_, (FLG))\
+	       ? (argv[1]\
+	          ? ((arg_ = argv[1]),\
+	             (brk_ = 1))\
+	          : (usage(), 0))\
+	       : 0))\
+	 : (!strcmp(lflag_, (FLG))\
+	    ? (brk_ = 1)\
+	    : 0))
diff --git a/src/common.h b/src/common.h
index 9234e43..aa9af94 100644
--- a/src/common.h
+++ b/src/common.h
@@ -20,8 +20,6 @@
 #ifndef REDSHIFT_COMMON_H
 #define REDSHIFT_COMMON_H
 
-#include <libsimple.h>
-#include <libsimple-arg.h>
 
 #ifndef WINDOWS
 # if defined(__WIN32__) || defined(_WIN32)
@@ -29,6 +27,9 @@
 # endif
 #endif
 
+
+#include "arg.h"
+
 #include <sys/stat.h>
 #include <sys/types.h>
 #include <ctype.h>
@@ -40,6 +41,7 @@
 #include <locale.h>
 #include <math.h>
 #include <signal.h>
+#include <stdarg.h>
 #include <stdint.h>
 #include <stdio.h>
 #include <stdlib.h>
@@ -54,6 +56,7 @@
 # define localtime_r(T, TM) localtime_s((TM), (T))
 # define pause()  millisleep(100U)
 #else
+# include <sys/file.h>
 # include <poll.h>
 # include <pwd.h>
 # include <time.h>
@@ -140,6 +143,33 @@
  */
 #define FNAN ((double)NAN) /* because clang warns when implicitly promoted to double */
 
+/**
+ * Get the number of elements in an array
+ * 
+ * @param   ARR      The array, must not be a pointer
+ * @return  :size_t  The number of elements in `ARR` (constant
+ *                   expression, unless its size is dynamic)
+ */
+#define ELEMSOF(ARR) (sizeof(ARR) / (sizeof(*(ARR))))
+
+/**
+ * Get the smallest of two numerical values
+ * 
+ * @param   A  One of the values
+ * @param   B  The other value
+ * @return     The smallest of `A` and `B`
+ */
+#define MIN(A, B) ((A) < (B) ? (A) : (B))
+
+/**
+ * Get the largest of two numerical values
+ * 
+ * @param   A  One of the values
+ * @param   B  The other value
+ * @return     The largest of `A` and `B`
+ */
+#define MAX(A, B) ((A) > (B) ? (A) : (B))
+
 
 /**
  * Symbol used to delimit paths in environment
@@ -1132,13 +1162,88 @@ DIR *try_path_opendir(const struct env_path *path_spec, const char **path_out, c
  * Create a pipe(7) where both ends have `O_CLOEXEC`,
  * the read-end will also have `O_NONBLOCK` applied
  * 
- * @param   pipefds  Output parameter for the pipe's file descriptors:
- *                   0) reading file descriptor, and
- *                   1) writing file descriptor
+ * @param  pipefds  Output parameter for the pipe's file descriptors:
+ *                  0) reading file descriptor, and
+ *                  1) writing file descriptor
  */
 void pipe_rdnonblock(int pipefds[2]);
 #endif
 
+/**
+ * Wrapper for calloc(3) that prints and error message
+ * and terminates the process on failure
+ * 
+ * @param   n  Number of elements to allocate memory for
+ * @param   m  The size, in bytes, of each element
+ * @return     Pointer to zero-initialised storage of at least `n*m` bytes, with default alignment
+ */
+GCC_ONLY(__attribute__((__warn_unused_result__, __malloc__, __alloc_size__(1, 2), __returns_nonnull__)))
+void *ecalloc(size_t n, size_t m);
+
+/**
+ * Wrapper for malloc(3) that prints and error message
+ * and terminates the process on failure
+ * 
+ * @param   n  Number of bytes to allocate
+ * @return     Pointer to uninitialised storage of at least `n` bytes, with default alignment
+ */
+GCC_ONLY(__attribute__((__warn_unused_result__, __malloc__, __alloc_size__(1), __returns_nonnull__)))
+void *emalloc(size_t n);
+
+/**
+ * Wrapper for realloc(3) that prints and error message
+ * and terminates the process on failure
+ * 
+ * @param   ptr  Pointer to reallocate
+ * @param   n    Despired allocation size in bytes
+ * @return       Replacement pointer for `ptr`, pointing to storage of at least `n` bytes,
+ *               any byte that could be copied from `ptr` is copied over, and additional
+ *               memory is uninitialised
+ */
+GCC_ONLY(__attribute__((__warn_unused_result__, __returns_nonnull__, __alloc_size__(2))))
+void *erealloc(void *ptr, size_t n);
+
+/**
+ * Wrapper for strdup(3) that prints and error message
+ * and terminates the process on failure
+ * 
+ * @param   s  String to copy
+ * @return     Copy of `s`
+ */
+GCC_ONLY(__attribute__((__warn_unused_result__, __returns_nonnull__, __malloc__, __assume_aligned__(1), __nonnull__)))
+char *estrdup(const char *s);
+
+/**
+ * Print a message, prefixed with the process name (followed by ": "),
+ * to standard error
+ * 
+ * @param  fmt   Message text format string, see fprintf(3)
+ * @param  args  Message text arguments
+ */
+GCC_ONLY(__attribute__((__nonnull__(1), __format__(__printf__, 1, 0))))
+void vweprintf(const char *fmt, va_list args);
+
+/**
+ * Print a message, prefixed with the process name (followed by ": "),
+ * to standard error
+ * 
+ * @param  fmt  Message text format string, see fprintf(3)
+ * @param  ...  Message text arguments
+ */
+GCC_ONLY(__attribute__((__nonnull__(1), __format__(__printf__, 1, 2))))
+void weprintf(const char *fmt, ...);
+
+/**
+ * Print a message, prefixed with the process name (followed by ": "),
+ * to standard error and terminate the process with exit value
+ * indicating error
+ * 
+ * @param  fmt  Message text format string, see fprintf(3)
+ * @param  ...  Message text arguments
+ */
+GCC_ONLY(__attribute__((__nonnull__(1), __format__(__printf__, 1, 2), __noreturn__)))
+void eprintf(const char *fmt, ...);
+
 
 extern const struct gamma_method dummy_gamma_method;
 #ifdef ENABLE_COOPGAMMA
diff --git a/src/config.c b/src/config.c
index 5762a9c..03d0e74 100644
--- a/src/config.c
+++ b/src/config.c
@@ -20,9 +20,17 @@
 #include "common.h"
 
 
-/* TODO missing translation */
-USAGE("[-b day:night] [-c file] [-g r:g:b] [-l latitude:longitude | -l provider[:options]]"
-      " [-m method[:options]] [-o | -O temperature | -t day:night | -x] [-pPrv] | -h | -V");
+/**
+ * Output usage synopsis and exit
+ */
+static void
+usage(void)
+{
+	fprintf(stderr, _("usage: %s %s"), argv0,
+	        _("[-b day:night] [-c file] [-g r:g:b] [-l latitude:longitude | -l provider[:options]]"
+                  " [-m method[:options]] [-o | -O temperature | -t day:night | -x] [-pPrv] | -h | -V"));
+	exit(1);
+}
 
 
 struct colour_setting day_settings;
diff --git a/src/config.mk b/src/config.mk
index f26a6a3..9c0e131 100644
--- a/src/config.mk
+++ b/src/config.mk
@@ -21,4 +21,4 @@ CPPFLAGS = -D_DEFAULT_SOURCE -D_BSD_SOURCE -D_XOPEN_SOURCE=700 -D_GNU_SOURCE\
            -DENABLE_DRM -DENABLE_GEOCLUE2 -DENABLE_RANDR -DENABLE_VIDMODE\
            -DENABLE_COOPGAMMA
 CFLAGS   = $$($(PKGCONFIG_CFLAGS)  $(LIBS_PKGCONFIG))
-LDFLAGS  = $$($(PKGCONFIG_LDFLAGS) $(LIBS_PKGCONFIG)) -lm -lcoopgamma -lred -lsimple
+LDFLAGS  = $$($(PKGCONFIG_LDFLAGS) $(LIBS_PKGCONFIG)) -lm -lcoopgamma -lred
diff --git a/src/gamma-drm.c b/src/gamma-drm.c
index 2de0261..2098e0d 100644
--- a/src/gamma-drm.c
+++ b/src/gamma-drm.c
@@ -64,7 +64,7 @@ static int
 drm_start(struct gamma_state *state)
 {
 	/* Acquire access to a graphics card. */
-	char pathname[STRLEN(DRM_DIR_NAME"") + STRLEN(DRM_DEV_NAME"") + 3U * sizeof(int) + 2U];
+	char pathname[sizeof(DRM_DIR_NAME"")-1U + sizeof(DRM_DEV_NAME"")-1U + 3U * sizeof(int) + 2U];
 	int crtc_count;
 	struct drm_crtc_state *crtcs;
 
diff --git a/src/hooks.c b/src/hooks.c
index e3abf44..5412582 100644
--- a/src/hooks.c
+++ b/src/hooks.c
@@ -165,8 +165,10 @@ run_hooks(const char *argv[])
 			break;
 
 		case 0:
-			if (dup2(STDOUT_FILENO, STDERR_FILENO) != STDERR_FILENO)
-				_eprintf("dup2 <stdout> <stderr>:");
+			if (dup2(STDOUT_FILENO, STDERR_FILENO) != STDERR_FILENO) {
+				weprintf("dup2 <stdout> <stderr>:");
+				_exit(1);
+			}
 			stpcpy(stpcpy(&dirpath[dirpathlen], "/"), f->d_name);
 			argv[0] = dirpath;
 			execv(dirpath, (const void *)argv);
diff --git a/src/redshift.c b/src/redshift.c
index 29f463c..4f2304c 100644
--- a/src/redshift.c
+++ b/src/redshift.c
@@ -38,6 +38,9 @@
 #define FADE_LENGTH  160U
 
 
+char *argv0;
+
+
 /**
  * The user's current geographical location
  */
diff --git a/src/util.c b/src/util.c
index 0c1adc9..595f236 100644
--- a/src/util.c
+++ b/src/util.c
@@ -224,3 +224,104 @@ apply_nonblock:
 		eprintf("fcntl <pipe> F_SETFL +O_NONBLOCK:");
 }
 #endif
+
+
+void *
+ecalloc(size_t n, size_t m)
+{
+	char *ret = calloc(n, m);
+	if (!ret)
+		eprintf("calloc:");
+	return ret;
+}
+
+
+void *
+emalloc(size_t n)
+{
+	char *ret = malloc(n);
+	if (!ret)
+		eprintf("malloc:");
+	return ret;
+}
+
+
+void *
+erealloc(void *ptr, size_t n)
+{
+	char *ret = realloc(ptr, n);
+	if (!ret)
+		eprintf("realloc:");
+	return ret;
+}
+
+
+char *
+estrdup(const char *s)
+{
+	char *ret = strdup(s);
+	if (!ret)
+		eprintf("strdup:");
+	return ret;
+}
+
+
+void
+vweprintf(const char *fmt, va_list args)
+{
+	int saved_errno;
+	const char *errstrprefix, *errstr;
+#if !defined(WINDOWS)
+	int locked;
+#endif
+
+	saved_errno = errno;
+	if (!*fmt) {
+		errstrprefix = "";
+		errstr = strerror(saved_errno);
+	} else if (strchr(fmt, '\0')[-1] == '\n') {
+		errstrprefix = "";
+		errstr = NULL;
+	} else if (strchr(fmt, '\0')[-1] == ':') {
+		errstrprefix = " ";
+		errstr = strerror(saved_errno);
+	} else {
+		errstrprefix = "";
+		errstr = "";
+	}
+#if !defined(WINDOWS)
+	locked = !flock(STDERR_FILENO, LOCK_EX);
+#endif
+
+	fprintf(stderr, "%s: ", argv0);
+	vfprintf(stderr, fmt, args);
+	if (errstr)
+		fprintf(stderr, "%s%s\n", errstrprefix, errstr);
+
+#if !defined(WINDOWS)
+	if (locked)
+		flock(STDERR_FILENO, LOCK_UN);
+#endif
+	errno = saved_errno;
+}
+
+
+void
+weprintf(const char *fmt, ...)
+{
+	va_list args;
+	va_start(args, fmt);
+	vweprintf(fmt, args);
+	va_end(args);
+}
+
+
+void
+eprintf(const char *fmt, ...)
+{
+	va_list args;
+	va_start(args, fmt);
+	vweprintf(fmt, args);
+	va_end(args);
+	exit(1);
+}